diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..64a3f65 --- /dev/null +++ b/.gitignore @@ -0,0 +1,172 @@ +### Python template +# example NB +examples/catboost_info/ +examples/.ipynb_checkpoints/ +examples/cb_model.json + +# example NB +boruta/catboost_info/ +boruta/.ipynb_checkpoints/ +boruta/cb_model.json/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Pycharm +.idea/ +.idea/* + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/dictionaries +.idea/**/shelf + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# CMake +cmake-build-debug/ +cmake-build-release/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests diff --git a/README.md b/README.md index abcb788..9ce452f 100644 --- a/README.md +++ b/README.md @@ -118,6 +118,17 @@ dividing the p-value threshold with the current iteration index. If this two step correction is not required, the two_step parameter has to be set to False, then (with perc=100) BorutaPy behaves exactly as the R version. + +## Differences with the original Boruta scheme ## + + - Allow using sample_weight, for applications like Poisson regression or + any requiring weights + - 3 different feature importances: native, SHAP (if installed) and permutation. + Native being the least consistent + (because of the imp. biased towards numerical and large cardinality categorical, + see [Beware Default Random Forest Importances](https://explained.ai/rf-importance/#5) + but the fastest of the 3. + ## Parameters ## __estimator__ : object @@ -175,36 +186,35 @@ __verbose__ : int, default=0 ## Examples ## -```python -import pandas as pd -from sklearn.ensemble import RandomForestClassifier -from boruta import BorutaPy - -# load X and y -# NOTE BorutaPy accepts numpy arrays only, hence the .values attribute -X = pd.read_csv('examples/test_X.csv', index_col=0).values -y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values -y = y.ravel() - -# define random forest classifier, with utilising all cores and -# sampling in proportion to y labels -rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5) - -# define Boruta feature selection method -feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1) - -# find all relevant features - 5 features should be selected -feat_selector.fit(X, y) - -# check selected features - first 5 features are selected -feat_selector.support_ - -# check ranking of features -feat_selector.ranking_ - -# call transform() on X to filter it down to selected features -X_filtered = feat_selector.transform(X) -``` + import pandas as pd + from sklearn.ensemble import RandomForestClassifier + from boruta import BorutaPy + + # load X and y + # NOTE BorutaPy accepts numpy arrays only, hence the .values attribute + X = pd.read_csv('examples/test_X.csv', index_col=0).values + y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values + y = y.ravel() + + # define random forest classifier, with utilising all cores and + # sampling in proportion to y labels + rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5) + + # define Boruta feature selection method + feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1) + + # find all relevant features - 5 features should be selected + feat_selector.fit(X, y) + + # check selected features - first 5 features are selected + feat_selector.support_ + + # check ranking of features + feat_selector.ranking_ + + # call transform() on X to filter it down to selected features + X_filtered = feat_selector.transform(X) + ## References ## diff --git a/boruta/__init__.py b/boruta/__init__.py index 29e7031..21c65a7 100644 --- a/boruta/__init__.py +++ b/boruta/__init__.py @@ -1 +1 @@ -from .boruta_py import BorutaPy +from .boruta_py import BorutaPy diff --git a/boruta/boruta_py.py b/boruta/boruta_py.py index 1c18fe5..91147fe 100644 --- a/boruta/boruta_py.py +++ b/boruta/boruta_py.py @@ -1,24 +1,102 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- """ -Author: Daniel Homola +This module provides a method to perform 'all relevant feature selection' -Original code and method by: Miron B Kursa, https://m2.icm.edu.pl/boruta/ -License: BSD 3 clause +Reference: +---------- +NILSSON, Roland, PEÑA, José M., BJÖRKEGREN, Johan, et al. +Consistent feature selection for pattern recognition in polynomial time. +Journal of Machine Learning Research, 2007, vol. 8, no Mar, p. 589-612. + +KURSA, Miron B., RUDNICKI, Witold R., et al. +Feature selection with the Boruta package. +J Stat Softw, 2010, vol. 36, no 11, p. 1-13. + + +The module structure is the following: +--------------------------------------- +- The ``BorutaPy`` class, the main class, with a scikit-learn like syntax. It performs all relevant FS + as described in the original paper but implements several additional features, as native handling + of categorical predictors, different feature importance (native, pimp and shap, + if the SHAP pkg is installed). It works with CatBoost scikit-learn models and you can pass + sample_weight. """ from __future__ import print_function, division +import time +from warnings import warn import numpy as np +import pandas as pd import scipy as sp from sklearn.utils import check_random_state, check_X_y -from sklearn.base import TransformerMixin, BaseEstimator -import warnings +from sklearn.base import TransformerMixin, BaseEstimator, is_regressor, is_classifier, clone +from sklearn.model_selection import train_test_split +from sklearn.inspection import permutation_importance + + +_DEFAULT_IMPORTANCE = 'shap' + +# Shap is nice to have +try: + import shap +except ImportError: + warn('SHAP not installed, install it if you want to use Shapley values as feature importance\n' + 'Reverting to permutation importance as default') + _DEFAULT_IMPORTANCE = 'pimp' + +# MPL is a must +try: + import matplotlib as mpl + import matplotlib.pyplot as plt + from matplotlib.lines import Line2D + + MATPLOTLIB_INSTALLED = True +except ImportError: + MATPLOTLIB_INSTALLED = False + +# Progress bar to notify Users is a best practice +try: + from tqdm import tqdm + + TQDM_INSTALLED = True +except ImportError: + TQDM_INSTALLED = False + +# !/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Author: Daniel Homola + +Original code and method by: Miron B Kursa, https://m2.icm.edu.pl/boruta/ + +License: BSD 3 clause +""" class BorutaPy(BaseEstimator, TransformerMixin): """ - Improved Python implementation of the Boruta R package. + This is a PR version of BorutaPy which itself is an + improved Python implementation of the Boruta R package. + For chronological dev, see https://github.com/scikit-learn-contrib/boruta_py/pull/77 + + This PR vs BorutaPy: + ------------------ + + To summarize, this PR solves/enhances: + - The categorical features (they are detected, encoded. The tree-based models are working + better with integer encoding rather than with OHE, which leads to deep and unstable trees). + If Catboost is used, then the cat.pred (if any) are set up + - Work with Catboost sklearn API + - Allow using sample_weight, for applications like Poisson regression or + any requiring weights + - 3 different feature importances: native, SHAP and permutation. + Native being the least consistent + (because of the imp. biased towards numerical and large cardinality categorical) + but the fastest of the 3. + - Visualization like in the R package + + BorutaPy vs Boruta R: + --------------------- The improvements of this implementation include: - Faster run times: @@ -43,32 +121,55 @@ class BorutaPy(BaseEstimator, TransformerMixin): crucial parameter. For more info, please read about the perc parameter. - Automatic tree number: Setting the n_estimator to 'auto' will calculate the number of trees - in each itartion based on the number of features under investigation. - This way more trees are used when the training data has many feautres + in each iteration based on the number of features under investigation. + This way more trees are used when the training data has many features and less when most of the features have been rejected. - Ranking of features: After fitting BorutaPy it provides the user with ranking of features. Confirmed ones are 1, Tentatives are 2, and the rejected are ranked - starting from 3, based on their feautre importance history through + starting from 3, based on their feature importance history through the iterations. + - Using either the native variable importance, scikit permutation importance, + SHAP importance. We highly recommend using pruned trees with a depth between 3-7. - For more, see the docs of these functions, and the examples below. - Original code and method by: Miron B Kursa, https://m2.icm.edu.pl/boruta/ - Boruta is an all relevant feature selection method, while most other are minimal optimal; this means it tries to find all features carrying information usable for prediction, rather than finding a possibly compact subset of features on which some classifier has a minimal error. - Why bother with all relevant feature selection? When you try to understand the phenomenon that made your data, you should care about all factors that contribute to it, not just the bluntest signs of it in context of your methodology (yes, minimal optimal set of features by definition depends on your classifier choice). + + Summary + ------- + - Loop over n_iter or until dec_reg == 0 + - add shadows + o find features that are tentative + o make sure that at least 5 columns are added + o shuffle shadows + o get feature importance + * fit the estimator + * extract feature importance (native, shap or permutation) + * return feature importance + o separate the importance of shadows and real + + - Calculate the maximum shadow importance and append to the previous run + - Assign hits using the imp_sha_max of this run + o find all the feat imp > imp_sha_max + o tag them as hits + o add +1 to the previous tag vector + - Perform a test + o select non rejected features yet + o get a binomial p-values (nbr of times the feat has been tagged as important + on the n_iter done so far) o reject or not according the (corrected) p-val + + Parameters ---------- @@ -94,7 +195,13 @@ class BorutaPy(BaseEstimator, TransformerMixin): alpha : float, default = 0.05 Level at which the corrected p-values will get rejected in both correction steps. - + importance : str, default = 'shap' + The kind of variable importance used to compare and discriminate original + vs shadow predictors. Note that the builtin tree importance (gini/impurity based + importance) is biased towards numerical and large cardinality predictors, even + if they are random. Shapley values and permutation imp. are robust w.r.t those predictors. + Possible values: 'shap' (Shapley values), + 'pimp' (permutation importance) and 'native' (Gini/impurity) two_step : Boolean, default = True If you want to use the original implementation of Boruta with Bonferroni correction only set this to False. @@ -120,10 +227,10 @@ class BorutaPy(BaseEstimator, TransformerMixin): confirm a tentative feature for `n_iter_no_change` iterations. Will speed up the process at a cost of a possibility of a worse result. - + n_iter_no_change : int, default = 20 Ignored if `early_stopping` is False. The maximum amount of - iterations without confirming a tentative feature. + iterations without confirming a tentative feature. Attributes ---------- @@ -132,54 +239,48 @@ class BorutaPy(BaseEstimator, TransformerMixin): The number of selected features. support_ : array of shape [n_features] - The mask of selected features - only confirmed ones are True. support_weak_ : array of shape [n_features] - The mask of selected tentative features, which haven't gained enough support during the max_iter number of iterations.. ranking_ : array of shape [n_features] - The feature ranking, such that ``ranking_[i]`` corresponds to the ranking position of the i-th feature. Selected (i.e., estimated best) features are assigned rank 1 and tentative features are assigned rank 2. - importance_history_ : array-like, shape [n_features, n_iters] - - The calculated importance values for each feature across all iterations. - Examples -------- - + import pandas as pd - from sklearn.ensemble import RandomForestClassifier + from lightgbm import LGBMClassifier from boruta import BorutaPy - + # load X and y # NOTE BorutaPy accepts numpy arrays only, hence the .values attribute X = pd.read_csv('examples/test_X.csv', index_col=0).values y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values y = y.ravel() - - # define random forest classifier, with utilising all cores and + + # define lightGBM classifier, with utilising all cores and # sampling in proportion to y labels - rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5) - + lgbc = LGBMClassifier(max_depth=5) + + # define Boruta feature selection method - feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1) - + feat_selector = BorutaPy(lgbc, n_estimators='auto', verbose=2, random_state=1) + # find all relevant features - 5 features should be selected feat_selector.fit(X, y) - + # check selected features - first 5 features are selected feat_selector.support_ - + # check ranking of features feat_selector.ranking_ - + # call transform() on X to filter it down to selected features X_filtered = feat_selector.transform(X) @@ -190,9 +291,18 @@ class BorutaPy(BaseEstimator, TransformerMixin): Journal of Statistical Software, Vol. 36, Issue 11, Sep 2010 """ - def __init__(self, estimator, n_estimators=1000, perc=100, alpha=0.05, - two_step=True, max_iter=100, random_state=None, verbose=0, - early_stopping=False, n_iter_no_change=20): + def __init__(self, + estimator, + n_estimators=1000, + perc=90, + alpha=0.05, + importance=_DEFAULT_IMPORTANCE, + two_step=True, + max_iter=100, + random_state=None, + verbose=0, + early_stopping=False, + n_iter_no_change=20): self.estimator = estimator self.n_estimators = n_estimators self.perc = perc @@ -201,25 +311,49 @@ def __init__(self, estimator, n_estimators=1000, perc=100, alpha=0.05, self.max_iter = max_iter self.random_state = random_state self.verbose = verbose + self.importance = importance + self.cat_name = None + self.cat_idx = None + # Catboost doesn't allow to change random seed after fitting + self.is_tree_based = check_if_tree_based(self.estimator) + self._is_lightgbm = 'lightgbm' in str(type(self.estimator)) + self.is_cat = 'catboost' in str(type(self.estimator)) + self.is_xgb = 'xgboost' in str(type(self.estimator)) + # plotting + self.imp_real_hist = None + self.sha_max = None + self.col_names = None + self.tag_df = None self.early_stopping = early_stopping self.n_iter_no_change = n_iter_no_change - self.__version__ = '0.3' - self._is_lightgbm = 'lightgbm' in str(type(self.estimator)) + self.__version__ = '0.4' - def fit(self, X, y): + # Hackish but avoid direct dependency to the SHAP package + if self.importance == 'shap' and (not self.is_tree_based): + raise TypeError("To compute SHAP feature importance, use a tree-based model") + + def fit(self, X, y, sample_weight=None): """ Fits the Boruta feature selection with the provided estimator. Parameters ---------- + X : array-like, shape = [n_samples, n_features] The training input samples. y : array-like, shape = [n_samples] The target values. + + sample_weight : array-like, shape = [n_samples], default=None + Individual weights for each sample """ + self.imp_real_hist = np.empty((0, X.shape[1]), float) + if not isinstance(X, pd.DataFrame): + X = pd.DataFrame(X) + self.col_names = X.columns.to_list() - return self._fit(X, y) + return self._fit(X, y, sample_weight=sample_weight) def transform(self, X, weak=False, return_df=False): """ @@ -227,18 +361,20 @@ def transform(self, X, weak=False, return_df=False): Parameters ---------- + X : array-like, shape = [n_samples, n_features] The training input samples. - weak: boolean, default = False + weak : boolean, default = False If set to true, the tentative features are also used to reduce X. - + return_df : boolean, default = False If ``X`` if a pandas dataframe and this parameter is set to True, the transformed data will also be a dataframe. Returns ------- + X : array-like, shape = [n_samples, n_features_] The input matrix X's columns are reduced to the features which were selected by Boruta. @@ -246,19 +382,23 @@ def transform(self, X, weak=False, return_df=False): return self._transform(X, weak, return_df) - def fit_transform(self, X, y, weak=False, return_df=False): + def fit_transform(self, X, y, sample_weight=None, weak=False, return_df=False): """ Fits Boruta, then reduces the input X to the selected features. Parameters ---------- + X : array-like, shape = [n_samples, n_features] The training input samples. y : array-like, shape = [n_samples] The target values. - weak: boolean, default = False + sample_weight : array-like, shape = [n_samples], default=None + Individual weights for each sample + + weak : boolean, default = False If set to true, the tentative features are also used to reduce X. return_df : boolean, default = False @@ -267,15 +407,121 @@ def fit_transform(self, X, y, weak=False, return_df=False): Returns ------- + X : array-like, shape = [n_samples, n_features_] The input matrix X's columns are reduced to the features which were selected by Boruta. + + Summary + ------- + + - Loop over n_iter or until dec_reg == 0 + - add shadows + o find features that are tentative + o make sure that at least 5 columns are added + o shuffle shadows + o get feature importance + * fit the estimator + * extract feature importance (native, shap or permutation) + * return feature importance + o separate the importance of shadows and real + + - Calculate the maximum shadow importance and append to the previous run + - Assign hits using the imp_sha_max of this run + o find all the feat imp > imp_sha_max + o tag them as hits + o add +1 to the previous tag vector + - Perform a test + o select non rejected features yet + o get a binomial p-values (nbr of times the feat has been tagged as + important on the n_iter done so far) o reject or not according the (corrected) p-val """ - self._fit(X, y) + self._fit(X, y, sample_weight=sample_weight) return self._transform(X, weak, return_df) - def _validate_pandas_input(self, arg): + def plot_importance(self, n_feat_per_inch=5): + """ + Boxplot of the variable importance, ordered by magnitude + The max shadow variable importance illustrated by the dashed line. + Requires to apply the fit method first. + + Parameters + ---------- + + n_feat_per_inch : float + the number of boxes per inch (vertical axis). Increace to make the chart smaller and denser, + decrease this number for better readability + + Returns + ------- + + fig : matplotlib.figure.Figure + the box plot of the Boruta feature importance and the statistical test results + (accepted, tentative, rejected) + + + """ + # plt.style.use('fivethirtyeight') + + if not MATPLOTLIB_INSTALLED: + raise ImportError('You must install matplotlib and restart your session to plot importance.') + + my_colors_list = ['#000000', '#7F3C8D', '#11A579', '#3969AC', + '#F2B701', '#E73F74', '#80BA5A', '#E68310', + '#008695', '#CF1C90', '#F97B72'] + bckgnd_color = "#f5f5f5" + params = {"axes.prop_cycle": plt.cycler(color=my_colors_list), + "axes.facecolor": bckgnd_color, "patch.edgecolor": bckgnd_color, + "figure.facecolor": bckgnd_color, + "axes.edgecolor": bckgnd_color, "savefig.edgecolor": bckgnd_color, + "savefig.facecolor": bckgnd_color, "grid.color": "#d2d2d2", + 'lines.linewidth': 1.5} # plt.cycler(color=my_colors_list) + mpl.rcParams.update(params) + + if self.imp_real_hist is None: + raise ValueError("Use the fit method first to compute the var.imp") + + color = {'boxes': 'gray', 'whiskers': 'gray', 'medians': '#000000', 'caps': 'gray'} + vimp_df = pd.DataFrame(self.imp_real_hist, columns=self.col_names) + vimp_df = vimp_df.reindex(vimp_df.mean().sort_values(ascending=True).index, axis=1) + bp = vimp_df.boxplot(color=color, + boxprops=dict(linestyle='-', linewidth=1.5), + flierprops=dict(linestyle='-', linewidth=1.5), + medianprops=dict(linestyle='-', linewidth=1.5, color='#000000'), + whiskerprops=dict(linestyle='-', linewidth=1.5), + capprops=dict(linestyle='-', linewidth=1.5), + showfliers=False, grid=True, rot=0, vert=False, patch_artist=True, + figsize=(16, vimp_df.shape[1] / n_feat_per_inch), fontsize=9 + ) + blue_color = "#2590fa" + yellow_color = "#f0be00" + n_strong = sum(self.support_) + n_weak = sum(self.support_weak_) + n_discarded = len(self.col_names) - n_weak - n_strong + box_face_col = [blue_color] * n_strong + [yellow_color] * n_weak + ['gray'] * n_discarded + for c in range(len(box_face_col)): + bp.findobj(mpl.patches.Patch)[len(self.support_) - c - 1].set_facecolor(box_face_col[c]) + bp.findobj(mpl.patches.Patch)[len(self.support_) - c - 1].set_color(box_face_col[c]) + + xrange = vimp_df.max(skipna=True).max(skipna=True) - vimp_df.min(skipna=True).min(skipna=True) + bp.set_xlim(left=vimp_df.min(skipna=True).min(skipna=True) - 0.10 * xrange) + + custom_lines = [Line2D([0], [0], color=blue_color, lw=5), + Line2D([0], [0], color=yellow_color, lw=5), + Line2D([0], [0], color="gray", lw=5), + Line2D([0], [0], linestyle='--', color="gray", lw=2)] + bp.legend(custom_lines, ['confirmed', 'tentative', 'rejected', 'sha. max'], loc="lower right") + plt.axvline(x=self.sha_max, linestyle='--', color='gray') + fig = bp.get_figure() + plt.title('Boruta importance and selected predictors') + # fig.set_size_inches((10, 1.5 * np.rint(max(vimp_df.shape) / 10))) + # plt.tight_layout() + # plt.show() + return fig + + @staticmethod + def _validate_pandas_input(arg): try: return arg.values except AttributeError: @@ -283,17 +529,76 @@ def _validate_pandas_input(self, arg): "input needs to be a numpy array or pandas data frame." ) - def _fit(self, X, y): + def _fit(self, X_raw, y, sample_weight=None): + """ + Private method. + Chaining: + - Loop over n_iter or until dec_reg == 0 + - add shadows + o find features that are tentative + o make sure that at least 5 columns are added + o shuffle shadows + o get feature importance + * fit the estimator + * extract feature importance (native, shap or permutation) + * return feature importance + o separate the importance of shadows and real + + - Calculate the maximum shadow importance and append to the previous run + - Assign hits using the imp_sha_max of this run + o find all the feat imp > imp_sha_max + o tag them as hits + o add +1 to the previous tag vector + - Perform a test + o select non rejected features yet + o get a binomial p-values (nbr of times the feat has been tagged as + important on the n_iter done so far) o reject or not according the (corrected) p-val + + Parameters + ---------- + + X_raw : array-like, shape = [n_samples, n_features] + The training input samples. + y : array-like, shape = [n_samples] + The target values. + sample_weight : array-like, shape = [n_samples], default=None + Individual weights for each sample + + Returns + ------- + + self : object + Nothing but attributes + """ + # self.is_cat = is_catboost(self.estimator) + + start_time = time.time() + # basic cat features encoding + # First, let's store "object" columns as categorical columns + # obj_feat = X_raw.dtypes.loc[X_raw.dtypes == 'object'].index.tolist() + obj_feat = list(set(list(X_raw.columns)) - set(list(X_raw.select_dtypes(include=[np.number])))) + X = X_raw + X = np.nan_to_num(X) + y = np.nan_to_num(y) + # w = w.fillna(0) + + self.cat_name = obj_feat + # self.cat_idx = cat_idx + # check input params self._check_params(X, y) if not isinstance(X, np.ndarray): - X = self._validate_pandas_input(X) + X = self._validate_pandas_input(X) if not isinstance(y, np.ndarray): y = self._validate_pandas_input(y) + if sample_weight is not None: + if not isinstance(sample_weight, np.ndarray): + sample_weight = self._validate_pandas_input(sample_weight) + self.random_state = check_random_state(self.random_state) - + early_stopping = False if self.early_stopping: if self.n_iter_no_change >= self.max_iter: @@ -305,7 +610,7 @@ def _fit(self, X, y): ) else: early_stopping = True - + # setup variables for Boruta n_sample, n_feat = X.shape _iter = 1 @@ -329,8 +634,12 @@ def _fit(self, X, y): self.estimator.set_params(n_estimators=self.n_estimators) # main feature selection loop + if TQDM_INSTALLED: + pbar = tqdm(total=self.max_iter, desc="Boruta iteration") while np.any(dec_reg == 0) and _iter < self.max_iter: # find optimal number of trees and depth + # be sure to use an non-fitted estimator + self.estimator = clone(self.estimator) if self.n_estimators == 'auto': # number of features that aren't rejected not_rejected = np.where(dec_reg >= 0)[0].shape[0] @@ -338,13 +647,15 @@ def _fit(self, X, y): self.estimator.set_params(n_estimators=n_tree) # make sure we start with a new tree in each iteration - if self._is_lightgbm: - self.estimator.set_params(random_state=self.random_state.randint(0, 10000)) - else: - self.estimator.set_params(random_state=self.random_state) + # Catboost doesn't allow to change random seed after fitting + if self.is_cat is False: + if self._is_lightgbm: + self.estimator.set_params(random_state=self.random_state.randint(0, 10000)) + else: + self.estimator.set_params(random_state=self.random_state) # add shadow attributes, shuffle them and train estimator, get imps - cur_imp = self._add_shadows_get_imps(X, y, dec_reg) + cur_imp = self._add_shadows_get_imps(X, y, sample_weight, dec_reg) # get the threshold of shadow importances we will use for rejection imp_sha_max = np.percentile(cur_imp[1], self.perc) @@ -361,11 +672,13 @@ def _fit(self, X, y): dec_reg = self._do_tests(dec_reg, hit_reg, _iter) # print out confirmed features - if self.verbose > 0 and _iter < self.max_iter: - self._print_results(dec_reg, _iter, 0) + # if self.verbose > 0 and _iter < self.max_iter: + # self._print_results(dec_reg, _iter, 0) if _iter < self.max_iter: _iter += 1 - + if TQDM_INSTALLED: + pbar.update(1) + # early stopping if early_stopping: if _last_dec_reg is not None and (_last_dec_reg == dec_reg).all(): @@ -381,6 +694,8 @@ def _fit(self, X, y): if _same_iters > self.n_iter_no_change: break + if TQDM_INSTALLED: + pbar.close() # we automatically apply R package's rough fix for tentative ones confirmed = np.where(dec_reg == 1)[0] tentative = np.where(dec_reg == 0)[0] @@ -397,6 +712,24 @@ def _fit(self, X, y): self.support_[confirmed] = 1 self.support_weak_ = np.zeros(n_feat, dtype=bool) self.support_weak_[tentative] = 1 + # for plotting + self.imp_real_hist = imp_history + self.sha_max = imp_sha_max + + if isinstance(X_raw, np.ndarray): + X_raw = pd.DataFrame(X_raw) + + if isinstance(X_raw, pd.DataFrame): + self.support_names_ = [X_raw.columns[i] for i, x in enumerate(self.support_) if x] + self.tag_df = pd.DataFrame({'predictor': list(X_raw.columns)}) + self.tag_df['Boruta'] = 1 + self.tag_df['Boruta'] = np.where(self.tag_df['predictor'].isin(list(self.support_names_)), 1, 0) + + if isinstance(X_raw, pd.DataFrame): + self.support_weak_names_ = [X_raw.columns[i] for i, x in enumerate(self.support_weak_) if x] + self.tag_df['Boruta_weak_incl'] = np.where(self.tag_df['predictor'].isin( + list(self.support_names_ + self.support_weak_names_) + ), 1, 0) # ranking, confirmed variables are rank 1 self.ranking_ = np.ones(n_feat, dtype=int) @@ -411,30 +744,55 @@ def _fit(self, X, y): # update rank for not_selected features if not_selected.shape[0] > 0: - # calculate ranks in each iteration, then median of ranks across feats - iter_ranks = self._nanrankdata(imp_history_rejected, axis=1) - rank_medians = np.nanmedian(iter_ranks, axis=0) - ranks = self._nanrankdata(rank_medians, axis=0) - - # set smallest rank to 3 if there are tentative feats - if tentative.shape[0] > 0: - ranks = ranks - np.min(ranks) + 3 - else: - # and 2 otherwise - ranks = ranks - np.min(ranks) + 2 - self.ranking_[not_selected] = ranks + # calculate ranks in each iteration, then median of ranks across feats + iter_ranks = self._nanrankdata(imp_history_rejected, axis=1) + rank_medians = np.nanmedian(iter_ranks, axis=0) + ranks = self._nanrankdata(rank_medians, axis=0) + + # set smallest rank to 3 if there are tentative feats + if tentative.shape[0] > 0: + ranks = ranks - np.min(ranks) + 3 + else: + # and 2 otherwise + ranks = ranks - np.min(ranks) + 2 + self.ranking_[not_selected] = ranks else: # all are selected, thus we set feature supports to True self.support_ = np.ones(n_feat, dtype=bool) - self.importance_history_ = imp_history - # notify user if self.verbose > 0: self._print_results(dec_reg, _iter, 1) + self.running_time = time.time() - start_time + hours, rem = divmod(self.running_time, 3600) + minutes, seconds = divmod(rem, 60) + print("All relevant predictors selected in {:0>2}:{:0>2}:{:05.2f}".format(int(hours), + int(minutes), + seconds)) return self def _transform(self, X, weak=False, return_df=False): + """ + Private method + + transform the predictor matrix by dropping the rejected and + (optional) the undecided predictors + + Parameters + ---------- + X : pd.DataFrame + predictor matrix + weak : bool + whether to drop or not the undecided predictors + return_df : bool + return a pandas dataframe or not + + Returns + ------- + + X : np.array or pd.DataFrame + the transformed predictors matrix + """ # sanity check try: self.ranking_ @@ -457,11 +815,11 @@ def _get_tree_num(self, n_feat): try: depth = self.estimator.get_params()['max_depth'] except KeyError: - warnings.warn( + warn( "The estimator does not have a max_depth property, as a result " " the number of trees to use cannot be estimated automatically." ) - if depth == None: + if depth is None: depth = 10 # how many times a feature should be considered on average f_repr = 100 @@ -470,24 +828,35 @@ def _get_tree_num(self, n_feat): n_estimators = int(multi * f_repr) return n_estimators - def _get_imp(self, X, y): - try: - self.estimator.fit(X, y) - except Exception as e: - raise ValueError('Please check your X and y variable. The provided ' - 'estimator cannot be fitted to your data.\n' + str(e)) - try: - imp = self.estimator.feature_importances_ - except Exception: - raise ValueError('Only methods with feature_importance_ attribute ' - 'are currently supported in BorutaPy.') - return imp - def _get_shuffle(self, seq): self.random_state.shuffle(seq) return seq - def _add_shadows_get_imps(self, X, y, dec_reg): + def _add_shadows_get_imps(self, X, y, sample_weight, dec_reg): + """ + Add a shuffled copy of the columns (shadows) and get the feature + importance of the augmented data set + + Parameters + ---------- + + X : pd.DataFrame of shape [n_samples, n_features] + predictor matrix + y : pd.series of shape [n_samples] + target + sample_weight : array-like, shape = [n_samples], default=None + Individual weights for each sample + dec_reg : array + holds the decision about each feature 1, 0, -1 (accepted, undecided, rejected) + + Returns + ------- + + imp_real : array + feature importance of the real predictors + imp_sha : array + feature importance of the shadow predictors + """ # find features that are tentative still x_cur_ind = np.where(dec_reg >= 0)[0] x_cur = np.copy(X[:, x_cur_ind]) @@ -495,12 +864,21 @@ def _add_shadows_get_imps(self, X, y, dec_reg): # deep copy the matrix for the shadow matrix x_sha = np.copy(x_cur) # make sure there's at least 5 columns in the shadow matrix for - while (x_sha.shape[1] < 5): + while x_sha.shape[1] < 5: x_sha = np.hstack((x_sha, x_sha)) # shuffle xSha x_sha = np.apply_along_axis(self._get_shuffle, 0, x_sha) # get importance of the merged matrix - imp = self._get_imp(np.hstack((x_cur, x_sha)), y) + if self.importance == 'shap': + imp = _get_shap_imp(self.estimator, + np.hstack((x_cur, x_sha)), + y, + sample_weight) + elif self.importance == 'pimp': + imp = _get_perm_imp(self.estimator, np.hstack((x_cur, x_sha)), y, sample_weight) + else: + imp = _get_imp(self.estimator, np.hstack((x_cur, x_sha)), y, sample_weight) + # separate importances of real and shadow features imp_sha = imp[x_cur_w:] imp_real = np.zeros(X.shape[1]) @@ -508,7 +886,30 @@ def _add_shadows_get_imps(self, X, y, dec_reg): imp_real[x_cur_ind] = imp[:x_cur_w] return imp_real, imp_sha - def _assign_hits(self, hit_reg, cur_imp, imp_sha_max): + @staticmethod + def _assign_hits(hit_reg, cur_imp, imp_sha_max): + """ + count how many times a given feature was more important than + the best of the shadow features + + Parameters + ---------- + + hit_reg : array + count how many times a given feature was more important than the + best of the shadow features + cur_imp : array + current importance + imp_sha_max : array + importance of the best shadow predictor + + Returns + ------- + + hit_reg : array + count how many times a given feature was more important than the + best of the shadow features + """ # register hits for features that did better than the best of shadows cur_imp_no_nan = cur_imp[0] cur_imp_no_nan[np.isnan(cur_imp_no_nan)] = 0 @@ -517,6 +918,28 @@ def _assign_hits(self, hit_reg, cur_imp, imp_sha_max): return hit_reg def _do_tests(self, dec_reg, hit_reg, _iter): + """ + Perform the rest if the feature should be tagged as relevant (confirmed), not relevant (rejected) + or undecided. The test is performed by considering the binomial tentatives over several attempts. + I.e. count how many times a given feature was more important than the best of the shadow features + and test if the associated probability to the z-score is below, between or above the rejection or + acceptance threshold. + + Parameters + ---------- + + dec_reg : array + holds the decision about each feature 1, 0, -1 (accepted, undecided, rejected) + hit_reg : array + counts how many times a given feature was more important than the best of the shadow features + _iter: int + + Returns + ------- + + dec_reg = np.array + the tag array + """ active_features = np.where(dec_reg >= 0)[0] hits = hit_reg[active_features] # get uncorrected p values based on hit_reg @@ -552,13 +975,15 @@ def _do_tests(self, dec_reg, hit_reg, _iter): dec_reg[active_features[to_reject]] = -1 return dec_reg - def _fdrcorrection(self, pvals, alpha=0.05): + @staticmethod + def _fdrcorrection(pvals, alpha=0.05): """ Benjamini/Hochberg p-value correction for false discovery rate, from statsmodels package. Included here for decoupling dependency on statsmodels. Parameters ---------- + pvals : array_like set of p-values of the individual tests. alpha : float @@ -566,6 +991,7 @@ def _fdrcorrection(self, pvals, alpha=0.05): Returns ------- + rejected : array, bool True if a hypothesis is rejected, False if not pvalue-corrected : array @@ -592,7 +1018,8 @@ def _fdrcorrection(self, pvals, alpha=0.05): reject_[pvals_sortind] = reject return reject_, pvals_corrected_ - def _nanrankdata(self, X, axis=1): + @staticmethod + def _nanrankdata(X, axis=1): """ Replaces bottleneck's nanrankdata with scipy and numpy alternative. """ @@ -602,10 +1029,19 @@ def _nanrankdata(self, X, axis=1): def _check_params(self, X, y): """ + Private method Check hyperparameters as well as X and y before proceeding with fit. + + Returns + ------- + + X : pd.DataFrame + predictor matrix + y : pd.series + target """ # check X and y are consistent len, X is Array and y is column - X, y = check_X_y(X, y) + X, y = check_X_y(X, y, dtype=None, force_all_finite=False) if self.perc <= 0 or self.perc > 100: raise ValueError('The percentile should be between 0 and 100.') @@ -613,6 +1049,27 @@ def _check_params(self, X, y): raise ValueError('Alpha should be between 0 and 1.') def _print_results(self, dec_reg, _iter, flag): + """ + Private method + printing the result + + Params + ------ + + dec_reg : np.array + if the feature as been tagged as relevant (confirmed), + not relevant (rejected) or undecided + _iter : int + the iteration number + flag : int + is still in the feature selection process or not + + Returns + ------- + + output : str + the output to be printed out + """ n_iter = str(_iter) + ' / ' + str(self.max_iter) n_confirmed = np.where(dec_reg == 1)[0].shape[0] n_rejected = np.where(dec_reg == -1)[0].shape[0] @@ -630,8 +1087,291 @@ def _print_results(self, dec_reg, _iter, flag): # Boruta finished running and tentatives have been filtered else: n_tentative = np.sum(self.support_weak_) - n_rejected = np.sum(~(self.support_|self.support_weak_)) + n_rejected = np.sum(~(self.support_ | self.support_weak_)) content = map(str, [n_iter, n_confirmed, n_tentative, n_rejected]) result = '\n'.join([x[0] + '\t' + x[1] for x in zip(cols, content)]) - output = "\n\nBorutaPy finished running.\n\n" + result + if self.importance in ['shap', 'pimp']: + vimp = str(self.importance) + else: + vimp = 'native' + output = "\n\nBoruta finished running using " + vimp + " var. imp.\n\n" + result print(output) + + +def _split_fit_estimator(estimator, X, y, sample_weight=None, cat_feature=None): + """ + Private function + split the train, test and fit the model + + Parameters + ---------- + + estimator: sklearn estimator + the scikit-learn estimator + X: pd.DataFrame of shape [n_samples, n_features] + predictor matrix + y: pd.series of shape [n_samples] + target + sample_weight: array-like, shape = [n_samples], default=None + Individual weights for each sample + cat_feature: list of int or None + the list of integers, cols loc, of the categrocial predictors. Avoids to detect and encode + each iteration if the exact same columns are passed to the selection methods. + + + Returns + ------- + + model: sklearn estimator + fitted model + X_tt: array [n_samples, n_features] + the test split, predictors + y_tt: array [n_samples] + the test split, target + """ + + if cat_feature is None: + # detect, store and encode categorical predictors + X = pd.DataFrame(X) + obj_feat = list(set(list(X.columns)) - set(list(X.select_dtypes(include=[np.number])))) + if obj_feat: + X[obj_feat] = X[obj_feat].astype('str').astype('category') + for col in obj_feat: + X[col] = X[col].astype('category').cat.codes + else: + obj_feat = None + else: + obj_feat = cat_feature + + if sample_weight is not None: + w = sample_weight + if is_regressor(estimator): + X_tr, X_tt, y_tr, y_tt, w_tr, w_tt = train_test_split(X, y, w, random_state=42) + else: + X_tr, X_tt, y_tr, y_tt, w_tr, w_tt = train_test_split(X, y, w, stratify=y, random_state=42) + else: + if is_regressor(estimator): + X_tr, X_tt, y_tr, y_tt = train_test_split(X, y, random_state=42) + else: + X_tr, X_tt, y_tr, y_tt = train_test_split(X, y, stratify=y, random_state=42) + w_tr, w_tt = None, None + + X_tr = pd.DataFrame(X_tr) + X_tt = pd.DataFrame(X_tt) + + if check_if_tree_based(estimator): + try: + # handle cat features if supported by the fit method + if is_catboost(estimator) or ('cat_feature' in estimator.fit.__code__.co_varnames): + model = estimator.fit(X_tr, y_tr, sample_weight=w_tr, cat_features=obj_feat, verbose=0) + else: + model = estimator.fit(X_tr, y_tr, sample_weight=w_tr, verbose=0) + + except Exception as e: + raise ValueError('Please check your X and y variable. The provided ' + 'estimator cannot be fitted to your data.\n' + str(e)) + else: + raise ValueError('Not a tree based model') + + return model, X_tt, y_tt, w_tt + + +def _get_shap_imp(estimator, X, y, sample_weight=None, cat_feature=None): + """ + Private function + Get the SHAP feature importance + + Parameters + ---------- + + estimator: sklearn estimator + the scikit-learn estimator + X: pd.DataFrame of shape [n_samples, n_features] + predictor matrix + y: pd.series of shape [n_samples] + target + sample_weight: array-like, shape = [n_samples], default=None + Individual weights for each sample + cat_feature: list of int or None + the list of integers, cols loc, of the categorical predictors. Avoids to detect and encode + each iteration if the exact same columns are passed to the selection methods. + + Returns + ------- + + shap_imp: array + the SHAP importance array + """ + + # be sure to use an non-fitted estimator + estimator = clone(estimator) + + model, X_tt, y_tt, w_tt = _split_fit_estimator(estimator, X, y, + sample_weight=sample_weight, + cat_feature=cat_feature) + + # Faster and safer to use the builtin lightGBM method + # Note the xgboost and catboost have builtin shap as well + # but it requires to use DMatrix or Pool respectively + # for other tree-based models, no builtin SHAP + if is_lightgbm(estimator): + shap_matrix = model.predict(X_tt, pred_contrib=True) + # the dim changed in lightGBM 3 + # X_SHAP_values array-like of shape = [n_samples, n_features + 1] or + # shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects + if is_classifier(estimator): + # remove every (n_features+1)th element, python indexes from zero + n_features = X_tt.shape[1] + shap_matrix = np.delete(shap_matrix, list(range(n_features, shap_matrix.shape[1], n_features+1)), axis=1) + shap_imp = np.mean(np.abs(shap_matrix), axis=0) + else: + shap_imp = np.mean(np.abs(shap_matrix[:, :-1]), axis=0) + + else: + # build the explainer + explainer = shap.TreeExplainer(model, feature_perturbation="tree_path_dependent") + shap_values = explainer.shap_values(X_tt) + # flatten to 2D if classification and lightgbm + if is_classifier(estimator): + if isinstance(shap_values, list): + # for lightgbm clf sklearn api, shap returns list of arrays + # https://github.com/slundberg/shap/issues/526 + class_inds = range(len(shap_values)) + shap_imp = np.zeros(shap_values[0].shape[1]) + for i, ind in enumerate(class_inds): + shap_imp += np.abs(shap_values[ind]).mean(0) + shap_imp /= len(shap_values) + else: + shap_imp = np.abs(shap_values).mean(0) + else: + shap_imp = np.abs(shap_values).mean(0) + + return shap_imp + + +def _get_perm_imp(estimator, X, y, sample_weight, cat_feature=None): + """ + Private function + Get the permutation feature importance + + Parameters + ---------- + + estimator: sklearn estimator + the scikit-learn estimator + X: pd.DataFrame of shape [n_samples, n_features] + predictor matrix + y: pd.series of shape [n_samples] + target + sample_weight: array-like, shape = [n_samples], default=None + Individual weights for each sample + cat_feature: list of int or None + the list of integers, cols loc, of the categorical predictors. Avoids to detect and encode + each iteration if the exact same columns are passed to the selection methods. + + Returns + ------- + + imp: array + the permutation importance array + """ + # be sure to use an non-fitted estimator + estimator = clone(estimator) + + model, X_tt, y_tt, w_tt = _split_fit_estimator(estimator, X, y, + sample_weight=sample_weight, + cat_feature=cat_feature) + perm_imp = permutation_importance(model, X_tt, y_tt, n_repeats=5, random_state=42, n_jobs=-1) + imp = perm_imp.importances_mean.ravel() + return imp + + +def _get_imp(estimator, X, y, sample_weight=None, cat_feature=None): + """ + Get the native feature importance (impurity based for instance) + This is know to return biased and uninformative results. + e.g. + https://scikit-learn.org/stable/auto_examples/inspection/ + plot_permutation_importance.html#sphx-glr-auto-examples-inspection-plot-permutation-importance-py + + or + https://explained.ai/rf-importance/ + + Parameters + ---------- + + X : array-like, shape = [n_samples, n_features] + The training input samples. + y : array-like, shape = [n_samples] + The target values. + sample_weight : array-like, shape = [n_samples], default=None + Individual weights for each sample + cat_feature: list of int or None + the list of integers, cols loc, of the categorical predictors. Avoids to detect and encode + each iteration if the exact same columns are passed to the selection methods. + + Returns + ------- + + imp: np.array + the importance array + """ + # be sure to use an non-fitted estimator + estimator = clone(estimator) + + try: + # handle categoricals + X = pd.DataFrame(X) + if cat_feature is None: + obj_feat = list(set(list(X.columns)) - set(list(X.select_dtypes(include=[np.number])))) + if obj_feat: + X[obj_feat] = X[obj_feat].astype('str').astype('category') + for col in obj_feat: + X[col] = X[col].cat.codes + else: + obj_feat = None + else: + obj_feat = cat_feature + + # handle catboost and cat features + if is_catboost(estimator) or ('cat_feature' in estimator.fit.__code__.co_varnames): + X = pd.DataFrame(X) + estimator.fit(X, y, sample_weight=sample_weight, cat_features=obj_feat, verbose=0) + else: + estimator.fit(X, y, sample_weight=sample_weight, verbose=0) + + except Exception as e: + raise ValueError('Please check your X and y variable. The provided ' + 'estimator cannot be fitted to your data.\n' + str(e)) + try: + imp = estimator.feature_importances_ + except Exception: + raise ValueError('Only methods with feature_importance_ attribute ' + 'are currently supported in BorutaPy.') + return imp + + +# for better looking conditions +def is_lightgbm(estimator): + """helper is lightGBM model (better looking condition in private func)""" + is_lgb = 'lightgbm' in str(type(estimator)) + return is_lgb + + +def is_catboost(estimator): + """helper is catboost model (better looking condition in private func)""" + is_cat = 'catboost' in str(type(estimator)) + return is_cat + + +def is_xgboost(estimator): + """helper is xgboost model (better looking condition in private func)""" + is_xgb = 'xgboost' in str(type(estimator)) + return is_xgb + + +def check_if_tree_based(model): + """helper is tree-based model (better looking condition in private func)""" + tree_based_models = ['lightgbm', 'xgboost', 'catboost', '_forest', 'boosting'] + condition = any(i in str(type(model)).lower() for i in tree_based_models) + return condition diff --git a/boruta/examples/.ipynb_checkpoints/Madalon_Data_Set-checkpoint.ipynb b/boruta/examples/.ipynb_checkpoints/Madalon_Data_Set-checkpoint.ipynb new file mode 100644 index 0000000..31b660b --- /dev/null +++ b/boruta/examples/.ipynb_checkpoints/Madalon_Data_Set-checkpoint.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using Boruta on the Madalon Data Set\n", + "Author: [Mike Bernico](mike.bernico@gmail.com)\n", + "\n", + "This example demonstrates using Boruta to find all relevant features in the Madalon dataset, which is an artificial dataset used in NIPS2003 and cited in the [Boruta paper](https://www.jstatsoft.org/article/view/v036i11/v36i11.pdf)\n", + "\n", + "This dataset has 2000 observations and 500 features. We will use Boruta to identify the features that are relevant to the classification task.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Installation\n", + "#!pip install boruta" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.datasets import load_iris\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from boruta import BorutaPy" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def load_data():\n", + " # URLS for dataset via UCI\n", + " train_data_url='https://archive.ics.uci.edu/ml/machine-learning-databases/madelon/MADELON/madelon_train.data'\n", + " train_label_url='https://archive.ics.uci.edu/ml/machine-learning-databases/madelon/MADELON/madelon_train.labels'\n", + "\n", + " X_data = pd.read_csv(train_data_url, sep=\" \", header=None)\n", + " y_data = pd.read_csv(train_label_url, sep=\" \", header=None)\n", + " data = X_data.loc[:, :499]\n", + " data['target'] = y_data[0]\n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "data = load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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", + " \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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123456789...491492493494495496497498499target
0485477537479452471491476475473...481477485511485481479475496-1
1483458460487587475526479485469...478487338513486483492510517-1
2487542499468448471442478480477...481492650506501480489499498-1
3480491510485495472417474502476...4804745724544694754824944611
4484502528489466481402478487468...4794524354865084815044955111
\n", + "

5 rows × 501 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 6 7 8 9 ... 491 492 493 494 \\\n", + "0 485 477 537 479 452 471 491 476 475 473 ... 481 477 485 511 \n", + "1 483 458 460 487 587 475 526 479 485 469 ... 478 487 338 513 \n", + "2 487 542 499 468 448 471 442 478 480 477 ... 481 492 650 506 \n", + "3 480 491 510 485 495 472 417 474 502 476 ... 480 474 572 454 \n", + "4 484 502 528 489 466 481 402 478 487 468 ... 479 452 435 486 \n", + "\n", + " 495 496 497 498 499 target \n", + "0 485 481 479 475 496 -1 \n", + "1 486 483 492 510 517 -1 \n", + "2 501 480 489 499 498 -1 \n", + "3 469 475 482 494 461 1 \n", + "4 508 481 504 495 511 1 \n", + "\n", + "[5 rows x 501 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "y = data.pop('target')\n", + "X = data.copy().values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Boruta conforms to the sklearn api and can be used in a Pipeline as well as on it's own. Here we will demonstrate stand alone operation.\n", + "\n", + "First we will instantiate an estimator that Boruta will use. Then we will instantiate a Boruta Object." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "rf = RandomForestClassifier(n_jobs=-1, class_weight=None, max_depth=7, random_state=0)\n", + "# Define Boruta feature selection method\n", + "feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once built, we can use this object to identify the relevant features in our dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 99%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 99/100 [01:02<00:00, 1.59it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using native var. imp.\n", + "\n", + "Iteration: \t100 / 100\n", + "Confirmed: \t30\n", + "Tentative: \t1\n", + "Rejected: \t455\n", + "All relevant predictors selected in 00:01:02.25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "BorutaPy(estimator=RandomForestClassifier(max_depth=7, n_estimators=135,\n", + " n_jobs=-1,\n", + " random_state=RandomState(MT19937) at 0x200D9BD7048),\n", + " n_estimators='auto',\n", + " random_state=RandomState(MT19937) at 0x200D9BD7048, verbose=2)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_selector.fit(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Boruta has confirmed only a few features as useful. When our run ended, Boruta was undecided on 2 features. '\n", + "\n", + "We can interrogate .support_ to understand which features were selected. .support_ returns an array of booleans that we can use to slice our feature matrix to include only relevant columns. Of course, .transform can also be used, as expected in the scikit API." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[False False False False True False False False False False True False\n", + " False False False False False False False False False False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False False False False\n", + " True False False False False False False False False False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False True False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False True False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False True False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " True False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False True False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False True True False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False True False False False False False\n", + " False False False False False False False False False False True False\n", + " True False True False False False False False False False False False\n", + " True True False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False True False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False True\n", + " False True False False False False False False False False True False\n", + " False False False False False False False True False True False True\n", + " False False False False False False False False False False False False\n", + " False False False False True False False True False False False False\n", + " False True False False False False False False False False False False\n", + " False True False False False False False False]\n", + "\n", + "Selected Feature Matrix Shape\n", + "(2000, 30)\n" + ] + } + ], + "source": [ + "# Check selected features\n", + "print(feat_selector.support_)\n", + "# Select the chosen features from our dataframe.\n", + "selected = X[:, feat_selector.support_]\n", + "print (\"\")\n", + "print (\"Selected Feature Matrix Shape\")\n", + "print (selected.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also interrogate the ranking of the unselected features with .ranking_" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([418, 351, 150, 362, 1, 271, 174, 464, 410, 358, 1, 222, 262,\n", + " 35, 302, 332, 287, 191, 141, 405, 339, 265, 428, 215, 300, 82,\n", + " 49, 411, 1, 234, 429, 67, 159, 42, 351, 110, 220, 294, 52,\n", + " 454, 443, 76, 114, 41, 20, 264, 67, 195, 1, 58, 180, 157,\n", + " 389, 415, 206, 5, 22, 206, 377, 176, 87, 313, 181, 444, 1,\n", + " 196, 249, 236, 183, 401, 342, 240, 204, 30, 159, 126, 324, 84,\n", + " 169, 112, 414, 40, 347, 419, 269, 66, 391, 253, 329, 57, 471,\n", + " 247, 360, 281, 139, 110, 439, 271, 141, 78, 214, 375, 413, 148,\n", + " 212, 1, 49, 389, 355, 167, 411, 151, 388, 321, 129, 307, 29,\n", + " 349, 285, 62, 450, 271, 152, 219, 331, 131, 305, 94, 1, 156,\n", + " 91, 73, 311, 437, 139, 133, 1, 5, 415, 107, 123, 299, 321,\n", + " 337, 297, 327, 307, 31, 365, 24, 242, 315, 133, 1, 461, 204,\n", + " 268, 244, 325, 309, 186, 78, 396, 405, 114, 98, 453, 429, 456,\n", + " 350, 234, 145, 153, 446, 363, 34, 360, 216, 250, 314, 27, 232,\n", + " 193, 281, 38, 372, 201, 224, 73, 448, 408, 225, 178, 88, 238,\n", + " 417, 338, 289, 462, 8, 209, 244, 96, 403, 1, 455, 42, 353,\n", + " 285, 199, 383, 12, 317, 329, 421, 123, 161, 139, 164, 400, 198,\n", + " 345, 165, 92, 64, 288, 31, 449, 468, 170, 354, 254, 241, 405,\n", + " 69, 61, 252, 431, 27, 369, 220, 1, 348, 21, 44, 36, 129,\n", + " 450, 290, 384, 149, 278, 447, 317, 436, 104, 178, 311, 409, 110,\n", + " 276, 425, 113, 86, 120, 279, 262, 103, 254, 217, 257, 302, 316,\n", + " 60, 398, 367, 468, 18, 5, 294, 459, 1, 1, 460, 173, 10,\n", + " 17, 174, 442, 239, 76, 163, 364, 433, 129, 83, 15, 231, 12,\n", + " 294, 166, 107, 393, 8, 229, 259, 80, 402, 365, 127, 47, 394,\n", + " 334, 105, 301, 230, 382, 369, 1, 118, 305, 19, 281, 15, 405,\n", + " 438, 69, 327, 339, 15, 226, 336, 462, 136, 1, 197, 1, 168,\n", + " 1, 260, 260, 244, 159, 2, 213, 423, 372, 27, 1, 1, 427,\n", + " 97, 194, 319, 125, 360, 154, 464, 51, 143, 291, 94, 136, 71,\n", + " 441, 116, 99, 99, 396, 341, 65, 192, 145, 355, 102, 200, 392,\n", + " 55, 1, 237, 419, 344, 52, 297, 46, 283, 132, 466, 209, 44,\n", + " 422, 89, 452, 379, 445, 187, 244, 202, 265, 426, 368, 276, 456,\n", + " 38, 470, 123, 37, 435, 185, 188, 3, 8, 75, 55, 90, 248,\n", + " 319, 10, 209, 94, 211, 381, 227, 467, 24, 59, 116, 171, 183,\n", + " 440, 33, 1, 72, 1, 121, 177, 189, 384, 325, 375, 274, 258,\n", + " 1, 155, 147, 432, 379, 387, 136, 250, 342, 1, 218, 1, 234,\n", + " 1, 292, 23, 54, 275, 171, 297, 203, 85, 333, 256, 273, 106,\n", + " 80, 323, 162, 395, 1, 458, 399, 1, 386, 372, 183, 434, 118,\n", + " 1, 379, 143, 346, 335, 223, 227, 357, 374, 48, 424, 305, 1,\n", + " 62, 190, 101, 310, 267, 284])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_selector.ranking_" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = feat_selector.plot_importance(n_feat_per_inch=5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "boruta", + "language": "python", + "name": "boruta" + }, + "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.7.9" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/boruta/examples/Madalon_Data_Set.ipynb b/boruta/examples/Madalon_Data_Set.ipynb index 435eba0..31b660b 100644 --- a/boruta/examples/Madalon_Data_Set.ipynb +++ b/boruta/examples/Madalon_Data_Set.ipynb @@ -18,9 +18,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# Installation\n", @@ -42,9 +40,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "def load_data():\n", @@ -77,6 +73,19 @@ "data": { "text/html": [ "
\n", + "\n", "\n", " \n", " \n", @@ -231,19 +240,19 @@ "" ], "text/plain": [ - " 0 1 2 3 4 5 6 7 8 9 ... 491 492 493 \\\n", - "0 485 477 537 479 452 471 491 476 475 473 ... 481 477 485 \n", - "1 483 458 460 487 587 475 526 479 485 469 ... 478 487 338 \n", - "2 487 542 499 468 448 471 442 478 480 477 ... 481 492 650 \n", - "3 480 491 510 485 495 472 417 474 502 476 ... 480 474 572 \n", - "4 484 502 528 489 466 481 402 478 487 468 ... 479 452 435 \n", + " 0 1 2 3 4 5 6 7 8 9 ... 491 492 493 494 \\\n", + "0 485 477 537 479 452 471 491 476 475 473 ... 481 477 485 511 \n", + "1 483 458 460 487 587 475 526 479 485 469 ... 478 487 338 513 \n", + "2 487 542 499 468 448 471 442 478 480 477 ... 481 492 650 506 \n", + "3 480 491 510 485 495 472 417 474 502 476 ... 480 474 572 454 \n", + "4 484 502 528 489 466 481 402 478 487 468 ... 479 452 435 486 \n", "\n", - " 494 495 496 497 498 499 target \n", - "0 511 485 481 479 475 496 -1 \n", - "1 513 486 483 492 510 517 -1 \n", - "2 506 501 480 489 499 498 -1 \n", - "3 454 469 475 482 494 461 1 \n", - "4 486 508 481 504 495 511 1 \n", + " 495 496 497 498 499 target \n", + "0 485 481 479 475 496 -1 \n", + "1 486 483 492 510 517 -1 \n", + "2 501 480 489 499 498 -1 \n", + "3 469 475 482 494 461 1 \n", + "4 508 481 504 495 511 1 \n", "\n", "[5 rows x 501 columns]" ] @@ -279,9 +288,7 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "rf = RandomForestClassifier(n_jobs=-1, class_weight=None, max_depth=7, random_state=0)\n", @@ -298,9 +305,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 99%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 99/100 [01:02<00:00, 1.59it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using native var. imp.\n", + "\n", + "Iteration: \t100 / 100\n", + "Confirmed: \t30\n", + "Tentative: \t1\n", + "Rejected: \t455\n", + "All relevant predictors selected in 00:01:02.25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "BorutaPy(estimator=RandomForestClassifier(max_depth=7, n_estimators=135,\n", + " n_jobs=-1,\n", + " random_state=RandomState(MT19937) at 0x200D9BD7048),\n", + " n_estimators='auto',\n", + " random_state=RandomState(MT19937) at 0x200D9BD7048, verbose=2)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "feat_selector.fit(X, y)" ] @@ -316,9 +367,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[False False False False True False False False False False True False\n", + " False False False False False False False False False False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False False False False\n", + " True False False False False False False False False False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False True False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False True False False False\n", + " False False False False True False False False False False False False\n", + " False False False False False False False False False True False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " True False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False True False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False True True False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False True False False False False False\n", + " False False False False False False False False False False True False\n", + " True False True False False False False False False False False False\n", + " True True False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False True False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False True\n", + " False True False False False False False False False False True False\n", + " False False False False False False False True False True False True\n", + " False False False False False False False False False False False False\n", + " False False False False True False False True False False False False\n", + " False True False False False False False False False False False False\n", + " False True False False False False False False]\n", + "\n", + "Selected Feature Matrix Shape\n", + "(2000, 30)\n" + ] + } + ], "source": [ "# Check selected features\n", "print(feat_selector.support_)\n", @@ -338,28 +441,88 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([418, 351, 150, 362, 1, 271, 174, 464, 410, 358, 1, 222, 262,\n", + " 35, 302, 332, 287, 191, 141, 405, 339, 265, 428, 215, 300, 82,\n", + " 49, 411, 1, 234, 429, 67, 159, 42, 351, 110, 220, 294, 52,\n", + " 454, 443, 76, 114, 41, 20, 264, 67, 195, 1, 58, 180, 157,\n", + " 389, 415, 206, 5, 22, 206, 377, 176, 87, 313, 181, 444, 1,\n", + " 196, 249, 236, 183, 401, 342, 240, 204, 30, 159, 126, 324, 84,\n", + " 169, 112, 414, 40, 347, 419, 269, 66, 391, 253, 329, 57, 471,\n", + " 247, 360, 281, 139, 110, 439, 271, 141, 78, 214, 375, 413, 148,\n", + " 212, 1, 49, 389, 355, 167, 411, 151, 388, 321, 129, 307, 29,\n", + " 349, 285, 62, 450, 271, 152, 219, 331, 131, 305, 94, 1, 156,\n", + " 91, 73, 311, 437, 139, 133, 1, 5, 415, 107, 123, 299, 321,\n", + " 337, 297, 327, 307, 31, 365, 24, 242, 315, 133, 1, 461, 204,\n", + " 268, 244, 325, 309, 186, 78, 396, 405, 114, 98, 453, 429, 456,\n", + " 350, 234, 145, 153, 446, 363, 34, 360, 216, 250, 314, 27, 232,\n", + " 193, 281, 38, 372, 201, 224, 73, 448, 408, 225, 178, 88, 238,\n", + " 417, 338, 289, 462, 8, 209, 244, 96, 403, 1, 455, 42, 353,\n", + " 285, 199, 383, 12, 317, 329, 421, 123, 161, 139, 164, 400, 198,\n", + " 345, 165, 92, 64, 288, 31, 449, 468, 170, 354, 254, 241, 405,\n", + " 69, 61, 252, 431, 27, 369, 220, 1, 348, 21, 44, 36, 129,\n", + " 450, 290, 384, 149, 278, 447, 317, 436, 104, 178, 311, 409, 110,\n", + " 276, 425, 113, 86, 120, 279, 262, 103, 254, 217, 257, 302, 316,\n", + " 60, 398, 367, 468, 18, 5, 294, 459, 1, 1, 460, 173, 10,\n", + " 17, 174, 442, 239, 76, 163, 364, 433, 129, 83, 15, 231, 12,\n", + " 294, 166, 107, 393, 8, 229, 259, 80, 402, 365, 127, 47, 394,\n", + " 334, 105, 301, 230, 382, 369, 1, 118, 305, 19, 281, 15, 405,\n", + " 438, 69, 327, 339, 15, 226, 336, 462, 136, 1, 197, 1, 168,\n", + " 1, 260, 260, 244, 159, 2, 213, 423, 372, 27, 1, 1, 427,\n", + " 97, 194, 319, 125, 360, 154, 464, 51, 143, 291, 94, 136, 71,\n", + " 441, 116, 99, 99, 396, 341, 65, 192, 145, 355, 102, 200, 392,\n", + " 55, 1, 237, 419, 344, 52, 297, 46, 283, 132, 466, 209, 44,\n", + " 422, 89, 452, 379, 445, 187, 244, 202, 265, 426, 368, 276, 456,\n", + " 38, 470, 123, 37, 435, 185, 188, 3, 8, 75, 55, 90, 248,\n", + " 319, 10, 209, 94, 211, 381, 227, 467, 24, 59, 116, 171, 183,\n", + " 440, 33, 1, 72, 1, 121, 177, 189, 384, 325, 375, 274, 258,\n", + " 1, 155, 147, 432, 379, 387, 136, 250, 342, 1, 218, 1, 234,\n", + " 1, 292, 23, 54, 275, 171, 297, 203, 85, 333, 256, 273, 106,\n", + " 80, 323, 162, 395, 1, 458, 399, 1, 386, 372, 183, 434, 118,\n", + " 1, 379, 143, 346, 335, 223, 227, 357, 374, 48, 424, 305, 1,\n", + " 62, 190, 101, 310, 267, 284])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "feat_selector.ranking_" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = feat_selector.plot_importance(n_feat_per_inch=5)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "boruta", "language": "python", - "name": "python3" + "name": "boruta" }, "language_info": { "codemirror_mode": { @@ -371,7 +534,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.7.9" }, "varInspector": { "cols": { @@ -404,5 +567,5 @@ } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/boruta/examples/Whats_new.ipynb b/boruta/examples/Whats_new.ipynb new file mode 100644 index 0000000..a651941 --- /dev/null +++ b/boruta/examples/Whats_new.ipynb @@ -0,0 +1,783 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

All relevant feature selection

\n", + "

Regression - Boruta and beyond

\n", + "

\n", + " Human Bender
\n", + "

\n", + "\n", + "\n", + "In the original Boruta paper NIPS2003 and cited in the [Boruta paper](https://www.jstatsoft.org/article/view/v036i11/v36i11.pdf) the gini feature importance is used. The gini importance is known to be biased. See [this blog post](https://explained.ai/rf-importance/#5) for a nice illustration and [this one](https://blog.methodsconsultants.com/posts/be-aware-of-bias-in-rf-variable-importance-metrics/) for an explanation why is impurity importance biased. \n", + "\n", + "#### What's new:\n", + "\n", + " - The categorical features (they are detected, encoded. The tree-based models are working better with integer encoding rather than with OHE, which leads to deep and unstable trees). If Catboost is used, then the cat.pred (if any) are set up\n", + " - You can use lightGBM, XGBoost and CatBosst (sklearn API only)\n", + " - Allow using sample_weight\n", + " - Supports permutation importance\n", + " - Support SHAP feature importance for lightGBM, XGBoost and CatBosst and does not introduce a direct dependency to the SHAP package nor to the boosting packages (for XGBoost and CatBoost you need to pass the data structure function though)\n", + " - The dependencies which are not part of the [list of scikit-learnn dependencies](https://scikit-learn.org/stable/install.html) are optional. Not part of the distribution but import checks are performed. Those dependencies are `tqdm` (for a nice user notification) and `SHAP` for the Shapley values.\n", + " - Visualization, as in the original R package, based on matplotlib (which is a scikit-learn dependency, see above, but installation is not forced in the setup.py) \n", + " \n", + "Note that for lightGBM with SHAP, the run time for this example is almost the same as for Boruta with gini/impurity feature importance. The IQR (inter-quartile) is much smaller with permutation and SHAP importance." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from IPython.core.display import display, HTML\n", + "# display(HTML(\"\"))\n", + "\n", + "import gc\n", + "from sklearn.datasets import fetch_openml\n", + "from sklearn.utils import Bunch\n", + "from sklearn.datasets import load_boston\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from lightgbm import LGBMRegressor\n", + "from catboost import CatBoostRegressor\n", + "\n", + "from boruta import BorutaPy\n", + "# plt.style.use('fivethirtyeight')\n", + "rng = np.random.RandomState(seed=42)\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "gc.enable()\n", + "gc.collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing by adding random and genuine predictors to real data\n", + "\n", + "I'll use a classical data set to which I added random predictors (numerical and categorical). An All Relveant FS methods should discard them.\n", + "In the unit tests, you'll find examples using artifical data with genuine (correlated and non-linear) predictors and with some random/noise columns.\n", + "\n", + "## Fetch the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_boston_data():\n", + " boston = load_boston()\n", + " rng = np.random.RandomState(seed=42)\n", + " X = pd.DataFrame(boston.data)\n", + " X.columns = boston.feature_names\n", + " X['random_num1'] = rng.randn(X.shape[0])\n", + " X['random_num2'] = np.random.poisson(1, X.shape[0])\n", + " # high cardinality\n", + " X['random_cat'] = rng.randint(10*X.shape[0], size=X.shape[0])\n", + " X['random_cat'] = 'cat_' + X['random_cat'].astype('str')\n", + " # low cardinality\n", + " nice_guys = ['Rick', 'Bender', 'Cartman', 'Morty', 'Fry', 'Vador', \n", + " 'Thanos', 'Bejita', 'Cell', 'Tinkywinky', 'Lecter', \n", + " 'Alien', 'Terminator', 'Drago', 'Dracula', \n", + " 'Krueger', 'Geoffrey', 'Goldfinder', 'Blackbeard', \n", + " 'Excel', 'SAS', 'Bias', 'Variance', 'Scrum',\n", + " 'Human', 'Garry', 'Coldplay', 'Imaginedragons',\n", + " 'Platist', 'Creationist', 'Gruber', 'KeyserSoze', 'Luthor',\n", + " 'Klaue', 'Bane', 'MarkZ']\n", + " X['random_cat_2'] = np.random.choice(nice_guys, X.shape[0])\n", + " y = pd.Series(boston.target)\n", + " # non linear noisy but genuine predictor to test the ability to detect even genuine noisy non-linearities\n", + " X['genuine_num'] = np.sqrt(y) + np.random.gamma(2, .5, X.shape[0])\n", + " cat_f = ['CHAS', 'RAD', 'random_cat', 'random_cat_2']\n", + " X[cat_f] = X[cat_f].astype(str).astype('category')\n", + " return Bunch(data=X,\n", + " target=y,\n", + " sample_weight=None,\n", + " categorical=cat_f)\n", + "\n", + "def highlight_tick(str_match, figure, color='red', axis='y'):\n", + " if axis == 'y':\n", + " labels = [item.get_text() for item in figure.gca().get_yticklabels()]\n", + " indices = [i for i, s in enumerate(labels) if str_match in s]\n", + " [figure.gca().get_yticklabels()[idx].set_color(color) for idx in indices]\n", + " elif axis == 'x':\n", + " labels = [item.get_text() for item in figure.gca().get_xticklabels()]\n", + " indices = [i for i, s in enumerate(labels) if str_match in s]\n", + " [figure.gca().get_xticklabels()[idx].set_color(color) for idx in indices]\n", + " else:\n", + " raise ValueError(\"`axis` should be a string, either 'y' or 'x'\")\n", + "\n", + " return figure" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "boston = get_boston_data()\n", + "X, y = boston.data, boston.target" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CRIM float64\n", + "ZN float64\n", + "INDUS float64\n", + "CHAS category\n", + "NOX float64\n", + "RM float64\n", + "AGE float64\n", + "DIS float64\n", + "RAD category\n", + "TAX float64\n", + "PTRATIO float64\n", + "B float64\n", + "LSTAT float64\n", + "random_num1 float64\n", + "random_num2 int32\n", + "random_cat category\n", + "random_cat_2 category\n", + "genuine_num float64\n", + "dtype: object" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.dtypes" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATrandom_num1random_num2random_catrandom_cat_2genuine_num
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.980.4967142cat_3517KeyserSoze6.588640
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.14-0.1382641cat_2397Krueger5.112846
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.030.6476891cat_3735Bane6.668522
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.941.5230303cat_2870Lecter6.298638
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.33-0.2341530cat_1160Bejita6.926993
\n", + "
" + ], + "text/plain": [ + " CRIM ZN INDUS CHAS NOX RM AGE DIS RAD TAX PTRATIO \\\n", + "0 0.00632 18.0 2.31 0.0 0.538 6.575 65.2 4.0900 1.0 296.0 15.3 \n", + "1 0.02731 0.0 7.07 0.0 0.469 6.421 78.9 4.9671 2.0 242.0 17.8 \n", + "2 0.02729 0.0 7.07 0.0 0.469 7.185 61.1 4.9671 2.0 242.0 17.8 \n", + "3 0.03237 0.0 2.18 0.0 0.458 6.998 45.8 6.0622 3.0 222.0 18.7 \n", + "4 0.06905 0.0 2.18 0.0 0.458 7.147 54.2 6.0622 3.0 222.0 18.7 \n", + "\n", + " B LSTAT random_num1 random_num2 random_cat random_cat_2 \\\n", + "0 396.90 4.98 0.496714 2 cat_3517 KeyserSoze \n", + "1 396.90 9.14 -0.138264 1 cat_2397 Krueger \n", + "2 392.83 4.03 0.647689 1 cat_3735 Bane \n", + "3 394.63 2.94 1.523030 3 cat_2870 Lecter \n", + "4 396.90 5.33 -0.234153 0 cat_1160 Bejita \n", + "\n", + " genuine_num \n", + "0 6.588640 \n", + "1 5.112846 \n", + "2 6.668522 \n", + "3 6.298638 \n", + "4 6.926993 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model \n", + "\n", + "Let's use the same model for all the examples" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Let's use lightgbm as booster, see below for using more models\n", + "model = LGBMRegressor(random_state=42, verbose=-1, max_depth=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boruta (vanilla)\n", + "\n", + "the original form, with gini/impurity feature importance. IQR is large." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 95%|████████████████████████████████████████████████████████████▊ | 19/20 [00:05<00:00, 3.22it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using native var. imp.\n", + "\n", + "Iteration: \t20 / 20\n", + "Confirmed: \t2\n", + "Tentative: \t0\n", + "Rejected: \t16\n", + "All relevant predictors selected in 00:00:05.91\n", + "['RM', 'genuine_num']\n", + "Wall time: 6.1 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "feat_selector = BorutaPy(model, verbose=1, max_iter=20, random_state=42, importance='native') #, early_stopping=True, n_iter_no_change=20)\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictorBorutaBoruta_weak_incl
0CRIM00
1ZN00
2INDUS00
3CHAS00
4NOX00
5RM11
6AGE00
7DIS00
8RAD00
9TAX00
10PTRATIO00
11B00
12LSTAT00
13random_num100
14random_num200
15random_cat00
16random_cat_200
17genuine_num11
\n", + "
" + ], + "text/plain": [ + " predictor Boruta Boruta_weak_incl\n", + "0 CRIM 0 0\n", + "1 ZN 0 0\n", + "2 INDUS 0 0\n", + "3 CHAS 0 0\n", + "4 NOX 0 0\n", + "5 RM 1 1\n", + "6 AGE 0 0\n", + "7 DIS 0 0\n", + "8 RAD 0 0\n", + "9 TAX 0 0\n", + "10 PTRATIO 0 0\n", + "11 B 0 0\n", + "12 LSTAT 0 0\n", + "13 random_num1 0 0\n", + "14 random_num2 0 0\n", + "15 random_cat 0 0\n", + "16 random_cat_2 0 0\n", + "17 genuine_num 1 1" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_selector.tag_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boruta with permutation importance\n", + "\n", + "Not the original form, same process but using permutation importance instead of the gini/impurity one. IQR is small." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 95%|████████████████████████████████████████████████████████████▊ | 19/20 [00:29<00:01, 1.54s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using pimp var. imp.\n", + "\n", + "Iteration: \t20 / 20\n", + "Confirmed: \t11\n", + "Tentative: \t0\n", + "Rejected: \t7\n", + "All relevant predictors selected in 00:00:29.20\n", + "['CRIM', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'genuine_num']\n", + "Wall time: 29.4 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "model = LGBMRegressor(random_state=42, verbose=-1, max_depth=5)\n", + "\n", + "feat_selector = BorutaPy(model, verbose=1, max_iter=20, random_state=42, importance='pimp')#, early_stopping=True, n_iter_no_change=20)\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boruta with SHAP\n", + "\n", + "Not the original form, same process but using SHAP importance instead of the gini/impurity one." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 95%|████████████████████████████████████████████████████████████▊ | 19/20 [00:06<00:00, 2.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using shap var. imp.\n", + "\n", + "Iteration: \t20 / 20\n", + "Confirmed: \t10\n", + "Tentative: \t0\n", + "Rejected: \t8\n", + "All relevant predictors selected in 00:00:06.36\n", + "['CRIM', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'LSTAT', 'genuine_num']\n", + "Wall time: 6.54 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "model = LGBMRegressor(random_state=42, verbose=-1, max_depth=5)\n", + "\n", + "feat_selector = BorutaPy(model, verbose= 1, max_iter= 20, random_state=42, importance='shap')\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:boruta]", + "language": "python", + "name": "conda-env-boruta-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/boruta/examples/Xgboost_boruta_pimp.ipynb b/boruta/examples/Xgboost_boruta_pimp.ipynb new file mode 100644 index 0000000..5636892 --- /dev/null +++ b/boruta/examples/Xgboost_boruta_pimp.ipynb @@ -0,0 +1,814 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

All relevant feature selection

\n", + "

Regression - Boruta and beyond

\n", + "

\n", + " Human Bender
\n", + "

\n", + "\n", + "\n", + "In the original Boruta paper NIPS2003 and cited in the [Boruta paper](https://www.jstatsoft.org/article/view/v036i11/v36i11.pdf) the gini feature importance is used. The gini importance is known to be biased. See [this blog post](https://explained.ai/rf-importance/#5) for a nice illustration and [this one](https://blog.methodsconsultants.com/posts/be-aware-of-bias-in-rf-variable-importance-metrics/) for an explanation why is impurity importance biased. \n", + "\n", + "#### What's new:\n", + "\n", + " - The categorical features (they are detected, encoded. The tree-based models are working better with integer encoding rather than with OHE, which leads to deep and unstable trees). If Catboost is used, then the cat.pred (if any) are set up\n", + " - You can use lightGBM, XGBoost and CatBosst (sklearn API only)\n", + " - Allow using sample_weight\n", + " - Supports permutation importance\n", + " - Support SHAP feature importance for lightGBM, XGBoost and CatBosst and does not introduce a direct dependency to the SHAP package nor to the boosting packages (for XGBoost and CatBoost you need to pass the data structure function though)\n", + " - The only dependency which is not part of the [list of scikit-learnn dependencies](https://scikit-learn.org/stable/install.html) is `tqdm` (for a nice user notification)\n", + " - Visualization, as in the original R package, based on matplotlib (which is a scikit-learn dependency, see above) \n", + " \n", + "To use SHAP feature importance for tree-based models, you need to pass the `shap.TreeExplainer`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from IPython.core.display import display, HTML\n", + "# display(HTML(\"\"))\n", + "\n", + "import gc\n", + "from sklearn.datasets import fetch_openml\n", + "from sklearn.utils import Bunch\n", + "from sklearn.datasets import load_boston\n", + "from sklearn.inspection import permutation_importance\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from catboost import CatBoostRegressor, Pool, CatBoostClassifier\n", + "from xgboost import XGBRegressor, DMatrix, XGBClassifier\n", + "from shap import TreeExplainer\n", + "\n", + "from boruta import BorutaPy\n", + "# plt.style.use('fivethirtyeight')\n", + "rng = np.random.RandomState(seed=42)\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "gc.enable()\n", + "gc.collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing by adding random and genuine predictors to real data\n", + "\n", + "I'll use a classical data set to which I added random predictors (numerical and categorical). An All Relveant FS methods should discard them.\n", + "In the unit tests, you'll find examples using artifical data with genuine (correlated and non-linear) predictors and with some random/noise columns.\n", + "\n", + "## Fetch the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_boston_data():\n", + " boston = load_boston()\n", + " rng = np.random.RandomState(seed=42)\n", + " X = pd.DataFrame(boston.data)\n", + " X.columns = boston.feature_names\n", + " X['random_num1'] = rng.randn(X.shape[0])\n", + " X['random_num2'] = np.random.poisson(1, X.shape[0])\n", + " # low cardinality\n", + " nice_guys = ['Rick', 'Bender', 'Cartman', 'Morty', 'Fry', 'Vador', \n", + " 'Thanos', 'Bejita', 'Cell', 'Tinkywinky', 'Lecter', \n", + " 'Alien', 'Terminator', 'Drago', 'Dracula', \n", + " 'Krueger', 'Geoffrey', 'Goldfinger', 'Blackbeard', \n", + " 'Excel', 'SAS', 'Bias', 'Variance', 'Scrum',\n", + " 'Human', 'Garry', 'Coldplay', 'Imaginedragons',\n", + " 'Platist', 'Creationist', 'Gruber', 'KeyserSoze', 'Luthor',\n", + " 'Klaue', 'Bane', 'MarkZ']\n", + " X['random_cat'] = np.random.choice(nice_guys, X.shape[0])\n", + " y = pd.Series(boston.target)\n", + " # non linear noisy but genuine predictor to test the ability to detect even genuine noisy non-linearities\n", + " X['genuine_num'] = np.sqrt(y) + np.random.normal(0, 1, X.shape[0]) #np.random.gamma(2, .5, X.shape[0])\n", + " cat_f = ['CHAS', 'RAD', 'random_cat']\n", + " X[cat_f] = X[cat_f].astype(str)\n", + " return Bunch(data=X,\n", + " target=y,\n", + " sample_weight=None,\n", + " categorical=cat_f)\n", + "\n", + "def highlight_tick(str_match, figure, color='red', axis='y'):\n", + " if axis == 'y':\n", + " labels = [item.get_text() for item in figure.gca().get_yticklabels()]\n", + " indices = [i for i, s in enumerate(labels) if str_match in s]\n", + " [figure.gca().get_yticklabels()[idx].set_color(color) for idx in indices]\n", + " elif axis == 'x':\n", + " labels = [item.get_text() for item in figure.gca().get_xticklabels()]\n", + " indices = [i for i, s in enumerate(labels) if str_match in s]\n", + " [figure.gca().get_xticklabels()[idx].set_color(color) for idx in indices]\n", + " else:\n", + " raise ValueError(\"`axis` should be a string, either 'y' or 'x'\")\n", + "\n", + " return figure\n", + "\n", + "def plot_y_vs_X(X, y, out_col=5, figsize=(15, 15)):\n", + "\n", + " n_charts = X.shape[1]\n", + " out_row = int(np.ceil(n_charts / out_col))\n", + " n_subplots = out_row * out_col\n", + "\n", + " fig, ax = plt.subplots(nrows=out_row, ncols=out_col, sharex=False, sharey=True, figsize=figsize)\n", + " plt.subplots_adjust(wspace=0.05)\n", + " \n", + " for i, axi in enumerate(ax.ravel()): \n", + " if i < X.shape[1]:\n", + " axi.scatter(X.iloc[:, i], y, marker='o', alpha=0.1)\n", + " axi.set(title = X.columns[i])\n", + " axi.set(xlabel = '', ylabel = 'Target')\n", + " if (n_subplots > n_charts > 1) and (i >= n_charts):\n", + " axi.set_axis_off()\n", + "\n", + " # plt.tight_layout()\n", + " plt.suptitle('Cond Dependency Plot', fontsize=20)\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "boston = get_boston_data()\n", + "X, y = boston.data, boston.target" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAQmCAYAAADGG0+QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eZxkbVbQiX/P3WPLtbLWt+rdeqW7oVu6pRHERkBhRMGfI6hgIy6MjuA2jiCKNrihqKOijjKogMgILgjisAgOjkjT+MLb9L68W21ZVZmVmbHeuPvz++NGZGVm5Z4RFRmZ5/t+4o3KG3d57nLuOc95znOOGGNQFEVRFEVRFEVRFEU5zViTboCiKIqiKIqiKIqiKMpBqANDURRFURRFURRFUZRTjzowFEVRFEVRFEVRFEU59agDQ1EURVEURVEURVGUU486MBRFURRFURRFURRFOfWoA0NRFEVRFEVRFEVRlFOPOjAURVEUZYSIyGsi8tqk23FWEJFnRMSIyPdNui2nERF5z+D6vG/SbVEURVGUcaMODEVRFOVUIyJvEpHvFpGPiEhLRBIRWRaR/yQif0hEgkm38SQMHB5myycVkTUR+bCI/EsR+d0i4k26ncqTYYvDZusnE5EHg2f+y8Z03PcNjvWecexfURRFUUaBM+kGKIqiKMpeiMhfAv4ypcP9l4DvB7rAJeA9wPcCfwx454SaOEr+PtCkPNcZ4I3A7wS+Fvi0iPx+Y8wHJtc85QnTAv7e4N8B8FnA/wT8TyLyJ40x/2BSDVMURVGUSaEODEVRFOVUIiLfCnw7cBv43bt13kXky4H/7Um3bUz8PWPMa1sXiMgs8FeAbwJ+WkTebYz5xCQapzxxmsaY921dICJfD/xz4K+LyPcaY8KJtExRFEVRJoROIVEURVFOHSLyDPA+IAX+p70iD4wxPwF86S7bf5WI/H+DKSf9wXSMPy8i/i7rvjb4VEXku0TklojEIvKSiHyziMgu24iIfKOIfFREIhG5KyL/cOBwGBnGmJYx5k8APwDMAt+5S1uqg3P7oIj0RKQrIu8Xkd+7y7qb+RJE5HNF5GcH16gjIj8tIrtGsoiIIyL/q4j8koi0RSQUkRcH18Dase5mzorBv/+1iDwcXKcXBk6n3Y7REJG/KyJ3But+QkT+DPvYKic497cPpmM0B+fyX0XkN+xxDFtE/qiI/Pctz9NLIvK9IvL6wTrfOdj3e/fYx2cPfv+Pe53LIfk+oAfUgLcctLKIvF5EfmDwfA6nXv3AsN1b1nuNMtIJ4P/dOn3lhO1VFEVRlJGiDgxFURTlNPL1gAv8O2PMR/Zb0RgTb/1bRP468MPAm4EfAv4hIMBfp4xicHfZjQv8DPC7gJ+knJpSoXQY/KVd1v97wHcD88D3AP+a0pHys8A48lV8++D7y0VkZrhQROaAX6A8t5xydP77gSXgh0Tkr+6xv88Bfh6IgX9Eec5fBPw3EfmNW1ccXK+fGKw3R3lNv4fShvjuwfF242ngl4FngH9JeU/eCvyYiHzhjmP4wM8Bfxp4SDmd5r8C3wb8H7vt/ATn/k7gFymnZXzv4Nw+H/g5EXnjjmN4wE8B/ydwfXDu/wD4FcrpPZ83WPWfAAXwv+xxzOHyf7rH78dhX+eCiLwLeIFyCtL/AP425TSsrwFe2OGs+nuU1xvKa/jtWz6KoiiKcnowxuhHP/rRj370c6o+lJ1ZA/zhI273uYPtbgGXtyx3gP84+O1bd2zz2mD5/wNUtiy/SJmTogm4W5b/hsH6LwELW5YHwPsHv712hDYPj//MAevdHqz3hVuWfd9g2Z/bsW5A2fEugLdvWf6ewfoG+MYd23zFYPmnAWvL8vcNln83YG9ZbgP/bPDbV2xZ/syWY/zlHcf4rcNrvWP5tw6W/7sdx34WWB/89n07tjnJuf+BHdv8L4Pl/3jH8r8+WP7jgL/jNx9Y2vL3TwzWfduO9epAZ/BM2lt/2+M+D6/fY88Q8AcHv3WHz+qW83rflvUE+Phg+dfs2MdXD5Z/Yo/7/J5xyLR+9KMf/ehHP6P4aASGoiiKchq5Mvi+c8Tt/uDg+68aY+4PFxpjMspcGQXwh/fY9k8YY/pbtlkBfoxy6sbWkfmvH3z/NWPM+pb1I+DPH7G9R+Hu4HsJQEQWKUfXXzDG/K2tKw7a8s2UHdnft8u+XgL+8Y5tfoxyFP51wG8cHMMCvhG4D/xpY0y+Zf2c8poaylH9ndwEtkVBGGN+mrIj/+t3rPv1lPfmzxljii3rv0oZ8bCNE577fzfGfN+OZf8cyLa2S0Rs4H8F+sAfNTsifYwxsTFmdcui/3Pw/Q079v01lE6M7916/Q7B3GC6y/sGU1T+H0qHEZROuP4+2/4G4E3A+40x/2pHu3+YMnLljZSRJ4qiKIoyNWgST0VRFOU0Msw7cdQ5+L9u8P1fdv5gjPmUiNwBnhWROWNMc8vPLWPMS7vs7/bge36XY/xXHue/UXaEx8HOa/IuyigIIyLv22X94VSZN+/y23/b6ijYws8Dvwl4B+X5vQFYpIzK+Iu7pAOBsoO/2zE+uEeH/TZlpAxQ5r6gdJrcNsa8vEeb/vKOZSc59xd2LjDGpCLygO33+U2UzqsPGGOWd9nPTn4SeBX4/SLyzeZRgs1voJzi8r2H2MdWZnl03jllJMpPAv/QGPP/HLDtnnKwZfnnU97n/++I7VIURVGUiaEODEVRFOU0skzZgXzqiNsNk2je2+P3e8CNwXrNLcubu63MI2eEvcsxHuxc2RiTi8jaYRp6DK4Ovoej/ouD73cNPntR32XZY20fMIxaGZ7j8Biv53EnwkHHaO6xbsb2HFx7Xs8dbdrKSc59v3Ztvc9zg++7j6/6OMaYQkT+KWXelK8G/oWIfDalM+E/HNIJspWbxphnjrjNkMPIATw6R0VRFEWZCnQKiaIoinIa+YXB9xcdcbvW4PvyHr9f2bHecRhue2nnD4NpB4s7l58UEXkdpTMno0wgubUd/4cxRvb5fOEuu3ys7QOG16214/tHDzjGsyc4vT2v54427bbNcc79sDQH39eOsM0/p0yMOkzaOY7knYfhSciBoiiKojxx1IGhKIqinEb+BWUJ1d8lIp+x34qyvTTqi4Pv9+yy3tAJ8OqO6SNH5VcH379pl99+I+OJbhxWQvmPxpjO4N+/TJk34jfuvsm+fP7O8qcD3jP4Hl7HT1B25N+9R/WWEzM4n5eAayLy/D5t2spJzv2wDM/9M0Xk6gHrAjDIifFvgc8Rkc8Dfi9lktafGVMb92JPOdix/Fe3LBtO97FRFEVRlFOKOjAURVGUU4cx5jXKqgge8J92lHzcRES+lDIvwJB/Pvj+iyKytGU9m7KMpMWjRIjH5fsG339BRBa2HCMA/sYJ970NEZkRkX8A/H7KzvS3DH8bJBn9V8A7ReTbROQxx4mIPC8iu0VHvJ4yQeXWdb+C0inzEmUuj2Hy0++mHLH/ByJS2eUYVw5yMh2Cf0F5b/7mVsfKoO1/YufKJzz3QzHI3/GPKcvp/pMdjjJExNv6jG1hmMzzhymnsHzPHvlGxsl/Bz5J6aj6n7f+MPj7C4BP8SjSCWA49enGE2mhoiiKohwDzYGhKIqinEqMMX990DH9y8D/EJFfpEzA2KWcbvAFlB3xF7Zs84si8reAPwd8RET+LdADvgx4K2WH7btO2K7/LiLfDXzTlmOklGVIN9g778BB/CkRaVIm65yhrBLxBUCNsrP5tcaYT+3Y5hspr8F3UCaP/AXKXBJXKRNYvosyCuDVHdv9FPB3ROTLgF+jTKL5/wMi4A/t6HD/FeCzgD8K/HYR+S+UeSEuDo79ecBfAD52zPMG+DvAVwK/C/hVEflpyjwOX02ZZPJ37LLNcc/9KHw78DnAbwc+JSI/QVkS9TrwW4D/nUcOLWDz+fg1ymuW8sip9sQwxhgR+TrgPwM/LCI/RhlR8kbK69wB3rvjPv+/lFEtf0NE3kr5LGOM2VZJRlEURVEmiTowFEVRlFOLMeY7ROTfUEYLfCFluc2AcrT4g8DfBH5wxzbfLCIvUnZw30tZkeJl4C8Cf8cYk4ygaX+S0qnwxynzHKwBPwp8K6VD4Lj7hDLPRYfSSfCjlKVcf3y3dhtj2iLymygrXfw+SgdAQNmR/zTwpyk7sTv5AGXH/69QXiehrEzxF4wx/2PHMVIR+UrKsqV/APhyysiCVUrnwLdRRkMcG2NMLCJfTBl189WU1+I1yjKsP8ouDowTnPtR2pUMonz+KOWz9HWU12p50K5f2GPTfwH8PeDHjDF7JScdK8aYD4jIuyif+y+mdMI8BP5v4K8YYz65Y/2PD5wef5ZS3oLBT+rAUBRFUU4NYsxRK9QpiqIoijKNiMh7KEfav90Y876JNuYMIyLfR+ns+GJjzM9NuDmKoiiKcmbQHBiKoiiKoigjQkSuA78H+DhlVIuiKIqiKCNCp5AoiqIoiqKcEBH5fcAbKJ0XPvBtRsNcFUVRFGWkqANDURRFURTl5HwDZdLV28CfNsb8uwm3R1EURVHOHJoDQ1EURVEURVEURVGUU4/mwJhiROT3icgLItIVkXsi8pMi8vki8j4RSQfLmyLyiyLyuVu2e4+I3Nny98+LiBGRz9qx//8wWP6eJ3dWinL6EJGvGcjTzo8Rkb80kKFoMPd9uM0Xi8hrE2y2okwUEXltIAd/YCAr//uO3+8M9csWvdUZfD4lIv9QRK5sWf8PDEql7nqcwb+fEpF/JyIPRaQlIh8WkT8w1hNVlAlygC34g7usb0TkdTuWDWX0q3ZZ/1tF5NXB/u+IyA+P83wU5bQx0DEPRKS2ZdkfFpGfH/xbROR/F5FPi0hfRG6JyHeKiD/4/ZtE5CMi4m3Z/k+JyIuDUvHKEVEHxpQiIn+GskTbXwcuATeAfwx8xWCVHzbG1IELlBnn/80Bu/wUZYm44f4XgXdTlslTlHONMeZfGWPqWz/An6Is1/h/DVbrUZaTVBTlcdaBbxaRmX3W+WFjTANYAH4ncBn4la1OjEPwLymncDwNLFLqtYmUMVWUcXMIW/CwfB2ljH7djv1/HfD7Kavp1IF3AlpVRzmPODwqdb6Tf0A5hfC9QAP4MuA3Az8y+P0fAU3gLwCIyHPAtwN/yBiTja/JZxd1YEwhIjILfAfwx40x/94Y0zPGpMaY/2iM2TbCNRCMfwVcE5GlfXb7r4CvFhF78Pfvpaxxn4zhFBRlqhGRdwD/B/B7jDH3Bov/AfB7d45sKYoClBU53g/86YNWHOizjwJfTelE/9+OcJx3Ad830IuZMeZFY8xPHqvFinKKOYoteMB+ngZ+E2UH7LeKyKUtP78L+GljzMsAxpj7xpjvGeFpKMq08F3AnxWRua0LReT1wP8KfI0x5v0DvfNR4HcBXyoiv9kYUwB/CPjTIvKZlANf/9gY86tP9hTODurAmE4+FwgoHQz7MghXei+wBmzss+oy8DHgtwz+fi/wAydrpqKcPQbK698Cf9UY8/NbfrpLqZTe9+RbpShTwbdRGnALh1nZGJMDPwb8xiMc45eAfyQiv0dEbhyjjYoyLRzaFjyA9wIvDJLOfhz4mi2//RLw3kF4/Du3DHIpynnjBeDngT+7Y/kXAXeMMb+8daEx5jal/HzJ4O9PAn+DsrT2U5QRGMoxUQfGdLIIPDwg7OirRKQJ9IE/AvzPhwhT+gFKRfVGYM4Y8/6RtFZRzggiIsD3Ax8B/tYuq/wN4LeLyFueaMMUZQowxnwQ+Bngm4+w2TLllJLD8ruB/0bpLHlVRD4oIu86wvaKMi0c2hbc+tllnfcCPzT49w+xZRqJMeYHgW8CfivwX4EVEfmWkbReUaaPvwR8046I9gvAvT3Wvzf4fch/o5Tbf2uMicbTxPOBOjCmkzXgwgGJX37EGDNHOSfyI8BnH2K//55yztY3Uc4jVhRlO98MvBX4OrNLCSdjzCrwDynDehVFeZy/BPwxEbl8yPWvUc7NB8gAd5d1XCAFMMZsGGO+xRjzFkr990HgPwycj4pylji0Lbj1s/VHEfk84FngXw8W/RDwNhF5+3CdQQ6oLwbmgD8KfIeI/NbRnYaiTAfGmI8APwFsdeI9BPbK03Rl8PswIv6fAt8NfOMgD4ZyTNSBMZ28H4iArzxoRWPMQ+B/Ad53UCI0Y0wI/CTwx1AHhqJsY1At4S9QRjM191n1u4Av5HBOQ0U5VxhjPkHpLP/Wg9YVEQv47ZSjVgC3gBtbnREiUgUuAjd3OdZD4G8DVzlaFIeiTAOHtgX34esAAT4oIveBDwyWv3fnioP8Gv8G+BClI19RziN/mTKy/drg7/8CXBeRX791pUFVunfzKOnttwErlIlA/wmlM0M5JurAmEKMMS3KUax/JCJfKSJVEXFF5MtE5LGw9oHB+NPAnzvE7r8V+E3GmNdG2mhFmWIGzr9/DfwpY8yL+607cG78HQ4nb4pyHvl24OspR3QfY6DP3gz835SVSP7u4KcPUHbYvkVEgkFJu++knJt8c7Dt3xSRt4qIIyINSof8S8aYtXGekKI8aY5qC+5ERALgqyiTd759y+ebgK8ZyNAfEJHfJiINEbFE5MuAt/DI0aEo5wpjzEvADwN/YvD3pygdEv9KRN4tIvZgGvG/A37WGPOzIvJZg/X/yCB6933AMyLy9RM5iTOAOjCmFGPM3wX+DPAXKbO03wa+EfgPe2zyXcA3iMjFA/a7bIz5hRE2VVHOAn+EMhz974tId8fnn+yy/t8H8ifbREWZDowxr1JG+dV2/PTVItKlLDf345Qh8p9tjFkebBcDvw14D3AHeIUyuuKrtkzpqlImNWwOfn8a+B3jOxtFmRzHsAW38pWUedJ+YFBd5L4x5j7wzwAb+FKgTTmwdYtSpv4W8MfUTlTOOd/Bdv31jcD3Aj8IdIGfokz4+bsGiW//GfDXBs4PjDHD/ITftaPqj3JIZJdp3IqiKIqiKIqiKIqiKKcKjcBQFEVRFEVRFEVRFOXUow4MRVEURVEURVEURVFOPerAUBRFURRFURRFURTl1KMODEVRFEVRFEVRFEVRTj3qwFAURVEURVEURVEU5dTjTLoBh+HChQvmmWeemXQzFGWTX/mVX3lojFmadDtOisqWctpQ2VKU8aCypSjj4SzIlsqVchrZS7amwoHxzDPP8MILL0y6GYqyiYjcnHQbRoHKlnLaUNlSlPGgsqUo4+EsyJbKlXIa2Uu2dAqJoiiKoiiKoiiKoiinHnVgKIqiKIqiKIqiKIpy6lEHhqIoiqIoiqIoiqIopx51YCiKoiiKoiiKoiiKcuoZaxJPEXkN6AA5kBlj3ikiC8APA88ArwFfZYzZGGc7FEVRFEVRFEVRFEWZbp5EFZIvNMY83PL3twA/Z4z5ThH5lsHf33zUnd5v9fnZj97nhdfWiLOCWuBwse6zUPN5/aUGn3VjnsC1Wd4IubPRpxUmzFRdLjYCfNcmzgrCJKXqOsxUXBbrPoFrj+qcFWVq+fEXb/MD73+N9W7CQt3jvZ/7DL/jHdfHftxmmPDyaodulFEPHJ5fajBX9cZ+3PNGlOasdWPirMB3rCO/+/bb/qT7PuvsvD4136EXZ3tey+WNkJVOjDGGS7MVrs5VNn8/jrzo/YFP3mvxs5+4z8NOwoWGxxe/6TJvvDK7+ftrD7v84surrHUTFusev+H5JZ65UJ9gi5XD8FMfvssP/tJN1roxi3Wfr33303zp265NulnKlPOh2+v8pw8vs9pJWGp4/La3XeUzry9MulkTZy9d1o6ykfetdtNbwFh02WF05EE6YrffL89Wdt2v6uTjM4kpJF8BfP/g398PfOVRd3C/1eeH/8ct/ttLK4hAux/zwVstXry1QZhkfOxei5/9+H0+eHuD19ZCmv0Ex7ZYbUe8cGudTz5os9Luk+fQ6qf0k5y7GyFRmo/yPBVl6vjxF2/zt3/mk/TTnCszLv0052//zCf58Rdvj/W4zTDhxZvr5DnMVz3yHF68uU4zTMZ63PNGlJbvusJA1bMpDEd69+23/Un3fdbZeX36Sc6LN9cJk3zXa/nKSoflVoTnWPiOzXIz5OXVLlGaH0te9P6Uzosf/MBN4tRwbS4gTg0/+IGbfPJeCygNzx998Q5JargyG5Ckhh998Q6vPexOuOXKfvzUh+/ydwZ66+qMRz/N+Ts/80l+6sN3J900ZYr50O11vvcXXiFKDU/NBUSp4Xt/4RU+dHt90k2bKDt1STjQZRthQiuMR9q32k1vvbLS4eXV7sh12WF05EE6Yrff/80Lt/nlVx4+tt9mmJx7nXwSxu3AMMDPiMiviMg3DJZdMsbcAxh8XzzqTj94e4O76yEXagEFApbNhYZHVhhub/SZr/osr/d5aaVDVhiqnkPVdygQLAMb3ZQoLaj6Dr5r00syPMdmrRuP8NQVZfr4gfe/RiNwuDhTwfN9Ls5UaAQOP/D+18Z63JdXO9R8l6rvYFkWVd+h5ru8vNoZ63HPG2vdGM+x8RwLEcFzrCO9+/bb/qT7PuvsvD69JKPmu/TibNdr2Utzar5TbuPa1DyXMM5Y68bHkhe9P/Czn7jPfNVjse7jOg6LdZ/5qsfPfuI+AL/48irzFY+5modj28zVPOYrHr/48uqEW67sxw/+0k1mKu42vTVTcfnBX7o56aYpU8x/+vAy81WfCw0f13W40PCZr/r8pw8vT7ppE+UxXRaXuuxeM8J3nJH2rXbTW700J4yzkeuyw+jIg3TEbr/blvChu83H9vvyaufc6+STMG4HxucZY34d8GXAHxeRLzjshiLyDSLygoi8sLq63XhohilxllPxLJK8oDAG14LCGLpxhucIcZ7Ti1LyosCxBIC8MIgISZ5TGAOAYwlxVuDa5beinHX2k631bsKcv/21MOdbrHfHGwnRjTICd/txA9eiG2VjPe55Y/iu28pR3n37bX/SfZ8F9pOtndcnzgoCt9RhQ7Zey6Iwm7oLwLGFwhjirDiWvOj9gYedhJlge3juTGDzsFO+39a6CfUdv9cDm7Uxv/+Ug9lPtta68a56SzsCyklY7STM7ngfzAY2q52z8z7YT672YqcuSfJSl/WSDGewfFR9q930VlGYzT7ckFHossPoyIN0xG6/B7bQ7m/Xza4tdKPs3OvkkzBWB4YxZnnwvQL8KPDrgQcicgVg8L2yx7bfY4x5pzHmnUtLS9t+m6u6+I5NPynwbAtLhLQAS4S675BkBt+2qQUutmWRFeWDbluCMQbPtrGkfGiywuA7FmlefivKWWc/2VqoezTj7S/PZlywUB9vLop64BCl248bpQX14Emk6Tk/DN91WznKu2+/7U+677PAfrK18/r4jkWUljpsyNZraVmyqbsAstxgieA71rHkRe8PXGh4tKPt4bntKOdCo3y/LdY9ujt+70Y5i2N+/ykHs59sLdb9XfXWcK68ohyHpYZHa8f7oBXlLDXOzvtgP7nai526xLNLXVbzHLLB8lH1rXbTW5Ylm324IaPQZYfRkQfpiN1+j3LDTGW7bk5zQz1wzr1OPglju0oiUhORxvDfwG8BPgL8OPB1g9W+Dvixo+777dfnubZQZaXTp5+khP2Ee60+NnB9vsJGGHN1ocLrLjZwLCFMMsI4w8JQCMzXXQLXIowz4jSn5jkkWa7KTjn3vPdzn6ETZay0+yRxzEq7TyfKeO/nPjPW4z6/1GCjF/PaWpdba11eW+uy0Yt5fqkx1uOeNxbrPkmWk2QFxhiSrDjSu2+/7U+677POzutT8xx6cUrNd3a9ljXXphdn5TZpTi9JqfrltIfjyIveH/jiN11mI0xY68akWTkdZyNM+OI3XQbgNzy/xEY/odlLyPKcZi9ho5/wG54/nGGvTIavfffTNMOUO2td1jshd9a6NMOUr33305NumjLF/La3XWUjjHnYiUnTjIedmI0w5re97eqkmzZRHtNlfqnLrswFxFk20r7Vbnqr5tpUfWfkuuwwOvIgHbHb73lheNOlGW6t93jtYZdb6z06/YTnlxrnXiefhHG6eS4BvyAivwb8MvCfjDE/BXwn8CUi8mngSwZ/H4nLsxW+4u3X+Iwrs2BgpubxGZcaPHOxgWtbfMaVWb74zZd5+/V5nlmsMlfxyPKCpZmAd95Y4I2XZrg4U8G2YbbiUvFsrs1XNfOrcu75He+4zp/9LW+k4trca6dUXJs/+1veOPYqJIFrszQbYFGGz1kIS7OByuSICdzyXWcJhEmOJRzp3bff9ifd91ln5/WpeDbveHphMwnazmv53MUGV2cDkqwgznKuzlV5fqm++ftR5UXvD7zxyixf+zlP47vC3WaE7wpf+zlPb1YheeZCnd/5jqfwXOFeK8Jzhd/5jqe0Cskp5z1vuszXvvsGnmPzsJviOTZf++4bvGfgmFKU4/CZ1xf4w5//HIEr3GlGBK7whz//uXNfhWSnLqkOdNl81WO26o+0b7Wb3nruYoPnl+oj12WH0ZEH6Yjdfv8dn3WVK/PVMiskgAEjojr5hIwtPtsY8wrwWbssXwO+6KT7d22LL3nrFd56fW6QQMbhymyF+arHtfnq5nrPXWzw3EUdxVWUw/Jb3nqVz35m8bGSVeNkrRuzVA+4NvdIdpOsYK0bb5Nn5eQMleaktj/P7Hbt9ip9Grg2V+erm2W/t4aVqrwcnzdemd1WNnUnz1yoq8Niyljrxrzr2Qs8tVDbZg+qPCgn5TOvL5x7h8Vu7NRlUZrTizN8x2ImqIy0HOheNsdi3d8sQTosnzwqJ8Z+HKQjdv4+rDRyYYstvVVf6zvqeEztRJvVTswn77XIc5itlGXkPnmvxWpHkzYpynGZVKlFTTA4/WiZztGy3/U8jrzo/VHOKmoPKsrkmIRumSZ9pvbteJhaB8b9dh/Pcah4ZULOimfjOQ732/1JN01RppZJlVrUBIPTj5bpHC37Xc/jyIveH+WsovagokyOSeiWadJnat+Oh6m9erYItgVpXiY/SfMC2yqXK4pyPCblKdYEg9OPjjKMlv2u53HkRe+PclZRe1BRJsckdMs06TO1b8fD1DowFuoeM4GHJUKUFVgizATe2Ms9KspZZlKeYk1mNP3oKMNo2e96Hkde9P4oZxW1BxVlckxCt0yTPlP7djycvjt9SJ5fapDmOXXf4epsQN13SPNcyy4qygmYpKd4+JJ/bqmuL/cpREcZRstB1/Oo8qL3RzmrqD2oKJNjErpl2vSZ2rejZ2odGHNVj3c8vYBtw0aYYNvwjqcX9szorijKwainWDku+uyMllFfT70/yllF7UFFmRyT0C2qz5SxlVF9EgSuzeWZCnG12AyrVRRFUSaDllgdLXo9FeVwqD2oKJPjSeuqKM03S6j6jjXSsq3KdDC1ERjTVEJHUaYFlStFOZuobCtnFX22FeX8oPKuwBQ7MKaphI6iTAsqV4pyNlHZVs4q+mwryvlB5V2BKZ5CEmcFlsD91qMQotmKS2oO3lZRlN2Js4Kqtz0Mz7WFMBm/Z1tDAhVlf04iI5OUbUUZJ/psK+NC7ZLRMaprqfKuwBRHYGAMdzb6FAYqbhlCdGejD0Y9GIpyXCZVmkpDAhVlf04qI9NUdk5RjoI+28o4ULtkdIzyWqq8KzDNDgwRwMDwGTaD/4lMrk2KMuVMqjSVhgQqyv6cVEamreycohwWfbaVcaB2yegY5bVUeVdgiqeQACw1fG6th/TijJrvcGNBs7UrykkYZpJe68aESY7vWE+kNNVwSti9ZkySF3i2xVxVp4QpypCTysikZFtRxk3g2izWfV5e7dCNMuqBw/NLDX22lROhUxVGxyhtPNVlCky5A2O1E3OhFnB5Rshyw2on5uqcOjEU5SRMqnTjnY2QmudScW2y3HBnI1R5VpQtnFRGtCyrchYZzq2/2KhwbU5Ic8NaNyZwbe3UKMdmOFXBcx5FdutUheMzShtPdZkyvVJoDCAwfK/I4H+aA0NRpg+VZ0XZH5URRdkVDfVXxoFOVRghqr+UETO9ERgiLNU9bq336SUZNc/hxkJFc2AoygmZSNZtEZ6ar9Dqp/TTMiTwqfkKheo2RSkZgYxoRn3lLKJTEJVxoFMVRsiIbTzVZcr0OjCA1W7MhbrPZTsop5B0dQqJopyEYaZoz7GpejZpbri7EY5dafuORWHg8mxlc1mSFbjqj1QU4OQyMinZVpQngU5BVMaBTlUYDaO08VSXKaBTSBRF2cKkQnE1VFNR9uekMqJh9sqZRe1BRTnVjNLGU12mwBRHYMRZgWvDcrMPwIWGpyHninJCJpV1W0M1pwcN3ZwMW2VkI0wJk5Sq67DWjQ91DzSjvnJmGUwpvr3Rpxtn1H2H6/M6pVhRRs1x9f8obTzVZQpMqQMjSnM2woSsMASORZjmrLZjap7DfNWbdPMUZWrxHYtOlNGLs825xDXfeUxZjAMN1Tz9aOjmZNhqNGIMhTFcbFRwbTn0PdCM+sqZxRjuNPvkRfk850X597OLtUm3TFHODKdF/6suU2BKp5CsdWNmKi7LzZAH7YhOlLHWTfjwnQ1q/lT6ZBTlVFDzHe6s90iygsCxSLKCO+u9JyJXQ+X4ymqXuxshUare9NOGhm4+eYZyURioejZrYcJGL6afZDxoR9xr9VkPE5Y3wn33o9O0lLNKnBfcb4ab0Ulr3Zj7zZA4LybdNEU5M5xE/+/UY4Xh2HbeOHWZ2qHTw1Q6MOKsoBuluJaNbQuCwXeFwgjrakgryrHpxRnXF2r4rkWUFfiuxfWFGr04G+txR6nclPFRTt3bHpbt2lJGBihjYafRaAzYInzqQYfCQMW1sUW4tb6/vAwjnCyBMMmxBI2cUc4EK62IwHE27UHbFgLHYaUVTbppinJmOIn+H+Xgx7h0mdqh08VUhiv4jsWDdkzgWUQppKbAEqEaCCudmOcuNibdREWZSuKsoB44NCru5jJjzNjnFq51YwpTfm+durLWjXVaySlCQzefPDvn+/qOxf1eQpIVbITltwjUPftAedFpWspZpBNl2I5AIaSmwLEsbKtcrijKaDiJ/h913opx6LKtThZg8zxHYYdq7rDRM5UOjMW6T5jkdPoJSClAhTFcqPnEgXrKFOW4TKqD2o4yWmGM7zhUXJtunHFnvYc/eMHry/50sFj3uTuYqjDMv5BkuXaKx8hOmZyrenzkbpsky5mpuDgi9NOMzLFoRxnXdtmHGk/KWcZ3hJsrIZYIZQxGaRO+QQezFGVkHFX/b9U7G2FMUXjbBsdO2+DHuJKDnpbcIWeN0/PkHIHAtblQ99gIE+LMELg281WfZhg/KqOlKMqRmdQ8+TBJscTCdSySvKAZJpiBMGsY3+lBpyE8eXbKpCWC7whzVZesMFiWcHW+SsV1CJP0se01LFY563iuTVEYMBZl+VSLojB4+l5SlJFxFP2/U+/MBB6313t0+umpzcE0HCzYyiicLJo7bDxMZQQGgGdbPL/UIB9kZLdEWGpUQMuoKsqxmVQ506rr0MpS0ryg2UsQBMeCiudshvPpdJLTgU5DeLLsJpOvu9QgSnJ818axhKwwpKag4bqPbT/OsFhFORUYuDJb3WYP2uKpPagoI+aw+n+n3pmpuDy1UKMVJViWPDHb8iiMK8JUy76Oh6l1YDDwYnWTDGOE+ZrHbMVBNARDUU7EJDqoMxUX17boJRmdOGMmcKn6NpWBctOX/fjQ6QWni73ux06Z7Cc5vSSjn5ZOjQt1n8ou5Y7VeFLOOr5rszTjs9KJiZKCqmex1PDxHX2PKcqTYKfeakcZ89XtDvVG4GBbwnNL9Qm1cn/GNYCnucPGw1RevSjNwRjyApbqPpcaZYhtmORcbJyecCRFUQ7HYt1HBBZqPk8vVKn7pTNyruoB+rIfFzq94HRx2PuxVV5uLFRZqJV/7xaOO66wWEU5LcxWXB60Ixq+y435Cg2//Hu28nhEkqIoo2U3vdXsxY8l0Z0GvTN0Yjy3VB9ZhIiWMB8PUxmBMQx9TYseq92IOC2wLCGwLa5qSKyinIhJjMhv9XwHnkPUi1lqBPiOtfmy13D30aPTC04Xh70fRxkp2hoWmxcFq52YXpxxY6FKlOYabaNMPb5jMRO4bPRj4rQs/z1f8U59Z0lRzgK76a2lRsBKJyJw7bEl/J6W6NFJTc0+60ylAyPOChxb8B2bxVpAXpRlVBVFORmTzJY8fMlf45Fi0pf9eNHpBaeLo9yPw071Gq633Oxza61HLXB45kIN27I0E7pyJijlxsGyLPKiwLYsAscizopJN01Rzjy76a164JDm3mbCz1HbcdNW2UNzh42eqXRg+I7FcqtPPXCYr3nEWc7DTkw/zfnocpO3XJ07lQ+wopx21roxhSm/k7zAsy1qvvPER+T1Zf9k0LmZp4tx3Y/AtfEdi+cvNjZHyYZotM12pmVUT3lEmGYg4FhCYQTHEpDBckVRxspeemum4o5Nt0wyelR1xOlgKq3UxbpPL8owhSFKM5Y3QpKs4OpcQJwUOodbUY5JO8pY60YYAxXXxhhY60a0IzUEzyI6N/N0Mc77EWcFrr09UtG1RUept6A5YaYTWyxW232SQYciyQpW231smUoTV1GmiknYEZPSZ6ojTg9T+XYPXJsbizVyY3jQivBcm6vzFRzbphY4Wl9XUY5JmKRYYuEO6lW7joUlFmGSTrppyhg4Sl13ZfyM835oMs+D2TqqJ4NKZ2pPnH5yU3BxpoLnltNGPNfi4kyF3KhzTlHGzSTsiEnpM9URp4epnEICcHWuUnr68oKG75AbSLKCy7OBzuFWlGNSdR1aWUqaFziWkBWGwhgarmZzP6vodJ3Txbjux7hq3J8lNCfMdFJ1HdLMUA/sTb0VpzlVd2pNXEWZKp60HTEpfaY64vQwtUMvQ2EJXItulGEJXJ4NCFxbR5UU5ZjMVFwu1H0sgX5aetIv1H1mtBydokw1Gm1zMBqlMp2o3lKU88Wk9JnqiNPD2N3TImIDLwB3jTFfLiILwA8DzwCvAV9ljNk4zr4D1+YtV+c2M9G6tmjJRUU5AUOv9kLN3+bV1pwIijL9aLTN/miUynSiektRzh+T0GeqI04PT8Jl9CeBj2/5+1uAnzPGvB74ucHfx0ZHlRRldKg8KYpyXtH333Si901RlCeBvmtOD2ONwBCRp4DfBvw14M8MFn8F8J7Bv78f+Hngm4+z/52lbK7OVfQhUhRFUaYeLdU2GTRKRVEU5fRw2nSh6ojTwbgjMP4e8OeAramgLxlj7gEMvi8eZ8daykZRRo/KlaJMHpVDRTk8Ki+KcjZR2Vb2YmwODBH5cmDFGPMrx9z+G0TkBRF5YXV19bHftZSNohyP/WRL5UpRjs9BeuuwqBwqynZUbynK6BmVzhoXKtvKXowzAuPzgN8hIq8B/xr4zSLyg8ADEbkCMPhe2W1jY8z3GGPeaYx559LS0mO/x1mBa8u2Za4txJnW/VaU/dhPtlSuFOX4HKS3DovKoaJsR/WWooyeUemscaGyrezF2HJgGGP+PPDnAUTkPcCfNcZ8rYh8F/B1wHcOvn/sOPv3HYtOlNGLM5K8wLMtar7zWH1eRVEOj8qVokyeYak2zykNtyjNWWlH5IU5FXOAFeU0oXpLUU4/x8llsVMXgpYtVUom8QR8J/AlIvJp4EsGfx+Zmu9wZ71HkhUEjkWSFdxZ71Hzx14ZVlHOLCpXijJ5Fus+SZaTZAX9JOP2eo84K7g8G+gcYEXZgeotRTndHDeXxVZdaIwhyQotkawAT8iBYYz5eWPMlw/+vWaM+SJjzOsH3+vH2Wcvzri+UMN3LaKswHctri/U6MXZaBuvKOcIlStFmTxbS7Xda/bxXZvrC1UqnqNzgBVlB6q3FOV0c9xcFlq2VNmLqXVPx1lBPXBoVNzNZcYYwkRHpRTluKhcKcrpYGi4xVlB1bMReRRC69qiMqkoA1RvKcrpZqjHtnJYPaZlS5XdmFoHhu9YdKOMXpJtzqeqeQ4VnfOoKMdG5UpRTgfD+cIPWn0cx+JiI9gcddI5wIryCNVbinK6OUkui+PkzlDOPlPrwKj5Dh+50yQrQASMAceCz3n+wqSbpihTi8qVokye4Xxhz7G5MlfhzkbI7fWQp+Yr2JZFkuXHGpFSQ1A5i6jeUpTTzWLd5+5GCJSRF2luDqXHturCqmeT5oa7GyGLdZ9enKkuO8dM7RDOejemANpRwkonoh0lFIPliqIcj/VujONYOLYgAo4tOI6lcnWGGBoEr6x2NRnkKWXrfOGK55Tz+x2L+63owDnAe93f4yZRU5TTjtqDijI5DmNTHDeXxW65M4yBjy23VJedc6bWgXFno08YZ1gi+I6FJUIYZ9zZ6E+6aYoytax0YqqejWuXysK1LaqezUpHDcGzgHZip4M4K8iLgnvNPjfXemz0EpYaPhdngkM5L3a7v8dNoqYopx21BxVlMhzFphg6MZ5bqh86EedOXXiv2WetF2NAddk5Z2qnkKx2Ih52IyyxKYzBEqEwaoQrykmIs5xWmFDzPQLHIi9gtR0xW/Um3bSJcZbC7rd2YoHN+ahr3ViTZJ0y7myE1DyXimuT5YY7GyFX56r7Po/73d+TJFFTlNOM2oOKMhkOY1Oc1IbaqQtvrfW4sVjbto7qsvPH1EZgpJmhGWYYyqQwhvLvNDOTbpqiTC2+bZEVwDDPkkBWlMvPI2ctYiHOClxbti1zbSHOigm1SNkVYwDZJocgxEm27/O43/0dJlHbiiYDVc4Cag8qymQ4yKY4sQ21iy50bZss326zqC47f0xtBIbnWPiexZ2NHlFWEDgWC3V/0wuoKMrRma16xHlBlBUkhcGyhMW690QiME5jpMNaN8YYWO/F27LbT2vEwkkygStPEBGemq/Q6qf00xzfsXhqvsL9VsQFx2a9F9OJMqI0x7aEZj/hLVfn9r2/x02ipiinHbUHFWUyHGRTnNiG2kUXvvlKg3utiGTgPJkGXXYa7dtpZ2rf7r5jsdKKaPZSelFKs5ey0orUEFeUEzBTcakHDs1ewu31kGYvoR44zFTcsR73tEY6tPspD7sxhYGKW7brYTem3U8n2q7jslj3SbKcJCswxpBkBUmWs1j3J900ZQd3Nvrc2eiz2o6JspwsN8RpzsNuTD/N6fRTssIQxhntMOXuRkjNd/a8v8dNoqYopx21BxVlMhxkU+xnQx0m+afvWGQ7Igdty+LGwvTostNq3047UxuB0U1SenGGofT2RUVBP41ZD5NJN01RphbbEj5xr81M4LHU8OnFOZ+41+ba3Hg922sDBbfWjUnyAs+2qPkni3QYhcc7TMvEcO5gCo1rC2lWEKbZsdo0aYad2LVuTJiUoxmnWfGfR6I0Z6Xd56PLLXzHouJYdOKEjWpKxS0TFHbjDCMQxhndKMN3LZ5aqNGLs33v7/D+K8pZopukdPopaW5ITYEr0OmndJPpdDQryrRwkE2xlw3V6qeHKo9qW8Lt9R413yVwLaK0YL3b4x1PLzA3JbnZxmHfKlPswLjfjggciygzNHwXsSBNC15a7RCluRrkinIM7jZDbizUSIvSk14LHOaqLnebIZdnK2M7bjvKaIUxvuNsJmpa60ZkVZ9rx9jfXrXDj9pZr3ourTAmzQocW8hyQ2EKGt70RixoJ/Z0s7wRcq8dc3k2IM0LoiQnNwbfFjBQmIJmmBAlOZYlOFYZQr8pL/NVvb/KueJOM6QwhmrgYAM5ECcZd5rhpJumKGee/WyKvWyoOC0eS/4ZpzkfW25xfaG2abfdXO2yNBOQ5YYoK/Aci/la6ayfFgfGqO1bpWRqHRhZVlCtuFRNOe/KsYWiKEizXL1ainJMulHGfNXDsh6F3hZFwcaYI5vCJMUSC3egzFxHSHOL8JgjaKOqtjETODiW0Isz+mmOZ1ss1oPHqjkoyqhY6cTYAjOBi0j53CZZTi/JuVD3Waz73FwLSfKChufScMvs7JYcX14UZZpp91IuzAR4Ttk5cGwhyRzaPZUHRZkke9lQa934seSf3TjdLI8KDBLyQpYXXNkSBWyMmaqKI6O2b5WSqXVgXJqp8PLLD3FtC9cpa39TCNcXq5pRX1GOST1wiNKCqv/IgRGlBfVgvK+KquuwGsU0+yl5UWBbFoFjsRQcL9JhVCUjF+s+0SCscWuyqPOcM0KTUY2O3a6lMQbPscgNDPOiCUJeGGYDh4ediKIonfauZSEYqn5ZPrLhjjdXjaKcRhZnfO6uhXSjnDwvsG0LRwzXFnUgS1HGwWHtgK02VF4UrHZj7m6EBI5FN8pobMmvFsb5Y3Zb1bUJ4+1227QlHq+6Dq0sJc0LHEvICqP6egRMzxOwhSjNma25YArWuhG31kJeWemRFDnPLNWn6sFWlNPE80sNenFKGGcURUEYZ/TilOeXGmM9ru9YNPsJL6+0+ejdFi+vtGn2k2PL8qhKRmriw+1oMqrRsde1nKt5eJYQxhlpXpBmBe0oIfBsotxQAFmR04szVjsRgWtTcW0u1P0jJ9s9TBI1RTntPHehTjtKaYXJtu/nLtQn3TRlytF35OMcxQ4Y2lBplvOp+x1WOxG2JeTAyysdOv2UfpJxa73HcqtPmObb9lMPXESY6sTjMxWXC3UfS6CflnbkcfS1sp2p7OmvdWM8y8bzHcIkox+nJHlOu5+SZcVUPdiKcpqYq3q84+kFbBs2wgTb5okkS2pHKTfXujQCj2eXajQCj5trXdrR8ULsznu1jXEZXVun5ogInmPhOTZr3Xisxz2LbL2WcVaw3ot50IrYCBPm6wELNZc4zenGKfXAxSrgpQdtNroxsxUX2yrDa11LWKj5iHCk51udUcpZwbdsAt8hyjI6/YQoywh8B986n45mZTToO3J3tpZGvbUest4r/x7aAbDdFljeCLm9HtLqJ9hiUfFsqq6D41jcXQ957WEPDLzt2izGwO31Hv0kI8kKLIE3X52d6kGkxXqpnxdqPjcWqsfS18rjTOUUkjgr+Pj9JuutMimKbRscETr9jAedeKoebEU5bQSuzeWZCnG1DA18EvJ0ez3k+kKNvIA0L6h4NvWgxu31kLffWDjy/kZVbWNUyUCfJAe1+SRTQPabmjON12qSDK9llObcXOvRT8vw9zQ3XF+0uTJX5cpcuW6UZHx6tUvFs2mGGWC4MhOw3k/58N0W1xZqR77OQwdKYQz3W2V2dAFEhOeWdORamR5utUKytECwcBwQLLK04FZLk3gqx2dUubTOGu1+SqufgkAvzniQ5AiGpwYJpLfaApbAnWbEJ++3uTpfwbEsVjsxF2cC5ised5uljec5FlGa49op91sxG72Et1yb29Rr05Kwcze0+tt4mEoHBsCHbjexLLhYDwCI8hyTGV5Z7U64ZYoyvUyqE5pkBY2Ki+88Okac5XT6x09yNIpqG9NowOzX5sW6f6L7O5yaM9wnPJqaM43XapIMr+X9dp9mmFLzHWwE2zKEccZcxeO5pTp3N0Jc28OxLDqDqSQYiHLD5ZmAWd89lqMxHoxuPWhHeHY5DSXNCm6t9bg6V1HjSpkaXl3p0o8zrsxVcG1Ic1hv93l1Re1B5fiMKpfWWSNMy+mN3TjHcywavkMnyri1FvKmK7PbbIH7rZia71BxnTLnReABNq0wZa7qkmQFri1Eac79Vh/Ptnn2Qo1ulGGMObAt04JWfxs9UzmFBGMoijKxmQEMBjGCWJDnmsBTUY7LQVMExsWV+Qq9KCfNyykfaV7Qi3KuzI+vdOthiAfKdSuuLac6UfB+bT7p/d1vas40XqtJMryW91sRFdcCA2lRcKHhU3UdHrT6wKP7udTw6EQ5piiwxNBPMqKs4NKcf6xr7DvlSJhn27iD50EsoRY4Y5d3RRkl/azAdizAUPZ5DLZj0dd3j3ICRpVL66xRlkZNEMAWyAuwLahX3M3ozqEtEGdl4sqlmYBOXNp4lhh6SUaYlDZemhs2esmmLsoN1ALnidieyvQynVIowhsu1bBtizjLyYoy5Ny2LZ6+UJt06xRlaplUJ/QzrsxS9SzitCBMcuK0oOpZfMaV2bEe9yCm0YDZr80nvb/7JTWdxms1STavpSkTe4nAxZmgjEISNkuoDq/rpZkKF+oeaWEIkwLbEuYqHou14FjXeLHu04szDGbTaZhkBUv14zlEFGVSXKp5zDd8jAj9tMCIMN/wuVSb3rBzZfKc91xaezETONQCt4ycyIoyv0PdZ6Hqbk5NHdoCvmORFYa5qstizaMw0ItzbBEWqi6fcWV2UCY8w7bY1ENzVU8HQJR9mUrL0ncsPvuZJS41fCqOhSCkecFs4PC5r7sw6eYpytQyqU7oXNXjs27MY9tlQk/bhs+6MT/xeY/TaMDs1+ZR3N9hx/u5pfq2qSfTeK0mTeDavOXaLAs1n/mah2dbpHnpxLvYKK/b8LpaInzGlRmqroPvCE/NVRAL7myExFlx5MRygWtzY6FKbsxmZvTLswG2ZanTSZkq3nFjAQfwBALHwpNyfvQ7jpE/SVGGaBWy3RnaEo3A5dpchfmahyDUB9MZt9oCsxWXXpyRFQVvuTrDfM2lHji86coMz11sMFf1Bte0LKs61EOBa5+pARBNcD56pjIHxmLd5+KMx8XZgFdXOvSjlMBzeP2lOZ5Z1ORjinJcFus+r6x06KU5RWGwLKHm2jx3cbxlVKO0LAv5lqtzuLaQ5oZenBGl+bGNhZMkqxwyjcmX9mvzMAcGsHmdkywfydzMabxWp4Grg6RnvTQnyUqZs21YaUfc3gipBw7X5qrkhcF1bD7zqVnirOBBO6JmWzw1V8G2rGPlqrk6X8UAnmOP/HlQlCfF227M8aHlDV5Z7dKPcyq+zXNLdd52Y27STVOmHM1d8DiBa/MZV2f5+HKLTr+g6tss1rzNyhpbbYHUwNXZAAYRhVcDl8Vr/mZC8bsDB/x81SdyMjzHZqMXE8ZlVOKbr042CncUaILz8TCVDozAtRFLCOOc1AiOY1MPXPppzr1mf+KjtooyzUR5wWo7Js5yfMfGngvGfsxRJ4A8isI4yNExjQbMXm0eOjFeXu3QjTLqgcPzS42RKdFpvFaTJnBtrs5XeXm1Q5jmCEKrn3BppsK87xClBb92a4MbizV818Z3bRDh+YuNTXkZchh52e1578WZOp2UqWWjl1DxbGYDD9fOqbo2Fc9mo5dweXayeZSU6WYUAyFnkbmqx5uvzvLyaodWPyU3ZpstsZstEKU5yxshH7y1QZzlmAKeWqhSDxzS3NDMC1baEa5b2m31oMypEbj2VF9zTXA+HqbSgQHwq6+u8+paSG4KbIEwy3npfpcZf+1MeOwUZRIsb4SEcc6VuQqOJWRFGQmxvBGOJQpjaBy8tNJhJnBZ2GIcnCTb92FLREZp/ljESStMeO7i6Dr1p4nh9b7YqHBtrhxxPwsGwjTTDBM+ttzCADOBy621HrkB2xYsy8K2Db0k59WHPX7d0/OkueHWWo9nLtTYOgv0IHmJ0pzlZp+XHrTJDDR8h8CzNyOs9P4r08qHbq+z2olxbKiKg2MZVjsxH7q9rvagcmzOm31wFHbaEp0o42PLLearHjMVd9PRM1yvHWU8aPY3c2bcb/XJckNmDK+/VF7PvDDUApcbi49yGSaD5OPT3NHXajbjYSonF0Vpzi+9tsZaNyLLC0xhiJOCVpzy0eXWpJunKFPLSiem6tm4dlmVwLUtqp7NSmf0maCHURKFgdmKW5aUbPU35waeZP5jnBXkRcH9Vh9joOLa2CLcWuttm3u4vBGyHqY4lkXVc3Asi/UwZXkwzeKsMe4qMzrP82hEac7Hl1sUBcRpwfJGxCcfdBAxtAYlhFv9lEbglE64wT2rBQ6rO2RyP3kZ3pd7zZAoLbBE6EYZeWHO9POunA8+vdpjrZ3Qz8pktP3MsNZO+PRqb9JNU6aY82YfHIXy2iTca/W5ud7jfquPY5WFFQoDdzdCmmGyaeNFScZ6P+H2RkhemFKP+TZ3myEP2mXFraIwFDtKp56FRJ6a4Hw8TOXVW94I2egkZHlOL8rY6Kc0+ylxWmayVRTleBhjiNOclXbEnY2QlXZEnOZjqce9tTM9X/MxlKWR17vxiRNA7iwRmeQFD3sJrSjlo8vNzY71k3TYnAbGWWVmq0Oq6tmbRow6MfZmrRsTp+UI02o3oh2nZHnBp1c6bPRiVjoRt9dDVloRjvXovi0Npn0cNmHqUNZa/Yyq71BxS7kI4/xMP+/K+aATpbT7GQ87CavtiIedhHY/oxOlk26aMsWcN/vgsERpzq31EFuEimvT7KU0wxTLgiQ3mwMjL692Nm28XpKzvNGnH6csN/uICI5lYSGsdhIALEuwZLt9Muz4T/PAiCY4Hw9T6cC4s9Gn4tkkeUGU5YRpRrefsNFLWKzpA6Eox2Wu6nF7IyTJCnxbSLKC2xvhWPLKbO1MB67N5dkAzxHaUXribN9bS0RGacZys4zsuDobEKXFphI0xhDtcNhEY3LYnAbGORIw7uiOs0icFfSSjI1+gi1C4Fpcnatyb6PPyw+65Hk5RbIdp5vhuAC2ZXFj4fDZ8YeyNnRQPuzGrHYi7rXO9vOunA8826KXZhR5gW1BkRf00gzPnkoTVzklnDf74LCsdWNqvoMgiAgGCFyL9V66aUu4dhnl59pClOY0w4TMlOW/V7sxy80+tzZ6pEUBg059zbWp+s62jn47SomSbKoHRrSazXiYyrd7K0xYavgYA1lusIw1THDLcxe1ComiHBd/kORRhM25iot1v0wcOOpj7ehMlwkmA153sXHil/vWEpEP2jGeY3FtvoJj2dQ8Z7NjPVfzuLPeKx02jkWSFdxZ7zFXO5uJgEcxErDXNJFxRnecVXzHKkuYIptZ2gPX5tJMFRHoJTnzVY+nF+vEacFH7jS5td6j00+4Ol/dtZztXsdJc8Ns1WW5GZJmpSEpmDP9vCvng7rvMF91sCyIM4NlwXzVoe5PbZo35RRw3uyDwxJnBTOBw91myM3VHu1+QhiXleSGg11pbh4l5wwTLjR8aq7DvVaMJULVscjzgjBO8RwLS+C5iw2eX6pv6+hXHItGxZv6gZG9ys8rx2cq3+6BZ4PAYi2gGcWEcRm69PRijauz05voRVFOA88v1WmGKUle4NkWc1WXYgwDDuMs6QmPSkSmaUE9cMgLSPKcy7OVzQRKvm0xU/FohjFRVhA4FnNVD3/LyN1ZykJ+0lKn+1V3GXaShxm2Qed5HsRi3UeA2apDVhjCuHT2PLNUpeG7vPPZRaI05+ZajzDO6Kc5SVpOnRSRbcnSDjrO3Y0QAeq+y3ovopcUXJ7xWagF2553RZk2lhoV7q716KcZqSmQwqLh2Sw1tAKJcnx82+JCIyAtykgMyxIuNPR9iTGsdkunRC/KiHOL+60+b7w8s+noSbKc55carHVj1noJRV5QFIa0yAn7hiS1qPgOr7s4w/ODTv2Qrf9+ZbW768CIJsBUptKB0QhcfNcmyXPStMCyhIprUXXdcx/apSgnwXcsmmHCw25MN86o+w6uLWOZQnLSzvRh99/sJ3TijJrncHm2QuDamyMq7X5K1XOwLIu8KLAti8CxNqMGzmL97pOUOt2vHNhhHFJnyRk0CgLX5vmLdX711gbGGBqBy6WZgI1ewvxA5pphQiNwafguaZ5jGEa25BTGPdTzOLznH7/X5tZGj36cMVtzqfkOVc/RKBllqql5QjToZMZ5QWEbIs+m5snBGyvKXgyqlrX66abOmq2MZ0BnqhABDL7tUJtxqPoOeZ6z3kt4dbXLpdnKNp30sbst8sLguzbPLdaJi4KG71DxDtY/ew2MxEnGr9xc21YOfhx2qnJ6mUoHRuDZ9KOMKM0JXAcEBEMzjFkPpyusSFFOE7YlvP+lVXpxAYO0mq+tdvjytz81luOdpDN92P2/5ercphPCHeT1GHas77f7BK7NwpYpFGGcEaZlMmCt372d/cqBHeSQOovOoJMSpTmebfHMYo00L0jTgo1ewuXZCjNBORc4SnNcyyItBlVILAvHFvppvvlcHuZ5jNKclx90iLICz7WJU7jfipipuJvPu6JMIxtRSrMXYygTLRqg2YvZ0CSeygnwHYvCwOXZR5E8SVbgql+Mp+arNMOUVj+lFSY8tVDDsoSrc1WS7FF0RC/OePPVWdZ6CVHWwXctBNksn5rnZl/9s9vAyMNOn9vNsgxrGGfEecGn7rX5wjdf3navlLPNVMZB5UWBMaWiwhZsEWzLKsvQNaNJN09RppZP3WsTZjmeI/iujecIYZbzqXvtSTft2OyXQKnquRSmIB3khEizgsIUVD0XOHleh7NWVvSgJKD7zfPUJJ+Ps9aNaVQ8nr/Y4PJshYtzFa4tVLnY8HnuYgNLwBjIjdk0zBxb6CUZ7X7KzbUea92Idv/gjtqHbm2w0U9xRAgcG8cSlpsRL9/vbD7vijKNvLoaElgOjm1jITi2TWA5vLqq5S6V46PVI3bHdyxsy+LKXIW673B1rkrgOQSu/Zhej7NyCu/l2WCQiLpALGj4Dhayzd7ayTBiM8kNK50+G70ES6Ddz8qcG4OBkpnApRvn/PdPrU69jaUcnqmMwKi6Du24NMRKj1yBiIVlw4Nmf9LNU5Sp5dMrXZZqPhX/kULpxymfXunyBW+6NNZjj3N6wV6RHjOBg2MJvUF+Ac+2WKwHm1EGJ8nrcFDEwTROpzhJ3pL9ojfOK8NrImJtOiiMMdsiWhbrPi+vdllpR6y0+iRFaUhfnQ3oRCmdMEVs4cpcZd8Q2k+vdLnY8BCxymiP3NAIbDb6GTPBVJoCigJAt5+SUmCLDAa1DKkxdA/h2FOUvRj3NNdpZaiTwjjjzkaPqldOB3l6sQZs1+tDGypwbZ5dqnM5zWn1U7LNJPHBY3YBbLef5qsudd/ZdB594JU1BEPFsXAG+Ujmqi7rYXJqo2On0d477Uyl1eIPRvDCLIO07Fg4lsEYizjPB1NL9MFQlKNijMEY2bFMxp5bJkpzXlnp0EtzisJgWUIrTHjuYmOssrxY94k2Qhbr/rYO+XCE5SQd9sPkixjXdIpxKcuTGHSa5PNxDntN4ixntVNe8+WNkJmqx4N2RJJBkmfMVTw+eHODd7/uwp73whhDzXOJsoKa72BbQref0o2ycz+iqEw3nmPR7MeI2FAUYFkYk2s4uXJixj3NdVoRY0DAs2yyHITtOgzKcqftfspGmLDUCJituHSijJpn89SlBrZl7RnRsp/95FpCu18wW32k67KcbfnLThOTsm/POlNpOcZ5wWzFxrdcMlOQDmp++5bFQt1neUPDBhXlOLz+UoNWlBAlOUVRECU5rSjh9ZcaYz3u8kbIepjiWBZVz8GxLNbDdOyyfFB97mBQVnal0+eT99usdPqHdgbsN/1knNMphiMX46qbftxyYBqO+ziHuSbLzT5hnHFltsKbr85yZb7KzdUOv3pznW4cc7Hh06i4rHbjfeXl9ZcahGlWjnYZQ6ef0ktSPvuZBTWilKmmHjhQlE66QspvisFyRVFGynDq442FGm+9PseFhofvWGz0YpKsoB2lRElGYWC+5jFbcfnEcotPr3SxrFLvFYbH7K2t7Gc/ve5Sgzgvq3EN7dRukvLUQvVUDohMyr4964ztTotIICK/LCK/JiIfFZFvHyxfEJH/LCKfHnzPH3XfzV7CO64vIFaBI4LnWswEHrZdGmkrnfM7p1pRTsJn3Zjn2kKVJCto9VOSrODaQpXPunFkMT0SK52Yqmfj2mWH3rUtqp79RGR5vw75MJLhYqPCGy/PcLFRYa0bH8oZsF++iJPm1tiPg5wjk8rLcZCz6DwyvCZplvPawx531nuIbH8uHrT6VF0H17FI8oKsMFi2TaPisliv0I5ykrxgpuLuKy9D2TYGLEuYrXi8+doc73pucdynqShjxUFYqHn4g9wuvmOzUPNw0GyLijJqhvZLlOY0w4Q0L2iGCaudGEug4lg0Kh7ewNbpxjmXZitcqHlcn6/h2RZX5yr76v/97Kdnl+p85vU5krxgvZeQF4anFqpcnK2cygGRSdq3Z5kDHRgi8jcPs2wXYuA3G2M+C3g78KUi8m7gW4CfM8a8Hvi5wd9HQkRwHYtq4OI65cNvjMGyLCgKLaWqnEtOIKubzFU9fv0zi1yc9al4DhdnfX79M4tjL09lTFkCb6UdcWcjZKUdEaX5xGX5JJES+42uH5QM8yTs5xwZRXTGSRwgx43emDSjkK39MJTOnGeX6hSF4cWb63z8Xpu7G2H5nAxuZ6ufslDzQQxxWtCKEh52Il5d7eA71r7yMinZVpS9GJVcOY6F7znYYigM2GLwPQfnFI7GKsqTYJw6y3csulHG/VZEYUq9nuZms9zsVhukGSZ4jkXFs0kLc2gbaj/7KXBt3nF9gc99/gKXGgEVz2Y+cLk2VzmVNsVptW+nncO83b9kl2VfdtBGpqQ7+NMdfAzwFcD3D5Z/P/CVh2jDNmYDh0+vdAgE0jwnLwxxVhA4Fp9eDZmreWcu+7+iHIJjyepWojRnudWnKAYlxApYbvXHLj9zNY876z2SQc6GJCu4s95jrjbZzlWcFeRFwb1mn5trPe41++RFcahIif0iDsY5nWI/58hJp66Me3rKKebEsrUXW+9JnBWs9RJsy9oMwS2KgmaYkuYFcZpTmALHgoedmNtrIWGc0umnfPJem8ouydCGRGlOL854y9U53vPGi7zl6hy9ODsP924bahucKkYiV54Nq52IblyQZAXduGC1E7GPOCjKWWdsOmux7rPaiRAY2EcRuSm4OldGqG6ECd2oLI06tKGWW31W29GhbajDRGx6jsWbrs7y7IUaOfCx5RbNMBnFKR6aw+iT02rfTjt7OjBE5I+JyIeBN4rIh7Z8XgU+dJidi4gtIh8EVoD/bIz5AHDJGHMPYPB98aiN9j2HLCvYiHKKAorCYIyhFSZkRQ6FOa9GtnIOGYWsDnl1tcvH7jbZCGP6Sc5GGPOxu01eXe0evPEJ8G2LC40AsUqFkBQ5iMVqO5647N7ZCDEGKq6NMeXfh2WviINxTqfYzzly0qkr560U6ihlay/2Gq3qJeX0JSPCRi+mP3A23G9GLNQC3ny1gWsJYVpQCxzmaz6tMN1VVqI056PLTR60ItZ7ZXLXs37vduMcO+BOFaOWq1aUEacFWZ6T54YszwcRStnoG68op5gnobMC12auViY+f9CO8QbJvBuBiwGWGgGrnYhOP2WlHfHCq+vcb/aZq3lHsqGGdtLVuTIZ73Kzv/m+XuvGFAbWezEgzAQujmXx8eXWE3ufH1af7LRvxYILjQDf1gixk7BfhqMfAn4S+Btsn+bRMcasH2bnxpgceLuIzAE/KiJvPWzDROQbgG8AuHHjxmO/21aZmb3iOhhjEEvoZzm2KZXZtcH8K9ievVazCStnkCPJ6n6y9bHlFt04wxZrM8lSbgo+ttzizVdnx3cGIjy3VKfVT+lEKc0w5fp8BcuSTaUwkSkHxgCyGcJffstg+ckYV3bz/SqFnLQSyDkshToy2dqLrfckzgoqrk03zmiFCTXPYbHmYQAE6p4DdcFgiJKM3AjNMCEvhEbgkPO4nhsaWVFalOsYuN+KuDwb4DvWWb53j7FfZnu1DZ4oR7Yv95Oth50E1xY8xyY3BlsEYwoedp7saKyinALGrrOgLEFf9x3SwlBxbUSENCvwbItG4NCLHVY6EXGa47s2czWPdphi14Wj2FB7laNPcrMZpbgRJiR5gWsJYskTe58fWp9ssW+HleFmKy6FziA5EXtarcaYljHmNWPM7wWuU+azuAlYIvLsUQ5ijGkCPw98KfBARK4ADL5X9tjme4wx7zTGvHNpaWnbb75j0Y5yHCArDFhg2xY116GXlqOO40qQpyinjaPK6n6ytdKOiZIcy7LwXQvLsoiSnJX2eEdpfcfCtiwuz1ao+y7X5qoEnkPg2mMfKd43BFCEp+YrWAL9tIyUeGq+AjsSLY78uCdkr8iPk05dGWfujtPIKGVrL7beE88W+knO+qDUrutY5AZqvo3rWLSjlKtzpeOh3c9wLeH1SzNcmgnK0uJRSnvHqPPQyKp5DnkBhSnnKn/kbovbG+FInHHTwjiT5yqH5zj25X6yFWc5lghiWTD4tkSIs/PjnFMUeDI6C6DmO9xeL6fV3t0I6UQpSZ4zX/NIc0NuCq4v1Li+WONtT83SCFwyY1jvls7G2xvhoeyevaI+wySl2U/Z6MUYU5ZQTXOzqw4cF4fVJ1vt26cXa1yerWBb1pm1m54Uh0ni+ZeBbwb+/GCRB/zgIbZbGkReICIV4IuBTwA/DnzdYLWvA37sqI2u+Q7tfgqWEOc5nSihFcYUQF7ApdnKuTKyFQWOL6tbcR0hyQytfsLDTkyrn5BkBtc5eYd9P7Z24uIsx1B2rocJBsfVyTgoBHBciuekoezHdX6cdOrKeS2FOgrZ2out98R3bLKiwLGFXpzy6sMurz7s0u3n2CIEro0gzAQermMxE7i4ThkpZYC5qk+YpNv2PzSy5mse692Ij9xtcr8Z8rAb0QkT+oPkrueB8+aAO+2MSq7qgUM/KcizHAtDnuX0k0LLqConZlpz5oxTZ0VpXpYANeUU/lsPQ+6u95irulgiJFleVs6yBc+2sMXiYiPgymxAnBUDHeYeyu7Zy0lQdR0edmNWOwkrnYgHnYg4K3bVgePisPrkvNpN4+Ywb/ffCbwD+FUAY8yyiDQOsd0V4PtFxKZ0lPyIMeYnROT9wI+IyB8CbgG/+6iN7sUZF+set9d79OKMJM1xXAsMvPPGPFfnKtwdzLFybSHNDUmWa4ioctY5rqxucmWmwifuNbnfLkuFBq7N5Rmft4xz+gjbpz0UhSG3DJdng82O9bg6GQeFAC7W/bG8S04Syr5XSOVhHREnmbqy3/SUM86JZWs/htf12nyZB+NnP3afVj8lcC3y3GAGURizFZfVTlSWU83KhJ5RbnFtrsJ8zQUDVXe7Wt9qZLWiDEeEQsARC8ex8Wzr1E2haIYJL6926EYZ9cDh+aXGSKqljEuelWMzErm6UHNxHItmPyYdONxnKj4Xau6o26ucI06qayfM2HTW8kbIephS8x1ed6nBlfkK95sR95sRr7vkbtoIaW6Yr3ncWuvR7xTcb/dBIM48Ls3WKIxhvVeWX72+UN2sMLIV37HoRFnZ18vLKSo138F3LCquRS/KyHODJUJWFBTGPKYDtzLMnzGcyrHbMQ/LYfXJObabxsphHBiJMcaISDkNV6R2mB0bYz5EKTw7l68BX3SkVu4gzgqMJfTjjLwwiGVhCuglKYkp9GFRzivHktWtxEXOg2aKKSw8G0xm8aCZEhfjH3UYyu1QKVgiGGOO3ck4jKI6KKfDuN4lJ8klcdJ5/CdV4OPK3XHKObFsHZb1XkLds+nFOcYI7Sil3Y952I2Yr3hUBsabZVvMVV0uz1bwnTK/Sc1zsKQc1Rre35rvsNaNWe8leLbFzCBC8eKMj4XQjVJsa7wRVkehGSa8eHOdmu8yX/WI0oIXb67zjqcXTuzEUNvg1DEauRKLOE0xCJYFBiFOUxCNrFGOz5TnzBmbzlrpxFQ9G3eQhNK1LSqexcNuzOsulT6SoR1nTDltMclz2v2Euu9wr9lHRDBFQc13KQblj+9uhCzWfXpxtqm/bEu4s96j5rsErkWUFmz0elyeq3BppsKFekCYltENIuBYwkxld8flqB1SR9En59RuGiuHcWD8iIj8U2BORP4I8AeB/2u8zdof37G4udbDiOB5FhQGI2CKgptrPUAfFuVccmJZ/dS9NrNVl4pvI5Rh6f0451P32mNo7u6MopMRpTmvrHTopTlFYbAsoRUmPHexsW0/h0lqOY53yUmSaZ7E+THlI0qT5InpwdtrPbpxjm1Du5+w1ivz0szVCp6/0EAsoRdnvPnyDIjgOxbXF6qkuaHTTzAiuFvu79ogn8ZqJwaB3JTOC9+xMcbQjjIunqIpFC+vdqj5LlW/NE+qvrW5/LOfXjzx/tU2OFWMRK4etCKwHBoB5IXBtoS0GCxXlGMy5Umrx6azjDGlcUiZf2alHYOBwLG3JV2/Nl/lo8tNHNvi4kxAmhVUPAfbgtvrPeq+i+vaVAa5zuI054O3NqgFzqbd1osyLs4EZIUhygp812KhVmO1E3FlrsKDdunYd+wyiWg7SvecmjEOh5Tqk8lxoAPDGPO3ReRLgDbwRuAvGWP+89hbtg+LdZ9mmCBiMDmkRZl12nMdNrrHzzo9ytAiRXnSjEJWm2HKXM2h1c82p5DM1Rya4ZOZUzhkN6VwFPncGuLoOEJWGNbDlGAj5LmLj6IoJxVSfpLjnsT5sdYtE14NS2kOR+2nZERpYjxJPbjWTejEKY3ApTbrgIHlVp9OP8W2SgeECHhuOa/4fivadPSJJax3E1572AMDF2Y8FqvliNb1hSoX6j5rvWQzuqmf5AiMbC7uKHRoN8qY3xFpEbgWG+FoKkqonj89jEquWv0UKOjHBZkxOCI4rjVYrijH46RVuybJOHXWpdkKy80QkXJgKMsL1roxc1WX9V5MzXNYbvbxHYtulDETuKSF4cpchY0wRUQG+SrKiiFvvTYHwFovYrUTM1v1Nu221U6MvSOqwrEFEdnMT7bRS+inpS67sVjb831+mhxSqodOzqEyHA0e+ok6LbYSuDY11+FhO8b3HCpu+TBHcY5TO16IqY5MKmeBk8pqI7B5ebXPfN2lHtgkuWG5GfP8UmWErTw6R5XPx0Mchapns9KJtzkwJhVSfpLjnsT50e6ntPop/mDUIysMD7sxsxWXa/MnPq0zzZPSg4bB6NZmpRthLvAI05QwLqj4NldmAwoDtlVGX1ybrxKlOR+92yJKcypemezzQSsiSnIuNgKeXaqXIbo1j26c0ulniMBnXJ0dyfM+Kh1aDxyitNiMvCj3PZqEjKrnTx+jkKvcGKK4fO5dY0CEfpyTn6MKO8romfacOePSWVfnKvTTnDDOeNgpHeiNisdTC9UyAqMZEqcFb746y2zFJckMd5sh1xeqXJzxediNsUWwEBoVd/Pd+6AZ0wicbXab7wgfv9fmXc8ubtosdzb6LFZdkizHc2wuzwab9+bq3N626mlxSKkeGg0HWgQi0mEzWGiTFvAC8L8ZY14ZR8MOYnHGY7UXISJkmQExiAWNaumlO6p3a7fQojjN+ehyk/mqrx4y5dQzClm9sdjgI8ttHt6LSAuDawm1wObG4sVxNPnQHDX0b2uI46OFg+U7mFQI4HGPexLnR5hmWCLbDIQ0KwjTJ1N2bFp5knrwQsPHmIK8KEgLsCxhpmLz9IUqF2Y8PNvGDP7bakyvdWMyY/BcG88pn4WauHSijHqQEbg2i3X/yMkxD6tLRxWe+/xSgxdvrgNsznnuxSnveHrh0PvYi7VuTD/NeWW1Ry/JqHkOV+YCjUCaEKOSq8CzsKyCNLfIjcEWsKyCwDv9I+XK6WWvd+Y09APGqbMC1+b5pTpr3Zj7rT413+PyXIA/0DudKMOyypKn8zWf+60I17F42Im5NFthruLx7GKNlU6E71qbuc7SouBCZXs0oIiUpb6HZ2LK//mew0LN23Zvrs1V99VVJ3FIjTJiYpRTWc5zJMdhhjT+LrAM/BAgwO8BLgOfBP458J5xNW4/npqt8bAd0+qnWI7gWILvOsxUyuklwwfksN6tnaFFUZrzsBuTG6MeMmVaOLGsWha4loXrFFiDucSuZWFN2A48aujf1hBHxxay3BCmGVfnzkYn5bjOj6rn0gpj0qzYvC6FKWh4Ws7rAJ6YHry+UCMrzODeGBq+TbOfcm2uyqWZgNVOTC/OuLFQ5eoWfRRnBQ3fphPlZEXZiRs6Oaqeu2noXGxUuDYnm/kxAtfeU6cdZaRoVOG5c1WPdzy9wMurHTbChHrgjCSBJ8BqN+blB2WOjdnAIc4Mn7zX5vlLDXVgTIaRyNWc7+G7DlkONmXwku84zPknf2aU88tx3pmniLHqrKEN0o4yWmGMRTktMRs4BZYa/uZ6l2cDwPDKao/Fhs+lGR/bKp0bFcfaHIj5jGuzZfWSLfZJlOa8+coMItBPczzb4qn5Kv1k+73pRBkfX25xfaFGPXB21VXHHfwZdcTEqHTleY/kOIwD40uNMZ+z5e/vEZFfMsZ8h4h867gadhDXFisstwNEbMIkw7ZtFqoOM4HFJ+61uTZfPZJ3a2doUTMs5wkHro2ITFv2YeV8cmJZvbXe49JsQJwWRFlB4Fj4rsWt9d6xGjQq7/BRQ/+2hjgmgxJb8zV/3/DC88BM4OAMkkAOjYHFevCYMlUe44npwa3PbmHKZ/faQo3ZwKEw5e97lZsLPAfXsQmTnGiQlf3STMBM4Bx61GerzG6EMTOBdyhdOsrw3LJ8c4W4Wr43RmWM3W/18RybyuB5r3iQ5gX3W324Xs6hOs8jWhNgJHLl+RaX6j7dxBBlGYHjUPcEz9cIDOX4rHVjClN+by3hOSX9gCeis3azKS7NBHg73pmWJVydDbAE+knOTMXi+aX69giJNKcwbLPbluo+V+aqNLbkwEiygjCNqQeVTd3UizNqvstaGNMdlFwVygiO55bqm9seZ/Bnp+4sTHFg+df9GJWunPIqOSfmMFerEJGvEhFr8PmqLb9NbILhU3M1+nHBYs3l8ozPQtUhzwsuzVR59WGPvCi2re/aZdKYvVis+yRZWYrHGEMvyihMwfyWnBoH7UNRJsyJZTVNDc1ugm1ZLNZcbMui2U1I06OL+tA7XBioeo+yU0fp0RMm7ZTPJCtIsnzP5IPDEMercxWWGgFX5yqPKcvzyGLdx5Ly+8ZA8Q7/VvblienB3Z7dN1+Z4bmLDZ5bqu85urJY96m5NllumKu4XKz71DybuZrPYt0nzgpce3u51J06bafMxknBWjfaJrN76cGjyuhejPK9sRNbBEsgK0w5WlgYLCmXj/vYyq6MRK6W6hWSwjBbdbk+X2W26pIUhqX6+XZYKyejHWWsdSOMgYprYwysdSPa0VRMuXwiOms3m2KuVuqiJCvoJxm310PiNOfpCzUuNkqnw26d/t1039ufXkCEx/RK1XO36bMkLxAxLG/0N++XLcKttd6J399bdWeU5txv9bFFEOFYOmJUuvIwOv0sc5gIjK8B/j7wjykf+l8CvlZEKsA3jrFt+9JLytI6H1tu0c8K5qseb7hUJzcFs1WX1U7MjcVHp3eQd+ux0CLPYibwtgnYtGQfVs4tJ5ZV1xV832G1G9FNcuqezVzVw3Xl4I13MErv8HFC/w7raT9PI66TSlp6BhibHtzr+TuKjAz3IYPpXp1+iudYXJ2rcnWuQuDa+I5FJ8roDUanPNvCsYU4y3lltRwVitN8m8zWAoc4LdjoJVwZRC/tpQdH9WyNc1Rpoe4RxjnpoCSf51jMVFyqvj32Yyu7MhK5qvoWzyzWeW21x+pAbz2zVN+WCFZRjkqYpKS5IUwTksH7wrWEMJmK6jZPpO+223v/+aU6UZrz8mqHmw9DAtfmdRfrVDxn0wHw8eU2i3WPS7OVTR21dX87j7FTr6x14236rNVP6PSzsjTr4P0tllALTh4xszViYqOX4Nk2CAT2I11xlGOMSleelqSkk2JfB4aI2MAfM8b89j1W+YXRN+lgojTn1nqPext94rzAFehFKZ+616biOTx/oca9VkQy8E4dNlHLVsGJ0gp3N8Ij70NRJsGoZHWxFvBLL61iWzaulKF8nX7MZz41d+Q2jbpk1XFC/w5yTpzHOYRat/xojFMP7vf8AYdyrG3dx3zVpe47m7pq6/q2Jfza7XUcy6YROBjgQbvP26/Pbx771nrIMxdqDIMz56oeNx/2uNfqE2c5liXUXHtbJZ+tjOLZGmepu2GC0LrvEtQeJQh9fmlu7MdWtjNKuaq6NrfWQ4wFdV8wArfWQ9761OxoGqucS2wRVtoxtcDBH4xsb0QZz1+sTbpp+/Kk+2473/tbc4eEUUaY5nx0uc2FhkeS5PSSHEsE37FZbob00/zIEbI13+FT99vUfLdM9uzYfGi1yTMX6txeL7Ati4prc32hcuKIhK3JP+Msx7Ut0swMcnscT0eMQldOe5Wck7Kvm8YYkwOf/YTacmjWujHL6yHdNMe3bQyQFoZmP6MbJVR9lxsLVSyBMMmxhCN3SIYP10n2oShPilHJarufMF+r4DkOBYLnOMzXKrT7yZH3NfQOb+Ww3uFhp+yV1e6xQ7gPEw6+dcS1zHVj4Tmlt19RYLx6cK/nb7nZP/RUhsM8w80w4QOvrlEYSPOcVj/lXrPPlZkqWWE2t6v5Dqs7nv2sKHCHIzwGjBw9GusonOS9cRDDBKG2DRthgm2zLUHoOI+tbGeUcvWgHSFAUUCcld8yWK4oxyU3psznYFvEudnM73Day/NOuu821En9NOPV9ZB7rYg4zXhlpcudVh9EqPoOnmtT81zCONvT5trLjlvvJVxfqOG7FlFW4LsWV2Z9eoOKasNKXdkI3t9b+4NFYchN6bwY9gcnpSPOez/1MFNIXhSRHwf+DbCZyc8Y8+/H1qoDiLOC9TABDHM1jzzPSQvoxglrvXTX0afjoCOVypRxYlntxhmLDZeZwMOxhKwwtKOEbnz0OZ/H9Q6PKiriMOHgOuKqHJKx6MG9nr87632eWqgdairDQc9wlOZ8fLlFURiWGgGFKecTQ2nkbR2dWmr4vPawtxl5uNKJ8ByL5y8+Kh2YZMVYp1SMe1Rprurx2U8vTuTYymOMRK4edGI8x+LCjI9rQ5pDO4x50FFHtHJ8qp5LmsXUfG+zKkacZVQ99+CNJ8/E+m5xVmAJfPp+h7mKSzfKMcaw0omYrbh0+gnX5sspiY4tJLnZM0piLzvuznqPZ5fqm8k97zX7PLPU4EE74vJMBccW+knOaicaSQnuYX9wqCMskc3yr5PUEee5n3oYB8YCsAb85i3LDDAxB4bvWOS5YbHhYYwQGYNDwVzgYYw5Vx4oRdnCiWW14TvUPIcoLegnZej65UYF6xiDrsed5zeqeeiHcU6c9zmEyqEZix7c6/kTkV2Tc+3mWDvoGV7rxhgDM4FLUZQGI45Fp1/QiTIuNB4lDrMtixuLtc0RnSwreGqHzI7bwTfJPC2aI+aJMxq5yg1LMz5FISSZwbOFpRkf8tM9Uq6cbqa8atfE+m6+Y7Hc7MNA71Q8h/VejO/YpHlBxXfwnfIaZoNqI3vZXHvZcSKyTe8leUHg2lydr2yWXHVtoVEZbU4z1RGnhwMdGMaYr38SDTkKi3WfpxZr3FzpMF8PmK+6RElOkua85ak5fZCUc8koZPUzr8/zgVcelvPtPZsoyVnvxXzOcxeOtb/jeIdHFRVxGOeEjrgqh2FcenCv5+9iwz+0Y+2gZzjOCqq+jWWXCcjAxrLACGRFTs1zHhtJGupQ37EodvQBn4SDb5KjSud5ROtJMyq5evZSg08tt1ioV/BdIU4N690+b7iqOTCU47NY94k2Qhbr/rZ36zRU7Zpk322x7vPpBx0cp4ziFWAm8HhqvsrN1S4WQpLlYCBMM+YHlbJ2Yy877mKjrOQBA4cGpdP9+kJ1W7TgcQbfDkJ1xOngQAeGiATAHwLeAgTD5caYPzjGdu1L4Np86dsu829+OeXuRkiaFTQChxsX6nz+G5Ym1SxFmSijkNV3PbvIWjfhpZU24XpO1bd53cUZ3vXs7iHXo2SY+OlBq4/jWFxsnGyO4WGcE+pNVw7DuPTgXs8fcGjH2kHPsO9Y1H2XOEuYr3n0ooxmmBK4Nm+61OCl1Q7NMGWu6vL26/Pbnn118CnjZFRy9QVvWOJhO+JOMyRJMzzX4am5gC9Qe1A5AdNsH0yy7xa4NjcWqtxvRTzoxNR8h6WGR1HAhZkAz7F4dbWL51i87lKDK7OVPRNWH6SDhvdmse4TJdmpmdqhjJ/DTCH5l8AngN8KfAdlaZ6Pj7NRh+FSowIitPop/SQjKwxPFQUYeGW1C8aACHGaE6blnLWZwDnTJRKVc8+JZTVwbSyB19ZCNnplh+cNl2bGLjNb814s1D0+vtzmtdUe1xcqLNaDzTrjdzfCTSVX8x16cbZnlYbDGh/qTVcOwdj04F7P31EM592ywA9lJU5zHrT6GBF6UUo0mGt8dS7gtYc9Fmo+izWPlXbCf/n4A97x9DzPXigzwh/VgB93SeJR7L8ZJry82qEbZdQDh+eXGptJPJ/EOSjbGIlcXZ6p0E9zXl1tb97XxZrL5ZnKiJurKFPDRPtuV+erGODiTEA3TlkPU9a7MYFjM1/zuDIT0I4zbq+F3F4LqQ2m61giNPvpZlWSwLVZrPt87F6Lexv9TafHTnzHYqFWpRdnZbSuKadiLjf7I3+PnyUdMc3nsqcDQ0QcY0wGvM4Y87tF5CuMMd8vIj8E/PSTa+LjRGnOj3/wDh+63aQVRoOa7hnxawVPL9T44rde4U4zIslybEuouA6tMMaxhOiMl0hUzh+jlNX//qkVfuLXlnGAhapNnhb8xK8ts1jz+KK3XBlL++FR3ovCGJphykLN4+5GyIfvtLg8E/O263Msb4T00pyiMKSFoddPee5ig0bg7Jno80k7J56UMhjncaZZoY2acenBw5T3Pc49iNKc5WafW2s9HMfC5AX32xHdOCdOM1a7CQ3P5vPeeIHVdkonSojzgvVeQsWzqfk2rz7s4tmPHBWHlaFxlyQexf6bYcKLN9ep+S7zVY8oLXjx5vpmJZLzWFZ5Eoxarn7yQ3f5xZfW6EUJqYE0S/jFl9b4jCt3+frf+LrRn4ByLpjG98GT6rsNdc2DVp8kN7iOMF/xmKm4m9NBkjTn5dUe3STDsYSFmk/FtbjfiviV9T7XFgKStGAjTLk043NlroItFhu9mGXX5rmlenmcjZCigGcHf3/yXpuXVzrUfZdr89VNG3BrnrS7GyGebW1GbYzqvk3jM7EX034u+8Vk//LgOx18N0XkrcAs8Mw4G3UQy80+//mj97i/HtJPC7LM0A4L7m6E/JdPrdDqp9R8hyyHKC2o+g6+U47WaolE5QwyMln9iQ/fJYxS2knGajejnWSEUcpPfPjuCJv7OPGg6sFGL8EY2OiniCW4joXYwi++/JD77RjHsqh6DmFc1hLf6MWnpvzpYcq2nobj7Fei9kmdwxQxcj140DUedrJvPuzR7if0k3zPe7D1Xr6y2uWVlQ5r3RjfsdjoJby82sOYMkP7K6shDd/GcSx+5dUmq92YKC2414rwbKHdz3httced9RBjOFCWdj5HywNDaFwliUdR8vjl1Q4136XqO1iWRdV3qPkuL692RnYM5VCMVK5+5IVbPGwnpHlZQjXN4WE74UdeuDWi5irnkSl9H4y97xalOS+vdlluhhigGcY8aMasdmL6Sc4rK50yYqIdYTA8aPV5eaXLh26tc3u9Tz/Nma3Y9JOC2+shlhiqnku7n+E6FlXX4UGrD5T3oJfmOLaw0on51IMOYZKz3o3pxTn3myG31kPutfqs9xKWm/2R3bfdbKUpfSZ2ZdrP5TBTSL5HROaBvwj8OFAHvm2srTqA22s9bq2H9HMwOeSUqXXJ4VP3mnSilNmKR24eleVxbNnMSqslEpUzyoll9dXVkGYvoqBMvuRYgoXh6EVUj4bvWHSjjLvNPqudiNV26dU3QJyWyxu+w8WZcipnYQyNwOFhN+HpQX7RScv2qKqnjPM4B3ncn9Q5TCEj04P7XePFus/Hlls4lkXFs8kKw1ovYbHmPXYPdt7L2+vhZim6JCuouDaObfHKwy5RkvOwF9NPU3ynTNrpOsJzF+rca0c8tITAdbClzAr/sBszW3G5Nr/7Oez2HN1aD1mouzxox/TijJrvcGOhimuPZiRnFMl9u1HG/JbpIgCBa7ERJpvHsATuNWOSvMCzLeaqLqkWsxgXI5Grmw/7JEA2sAdtoBgsV5TjMuXvg7H13da6MWGcUfNcNsKEuu9hMERZQS/JSPKCu+t9OlHCrfWQ9TChYlssJxlpIVye86l5Nsmg4lY3TtkIY3qDd3nFKzvUUN6Dh52Il1c7rHdTAtfhUsNjuRkR5QX3WuWg1hsu17EQbq31uDRbYb66vdTtUXXFXrZSkhVUPHtan4ltjCph/qTYz4FxUUT+zODfw2y2/2jwXRtfkw6mE2X040fuxa30YmiGKY5tYYtF2QUqjTLPtrREonIWGZms9pOU9V5KxXfBGPIC+nGKP+Zwsprv8Kn77bJWeDNiuR3j2sIzF6rkBTR7GXfWQ55dKuc+erZFnJa1xYdMWraPqgyOO03gJEpnt85zlOZ8dLnJfNVnpR1xeTZga3DeNCm0MTByPbjX/dvoJdxv93ltLcSxIHAd6r5D1bfpxinWjnTqO++loYzoWOsmJGlBLbAJXKuMqAAcgSjJcSybJMtIUvj0SgeDcLHukeUF7TjjTddmsUQI073dlrs9RwbD+196yOW5KllWcDfs88qDLp/z/N4JgI8iA6MoeVwPnEFU5qNtorSgHjwyhe5shNQ8l4prk+WGOxshV+fOtfNuHIxUruKyoAHDt1S+ZbminIQpfB+Mve8WZwWFMTi2kOQFFnC/1efmeo/AKXNWrHdjOlFGLXBpuA6tKON+s4/JDRXfwhGwLZuKZ7HSTlmo5lRdiyQveLge87arM4Nj5Xz4zgaB61BxHUSEl1dD8qLAdAyvv9ggzgyrnYT5mkstcAiTlLrvnEhX7DXQsNqJWevF0/ZM7MoodOok2c+BYVN67HYrQjNRX1MjcCj2+C0tIE5ybq2FXKh72JZFGGcUpmCxHmhWWuUsMjJZdW2bKIVumlJQdmOdwfJxMOzA3F4P8RwL17G43+4TuBYL9YA4NdR8m6cWAm5v9LjbDCkKQ1YYWmHMs0uNU5Nxejdl0I0yWlHCK6ts66CdZO7hSZTOzs5zef0jigKqcza2JdzZ6G8rRTZNCm0MjFwP7vWcbIQJcVaQ5zlRanjYial4Dq4lXJjxWWpsJpInSnNur4eIlHleKq5Nq5/Q6qe0+xlJltMIHGqeTRhl+J5D1XfpxhlRllMY6PRTPvtSg3aY0o4ybMui6tlsdGP6swEXK3snQBw+R1Gas9FLSPIyFDhMCtqDCic1zybNDC8/6PKmK2U5y63OiprvbBqJO2Vg57qLdX8kFVGeX2rw4s11oIy8iNKCXpzyjqcXyhWMoRvl3NnoE6U5gWszV/HKpODKKBmpXFk8clrsXK4ox8YYQB49pTL43+l+H4y97+Y7FpYIWW7AwKtrXZZbEYEtzFQc1rspH77bYq7mURhoRSn9JMVCaEcpD9sxrV7CxdkAQZituuTG4LsWInCh5uJ7DlGa8+kHHaIUoiQhzg0YQ6tfOijywuFhJ8YgWAJRmvGOG/P0k3yzxGpeFKx2YjZ6CfWKQzvK9izosNWhvtdgTpzm9NPiTOiIaa8ytp8D454x5jueWEuOwGzV3dOBAbAeJgSuzZW5CnGac78dYVsWrpPw/FJjKpKTKMoRGJmsJllGsuXvAkgGy0fN1k68CFRch7QoeGapTidKKfKC1CoVojE57X5GOgjpFGCm4rNQ8wiTnDjJaEUZdzbCXSsLPAl2KoNulHF7vcdTC7XHOmgnmapxEqWzs/O80UuwxKISlCGbF2cCbq/3WOlEXJ+vTp1CGwMj14O73b/VTsRSI+C1tS4Vz2ajGeFYQlEUZFjcWQt593MXNhOa3VoPy+pars1KJ+bueshczWO920fEpttPeGmli2vBfMMjywxhnBK4FpZYJFlGveJQd21qcw6eVY58xVmO79rkebGv08p3LDpRxnovxrNLB0o/yUiznFaU0uwnVFyHyzM+cVawvFFGgWx1VnxsucXFRvCYDOy27lBuTlrScK7q8ears3zw9sa20rHDd0U7KkOZC1NGbOZFwUYY0478491sZS9GKld7PanqwFBOhAhPzVfKaodp+c55ar5Ccbr7qmPvuy3WfZr9lI1eTJLlPGhHiIF6xWUm8IGEfpLSDmN8zyUrDIFr0ai4hGlOWhS86coMczWfl1c6XKz7XFuoljbRYErGMPdTkuUs1V0+dKdFO8rwbGhUPPLC4DmGbpzguw5r3QLXtujG5TTBmu/wiXttXn3Yo+baVH0HR6w9CzrsHFTaazAnyYszoyOmuUww7O/A2M17dyoID0god32hRkGBb1t4tsViPdg0FNe68WZmdUU5I4xMVjfCGBtwLDAFiAVZUS4fNVs78YFbJjP0xKbhl2HeaVZgU5Abg8Hi7Tfmub5QfTSC6zmDygkOLz7s7llZ4EmxUxm0ooSnFmrMVMq5mFudFCeZBnISpbNY93l5tTuISjPca/aZr3lcmq1v7vup+Sr3mv2pVGhjYOR6cLf7N1fzaQQOFcfmQVowV/VIspxOlHFhJuDqbIX1bkw/K7j5sEdWFKS54aWVLjO+w2zg8LATEaeGOEsJPJvnLpQG4cfvtZmt2mRdgzGGmYpDoxJQ910uzATcbfaxLYv5Wmn0ubaF5zr7jigt1n1u3lzHsSwce5Avx7ZJsoQahorvECc5Lz3s8vRCjZVO6ZjbPuUEunFKo/JorrJrC3c3Hl8XHjn3TuJMi9KcXpzxlqtzmzZBL842R9LutyPqvrspswDtfsr9dnTsYyq7MlK52ks7TUcqOuW04jsWhYHLs4+i0ZKswD21vSPgCfXdKo7Fw9yw0onAwHzNxSA0w5RemuG7DpATZzmWQJyCb9lcqHtcqLu0o4w3XZljvuYhpkwgeWWuvM5JVhCmMfWggmuX+Z1mqy4XZ8uqJWvdmNwumA1qWJbNTOBiWdCPCz5xr8Xnv/4ia90Y2xLeeKnBai+mn+XM2x4uZUGHxbq/bcBo56DSXoM5/TQ/UzriSVfqGyX7OTC+6Im14oiUHRt2jcIogHvNHrXA5cVbG1yeDXAHXr35mreZYXW/G6ZlBJUpY2SymhcWOQX5ULiKR8tHzdZO/FzV434rojAFjm0ReGX5q9mKS5zkuLbFGy7VN0c+jCkT88ZZwf12B8e26CYZ62FRTkWxLV5e7fDZT+89/37cJGmBW9tuSwydFCede3gSpSPGlCaOAc+1yXcMJ2W5wXN17HLAWPTgY/dvIyTNDfWgrJBhDFgCs1WvHAFyLG6vh9i2YApo+A6rnYQ0y3lhuY3jWqRZwdW5gEbgErg29zYibEfIspy+CE8tVEgGST5rvssbL83Q6idcqAfcWKhwZ71fRjosVJkJbB60IxDZVQcGbjlKdWejz0qnzFcTOBbG5NxvFjx9wcaW8pmO0px4kEB7K1XXJtyRpCDNSydLXhRjSZK21o1p9VM+9WCddj9lpuLyhksNAre0CWzLIspj7rczigIsC3wLAm/6RtdOOafWvlSUIYt1n1dWOpvl2y1LqLk2z11sTLpp+zFW2doaqfD0hRq9NGe1HRPnBddnKgSuxQde7lL1HDBCkeZQ5GRiiPOcd15eYDZw6UQpSV6QZoaNXkQ9cLk8G2w6Cqqei2sLpjAYsah5Ft1+SjvOCTyb2cCh4rlUPJvXVnu0+ilX5wIW6jXuNkMuNioYoMDwsJMQpxn3Wn0WKi5RVvD0Yg3Hkk3dttUeHU6NjAfVVpphykLN5fmlBhXPIUkzstxgW5AXYInBtk5eBv2g637W+qUnPac9HRjGmPWRtHAMuI6150SuAuinBTNVYa0TYygTBBaDMNTXXarvO59/2uviKuePUcqqMbtPztpr+UHs94La2okPXJvLswEfXW4xU3F59kKNdlRms/YcC0+Eh92kzDJvCmyxuN/qM1f1eGmlgzGGxUZA1bXJTekRP0pZ0VEohp3vDsexuLMRcn2h9lg+iUnNPVzrxjQqHouN0kFxebbMpbDSjri+UN132st5fP89CT047ODfWg9xHQuMwbNtqjWf+bqHINR9l9vrIdfmqiS+ITeGjTDhznofBK42Alr9hI8td5gNHALfoSjKOcW+a+M7ZVRFPRBsW1is+lxo+FyeC3hltcuttTKfxpW5Ckma8/99cpVLsxUC16YeuLuG2zZ7CUlWcGOhijGG19ZCqoFLHqb0opxaxeENsxXSvMB37cccdvXAJUrzckRziwzM1TxeWemQGjY7DevdiGeWGieW1TsbIb/0yiqW2DiWsNqJedAOefdzS1ybr9LwHda6ETIcxDQQ5YbL/v4F286icTlOTrN9qShbifKi7KBnOb5jY88FB280QcYtW8NIhcIYHrRjFmoec1WXO+t9fLvPhZpPK0xohjH1QTXIZq+g4gpX5irl9JMwxrbLUt9X5yokacGthz2ywmw6CnpxRpobsOD5C1U+vdKlmxRUXYvrCxWaYTlV8UGrYKbi8vRijTQvuL0R0gpTwsWM19ZDulFGbgxZllMgbHQTfNciTHIuzgS8stLhuYuNTXu0MAX3W32MgW6cc6EW0PBtZoKyEljNL/VplpdVVzzbolHxqPn2timeNd9hqeFvlkk/iQ11FvulozinqRxmm696+5Z1XO3GrLUjZqsutzdCXlrp0s9yMmP4+HJ7331Pe11cRTkJ6W6lffZZvh/DF1RhyuoIwxf50LGwWPdJsrIDY4whzQrCOGOh5tKouLzl2iyf+/wFft2NeRg4MAoMgWMRZTkvrXbpxymuLeQFtMKUdFD6tTCQHyKp0kFtPAo73x0XGwEgrLQjjDEkWUGS5Zudm2vzVSyBMClDLJ+EMooHncUh5ZSRCnlhHpv2ou+/8TN8/lzH5pkLNTzHwncckiyn4toEjsVizUMEZioeSJkDKs0Nr611SbIcA6z3U2brPkmac7fZRwpDzXMJo4Kq79KoerzhUp1nLzR497MXeOZCjcW6T8W1ubFYxbGF+aqP71jcXA/pRvkglFZY78UUhm3PwFo3xnVtCgz3WxGfftDhfqvPw07CG6/OcHWhnLbZTzMuzwbMVtxtsp4Mctm8+ersYzJAYXjYSzGGQVQHPOyltPvJiWX14/fahHFBkhX04qwMVY4LPn6vtAtmA4esMGRF2c6sKMgKw2ywtwNjlO8QRVFOD8sbIc1eWdUwGJSlbvZSlgeDD+eRoQ3RDBM8x6Luu1ydr3JtoUInTvnkgxZpXuA4NjXP4Q1XZlia8SkEsjyn4lkUBYPOvaGXZDT7Kc9drHOh5nGxURk4Cko96DkWhSnLfF+dC3jjlRksy8Z1bPpxysWZgEuzQRmdKIAxPOxFrIcpeV7mfkqSgtVOwu21Hi8/aHN3I6QbpRSFYT0s7+fQHl1pR7iWRSsqK39dngvwnXLaiefYzFfLvGthklEUBWGSESY51+aq3N0IWQsTZioujmXxoB2VuTIcm+VmGeH4ymr3yPphnP3Sof46TrtOwijOaf9hhVOK79jDCOhdCVybVj+nFfXoJjmB4xBXy86RbVv7zu2d9rq4inISsj1EY6/l+3FQosqtuQA2egkbYcKVuQoVp+wE3G+VWaAtEfpJxvWFCv20IM7KZINPzVfoZ6ZMfviwR54XNHsxjaDMH3B98eAwz5Mk09zJznfH0DlwvxXtmk/iJNNAjjviu9vUFduyuL5Q5hZ4ZRV9/z1Btj9/FjcWHC7PVOjGKWGS0eqn5Mbw/FKDJM35yP+fvT8Psu3L8ruwz95nPne+Obz38g2/seZuukpVSA0dAmFZIDFIEIEIyQY1hCJkAoHBQQQSRHiIsMMhY4MFwRQNklvYsoQshCVsQkghkIQQklF3VXdVdXXVb35zZr7Mm3c64z57+49z732Z+TLzZebL+e1PxPvlL0/eYZ9h77X32mt917MRWalJC8WTQYpA041rZ8HHz0cIUZedUxoCHxpGkhSK+/0YV0paoUtlTB3ZMHMYfO/hgPv9mLTQPNtJ8aVkdSlgWqg6IgSYZCXOrjKuudJoXad7DJIcR0j6scfTQcJf+sEzbndies2AO+06JDjwHPoNn082x0wytUdod79OzTCb9fVCk89SSO73Ix5tJXzznf4b9dXBtGCal2RK1xMIAVVVMZjOnnkhuN2KeDHNF7oYy40AxOFp5Wc5hlgslqvD40HKYJqjtEEbgxQCV9b/rngaybkxn0OMs9oBXFR15SnflfzseyuUWvPXfrzJ+s4EiQBdbzp7UuJ6Dg/6DTzpMJjmbE00W9Oc2HWY5IpRpug3A3zXYZor7vZiikrz3/7aOpvjnFJrIs/lbi/i5760wg8f72CM4clOihS16HXoOnVVEilwHcGtdsSnWxOKSrM1LbjdDvBdiZSCrUnOnW7Ixjjn/dUWS82AHz0dUWrNJFe8v9IkcB2MMaSLNEjBrZbPs1FOXtai17daPsnMwWFMnSUgxEuh9G7s8XBrygerrVNFG5zXujQrq1dSpIZJwfur51/s4izO6Zo6MA5PIYGXQl2hI7ndDUnKupO0I49+5B45GbnudXEtljfhsDzz0+SfH2eAermIT2iGHtoYng9TfOHgOYKNcUY/9mnH3h6PZVEZIlfWqSPNOkzv0xdjHg0K3l9p8uGtJivN1+etn6VhCFzJJFNMC7VHaHTuHDgr3iT07nWpK3b8u1gOev4qrVkfZnyw2uJut75HTwdJnVJVVDArFxd6ElPVzqtpXqKNwHcd1roeSanYfFZgTO0AuNUMWW0FtSMh9vc8K2aXQ1/NStlVxuCY+p67jmCUKVZ3PQOBKxnnJXlpuNOpIzhejDOmeQWIuqylUnz+Ykon8skLxZYxrLaixTkdJqhtjCFwHVrtl46NoqwotXlFR+OkfdVoU4sFS7FYkJSqPg6QlIrQc1hthQv9Dd+RJOXhMZ9208NiuZlsjjNGaUErCvBnegej9O2ORpzrgmxOcgSGvNA8G6ZUxtCN68pwkSdZbkUobUhVRSv2WG77hI5HJ/L49edjhlmBlIJPnqUsNTzeX24Q+R7Phxm32gGleVkiPC0rfE/iGYmqNOujjElW0g494sDB8ySjVLE1LYk9RTvyudMJZ+mZGk8K7vVCHClZbvh4niR0JZo6crcTeYtNoVudEEcINqc529O6oqVE4Dv13CgpSjqhj5RyzzxvY5zz7nKjTi+Z2SrXEaRlxeY4pxG6p3Zyn9e87OkgYTspaQQurluLcW8nJeEgOXcH3Vmc07WclS69ZmGiVEU/rmvep0rzoBez2g5xpaDhu0deoP1h7bvDvi0Wy/GZL+ifD1O+2JryfJgyydSB/W8ellhrYUQIAWWlUUpzd9Z/H21PKcraYAhjeLQ9pRN7RJ7D1qQgkC73ezGN0OXFqA5BfF143HwQ3c1pDUMjcHm0PSUvNaEryUvNx5sTRklxpuF5bxJ697rUFTv+XSwHPX+b4xzPkWxNch5uJ3WEUlKyneTcW4oJXYeyglutAOlKJnmJJwWx54AE35NsjzOysiR2JQLD42HCT9ZHfPFiyqcvpvzw6Q47SV0wuRv7PBokFKrOL3ak4Ml2RuTVDsK0qBDstbtLzQBXSMZpwfYk48lgyq8+3qEVuXz5VotOI2SpFdFtuOykBcNMYQxsT+tz2p7mmH1pKXNudSKSsi6ZvEgtKxVrM4G33Zy0r662Q7SGwBH0Io/AEWhdH4c6Gml9lFIoTeAICqVZH9VVWk5yD89icnlZob0Wi6WmjvQWL+t6iPr3q12E5HyYj0dPd1JGmSJ2Bc93MtJSEfq13fjB4x0KVXG7E1EBnifpRC66gvVhQRw6fLw+QalaJFkpQzt0GSaqrqgV1Yv8zUm+GD//5ieb3GrXzvdW6HGrGxL7Lv/dx5vc7tZOEqUMyw2PlYaH0nUqidKG91eadCKPlVZEVhjA8HQnZZpX5FWF70jGWcmtTp22Ykwt+vnR5pjnOxmPtqb88MmQUVYsUlocIXgxqdMqo1n1vBeTOhqjrMysgpimrOpKegKY5uqVDTVvJkJ/HM5rXrYxzol9B8+p55KeI4n9ujT7eXMW53QtHRivYycpebSVUlamFnMpKlwpCJxa0OyoC3RZuekWy1XgMMN8GoN90IL+0faUxgGCeLsXAaHncKcbsdaNebBUC2AGjmSpFSJEbUhboUcz9hHAICkADcLQjr06VNGVPJvlHB6Vm36WhmGaK+71ax2DTGkQ4EuYlNWZ5sbv17GAkxnDo7Dj38Vy0PM3SAoqrTGzCZIxsD5K2R4XTPOKfjNgrRsR+A6twGF9lDMtKpqxx71uhNZ19RJfSnAcOnHAUqOeVIW+w61WQFXBd7/YZicpFjZRCAg8BykE9/sRvisYpyWV1nx9rfNKFZLVls8oVzzdSRlnCmMEse/iSFhu+6zOyr9OspK8rA6c9I3SV8V11roRvUaAmuUXK63pNQK+utZ54756vx9ztxvx6eaUv/3pFp9uTrnbjbjfr3fBKq1ZaYf4riSvDL4rWWmHVPrwvnUek0urq2GxXD5LzYDIl7yYZDzaTngxyYh8+dY59OfjUVJUDJOCx4OE9VHO/aUYz3GQUtKNPO72aofCO0sxke+gK8P2pKDUmn7s8cFKk2Fa0gp93lluIoSg4TsEnsAgSPIKow3TTC2u8cYwn9lCF88VlBVUlUaVhmbg8qAXE7iSVBk6jZAvrTToRz5PBwnPdzKSvAQMk6JkueFzqxPgCE2WazSGlZk9HaUlL2ZOjNARuA4YDBujlIdbU7YmOUvNgGoWubd70S+FIPAcClUhheBWu7Zfo6xkqRnwoB+/4gQ/TdW5g+ZlO0nBL32xxV/78Tq/9MXWYmPiOBhjXtViMHujMs+Ls5hrXssUktftNBoj8D2JNppslqNlZuFI+ydiB3Gd6+JaLG+CDwcK5PoHHHsd01yx0g55Nkx5OlQ0Apc7nYhprl7Je39tVQ4hFsZvHrb3ZbfJICl5MkjpRD4f3goJ3LpvF2XFx+vj1+bM79bhOEin4iTkStMK3UV98Gc7Kd04QBkzi5Q4m9z4Nwm9O076iR3/Lo6Dnr9m6OIKudCf8FxB4Lo8HSYst0K0MbWzzwg6sYcrBXd6Ef04YH2UMskqQlfQa4R87W4bAXy2MaLbCDDa8GJWPURpza8/HdJpBDR9h61piSME9/sxSaGY5BV3upK73ZhprtieFgu9FYCdVLHWiRgkOSAQaApl2BhXVAY2RzkC6DW8hWPEc2bn5IhFZMVB12Sp4fNoe8pOUtKNPe73Y7qxT+g5b9RXQ1/ydJTSjVx6sYcxhqejlN/o9wGIfY9JpiirWfRHpXGkJPa9E93DN3X6WV0Ni+XyWW0FfPfxgE83JiSZIg5d3l9t8s17vctu2oWyNXM+b09zfMeh3wgYJiWfbU54f6XFaqeOkM1VxfpOyrhQfPlWi0muKEu9qIT1ZJAiqVMVP1xtsdoKMRj6jZBBkrOdFORVRcNzFw4DzxOkI0PsS6Z5hSMA16HbqMfX7bSk2/AJPIfIlTwbpXyxOWGUKt5dbvCg3yD0FZUGR4LWmp2kICsrTGX46mxNmJQKKQSTXNEMA+LQUCjDUjPky6stKlOnPTpSUqo6QtB1BGpWuaQTBws7UBpY60Qs3a21yebzLjh91bmD5mU7ScF3v9imEXj0Yp+s1Hz3i22+9U7/lTn2QdzqRHz2YoKa7NJ4cQTvLTeP3a7L5Fo6MEaZwgMOK4xQqIqVToAjBEmh2EkK+g2f3/yVVULP4ckgOZb4nS2NZnnb8H04yIHrn8KDMcoUk6xkuRFyu10P9LUYoOTuvte+bhEQuBJt4HYnWrynUJpmWC8s5mkUCwTHzpk/qwX7fsdCUelF5NdR339S3qQEq10YXT32P3+jtGSYlrWSu6zzUn1XUCh4tD1Bawh9h5VmyCjNcSIPU2m0MbhScqsTME7rHSzPkZSqYpIbVtqCYVoRBx6hKykr+Ghzwv1SEwe1Vss0VzzdqR0l93ouzcDjR0+H3Os3aIXuwuElhMAYQytyEUIwSgt6zYCfPB9zqx3iO4JpUTLJK37Dg+5sEvfqpM8X7iv2OCsrfvR0SD8OWOtEZKXmR0+HhJ5Dd6bfcVoeb6c4GDJdp6Z4rqDhGB5vp/ym9+s+XFWahUq4qHf7XuccPGunXz6r0vJ8+HL+0Ym8U2kRWSyW0/FikvPxxoTYc+hGHpnSfLwx4dv33y4djFxpJlmJ7zh4rqQTewS+w4tJTlKUxMJDVRB7Lo4UDJKCpifpxw0CT/J8lDFJS9JC4UrBw0GC50iWGgGDrEQpza1Zmn879LnXixZRZ+8vtfjBoyHN0KUdukyLiklZ8s1+F81Mv0hCWih+9GyKBPpxwO12RDvy8R1BK/Ioq4phUjItKnzfZanpcrffYJorsrIi9j2GSU5SKDxH8MWLKeNcsSxDNAYD+K5DlRYsNUOmuSItK4wxVBp2pjlboXvgOnG/YH1SKmLfWzhpTruu/GRzTCPwiGdRzXEgF8e//c7Sa9/fb/h89FxTGoMESlNvjPQbp9myPBlnUUb1WjowkqI80oGx3AoolSGdlezpN31WZg/JcS/YTay7a7G8jgMiuo88fhRJUSL37SSXlSQpTv5hRy3a87Li6TBDzBTC1awk6Dxn/qIEKfe3UVCHxs3D08/q+99kx9cKDl592pGH50imxWyChMGRgveXm0hBXT64rHhvpclX11pM84pRVpAWmjvdCGckyMqKJFc83ppQVuA7IIWk36wjNqAWpEtzxWfbE4rS0IncWT6swygteWepwU5S0Ag8prmiHXmLvvR4e8q0UCR5/dz4rsNSHHCvp3CExHEd7jUD3ltq0Gn4VEbvmfT5jqQZerwY1cryuxXQR5l6o0nZUTzcnqKqWusCp46uUFV9HABj8D2XXuAuxpJpro6sXHYuGMPjnYxG4BJ5DkobHg9S1jrhxbbjmuBycOTgtZzgWq4M33004N1+jOc5KGVYcgVlWfHdRwN+81duXXbzLozAlSRlRXu2YRS4Dg/6MdvjjO1xgQZud0I8R9KLPXpxQKE0k7xkJzFsjlJGWa2lFAcuQgt+/dmIpWbA3V6E49bl5lfbIb4rFtpeAELCP/C1W3zviwEvJopu5PDtd/pURnO/V6cE/uDJkEdbU3bSWpDTlQ5327VoZ6I0g2lBJ/SYFpq1rodhloai9UI/rB3WY/72pODRdkpSVjiO4Ml2wotxzgdLMautgNj3kKKe71Va83iQAoY73XjhdDloPhbOUjWzsqIZRot57JusKyeZorcv0iL05Cyt+vVMc8UHq61XhOcPipI+a85iM+1aju+x53JUtndSVgg0yy0Px3HQGoQQr71guyMuBklOO/TtTqXlrSI/ZJ5+2PGjiD2XzSxnZ5ZH78ha+XklfDV/9HUOw6MW7WuzvjstKwpVL4T6cV2bfJ5udtqwvZOwv41LzYCsqMMSzSzs/6y+/7Q7vodVSol865S9KswdYf1GgOcIHm3X/eLrazGDpCD0XNJSkZQKPTWs9SIeLMXkqiL2XB5tJ7TCendnlJUEnssHt5o8HaT8+PmIQEriwEVjmOQlfTfk3aWIraTg+0/GfGOtRTvy2UkKPnsxpRU4s9SsOvpp3peGqapFPKcFINmaZnhS8P5Kk2+/11+Un0sKRTN8Oembv/+T9RGZ0uTTlw6MsRRsjHK+vtbec01OMik7iuG0ZJQrpBSoSuPquqRsOJ05VYXgXi9imJakZT3OzHcDLxQxCwGZf6+Z/eeICmpvM2ep3WSxzBlniuWmT7grhSxzSl5M3nwsuk4sNQO+2JqykxQUlV5oFnzn/SWeDlIGSUHhaTqxT6kqvnSryfNhxvpI8+nGkLSsKKq6xOnmOKPX8Al8h37TZ5AUfLjS4k4nmmlMwPNhxu1OSOBKHCF40I950G+QFBWDpGCa1eXFx1ldQWO5FTDOFAiDlCwqavgOTEvFOC1rLYsXCff6MXHg4EpJkisqreuUj25ENkjoNHySUjFICiZZyUozoDKaF0nBJ5sT3ltqLOaWT4YZAoPn1sKXviNpBO6h68SzjoBthi5ZqRdOfoCs1DTD4y3t81lE5G7cM9JTO853v5VlVOc55ocxSnJW2xFGGzJV8bRMWWr4rLQCevtCY+YXbP8C6vmOZktl+K5ceMbsTqXFcnzqclLz4LtaEEnpg8Ox5zmWW5N8Ub5wvyHYv2if99lc6drJ4buL752H5b1pzvxJOaiNF/n9r6MRuPzg8Q5K12shY8CV8Js+WL60NlleMn9eisqwk6bEnkulDfd6EZHvzoTCpnyymeI7gg/vNzFGsDnKFnmvgecsSrj1Gj79ho8UMIocjK5Tm8q0wJGC0HNr4dC0JHAd7nZDBpMS15H0jE879GYhtpqsrAi92rnoOwJf1hN8R9aLbVeKmZiZZJiWrLbqyAEpBe3IoxG4fLI5ZpIpmqHLNK9QxtAMPRwHKgPjrGSSl4dOyt40rdN3Bc92ElxHIiW1En6ludetIxsOS1XzLmElfK8Xs5OUi4iVe7344h0p14TDZmV2tmZ5E+71I55sZwRerYkjhCAvK+71o9e/+QYReg7vrzT5Gx9t4EqHVugSuA6jVHG3HxH7bq2blJUkhcL3HZaaPo3Q4dkwpdQFrusiTF0tpNIGz5H83e8u8dnGBE/C+jjn0826stxqK5il/gf0mz7t0GeaK5Q2hK5kdaVJNqv68ZP1cS0Sryq2pyXNwOVW22V7WlCGLoNJWWtbZHUU4TAr8V2J60DseWyOc9a60SJC4kdPR2xNCnaSnHFWl2HtNTx8RzNOSxBiMc8bZYphktfC8bPUyK1JhoqDV9Kk4ewjYD9YafHdL7Zn90iSlZppXvKtd/rH+4BLjPR7q8uoHrURYQwkhSaroN/0udethWJqj9reQMP5BdtfmrARukghGUyLV15rsdxUDnMNHu0yPIRZGOBqM+ReL2a1Wav7H9R5R5lia5JhDEhRh6j/9R9v8N/9ZJNPNyevqO/vV+n3Zru9a93oQEHK91eal+I8uOzv38/2JMd1a2MrRO1td13J9jFKsFrOl93PdC/2WG1Fdf9pBQsF89BzaEceP3W3w4PlBoa6j92b5fICjLKS7WnBcjPkveU6DeRvfbLN5qhAacNyO+BLq22Gack4U7iuwOh64rU+zPjhswFSwGCaM5wWPBkkTHLF9x8NeLg1ZZSVdBoBtzsRUgrCWf9baYVUpk4dS9KSQlVMc0XDcxbOyNVWxFdut1ltRTwdpmDAlWKR/uU7kmbgMs1LklyhtSbJFdO85G43fuPKHAZBHNSq+VqDlJI4cOpSiVydMsLnVZr1pnLYfuH57yNabjI/+94y46JknNVRpOOsZFyU/Ox7b5/Dv9KGn7nf593lBq3Ioxm6tGaRDB+uNpFC0msE9COfzVHOxijjbjcm9h0avkvoSdKiYlLUKY+lrlDakFUVv/58TOQ7i0X4R+sTng9TClXxwUoLKaAZuCS5WkT/3e6EGGrNqF99vIPrCCLPYZiU/OoXA7YnGc9nERJ1FKygE3lgYGtaMM5LcqWY5mqR2rE1ybnVCYl8h2mmkcLgOXVU/8Yow/f2jr+706SFEHiuRIrD06TPelzvxj7feqeP49TV+ByHYwt4Apca6XcWtvbcIjCEEPeB/xS4TW1HfsEY8+8IIfrAfwa8C3wO/FPGmMFJPvt1i4Bvv7+EK+sHZbk5K2eTKu50DI8GCR96rVdCyp/upHs8Y93Y59lOyrRQZx7+bbFcVVzBgUJx7inHs+PuIs4NgcbwdJAwyip8V9ZVAnYS0rLig5Xmou9bMcrTsTHO6cX+HsHTQlVsjHPeX21dYssshz3TZVUbdqh3a6ZZLTL2YKm96A91qkb9mufDFN91iHyHotJsT+tS4o5jWG212JrmJHmFUpqlts+tdsTDrSnGGEJf0onrcGHfdXCEwBgYpzlCBCBAGFNXFXEk7/RjfrI+qQXOPMkHqw2KSpNpTaE0a51wEW67/9x6DZ/1cUpeaSpd63yIWS7xV263+N6jwaIKyTfv96i0OZM+340CjBCLtDaxS9/iPCqKnIZG4PL9J0NUVYt5agOuI/nZ999MA8RisRyfZujxO3/mLt97tMPOtORWJ+Sb97sL8fC3if1V1gA+f1GhtSEtK9Z6IUlRkZd1KdGVdshnmxO6sc8ozflsY8rzYT3/WGn7VFowzkqmeUXku3Qjn9h3GaUlWanYmub8/b1bi7H3154OGWUFvdinEXokhaYXe7UzpNLEvstKO6Ad+WyMM3amJe8u+yy1AramBY5j+MnmBGkMjcDlVitka1Lw9TvtPfqIndjjJ+sjSq3xpCQpDO1Ycqfjsz0p9jgbYs9lqPYKbmtjaHkHPx9vIsC+n93RiLfbEUtrpxMDvaxIv7OwteeZQqKAf9UY88tCiBbwS0KIvwz8s8BfMcb8ESHEHwb+MPCHTvrhR2lqre9kgCAtFBvDjFbk8f5yzDhTbI5zIlfSaQS0Q3dxwXaHs2RlVZfZKSqyqmKQlHtea7HcVOYO2QOPn5B5OPad7uvDseeGYDAuSMoK1xFoDY3Qo+F7JLnas1DZH4qXlVW9YzxTG7UVgw7GGENeVuykJYXS+K4ksru6V4JRpsgKRakNviPrPOFZtZA9ht6XtEN/z/O9exen0rCT5DMdh5JpqXAdSAvDJFeEroPnSFZaAQb47MUYDDhSELkSr+GDMZRak2tQpmKSahzp4EmJ5zr135XmxSSnEUhC10UZTanq0OCVZsD9frzohweFzt5q+nz2YkJZ1TtxrhTEvseXQodprvjGWncxyZvmikLpQ1NAj0srdim3FY8HGWlREfkO93ohrfjlVOgqlBHenhb4jkDiUBmNL+uQ5+1pceDumq2YZrGcPbnS3OlERJ67SG3txt6FaARcJbKyYpDkPN/RNEJ3UdJaCgGivk4Nv65aVSqNELVA5MY4pygrfrI+xRGC5abHMC3JBhXNwGF7WmCMptsIKCuNJ+soiciTeM7L9P3taYHnSCLPJS00RVVHE47Sksj3aPguAghcF60VvdgldD0avsOj7SlKGzbGBZJ6XtqJPXxX0ggdglnq8dxGPRuWqAqyXLFRKEJX4nswzh0i311ECGRlRVLWotSTXBF6dWrNcjM4VFNsnqayO5Xyg5XWicfqrKz4ZHNSRynOyp/upOWeTb7jELjyFftZVuYVW31evKmtPbeZqzHmmTHml2f/PwZ+BNwFfhfwJ2Yv+xPAP37Sz87K6sjQwHriVpfGycqKtCxZnxTkSrPaDnFcie+IPUZ+Hs4yTkue7aTkpSb0JR+stF55rcVyUznMLp/GXp8kRKwdebNoqVqYaZyV5KoiVxWVqUtE7p407A7Fy8qK58OMQhnaoXeq0PK3hW7D59H2lKKsFzpFqXm0PaV7AWWzLIeTlRU705yyMkSegzF1JMU4UwQzHaalZkDgSmLf48U4Y5yWr/SrrKzQlaYReHUYbF6RzHQlkqJilNb96tlOQuC5rPVjtDZUs0lQKw4wBia5plSaSlcMJgXPd3LWRxkbo5xnOwl5ZehGLttJwdak5OH2lFFaMkpLlme2cnc/PCh0VgGR69CNIlaaMd0owpeSYab2pHPOSyQnpXrj8FuJ4IvtlNBxWeuEhI7LF9sp8orJPa4PU7qRz1ov4n6/wVovohv5rA/TV167P53Ojn8Wy9nxeJBgDItx+fFsB/1tYT6+tEMfKSEvNc92UsZpSRy4NDwHIepIwVJpiqoiDhwebk0JXYdCa6QUCClq57krCV2njn4DIr92Dq2Pcp4OU1RlaIc+/aa/+P6HW7UDpNfweDZMWB/meJKZY1ux1ArISs3GKGWYKpQGjeHh9pSNUYE2deSgADYmOc+Hta293X65uTa3UV9sTlCVZqUTsNYJEQgebaU8H6bcX2rMSoK/vCaRJ2mHdXWvhu8iZmLVh13L/amUW5P8xGP1052UwTTHlZLYd3GlZDDNebrzqn04ikbg8nh7SqE0oSsplObx9pRGcD3kMS9k600I8S7wLeBvA7eMMc+gdnIAqyf9vK1JfqQDQ2tDM3SRriD0BJJaeOfxzKhvjHLMTDBwztwTNMwKKmPwXcmdbjwrHefsea3FclM5TFv7NJrb8z4lBQvV6sOimOa6Nt3Yw5OSyK0rHzR9j2c7KWoW0/ZkkPDp5oS8rBhldRTBYJpTB44Y+s1gseCxffZVAkey1AoRojamQsBSKyRwbBTGZbI1yVlp1Tm9SptaowTB5jhbOCZ262Mst0I2xhmDabGnX21Nct5fbTItFM+HCYMk5+kgxSD50u1GLTI2Leg3Azqxx1Ij4Kt3unz9TocPb7VpBvVkshW4FKXmi62UpzspSaF4tJ3w2YsxX2xPWR+lbIwLlhsBd2ZpIpWBfstHIglmDoh5PzzImbk9Lvjpe13u9EL6TZ87vZD3V5u8GOd4+5TRPaeOznjTnNlnOynLcQAShpkCCctxwLNdE7/5tf50c3JsR8Bp3nMUYrazuffg7Pg+9ut32fHPYjkjjKHueLPfxew/F11W+RKZjy/tyONON8Z3JZUxDLOCD1aavL/aYin2GaUlSmtutUOGSYnrOnQaHsNpyVo3xBGCTGnWOhEfrjQYporKGMpS8/mLhEYgWW4GpEXFNC/5YKW1+P5G6CKkICsNd3sNokCyPipohi7ffqfPzrRka5qxPkp5tD3ls60pk6zgo40J06zk6SBlmNapHivNkNh3WG0FVLsc4HMb9WSYcqsdoiqDMvDuSszdXkheQifyF06Ig67Ji0k9F326kx5oB85qrF4fpjhCMEgLnuykDNICR4gDHdxHMc0V9/sNAk+SKU3gSe7v0tM6b97Ubp67m0UI0QT+c+BfMcaMDjLAh7zvDwB/AODBgwd7/pYrfWjdb4Dn44yfedDldjdilBQ8HmSoSvPuapvYrwW7XkxyOpHH3d7L94WeQy8OiH1nz0TBVh+x3CSO6ltnzXFDxOav2xxleK6L0ppe5OG5gjQ1TNOSLPLwHH9RZrVWodYM05J26NFvhodWDLIh1jOE4F434uF2SlpWNHyXe93Ilmc8I07bt3JVV9nwXMlOUtT5qK6g5fqL/Fxt4NkwZXOUIYSgE9VVSXb3r1zVubgCwAiEAcdxAEPLd2n4MEprwczIc2iHDp+/mPBwK6EXe3zlTgtHCraSnAf9BjtJzuO0JCkVncDni60prlPrYiy3aoX4h4OUrVHO9rRga5yz0ytY6fg8H0In8ijNwfmuK+2QZui+oscSuM6B6uTtsA7ffZOc2WmhiH2J7zkY7SCkxBWGaVHPJrKy4tONMdOyWpR2HSYF768eHuZ7VuG8u1ltBTwdZgtxU6VrjZOD1OHPWtn+qnKRdstiAUAIVpo+jwYpk1zRDFzu926WvXxdv9o9voSew51uRFoonu3Uzu3Alaz14oXWUa5qTaOv326xkyqEEFRKIwxkSiMlPNxK2E5KmoHDl1ebdCOXzzamNCOXlVbAg+XGIlUuV5p24PLx5oTnw4xO5NEMXHzH8KVbLYwxtMOMjzfHPBqkCAO+6/CxmrIzrfUxVlsh7cglyTWPBlM6kc9HG2Pu9iN+9sPlxbnd7cUEroPWhm7DJywURQVSCD5YjVie2Z/DrsmP18c4UhxqB85qrC6UZictaYYeoSupTK1v1n1Nhc6D7m0zdGntet9uPa3z5DS2dj/n6sAQQnjUzos/aYz5c7PD60KIO8aYZ0KIO8DGQe81xvwC8AsA3/nOd/a4OwNXHhmBIRD8+vMx3dhnkJYMkxIpIFeKpNDc60dUlSEpX3WBHFTaZZwpRlnBp5u83Ysfy43gqL51mYSew2on4nY3YmOcsTmu077u9iLyUtOK/D0Cfq2oLg/54WoLbVj8DfaGlu8vkVxWhieD5K3VtNmc5Cw3A2479S7D5iRnrWuFT8+C0/atud0JPWdRwrNQtYAj1PoYG6O0zvn1XBCwNSmY5mpRAm7+Ob/+bDQLbXXR1MKX40zx480JD3oN1roRnhSM05LvP6mrlaw0a6GzX3s2mgmExviOZH1SUCpNw3MX1UayvOTRdsrdbsxnoynb4wwpBFLC02FGw3cWwpO7S7Ltd2bmZXXgIv2DlcYe0dLdQmdvmjPruQ6TPKPUZuHM9KSg26zb+HSQ8HyUo7RZiHyOZZ3ffJjI7Tyct+F7i1J6g2nO01npwdOw1ovJyoppWVGoenLXjz3WDjj3syhHdx24qnbLcoMxhs1JwVIzqHfldf37RZSZvChe16/2jy/ZLJo98F6dT83H5rn+Wei73OqE/OjZiGbo0Kokj7ZTclXx1VtNcmX4lcdDPrzV4oOVFpUxdCKXPeFnu+7BNFdM84rpzE6EnsPDWQqsUoZQCsLQo1QGgcBBUlQaz5Ws7yiGeUnoSXyn3iho+M6iPDjUNupbD3p8vD7ixxsThmm9RmwHTm03dzkbHm0ntXj1TK/qyU5KmivcZnioHQhcySRTTAu1sD8N3z1UM+MwPE+ip7WzASEwxqB1ffwkXKbteDqonViNwMV1a/u/nZSEg+TYgvLn1kpRhzD8MeBHxph/e9ef/gLw87P//3ngz5/0s5eawZEh7ZWGp4OMnbRAVxXG1OXcHCMx1OJj2mhi/1Vv1f5Q11Fa8nh7Sif0bX6pxXJCdpKCX/pii7/243V+6YstdpKjk1ECV+JIyTtLTb7zbp/vvNtnrRvjOeLAsPJc6ddqbbyNIdaHhubZkNgryeue4aSoS57Gvofn1gJnvueQFpofPt1Z3OdG4PJikjNMc7TRBI4k8Oq8XF8KlpsB2oAzK6WbFfXkLvAcbnUi1joxvuOQlZonOwmDSUboOdxqh9zpRPQaPnHokRYleVVHQMWBh5QOQtQCd54reTxIX1uSba0X0489lNYkhUJpTT/2eG+1dezUs5NytxOxPkpJMoWLIckU66OUuzOn0eNByiSvNzwir3bETPKyPp9DWB+mxJ67p5Re7LknDufdTeg5rM2uQVbW12DtiPS7q1D61WK5cVximcmrwv7xZWNUF0lYbYWL+ZQ2vGKHClVXI3l3ucE37rZoBR6BWwuArnUjmqGHFOC6Dnmh68g+eLUM6eweBE7tCGiEDqXSbI5yHm5NeT7MFiVuG5GH70iGacEgySm0QmuIAhfPr0t0d6OAZuSy2g7wXYdPNsd7zvfd5Qbb05Lnw5SyqpAYMmUYZ4oXszljNnNAuFKgteHR9pSHL6bcaodH2oFG4PJoe1prLLqSfKZBdlLNiV4csNT00BrSskJrWGp69OKTjfmXaTs2xjmxXwuKCyHwHEnsO2yMjz8vP88IjJ8D/hng+0KI782O/RvAHwH+jBDi9wMPgd99mg8/pFgCAN3IIQpchoni3aWY5XZI4Dh0Gx6OFIwzxbvLjQOVVveHuo6ygvv9xiLExpZrtFiOx05S8N0vtmkEHr3YJys13/1i+8g61YeVmbrViQ71XL+uHNNVDbE+r7SWoyJOEIJ7vWgmdFxfq3u96ELKZlkO53Xq5LHnUihN4GqMkShdp1BlSpEXmrhb3+etSU7Dd9gcZTzdychUPblJC0UjqFOzKgOd0GVrWrDc8ms9lFlFmm7s8sOnO3xjrUsv9vm1aMQ4LSi0YZgWSCkIXehHEa6QTHNFpTUGqLSm6deTyxfjgi/f4siSbPOohsP6wHnY11QpvnG3y3ZSMs0VvZZLP26SqnqnbZjUavfeTBPGcwSelAyPcLyeRK/iuOwWe7vbFYt7G3rOK2PEVSn9arHcRC6rzORVYf/4UmnDvd7LqL+srEWhd6YlqqqjxRozB+w0r4sp/Mz9HluTgh8/H9GJPLaTgmGmCLw6vXFzmnE/j3EdeWAZ0vk9yAqNg2C1HVBpU1dAKStKz8ERkkGaM0hLSqUJXJfmzDHQCVykEcS+QytykdSREA6G7Wm557uSokJKuN+NGeeK0HdpB3VaySebE356rUMrqku57iR1lHDg1Zptwf4xd58dmOaKezONibnN7TXq3w+bEx9EO3RxZX1959VxGoF74uohl2k7jDGvLuLN7PgxOTcHhjHmb/CqWZ/zW9/ks7cmOR6HCwuudiLWuiHDRPHeSpOtcca0qEjLineXY0plkEcoxe4OU/10kyu5+LFYzgMHOOjJPs1w9snmmEbgEc+MSBzIxfFvv7N04Hvmfe/pIOHJIMcYw61OROw7/OjpkEbgEXqSrNRsT6Z8653+nvcdxFUMsT7PtJbdESew1+k6D+2cpynA4aVtLRfH6xas7chjtR2S5FU98XEkjhC0Ar8WOBNicZ8l8Gyc4kmX0HXYHKVsTHLeDz2kkCy3PBqBx7NhRsP3WG2F5KpimJR879EOLc+jmqm43+4EDDPFJFN87U4LgSCrKr691uZeN+K//0jx+VZSf6ugjgyhnmDd6UavfbYuumSpKx36sUe/Eb7cBDEVrqz7XDv2GCYFqnJwZB3NWVYVnSMml6utgM+3EpQuFmknrhS8u3T68zqqDx90va5C6VeL5aZxklLwN5nd48v8msx5PkzZmpTEoUPsuy9TAbyctV7M81FKVmrWerVDQGu447q4MqMVumRFRaoqHm1P+al73VfKkM6/r9fw2Rzn+I6D59XO9gf9BtuTgo/WRwSeYH2U4zgS3xU4Tq1dsdzy2ZoWCAnjTJMWCY3QRwuvrm63T7ByfZgSuQ4/da9DWmo2RxnjXLExyurnQNTRwELIxTzKmDqabycpj7QDudK0Qpf2G2pOLDUDskHCUjPYs9G3f017nE2yy7IdtzoRT3eSOoV0lnKTlOpE6czXo1bKPnKlCV0oDlHxfLAUUZSa2JdsTzN6jZBe0+BIyecvptzvN469ULiKix+L5bxo+jA8wDPYPEWVzUmm6O2b+IeeZPCaNBKoFxZ3e/FicP50c8LKTBn6pJ7rw6I6LnPCf9IFykk4KuJkrRu9IpzUOCK/33IxzJ8HbQzro3rCMd/Yf3+1xVIzYCctgZx4oYGRc6sd7nn+PUewnZT0GwFlaSi0xnUdbrUipIDVlo8QgvVRRuw7uBJ2pgWjrKDSkBSKL622eDKckuQVo7zCd+oUI991iDyH237EStNHC0HsBwhSWmFdSi/JS7KiQq2+DEe9SgvrW62QrKgrjZUVeA44UnCrVee03+83UNqgKk1R1UJsjdDjfr9x6Gf2mwE/fDJkkJVUlcZxJL3Qo/8GYbhXNWrMYnmbuIpzh8tm/zV5PsyQElqhy+Y4p6g0AvhkY4IBOqFPqXIwcKcTsb6TkhnDh6tNRmnF1qTg62ttbneiWTrB3s3lpWbApxtjtpOStFREnkNaVmSlXAi5V7PqIrUdqiuCtEKPpXaAL2BjlLGTKrYnKbdbMd3IJVMV20WF2ieoKIQgDh2mRUWSV7Qij0bgMMoUyhgw5sA14Won5OPn4yPtwFmtJ48TOXHVtd/WuhFpWZHkamFre42AtV3OwtdxLR0YgStRR0SZlEqz1A6JXIfxrLRPr+FxuxOhKsNq6/ih2ocNYPPjb31VA8uN4jANoBNqAwHQDF2yUi8iLwCyslY9PoqDFvcGUJXmzi7v7HE911cxxPo8FyivM5JGiD05veYtyue9quQzwc71UY7vSiLPoaw0D7eThfbBBytNnnoO68MUIQR3+xGruyrvAAv71It9Yt/FkYKP1+sKGYHv4Mha1MyVkpV2wNfvdPhbn74gKRSd2Ocbd7tsjQsG05KmL7nfi+gEDi8mtfjZl2+3ud+LGCQlSy0P3xW8sxSTFJpMaW61PDqxx9Y0P1PtirPiK7eb/GRzTOgIIldSak1W1cdh76RqriQfB+6Rk6rtSY7rSjxJLaQmwXUl25P8RGHBu7EbJyfjsJRiO7JZ3oSrOHe4bPZfEymgHXoME4XnCEJXkhYVDwcJ7600aUXeorpWXDncW4p5Mc4RAu72Q779Xhet6wV3pc0r1zf0HELfJSgqHCHQwN1eVFf5mFXsaoQ+niP5mQc9XoxLMqXohB7vLjf4fDPlS7djwq2EhucwzEteTEo+WGnQCj2G6d4NtdVWwE5S8P3HQxqBRArJJKsIHEHbd3g0SPEdwUqrrqI1t7lo81o7cJYOsddFTpznJtlZMJ/TvEka9bV0YCw1A3wHkqoOlxWApjZgHpAVFbdbIR9vTghdSS/y6rAkzyGMJBvjnLwyJEVJ7NXhPIdduIMGsHkpt6vq2bJYTos+ZCqoTzEV/GClxXe/2AZYpH1M83KR9nEY88Xcs518kd/nCkjyvYv7k0zor1qI9XkuUI4ykluTnHZYj4dzCqWvjFF7WwlcydNhiu++1F8QCBqBu7g34UzNfK5oPt9hKZTec59X2yGOFFRmFq3oS5QWqEqTqwopBa1A0osDurHPl2+1F6XDh2nB//1vflY/h1KCNview7ffbRB6Lj99r0uhNNvTAs8R+J4k8CRx4BO4IKWkG7n4nnsln6d2HPDBcoP/4ZMX7CQl3djj7/lgmfZM/Cz0HO52Iz7ZHJNkFc3Q5e6uKi8H8WiQMslKHOnMRIgFk6zk0SA9dWST3fk9GYelFJ+sqKDFYjkO++dTv/poQOi5uFJQaWabxj5b05zJLp2GtZne1kGV4+ZVtw4ba+/3Y1bbIc+HKRKBI+ooXwG8vxyzMS5YaUUYA80wxnMdng8zXGl4b7nJxjAj9iWhF+I6cLffoFQKf9/3zStADaYlW9OMcVrRDBzuLsd04oBSa/qNgI1xRln5tCOPu72Yv/3p1mvtwFk6xHaS4hXNrN0O8+Nukp2XFttFcC0dGKHnsNKK2NlKXymn2gqhMhD5Dr/hQQ9BvXt7e1b26NF2ghAwTHKkkAxViefIIx0Q+zvrPCznqnq2LJbT4siDQ5sOO34U3djna2sdvvdosFgsfPN+71i7ko8HCQ3fI/IcVGWYFBUO4pXF2nXtb+e5QDnKSNrQ9KvJUjPgo/Ux7dDDSIOqDEVVcasdku+PcZ2x+z4PpgVJWVcpWW4GPN5JWGqEBK4gLypeTHLutAO2JwVK18/Ayix/d7czrRP53O5EbE1ztic5Td+lEXi4UpKX1SIt5FYn4sUkpyg1o0wROIa8FDiOoNfweHfp8JSLy+TJdsKTQcI37/cWTtUng4Qn2wlfu9MmKyueDpK6BKBXVx17OkgOFM+c82KcsT0pqQOb6vJ9xtT516fF7vyejOCQlOITivtbLHu46mH4V4F+wyctNTtJguc4dCKXTuwjjOHh1pQPV9tEnsM0V3zv4YRew+d+v0FWKFqRf6z5z/4y44NpMRPYlHxjrcPWtOD+UkwjcOg3PB4PUgSaUlV8ba3FOFMkZUWmDJ4H01zzYpLRjV+1VXNx6VRVjNI6bXlaKDzhUGhN5DmLjYZhWi70LI5rB85iM+04AvnH2SS7zOf7LL772g7vd3oRH20dUKbMQD/2afgeZVUtHqTBNGeaV7wYZ0BdVme5GeAJybRQ9BvBHgfEUV4puwiw3FTq3d9XF0zzXeGTkJV1+eJvrHUXRmquSn3kAHVAqc/AdVhq+IvSitd9Qn/eC5TDjKQNTb+ahJ7Dg6UGW5McNVO7v92pw2RfJ4K51AwYJgXawCgtcJ26LGpWVqSlQWO4243oNwK6kY/BMMkqNoYZ7y03X3Gm3W4FDKYFX1/r0PDrXOCng4R3l5qLtJCsrPjlz7e50w1Quk4fKSvNchzgSMlX77Qv6MqdjM+3JkjqEm5lpWvRUVkfh9PVpleVZict6TXqEn5lZWYO22s7vbp2hC6MD3BgvCZb0WI5kqsehn/ZzNdJ7/RjxnmJUnVlkNudkM1Rhuc4daUQVfFkJ2VnWmCMIQ7q9MZQVZSVeO38Z7eNmq/HWupllJ8xta5XK3QBwdfv+Hy42uTTjQkfbU5AFNzvx3yxlTJJC9Y6Ea3AO9JWxa7Dj3fGtCMPgWGUZfzgacpSM8BBcL8fEfou2tSb2mmhLswOHEcg/zibZJf5fJ/Fd1/b4b1ShrYP4+JlwLtHvfZxnFrVtNSC2+2Q7UnO5qRglBSsdSN20hJHCJ4MUlwHCmUwxhC4Dnd7r/cM2UWA5aZS6YNXS4cdP4pTD1BHlPo87aB6FcPkLiOtxYamX13WuhFmJpZ5kntz0KK7F/tEvsPtdsTGKKNQFaO0YmOSYYyg3/Aw5mVf3O1MW26F3CsUjhBkpcYRgnv9mL/rfnfRlq1JzlLTr9M2PYftSY6qDL2Gx1dvd06t/XDeTDLFMCupDKjK4Dp1KHIc1LtoG+McR8IgKShmYsGRV6edHubA8BxJMxAMs7p8n+fWv5/G6TvH7vyejOqQS33YcYvlOByUztqNPcq3qIzqUczneHf7Mc+HGb4rMdowTErKyvC1Oy0ypfloY8rzUUIrdEkKTaUNeanpht4iJfIoXrfhc1g57lxp1icZW+Mc36k1nV54gtVOyFovZLUVvWKr5mPvpKx4b6XBKFN8sT5hnCputSOKsiLyPX6yPuVrd1qL+W2u9JnbgcM4jkD+60qzz9t8WZvx8771fPjyvnWik/Wta+vAyLUmlIIwFiRlvWNsKvB8wfZUMZjmjHPF5jhHVfUk7Fa39pgFpSYrK0ZpiRCGfiPg8U5KnlcLJ8RRCy+7CLDcVIqqQlBry8ziINCz4yfltIPjWZf6tIuBl9jQ9KvLae/Nxjgn9p3FRMlzBL3Yp1Ca91eaBK7kJ+tjHAmrrRBXCjKlmRQlo7Tkbu9VZ9rtTsjD7ZRpoWj4Lg/6EZ67d+IT+Q6jtKLhe/RWAtqRS1FqVlqnr75x3iiteTEtqWaVRlynzlVeadVziLysGKYljdAjdCWVgc1RTic6XE2hFfs8HyY0fQfhuxgMRmtab+DEsTu/J6NSLwP25nZrftxieRM+3ZygKqiMxhGS7WnOu8uvX3S/DczneHVJ0ZCdpCDTGmPgQb/WoQh9wyRXM9tTVwgZTAu6sXekY3g/R234HBpx6jl8550+33u0wyRXLLdCftN7fVzX4U6nrsy1n/nYa0ztnPakJFOmXmR7gvGkohv7KC0YZWqml5EzzhRZURKHHi3fPxM7cBi7BfLnJdCHaUHkO4sI59eVZod6rj3JFNNCLZwIDd/dU8b23DCGxzsZjcCtU8W14fEgZW0m93Acrq0Dw5egRJ0rLAEEGAdC1wEM33+0w61ORCN0EdShtYEnMRriwKkdEAYSVRG6Fb4rWOtHbCUF00zx7nKDehlXs3vhZRcBlpuKJ+sJ4FwUdy7peZoqJIErGWeK6S4Rp0bgvuLU2M9ZOwjtYmAvV03Q1PJmGGNe1d01s+PU/Wn8+TZCCKKZuKcx0Il8hmn5SjUtgM1JQVFpPClpxy6OlHsjDI1hWlRkShF7LpXWPNpK6Te8V2rRXyUcIdmeZMS+h+/UjtFhUeKIDlBPeNU03zP4Ka0JjrDtjcCh34pqZ++scomZHT8tNk31ZHjO3i5gdh23WE5LXiheTAraUe3QzCvDi0nJnbb1jMHelNS5PsVcjHM+j9tOClyn1oMotaEduYzSko1RRr/hvz6l+JjMF+yjTC0KNCSlInAd3ltp8GSQEQe1WLWAQ+eUL8dew7NhTuTV5cbbscfWtKAyAoPgTjtkmCmeDzME0G/6TLLaQRMHDoHrvLEdOIy5QH6mKsZpgTYCreF+L15szh1n3tsIXH7yfEQj8BaaUNuT6WuF9s8EMTOwuyrigZkdPx7XMsAuKytasUcgHbQGxGzH2IDretzrh/i+g5QwzRVCCJD1Ysr3RF2NxJM4ziz8M3RZ68U0gzqsthG4bE7yPd+5P0Vkvgh4f6V5aufFfGf4080JTwYJWWknJ5bLJQ79RWWf+T85O35SGoHL4+0phdKErqRQmsfbUxqvUVab96253sWblmPMZ8Kfu/Eccag4osVyGcztgTYQ+84it/Z1duFWJyIpFaXSGGMolSYpFbdmEUxzfQ2BYZopBIZe7KGNYZQWe77vk80JG6OUpzspUoDvCJ5sJ3y8Odnbb0Wdt7zSChGi7mNCGFY74ZV25E+Lkge9GCNgJ1EYAQ96MdOiBKAzq0imtCYtK5TWLDWDIyMwenHAWidcVHXZ/ftpmS8MdmPTVA+nFR18rQ87brEch2GmuN+P8GfOC9+V3O9HDDPrwIDaSVGoWtzZGLMQeZ6ncNztxSilaQVu7RgIJMOkROvaebzUCM5k7TO3nUlRMUxyqgqGaYkAfuXRgKzU3OuFKGX47MW0ri51yJxyPvYa6jWlEALfcTC6XmO3ApeyqpjkFcbM6/YZ7vUb3O1FLMUBjhRnYgcOYy6Q/3gw5YuthKRUfPl2k+VWiO86i3Sa1817p7niXr+B70qyWcrkvX6DaX4xz/e9XowQkJYVQtS/n4RrGYGxNcnpNwKWWgFqlJGWGkdCO3Z5txuS5BopodIajWAnyRkkJdvTgsoY/u53+7y70iQvK0DQiTyEEJTVyzycz19Mz7XigQ1rt1xFfMfBAxR1FIakHiR85+TP5DRX3O83mBaKTGkCT9Jv1IPj63LkD4oSOK2OhdWssVwHThsptNaNSMuKJFcUVR0B0Ag8MIZPNycErqQdeXzlTmdPNFSlNXEz2PN9Sa7YTkoeLMUkRT0xbYQeTd95pd/e68U8HiQ8G6YUSrPaDsjLq+0UlFKwPS1whaAVuWBge1pwq1s7e9qRh+fIE4XUtkOXSgc8G9ZpqI1A0G+GtN9AQdKmqZ6MwHXw2VtK1Z8dt1hOy1wbr7VrA6coK3JlNxvh9dHoc+f5Sivk6TDlyXaC1iCloR17uK5gfZixkxZ8Y6176rXP3HZuTXIC18VzJWVVl4d/0G+QqaquZpeXGCH4YmvKnc7B5bHnY2+SV7jS8HQ7IS8rRlnB/V6D0K83wNeHKXe6IZ5Tj/eDaYEjIFcpO4litW3e2A4cRlZWbE0LGr5HN/JxHMkgKWlHPoErF/fidfPeXGlaobuopAL1M38RkX7zVPE73dOnil9LB0auNO3ARQN3OjFFVaGNIS8r4shDijpU6bMXKbc7AUmucaUk9hwmqeLzF1NutQJi3yXJ650rIesSjbc7IVIIHiw1zrXigQ1rt1xFXClw5MtUEgFoXR8/KbnSNEOX1hkMjm/i8LOLAct14LRpA6Hn8MFKc+HcA8gKhbdLDDQrFEYIlprB4thOUnC3t3d3aG5HG75LcyZsWfdZtWfnJnBrwbCNUcZyMyTw6lzajzdGvLvcuLIinlLUjlnXkRitEY6kUtUiF3o+VvQbwZ6x4qi0mHkYbif0udUKyUrN5ig78W7Sbmya6skwRiMERA4Lz7uu6uMWy2m51Yl4upMgRF0YQFWGpFSsde3cYc7rUlLnY+paJ2KUlmCgqDSdyMdznLqCUK7eaAN3bjuLqi5zCvWctdbeaFBO6oogndjHdwTDtHyl7Oju81lqBvzwyZDKGNZ6Eb2mzzhTs2iTitV2wFdut8lVNYt6kMSBw6ebOZHnsbQS0gq9N7YDh/F0J2UwrfUsHCEQUrCTlAReylonXmzwvW7ee5mbe2cxL7+WDozAlZRas9yMSApFVlWkeQUObA0zqruGTzbGlJVmOM253avL0S21AroNnw9WW4scrac7KQ+3pjRCl1vtACnE4iKe52TB5rhariKeI/E9yEsode3ICLzTlVE9y8HxTRx+djFguQ68SX/ZPYl8MkjwHH9PX2lFPuVsoT7vAw/6MY7c+9lSCALPYVqoRQSGEND0nT3tWGoG/J0vtusJqCdR2uA6kl4c7ynldtUIPIdu6BH4Lo6AytR57sGuHUNHCv67j9bZmhQsNX3+3g9WjhwrprlitR3ybJjxdKhoBi53OuGxIs0sZ0NlNL4LStf/XAG+Wx+3WE7LWreuhvZsWO/CB57DnU7M2q5dY8vR7J5/LTV8XFdijMFzauHpUmkavruIoDjNxtLCdjoSVRm8WTWuZuAyTEt+sjEkdFwMHpXn0Il8GoF7qK3anhb0m0FdBEIbtDZ0Yw9tXH7qbh0pYmZipMUsGmeaKTqRx9NhRlrW+hfnZQfWhymx5xL5LhujDF84RJ7k+TBjuREs5revm/de5ubeaWztfq5lDPVSs64170lDVip8x0FKidSajaTgyU6GqgytwGVjUrA1zmlHHrfbtadsdx5Q4EpuzdRo0zPItz8uNsfVchXxpCDL66gLKeqfWV4fPylH5UeelDfVsTgLzRqL5Tw5q/5yWF9BiD19YK0Xv/J9ceDSjz0ebtUTdgeYZiXjvNqjgRF6DrFXR0NlSiOFYLVdVyKZXOH88Fbg8ZU7LaQjmZQV0pF85U6L1iza5Pkw5S//4Dmb4xytDZvjnL/8g+c8H6aHfuYoLRlniqVmwAcrzVo0NVP1buMpOa0eytuK73rkJQhTC3cKUzvhffdw7RKL5TgYDJiZIpgR9e+WEzGff33rnT792EcpgyOgVJqiqug1/DfSJZvbzkbgkitFkivysqLf8Hi4PUVVhmboUCrNxigl8iXhLGpwP1lZ8XBrSuw53O9HCAQvJjmlqqNG5nPHsjK0I2+h1/ZikpMWmi/davG1O+0zsQOHIYQAUafIrbbDhY6ENCdbv5613txJOI2t3c+1XC2HnsO9foTvSFwpyUuFlAZNLUWdK8VqKyApNff6EYHn8GKS8/HGmGmmeDTLaZpPEHqxx2qrFuo5bl79m3KWizuL5axICoVwQczqqAoJwq2Pn5SzHBytw89y0zmr/nLcvnLQ932w0mS1HbHS9Nma5DwaJASey71e9IqwV7/p0wo97vViVtshgeuQlXXa2FXlnX6D9WmBL6AXuvgC1qcF7/QbAPyNjzbZmpZErkM78ohch61pyd/4aPPQz0xKhRQCz5GI2U8pBEl5ekfO7ogzIQS+Kxc7lAfxtguCCwyeB1pAWdU/Pa8+brGclqc7KUmuuNOJ+HC1xZ1ORJIrnu4cf5Flecnc5gS+ZJwrhIDbMy2KN5nPzT839h06cYDj1ILMBvjqnTaulHy+lTDJFb2GT1roQ23V1iSvq1dKQei5rPUivr7WQRtTV7KcrdfGaUGu9OJZaIQuq+2QZuCdmR3Yze4xXmNYH2U8GSRsjDLKStMIXL5xt7OYLxzXCX5Zm3unsbX7ubozjdfw/kqLv/TD53QjF1ca0tIwyStagcPGKGetG7GdlJTKMMlyqrFhpRmyNc1QWiMQ3OqENEMHEAuxrpOGMJ1WWPAqh7Wf9pws15+i0ii1q4yqBqnr45eJ1bGwvA2cRYnbk/SVg75vlJaLsNfIc4gDl0lW4kjJ3V2vm5dyqz+nLsE2zcuLKcF2StoNl+1xzsMX04V9e7DcoN2op0KfbEzoRA6BX/8e+JKO1nyyMTn0M2PfY5jUO3TzPHltNC3/9JsRJ0kxtYLg4EuHooT51akqcKr6uMVyWuah+t5sYe25gti4rA9T3l9pXnLrrieh5/CNte5izPIcsdjAfRPbN7dlS7vWLxujDAR8/U6HTzbGeI5kkpZ1aiTBgbYqV5qVZsD6qHYWu7J2ILtOXejhx89HeK4k8lxajlzY2EmmCF2J58gT24HXrbn2j/Gd0ON7D7fJck0FhK5krRPR33U+W5McY2B7mu8RpL4qOounsbX7ubbbl56U3GqFFJUhr6DShnZYe7wAilJzbymiE7n4jstyM2C1E5IpzTRXSAwPtyasj/I6VN7UIUAnCfd50zDPqxjWbkNX324SpRaVR3b/TNTJvchn+SxdZqibxXKdeJO+kpUVj7am5MqQlRXPhjmfbo6Z5BVJsdc2dmOfb73Tx3FgkBQ4DgeKol0lvvfFDsOkpNcIuNMJ6TUChknJ977YAcCVsN9XW+n6+GG0Q5elZrinHNzSG6rPnyTi7KTRGjeRSVkiAQ/2/JyUZx++bXl7mIfq7z04O245Nec1n9s/55yWFc+GKUlZ0Yp8ElUxzBRK60NtVeBKHClnBR3qMT0rKpqBx/1eg6/cbteVqvISbcxizO3FPo6UJ7YDx5kn7x/jB0mB1oLAk9ztRvSbPmlV8Wy2cQH1RsSLSY42EHnOqda458lpbO0rn3G2Tbo48rL21j3dSQldh0laMkwVQghW2kF909y6du/9Xsj7t1qMU0U7dJkUFQ93EgS1Gvk4K+k3AqrKoE8QcngTK4ncxHOyHB8pHEoqZhkkVMxE3cXJDctZP0tnsTttsbwNHLev7N/5ycuKwHX4YnvMNCtQptYT2Brn/H1fWX3l/d3Yv7KCnQfxKw8HxL6LlAJVaVxHorXhVx4OAPi77vf47z/eZJzVpdkrDXlV8nMfrhz6mUvNgOHGmFLX6aCl1pSqYql/+rHqJFE0VhAcsrLeiZSifl7NbFMqu+JlfS1Xm9VWwNNhVlchkbUwZFJUrHXCy27atWW/zVnrHlzO9DTsn3OGrsPHw4zPNiY0AhfpCNqhx9fvdA51tM/HXmPqClxK1eVY31ttLj7XGIg9l8G0oNfwGUwLsrLi8XbK/eUYT4pj24HjzJP3j/GfvZjSb3hIKbnTqQVlk0LxyeaUr93t1r/vSm2EmR1R+sxSWt6U09ja/VxbBwaA6wgcR7I+mlLbakHgOGSFJskVrcilF3m4jsOTnZSNUYYj6omL0rWoy9YkpzKGduhRac0kE2RldawOdRMnDjfxnCzHx5mVGdw/7XNOseFgnyWL5epyUOrBw+2E7bTepXFdB9/UInaDtGSUXI2dmzchU5rBJEM4tYq8EAJTVfSa9YLkp+91+WhjwotJRl5opCNZbUf89L3ukZ+bV4bNcbaoVOB23szRepIU08sshXdV0NpQUVeVMdROjPlxi+W0rPVisrJiWlYUyiCloB97rNmNlFNx3ulu++ecw7RgnCsMAt+tK4MMX2PL5mVUf+3pEEMdFdGMPCaZohXWa8PAlVTaMMlKclXhOw6uIzDC8JPnIxq+QyvyjmUHjjNP3j/Gl5VBC0NZVjzaNmRKIYzB8HL9eh6pjWfJaW3tbq6tA8PzJDtpiRTQ8Fw6cf0A+ELQjjzW+jHvLcV8vDEBoZhmilIZXqQFy42QQpWkBQyTCm00gevwU3c7xCfIEbqJE4ebeE6W46Oqipnedj0RnP1U1cmdDvZZsliuLgft/DQCl8dbCXHo0Ap9HFGnY7pOyeYNSEmIA4fPNkoQisoYHCHAGO4u1SKelTb8/V9e4dkwY5K/LIlaHbEQfrqTMphkOFISegIpBYNJxtMd743y5I8bRWP1gaBSCgM4vLRb1ey4xXJaQs/h/dWW1YQ7I847wnv/nHOQFISeQzv0WG4FVBrGaf5aWzbNFautkGmhyJVGVQYlDTtJwe1ORDf2ebSdMMpLbvsRCHg+zJHU81ulDY6Ux7IDx5kn7x/j26HLrzzcxpGSpKhwpSD0Hb6+1lk4hNqhiysF01yRlhW+I1lqhq84Sy6L09ja/VxbB0bsuySZQlcQ+i55VYdvNmKfwHMolCIpNV9fa/PdxzsUFbQil0FSsD5KMRI+2ki4261zYdd3Mowx/MzdDqPMW4iVHSaukpUVeVnxcDuhEbistOrSrtd94mAnQ283lamLhM2HELPr+Emxz5LFcnU5aOdnpRWQKs2d2GOUFiSZwnUk7y7HNyLvu04hVeSVRlcgHQgcuchTzlWt5r7cDGhHHr4jZ6X5Dk9FeLQ1ZZJXNEIPx6mjACZZyaOt6YUI/V1lQfCLwsxOdb+b3bw9l8ByTtjU1bPjvKNy9885K2VouhKl4fFOSuQ6LDU8zCvCJnsZpSWb45xMaSqtqbRha5Jxu4q41Q6Roo7EqXSdMhg6DqWqKCsIfQdVGVwpj2UHHCn4mx9tspPk9bPWbXC7HfD+agt4uQYtKsNOWovKhp5DpaGsKnwpqKgjS5qBu9A/WmoGZIOEpWawZ/59VSpdnsbW7ufaboVWWrPSDlDakBWKtFSUlWE4LZnmFXllMBj6zZAPllt8sNqkG/ssNX3GeUleaHxXkit4uJ0ReJJuHDAsKnamOVlZHSquspMUPBkkeK7Du8sNEPD5iyllpa/9xMGKJb7dVOXBjorDjh+FfZYslqvLQUKRjpR8+VaTpzspz4cZ46ykrDSPdxKWrrA453HZHBW4wuALgecKfCFwhWFzVCxe83iW/xx5DsbUvx/FOFN4rsSVYpEr77mScWZ3/y8KfUhE+GHHLRbLxXMSceLTsH/O2Wv6DAvFKMkYJSVb45RPt6avtWWDtGBrUiBFbQdCzwEhGOXlYi671otphg7V7HymRYXrSATgO/JYdmAnKfiVhwOMhlbgUVXw0fqQ0ew9u9egvdhjtRXV69ZS8417HVxXUJha6+PDlSabkxzPEeRKX4v590lt7X6ubQSGIyVZUdEKXJ4NE+pSqAYjK57sJLy7HDHOFJNc4TmSJFf84OmQwbikNHXFknbk8XyY4QJp4PJ0mJKriveWGgsF74PCnT7ZHC8eJJA86LsUSiMFV+rhOC3W4/z2UhwSaXHY8ddhnyWL5WpyWITUWi/iB0+GtAMX15GoSrMzLQnDa7vfsWBjkmKQSGmoNEgJBsHGJK1fYAy50kzzDG0MUghcp04zOYxW6PJinDPKSrSu8+RdBMuti9npsmVUz95uWSxzXlfi0nJ8LiIqd/ecc3OS8iuPBoSus9CBmBzDlpXKoHTF9rSOvnCkwBHQiXzeX2kuxtx26PM0S3i0nfB0kCCFIAgclhs+aqRfawc+2RyjNDRDl7SoYFbR5PkoZWtSn8NBa9CNcYonJZ04oFJ1ed9MaWRRXZ807VPY2v1cg7M8mKyoiAN3lg/k4UjDpCiZlppO6KEqQyAlX2xNeLKT8JPnI5JcEfr1A/LZi4SNcQZGU1CLexVlRSf2GGeKUVqSK423T73QcwSTTB14fHfoy/wB/3RzYsuQWq4N+8save64xWK5nhy2Q7MzKflwpUWpNevjnFJrPlxpsbFz/TUwSmWY5BVpqVGVJi01k7yiVPWkKa8MRhsG04L1UcZgWmC0Ia8On1TV5dkVVVWLqFVVLaq2ekGVCmwZVWu3LOfDWZaCt1x8VO7GTn46W2YMAoExdUK1mf0+X1zvHnMl4LmSftNnmBXoSh/bDkwyRVlpNscZ20nOMCkY53XayXwNWmnN82HKF1tTng9TKq0RwOakTjmRwqAqzYtxHTEyTxO56s/uaWztfq5tBEZe1tEX0hH0Gz7d2GeQ5gSuw+1uyChVpKqiGTg8Hya0Gz5Kw6RQaK2RsnaCCAxFVdFYirnbi2kGLlIIklLRjrwDxVWaoXuk6IrdEbFcVw7TPLNaaBbLzeOgCKlhptic5Kx1It5ZkpRKsznJcZxru9+xQM+yn+WuU9EVi/LpgyRnnFUst4JF2cRxqhgkh094A0dyuxvPVN5f7iQFF3S9bLWn+h6e5LjFchzOW3TybeQio3JPa8sCz0FK6EXhosTnMM0JZuu3+Zj7fJjTDH16rpw5LqATeiDqaJPX2YFm6PLJxoRJXtIIPDyvzhYoKsMgLbjthjzeyWgELpHnoLTh8SCl6XvkVcU0VeRVRaE0rhS0A2+xzpyXgt2evoweapygSMV5cxpbu59r68AIPId+MwAMUkqyoq4kEjoSgSDw6t2ITzanZGXFNx90eBKkPNpOcIBxVpJVFcYYTAWjXNEOXSplyIoSIwQjX7EzzVlphQunRaEqPlhpLXY3DgqDsoOe5brizMuOHHTcYrHceHSlKZVmUlTorEJKKJVG34Dt7MBxQdQTUj1LIRFidhwoSz07Vg94Qoj6/Msjzl0IPlhpMpztmAWupBN5XFQFT1vtCVyHV2t/z49bLKfEOgevN6e1ZZ3YJ1cVWakpqtopvdQM6My0M+ZjblFpoplTQxl4b7mJP9O9uN0JX2sHPlhp8d//ZBOlQRuDKgxZWXG3G9VRgUJQlIppoRbpiZ4AzxN0TUBWZpgK2pHH7VbI7W602CTfL0TqSEnolqy0Au72zub6vgmnsrX7uLYOjNVWwCebE263Y56PUowxJAUgBGlZcW8p5k4nnCnDVvzqwx2WWj6x51CUBkeCg2ClE/HeUkxawudbCe+vNCiNQzt06cUerhRsjDPKyqcdvfRuhZ5zqOq3HfQs15XQg+kBDtDQu/i2WCyWi6cV+ejBlKwUuAKKCozRtKLrL+Lpu4LYk5TaUIk6t9mTYrH4913J6qwSS6b04vejCFyJNnC7Ey2OFUrjXZDT11Z7gsAFDhDsDK7tDNdyFbDOwevNaW1ZXYI0ZporikovKmTM13XzMVdQO0SEFAigN6uCudwMuN2JXmsHurHP1+7WpU+HSYnnSL50q8VSM0BQryUrA9u7NFiWmwGFMqSl5p1+jO9KCqXZSRRm1+7jXIi0Fbn4s+iNrUmB616N3cjT2Nr9XNvhfa0X47sDWpFLFDR5NkjJK28RJrPaDMjKun7vg6UGv/ZkzCRVGKNJ8pLId+hEPq3QIykMriOIPVGLsLgOq60QIQTtyJvlGbFnQnBUGJQd9CzXlU7TZycvmAdizH92mtd/8WKxWF5PFEg+uNViklWkpSLyXJqhQxRcf/vVCn0QgtB36nxmIagqXR8HbnUinu4k9CJ/Ifo2LUrWuoc7Ay7bgWDLqEKnETBI8z3FEc3suMVyWi67b1vejNPasteVIJ2PuUIIHm5NaYQuX1qtq4Co3HCvVzsvjvOsfLDSIvIcGr73is15PkrZnpZIKXCkYJiWvBjnTIuSd5YaSEeSK4PjSJaaPmJXtEepDFLOtDsAgUBKs9B7umxOY2v3c20dGKHn8KAfMUwKXkwK3ltt4AqJEHWqhudKdpKCr661ac5EPT/enKAqaMc+/bhOCUmVpuUKQtdBSEFaVNzrvQzDycqKwTRnmNbu/YMUiPerFDcC98gUE4vlqnKnHbMxKMg0i8lgJOvjFovl5nO7HTLNKu71AwJHkFeGaaa43X4zUcqroObfDByaoWSSGZTWuFLSDCXNoG7HWjciLatFHrIUgl4jYK0bHfqZV8GB8LZXe7rViljfycl3aTWFbn3cYjktV6FvW07PSW3ZbhslhJhF8IsD73voOby/0qTf8Plkc8zzUUbgOnRCF23Ae41A6e7vKivDtKiLQ+y2OZ+sj9lJCiLfYZqVGOrovlKD50gaoYugFm6O9m2Q+45gpRWSlbMIB0ey0gq5GvEXp7O1+7m2DoysrKg0fOV2m7W8ZHNUMMpKAlfSawREvkMvDug3AoQQfG2tgyMlK82AnaTge48HpGXFSsOvH7pGQDesRUEdKcnKivVRypNBhucKVhr+QsV190N5kGDn1iRnqRkwzZUd9CzXimboEocSU2hKBZ4LsS9phtd2qLBYLCdgpRXiOZJnw4xhpmgGLl+906Ibnz4K66oIW/ueQAqHyNMoDa6USCHxZ3G+oedwtxvxyeaYJKtohi53d+UVH8bb7kC4bJqhS+RLNC/tVmTtluUMsH37+nISW7bfRo0zxeY4q9NCDomenzshVlsRd7u7SpG/xmbs/q65VMHmOKMderQjb+Hcz8qKW+2AF5MCkIR+vUG+Pc2pZhU8erFPqTTGGN5bbi6+41Yn4vPNMaUBYwyl1lBo3l1pvfF1PQtOa2t3c21H961JLa65Pc25E8SstkIebiVIAV+702ZzUvBinBF6ksivvVT3ejGDac7zUf2gBG4dflOlJe8uxciZ9+vFOGVaaKa5InQlSmvymcL4vDzZ6wQ7p7myg57l2qG1oawMcSCRvkCLOuRMX5QincViuVTmJdi+crt9YPjsabgywtYGKm1wHIGUtdB3pc1CuPigCenWrFyd3YC4uli7ZbFY9nMSW7bbRmVlxfY0x5WSXFVo4x3ocD+tXdv/vsOkCtqxxzApCD2HVigYZSU7aYnv1boXZWUwkaE0BkxdkXNOv+Hzk3VQlUaKOqXEOHLPay6Ts7C119aBkStNK3TxXclgWrAxzIl9h2bo0m0EhL6LBJ7upLyz3OBWO+DJoOLFtOD91SZJXvHp+pBBUdFyJVNV8UE3xpGCXNV6FS8mdanW1UaIRDCYFtzuhHvEOK1gp+UmMc4V/YZHqeuctMAReIFhnNs6qhbL28B5hE1fFTtZlJpO6KGModAGXwpcIShmyudXxtFiORHWblkslv2cxJbttlGDaYHvOLhOXRRibg/224HT2rXjvu9+v4HShp2k5PNBRu1plzgSEHCrHbLcChfaj9NcLaJLprniw5Um00LtKaO6+zWXyVnY2mvrwJgLZYaew51uRFHVdXAd+TIU9P3VJr1GXT0kV5pKQ1lpXoxzJllJqgzdyKUX+6R5RVFpHnRivtia8pXbbfyZurjnSIwxpGX1ihinFey03CRc6eA5gjj0MUYjhKQsC1xpdx8tlreFsw6bvip20ncdPE8QSReNQGJQusJ3bQWx64y1WxaL5SCOa8t226h5eVSlX9qog+zAae3aUe/brY0B0Gv4DKY5Wle0ZoUnCmVIc0Vnuck7Sw2AWSXOvZvrzdClFb0sIbj/NZfJWdjaa+vA2K8OLICkqLjff/mglpVZlD7NyoqHW1Me9GOeDqbImRJ5M3QptaEXeISzhyotKz7dmOC6gqysy7vsTAtypVGV5utrnUPbcVGCnVdBEM1y87jdDdgcp4yTHFVpXEcSeA63u1bN3WKxnI6roubfa7h8sQ07SUmhFb50aQSSXqOeCl0VR4vlZFi7ZbFY3oQ9NmpW0MEAtzu14OdBduC0dm3/++Z6G7Hv8NHzEZ7n4Mpa0sB1JMIIvny7gwYC1yFXFZ70GSYva0cftLk+ztShpWAvm7OwtdfWKs+9alLUjoulZkA/9pBCYIxZlLCZ5zptTXIagctqKyT0fW53Qt5frj1XvdjnS6sNprni8faUe70YKQEjyMuKR9tTxpnididktRWyNcnJyurAdpSqQgjB052UJ4OEnaTgySDh080JTwbJ4n1vwlwARhuIfWchLnoWn215u7nbiSmritJUaAGlqSirirsdGz5tsVhOx347KV+j0H5edOKAtKhQ2oAWKG1Ii4pOXM8TlpoBhaooZqJo++cRlquJtVsWi+VN2G2jQt+l0pqlRi3geZgdOK1d2/2+QVLyYpyx2grJlWY7Kdme5DhS4ErJNC8RQrDWi1hqBviupBV6VNqgtDnUTjUCl082JzweJLwYZzweJHyyOaERXI24hbOwtVfjTE7J/tCgeVTCQblOudKstALWRxlLDZ8kV2gtCF2XD1aalMqQV5oPV1q0Io9W6DGYFkxzRSPw+MZaZ/FZhdJ78nTm7Vgoyzpy4VX7yfMR9/sNXEfwdJjy0fqYB0uN16rUHoXN0z1f3ubolkle0ot9hllJoWrvaCf0mOTl699ssVgsh3AV1PwH04LId9G5ojDgSoh8l8G02NNGWzbxemHtlsVieVPm4/9djl5PHvSe034XgwRXCia54odPR7gSpJCM0jF3uhHhTLDz0XZKO/IW5WAzpbnXCA5t3/a0wHcEEofKaHwpcZ36+FXQwDgLW3tuDgwhxB8H/lFgwxjzU7NjfeA/A94FPgf+KWPM4Ky+86gHKZjpWdzuRAgheDJIaESSLzWbrHVjClURZy7jrGQ7KfAdSRw4eI4kLyt2kvqmh55DpTWPd9JXFrj7HQtz58dWkoOpa/W2Q4+tSY4x5tQTI5une35clXJ/l8UgKTHGELgujqhDcY0xDBI7EbRYLNebQVJSVXWUpCNEXYWkqvaMb1fB0WI5GdZuWSyW68goU2yMUrJSsz3OSFVFK6xLqRoDm+MMIQ3t0GNnWpCpitB1WGr43F9u8P5K88DPXR+mdCMff9e6pSgr1ofpoe+5aN7U1p5nCskvAr9937E/DPwVY8yXgL8y+/1CmIerSCF40I/5qbtd+rFPO/SQov57WijKyhB5DmlZ8YPHO7WzwHPRBp4PM4ZJweNBguvKV9I3cqXxnJf5PEWlCT3Ji3GB70o8R+K5EgOLcqynYZ47tBubp3s27HZCCVE7nd7kXl03poViXCgCz6m9vZ7DuFBMC6vmbrFYrjd2fLuZ2PtqsVjOiotM0x8mBVuTumRrHNYxBeOsZJIqDAatBcZA5Dv0Gj632iG9hk/kO+RHtEcIAWL/wdnxG8K5RWAYY/66EOLdfYd/F/BbZv//J4C/Cvyh82rDbvaHq8S+w294p7/YVf90c0Jl4PlOWj+wWgOC7aSgrDRCCFqRw8cbE9qRx2ornC1wX6Zv7Bcl8R1JNivP5s6qo6jKLFJMThsxcVUE0W4ib3t0iyMEgXTJywptNFJIAuni3KBBz2KxvJ3Y8e1mYu+rxWI5Ky4yTT8vK1wpMRiagUehqlp8syjRBpaaPptjjSMknlNvjHuOxBGSpDzcQbvaCvhsa4qqDNqYmSCo4L1Z1ZKbwEVv2d8yxjwDmP1cvcgvnzsx3l9pstQM2JrkfLo54dPNCR+vj4k9h/v9CIHgk80JO0lBL/b5YLWJwfBsJ2OUldzr7dWv8BxBrvQroiSNwGWal3Rij7LSlEpTVBW9hv9GERNXRRDtJvK2R7d0Yw/XFWhjqGYDn+sKurH3+jdbLBbLFcaObzcTe18tFstZsT+aHl6u886awHNYaQcLB0Mn8unGPgYxyw7wacc+66OUQmkCR1AozfooxZGHr0v6zQClNKoyGFNvniul6d8gQeorK+IphPgDwB8AePDgwZl+9n6dg0fbCdOyoq01zcBjreeyNc3IlabX8Ak9l7s9lyRXbCf5Kw/NfIF7UJTHt97psz3Jebid0AhcbrVDpBBvHDFh83TPh7chuuWovtUJ6zJLnUaA0BojJWWp6IRXdqiwWK4M52m3LG+OHd+uL9ZuWSxnj7VZr3KR5bRXWwFPhxm9hk/gSX7t6YjQdfhguUE79NgYZXiOYKUdoqq62ITvSuIgpNKHO1SmueKD1RbTQi30Ghu+yzRXV0LE8yy46NF9XQhxxxjzTAhxB9g47IXGmF8AfgHgO9/5jjnsdadhf3iQAW63A16MCwK3rr/ru5KdaUHsORhjZmE4mtvtiELV6QQHLXAPcix0Y5+1mWMjVxrPRkxcWd4GFfqj+tZyO2KtU6AMYDQIiRv7LLejy2iqxXKtOE+7ZXlz7Ph2fbF2y2I5e6zNepWL3Mhcm1WwnJYVg2nBUtNHGGjHdcnUXqPB050U3xG0Ag/XEbUjQyli//AIs1xpmqFLK3r5GmPMjUqHv2gHxl8Afh74I7Off/6Cvx94VefAdyRaCLqxQQpIy4rId/nqnTZCwMPtBEwdptgO3YUzIikqMAYhBE930iNLbtqIiTfnosqbvs33arUZUNxq8P3HQ4aJohO7fOVeh9UbFHZmsVjeTuz4djOx99VisZwVF7mRGXoO76+26u/KFaErEbui/D1H4DuCZujxbJjOqlu63OlEtI+IMAtcySRTr0RgRP7N2Yw9t8R+IcSfAv4H4CtCiMdCiN9P7bj4bUKIj4DfNvv9wpinjmyMMh5tv1SU7TV8krJWsL7VDrnTiXi3H9OZaVXc6YTc6YQYDOksB+puL2atG2EAz3m1IsllMj/PTzcnV6I9Z8FFqgK/zXQbHt9/NEYIwVLTQwjB9x+N6TZsLrHFYrne2PHtZmLvq8ViOUt2ayaedxT2/Lvu9xuU2uBJSeQ5GAO//nzMw+0p/82vPef5TsZyM6AT+myOMhrB4Q6MRuDyaHtKXmpCV5KXmkfb0yPfc904zyokv/eQP/3W8/rOo9ite3G7E/J4kPJoe8q9XowjJY3AIy0VP34+ohm63O3GfP5iytYk54UBzxV0Qo8kVzzdqevoHkep9qKiBg46z9h3KCvDk0Fy7dMgLlIV+G3m6XZKXpW82MlJlSZyJcutgKfb6WU3zWKxWN4IO77dTOx9tVgs1x5jKJRmWmRobUgLxSfrE6SsBYlHWcF3H5Z860GX+/0G01wRes6Ba8xprlhphzzbyXg6VDR8lzvd8EZpYFzr0goniTTYvQCOfJf7/ZjAc3i2k1JWtbLr/V6Dr9xu0wl9fvR0SFpWrHVDpAStIfQdHCF4uDUlK6vXKtVeRtTA7vOsy7xKfLd+wK8zF6kK/DbzvUc7jNOS0HPpxbWA7Tgt+d6jnctumsVisbwR33u0Q5Iruo2Ae92IbiMgydW1H99uYtTlSbB2y2KxXCTnMebmSuNKiaBe6zzeSiiruqplr+Fzqx3RClyGaUkzdBml5aFrzFFaMskUy62AD1aaLLcCJplilJZv3M6rwrV1YJzUObB/ARx6Dvd7Mbc6EYEraUX+YtE/LRSNwENpzfa0pOF7RL7DKFUIKWiELluT/LUlNy/DmXBTF/pve3nTi+LxIAEj6DQCeo2ATiMAI+rjFovFco15NkwJHZelZki3EbLUDAkdl2fD67tTb9Mrrd2yWCwXx3mNuUlZR1SsdSPu9xsgBZ3YRQiBNgLXkcS+ZH2UU1aGpFSHrjGTUiGFwHPqv3mORApBUqozugqXz7Vd/Z3UOXDUAnj/oj9XmtCTRK5DUigMBkdAWlQUSrPSDMiVZqkZUKj6mJmF/hSqYmkmHHUZzoSbutB/3bW2nA2hJ9EYVKUxRqMqjcYQetf7+bFYLJZO5KKMJisrtK7IygplNJ3o+uYF39Soy5Ng7ZbFYrkozmvMjX0PbTTlbJ3DrAJmrxlQVhpVGSptEAIKVRH73qFrzP2fVSqNNvrIyiXXjWs7up/UOfC6BfCj7YQvtqY820kxGLJS0ww97nYjKmOYFBWBJ7ndCXGkJHDlQnhFCkiKCjkrjwocKBYK5+9MuKkL/cOu9XXW9biKfHirTSPw2J4WPBokbE8LGoHHh7fal900i8VieSN++n6PRujzYpLz2daUF5OcRujz0/d7l920U3NToy5PgrVbFovlojivMbcdujRDjxfTjE82xzRDj0pA6EpageT5KOGjzQmtwGWpGdAO3UM3rNthHWkoZpU1hYClZnhk5ZLrxrV1YJw00uAoZ0M2KzPjSoHWhmmmWB9nTPOSvKxIc0XsO9zvRWyMMn70dMgX21N+9GzE1iRnqRkslGqBRWjR7U5Irmrl17RQF+JMuMkL/YtUBX5b+c67PbJKUypFpeqfWaX5zrvXd4JvsVgsAL/xvT6ZqihKRTX7mamK3/he/7KbdmpuatTlSbB2y2KxXBTnNeY2ApfHg5S81PiOpNfwcaVkkBT80sMddqYF93oxtzsRT3ZSGoF76Ib1UjNAinpT+0E/3vP7TeHaumKWmgGfbE5IcoU2BikEceDywUrz0PfMF8C7eTJIaEU+jdBjJylmSq4OVWXwPQetDautkHGu+GJrSjPwCD0HV0iGSY4rBdmuKh97q2VI7vdjNsYZz3ZSHiw1LmThfdB5zrnoqiiW60VWahq+S5IpDBop6trRWfn27OZZLJabyfoop9/wqZQhU4rQdek3fNZH1zfd4jRzoZuGtVsWi+WiOK8xd3ta4DsCiUNlakHPyJXsJCWBI2lFHi3fw5WCwTQnmq31tiY5SVERuHLPGvOov90Erq0DA0AYAwIwgJj9fkLqXCEHISS3OxEATwcJAnjQbyxe93BrCgJ8R6INeI6kVJpprlhqBotynvPPmzMXC02K6tLLfd7UEquWs+N7Xwxo+pL+WhthwAgoCsX3vhjwj/zM3ctunsVisZyaX/58QCd0edCPkbOIy2FS8MufD/ht37hz2c07NWcxF7rOWLtlsVgukvMYc9eHKd3Ix5+txx5vT3GkZJopvnG3g5CCtKzYSUpWWwHrw3RP9P9+jtrMvglcWwfG1iSnFfkstV6G7BRKLxwJx2UeCuS7L/OZkrKiEexd0GtjwEBuNNHs4XKd+mHyHEFSVId+3lUJ59wbHcKijSe9Zpaby4tpTtN3aTVehpmNZ8ctFovlOjPOS5q+g+PUNtBxBIEjGefXt7TcWc2FrjPWblkslovivMZcIQTsktbYnpZEnsR1JELWVUhCY9hOclbbQf36t5hr68DYH+kA7HEkHIesrMjLiofbCY3AZaUV4EiJAJrBXqVWOXuwfEeitMFzBKoy+I7c46BYagY8mZXu8hxBWRkKdfnRF3A218xys1luBazvZJTkC89ynlfc6oaX3TSLxWJ5I+71Ir54kZBWZjG+FUXFO8uXb59Pi7Xr1m5ZLJaL47zG3NVWwNNhhhACVwpKVVfKaoYuj7YTmqFH5EkM9Xetdd7u8e3ywwJOyZuKqMzTKTzX4d3lBgj4/MWUstJ8fa0zK1PzUhglDlwankPDd8nLiiRX5EotRFTmwihXWUTTin1ZXsfP3O+iRZ1TXJQVWanRoj5usVgs15lvvdMDWauy56UiLSuQs+PXFGvXrd2yWCwXx3mNuWu9mH7sobQmKRSN0CEpS+72Y/qxS1oqHm2nhJ6kH3usXYGN8cvk2kZgvGmkw36xzQd9l0JppIBu7C8EOefiJ3Nxlq1JTifySEpFyw+IfecVIcyrmnd0laNDLFeDD5ab/PTdbi30WlUETv18f7D89gjCWSyWm8lKM+Rn31/mySAhKSvima1eaV7fnSxr163dslgsF8d5jbmh5/D+amtRaMFoQzPwEFIQOALfrVhqwN1exPurrSuxMX6ZXFsHRvga9dXX8boQoMOcEHd7MXdPuFlzVSp/vOk1s9x8At/l7/mgz4+ejxkmJZ3Y42u3WwT+tR0qLBaLpUYIvnq7RSNwmeSKZuByvxfBNc4ltnbd2i2LxXJxnOeYu3/t2Wv4PBqkaAQr7ZD7vQjPdd6q8f0wrvXo/iaRDhcltnnVKn9c1egQyxXBGEZZxZdvtXGlQGnDKFM0g7dL1d5isdxAjGFzUrDUDLjVDlG6/v265xK/9Xbd2i2LxXKBXMiYe0Pt1VlxrR0Yb8JFhV2eZ+WPqxLZ8abclPO4EQjBOCt5tD1d3I9u7EM3uuyWWSwWy5thx7ebib2vFovlpmHHtSN5e1Se9nFRYpu50njO3vBUzxHkSr/R584jO7SB2HfQBp4MErLyeimP35TzuCmMspLhNEebusKONobhNGeUXd8ygxaLxQJ2fLup2PtqsVhuGnZcO5q3NgIDLiYE6LxSVc4zsuMiuSnncVN4PkxphD7t6GUZ4VFa8nyYwv3rq9RvsVgsdny7mdj7arFYbhp2XDuatzYC46JYagYUqtpTknV32dXTcl6RHRfNTTmPm4IjBFKA0gZjDEobpKiPWywWy3XGjm83E3tfLRbLTcOOa0djHRjnzHmlqtyU2u835TxuCv1m7e0VAjKlEQLakUe/6V920ywWi+WNsOPbzcTeV4vFctOw49rR2FXiBTB3Yry/0jwznY3ziuy4aG7KedwUPlhpoSpN03dZ64Q0fRdVaT5YaV120ywWi+WNsOPbzcTeV4vFctOw49rRWAfGNeWiREjPm5tyHjeFbuzzrXf6OA4MkgLHgW+906+Vjy0Wi+UaY8e3m4m9rxaL5aZhx7WjeatFPK87N6X2+005j5tCN/b59jtLl90Mi8ViOXPs+HYzsffVYrHcNOy4djg2AsNisVgsFovFYrFYLBbLlcc6MCwWi8VisVgsFovFYrFceawDw2KxWCwWi8VisVgsFsuVxzowLBaLxWKxWCwWi8VisVx5rAPDYrFYLBaLxWKxWCwWy5VHGGMuuw2vRQixCXxxyJ+XgRcX2JzDsO3Yy01vxzvGmJVz+NwL5Zr0rf1cxXZdxTbB9WzXTe5bV/V+nAX23K4+N7lvzbkp98pytXjdc3Xt+9Zr+tVhvI397W08Z7i88z6wb10LB8ZRCCH+jjHmO7Ydth1XuR3Xkat67a5iu65im8C266pxk8/bnpvlKmDvleU8sM/VwbyN1+VtPGe4eudtU0gsFovFYrFYLBaLxWKxXHmsA8NisVgsFovFYrFYLBbLlecmODB+4bIbMMO2Yy+2Hdefq3rtrmK7rmKbwLbrqnGTz9uem+UqYO+V5Tywz9XBvI3X5W08Z7hi533tNTAsFovFYrFYLBaLxWKx3HxuQgSGxWKxWCwWi8VisVgslhvOtXZgCCF+uxDix0KIj4UQf/gCv/e+EOK/FUL8SAjxQyHEvzw73hdC/GUhxEezn70LaIsjhPiuEOL/c4lt6Aoh/qwQ4tdn1+TvuaR2/K9m9+MHQog/JYQIL6MdN4HL6lv72nBYP/vfCSGeCCG+N/v3D19C2z4XQnx/9v1/Z3bs0p41IcRXdl2P7wkhRkKIf+UyrpUQ4o8LITaEED/YdezQayOE+Ndnz9mPhRD/0Hm37zK4Cv3prDjp/b1OXCXbbjma1/UpUfPvzv7+q0KI33AZ7bRcHw4a2/b9/a18po5rv4QQf7cQohJC/JMX2b7z4jjnLYT4LbO51Q+FEH/tott4HhxjbO0IIf5LIcSvzM77n7uMdl5bB4YQwgH+feB3AF8Hfq8Q4usX9PUK+FeNMV8Dfhb4g7Pv/sPAXzHGfAn4K7Pfz5t/GfjRrt8vow3/DvAXjTFfBX5m1p4LbYcQ4i7wvwS+Y4z5KcABfs9Ft+MmcMl9azeH9TOA/6sx5puzf//VJbQN4B+Yff+8rNSlPWvGmB/PrwfwbSAB/ovZny/6Wv0i8Nv3HTvw2szu5+8BvjF7z38we/5uDFeoP50Vv8gx7+815CrZdsshHLNP/Q7gS7N/fwD4Dy+0kZbryC/y6ti2m7fumTqu/Zq97v8E/NcX28Lz4TjnLYToAv8B8DuNMd8AfvdFt/OsOeb9/oPArxljfgb4LcC/JYTwL7ShXGMHBvAbgY+NMZ8aYwrgTwO/6yK+2BjzzBjzy7P/H1Mv2O/Ovv9PzF72J4B//DzbIYS4B/wjwH+y6/BFt6EN/H3AHwMwxhTGmJ2LbscMF4iEEC4QA08vqR3XnUvrW7s5op9dVa7Ks/ZbgU+MMV9cxpcbY/46sL3v8GHX5ncBf9oYkxtjPgM+pn7+bhJXoj+dFSe8v9eKq2LbLa/lOH3qdwH/qan5W0BXCHHnohtquT4cMrbt5m18po5rv/4l4D8HNi6ycefIcc77fwb8OWPMQwBjzE049+OctwFaQggBNKn7jLrYZl5vB8Zd4NGu3x9zCYsbIcS7wLeAvw3cMsY8g3oiBKye89f/UeBfA/SuYxfdhveBTeD/JupUlv9ECNG46HYYY54A/xfgIfAMGBpj/tJFt+OGcCX61m729TOAf3EWwvnHLymc2wB/SQjxS0KIPzA7dlWetd8D/Kldv1/2tYLDr82Ve9bOgbfhHK/Ks39mXLJttxzNcfrU29DvLBfL2/hMvfacZxHQ/wTwH11gu86b49zrLwM9IcRfnc0Ff9+Fte78OM55/3vA16g3ib8P/MvGGM0Fc50dGOKAYxdaUkUI0aT2OP4rxpjRBX/3PwpsGGN+6SK/9wBc4DcA/6Ex5lvAlEsIr50tzH4X8B6wBjSEEP/0RbfjhnDpfWs3B/Sz/xD4APgmtbPq37qEZv2cMeY3UIfZ/UEhxN93CW14hVkY3+8E/l+zQ1fhWh3FlXrWzom34RxvFJdp2y3H4jh9yvY7y1nzNj5TxznnPwr8IWNMdf7NuTCOc94udcruPwL8Q8D/Wgjx5fNu2DlznPP+h4DvUa+1vgn8e7No/AvlOjswHgP3d/1+j9obdCEIITzqCc6fNMb8udnh9Xk42ezneYYT/RzwO4UQn1OH+PxPhBD/jwtuA9T34bExZr4z/mepHRoX3Y7/KfCZMWbTGFMCfw74ey+hHTeBS+1buzmonxlj1o0x1czj+x9zCSkHxpins58b1FoTv5Gr8az9DuCXjTHrs/Zd+rWacdi1uTLP2jnyNpzjVXj2z4QrYNstr+c4fept6HeWi+VtfKaOc87fAf70bD3yT1JrWf3jF9K68+O4Y8xfNMZMjTEvgL9OrQN4nTnOef9z1KkzxhjzMfAZ8NULat+C6+zA+B+BLwkh3pvtOv4e4C9cxBfP8n7+GPAjY8y/vetPfwH4+dn//zzw58+rDcaYf90Yc88Y8y71uf83xph/+iLbMGvHc+CREOIrs0O/Ffi1i24HderIzwoh4tn9+a3U+csX3Y6bwKX1rd0c1s/25Zz+E8CBiuHn2K6GEKI1/3/gH5y14So8a7+XXekjl32tdnHYtfkLwO8RQgRCiPeoxdH+f5fQvvPkSvSnc+YqPPtvzFWw7ZZjcZw+9ReA3ydqfpY6rfTZRTfUcqN4G5+p1/Y1Y8x7xph3Z+uRPwv8C8aY//eFt/RsOc4Y8+eB3yyEcIUQMfCb2FtU4TpynPN+SL3GQghxC/gK8OmFtpI6/OVaYoxRQoh/kVrx1gH+uDHmhxf09T8H/DPA94UQ35sd+zeAPwL8GSHE76e+wZehSHsZbfiXgD85e9g/pfbOyYtshzHmbwsh/izwy9RiMt8FfoFaYOay78m14pL71m4O62e/VwjxTeqwts+B/8UFt+sW8F/Uax1c4P9pjPmLQoj/kUt81mYG9Lex93r8mxd9rYQQf4pamXpZCPEY+N9yyLhkjPmhEOLPUDs9FfAHb1gY6lXqT2fCSe7vNeQq23bLjMP6lBDin5/9/T8C/ivgH6YWBk6o5yUWy6EcMrZ58PY+U8fsazeO45y3MeZHQoi/CPwqtRbhf2KMuaxNojPhmPf7fw/8ohDi+9QpJ39oFoFyoQhjbnr6lsVisVgsFovFYrFYLJbrznVOIbFYLBaLxWKxWCwWi8XylmAdGBaLxWKxWCwWi8VisViuPNaBYbFYLBaLxWKxWCwWi+XKYx0YFovFYrFYLBaLxWKxWK481oFhsVgsFovFYrFYLBaL5cpjHRgWi8VisVgsFovFYrFYrjzWgWGxWCwWi8VisVgsFovlymMdGBaLxWKxWCwWi8VisViuPNaBYbFYLBaLxWKxWCwWi+XKYx0YFovFYrFYLBaLxWKxWK481oFhsVgsFovFYrFYLBaL5cpjHRgWi8VisVgsFovFYrFYrjzWgWGxWCwWi8VisVgsFovlymMdGDcIIcTnQohUCDERQjwXQvyiEKI5+9svCiGMEOJ37nvPH50d/2cvpdEWyxVHCPFXhRADIUSw7/jvEUL8bSHEVAixMfv/f0EIIWZ//0UhRDHrj/N/v3I5Z2GxXD122ayxEGJHCPE3hRD/vBBCzv7+i0KI/8Ou1/9+IcSvz16/LoT4/wohWpd3BhbL1eKoeeDs743Z3/6rI957YH+0WN5W9s3j9K4+NhFC/M9nr/kts/XUv7bvvd8SQgyFEB/uOvbtWR9794JP5cZgB6Wbxz9mjGkC3wS+Bfzru/72E+Dn578IIVzgdwOfXGQDLZbrwsy4/GbAAL9z1/F/Ffh3gP8zcBu4BfzzwM8B/q6P+DeNMc1d/37motpusVwT/jFjTAt4B/gjwB8C/tj+Fwkh/n7g/wj83tnrvwb8mYtsqMVyTThqHvhPAjnwDwoh7hzy3tf2R4vlbWL3PA54yKyPzf79ydnLfh7YZtc6a/be7wL/PvAfixoP+OPA/8YY8/nFncXNwjowbijGmOfAf01twOb8l8DPCSF6s99/O/CrwPOLbZ3Fcm34fcDfAn6RmVESQnTg/8/enwdJtqWHfdjv3D1vrrV2d/X25vXsC4AHDAkSFEkIIEQyQBmkHaZJkwZs0UZYksOmJQcXhWQFGeGwFKZpyiEqZEphByiYNkGHKUJiUCIJmgsMEvQMHjDgbO/N23qprq7qqlzvvhz/cTOzs/bMrJtVWVXnN9FTr7Iy7z15z/ed5Tvfwp8H/g0p5f9LStmXBe9KKf+YlDK6uuYqFNcTKWVXSvmLwP8A+BkhxJePvOW3AP90uBhESnkgpfw5KWX/stuqUFwHTlkH/gzwn1Ks/f7YGZ89Tx8VCsUQIYRLYRz8N4HPCCG+euQtfw64B/ws8O8AA+A/vtRG3jCUAeOGIoR4APx+4HsTL4fALwJ/ZPj7TwN/9ZKbplBcJ34a+L8P//1eIcQd4LcDNvC3rrJhCsVNREr5z4HnFJ5Pk/wqhQ7+OSHE7zga0qVQKA5zdB0ohHgE/Chv5rSfPu8aZ+ijQqF4w3+PwijxNyiMhod0a3iw9SeA/xD4t4E/IaXML7uRNwllwLh5/JdCiD7wDNgF/v0jf/+rwE8PT5F/N/BfXm7zFIrrgRDiX6Jwo/0FKeXXKUKt/ofAOvBaSplOvPdXhvGMgRDid01c5n8zfH307+cu9UsoFNeTbWB18gUp5T8B/rvADwJ/G9gXQvxFIYR+Be1TKJaZ09aBPw18Q0r5LeD/AXxJCPHOFNc7po8KheIQPwP8dSllBvw14I8OQ0Um+RdACvymlPI7l93Am4YyYNw8/uAwfvFHgc9TbLbGSCl/GdgA/l3gv5ZSBpfeQoXievAzwN+VUr4e/v7Xhq/tA+vDHDIASCl/RErZGv5tclz9C1LK1sS/Q7GRCoXiRO5TxBIfQkr5d6SU/yrFZuqngP8x8D+93KYpFEvPaevAkUchUspt4B9xJF7/FE7UR4VCAUKIh8C/zFC3KLxzHeAnj7z1/0ihcw+EEH8ExYVQBowbipTyH1HE7f+FE/788xQuTCp8RKE4ASFEBfjDwO8eZnLfAf7XwPcDPkUStJ+6wiYqFDcSIcRvodgw/fJp75FS5lLKXwL+AaBi8xWKE5hcBwohfgT4DPBnJ+a0H6Y4KTZOu8Y0+qhQ3HL+RxT76f9qqFcfUhgwxmEkQogfp1gz/s+H//4jIYTyaroApw5aihvBXwI+FkL8wJHX/8/APwH+8WU3SKG4JvxBIAO+AsQTr/8CRTWSPwf8J8OSqf8NhVHj+4Dq5TZTobgZCCEawO+iqO7z81LK3xxWJB79/aeACkV8cYciqefvBv7kZbdVobhG/CXgYwrd+Xscjs2vUCTz/P0USd7HnKSPl9BWheI68tMUa8L/dOK13wr8DSHEGkX+wf8M+JNSyj3g7wgh/h7wf2I6DyjFCSgDxg1GSrknhPirwL8H9CdePwB+6coaplAsPz8D/N+klE8nXxRC/McUBsAHwAvgT1F4MnkUVvc/DfzKxEf+lBDiT078HkopD4V1KRS3nP9KCJECOfAt4C9yeCE4og38Lykyt9vAS+D/MFHCTqFQHGG4DvwFCqP8Tw8rk4wRQvwXFPPdyIAxrT4qFLceIcRvA94C/vLQODHiF4UQ3wP+KIXn03eOzFV/EviWEOJfkVL+3ctq701CSCmvug0KhUKhUCgUCoVCoVAoFGeicmAoFAqFQqFQKBQKhUKhWHqUAUOhUCgUCoVCoVAoFArF0qMMGAqFQqFQKBQKhUKhUCiWHmXAUCgUCoVCoVAoFAqFQrH0KAOGQqFQKBQKhUKhUCgUiqXnWpRRXV9fl2+99dZVN0OhGPP1r3/9tZRy46rbcVGUbimWDaVbCsViULqlUCyGm6BbSq8Uy8hpunUtDBhvvfUWX/va1666GQrFGCHEJ1fdhjJQuqVYNpRuKRSLQemWQrEYboJuKb1SLCOn6ZYKIVEoFAqFQqFQKBQKhUKx9CgDhkKhUCgUCoVCoVAoFIqlRxkwFAqFQqFQKBQKhUKhUCw9yoChUCgUCoVCoVAoFAqFYulZaBJPIcTHQB/IgFRK+VUhxCrw14G3gI+BPyylbC+yHQqFQqFQKBQKhUKhUCiuN5dRheRfllK+nvj9zwC/JKX8D4QQf2b4+5++hHZcOmGSsT+IiNIc29BYq9k4pn5l95mnPYu89rSf6/gxH+z1ORjE9P2EROaYus6aa7HZdLBN/cTPjq7dC1P8OME1DRoV88R7hEnGdifgVTdACMFm3WZrxV1IfymmYxaZGsnIIEypOQZPNuq0XOuSW1y+zl/GGHLaPY6+XrUNvCg9UZ+AY+89GEQ8bwfs9UMEsFazaVYMwlQSpdmV9tNVESYZH70e8L1XfTp+Qk7OetXhbssZP4vJ5w7Q8yM+3PM58CJWqhZf3Gpyr1XBi9Kp+2zRc9Dou50mq4e+k5QgBMDC26S4PVzWeuuq2vWNZwf87d/cZq8fs1G3+MmvbPF9D1fnalOZ8+WyPvey+O7LLn//Ozu87ses1y1+z+fv8rl7zatu1pUQJhnbbZ/dfoSUkjvNClutyonj/GmyMPmeKE7phunU64HLlrWPXw/4lQ/22B/ErNUsfuTJBm+t1xZ2v+vMVejJb79POwABAABJREFUVYSQ/BTwc8P//jngD15BGxZOmGS8aPvkElxLJ5fwou0TJtmV3Gee9izy2tN+ruPHvPvJAUGUc+DFfPdVn0/2fdI041s7Pb7+yT5Jmh377OjafpzR9SOyDLpBQhBnx+4RJhkf7A3Y7vjYho5laGx3Qz7c7ZfeX4rpmEWmRjKSZbDiWmQZvPvJAR0/Xto2X8X1ZrlHx48PvR7EGe9+ckDbj4/p04e7fT7YGxx6769+8Jrvvuqz1w/pBTGdIOGT/QH/4L09Ptkf4Fr6lfXTVREmGd9+2eM3n7UJk5RXvYDdbszztk/XS3n3kwN2usH4uWsC3tvp8g/e2+O1F+JaBr0g5p9+9Jp//P4ufpyd2Wf+sM+CI+9bxJh2lqxO/k0TsN0N2e74aIKFtklxe7is9dZVtesbzw74z3/5Q8JE8qDlECaS//yXP+Qbzw5mblOZ8+WyPvey+O7LLj//q58QJZL7LYcokfz8r37Cd192r7ppl06YFHP9djfEMjRsQ2e74/PB3uDYOH+aLEy+J0kzfnO7x3bHn2o9cNmy9vHrAX/z3efEieRe0yFOJH/z3ed8/HqwkPtdZ65KTxZtwJDA3xVCfF0I8bPD1+5IKV8CDH9uLrgNV8L+IMIaboaFEFiGhmXo7A+iK7nPPO1Z5LWn/dwHe32qtkmc5bSDmNW6Tati8awTslK1EELw9CA49tnRtb0oxTYMXNvANnW8OD12j/1BhB+lVC0Ty9SxDL04uRxaexWXzywyNZIR1zbQNA3XNqjaJh/s9Ze2zVdxvVnu8cFe/9DrXpxStU1edoNj+uQlGX6UHnpvmhcL5TSX1Cs2DdfiVS/E0gQCjX6YXVk/XRX7g4iXXZ9GxaYbpjQci9WaRS4l+35E1Tb59Wft8XPv+AkHflo8MyFwHYN6xcYPUzqDBC9Kz+6zqOgzL04XOgeNvttpsjr5t26QULUNqpZJx08W2ibF7eGy1ltX1a6//ZvbrLg263Ub0zRYr9usuDZ/+ze3Z25TmfPlsj73svj739lhxbVYq9mYhsFazWbFtfj739m56qZdOvuDCC/JqNpG0eemTtUy8aP02Dh/mixMvudZO6BRMWlW7KnWA5cta7/ywR4rFYtW1cLQdVpVi5WKxa98sLeQ+11nrkpPFm3A+B1Syh8Efj/wbwohfte0HxRC/KwQ4mtCiK/t7V0/gYnSHFMXh14zdTF2C77s+8zTnkVee9rPDcIUx9SIs5w4ybB0gWkIBnGKpQsExYbp6GdH146zHGN4D0MT49cn7xGlObmU4/eN3pvnsvT+Wgaug27NIlMjGZnEMTUGYbrQNh6lbJ2/jDHktHsMwvTQ61Ga45gaXpQe06c8l+RSHnqvEG/0StdAF+AlOboQZFISZ8V3uIp+WiRn6VaU5kRJhm1qBEmGaWromkAAfpzhmIXRYvTc4ywnTjN0UYxFALoGeS7JZD5+hnByn8VZ0WeT8rKIOWj03U6T1cm/RWmOoQmM4di8yDYpbhbn6dZlrLdmpax27fVjms5hV/mmo7PXn91rosz5clmfe1m87sc0jjz3hqPzeo7nvqxMux4czfWGNrFO1gW5lMfG+REnrbVH7xlEKbYu0DWmWg9ctqztD2JqR/q+5ujsD25O35fFVenJQg0YUsrt4c9d4G8CvxV4JYS4BzD8uXvKZ/+KlPKrUsqvbmxsLLKZC8E2NJJMHnotySS2Ue4jn/Y+87Rnkdee9nM1xyBMcixdwzJ14kySpJKaZRBnEomkahnHPju6tqVrpMN7pLkcvz55D9vQ0IQYv2/0Xk0TpffXMnAddGsWmRrJyCRhklNzLiPFzxvK1vnLGENOu0fNMQ69bhsaYZJTtY1j+qRpAk2IQ++V8o1eZTlkEqqmRiYluhBYevEdrqKfFslZumUbGrapEyU5FVMnSXKyXCIpXGLDJKflmuPnbunFCVMmi7EIIMtB0wS60MbPEE7uM0sv+mxSXhYxB42+22myOvk329BIc0k6HJsX2SbFzeI83bqM9daslNWujbpFNzzsKt8NMzbqs+etKHO+XNbnXhbrdYvekefeCzPW53juy8q068HRXJ/mE+vkTKIJcWycH3HSWnv0npptEGWSLGeq9cBly9pazWJwpO8HYcZa7eb0fVlclZ4sbJQRQlSFEPXRfwP/CvAvgF8Efmb4tp8B/tai2nCVrNVs4jQjTnOklMRpcZo2Snh32feZpz2LvPa0n3uyUceLEixdY6VicdCP6AQxD1sObS9GSsmj1cqxz46uXbUNojSl7UW8aHu0BzHPDzyqtnGoHa5t4MUJcZIRp1nhfm3qpfeXYjpmkamRjPhRSp7n+FGKFyU82agvbZuv4nqz3OPJRv3Q61XLwIsS7jUrx/TJC1J0XRx6r6FBy7UwNEE/iOj5MXcaDnEukeTUHf3K+umqWKvZ3Gu69IKIpmPQC2MOBjGaEKy5Nl6U8AMPV8bPveWarLpG8cykxA9TDgYBcV54X3hxShCnp/eZXfRZ1TIWOgeNvttpsjr5t2bFxItSvDih5ZoLbZPi9nBZ662ratdPfmWLvUHIx3sDdjs+H+8N2BuE/ORXtmZuU5nz5bI+97L4PZ+/S9uP2R9EJGkRKtH2Y37P5+9eddMunbWaTdUswrLjNCNOMrw4wbWNY+P8abIw+Z6HKxVeDyI+ft2nH0Z8vD+g7UWnyuFly9qPPNmgHcR0vJg0y+h4Me0g5keeLOeh31VyVXqySDPpHeCXhRC/Afxz4G9LKf8b4D8AfkII8T7wE8PfbxyOqXN/xUUThXuwJuD+AqpaTHufedqzyGtP+7mWa/HO41U0HUCy4po0KgZSCL54t8EPPV7DNPRjnx1d27V0HNOg7cVUbZOma7Jed9gfROPkP46p82SjxlbLJRoOkFtNh7c36zcqm/Z1YhaZGsmIrsOrXsiBH7FSs/Gi9FKTiZWt85cxhpx2j5ZrHXq9Yum883iVFdc6pk/3V11sQydJs/F7f/jJOp+7U2ej7tCoWLQqJo/XavzYZzd4vFbDjzN0Hd55vHprqpA4ps4X7jX4ysMVHNPgTqPCZtPiwYpLs2rwzuNV7jYr4+eeS/js3SY/9tkN1qsO3SAmy+GdByv8zs+sYxkaH7/2SLL8xD5zh31WGSb0XNQcNPpuazWb3X7Ad3d67PaDcYb4SRnLJWw1HbZa7jip56LapLg9XNZ666ra9dm7TX7yy1tYhsaeF2EZGj/55S0+e3f2LP8t1+ILW00O/Ihvvexx4Ed8Yas51zi8rM+9LD53r8kf/+HH2KbgRSfENgV//Icf38oqJI6p8/Zmna2mQ5zmRGnGVsvlyUZtPM6fNgdMXmNyLtisWqzXHXIp0BBsNJ1TZeeyZe2t9Rp/6J0HWKbgZTfEMgV/6J0HqgrJCVyVnggp5fnvumK++tWvyq997WtX3QzFFTHKPmwZOqYuSDJJnGanDl5HSy0VsXMa1oSrWZzm4wFwHoQQX5dSfnXuL7Uk3CTdmlVOrjNXWbpulAm8TH2aROnWyZT93MuUoduke9cZpVvXkzJ1v2xdvellVKflJujWRfRqVrmaR6aVrN1OTtOtmxGoprjRzJJ9+KRSS0/3PbL8cMznTUo0pSi46RnRR1x16bqbnrhtWSnzuZctQ7dF9xSKq6BM3S9TV696LlIsD7PK1awyrWRNcRRlwFAsPbMMdCcNolXHYK9/eBC9SYmmFAW3ZWN91ZvFm564bVkp87mXLUO3RfcUiqugTN1fVmOI4nozq1zNKtNK1hRHUStOxdIzy0B30iC6McyHcFMTTSkKbsvG+qo3izc9cduyUuZzL1uGbovuKRRXQZm6v6zGEMX1Zla5mlWmlawpjqJWF4qlZ5aB7qRBVNc0Hq3e3ERTioLbsrG+6s3iTU/ctqyU+dzLlqHbonsKxVVQpu4vqzFEcb2ZVa5mlWkla4qjzF74WaG4ZEYD3f4gwo8zbEM7daBbq9m8aPsAKpncLWMWObnOnCXjl8XoWSsul7Kee9kydFt0T6G4KsrS/TJ1dRnmIsVyMI9czSLTStYUR1EGDMW1YNqBTi2kbze3YWOtZFxxURYhQ7dB9xSKm8AyGkMU159FzgFK1hRHUQYMxdJx0VJJaiG9nKgSWOWhZFwxKyfpn5IhhUKhUCgU1w0VPKRYKlSppJuJ6leF4upQ+qdQKMpGjSuKy0LJmuIoyoChWCpUqaSbiepXheLqUPqnUCjKRo0ristCyZriKCqERLFU9IKEKM2Ih9mFW66FbWj4sbKyXmeiNMe1DoeLmLq4tv2qwmEU14nL0j+lFwrFYlhG3bpp87piPi5DNpWsKY6iPDAUS0OYZLT9mDiVVMzCRWynGzIIU1Uq6Zpzk0pgKVdGxXXjMvRP6YVCsRiWVbdu0ryumI/Lkk0la4qjqJ5XLA37g4iNuoNEkmYSQxMIYK8fzlWjXLE8lFl7/qpRroyK68Zl6J/SC4ViMSyrbt2keV0xH5clm0rWFEdRISSKpSFKc+qOgWVotL2YIMkwdYFlGEvnOqmYjZtUAmvRrozL6CqsuN6UqX+nyady8VUoFkOU5mgCXnYi4izH0jVarkkiz//sIrlJ87piPi5LNpWsKY6iDBiKpWHkIuaYOvdaFaDIifG6H5JLG9fSSTLJi7avBq5ryE0p/TmSU8sQ49fKcmUcuWNahq7kXVEqZejfWfK5SL1QKG47z9s+VcukYuqkmeR522erdfXz6U2Z1xXzc1myqWRNMYlaWSiWhpNcxPb6IRt1Z+lcJxW3l0W6Mi6rq7BCAWfLp3LxVSgWhJSAgJFtUAz/T16xC4ZCoWRTcUUoDwzF0nCSi9iKa1FzDovpNG7Jyg1fsSgW6cq4KDd8pQ+3g0X381nyqVx8FYoFIQQPVip0g4QgKXTrwUqFfAn2iGpuueVcomwqWVNMogwYiqXiuIuYP7NbsnLDVyyaRbkyLsINX+nD7eAy+vk8+VQuvgpF+diGRi7hbrMyfi1Oc0xxxocuATW3KC5LNpWsKY6iQkgUS808bsnKDV9xXVmEG77Sh9vBZfSzChNRKC6fZdU7NbcoLks2lawpjqI8MBRXxjTuYPO4Jats+Irr6mq4CDd8pQ+3g8vo50WGiVxXnVUozqIMuV7W8Cw1tyimkc0ydEDJmuIoyoChuBIW6Q6msuHfbk6SrQ/2BlQMDYRY+s1R2W74Sh9uB9P0c5mbqTJR7sGKZaIsY1qZcr2M4VlqblHA2bI5rQ6cp3NK1hRHUT2vuBL2BxFSwoEX8fTA58Arfj/qDjYa/HIJrqWTS3jR9gmT062uy+puqbgcjroa5lLS9iL2/XhqGZqVkZx+uDco/doXRenD7WCtZtMPYp4eeHz8esDTA49+EI/7eZ6x9LJQ7sGKZaFMPSlTrpdxjlFzi+I8ztKBkUx/+2WPdz85IIizU3VOyZriKMqAobgSekHC60FELqFiFgPW60FEL0gOvW+eBcDIGqwJ8OMMTaBO8m4RUZpj6m+s9G0vxjUNpGQhm6Nl3hiC0ofbhBQCRtnf5fD3IctsJDiqs1C4B0dpfkUtUtxWytSTsuR6WecYNbcozuM0HegFyVimwzhF1zT2vZgozU/UOSVriqOoEBLFleAnKdrwdHxvEBOnOWmeH6sdPW/c2zK6Wyouh6OuhnGWY2gCW39jry0zdnJywQuM77s/iJZGBsvQB5Wj4OqY5tnvDyIajsn6xIlUnOZjOVzmGGLlHqxYFsrUk7Lken942LM/iIizHEvXqNrGUswxaq2lOIvTdMBPUgzdYn8Q8cmBR8MxcW2Djh9zt1k5UeeUrCkmUasDxZXgWiZhnLDdDshziSEEeZbTjdJDpwqjwW+SaRYAy+hueZNY5ud71NVQUFjsW641fk+Zm6PbcHq8rCeAt4Fpn/15cjjvWHoZLJt78DKPb4rFUqaelCXXvTBlfxAihx6rRbhtSC9MZ27TbUDp7/Jwmg7oQhvLdN02iVPJwSCmHxZe2LPqnOrz28fVr1wUt5KGY6APT63TXKJpgs1mhdWqdchtbJ4FgNpsLZZlf75HXQ3XajarrokmxEI2R8u8MSyLZQ4/uOlM++zPk8NlMxJMskzuwcs+vikWS5l6UpZc+3GCJjTM4RhgGhqa0PDj5PwP3zKU/i4Xp+lAJvOxTLeqFhJJlkuCOJtZ51Sf305UCIniSlir2bz/qs9G3cbUCyNGP0ywdMH3dvvj98xTPuw6uPRfZ2Z9vlcRenDU1XDUhkWUoFur2bxo+0Bx4p1kkjjNbpSsLXP4wU1n2md/nhwuaylGWK7wJDV/3G4cU2etZvPBXp9BmFJzDJ5s1OeWxzLc3l3ToJsmJMNwyDSX5FJSN80LXfcmovR3+ThJByZl2tI1VqoWe70QYGZD32l9vt0JsA1tKeYVRfkoA4biSnBMnUerLvt+TJpkSApXf01oNCtvLKijQWyWiUdtthbLLM93WcojLjJ2cpk3hmWhchRcHdM++2nkcBljiJdljBih5o/bzciYtlmvcL9VGAL3BxGOqV/ZmN6omJi6hhenBEmh2+s1m4p1c+aYslD6ez04KtMVU+cL95pUrNnnqJP6PMtznu57PNmsL8W8oigfZcBQXBlbKy4SsAyd1/0QYQgksFK1x5bUeazmarO1WGZ5vrflNGQZN4Zlchu8TJaVWZ79dZTDZRsj1Pxxu1k2eYQ3Y8Bq1T40BixD+NeyofT3elCmTJ/U53v9iKpjLJUeK8pFabTiypiMjeuFCZYhuNt0xtbReRMhTsawBnHK032PD3b7REmmYuJKYJYY4duQ4HIZWHQCq2XKUXDbWPSzv+rkZ8s2RixzrhDF4lk2eYTlHn+vevw4itLf68E8Mn2arJ3U516UsnGkz69ajxXlojwwFFfK5IlhLhlbS2F+q/nomtudgKf7HlXH4K31KrqmKReyEpglZEKdhiyey3LBv46n+zeFRT37ZQjfWLYx4jaEhClOZ9nkccQyjr/LMH4cRenv9WEWmT5P1o72+aNVF107rLPLoMeK8lAGDMWFKCv5Wtku6o6pYxsaTzbrh4wioFzIymDaiUeFHiyeZXR5HrFMyRmvE5f13JZBdpZxjFjGzaLiclhGeYTlHEuXYfw4CaW/N4/zZO2kxO0X1eNl1DnFG5QpSjE3ZZYuWoSL5DK6gt42ltn19aawrHKuSpvNx2U+t2WQHTVGKJaJZZTHZR1Ll2H8UNwOZpW1i+rxsuqc4g3KA0MxN2Vb38u2mi+rK+htQ52GLJZllfNlPZ1bdi7zuS2L7KgxQrFMLJs8LutYuizjh+LmM4+sXUSPl1XnFG9Qo4xibpbd+q6SOSluA8sq58s+Piwrl/ncllV2FArFG5Z1LFXjh+KyuGxZW1adU7xBGTAUczOyiE6yTNb3ZXQFVSjKZlnlfNnHh2XlMp/bssqOQqF4w7KOpWr8UFwWly1ry6pzijcsPIRECKEDXwNeSCn/gBBiFfjrwFvAx8AfllK2F90ORfksa7KrSZbNFVShWATLKOfXYXxYRi77uS2j7CgUijcs81iqxg/FZXGZsrbMOqcouAxT0v8K+PbE738G+CUp5WeAXxr+rriGLNoiumz1xRWKm8oidE2dzs3HPM9NjZUKxXJShm6qsVSxDNymeUbp3PKzUA8MIcQD4CeB/x3wbw1f/ingR4f//XPAPwT+9CLboVgci7KILmN9cYXiJrJIXVOnc/Mxy3NTY6VCsZyUqZtqLFVcJbdxnlE6t9ws2gPjLwF/CpjMenJHSvkSYPhzc8FtUFxDJjMACyGwDA3L0NkfRFfdNIXiRqF07Xqj+k+hWE6UbipuCkqWFcvGwgwYQog/AOxKKb8+5+d/VgjxNSHE1/b29kpunWLZURmAF4fSLcUkStfK4yp0S/Wf4jZwHectpZuKZWdavVKyrFg2FumB8TuA/44Q4mPg/wn8mBDi54FXQoh7AMOfuyd9WEr5V6SUX5VSfnVjY2OBzVQsIyoD8OJQuqWYROlaeVyFbqn+U9wGruO8pXRTsexMq1dKlhXLxsIkT0r5Z6WUD6SUbwF/BPgHUso/Dvwi8DPDt/0M8LcW1QbF9WXams+3KamQQjEts+jFZddXV5TLLP2nxkuF4nzK0hM1tipuCouWZTU3KWblKkxn/wHwE0KI94GfGP6uUBximgzAowEvl+BaOrlEDXyKW8+seqGybV9vpu0/NV4qFOdTpp6osVVxU1ikLKu5STEPC61CMkJK+Q8pqo0gpdwHfvwy7qu43pyXAXgyqRCAZYjx6ypzsOK2Mo9eqGzb15tp+k+NlwrF+ZStJ2psVdwUFiXLam5SzIMKXlJcW1RSIYXiOEovFCeh5EKhOB+lJwrF5aJ0TjEPl+KBobh9hEnG/iAiSnNsQ2OtZpfuNjlKKjSy1oJKKqRQXJZeXIaOK6Zjmr5Q46VCcT5l64kaJxU3hUXJspqbFPOgpENROpcVz1a1DZ4feHzwqs/Ljk8/SFSCLMWtp6xkW2cl1VIxq8vDeX0x+nsvTHl+4NEPEpVQUKE4hTKTFd6GcVIlX7wdLFKWVdJ+xTwoA4aidPYHEVLCgRfx9MDnwCt+3x9Epd1jZAlerztULB0vztjth+p044ajJrDzKSPZ1nmLlcmYVSEElqFhGXqpOq6YjrP6YrIfV1yT9brDbj+k7cWlJxRUuqm4CZSZrHBZx8mydPU2GGgUBReV5bNkTiXtV8yDCiFRXJijbmV7g4gwzrBNnYqpk+aS14OIZsXk/ko595wcTBsVE4A4zfGilJZrlXMTxVIxmsAsQ8e1dJJM8qLtX5us7pfpSnzRZFvnJdWK0hzXOtx2Uxf4sVpMXDajvgiTjLYXE2c5piZwrGJ6n+zHRsXEMfXxArEsrrtuKhSTlJWsMEpzNAEvOxFxlmPpGi3XJJElNHJOytRVlXzx9nARWZ5G5lTSfsWsKA8MxYXo+DHvfnLAJ689ekFMEGc8e+0Vi2i9sNSauoYmBH6SlnZflfTnZjHNidCynmZNw3U7PThPv0Yxq5OomNWrwTY0+mHKTjdASqiYxQKx40X0wvRSxskydVN5cihuEs/b/lgvpSx+n4ey9KJMXVXrsNvFvLJchsxdpqypOeh6oFabirkJk4xvbXfRNY16xUQi2PdiLFOj58ckw3i2JM3JZY5rmaXdW22gbg7Tbu6v82LpuhlfztOvMuPEFRdjrWaz1w8RCAxdkOYSCWzUHfw4uZRxsizdvG6GPoXiTKQEBIxUQwz/T87mglGmXpQ5j6p12C3iArJchsxdlqypOej6oEYZxdzsDyIkULH0saeFZRTeFlXbwAtjfuNZh3efHvCqFwHl+U2qDdTNYZrNfZhktP2ID/YGvOwE48nkuiyWrpvx5Tz9ckydtZrNbj/guzs9dvuByj9TMtOeAjmmzoprYRmCICnih+82HWqOgWsalzJOlrW4vIz8SQrFpSEED1YqaIKxbj5YqYAQ5392glE+m+/u9PhnH+7z3Z3eOCRxVsrcCKp12C3iArJ8mswBU3s6XJasqTno+rD8K3/FhVmUO1SU5rimTjoxMBmawNQ0vDjlm9s9kizDNTWCJOPpa4+OH5dy7zITbSmulvM29yP5bToWuhDEac7Ljk9vSavOnKRvZy0al9Fd8Tz9Gi2eN+sVPne3wWa9Ml5kKy7OtKdAo/d1/Jgkl9xpONxtVnCGYSSNinkp4+S8i8ujsr83iHg9iMiHbsq5hNeDiF6QlNpeheIysA2NQZSy24vY7gTs9iIGUTqzsWCvH/Kdl33SXNJ0DNJc8p2Xffb64cxtKnMjqNZhtwfb0A6t9QHSI4av09YyJ8lcL0wI43RqT4fLkrVekKg56JqgknjecBaZXM02NGqOyYFXWCYNXRDEGVJAP0xxLAMhoBtlaGQIIfnH7+3y5futUpIYlpVoS3G1nFcDfNJDwzQ0On6MF+b0wpgvbbUuJENlJ9Y8Td/WavbYgm/qgiST40XjsiY/PEu/5k2odZmJTK8z+8MF1P7gTcK0qm0cer6TsnavVeF52+fZgc+DlQq6phGn2ViOph0n5+2f0T32BxF+XBjszpPhk3Tl2WuPZtWi5hThhqYuSNK81PxJCsVloWuC33jWpuFYNBwDL8r4jWdtfvwLd2e6zk4vRAjwopTOOL9Y8fqszKOr01xvmVDzTPlUbYP3dnpUbRPH1AiTnIOBxzuPV4HimX+428dLMvJcommCrh/z9mb9RJmrGBrZOXPcUS5D1vwkRRt6lIOag5YZ5YFxw1lk7P1azUYTsFq1AUkvTEjznLt1G1PTuNuwMXWNtaqFaxnsdEOeH/hoAhVXphhz3onQpIeGY+rcbVZ4e7PGiluOsaHMWMfT9M2L0hNPD7wovVa5MUbMExKjYkunpxem7A/CQwnT9gchvfDNImpS1iqWwcPVKrahsdMNF1I69zxGi8u3N2pT3fskXalVzIXnT1IoLosXHZ9Hq1WqjkGcSaqOwaPVKi86syXyzHJoexFJmmMNN1RtLyKbMwJxVl29Tqh5ZjF4UcqD1SqWoRGmOZah8WC1ihcVc9J22+fATzA0DdcyMDSNAz9he5jo86jMRZk8d467ClzLJJe5moOuAcoD44azyHKHk1ZVXRNsDi3d252ApmuyN4iwdA1D1+iFKXkOKzWLbpBwt1kBVAkkxfknQud5aMzLIspynaVvJ50eXNdypPP0iSqDNj1+nKCJwuMIwDQESabhx2/cWI/KjmPqPFx18eNsrud52f1zkuyvuCZIiRjGWVu6xlrNOfY+heI6MAhTVlwLTXszLuZ5TnvGUFpdg1bVAkRR4c3QaBkWujqCPIaaZxZDlObUHYNG5c1GXko5Xqvs9iNcSz/kueBaOrv9iLc368euN80cdxU0HANDE3hRquagJUcZMG44i9r8jRgl8xu56+0PIpCSrVaFD3Y9mq5Blkuetj3yOOfJRpV+WBgwTtuoKfe/28dJcjTq91GYBRwOv5hlMXKSTJVlPJi8dtuPyHOL+sQkf5a+LVo/F8U8fXJdjTVXgWsadNOEJMsxtKKySC4ldfONXJUtOyf1T5bnPO8EU4/Fs4zdJ7W/Zpv4ceF9dTTU6jJQc4+iTGqOQS9IibN87CZv6Ro1Z7al991mhW88a9MLkrF7fqNi8uSEjeFtR80zi+Gs+SZMMvb6IXGWEyQ5aSYxdY26o9N0TvZcmGaOuwrWajbhMOz3KuYgxfQs9ypZcWHKztx7NElPx4+PuesFaY4APne3TpTkfPzaw5DwlYctLMOg4yeESXbiYlu5/91Ozur3aZM3nZZA6rRrw5tM2CNm3QAevXbDsXh24NEPkqn07bpmcZ8noZYquTc9jYrJ+jBEb5Txfb1mHzr9Klt2Rv0TJhkvOwHvv+rz60/byCnH4lnH7pPaLwR8cat5JUkB1dyjKJv7LZdPDgZFqKBenOp+cjDgfms2TwBb1wijjF6Usu/H9KKUMMqwlQvGMdQ8sxhOm2+qtsEHewOiNOPb212+96pPx4vIsrwYP7P8xDF0mjnuKlCJaa8PygPjhlNmwqaTkq59e7tLvWKy78Xs9UKEEDQrBqs1m7sNmw92B2zUbdZqFmkuSfKc9arFbi9ktWodO7FV7n83izDJ2O4EvOoGCCHYrNtsnSB/5/X7ecmbzkpWe/Taucw58GKCOMPQBRt1h7pjzOXZcfTajYrJg9Uq3TBG08S5+lZ2QrXLZNaEWmV40twWRs9qtXr6KVDZsrNWs/lgb0Dbi3BNg0GYIKUgk4xzmxx4MXv9iIer7jHvhNP07LT3n9X+lmvN9R1gfi8KNfcoyibLJW9v1PiNZ23aXsJK1eT7H66Q5bOVlN/thoR5xkrFRFQsJJIwz9jthnxhq7mg1l9P1DyzGE4br7c7AW0vwjYMXNskijO6UYKhC+613BOTT+8Pq3q0/ZiNusOdhrGUng5RktH2I3phSsMxlEfekqEMGLeAsjL3nrTAC9Kc7Z0elq5RMQ0QsD+I6XgxW6tVGhWjOHXY99A0wVbLJc1zhBAnLraV+9/NIUyyQxsiBGx3Q8IkG2emHnHRfj9r8zF57W4Q8/5OH5lLhCZ4a73K635Imts0HGPmDeBJ7a47BromeHujduZnj260tlqVGz05XmdjzWUz7bMqMyu7Y+pUDA3f1EmlJJPwcK2oaLLTC0CCqWnkQo69E0b33h9EfG+3T8MxWR0uQHe6wYnvP8mIcREm9QgpCdKchmPOXNVHzT2KER0/5oO9PoMwpeYYPNmoz2VU2+tHbLd93lqr87m7GlGSs932qZjGTHL/shdSNQ1yBHku0bUiFOXlHFVIbjpqnlkcJ43Xr7pBYfA2MtZrNmmWEyQpEo3Hay5ZLovEnG3/kNFipWph6hp7F1h/TVJW+N/oMExK6AYJmhB0/QhDE4RLUiFOUaAMGIqpOWmBl6Y5XT/h8VoNY1iVwDJ1XrYDklxSsQ2iLGfTqhBnxYm3EBqb9ZMHl+uaE0BxnP1BhB+lVC1znKhJCIE3nGgmJ8KL9vtZm4/RtXOZ8/5OH13T0A2QCAZRxkbdoWLNt5Gat92LLG+8zCxjyb1l5UqelRA8XHGLqiC6hpRgaILtdsxWqwICHP2NoXC7EyClxDJ0mhWTOJXsDL2tLF0/9v6yvRmO6tGztk+UZNRsAyG0mbwo1NyjgMJ48e4nB1RtkxXXIkxy3v3kgHcer85sxNjpBViGQWU4N1UsnSQzCoMgK1NfJ0ozLF2n7r5xr+/7CVGqjGsnoeaZy0MIAQIsXcM2igokdccgGRraoiSl40XUbIMozYrqJF6EZWjUKya2qY/DNOalzPXU6DDswIuwzSIpaZLmeFE6ztOmZGs5UDOzYmpOii00DY1cFu7CUkqSLEfmhSuYMaqlLMEwNCqGTsdLAAlCnHiP65oTQHGcKM3JpRwbtqDYDOW5PFZu86L9flbc6+jau72QXEp0DdIc1moWlqExiJIzy3+exbztXmR5Y4ViXib1aKVqEWcZQZwhh/+L03y8iTN1watuMJbjlaqNBASC3W5w4vvn1bPTOKpHUhbJ4dremyoP095XzT0KgA/2+lRtE9c20DQN1zao2iYf7PVnvpYuBLpGsS4aro90rXh9FrZaLn6SEsYZeZ4Txhl+krI1Yy4NhaJsNus2fpzh2jq2qTEIYwZhSt028aKUJMvZqDtYhkacSSqWjqXr4zG6jHmhzPXUqER8lBbJRQEMfVj9ZwFzmGJ+lAFDMTUnLfBsQ+PtjRpSCsI0RxOClZqFZeqYZiFed5oOQkCYFX9/cIb1UiXQuTnYhoYmBOmEYSEdZlA/eqp50X4/a/MxunaWSzQEUgo2Gza2oWNoAj/K5j5lnbfdo0lyEjU5Kq6aST2yDY3Vqk2a59Rtg0xK7jadsWwnmUQIMZZjx9S523SwDEGcyRPfX7Y3w1E9sg0NBMTZGz2a9r5q7lFAUfrUMY/OTxqDMJ35Wqs1i4ZjoYk366OGY7Fam82T48lGlUdrVSSFO75E8mitypON6sxtUijKZGvFZdU10TXBWtVipWpTMQuPvK2mw52GM666YxsaaS7HBgEoZ14ocz01MuKP2gqQZhJL15RH3pKhQkgUU3NSbOEXt5q8GCbxGeU58OOM+60KuZR0gpg0y7FMHdc0eLhaxFSbZxxAKPe/m8FazaYTJIVsyDeyseqaJ55qXqTfz4t7dUx9nEjwwIuGhgxJEGcIwYVOWedp9zK4q6uSkdeHy+qro3rkWjo/+HgVKHJYaEIMT5ILL7vNun1Ijouyxw4Nx0TCsfeXPa4f1aOWa/HswMc2tLnuq+YeRc0xCJMc134zFodJPnPpU4AnG3Xe/eSAmm3imBphkuNFCV/emC3x5taKSzeIkRSJBW1T526jSIitUFwljqnz9mZ9PD+9vXF4fnrR9sdjdMu12OmGJBQGhn6QsNcPaVVtGJYunWdeK3M9NUoCW7UMXg8ikjQnlzlrNUclg10ylAFDMROnLfD6fszH+x6mJvj0nTqf3qzxG0/bWIaGH6WkucTRBa5tjE/GX7R9tXm6wTimzpONGtumPq5CstV0TqxCUtb9zppcRvW9V6s2gzChF6YIirKNp7VnURvHsjKlz9u+25qD4zoyb1/NKxun6dFJBkLgTDk+L5HeRfXrqB5pQrDqmjiWoRL4KeZiZHQADhkd3hka8mah5Vp8YavJrz9r0/ETWq7JDzxcmSshqGUabNQglxJNCCxTLd9PQxnnL5fRnDFKfvu93f44+e3kGG0bGmtVi71+iGUa7PbDQ1Xg5l2DlFl5ZtKI36yY+ElK3bJxLV3J0ZKhRkDFhRhNFPdXq7y1URsPHH5cVJrwopQDJ2K7E3Dgx/zax20+d6/Gs30P09RxTZ2aY6rsvjcUx9R5e6N2bkWOsjltATOamHRNsHnOwua0jeNazcaL0gstjo6edCMLd/ztTjD1NS9ihFAlI68P8/TVImR30rAxqV9CCJI0I8mOlw2et/TxLG0qyr9evGKEQgGF0eFTGzV+5YM99gcxazWLH3myMZdMhUmGF6V8aas13lh5UUqYZDPNGfuDiIZjsj7hKRin+dzj9U3e4Cvj/NVwVvLbybWOJuBOs8KrboBpaOO8FeeV3T6L0+aBeft7NNfdnz7PruIKUAYMxUwcnfiiJENKOPCK1ySF2+6rTsDbGzWqtkHP0Gi4JncaDr0o5tefdWhVLJ5s1gDBgRexWlXZfW8DF104TfP58xYw08rYSRvHKMn41naXh6vVuRdHR7/DatUq7qVr40XuNNe8iBFClYy8PszTVyfJRphkfHu7y4MLyC4cLjM3iBL8qAjD+sJW89gm7yx9LcOINrr+Zr3C/VahO/uDCMfUS9+s3ORNn+INHT/mo70Bn95o8OWtwgPjo70BLdea2YixP4gOrY9sQ6NqGTOvdcocr8Mk48PdPl6SkQ9zUnX9+Fhp8+vK/iAil8XPOMuxdI2qPfszV0xPmGT8sw9fE0YZUgh0vUiCC0VS3B96vMb9FfeQ7O30QlzLIIxz7jRs2n58btnts+6/3fbJZWF8yCVst/2FzAOK5UFlI1FMzWjhmktwrWKQ+N7ugBed4jVNwKtuxKtOQCdI+OS1xy+/v8f7Oz16QUY7TIgSiWMUA1svTAsLrK4zCOevBKFYPkay8uHegBdtnzDJTpSf0d9mueZ5ny8rI/VJiaFGFUsOvIinBz4HXrFAnfbaJ32Hb293ySUzt/ciiavOqtqiWC7m6asTZTdMkHPI2VFGm7J9L0YiqFdMdE3jW9vdQ7p4nr7OK7+TY8s3tzvHvpOU8M3tzqGx56JcdOxSLJ6T5px5KLMKSS9I2O4EvOpF7A8iXvUKb9RekMx0nTLH6+22z4GfYGhFyUtD0zjwE7aHLvjXnV6Ysj8IkRIqpj6cn0N6cyRhVZzPSO8GYUrDNZESdnsRUZodS347KXsNp3hvJ4h5/9UAS9cRmhgaICQHQ4+OaXR5UTJd1piiWAxqtao4xmlKe9LGMM0l/SjF1DV6YYqhC/phiqEV79ntRTzb94GcKM7wogzLYFglolioGrrAT+avBKFYLk5b7G93ggsZFqY1TJSVkfqkRWPHSxiECflwcZRLeD2Ipl6QnvQdpCw2l7O29yKL2kWWjFSTfrnM0lejZ7/bC3l2cPjZ+0lR6m6SefQiSnMGUYJlaJh6IccVS0dy2JB3nr7OI79Hx5YwyXk9iMbfM0yy4e95qYYGVfZ4uSnTwFRmFZJ2ELPTDWl7ER0/pu1Fxe9BfP6HJyhzvN7tR7iWPtZdU9dwLZ3d/s2QZT9O0ISGOdRV09DQhIYfz2Y0UhznpLl9NDY2KxZxKjG0YnzsBsmx5LeTsteqWkgkhhC86r0pu10xdXa6IboQaJqYSpcXIdPKaL38qB2j4hCnKW3Hj3m677Hd8XnZCcZKXHd04iQjSXOiJKPvJ2garFYtbEunVTWRQjCIMu62KjQqBlECEhCCN5UguFglCMXycNpi/1U3uJBhYRrDRJhktP2ID3cH7HTfyOk8p1UnLRr7YULTtQ5NlJoQ+Ml0i9uTvoNr6/hHJsVp2nuRRe2iSkaqSb98pu2ryWd/t+kQpTnPDjyCOCVOcwRQs81DnzkqZ9MYn2xDw48yDO2NHKeZxDX1Q7p4nr7OI79Hx5aqZaAJQccvNoQdP0Ybvl6moUGVPV5uyjQwjaqQTDJvFRIvyuj4hceSPTRWd/wIL5ptPCxzvJZSEiYZu72Q50NjZ5hkSCnP//A1wDUNcilJsnxYiSgnl7KokqeYm9Pm9l6QYOqCx2sufpwO1/OSnhfjRQlPNurja0zK3l4/QghBmhWhTKOy20GSFXqMwB7q9Hm6LKUsNhWHXuRCMq2M1suP0mjFIc6K+5cSul6Mn2R4z9NxTNtK1RoaI6AfpdiGRj9KkKHgbsPB1jUyKRESqrbO3iDk0xsNWhWTfpAgxNmVIBTXi9PidYUQJ5a6AqaqSHNeqazRBNtwLPbTkCjJedkJWK/ZCHFyQsHJuHakLKxqw3ut1exjlRcerlUJk5QkzTF0QZpJcplTt6Yzvp30HWq2iR8XG7lZMmifVzr2PBZRMlIlB10M0/TV4Wev8XDVZbcf8rIT8Gityhe3mkVc+ISc9YMYxzL4cG8AUhKkOQ3HxLV0BmHKu58c0KraNBxjrJdrNZun+x5BnFGxdNJMEmcZq1X7kDHkPH2dR36Pji0rVYtP9vq87BWJEV91QlpVkzvNN0mDy8jtsgxljxWnE6U5moCXnTd5D1quSTLH/qXMKiRhnLLZdMhyiLMc09DYbDqE8dWFM7SqFr/20QFSE2hADohc8oOfmv37LSONiompa3hxSjD07F2v2VQstb68CKfN7Z0gppaZNF2LL99v8sm+z4EXU3MM3nm8eihvzGmy99VPrVJ3TDRR5GrKc8mBF9N0LV52gnN1+U6zwnbHRwgxXpf5ScpWa741R5hkPN330LTCiLJStXBMXeUJWzLU7Ks4xKlx/0lGLiVelOEFxeT7dH+AEBAnOVXb4MlmlTzLCZOcNddCINnrRzxYc9lquURpRpbDV7ZafPZOjY26w+P16rFBTnG9Oc01fLN+/MS1FyaEcTrVif15J7ajCbZRMbnXcrGMwnDWDeNzT6w1AdvdkO2OjyYYtwMKw8fbGzXur7hs1G3Wag5CQJAUyQvXag6NKU/nTvoOIwPePKdro03gqH1XbQRUJ9VXx9Fn75g6D1dc7jQr3F9xabnWoVPcJC0Sro3cbfeHLu65lERpzr4Xo2vaWD9HeumYOl/YapLmhf6CZLVqo4nDXnTTeFjMKr8nji0STK1YyhimIMnLz+2yyJArRTk8HyaWHeU9eD5n/HvLtXjn8Sq6Dm0/RteZe43SqFgIoFWxuNtwaA1/b1Rmu1apnm25HG8godgEyNGkdwNYGx5YrFZtHq26rFbt4TytdPUinDa3u5Y5HhsbFZPP32vwzqMVfvRzd47rzCmyZ+vaeG4K44xXvZDVmk2zYk6ly1utCitVmzTP8eOUNM9ZqdpstSozf8+RrhnDEEkpGXvzKqP1cqE8MBSHOOmkyY8ykjyn5dq0jQRvkI7zV3z6jsndhkM3jImTnE/fbdD1Y7yhS2KYZbzY9/ntn1kfD3STpfwUN4/zanJPnrhWDA1zyhP7805sJ09nHVPnXquClBI/Prlk3XYn4MCLkUDXT6hXDGzdoOMn3BtOfEfbsVazCYflKCe/27SLo7O+wyKMeEcrJ1Rt48IlYM9CnVRfHac9e6Q80cPpw90+fpziDb3moiTDNQ3aXowQRWJMQxNjl154ow8t1+IHH6+eWZXjoh5CJ3F0bNnthdiGzqeHFRTuNis8O/DY7Yc8XHFP9WaataLIIr6LokSkBASMRF8M/29OF/KWa/FDj9cu3KyHKxXSPCfNcuJMoglBzTF5uDLbxqrMyhrdMOXJRpUgzsfXqlga3TmTXHb8eKnKGCtdXQynzS8j77xpnvdI9rpByv4gRghJwzLYHcR84X7Rb1GSoevam89P6PJpsuaYOk82aqVUiRodhG3WHXa6IZYhMDWN3V7IatVSnqRLhDJgKA6xVrOPldgqXI51MllUX1ir2oAkz2GvH/JgpcKKW2zgXEunFya8v9PHci1WXAsvyXjZCXm0plO1Db49DEdxbZ2abaoa3TeM8xYQkxPAh3sDTL1wG2x7ceFmqwkcy+D+Gdc+iVk2zyMXwYZjYhoae0nEQRax2XDIh3a1k9wFy1gclRm6cdZG7Gg52X6Y8t5Oj4erVWqOMXcZzbM4z3ilWBwnPft+EBdeFoY+9DIKeP9VnzsNh2cHPut1G3OYjLnjp+g1QRZLukGKpoEmBCtVa3zNSX2YRo7LDlM6qn9ZLnmwUhnLr2PqPFhxedkJTtXP88osX9Z3UZSIEDxYqdANknHYwIOVypU7FWwNw2wn11NVU2drRjnqhSldP8I2DCpmEba1PwhJXfvEefIspJTYhk698cbIECcZUTq7N0fHj/kn392lHSZkWY6ua2wfBPzOz20uhRFDUR5nze3TPm8pJXL4827DQdcgiDNe98Oxd99putzxE775onuqrJXV56ODMCE07jYdOn5MmOdIWU6eMEV5KAOG4hhSiDcJcSQ0qiY9Lx5nBn7dD/HTDFs3cCyNb233+PzdOrZZLAb9KGOr5WIaGklWxKauVm2SNOPDvQGGphWx07lk34tZq1oqRv6actoGetrJxDY0+mHKgRdh6ToVUyeIM0IvejOhTXE/mG3zvD+IqDoGQityc1RsnTjN2R/E3Gk4wOnGj2VZHJ23ETsas+pFKVXbxItT6hVzIfkp1OnX1XHSs3csA1PXyKXkVS/CMorydR+99oZuvyaWUcT2rtctnu77WLqgYhrkw6zwUVzkl9CEWJgnzXm5aE7y7Bj9/egmVdc0Hq1VT5Vplafl5mEbGn6cjR0upCzG76O5mC4bx9R5e7N+4ZNhP05IM/DjeOw1YenzVdYoM1/AN562ed4JWKlaWJZOnEmedwK+8bTN7/r8nZmvp1heypjb7zQrfONZG8c00LWiMtZeP6RqG3xzu8OXtlrjMf1u842XUpzmfLjb51U/KkXWzlpHTh6Ejbz64mGOHbWOWS6UX6/iEPuDiIZj8mitylvrNR6tVdmoOdxpVhiECf0oIUhTyAWpzEDmdLyIIC3yYMRphhen6BokWVEqteVamLrgeTtgrx+x70Xs9YtYa8vQihwbKpzk2lFGXO5azWavHyIYLqbywkK/UXeOZXs+736zZGqP0pyNmk2c5iRZTqNiEGcZvSCm5ZrXIsb9vCzZR2NW4yzHMbVDulZmfopR/2x3AqCIS1XGi4szS1naozkloOjjjh+Py56ahkac5Ww2Ch1LhnkdLE0jy3M26g5Vp8jkv9Gwqdomu71wYfowTS6a077zPLkpVJ6Wm0fVNnh+4BGnOY6hEac5zw88qvbVn9GVkadIF4LnbZ+dbsDBIGKnG/C87aMLcf6Hj1BmvoD3dwe0KgaOqaNphdt/q2Lw/u5g5msplp+LyvJWq4JrGQgh6QUx2wcBSSYxNI3nBwEf7vbH+4ijY/puPypF1s5bR6p8R9eHqx/dFUvFyH3qJJf+t9aq1Comr/sxYZJSs00EgmbVwNI1Ptjr45oG/TAhTnNWqxZ3mw6OqdMPEvZ6IVXHwNCKE8HdXsRG3SJOcjbqypZ23SjjJNMxdVZciyjN6AYxQZxTsXT6YUKSy0PusdPcbxbPj1G5yY4fk0hYrdkYFJsms6SyoovktGovIzf/oyE1ll5k1LfNN7p2UhnNeU4L53XLV5zN6LlKWSRT9qMi9OkLW82pXLRHMhClOZVhP6SZpGoVC8Gma71JSEuxwHyyWUMMs8F3/HhYYnF2fZhWlib1eqcbFZtOyZm5aEbMcyqo8rTcPLwo5eFqFS9OCdNijFutVvGi9MoThM87ph66RpyRZjle8iZ/UdU0COeoiFBmvgApJVKKI6+JG1OSVVEujqnzcNXlo9ceL7sRgzBmtW4ziIpDz51edOqYbmiiFFk7bx2pvEivD8qAoTjEaS793U5AInPiJEPT4FPrVQxNJ0pTHMtgfxCS53C/ZWHoWnH6YRnYw9OQvX7I3ZUKmhieBuo6hiZ51Y1YrZrKunkNOW8DPS2NiokfF54B1ZqJoYsTw0hOul+W5zzvBDMvxEbhJpahc6fhHIvnvA6ctxE7GlJTtQ3ansdqtYqU8liIzUWMEMotfzHsDyKkhH2v8KCoV0yCuChr/YOPV8/tl5EMCFF4xAkEcZbxeM1ltx9hG0Wc72Qy2jLcZ2eRpUm9HpXD7PqFtx9wbgm9WUO6VJ6Wm0eU5tQcg3rFHL82SuB8lZRl2O1HKd0gQtM0LE0jzyXdIKIfOXO1q6wwyM/cqfOtl100TWAZgjgtqn598V7zwtdW3DzCYXL/RsXE0ASGptEPEpquYNV1GEQJz9sBb2/Wj8lnWbJW1rpVcfUs7MhBCOEIIf65EOI3hBDfFEL8ueHrq0KIvyeEeH/4c2VRbVDMzkku/WGakQNJKrnXqmBqgmcHPkmWsVK1yfIcTWhFToGxK7vGd172+GhvQJLltKo291sVNMHwREQSJhlBkvKFrea12TQq3nBaudRZTzKnDSM5er8wyXg+LHd1VgjLSS74s4SbLCvnuToe/Y6upfPO41Uqln7idz4vJOUslFv+YojSnEGUjMM/hBBULB0JU/XLSAbWXItekJDmOXcaDhXLYNUtDMeTsrDVqpTiPjuLLE3qtUSy3QmG2e2nK6E3S4jN5DO5zrqvOExZc9GIWWXqNC4ypk7SC1IMXcPQiusYmoaha/SC+SqHlMX3P1rh/qpLnOZ0g8Lz9v6qy/c/Ust6xXH2BxH1isXDVZcgyUCDimVg6zpVy8DUNLp+fOJnz5O1aXX2vLGi1JLFioVy7uguhPgPp3ntBCLgx6SU3w/8APD7hBC/DfgzwC9JKT8D/NLwd8WSMHLpl0ieHhTx7IOwcO+K05ydboRt6CCLMpT7/cLzIpeSlmsRJhk73YCKabDRsHmwWh1mvdbQNY27zQoVU6deMbnbrPCDc9ZXVxznAro6F2XFCo5kzjKKko2aKEI7ao5xaAN89H67vRAQbNadUxeHYZLx4W6f7W7AXj9ku1vEWU4aMS4Sm3yVTLMRO/odW6413qhCocOjyfkiRohpNxBlbQwum8vWrUk+2S9i33d7IVGakWYS19RnMg7ZZuFppGkQJIWXw9ubdd7eqB2S/7I297PI0iG9ziVZVuRraVTMc8thzrvYvO66f5Tbrldlxq2XuYEpz7BbeMx1gph9L6ITxMPx9mpDNVquxW99a43Npk3FMths2vzWt9bUmm4JKHPOKmt8GemDY+rcX61Qs02QsDsI2ekFeFFMwzVP/OxZsjaLzp43VpRldFQsnmnM0z9xwmu//7wPyYJRdhVz+E8CPwX83PD1nwP+4BRtUFwmUrLdDcmlxDE1emHMd1/20TS4U7fY9yJe9yNe9wLCJOPAK2LFXvVC3tvpF0nktWKQGik/snDT1YTgbtPhXrPCatWaK3GU4lTm0tV5KfMks1ExWas5PF6rcrdZlEU8ugGevF/bT9jpBEgpaXvxeKI6ujjcbvsc+AmGpuFaRf6VAz9h+5xT3WXirMXDSUkbz1tonDbZA3OfYk6zgbjmJxuXqltQPK8wTsd79zyXbLd9+lFCzTFByhP7elJePtzt88HegFzCStVis17B0sWZoVanbe5nWcTOciI+qddRmrO1YnOnaY+Tej5YqYyrkhxFLTaVXkG5c1GZMlWWZ4hj6rzsBjw/8HnR9nh+4POyG1y54S1MMrwo5UtbLX70c5t8aauFF6XXRfam4roaBylJt8ocXyb1YaNqEyUZQZqhi8LDO0wlm43DYVGj+397u8uHewOebNSPydosOnveWBGlOVme87IT8Mm+x8tOQJbnypv0HK5CT07NgSGE+NeBfwN4WwjxjYk/1YH/7zQXF0LowNeBTwN/WUr5q0KIO1LKlwBSypdCiM25W6+YilmSSIVJxk4/QuY5FctCSnjVjbB0iWlodKMUx9R5sOpiWxqb9QrfeN7mwIt5slHDixKCJGXFtXm09iYLfpIJ7rcqKjHOAihDV6fhNDkqI5Z22rh0x9RZq9mEScbdlQq6EEgJO92Au83KsVKPu/0I19IxdW18bdfS2e1HvL1Zv3C7F81kDLUmCo+J91/1ebTqsnVEf6aNtz4tX0WSZsTpG0PQLLkBpkl8dR3zZFyWbp3EyN32i1sN3t/tE6QZpqENF3sZsRCYR/p6rWaPn7Nr6Txr+0RJhqkL9gcZcZYjiu/F2xu1qdsyayz/rHkmJseRXDKWESg8/8xTii0sKp65jMSLl4XSq4Ky5qIyZWqtZvPhbh8vychziaYJqsPSqrMwiBKCOKPuWOgaZHlRWnUQzV5GtUyWVfbK0t/rmJy6bN2a7ONRcn8vTukEMV/aas30HA7NC4ZgvebgxymrVRPbMjA1ga0fTio+ev5RmhUHUF5RDnwy9HWUO2mn+6bPm5XTcyedN1Y8b/tULZOKqZNmkudtf64yw7eFq9KTs5J4/jXg7wD/ew6HefSllAfTXFxKmQE/IIRoAX9TCPHlaRsmhPhZ4GcBHj16NO3HFEeYVbC2OwG9oDixbgcRjqFTtQ00IclTSSdIMISGFBINwbO2T9OxyHKJ0ASdIGXN1bBMMb7+6MShrAWG4hgz6eo8urXoAWqWzM+jCXWz7rDTDbEMgalp7PZCXNugYmh8uDfANjSiNMPSj5x2Sa5NlvTRd82l5FUvxNJ1GhWTfT9GcnoOCzh9MXnaAv2iRsbz9PuaJs9auG6dxuh5Wa7Fl++3DlUEcSwDU9eO9fUHe/3Cy2L4epRkHAxi3tsZcH+lwlrNQkPwdN9jq1WZum9n3ajMm8l9VsPHIiqKXLdNy23QK7i8NWHZMiWFeBPpIYe/z8i+F7NRs4nSnCSXmJpgo2az752cL+CyWEbZK1N/l9VAcw6lzlmTlQl3ugGWrlO3DQZhOvNznZwXwiTn0VoFoQkEYmx0yCeWZvuDiFwWPz/e96nbBq5t0PbiIh/fSNak5HknpGobhdEhlzxvB2w150hyKyUghuGLnBvGqLg6PTl1RJZSdqWUH0sp/yjwkCKfxSeAJoT41Cw3kVJ2gH8I/D7glRDiHsDw5+4pn/krUsqvSim/urGxMcvtFBPM4lrV8WN+7ZMDun5CN0yIE8m+F1OxNGxDx7KKDaGmQatqkQMSgW0KTFPnfsvli1tNDF2QpVLVUL4kZtXVeXSrbFftsxJrnheXPhlHebfpoAnw4pSn+z4vDjz2/RhNFCe5Mod2EJMMQxuSNMdPUu40r0fo0ui7tr2ico85TOYoJcee/7Tx1me5NS8yN0DZifYug8vQrdOYfF6jiiBbLZeHq2882yYxdcEgTMevF2VQE/pBgmkUif/2+hFxnlN1jFN19yTdnCeWfxZZGt1zuxMghCBJs6lCAcrMfTDiuoWl3Aa9Gn7mTN0qy4W5TJnaH0Q0HJNHa1XeWq/xaK1KwzFnliVNExi6RsO1WHFtGm5R7U3TZjeGQHnPahllr0z9vY7Jqcues0Z9PLkGySRUHeNC46Kla2TFJmLYjuOy0wtT9gchUkLDMYftiBhERfLa8fuFKC40YSgEeWro4ZkIwYOVouDAKCfbWWGMiqvTk2mSeP77wJ8G/uzwJQv4+Sk+tzH0vEAIUQF+D/Ad4BeBnxm+7WeAvzVzqxVTM61ghUlRms+xdBquwV4/Yt8LsTSBH2W8HkQYmmDFNelHKUFcnGybmsSPc1arJlGaEcQp/SilFyW0vVhleL9E5tXVaThNjnpBMvNC6KIxlUc3di3XKqoz2BrrNQdD03jVi8il5MGqiw6keY4fp6R5zkrVvla5V54d+Hy8P6DtR0USx7yYtI/q8bSLyUVs+qbhqu5bBovUrdM463md1tc1xxi/3vZi1ms24VB3dQ0Egtf9iI2afaLunpofZVh29+j9ytioHL2nqWtIYKtVOXfuOC+eeZ6N2nXbtCi9KjdOv8x8GmXJ0nq10OM0l0iZD6vD5axXrzZJ6VrNph/EPD3w+Pj1gKcHHv0gvlLZK1N/l9FAMy1l6dZofPHiIpl/kuXEaU7LtWZ+rpOyt1qzeNH22G6HCIpx6/mBR9V+Exjgxwma0DANjaZrEqU5e/2Yj173j8nagxUXMTQ6CFH8ftK9p6lSMio4MMrJpmvatejzq+Kq9OSsEJIRfwh4B/g1ACnlthBimgC+e8DPDfNgaMAvSCn/ayHEPwV+QQjxJ4CnwH9/vqYrpmEad8gwyfjmdoftjo9rGbS9hI26Qz+I+N5enyDOWK/ZfLzn8WjNJZWSLJNoAizdACujaum86oYESUqSZdiGTtsv3LyU8eLSmFdXz+UkORqEKW0/puaYM7lqXtTd7Kib+bO2z+t+SJLldIyEpmtiGRodP+ZOw+FOs0KjYi5FPPtpsbknvQ4QxilRmuMYOlGS86Id0HJNHq9Vj+nxLHlETnPvX2Ts/7xhBUvCwnTrNM56Xqf19ZON+vhELEozLENjpWpjGYLXXsT+ICLN8qKSiaXzha3mId0tTixPyI+S5XPnRzmJkZz1wpRP9gfYRlGJaKVqHQqJmiX/ykn3mMeVfBFhKYtE6dXyuvrbhkY/TPGilDjLsXSNqm0cC7s4j4erFT7cHdD2ItI0xzA0VioWD1dnN8TvDyKkhAPvzThftYy5n1UZITJlUqb+zhrStmSUoluj8aUTxAzClKpjcLfp4Jg68VB+Rpy3fpjU0/1BzqO1Gt0w4UU7wNA1gjjjn7y3y5fut1itWgyClH2vWGNWbZ00L4y0tq4dkjXb0Mgl3Js4mJrMnTTLXHDN+/xKuKpnNo0BI5ZSSiGEBBBCVKe5sJTyGxTKc/T1feDHZ2qlYm7OE6yRYkdxzoprkWTFaXUmc7bbAa/6Ea2qha4JwjTDNHQ+f7fBs4OAfphQMXU+vV7jYBDTjxIGQcJn7jRYqVoEcca3t7u883j1uiymrjtz6eo0nCRHe/2Qjboz86LxInGzowkyziSdIEAXglftgK3VCn5UnELu9iI26hbJ0CWxUTGvfPIJk4yP9gZ8c7uLaWjcbTisVe0TEy9ObibrFYuqY7LTC9huF/GntiHQhDg2QcyykTlp03cZsf/XOA/OwnTrLE57Xmf1tWMWbr15Lsk0yZfvN3h64PPJvkecpPhxxk4nYK1mc69VYbPhjHX3+YHHp44k9yz0nXNla1rj1+QpXNePCKMiwWHF1MfJeG1Du3Ac/byb2uu4gL3telVmLoZR6e3JxJtdP+btzfrM42DVNnhvp0fVNnFMjTDJaXse7zxenek6Mi88klquSZjlOHpRVUvO4RTUCxJ2+yFhmo+/n2NobNYd7q/Mdq1RiMz6hMdFnOZXajgqK3EqXHvjYGlzlmPqfGmrNV4fmLoYe3pN7iXO0pswyXh24CNEcb1BlNKsmBi64EM/JsshyzNedWOCeJ+KbbDqmtxrOvSilO+87LHZcPj8vQaOqXOvVRnL2nlj9ixzwTXv8yvhqp7ZNAaMXxBC/F+AlhDifwb8a8B/ttBWKUrjvNPWb253iOIcPylCQuIsx9R0PtrvEwxdFOsVEy/KyKEon9qPqdrFYFC4EBbxaCuuyePValHiD6hYOv3gaiezW8bCdPUkOWpVberO4SFkmkXjvCckkxvsFdekZhs8P/C423JwjKIdH+56pFlOxw95vFpbio3HaGL/7qsBVcvANIoQlyjN2WpWjiVePLqZFELjrbUadxsVDgYRvTAhSTOEEGx3gkObxYtsZJb1FHNJWLp58Dzjxmgh3w0TvrfTY/vAJ6eI701lTpbB/++jfX78i3dxTJ0sz3ndj8iBqmWMvSGmScI8i/FrJGf7gwjbMGhULeI0x48zVlyLthePw2QuwrybWrWAvVRK0asyT91HpbertoFhCNJccuAnOG1/5k2wF6U8XK3ixSlhmmObGqvVKl6U0nKtqa8TZTmNisG9ljuuQuJFMVE2uwWj68e87AYIxLhUsUQeqv4wdbuWMIknQJjl7PWKkEvb0NFbcyRzHHKNjYOlzlnnjYvbbZ+dXkSaS7I8R9c0+lpRtXBrxeVF20fXBLoo5K7jxxiaoBskhHGOEHmRZ0ITvOyGZHnODzxaoWobbNYcoiTD0jSEKEqCwxtZO69ts8rpNe7zK+Mqntm5Bgwp5V8QQvwE0AM+B/xvpZR/b+EtU4y5qFv3WaetYZJTdww0XbDdDlmvmRi6ZK8XY+qC9ZqJH2eESUouTX7j6QEN1+bJZo2GY+LaBl6UYplFYsHJ+LU0l7i2vrSxwzeNRevqMTlq+3MtGqfxCjpJ3k/aYEsJhq7RjxK6fkzLNdn3Ij7a8xForLhmWV9/bvYHEV6SYeiCiqUjhKBqC4IkYxAlDMKU+63jMbtCiEPP1zF11usOzYqJpEiCNXp+ZXhKXMZi9DqVp5ykbN26rOcwcu/uRik1x6DimGw0HAZhSpQkdPyYthezUrV43vZZqdvoojhde9nxWas54xwAZ3GSW7quCb653WHFtQ99x5GcxVlOxdRpVswi/DDLWK9BP0qpp8aFF0MX2dSqBezlUJZelek1U2bp7SjNqTkG9cqbeUhKOfOYahs6Gw2HIM4J0yIUZaPhIJg9XKMfp7zqBgSxJJc5mtCoWGKuvBXLGG613fbxo4x7rQqGVhigvChlew4DFKg5a5KzxsXn7YBBlOBaBtawEsggSnjeDrBNHSkhR/L8oChRWncMdroBSSbJZI4uNDpeRNM1CZMMP4r59WcdfuKLd8lyiS4KL/C7zcaxCofntW0Z5fSmcRV6Mo0HBkOhV0aLK2BRbt2jzWDVMshyqNkmWytFXgPHMHi8ViGIMySFESKIUzp+ipQ563Wbthdxp2Fj6hqupQ8z3RcxbBWrGLziNGetaqlB4hK5TF2dd9F4nlfQafJ+0gbbtXW8OMMxNAJTJ04y8hy+70GLrZUKg+H1rvIENRq66rqmTpaDoYMuIM4lfpSNEy8enVw36/aJeQeEEFgnlNC8qKfEoif561ae8ihl6dZlPYdJ9+77rcJ7x7V0vCil7hj0wxhDCKI0Y7cXAoKHQ/np+DFemNMLY7601Tq3Xb0goRsk2KZOxdTx4pQXBz5rVZv7LffQdxzLma6RZhLb0FmtWQzCtJh/rHI8Hq5jKMhtpAy9KtNrRsqJagbjF+crvV3WmLpZt9nuhqxUrUOb8q3m7EaHg0GEF2UYmo6uFRtLL8o4mKOaxDLqWJkGKDVnTU/XjzF17dBzNzWNrh8fmh8errrsD2L2Bwl1x6DqGHzzeUyUpoXxIs7RBLi2iQE83ff48oMWVdvgdT9EE6KoKDeDrC2jnN4krkpPzjVgCCH6HB/Ou8DXgH9bSvnhIhp2HtfVKjori3LrHm0GV6oWO90AANfUyTNJdaUCFG6TSS4JopSqXVQmCZOUNK+Q5jm/9skBK1WbmmXQdE2+uNXk29td+kGOa+usVS2E4FpkQ78JXLauXmTReJq1/Cx5P2kxWLMLD6Ekl9xrOLzshkVs/0oFU9dIk2zsrn5Vk5VtFOXuqk5Rvxx0JJJMSoTgUOLF0+I3J5/vdic4Mcv6aad6k2MlUNQrE+LYuHnaJD96/aJjbdnJ4y6TMnXrqIznMufAj3ne9qk5Bq5p0KiYMz/no3NiL0xZGZ5m1RyD72z3cO2MhmNQMYsF/kbDIc8lclgqbnS/u80KsiHH7rnn4ScpmhDjxasfFXqXSjlMDPpGj0fyVLUN9gchSVYkZHtrrYoosWqVCgVZfsrUq7K8Zu40K2x3ihxEhi5IM4mfpGy1Zr92WRunrRWXTpjwshOMwyLuthy25vi+/aA4pGpWTXRNkOWSrpeMQ4FnYZRQ+IO9PoOw8PJ6sjF7rpAyKdMAtT+ICJKMD/c8vDilahncazm3bs6ahoZr0vVj0kwfhzklWUbTtQ7ND6aucX/FwI9SdB2+tNUiSXK+87JPEKUIBKahEac5KzUbmUt2eyGrVYtPbdR40fFnlrXz5oLbsp9cFFelJ9N4YPxFYBv4a4AA/ghwF/gu8H8FfnRRjTuN624VnYVFuXWPNoOOqXO3WaHtxfSj4vTryUadfpQikPiJZKfj049SHq+6OLaOF2a0vZDVqoEGvOgEOEYRf//O41U1EFwdl66rZbtanyXvW63KscWgEPDFreZ4AZXmknstB9vQSbJ8XG70KmNy12o2XT/mwE9ouSZdP6EfJmzUbL6w1aTlWuMQmZMm16PPd5ZTvcmxUhPwvO3DMA/CqHzeZPLHo5P8aQlG5xlrj57Sp7nk9SCiWTFnTh53BZSmW5MyHiYZO92QXBa5giqmQTdNMHVtpud80pzY8SKyPMeLUu42KnzxfpPv7vR42U2oOSaf2qjxeNXl7c3CgJYfWerOclLsWiZdPyJJcwxd4McpmgDHfPP5k+KVU9fGjxPqpknF0kufL1QoyNKzdOvLrVaFIMnwo5Q4k2hCzF16u0wjmqNrbDTsN4k358hZAVCvmAgNcilJkxxNEzSrBjV79nDL0cZvs17hfquYk/cH0Xg+uQrKNEDtDSI+eNWnaps0HYMolXz3ZY8nd+rXYVy5VN16uFolzSVplo/1puqYPFytEqX5ofkhzYrwpbpVjPff/2iFvX7Eh6971GyT9bqNrRtULA0BZLkcr0XmlbWyq1Up3nBVejKNAeP3SSl/eOL3vyKE+GdSyj8vhPh3FtWws7hNyebKckEcl60LEvwkRdc0/Chlo+5QdwzWajb1tPjpRSm2rhHoBjVdcqfu8PamyZ2GQ8eLyfKQDEmU5AhNsNmwqTlvTlJvWh9cI5ZOV2flLHk/azE4ypBtGhoaYlyr/G7TWWis4zSWe2eYAd1p++z2iw37Z+822JooMTzLRmuWU73JsfJlJ6JqmSCgGyTcbVbG7xl99mg7RhP7aWPtaeVfT3omR0/pTV2QpDl+MvvJ3xVQmm5NynjHj7EMjd1eTHWYU2gQJXz02sO1dTrBdCEcJ82JG3WHb77scq9RwbV13t6s4Vg6WVZU/PjcnTpbK2eXZZ1WJhuOgaEJvCglSDJsU8MxdOrOm03RpB6GScZOLxifpN1rVWZKaqi4MSzdnOWYOk82aqUdxJRhRNsfFMl1O14yPuGstObzLHy86vK9vQFenBXfb2hQfrw6exuXcS1epgFqpxtgGTqVocG5YhUlpXe6ATxceqv7perW5HPPZfHcXdtgq1VhfxAdmh8sXWOt5owN+S3X4vd86S7/6D0NmUnqrompa/SCFNfWMQ3BwVDWcinZ6UbEWY4AhBC8faRy1iycJcMjo4k6kD2bq9KTaVb1uRDiDwshtOG/Pzzxt9l9skogSvMTXahvYrLItVoRBx+nRf3jUemiWcIyRhbGIM7oBglZBmGc0qiYvO6HtP0EbRjqMTqJe7xeZa1usVF3+MJWk1XXJMskNcdgxbFYdU3W6g4bdYfHa1X0G/r8rxlLp6uzcp68jxaDb2/UDlnIJysv9MKENM+507DH5UYXEcY0WQ7StfSxR0OYHPf2GBkxftuTdX77pzd4e6N24QWxJsCPs3GSxZOuNzlWxllx+mFob3T1vHHzrLH2pO//wd6AD3f7Jz4T1zLJZU4y7NskzclljmtdfaLVKShNtyZlPEwyZC7x45S1qkWUFrHocZJTtw2iOD9VpiY5qZ+KcBQdyygSxlZMnR96vMrv/OwGX7zfPFQWchaZOu07jeaQR6sub63VSLOcqmUc0+OOH/PuJwdkGay4FlkG735yQMePZ3mMipvBUs5Zp80zV8XeIOK7L3tkuaTpGGR5ccK5N0feirc2amRD78RRjrIsy3lrjk3gMq7FRwaorVaFjbrDVqvCkznnW10INFEkpJdSkuYSTRSvXwMuVbfOeu5H54fJ30e0XIvf/dlN7jQddAS9IKZZMaiYGg3H4umBjx8l7HQDpISKqaMLwdN979z58SxOk+FekEy9vrvtXJWeTOOB8ceA/wj4TyiE/p8Bf1wIUQH+Fwts26ncpoyyZbggjiyMB16EPYx9TtKcNJM8WK2OF6uHT1s1NhsO39vt87Idsl63MTXB+7sDDryYVsXk0apNxdB4f6fPIE55uOqyWrXUSdrVUYquXmU84EXzarw9nEC32z473RApJXeas5+8TMM0p0+LepajRcHo2qPTgqPXnhwrR0kTEYzHyvPGzdHnc5nT9uLxqcdkaMnk9/ejFASs1Y8/k6On9EdPYZac0ubBSRmXEjIpud+qoAuNth+jCQ3L1sgkVB1jqhwuo34K4oSnBz6DKMUyNKqGzlrNGfcRQDyUxdPadZRpvYwm9da1inBCL0qPhSP92scHCF3QcC00TcO1i7Z8sNfnhx6vzfIoF4KKh75UStOrZe23jh8fyxEx6xpppxsghMCLUzpBjqlrCCHmOuHMcskPfWqNl90Ab5jf7F6zQnY0hmwKbEOjH6Z4UUqcFdVRqrZx5WN6WaFjqzULPypybIVpjmVoNComrn31cjUFl753m3zuR/Wxahvn5q9ouRbvPF7lm9sdTFM7VM674xt852UPxzaQMsEyigIC1Qnv73nGANvQGIQpXpweys3lJyk153h5+5vo6X9RrkpPzjRgCCF04F+XUv6rp7zll8tv0vmojLKzMYq5jtKibB2AoRencpP5AXpBQpRmxJlEIomTnLv1CnXbYBBlfG+3x51GBdcy2O1HvPeyx4emhmsWme6rlsG7nxzwzuNVZcS4ZMrS1cuIBzxvkilj8SEpjHJllhk9ynn5aRb5LKe99uRY2XLNQzkwRqfiZz3rIkHbgLYX4ZoGWZ6z041oezGOqfNozWXSkS8/IYHaZA6TsO2zVrOPJQldZhYxD056DI1OefYHId0gxjY0XNsch0BNk8NlrWbz7e0O7+961B0DQ8DLto8UEGU5n9qoUR9Wu5llrpxFhk/S21Ful16Y8nTfY6PukEpJTdfZ7UVsNmxsQ8cxC+PNVaPioS+PMvVqWfut48f86gevSXMQAgZhxutexA8/WZ9pjZRlkrYXFwZNXRBnOV6YYhvOzG2K0pz1ms1G/c1n5yntClC1Dd7b6VG1TRxTI0xy2p7HO49XZ75WmZRlzHqyUefdTw6o2SZOtfh+XpTwZKNVfqNLZFF7t2mf61F9HIQpzw48HqxWx1WpTstf4Zg6K66NOyw5P6JRMfin3/P4zN0GjqERpTkdL+FLW/Xiv/2Yb213kRQFCWqOSTjFGHCSDB8MPFaq9kzJ0m8zV6UnZ7osSCkz4IcW2oI5uKi763ViFjf10xidztmGRjq0sqfDMnaj18Mko+3HxGkRH93xEjp+QpznWKbOXj8iSmB3ELPRcPjS/QaDuPjMwzWXR+tVVqo2Vdvkg73+oh6H4hTK0tXJU/WieoA2PgEug44f82ufHPDxvkfXj/HjrHS3vEV/hxEjvZpk0qNhke2Y9tqTY2UuYavlstV0yCVTjZuOqVMxNOxhDov9Qcy9psN63WYQpTxvB4f6ThMCTTs86R/NYXLdxu1FzoOjZ+JaOk3XpmLpuGZRJeRu08Ex9am8Cx1TJ0olrqWTZpJOkHJvxeV+08WPs0OhgrM884vI8OTcFcZF3qV9L8bSi3LClqHRDZLhe3NqzlRV3Wdi1IYP9wZTjTOXNXYoytWrZe23b73s4sc5tlmcFtumhh/nfOtld6br6LqgVTWL6gyZxDQ0WlUTXZ/dRfu8eWsWvCjl4WoV29QI0+J7Plyt4kVXl9coTDI+2Buw3QnY64dsdwI+2BvMtcYYeQToOrT9GF3nWhzQLWLOmmUvclQfvTilapt4UTqVfp4ko70g5dFaDV1oRMP9y9aKQy9KQUrefdrmwCtKtu72I152g+HBwNljgBelPFitYhna2HvgwWqVTOal6clN56r0ZJoVw7tCiF8E/gbgjV6UUv6/F9aqKbgt2cXLSJI0LltnGbweROPY87WaMz6N2x9EbNQdDrxomCFYYuiC7XbARt0hyXIer1cIk8J9cbNhsz+IgZwHE+1YlpO0W8qFdXVRVW+gmAC/vd3F0DQqw43WgRexWrVLdctb5HeY5DxPsEW2Y5ZrX3isFIKHKy473ZCqVSyipZQ0KgYg2e2HPFwpTlVc20AMcx6c9Eyu8bi9sHlw9EzuA59ar45PrkxdTOUlMyJKMx6turz2Yly7CNfJ85woyw+FCs7CRWR4cu5KclnofC5pVgoPvoosygn7UYoXJaWf2s5zKn9ZY4diTCl6taz99rIdUK+YhxIXVx2dl+1gpuvcbVaKLP+WgV0RRKnEi94kYp6FMj2Yo7QwPNYrb/IYzevNURbbnYC2VySsHlW8aHsR28MQ01lpudZShLbNQalz1ix7kaP6GKV54d0wkRvlLP08SUa9KOUL9+p0ggRL1zGGScB7YULNNnjdD1lxbQxdkOXQ9QtvRl0720spSnPqTlG6fISUw2oqaXaoDcrT/3SuQk+mMWCsAvvAj028JoErNWDcFsqYmCfjk5sVEz9JqVuFi9bIBWykxJah0fZi8lyi6wJNK5LBNRyTMMmp2AamLuj6CYYmkEeceBZ1kqaYigvr6iLzy4xi/itD10BzeI9BmKBrs58kncZl5cg5L1/HIttxmXmARveKszchaGkuqTsmzYrJy04w/v5PhgvEMsoGLhmXMg9eJAdMzTEIk6L6jjOUgyiVVC1j7s3cReRscu4a5V8xdIFl6nz5fpPv7Q4Ik3xhpzXzGP9vU36tJaEUvVrWfrMMjSyTh1baWSYP5aSZho2ajaEJXnZCumFRheRz9xqszKEzZZZ2Xcbn/qob4JoG5rANpiFwpcGrbnChahXXkFLnrFn2IkflovDyzg/J/VlycpKMPlp1MQ0dxzJoezFBkiGAR2tVXnUDGo4FgmH5XKiYBi87waED1pM4TYYbFXOct+mGrWVuDOfuNKWU/5PLaIjiZMqaIManfKfkexrdxzF17rUqrFQtnh14xHGOLmCzYfOt7S6NSuEC3gsSWhUTtCJx3yh2bBEnaYrpKENXF5lfJkpzXLs4hR3FFhq6oBembJa44LnMHDlneRQssh2X+R1H9xJAkhalk0f5GTQheLRWPXbfm3ZKcZnz4LxeKqM41DTPSTLIcvDjlC/fb869qbiInE3OXStVi51uQJIJLENQsQw+d7e+0AXhPMZ/lV/rcilLr5a13z59p85vPmsjhMA2NaIkpx/GfGXGxJtrNZswyfj8vUYp+YPK8oRbxucuhICj5yHDje1touw5a5a9yFG5qFrGMK9EtahANoWcHJXRSY+6u01nfI2tVoXdXkjDNej4KZBjaIIkz8lyztWRs2T4GnuM3grONWAIIRzgTwBfAsa+OFLKf22B7VIMKWuCGCXf6QUJfpLiWiYNxxh7YBy9z6h2tqYJ+lFKs2LxL31mk51ewIEXUXNMftvb60CRPb7tx9Qc41rEB95UytDVs05nLpIYq8ixEtH3U7wkZW2Y9DWIs3FVi7Io84RpWdtxmd9xdC8xLFlWdYxDJWpvwwR/HebBURzqd7a7fLTv06yYfGmrQcUy5u6n0dxwtIrCNHI2OaeMstB/sDfANXUyKae+zrzMY/xflrHjtlCWXi1rv31qvcZeL+Ibz9v0wpSGY/B9D1b41PpsngDL+v2WsV2bdZvtblicxGuCNC9CWraasyc8vc6UPWdNsxeZXCPGWc6rfkgyDDP6wlaTbNgX88jJWbI26vOVqokfZXhRRpLlfPHe+XPMMsqwYjqm8fX/L4DvAL8X+PMUpXm+vchGKd5wUeUKk4ztTsD3XvXp+QmvvRBb12lVTT5zt0HXjxGaoOPFDKKMIEmpmDqrNYv7LZeKofH0wCfRcyqWQatiYWqFO9cog/Ao7mk0eB148VKVMbtFlKKrJ1mdL5LlffTZhmORpDmGbvG6FxE4GY6h8fZGbWbDSBmVTCavAYCURJnEjxNc0xi7EF5EhhdpwT/v2mGSsd322e1H43KyW63KzN9n9JygcNdESnIJ5kROhRdtf+nKF5bMUsyDh2RWyqK0AYyfe8u1+G2f3uAHHr95n3ZKP1VtAy9Kj/0+aeS2dUGQ5mzWK9xvFYvW7bbPgRcfuu9J/T05d7X9hH6Q8KV7TWrDaiinZaE/73tPK2OTC+4sz9nrR3hRyqPVotzeaZ9Xp26XSml6tYz9FiYZQZzy1kYNDciBIE7PlL+zrrXTC8aGxKptzD3O7nQDfv1Zm46f0HJNfuDhylz5NMpuVxlsDctpeklGnEo0TbDqmmzNKRtllMG9Ikqds87bi0yuETUxSp4peLxWJc0kH+0NaFXtQwenI44esOpCw09SkmHYyWjtchqTfV61deoVg6qp86nN+kzf7SjLWpp5GbkKPRFSnlz7WQhhSClTIcS7Usp3hBDfkFJ+nxDCBP5bKeWPnfjBBfDVr35Vfu1rX7us211rji5wgzSn7cW86gR8+LpPmOZUDAMvyWg4OquuxSBKsU2djp9Qtw0erLpULYPtbsDjtSrrNYvXg5hP9j3eWquytVIhzSR7/XA8IFVtYxxzfJIb1k1DCPF1KeVXr7odcDFdnVa3XrR9gjg7VCvb0ARhmrHi2mcO7qPM1dao2o0X48VF2NGTjfohuRmE6SG5OumakxPl5MbkTt3Gtgqb7Kg9wIkT0NFrPB9u7ExN4JgGuZSs12zExObvOk1kYZLx4W6fAz8p3Ogl+EnKStXmyUZtJgPoZFLJo3p93t/n4bbp1rQcl9kAkDxYcdE17cznfrSf+mHK8wOPh6tVDF3wvB3wdN/jXtNB0wQV0yCXhQuuRPJwtTru72cHPrah8XDVPbO/J+eith/hGEX42NhgYhlUrOkMjefJ4HYn4FU3QAjBZt1ma/i3jh/znZc9Pnrt0XRNnqxXhyVqZ5PRm7KQXRbduuj6ctFrwrL6++uf7ONHGUleJDa2DA1TE7i2PlPCu44f84/f36UzSMhkji40WjWT3/WZzZk3CTvdgP/2N7eRQmBqgiSXCCn5vV/ZmtmI0fFj3v3k4FAJylEY8Tybl7Kee1mbqVm+303QrYvo1eQ672WnqE7WDROCKMM0BA3HpGYbrNedE9cQUsKLjs+rjs97rwYgBKtVizsNh1xKmq7FRs1ivV45ZpAeGTDO6vNZZWsRa5ubStnjwFFO062zPDD+OfCDQDJqoxDiy8AO8NaFW6QonY4f8+3tLlKCa+sM4gyk5HU/xk8ywhQMTaMXpliW4Lsv+wgdkIK6ZYAGLzuS7a7P25t1Wo7F0wOP3X6EqQserVapOgZCCPa9CF3TCOOUmm3w7e0u63XnQtVSFHOzcF3tBQndIME2dSqmjhenvDgIWK2a47reJ3lkjDY8QhRW7pZrca9VGWcq96J0nGgvTDL2vfiQXJ10zZHBI4hT3nvVR0hBTs5uL2JrxeHBiksu4YO9AUJK6hXrmNfIZIK/l50iY3nb8/GilFbVGpYDhXtNl+22j4Sx90k/TPnkkwNWXKsUL40yODo5R2k+PI0wxhnwhSjy1cyik+clQiyjStKSszTz4OhZ51Lyvd0B0bAi1KteyFvrb5KnnvTctzsBB15cyLFeGDuqtsm+HxXGrSgr8lT0Q6qWQc0xMTHY7gTcazq0vZh7rQodPy5KteZyWA7v5P4eGdC8JCPPJc8OPNIM3tqoUrUM0lzyephU+rS8TEe/90kyVoS3DGh7Ea5pgIDtbkiYZGytuLzoBBz4EXVLR9cEr/oRjy0Dy9DZbvvYwwTWZy1oL+J9pjiVpdGro5TZ3weDuEiqaxk4hkYmi7l01pKev/G0zfuveqSJJJVgCNjzBE3b5Hd//s5M1/rah/t4cYZp6ERJhqZpJGnG1z7c5w+882Cma32w16dqm7h2sZVwbW38+qwVCY6OGZom6Poxb2/OFmoWJhkvOgF5Xqw58hxedIKpvb0mKfP7XSJXoluTOYcGYVLsMwwNL85Ysyz6YYoAtlbelJmfXENsd31e90Oe9SL8JCNKcrbbPh85Jo9XXT7aG7Ber/Bb3tbwowxL12lUTPb9mDDJiDJ5ap9Pq9NHje5Nx7rJa5vSuCo9mSaE5K8IIVaAfxf4RaAG/HsLa5FiLsIk41vbXbK8qBaw78c83R+gafDBjoefpjQcC1MXZLkkCaAbJoRximHotEXMZt3mwIv4cC/jdT/hM3drtCoWG3WDF+0ATTBOjmQNT+CDJMMyNKQsBq3JUkTLUMbslrEwXfWTlDST+HFMnOX0wwRdCFJ5fCMzytzcCxLafrFpquhF3fCdbjhO/jjaaI8mvY4fH5Or0TUnJ4yRW/x7r/oYmoZjauz0Yrwww9BcOn7CvVaFthfTCxPWa4W7Y8u1xrXHJ+8bZ8X1Xg/C4nqGRpLlvGiHbNYddvvF/UdGlgMvwtA0ojQjlyYv2j5rNfuQO/5pm6F5T4bOOj04aXJ+uu+ha9By3+QWMXRBnMk3ITNTcF4ixFkTJV7jk+xLmwdPe0YjuX/ViwiSjNrQkLDdCbnbrGAb2onPPUwynu57NJyiBG6aSV50AjZrFh/tB6xULF77IZYm2O5FPGhV2OtFrNctdvsBe/0ASZHvJM5yXNPA0t/kkTja32GS8WtPD3hxEAwNfBZJljMIczpeQs02ixOtNMdP0nOfx1kytj+I8KMUXdPoBAlxljOapnphjzTPyXOoVkyCJOOjvQEHg5h7LZuun/KFrea5m9RbYKS7SpZufVlmf2dSEiY5YRKT5DmmVlxT12dLKPkbz9rsd2NMSwcpiYUg8TN+41l7ZgPGR/sevTCm7SdESYZt6qy4Jll+sjf2WQzCFNfS2e2HYw+Tuq0zCGdf9223fQ78hKptYBhF7ooDP8FpFwdqU1+nE/D0wKM9SIizYqO7UjOpmLOXUR2E6bFKL46p0fbjma5zRVyqbtmGxiBM8eKUj/c9NCFouRZCSJxhFZJgoizp0TXE617M3iDmo1d9+kGCl6Ssug57/ZAV1yLKMqww5G+9+4KNqsNa3WKr6WAYhff4x3sD0LQT+3wanT66jnrZzRmEPo5XVM2zdI2Wa5LMriY3nqvSk7MMGJtCiH9r+N+jbLZ/efizurgmKeZhfxARJRlBkmObOpqUfPzaoxukWAL2+jEHgxhdE1RNnTiDLMvpBTGrdYdEwoEfE6Y5UZrx0es+YZKx3rBpOgaGppHlhZJbhkbF1EkzOV7IuraOd2TxfNXltG4RC9fVNJd8Z6eLqetUbY2Ol6IJSav6ZtAydUHbT4YyohOlWbHRT1IGuaQ+3Ljs9kNWXWtsfR8l2ovS/JhcnbQZtg2N7W6ApBgkhRCkWVFG0o8zNE0QJhm7vZBcSgaGzl6c8ewg4NGqgx8XG3hdE2w2HCxdY7cXYekapl5MVpqm4dqwNyjyR4yqprS9eFyDfGRkCZOMb293ebBaPXMzNOlmt+JahEnOr37wmkdrVWxTPxbicjQUrOGYJ17/pMm56hjs9SJqzpu2p5kcG46m5bxEiLMkSrymJ9mXOg+e9YxGcm8N81XkEjQhcK1Ctlar9onPfX8QFZ5zmhiXLzY0jW+86BFnOVme82x4z7o9ChPpIISkFyTYhk6jYvDJgQdSslpz+PTEhmKyv0ftf92NaLomutDY60dYpoGVxOz1Qu4PQxBzmVO37PHnTjNsnSVjUZoTJhn9MME2ilPuNJO86gXEqeSzd+rEliSIM7pBMj4RfN1PSLKMXEqE0M7cpJZRyvy0vr6mxrwyKF2vynqeI0PhTvfNtZqV+TYuK1WLj3YPqDsmFUsjiFP6YcIPrs1WqW23F+InKY5gqPcQJim7vXDmNvWCmPdfDnArBpqQ+FHG607EZ+7NXmLU1jU+3PMQojgY0zXBXk/yeHV2w95uP8K19LHHoKmLoXEkmsmA8cFun2f7Hg3HouEYxKnk2b6HIcTMBoxRaerRiTJAmBRJKZeYK9m7VW2D93Z6VG2TulOElL9oZ9xpOIRJTi5zamaxXjxpDeEnKe+97GEaOrqWAhptP8I1dV4PIiSw0w5xrCL0SQrJbi/i+x402e4GPG17vLVeP9TneV7c53u7fRqOyerEmHB0DJ9cR4VJRteLeXrg0XQtHq1V6XgJ77/q8XC1OlcusZvMVenJWVfXKSx2J5mKlQ1qiRidsD0/8BG6xp2Gw/NOscFLs5wUcKzihAop6fqFt0XFNsn7EQf9EITgIJNYlkGSpQh0BlFM1s35/3z3FZ+926AXCDbqDnVHJ4iL2Oi7zQphkuFHGS+Hi+uNmn0oJluxcBaqq2GSsdMNWalaSMnQXS9jvWqR5W9O85NhAsxavYJlaMSZpDJckCRZhhAQpzlhnLFWtdnuBMX145R6xcLSBUGcjeVqdM2jm7K1ms37r/qYmiDNJEIrchnWHIMgylitWnSGll8vTmm5FlVbpxsm/NPvHfClB00erFR43g54duCxUbfpBhGWqY3bkEvJimvihSmP1qokww3Xi7aPphVVelrVwttoECZESc6B92bBW7WMQ94oUZrz3qseNeuNm52uS7w446PXHj/4eGW8WR19ZrSJfdb2iZKMmm2MN1thkvHN7Q4rrs2rbsC9VgV485w2ajbtQYwXpeMcGO0gRgd6gQH4Uy3wq7bBt7a7SMA1dWqOiSbeJEjshSkdL2Kj7oyTM/aDGMcy+HBvcGgjcU1Psi91HjzpGUVDj4YklXzrRYcHKy51x+DjdkA6LCO378XUbOPE5xilORs1m1e9IhGroQm8KOGjvT536g67SZGPpjNIqFoar/tREbscpmytuuR5jmtZ7PUjDKGRZiGOqWMISGXxYL641TzUfn3oxXQQxuz3I3phQqOiEydFaFfVMrjXcmg4xrmGrbOy3+8PIvpRgiY0jNGptpDYhsEgjEBA0zV5uR2gawJNQJrmxFmxsB6FxoyufZJRoqxS5pNcU2NemZSqV2WFHxR3lzzvhFRtozCo55Ln7WCuKhaGJni8UeXFQcCrfkTDMXi8UcXQZvPAMA2dnb0BcZIR5xJLE1imzhfuNWduU5pDO4zohAm5zNGEhiQnzWc3YDiWzt4gpOVYQwNNRieM+dzd6Q0OI6SUx3teDl+fge12QMUwcIZGR8eCJDXYbgczt2lUmho4Ftu/xFzJ3s2LUh6sVvGiFEPT2KxXyJHkuSTNcxxTx49SPnjVRwj4wnDOGI3vbS9ikGToQtL2E+Jc0g8idARxLmk6Op0ww001bCumahsESc7rQcx2J8C1D/e5Fwm+s93l+x6s0KyYxKlkpxuM15a7/ZB0wtg5MlQX692A0UzwnZc9fvN5h82mw52aQ5bnt22sPper0pOzDBgvpZR/fqF3Vxxj3kQzhqHhOjp+lPGqG/KyG0AOuZTUbJNGRcfsCPb94gTZNA3u1yz2e4XbXjJ0vfWyFCEFNUtjve4QJpKdXoRr+fzA4xX6UcpHex6rVZtPbdSQspjcozTjTs1iux3wdM/ji/ebfGqGZIGKC7FQXd0fRDQckyBOsQ2DLM/Jcsknrz0k8PFef7yRcW1jfOJvGxppLjF0QZIL7rUq9IKE57HP/iAil4VHgKFrOGmGbej4ccxG3cE2NOI0P9EI5pg6j9aqvOwG7PZCXNvgU2suO70ITUDLNdluB0gpqVk6YjiPF8aRHNMQVCyDh6suu/2Qg0HMw9UqWZ4jEQRJSs0wMPQ32a9Hcfa6LpCyMMTESXH62wkSvDihKa3xgvf1IBoO5Nl4kzIIE/JcUrF1bEOnGyTUHQMvzg6F4Xyw12dzaASCotiEaxrjzVYxRoTkObgtHcPQeN72DyVa3BtE2IaGpkE/SECAjuDBqjs2NBydhI9WZYnilFf9CEPXMIeGnTDJ+NSES+aKa2JohVdNklnYhlYkhxt+ZvI+izrJXjCXOg8efUbjBJW9kCebNR6suLxoe6SyyM/i1m36YcJeL2K1ao2NZpPjrm0UG4s4y3hvp0cQZ7y/22e1amFaGh/v+bRck8frDq96Mes1Gy9OyAydVsWkYhkIUfRVnks2Gw57vZAkkzxac1mr2uOKIqP2Nx2DbzzvksqciqGhCfhwz+NT61XutxykFOz1Qh6suEPX8RgpORbqNZLPyez3DMPWtjvBuCJOkmUYukBKSZjmNB0TayhbVdug7hj4cUo3zNhqVlhvFNW04uywAfYko0RZpcwnuabGvDIpVa/KCj8AQAjipHCFHxlDTMG44s8s6EIjiFIerlaxTY0oyfGiGF3MZvwydWh7CQiJlJJECLw4Z57lVZhkaEIQpRlZlqPrhdzPmpejuFbOV+632O1HDOIM19L5ylqLMJk+THHEnWaF9171OfAi4rSYN1erNp+9M1v/2ZZOkmakWY6uFZ4hCIk9x8NquRZf2Goeq9iy5FVIrmTvFqU5daeo3rZStdjpBpiaRpLn1GyD72z3WK3bVKziIGSyClXVNtjtRcg046WXkOWSIEpJspxcaJBLvvmyT902cOo2HS9hpZJxt2mx1w+LtadlHOrzQZRSMQ0sQ2OlarPTDREIXnZ8iiWOHOdLe9H2EaIY20detnGa0w0KHalZJlGU0TMSojQ/ND8prk5PzjJgzD5aKy7EPKcy+4MIObRSd/wUTYCUKbvdiEGc4lg6q1UT2zLYaEI83FB6UcKuBNMwqFgSLc0QFG7mIKlaOnuDBFOTbNQsBnFGGOd85UGTPAc/TtFFkdNACLA0Qc2xaNWcwgp/PWIEbwoL1dUozXFNDS+EZwc+7SBmzTW5t1IhjDOeHgTjjcxeP6QfpjQqJi3XYqcbklAs/OM056PXAzpejDc83XJtgyhNcExtnD+lF8akuaThGKfK/upwgmy5FkmWEaU5q67JnWaFXIJtaazUikomvSAtQqOSjEdr1bFBwzF1Hq64+HHhtfGt7S4A61V77GkwchWsGBq+OcrVkbLRsLE0jd1eSD9IWKlah1xfkzTn+b7PnVZlnDjRNQ2yHLp+wmajmCBlLqlab4bhUSWW+603XWob2ji3DRRhLJrQqDjasOqCw7MDn91eyEbdHleneLxeHXtCCYpTvNM2TEdLoD1v+7zux9xp2jiGQZxl3F910YTgRcc/ZGBpVEwcs/gcZ9xnMkb2aCWKJeZS58Gjz6gXFOVHGxUTy9DZWnXZ9xNAslK1cG2dIM55sukiczlejE1WztkbRHzzRRdDg7sNhxcdn0GUse4a3G1U0IVG24uLvCy2wVc/tco3X/QIkkKPdU2w0wtpOQYJghzJ47UaiMKVvV4xidP8UB/3wqIcKwLkMLb+7Y0aNcdkrx+z1aqwUq1y4MV8b3eApDC265pGL0h5uFphkOQwrA4EFGWO05y2Hw89AQtDXN0yyCQEww3YnYbNqmuT5DmvuiFPhzH/Vcvk8ytVHq0Vz2ZUTUVKeaZR4qKlzE/imhrzyqRUvSor/ACKvtF1jWS0CZegD8OVZiWTORuNImQqGuaIcO0KmZztWr0wxbUEcS5IshxD17C04vVZCZIEEGi6IJPFTxDD12ejCK/UWKva1J18GIapzew1ARTehq89vDRFSIkUAi9I+YGHrZmu89aqy8cHPjmQJDm6LjANnbfmCGsJkyLR+Je2WmPjpRfNVwb3ErmSvdukp5pj6txtVtjthUhZHKLcXalg6trwsEZDE2JscP9ob8Bazeb1ICLKYLcfFIY1YaBLQTuIAEmaZwzijFxCmue87kdsNit89s4KL3thUaY4SvGilK4f89Z6fdxXd5sObS/ig92AR2tVNhvOoT5M0ow4LSrt1W2D3V6AEBLXMTE1DYnANDR2+xFf3LpVY/W5XJWenGXA+PGF3fWSuG4xpiedyky6iiPl+BRg9H0mq0O8vVHj6x/tF4osJEmaMwgTvCBma9UliiWmBn6c8aBZwR+eyuV5XlxaE0COzHNSKZFINK1I0Jllkrpj4JhGseDLi1wbmw2Hrh+DaWAO212xdPpBriyUl8fCdXUwDO2oWBqOaRMkOXku+eJWc7x5rQ8NELv9wsXcNjTWqoWFvF6xC5fyQUSzYlGxdLK8iN2vmBrfetHlt769zkrVopYVZQ5PK6H60d6AX3/epu+nGJrAsQqd+fSd+rgqyFarwrufHJDnsFG3STNJluXUHfPQKWuSSZCS/UHEZt1hECX4UeFp8IXhdwPGJValobPZ0JBAMtSbR2tVwiQlSfOhcTBlu+3x8UGAYWqs12ykBMvSed0NyXLJes0izXP8KOUHHq4cas/IQ2K0+a+YOt/a7hWGwmGekcqwogsUG6wHKxV2uuHwlEFiGsXi3dK1cYnjt9YPh7+auqDtxYDP030Pw9DYrDt0/ISqZdLVU/w4o+5YRGnGe696NByT5wc+a1WbyZCVyc3XaRuz1arFv3jeIc2LYUxKMDT44Sfr8wvm4lm4bk3OU1Ga8fS1x0rVxjE1tsOUna7P57ea40R5hau1pBcm+EmKaQj6UcLrQVFWbt+P+fWnbdZrdjH+SolranSjjDDN2fNiXFPjw/0AP8l5a6NOmuWESc6Xt2rkOTQqBrZZeG4YmiCMUp75MUIIwjglXZNs1O1xXoDJPn5vp0ec5txtOfhRYYxZq9k8XC1Ou9Zq9rgS0Xdf9vDijMqwulGaSzpBTLqX45gaNdsYG9RAYOpF/o4DL8IyNBxTZ71u88HugPWajWvr1GyTKMsRsjhha7kJbd9kfxCyUjXHC+1V18SxDNp+gh8nuKZxogcLvDFilMUiwlKuGaXqVVnhBwB+nFAxDdZqb5bHfpTix7Nv8F3TIEkldUfH0ArPkCjJioo5MxBEKXkOSZIRZxJyiWHqBNHsBgxD6HSCkDTXEFLixzmGlvNEzB5C0qpa/OazNo2KPfYwed0P+MrEnDYtH+8N0A1BHOb4UYZr6zQcwcd7g5nKu35+q0k3SEikRANywBSCz2/NHm6zP4joBgnvvTqgNzQkf/ZOHcdc6rXtlezdjnqqacMyqGs1m19/2j6URHqnG3CnUeTe2x9EhGmOLgCpsdVy6IcxaSrIsow0z+kNMkxdsh8VuTHCuCgDvtms8BMPWry1XiP84DV+nDFIMyqGwUajqEj3dN/DMjUEAiFgfTgXiQmPqmLTLVirWry/2+dlO6Dtx2iSsVFUSknPj7F147aN1edyVXpy6igqpTxY2F0vgesYY3qS+/DIVVyrwvNOyP+fvT/5sSzb9zyhz1pr9/u01pt5F82NG3G712e9BBKRgFDNqBHMECCkGiMxoMRfUCMkpikxAIkBCJAoIaQSUEqVUlRlvsx3b753+3uj88bc2tPvfq+1GKxzTph5uEe4WZhf93C37+DFc7tm27bts1f3+32bZ2lP46LGExJjLWWj2exGnGU1RlsiTwCSWakpThZ0lzE3TduStZpHo4xxVtFaUEtzP6MkWasp2paDIKI2zjH7g80OZrlDaLUluRA/lzeaXvRV+khrLEmortWxuMXV8crHqrWEnqP5/fF4gV1SuHuhorP0c1h1P93hO0AKVyiLA8VfPtgg8hVPxjmJ7+EpZyboKQDF4SSnE/jfSqde6Zx/dThjltcYDZNCY+aWOxsRVaMvdaB/dNDn14dTZqUh8RUPtlJOZy4m8mLXdeUwHXhyXYSZFw2fns4ZJiFVq/nl4RRPuizzNPIQuMVuxR7Ia4+sajmdVzyZZORlS6Bc1+50XrPTC9lMQhRQaddF3koCgkFM/Mz93Bm4yDBrQRvD4axCt5p+EjDOG2Zlw0738iFLScm9jYRZ2TLNK3zpPAFabTlflFSN+dqBaVG2jPPasU2kQAnhGDPa0I994kAtmQCaUVZjrMVPJXHorSUr4BghWe18FIZxcOn3rMxUtbEczQoMLg3FddsFnhKMFtUbS8l91WPr2XXqfFHheRKLk0KkocdGN+LLs5x7mymRJxEC53kR+5wvGvb6EdbA6bzidF6yP4iYlC1SSKQsnQt84BH4iifjgj88nTkplDGczGum5YidbkQn9rmzkVLULT/c7XK+cMbPR9Ns7TPx04MupTYcTwvyWnNv47JXzUoH3Z5lPJ0WzKsGYwSPzhfUrWGw3NCufmZetuz1QyZ5gzbOM8ATgj+ezvnvfrx7KeYY4RIG7m8ktEuq7zB18XzdyFu+r5q81gxjn04crMf0/gDmRcK0rNcsilVn/sk4p9ON152jz07mREtW1KtqfLwKWcr3CTc9rnb7MV+czmksl2Qf721f3Ysh8T2mrZPVrooOxlq6vv/tP/wMerGPryRZ3VI07r3b6oRXZp01GmZVi7WOHl8jaEzLNVQfFI1BG0HbtFTaEiqB8BXFNWQfoXJS48a4/aeUgq1uRKiufrj7w6ljZ/Yjn+1OSN0aJlnNH04X/NMfbL/0dQZJwN9+uHWttK9n8Xic819/dooUrgB1Oq84nuX80w+239ix+rrObi9iqj3PRBrcenUwiF3ke9UyLVt8BY/GzoC5aDRCCrKyIVKSxoAnBGXTYq3k8dgVQRBffeb/5e9P0AaCQPDxZg9r4WxeEweuOZM3LRa39+leSEy82Mj6cLvL+aLkcJZTVJrAl4zyht2OK9JZvi5t/r41y28ar2ucvNFWut8F30eN6bNdmXFW02ooW82vDmd4StCP/HVMJEBWauZlweenGaXWnExLysawP0gYJD7/5ssRxtYsSosvJEpK9gcRX55nLCpNbQzKusBoU1mSQOFFPv3Ip9QGYV304rRoOJ3V9KKcOFDsL2P7NjshX55nFMvDamssdWvYTIPbCuXbAiG4O4yZLqUS2hq85WH3cFLQT1xcFbiFoBf7zx1js6JBKvhylNONPIZxgBCOhfHhTsf5SeS1o9oqQegp7lxo5JwvKrJGMytqWuMMxGSj0VgmWcPhuOC9rc76e+8ME/7qwcalheXuMCGr2ksL7OGkWPt2gFuMzhYV2lqkgN89nWGMRUg3PkeLakmFL9cmReU4Jw09Ho8yBnFIq2En9hktKjY6IZO8ZpgECCH45x/vfs13YpzV5I2LgzyelfRin/G85L/6YgzG8vF+j27kMS9bIk/x2cmC0FNrtsZqQT2aFUgh12wo3xM0WhL6LgYTvjowfXq2YJ7V/O5oziSv6YY+Gx2fRls8mTp5QtNytqicBEW5v/8H2x1O5pUzzataGmPxpOD97Q7FMhWiGzuD11Xn/O4w5h8eTrDCcncjJfSWEbatvhbN+23Bs+uUBYZJgJKCvX7MNK55eJ5xNCuIA1dkK6oWgeDh+Zys0PzxZIHWxul/PcnpomKnExL4gsfjbN31HS1qPj1z702tDUVrGfjQjwMqbfmzjQ692Cf0FXnd0Is90sjF0e3lDdoYuklIYgxP6oJxVnN3GF/yqvn8dMGsbDielXx6usCXgsgXaAOfn2X82FeUVePmAgHdyCNUip2eYpo3lK1BCOiG/trBvNZmPb8Aa1+dYjlfSCEYpuF6TaxbZ7I27ISXnnUn8pDychLBqni0ev7GGkZ5Q1hr7m0kr6zx8SpkKe8yNtKA3x8703IpoGktVkk20qsfWnuxj7GWp9OSReVkVfv96FJE/MtiVajaSMNLharNZ97Nb4PGkpctVth1gUZYgb6GJ+O8rCkb5+/hmIQW3Vjm5TVkv8tkj2nRXEpsuUYiK6N5hbFQtoZFpZeFbvf1q2KQBPz1g82r38Qz+M3TGbOiRduWptUuIUO4r//tB280c/C14HlMteeZSFucxCANPR6dT/nlkwlfnGcoICtrGuuM4pV1xstWQFZrOqGk1SCEZTP12evHfHq84JM9x5btRT53hwm+cv5rn58t8JWgbF1x7d5GSt0aTucloa8ujcmLjazAk+x3c36XzzFly/1BRLEstNzfSNdz9SSv+e3hlM/Pc/qxz4fbKb6Sb3yz/KbxusbJW1vA+D5qTJ/tyoxz1wG7sxHTZDVKCEZZvXRuD3h4tuBff36KNXC+qBl2fOZlS6sN51nJNK/IitZRapeHFyXt0oTRsNHxqUYNNRZhoTUaYxXDNKQf+2gjiTzXjQ2VIG9amkbjS7epvNdxA/THB31+czhlXhiSULGZuoPpVRfpW7yZCD2JsbDXj4l9xS+fTBFKsNcPXeW8qPnzu4MXmm6CO6iP85p+HKCNc6x+MslJAn+d4306n7LVDUgDj6LW5HV9SUNXtU62UjZOA+wtuzzO0d2S1Y5Oe3GcP29BfbYT82zhcHUoklLwh5M554uaNHITcuBLitJQNi3bG1+Z1N4ZJvzqcMKscuNDCEFtjGNwNBpr3cb4/sblRW2VslA2mk4Uc74olxT5mvO8YbcbEftOIjDKGrqRQlcNrRX8+nDK/c2EXuSvTQ0XRQsCfE9e6h72l0Wl1YGpajSPllntgScx2vLp6YzGJAyTkIejjK1OxA+2O/zu6ZzWGu5sJOwtdaPWWv7LP5yy3YnoxwFJoMiqlo00XKc9PJ4UTmbWdT+jPInkKw8Q4No077cFz65TgZIYY9fxoOO8oRt7hH5C1VqeTHLuDCO0hn98MiFQkqfjjFHRstMN2PFDTqYleimZSmNnLPv4vOBwkoN13jJfToq14WrdGmLfw/Mk54uKexsJndBbH7T+/cMxo0Xl5CONoRd57PUd48kZArIeY8ezklFWkZUNd4YxR+OCSW7Y7AY86EZ4nsRTillZ85ODwfK9zUkDfy31yuqGQeyvx2SgHO0YAdvdgLo1a1+drGyREobpVwkR/tLMc5UctCqKCgGbz4z9Z5//JK9JloX4i8a6r6LxcdOylHcZWdVybxh/reiQVe2VO++rOMhe5LPTDSkbw8msvNZntZrfn2UDXPVgsygbPA+0VVhrkFKihJMIXxWL5R4RwBowEoy2LK7hp3Fxb7BC3RpnenpFdBOfT4+m9JKIKJCUtWaWl3y4d3Xpx03hdFouTcxDksCjaiyTsiJS78bB9CawekeGic/DUc6iagk8yUHPmT8XrSavalLf5/cnE7JCM69qfE/SaEEnDMjbljSQtMb5rARKsTcIWZQtOz03P4Mbu04q4uSGvpIEUrLbjximAeOspmq1W0O0odE8t5EVLRm7rbGcZRVKKbaigEEc8OEynGCS1/z8yxFZo9nquH3trw5n/PROn3iZQveuzO+va5y8tQWM76PG9NmuTNVqdnohndAnr/Q6tWFWNDw8W/C74wWdwFtPCEpKupHH00lJULXU2iKxzEunzY9DiUDyZFxSG0tdayptkcLieZK6cR4b3dBjUWt+spfgKclGJ8RXHtvdAKEk3SQgXuqPwR0I//KZTve7RqF6m3GxsJZVrfNJWOrcNrtLVkLmpAgvqjqfL1zU5iir2O1F5HXL+bxiWtT8zXsbHI5zLILxoobUeSRsd6NLi4BL1RAu3aM1TsMrBI2xgFjLWb5pnD+P6nfx79PG8MV5RlG3SASzsnWFmUwzl5q/2kjY7oQuFvJCxnXkK5QQtK2hsRD6kqzSVNKsD2FZ2bKZBF8zNrrYhV9Fz47zmvlyw2uMYZxVy8QfR5f/4V6XrTRiktUEStKNA2dcF3nMi4ZaaxotLlGWLx6Y/t2X5wS+IlCSvNYMOgFhoNyBOQp4fzNF4Qw572zG9KLgUgdyVrbs9CI+2OqstaRNaxgtSox1lG4hBNsX5oGtbsDRpERb56TfLrPfDwbvxiL/PDy7Tg3TgEejjNBXjLNq7a5+fzOlE/r8/mjK+cLFktqltGsjDWg0FLUlbyz7g4TGaI6zmh+kARbnA5M1DdPMYATsdEK0MQS+kx9qqzma5gSeXB/cq0bzi4djJnntxp4AbcEi1iyRg0G8fqeejPPlplE5+YsvUVLgS8FmJ+T+RkLRGj7Y6ZDXbgwcDGKKRpOv1ishSJYGv5+ezEkjj17ocbqoWDF5sqrls5MFUkqmZUU39JmXmjiQdCOfNPDY7cfMi5pR3jhWoXAF+BVDaPVOPvv8q9axywL1fH+XW7yZmBUN89J5rez2Ilrj5ElSiEssvpfBxTjIcmm8OUzTaxVDykZzOM4x1q0RxrrElFX6wsuibi0CgecJlFAIBWhB3V69+Nu0BgmkUejsHi1kZUVzDcnvZif8Wnxt6qtrMep20pCzJOJoXpI3msRX7HUjdtLX1wgrjXa+WYGgNRAGgi4+pbmdD56HF+2vPjuZczSr0MbiCUHdaI4XNWkUkFeanV7KPz6ZoC10Ix+LJa9bEAZPeahWUBmLthCGiq1OyE43omydf9JKrr7dDTmelYCTqvpKMCtq3t9JOZoWLoFRSWTkitwX96tfOzMKgZS4Jk3io4R0smfxVVpcGvpU2hnZrn7uy/Ocn93tv1NrxusaJ29tAeP7qjG9eMioWsM0dwtLL3aFCWMNxlpM5ejGG52I1hSczxt+93SONZZ+4lHUlvOswleuQy2EZVFpej54CorMFUiCpR/BKvbKWovWEHkSqSTnWcNOL2K3F9Bbaop9KVysZFGT+N7aOPFNf7a3uB4uFtZmZUM/9rm3+dXEb60lr795bK0itgLPJR5IKWiNYbMXcWeYMMkbzhYl87JhVtX85f2NZfThVxPgZidkmtf04oB2UVDVLm4LoBMqPCX548kcAfz4OYZdz/oNzMuWL78cMUwCQl+xKGqO584/ohUwqzRF09INfaal6+KezEo20xDBZYZR2Wj+cLKg1oZZ2VC3Zm0q1xrNP//RHncHMUp+nV54sQu8ip411qKEIPYVR7PaeR74S5q7gZNpRasto3mF7yk2uxHlchN5vqgpW82P9/vrFJJn2VCLsqUXuudb1i1xoAg917F4b6vDh9vukPnBdoeyiXkyzpkXzdrk9HBpwtUau+5aaGt4OMp5b7tDEiiUFDweF9xbsk72ejFZ2VK2mrxu19T/g8HLG7S9bXie8dkwDYk9yaNxTi9yZljj3D37SV7z6WnGLK+JAsXD84zGWHqJYl60jLKa97cSqsKg7ZL5lNX4SvDhVkozTChbzcm0pmhcZHYcetzfTFDCvZsf7rgO0+r37S7d5Gdliycss7zBGMNHe71L71XVOmbU/iDi0TjjcFI5JpMxnC9qqkbzYDO9VGCMfMWHy1jeWdEwLmqOZzVSQugpTucl44Xzd1nFwU6Lhvd3OixKZ2b7y8MJqa8QEvfsAo9/+sEmIyCsNa2xBEpybyNdO9+v5qpnn78QkDft2t8F3vzGxy3cZ7aoWh6Nc/JlnOcwCdZ6+6vAMf0MZ4tqzeaIfUnVXv1aNxXv2vGd6XWoQEiLRVAZ9/WrIgwUceBTG03bWjxPEAc+4TXToKwQXxmo2uW/r4F+6jMrGwIpCCIFVrj9Rnp16c5NeRLc6SV8drrAE4JO5CLKrXFff5fwMs/zm3wHhRBMiwZvmQ6URiGPznNGi3LZALGUVYuHRAOR79EYMNqxjHwlqYTAartszhgqbdjpRCShR+it/MYqGm2ZlSVKuBAEbS1/PJkziAPwnLxsrx9961qQlQ3Gsm6MWVxKVrU0nlmULcPEnYm0BU9A6AmmZfvOrRmva5y8tQWMN0Fj+l0n0V7k4UmXamAM7PRCssqlMLS2otGG03nLo/MMTyqGscfJouZo4iKk8kaT4iqOgXKxRU8XFYES7PYisqZllrdkpdMeSuF+Z+C7oobVlr9+sEHguS5t2ZZ0Iw9rfapGozVM2+at03y964Y8z8PFwpqxrDXj8HIb/FV1+yLySrM/cIyEom7pRQHbnZC8MoyzGoG4RO+Olp0dIQS/eGwoa8N+3yfxJceLmqLWQM0gCXgyKb7W5VoxHYy1PDzP+fwsWxdWdroRTycFm52AzU7AL0Y5/dgj8EJGWUk39PGV4PEoZxD76/SVFQ7HOXVr0EYzzSomRUPRGhJP8tO7fe49MzaeZZasKv+r6Fm9jJFtjUEb2OwEnE0rPCXoJS62NK80QgmOZwXbvXCdX/7eVsLTcckXZxn3N9PnjstO5DGvWoa+x7RsOJ5VLu889tYF34uHzM1OyK8Pp1hcykigBP/qD6eM8ppe5PPJXg+lBJ5ykhEhBDu9iEejjJN5yb2hi2Dd60Wv3CDx+4TnrlMDxzLAwtNZSS/yCTzB03HJNK8p6xaNoGk153nNOKvY6yd0Yh+wfHmeU9WafuozjF28oRRwPKsIljrgs3nBJKu4s9Hhz+4OyGsnOwyV5JePp2z1Ah6d5RSN5u6G4O5Gwums4jwrqVvNME3WVNoVwmU0XqMtie+RtxmTeUNZN3RTF003iAPmRX3p8HZRRmWNY0F50qNqDBtpSLtMvPpgu+MMNyN/GdnqMSlc4lGLJfV8itrQj2CUOT3/s27zq2Lri57/ZhJQtAYpBM/Gq96uC28uWm351eEEgWP8TPOaw0nOP72G/rqqW/7xcEYv9ulHHpW2/PvHU3520LvytW4q3rWT+HRjRaOhsRZfCLqxopNc/XC/P4w5nhXoxiXN6RY8X7A/vHoh+XxRESpJuzxABp4kVPJa9Plp1jBMfGZlS9EYYl/Sizym2dVkMjdp4P/JnR7nWcU/Pp6szYJ/dnfAJ3eu/i58X/Gyz/ObfAenRcODzYTA++r7e7HP0axiM/E5W9QsmoY0VIzziqqxSOkKGUVt0NbiS8mg56O15TQr+c3hFHUHjiYhe72IotXrZpAU8HiUsdWN+NFej989nXNUF04G24/XMtjVWrCa2+dlw9FsjpKS03nBXjdhp/+VPDGvWvLGSa06kUfZOIn9yawCT1I3TuLyfWiW3yRe1zh5awsY8Ho1pjcxiW52QspxzmbHGUAtypa8yvhgK+GLcYGvJH88XlDWGotzzJ5XNcYKIk+xESnGZUtgXVxq6ElCzxUzhABlBZ1Y0RifwLP4nsSXCovgRwd9lBBs9UImWU3dGmZlzZ3BBrOiYbPrKp+NNmS1076/DZqv72N6zZ8S12U2OR3wgnFWuSQSKVzOe9VyPC3Y7ISM84ZKW+JQIRCczkv+ammSuULkK3500Of9Zdd2xYrwfcUwCdfJG+Os4nB56FmhalcHuZKTeUWtDYEUnM5KjHXMhTRUDJaRxY22eErSixwtudFusVulqlzEybyiG3o8GRfU2jrJhWAp/RAczQre2+ysn9uzzJLVM11Fz+a1M0NKQ5+2NRh86toxsQaxj7WWrDZsdAIUki/PM7bSyJl3aniwnbKRhkjB1wxDq9aQLAs5i7JGLBOMyrphmPqMsppu6F3aYGeV60oHnuRkVvLHJQtgEHkIAf/VZ6fEnuSffbTDJK/XVGtfSR6eZWht2emGfLBzdf33247VOrWim//heO7GlrEusrQ1bPdCjqcFoe/x0W6Xz85yTuclgRTEgaJuNI2EO8MYg2RRNoSeRAiLh+DTkwWeEkSxjzaWe5tdPtzus9uPaLSlNQ2xL0kCxZNJTtVqlHTMpqeTkoNhzN2NhN1+RGsMB8tNIHz1Xs2KhvGi4mRRUWuNtJa8NShPkIYevcgjq2qEFF97B1ab31WEr79kIuWNZhD5HE8LPtjurDeoK2PP80XNIPYwuOJY2RoGiXtW95dsj2+TkT67T1j9PRcbH8DtuvAG43RZnPOUh7GWWAla3XI6u7oB5LRsMdYwzet1Y8dimV7DI+Km4l23eyGfnShaa/CsQEiBLyXbvavLK/a7Ab8AgkBy4Q9kv3t1w9NZ0TAtGsILMchni2rpuXS1a42Xfh4Hg4TAc/KYRVmvv/6yuEkD/06g+HyUsd2LeLApyRvD56OM/zDYu9J1vs942ef5Tb6DVesMl1nK8/qJTy/yWBQNQkk6oaTv+zxZSgWVBGEcC3WY+vSigEVZkzcazxOkgWJWNhxOKn52z3kDWiw73Yii0YyzhjQM6EQegzTkwbahWhYXVvP1ai1Y7fmthbIxbCShY7qbiON5QVa3eEt2ZORLdmJX6Ptwu8vPvxyRhj5bHZ/jecUsb/jL+8N3bl14XePkrS5gvE7cxCT6bHdoWtbc3UgZ5zW9vKZonPlmL/HIGsPJtKQXBAhpaVqLUIKodW7t3cjHE4qibTHWaZwLrelEPluJQkmQUrLbC0CItdlZ6EkiX9JqQyf06YQeQnzlN+BJd/23RSf8fUyv+VPiusymyFfEniT3Fa21hEryk/0eJ/OKp9OS97dSEMvnH3oEnqDrBS+87sVDx/G0YBAHl5I3EuutDz0rhJ7kcOJ0kPOyWUZSCqxwHbxB6nOyqLm32WG7H/L4PKcXByShop/4aKM4GDz/b11tSIumZTONCAJB3Ti9va8kZ/Oa95am6M8eop59pnGg+Mv7Q0ZZzfHUFSqH3ZCP97r8//5wxuG0QFroxj6JrwiU4mResNuNaLShbg17/ejSmHy2MOcryb1BzO+P54wzR5N+sJnSSxy76uIhs2w0fzyZMy8apJR8ejZDAPc2Oyzqlk7gupTSWoR0zvFfnmcInAzgw50Om51onYJyi69j9fmM8ppe7HO6qFgUDRb44nzBZ6dzWmPRBj7YdiYxvoKTWcWGFAS+JPQUs0rTTwRbnZBO7PMPjydsdSK2us5c1ZPO4PXP7vY5mlWkoUetDb4XLzeZDaGSpKFHGjrN/tm85MnI+WPMy5btbki6412678BTDNOA87wmrBpO55rWCH520KWfhgS+XBbNXDTis1hvfpeHRQAlXCIBgjWLYs1WWhp7CmExFnxfuvg8Jdfff91i6/MaH8+mldyuC28WFlVLuoyJV9JFjeaVYFFdvegwr1pMa3g8LcgbQ+JL7vZj5te41m4/5nCSL2PDxbV9f4Klv5HfWlqt8ZTC9wSBurpcozaOUVXWhsYYfCmJAkltrn6tvHFSwIsMk6Y16y71VWANDNIAISSNNvieZJAG2Ctac9ykgf8vD6d8uJVyPK04y1u6geLDrZRfHk75s3sb336BtwCrxs/R9Cv2WT/2aZ6pwb3IdxDcZ5vX2iX8GMvhOCcJPX58p8+0aNjqRERRxqABY53EtNaw348IfA+jDZPCIISLakdYAmX4YDulqK1LZuxH5LVmfxnNGnnOKw2cT9/TiStGPMusW+35R1m1TCaRzMuGk3nJNKsYZQ33NiJC30Nrs967rbz/nEGvZr8f8c9+sP3GRsK/SryucXJbwHhFuKlJ9OJm6rNTR98e5zUPtjqczSukcJ3YxFPEoUcaLF3e84bjRck8r1BSQOQxKhoEBkyLJ51bdJbXtBbSyOfuMGKrE9C00BrDvc0OoSfpRgHDNKRqXcFDCLcQ+0tN52riehs0X9/H9Jo/Na7NbBKCe8PLlO7Ak4wXFYuyJY08fnpnQOQr6uWi+XKXFc6M7AIqrTlf1Hx2urhkJvWH4/kyJs9JrLJKMy8bzmYVvhLMS003VGhtlrnlroN9PC14sNV5rl9D2bgIrkfjDK0147pFFwJlBT/YSWm0RrcGa53T++m8ZJCGsGRXraQuq2daNnptjCalYKMTsigahrHPdjdyG2zr6PWhp0hCRT0x/P5oziAN1kkndfvVYvu8wtxWN+bxuOA//OkewYWiTN3o9SFzktf84ssRvz+Zk/gew07Ak1FB5El2+zHbnRAr4K6KOM8aJ+OxjmqpDWx1XapRcOE+bg98X8fq87HWFRiqxjDJG/K6Zb8XU7aGotb87njGXj9ycatpyLwyxJ7rDB0MYvJKs2g1nUjSD33KyqAxHAxcsSlUku1uROAJPtzu8NunU2oNg9ijqDR/PJ7Rj308T2CJ2EicgfRvDkccbCQ82EzY7jq2XeQrzhcV1sIoq5aeTQ13BwmecIWE2JOEnqCoWjwBdWM4nBR8djJfm6GFnlwznrY6ASezaj1HCOE2vgdLGu+qKJGGHueLktjzOJmX7AUeVduy0QnX33+TMtLbdeHNRif0aANXxKpag68kvcR37+EVMc1rHo5Khp2A7a6kbg0PRyVBcPXt8sEg5mRe8qunE7KyIY18frDTvbLvjxIgEVgMFlfkk0iuUb+gbTX3N1LOMye7jAOXHNdeo8CcBP7ap21VoDHW0A2uwQzph/zy6ZS61rRW4AlLECh+un+19eImDfwfjwvmS6+dJFRYA5OiQV+NQPP9hrU8npSkS3Pl1lgej4v1nLzCZifk10+nHE1KqlYjhXDzv6/wfEkv9tDWLiPpBQrWTNqTacm9jQ47vZbDcU7WtPhKkEY+8dILyVeKQFmiwO3TBkmAxRUiED4Il44IrpBdNobQ/0oGu9UJmZb119aC1dx+kaH76GzO42lF7EniAOctGPsuDesCe2rl7VUlZtnsfXdYFxfxusbJbQHjFeGqk+jL6msfjXLO5q4o0U98Hmx3+fXhjHnZkBU144X7Hfv9iFoHzIuGxhiOJwVCChLfpxP7KCnoxT5l3dCLAtLIZ5D6BMpjt+8RKsWDzYTF0rTRWEcBf7ykCS3KhkY7B/utTvjWaL6+j+k13xdcfLZl4yiFWdmy3YvoRd46SeOb4lifh51uyOHUmUFpY3g6KXk4yrgzjJHCsWRXdO/7G4nrEnuCL89qBqnv4tpKl0l+ZyPm0ShHSrg3SNnshS7fujUUz+kqrTrQm52QrW7E03FJVhl2+h5p4AMuVWGr7zwqxnnNdjeiG3kvpKE/z/itbDWfni4YdgICX7LVDUkDj0le8/lJxp/dHbIoG6RwEaxSOEPCi4bAzzuA1csO9yUsO9hlo/nFl2Mejgt8pZgs55I08lynPmv4cDdiktc0rV5HtQoB06Kmbp2h8EpSEi69dG7xdaw+n5WJa9VqFnVDURmezksabYk9QegJHo3zJQtB8N5m7OQ/jWZRacDgC0ngS7LGRYwKC2eLCmMs+7td4kBRNJr9QUToKX73dMbpvOR0UbPVDREWfnM4o2rH/PV7mxRNyw/3+2x3A1dMqzShp9aykYsUck8JTpeRqw+GHZ5MM5qqRUpB1ZilN4obr2C5O0wwlnU6yEYaMs9rDqcFedmyN4jZ6QQcLN/ji0WJNgkxLM1PpaAbOePYXuh97fu/K0JPsihbsrpdr9Fp4BFf0/jwFjeLD7dT/t2jMQIQCErTYoG/vndFHQNcKF6vimhOsqH11VM6ykYzzdz8t5EEGGCaXY4HfxnklYsBFjhZmPuv+/pVsdEJ+PuHYxI/YBBLGg1PJjl/df/qz+qiT1vRaAIl2exEX1trXgbb/Yj24QRtnamjtoK2sWw/c1D+NtykgX/VtJzNKpRyLGRPSbQ212K+fG+xNNm8aNQKdl2AXqFsNKfTEoNLNjybV4SBx34vouu7Q23gCwSOORR6au1/lDctSoAvJT/c7TNceiI1rWGrG5G3joGujSsmBJ5EAE9GBYFUbHfcPqQbOXltGnocT+eksU95tlin4/zkYPC1cfeVP5vl6bRimtXMypaqaTFWoa3hcFriKcVP7vRZ+sbfys0v4HWNk9sCxivCVSbRlxkITqPuNk/D1Od0VvHrUUajXeX7fN4uZSYV1gi85eTiK0WtHfU4FoLWaLIKAqXYTH1mUvKDnS5p6DFMXZrIwTBhM/bJW40xEEeSQeLo/KGnmJY1/SQkrxu6vu8q+G+Jodn3Nb3m+4DVs60azdnCpWhM8ook8ika7SQHgXflTunB0j9gnDcczwqySrPXi9jrxRzPSvb6MYGnOBznVNrw8CxjnDekgWRRNbTaEPsCKaDWjkEQeYrNXkigFAcDHyUctfjZcXmR2bCdhmykIbUpKRrNRhrhScl2J+Kv7ruY4U7kX2JBlI3mV4cThkm4Llw+z/htmARMspof7feoWsMkrymWB9fNbrgsiviMs5qsbpmWNR9udzmcFBxPC87mFcNueMlMtNGW/WFMXjsGiSddsWTVwT4c5+4wCvRjj8iXnC9q+oHPNG/QxoAxVE3LtND89YMeu71o+bd5pJGgHwe0xnI0LdlMg9sD3wuw2kStTFyNtZxMSsJQ0eaaXhzQtIb3tjp8drIgDTy0sfSTgL6xaGN5MikYpgH7/YhxXi/ZcYLRkoHw/nYHX7nP2GJ5OimWpmUFR5MCKSUgOZ6X6BYGiccXp3NA8tO7CaHnkVfaSUWyErtwPjVSSPYGEUK4yN4vzzKUcLG5jYnJ65bWuOjGB1vpMr5XgcVRfwcxvcinWR4QC22RuINWoOTXUg1WRYk7y3//Kcw109Dj90cz0tB3Mc6NYbTI+MsHV6fH3pqB3jz2hwnx4YzDaUG5pI8f9GP2r7Fue0ryw92U87xhUbuYxh/upuuDy1Xw6enceYUZS728L5fiNuevH2y+9HXKVtM2ltiTzrPCCJrGUF6DNbHViRBWMM5LtDEoKYk8xVbnaoUC+LpP22q/9Gzq1cugrDT3txIQAmNASsBayup6rOWbYF51Q5/D6RhfSqQCo6Exho/3rh4T+33G3WVS3KpItSo8X8Snp3O0tRyOi6VERHE/8jhbVGykIZ3IQwrY68eXGLauiBHxxfmCx6McT0lXLI99hFT8d364xcNxh3/z2RnH8xJPCHaTwBml14Y0kHRjj6Jq8T3BF2cZVavX3i7AN6bjrPalbevYIUfTgkWl6ccB1loGHdcsarQbK/7yMrdy86/wusbJbQHjFeEqk+jLDITzRUU3dkyJSV6z0bGcZzXni4rYFwSBQpUQBx7zvOUPJwv6qYdcHkzqVlNpsMZ1E1pjXAxXpOhGHkpJ9voxP7szWHduDycFyUBdovx3Ig8pxSVvgbcJb0J6zduK1bP91eGEotFkVctWLyINPIpaMy4a/uoaJo+rdJJfHU7Y68WMi4bdXuiiuFqXaDJIfP54uiAJFPuD2DGWgKrWrusscNpp6zKsW22db8VWiq8kTWtIA49g2Xne7Dga/R9P5vQinzT0mJYtH+932R+GHE7cmP5oN3X6zgtUxRXKRnM4yZ1UoGyZ1y2elCyKhr1BfMmxm2XyS6Otoy32HQX509YQB2rNaKm1IV3+jieTYm2autVzJqqHo4L9QUgUeKS+4sf7/SVlU1O3FikFSeh+/ucPx7RGgwCDIA48dnuCvDb8Dw56HE9KzrMa31fcSwIiX64Py73YI5DuOXpK0ACn8/JaB753AatNVOApdnshfziZkUYuYSBcvjuTvKYcF2wmAfc3U3zPFRuMsRz0I+5sxEzyFm0sW2nIrGpotWCn53FnkOB7kkfnBd3YFQmtwRU6tGVWtnQTj7N5QzfwmOsWY6FsLR/uOG1xJ/Qol/fxbz8fMUh8pIDUd4aw+4MIJSRbqY8Vgu1ejOdJmsZFUt5dOsAfz0q85e61WEbSucMPYC3DJODuMFkX1LKq5fPTBb3Yf+6h/2VZFt+lcJBVLXc3UrKqpVymLQxT9++raJ5vu3avBqNFxaAT0FmyReXSc2K0qK6sSb8zTPjyfEEv9EkDDyUEtTY82Lz6nme0cAboUeARLeMWZ0VD2Vy18CDQwpCVLVoblHLeZF+nz307tIVupCgzQ2ssSjn20nXo3jcq09KGu4OYp7OKUmtSpdjvR1TXYL7cFCrtijF5ralbTeApeoFPpd8dJuHzmJONtl9j2Tw8L/j906nz5go8sPDrJ1Pub6br+PW8ad0eZblnAzcnYi2thh/f6VFpy7xqyVvLQU/x+XmOLwV/fndA4Cs+O1nw+XnmWLIbMcNutNyDKb48z9nqOLl74nv4SrK3lBPWrXluceFiylrVtJxlFcM4ZKMTuAKhsXhCuP3VhWbmy3qDvAt4XePklRUwhBD3gP8jsAcY4F9Ya/93QogN4P8MvAd8AfyPrbXjV3UfrxMvu7F63sFmtKiYLd2XNzvhBZ2WGx2Bp9juBPzdZzXzWlM3htj3ySuDXRYey7oFI4hCD19oWgO+B3XdkvuKoFb8xb0Bu4OYQeRhDUzLmiRwMXUrXfK7Jqd4nek1bzuiZVqIEi4ydMUyiAPFrHz+AvOyaFq3GVvR8IE1pf2XhxOeTkruDGPe30q5v9mhbg3jvGKSu/g2z1MIAbGneDrJmWY1ajulaQ211uz1Y3wlGC8pwIGn6Mc+dWv5/fEcbxn7FQUeu/2EYRK4CEjPxQw/GmVklTOy6oQei7JxxUulmFcaKSRF3WKAz08W9NMAJcV6M/6D3e7aCHPV7RLCeSYcTUsCTxL7iqLWHE0LuqGitrCoNBa3CJetZla0RL6HFWJd/Dkc5zwaF5wvKupWc3czRQhIfOeu3WhHz5xkNY8mOUL0+OFel/e2O2RVi7WsNylH04Kf3u0T+R7jrF6b/Hbj207zi3DxINBYuDdI2O1F/PF4TtFoirJhnLnPxhqX7vFgmNAL3SZBKUnZWGJf8tlZRigEYeSu2bQGqQSB5wpdi7JlYyPhLKthWZgSUpCXBk8oktAj8hStMWz1IjbSkMNxSdNa8qbhy9MFnTjg/mbC6aLmvKgJAsXxrOLOIGZ/mJIEl+fQJ+N8Hb+8Hp92abqJW1eqVvN3n42otdM33xnEdOMAJeFXh1P+9oOtax/6v0vhoGw0j0Y5Ypnos9uLvhbD97K47dq9GqxYa0XjTIx9TxL78spxpQDvbaX8w5MJedUisNilDPC9rfTK96WtM5ldFey8paRRXzGFxGKxFpQQGOH+6wJOrn5aOpnn5JVGa4PWoKUhrzQn8/zK14IblGkpyZcjZ3gaKImx8HhS8mDjate+ySJh20KkFFHqoY1GSQXG0l7do/R7izT0+McnU1pt1pJcT0n+6QeXGUSH0wzfV6SRT2Pc++przeNRzkYaMs5rAuX8nZILfjLnC2cmvduL0MadN0JfMs0aAqXoBK64djytOVkUWAG90GNvGNOPnPn4MA34x0djrLb0lkzUVrdsdCSTvF7v3Z43X5eN5smkcEykwGO7E1O0rTPNtpaidvunvV5y+R16SW+QdwHXHSfflY34KhkYLfC/stb+vRCiC/w7IcT/G/ifAf9fa+1/KoT4T4D/BPhfv8L7eOMRLt3ds6plUbVMl070/aXZ4JOxm9QXZct5VhN4kqxq+PXTGZ+fLZgUNZ7j22ENaAOehKoBhEU0LQZB21pC39HztAZjLE2rSXzFRiekagw73Xh9OFrpklfeBLdyilvcBEJPkleabvxVhn2rLcmy03xVrDYsSgoa7cwO/3i84GAYEfmSL04yLILtToiwgt8+nfH+VgdjndmbNoaiNiht2UwDtDE82OowKWrmVUsaeGvGw6NxztGkcNr8bsQwDTmalrTLQl9eN4BgfxBhjeV4WpIt0yTGS4ZEawxKuO5Ed9lV1gbiUBEpSdm0WCkYLWpHw7cWrGB/GV15sdv1o4O+y0OXEk861/3RomKS1/zhqOKTOz3SwON46aMwSHy2exH3N9N1R2KzE1K0hqJueDrJKRrDyaKiE3r0Y5+9XsS8qhnNKv5wvuCjrQ4fbiWc5TU//3eP+GS/zwc7HfZjNy/4vmRWtAySkP2lWd2KMnpLn38xLh4EQk9S1JrjScnTSUlWt2gL292Yxhh++9iZAv7VgyFSCz49mZNXmn7iJCTni5JfP5kxXTTsDSLi0MNg2Ux8fnk4w5eC2hp2Oy5ytB96PJzkCAuPxw3bvQRrLX9xb4OibinalryqOZ3XzGvDnaG3TK2KaFrDvGgIlSKrW/K65ccH/Ut/20VpXj/2eTwuWHlg1K1jaJxMCxpj6IUerbH89mjBJ3sdpkWD78nvdOi/buHg4tyihEvYOZqW7PUjpBBXLubfmoG+GlSNZlo4k8wV0+F05uI8r4q81twbJkzyej1PDZLgWp/RXj/mt08mzMoasSyHKOCTO4MrXUcARdUipVx6Pbm923UU5qczV4T2lUQCeW2YFjVbvdd78IoCxemiZBAFxIGb/yZlfWUa+k0WCePQY1bWnGWOSRN4kq004AfhuyMhGWU1gRJInB9EICWecl+/yG6KPY+6rqkaTeJLDqcl46xiUWne2+6wlfrsDhIEglDJ9edRtQalBD856PHLwxlni4rxoqJqDL3E5+NOl4fnBY8mGXWrGcQe46rli/OM9zYS6rp1BQsD3cSFDCSB50IKKpeSAy9uvh4umaobacA4q+lFkidPK6Z5RRJ6DBPHKPnx/jPs4Jf0BnkXcJ1xchOFxldWwLDWPgWeLv//uRDiN8Ad4D8C/vny2/4PwL/kHS9grPS1vlI8mWTMS83RtOI/+GC4noSbVnM6L1FSUlQN/+azcyZFjZQCrS3aaIw1WCSppzDCIrRB4Kr9q8XKlwqN4YfbHTa7IdNCk5UtRWwwGJ5OCwIlGabBWpcsl07wt3KKW9wENjshD8+ztQN6qy211stUjauze1YbliiQ/MOnYzylSCPJ2azmZF7ywU5CLw6Z5jVKCoTwOF2U3NtIYVGz309QivVCtNuPGSYBH8gORaPJq5aH5xlni5pe7DFIApQQ64PMXj9iVtRMi5r7mx1Ydt0q7TwqdroRi6ohCXw87SQZo7xBSJYFEp8kcIej80WN1oZP7vQYZQ1b3XBtGLiiq1/chJWNptaW0SRnUjTrAqOSAhSMs3qdbuFJyCu97nqvDk7ni4qTSc6jcYm2sJH6zpBrVuIryXbHI7EKC/xNZ8iDjZRJ0RL7rvPwdOoi0VZUze1OyBdnGbOiYVE25Et/kw+2O7f0+ZfE6sB/ZxhzOi+JfemMsayl1ZZeGjCrWn7+aML9jXR5mLFkdYNYuENK7CuQbn05nVdUTctuP+YHu136ccDJ3EmA4sAjDDx2uiFPxxXzxuJlNT+712dRNczrltiTbA4SEBl7UlIby9mi4qAfs93x+YfHM4ZJSBooOqG/Til5VuZxvqhY1BopoWnh6aRgtx9TNC3DNMQKwemsJA4Ukc+SPgx7vYink4JaGwIlGSRXo+pet3Cwmlt2ehFH04JAKHwlOJmXbDwzFl8GtybRrwahr2izys3hy3NFawzhNeaV46mLpL638RXjom7012K5Xwa9yKefhpeKIf3E7a2ugta4Q0Kt7dIfQhD7Hteo93M2r7DWsKhZy1ECaTibV1e/2A2ibAwf7/b4/DzjeFHRjTw+3u1RNlf7I2+ySNhozXlW0QkCwgSqFs6ziuYdkpCsYuqfTSp7djwcDGOSQLGoNfOiRQlB4nt4UqKEYFS0SFktzzSWbekKZqEnlybPFmEtw8TJ5MNQUtcuTU4KQeQJRosW31MoJVHCRWmfLiqEcg2cNHRH2n7iczwtmOeGzTT4RmP442mBEu79yGrN0axiUdV4ns/Hex1i33M5sM+JxdvuhDwcuXjWNPC4v3G1dKG3BdcZJzdRaPyTeGAIId4D/hL418DusriBtfapEGLnT3EPbzKyqmWnF/HFecY4q1FKYKzgF48m/O377gM+mVcsqpa60fz66ZynkwJjnNlg4HvM8pqqBYnB913ST+hB3UIaKUKlkKFlURk6kc+oqFCeoG4tZ1nJuKj5b3645ahQ2hnZrAz5bhkXt7hJRL7iRwd9fn04ZVYaxwBKQ6RYmoJdsUs/K1umecWvnsycyZIn0BqsMOwPYzbTkMEyBniWNwSeYJo37PcT3ttMOLiQBX6RabSRBnx+Oud0UfFo5IyhNqqIjTTAUy4ya0VPfH+rw8m8ZL//FYPp0ShjKw2JA8Uor4l8uZTMWLqxj7WGJ6MSi+Fs3i7TJyxJKAmV4s7AWzMYnkdXv9QdVoLAE3jKQyrBvGzpBB6ttpzPS4SAojEkoStOwlcHp1nZ8svDGRZX7GxaSEIXGda2ls1uSNv6fDnK6YaKXx3OOJoW1K1hVtR4StKNfBCW9zY7KCkZpD6/OZyyqDVta/A8wa8Pp9zbcNIaljRhF4d5S58vG83hOOdkXmGtZbcfs9kJmRQ1ga+Ylo3zc8kbl4RRNwzTgDiIyKuGR+MSozUb3ZiqNu598wTHM0Mv8llULd5S/vTTgz7jvGEQB/zuaIaSwpmVJQEWwT0RMy6cN4brZik+3hkS+AptLWW9jB6eV+z3Is6yhr1+xJ8/cCkGq3ShSVFfcn1faY3LRnNvmC5ji1uOpgWfni7Y70X0Yo+qdclAi7Lm0ShnkLoEnw+2u0gpKCrNF2cLPt7rvfTzvW7hYHUYEsJ5RI2XHSZj7LUKb7cm0a8G/dhnXvqczAoqbQiVS2q6DgPjebHcq2SmK8O6d2yjE2KM8xjypbgUxfhyl7Ho1jIpquV8KtmMQ+wVrwOQt5q8tGjb0BrrvGaEJL+GISjcHKuuajRFrflgq/OVoXTVrgvuL4ubLBKOspqNxDEUp6WTjW4kIaNlzPi7gJcdD39xb8h//o+HLgVLCVpfMS1qZwBaOLZG1TpT3IfnGdvdr6Kxp3nNPz6aOAluqDicFPjLwsYvD6fsdCPO5hVV66TxAoHEFfPOs5r7Wynvb6csKs2iasjKdt08QXSQS1+/572XjbZ8cTbn8TjnZFGzyBsGaUAnCalbQ6UrpIV/8+k5+/34K9aJtevkrqHxOc9q/vHxlIONmINB/E41Za4zTm6i0PjKCxhCiA7wfwP+l9ba2csuAkKI/xj4jwHu37//6m7wDUDVGhpt2OyEnM6qpcGTZZRV/PzRmO2Oi13sxT6fZxWPzzNqo3l4npM3Gk9BP/F4OnX6eWFc8UKwjGBsNIEnKSqLLwXD2GOcN1gEP9hO3e9vNU+nBUnZEniSxFeczqsr55Xf4s3HmzC2BknAXz3Y+NrGB/hal/7T04VzX19Sti9ukMpGM8kqRlnjPCAC5Tr+Ajwpyeua80yy20+4O0w49SoOl7GgB/2Ig+Wi9qw0484wceaWtWEjDTielvQid6gvGk05ydnrxyjpokiFgB8f9Mmqdn2N4XLBbpexX9qCkjCvnHFoGvoM0pZ5qcnqlshTdCNJ1RqOFyWbaciX59n6oP/sZL8uunhug2ERhL6TmkW+Ry92MY9H05Jh7CNCwZ1hQujJdUdisxPy++M5J/OSdHlQm+UFW52Q0JcUTUuzpHgeTwoOMTw8z8G6yFopJbOi4cvzjLxq2UhCam2YZg0baYi1FeNGU9aa03nF5ycL3t/p8OP9Hr6UnC9K2iRcJ0p833GdsVU2ms9O5ozyxn3GFg4nOUWj+XC7y/mi4WxeMC9qjDEUZQPLjtWiaBDWcr6oOMsqtkpNtGRqTC3c23Lv93lWkddwZ5DSTwJCX3E0zam1Jstb+nHA41GGxHkmfdwL6UYhgSc4n9brDeydYczvns6IPCcXmeQNWdXyH3ww5Gha8OV5jtauUAaSyPf4cLvz3NSestGMsgpPug1v0Rga07DdDTmbV/zhpGKrG3F/GPN0WvJ3X4z4ZK/rZFeF6wC+f+Ha34TrFg4uHoYi3xkAr+RQ19mg3ppEXx/fNLZCT6KkZLMbrZM1lLy6xAcux3I/m8x0VTh5oGV0YZ3bWnqaXek62nA8LxHK+Tppazmel7ynr24s2jaGom4REjRgtaU2hvaKTAe4Wb+J0FdMxzmHk5LaaAKpSCPHfroKbrJI2LSGyJcEvsIahZASiaW5DvXlDcW3rVkvOx4GScDHB33+eDJnNKpptKUfBdRGU1UuKWszDehEPr5S6yLeyofrH55MKaqWw4mL/DbGGZbPq5ZPT+acFy2eEPjSR1sY55rQr/ib9zf5ycGAJ+McC3xxuqA1kAQ+P7kzWBfOX/Q+zouav380wWiDEpKiMUxHBT+NnIln7Es2OwGLSvPzL0f85YMNV8QQgrOs5O+/yHkyzZHAVjfC9ySfni4urXtvO64zTm6i0PhKCxhCCB9XvPg/WWv/78svHwsh9pfsi33g5Hk/a639F8C/APibv/mbt9rXdeUJMCnqtcGTJwSxp/jiLENY+HBni4cjx9AojaFtNK211K1FCIsUksR3tNymhUCC8iHyHfvJWIHvQz92Ws7NNOL97ZRB7BH7HpWneTwp+NGejzGW41lJ7Ct+dnfwuh/PLW4Yb8rYep7512oztKKVGWsYZxW5r7g3TL62QTpfVGx3I45mFb4SlI1hklVIIflot8PpXHA2d1rMfuyzkQSESny1CH3DvTweFxSNdro+Y4isXEcofridMsorNpLwUnX/suN9TlFLzrOaJFCMFjXauLzxlSRkpxszSAxVG1G1GimcJGy8qNhMwvXvG2dfj2ycFQ1Vq3k6KQk8gRBQNwYhXQzg8bxmMw3Z60VsdSNmZYO0li/OsnWX/+mkwFrLMA6ZNw2htCyqhmlRM4idX0Y/9vnsdMHuIObffHpO0RisscSBB1bw0X6PRdkQ+IpPT+fEnmKaNyAET+cFdaPJK82saEhCRaMNn53l/OighxRy6RvyduA6Y+t8UZE1mjT01qa2Qgjyyvki7XR8hHSLvScEw25IVrVo69JDDqclZ/OKyJdEnnQa4qwmDhQPtpzBWdU4emwaOSPPo1nBw/OCg0GC1gbfUxzNCnqRT+R7dGOf0JMESqGkXEftdkOfD3e6/OZwhu9JlIQf7nWZF+4zrmqN7zkPlGEaMs4qDn21phpf7LqMs5pAKTwl2O5GTHLn+JWXrjCymYb8xb0B07JlkFpaazicFfwodQai1Qtc5Z+H6xYOXgVj4tYk+nr4xrElHANtGAR4yqUfZXVzLT36Kpb7YjLTRuJzcI3PbFo0zMuGnW6Mks6fbFpUTIurzXlnixrfFyjhCuGhcOabZ4urMwFaa9ECYk/iLyU3RWNor8HmuEm/CSFgvChBSnwhqI2mXjSI3av5TdxsjKrH4dhJ1xrjGoAuRvTtCXD8tjXrZcfD+aJyjNM7iqa1TPOKXhTwZFowTHzGWYWxsNEJ+dF+99LYjHzF/c2E40lFEnlsdyNOZyUn84o08DhdVIRC0E/9NVM0DSVWQDdUlxLuNtKQNHJS329KH1nh4aQglILKKjzlGOu6sHx2uuBv3hswLVrnD9gL8ZVaRyCfzkseni4YFc7E3ArB+axktxd9bd1723GdcXITa+urTCERwP8e+I219n974X/6z4D/KfCfLv/7/3hV9/B9wcoT4Gha0ok8okAxyWoSXxGqFl+57s8sb+mGPnvdkH88rPGVxNqSuhZoLFpDbV2zrNWQWQsGOonCF4LNrotPHGUV/UQyjH3ySpMEsNOLaA0oKam1wZOSTuy9MxXEW7wZeJZWNs5qEt+jtY7O/uwGqWoNncjjYBhxPCv5/GThGAuRj8UlnfzooMvpvMJYSyfyvla8eB5WHhBJ6CGxRErw6TKGNfQkdjsh8T3+4v7whWNkNUFvpgGLqkFJZyy31YuYljUfbHf47dMZ250Q35NrLxBwnjNWWB6NChCQBIrfHk7Z6cfOEyP0GOfOvLcX+dTaPYdWO4lYFHjsdh1LohsviyyD2D23C6a8P/9ixGY35N5mwt99OeIoL0gjN+6VksSBxxdnOY227PUitvsRzShn0tT4RrLfj+j4kkeLmjRyfjozXfNoUvDlecYw8emEPkpJikaThi5yE+u02P3Yp+tfneb9NqFaShK8C50ITwnqZbzp43HJdidEa8u8bBktGhJPMc5d0S5bFo98JRjnNUIIYl+hJJzPK+dl4ikGvmSWN/y7L0YsypY4lOz2nT/LPG/xBMzLhmEnRFiXDFS3hve2Omwk/qUN7EE/YqMT4inB0aRgUWs3FgOJVHJNTU9875JW+mLXpdZm7d6eRq548/lZxuPSGeF+vN+haAyjRc0or9juRFTastN1xqFKGB6NcmZlS143JL5jKb6o23adwsEtY+L7g7vDhEneUDR6uXlOMNeMBj0YJnx6Oidv9HJ9uWY0aKMdzT2v0NqlZEnrvn4VaG0QBgrdrqOpQyXR14kYFbCVehgU2liUFKSBvk4i641GSY7zmkEScppVjKuWTuixvUyvuCpuqki424v5rz49x1MST0LZWBZly27v3WEmv+x4mBUNp/OKsjWcL0oXkS0ESSBRStKJAgaxz0/vDJBCfM1SYpgEfHay4HxRIQQsSjeW9/sRByYm9SXWCrJaAwZrLVVtEMsLrRLukoG6JG/5NlnCLG84GMbMKk3TWtIooOOVfDrKOc9aYl+wsZQhz8qaonHFuk9P53hKMCsatDHEgYfynCfYj/f7X/MIeZsNzK8zTm5ibX2VZcT/FvA/Af5RCPGL5df+N7jCxf9FCPG/AB4C/6NXeA/fC6w8AX75ZEpetnQSn/e2UwSCjTSg0oajacHxvGQ0LwDY6PjMc8tEKGrdOv9BCdI4Hyvluci6tjX4UhJ4go00YqcfIaXEGBgXDdtpQBJ6nMwqOpGjnSshqdqWfhK+zsdyi7cU3zSRP0src8U0t1lb4eKCtPr+vV4MVtC2Lkavai3aGH6426UX+wyT8ErV8PNFxd4wZrSoMMbJPrqRx7xo6MUJx9OSj/d63zjZXorG1IZu5PPBR118JTidV/z26QwpBHmjCawlUE5n/2SUk/gSLBwMYrQ1HI5zzlrL3iCmqDV//8WIIFC0rStY2MYicSksZdXyu0XFg62UH+3318WaZ9ktgSewAj4/W3B/o8PHu10+P1twtqiwBra7IZEnOJoWhJ4k9BVbnQCtLXdVzLRoUFJynjXEgaQTeoyyhmleI6Ul9BRni5qsNmx3QhLfIw49lJKIJRV1q+M8Qt5lrEzMWmPxlXvvW21pjWWSVeilPwVC0I4yklByvmhQSpIGPtOiIVGSWaXRaHY7Mbs9Zxy4P4yoteUvDrosqoazrMZTAiQEUuAryWYa0Y00vif442lGIJ3vhZKCKPJ4bzNd+8RUreHxeUbZOp+NZOmLEXmS41mBLyMSD3Z6oTs8CtasqRVtvqxbl2wlBUWtKZdpCp3Q56d3+mhr+fIs43RWstVN2OoGnGcVD0fO1LRpDYuqodaGyFdMc8e4mrYNvpJfo7B/143jq2JMvM0b2j81Qs/Fbu5fkLzWrcG/xqF89bnsdGPuDFyh91lT2peFEI4Z57wqXLSk+9rVbsxFJ7cY6xxKGwPatthrVGj2+zGmNSAE2jhZI1ax37/GofwGoySLyvBolCGFR6w86hoeVRnd6JubDc/DTY2taVXz47t9FpVLV0oCj07oMa3eHQ+Mlx0P46Lm6dQ1XKrWyTHGRU038OlGPvv9CF9KpBAv6LQL9nrON+FkVhH5gu3Uw+JiiHtRwHY35LOzBQIfY52899EoW+/FxnnF0cRcYmB8myxhqxNytqgIpKTQDR6SKJQMI4/IkzzY6tCNfIpKM85rktDJH+eF5vFZwSxv8aSgblqM0ahB+jWPkJuUWr2JuO44+a5r66tMIflXvLim+99/Vb/3+4pBEvDPPtrmd0czfKmIli/6OLcsKkdhGsYe//CoxCL4ZNdFC31+liEltNZ5X4B76FUDSliiwKMb+fTTgCTwGM8rttIAYyyhLwk9ibCOAjRMQv79owmbqZsobp3Rb3HT+LaJ/FlamWAZa3chC/7igrT6/sBT7PZCzhcV2rR8cpCw14vXFMLrxB3eGcROv5zX1I0h8gQ7/Zif3u3TvqRW76sJOqcT+RjrDHIDpejFPkWtqVvNXi+iE3k02iKEG8+Jp/A9yXhWE3geUeDSD6x1fgF50+IrxWhpiCUw1Nry4U7Cdid0xYULG43nmSZFvuR8bqm0JisbdnsReW3oRYrQ96i1S0wZRIrz44ok8JHCmWf50h0ctHHFisYYskqzqGpOFg3bHZ9GCxZFjSfgw52U42lNPwqIPPfZ1q3m7sa7TadfmZhd9MDIm5a2NWz3Is7zmklWMa80R7OS1PNIQ0VROymItFBqTexJGmOpWxcLvJFG/MW9IUI4fTlC0Il8+nHA6aKibgzT3HlONFrw8V6fbuiTRN7acDBddt9WqBrN707mbHdCuqGHNlDUhjRUDJOAQRq49BMLFsskb5zZmmU93gshaFpNFHiUWYUUgsRXrtjRWvb6EfOi5ffHc/qpIVSCg37Ib46adVTdKsLUlwJfuXHSaENWt2yk4Zqh9aZuHN/U+/q+4ialPjcpiwiUK1ZspSFKgLYwzV0s5VXgKUHTQhxIvOX6UNTaFSOviL/9YJP/bJKTNwZjDNpKEl/ytx9sXvlaNxklOS1r6saStSVVbQgDl6g3La9WLLjJseVJRT9U9KNgFW4DVuPJd2eMvux4yErtZCNxyGYScLKoscYlgvxgp8PRpKQTei801Mzrhl4c8tEedCKXhIYxYC0Hg4jHo5JPT+cYC540+L7k3kaHvV7Cr59O2e1G9KKA87akagxPJ87LS4hvDiL46d0e/89/OCRSilBazrKKrG744X6PO8OIxPeY5DXWWASGzTThyThnXtY0VuApmBQ1wrpCpeeXTPKG9za/+p03Oae8iXhd4+TtEXK9BXh/u4MB8qrFWLdJi3zFn90b0GpLoyH2FYuy4YvTBUhB5AuMAQwYDwKBWygBISxKgVCCYeyz23OTShqsYuFKxkWLlYJ7wxQpnZu3lM4QsKxbykbfbqhucWP4pol8s+MOHrW2TIqCxPdcakHtsryttV/bmF5iOVj4ZL/3VYdXiW+Mz/omrDp6DzZTFmXLMHFyq2gZHdrv+VeiJ6+KB0fTimB54LLW0nqWnaWkRC5N53500OcXD8dY32KtJaudedVGGvB4lKOk5Mk0Bws/udMnCTxaYxikIbuDmPsX4v9Wz3Zl3vmsaVIaeGx3Q6ZFjZTSLdTWOlqmtRzNSiSWooXYl/jKmXo12hAGMeNFxf3NlFBJHo0z5pV79uXyEN0JfTbSgLIxnC4aAiXpRx5CuI2NfQcz05/FysQsupBCcjBImBU187JlqxNSVC1n8xl52ZLRYq1gfxCx2Ql4NCp4OivohxKke7eGoeInd/qMs4ZB4qON5e7QsWZaY+nHPsd1SV63LCrJOGvIq5bdbkgYuG3BRWPdT08X5FXL8axkXrZIAWnku0jTNOB0VtANffqRz7xsqVpHH21aw52N9NJ470U+UsAHO67A8IuHYxpjiJRaR/GmoeKjnQ4WmJaODfg//PMueW3oJwFlU7A/SDiZV+tDnCcFRaMvMbTexI1j2Wh+dTihqi93Cl/3fX2fcZNSn5uM4eynIXWrKbShXhYFt1IXrXoVGCG4vxGxqCyVNsSeZLvjY64xf3603SEJfMZlTtMYfN+ylYZ8dE29/k1Jd6qm5byo6Uc+g76iqC3nRc1B017pOjc55ne7EWVdu3QuDb4CJQW73aszTL6veNnxUDYtO/0YbaATB9TG0mjDvGxRUvDD3Y5b514wJhPfY9o2tNoS+86kurGWfhDwyX6PfhLyX/w6p9Lu5drrRSAsoS94eJ5zb5hilnuX01lFawwGy1/d3/jGeWC7E/FPHmzxxWjB0VRzMEy404/pxx6BrzjPXEGkF/vc2+zRjwMCT2GsoWhd2lvZtMwLTda0dGOfrGzY6Hw1xm9yTnkT8brGyW0B4xr4rvS0F/185Cs+3O5c+t9my8NT1Rp8T/LD3Q5fnruNrjCCBxtdThfOIXhatBRljRUQK+fKPYxC7gwSpBR8dpYxiAN+sOvM8wJPMUx9lHCdWgGEgUcaKD7ZT5BCvJIN1S119t3FiybycVYv03LU0jfBo271OgXnmzamz9LQVu/Xd9nIXmR27PcjGm2xsD5gXZWevCoerHT/AK1xLI5u5KGkuCRxub+RcJ7XtI1eppN4tMZyntV0Qo/NJGRa1RzPynVB4Wha8DfvXTb6vLhIPq9LGfqKj/cjfn+8IPRbzhbOVyGUTtYwWdT8YLdD3Rr6qc+dQULoKzaTgA92ujwZ5xgLX5wt+OXhlEXZoFtNN3YsL2vcBib2JIeT3H2uJ4af3RmQBh6BkreHNtw7Oy5q5lVLVWsWZcvhpKCb+Oz3IoQQSCXZ6UWczCoONhK00Swqg5LwF3eGnC6c3GSrG/GzO12UVCS+5Md3+vQiV3AbJAFH05LAkwwTn5N5xeenGfe3UrbTgFnVcjx3RanVvPzZ6YJxVpEGPkoKdjrOlT70Su4OnSdL4EnuDmP6SUAaKZKgQy/ymJUt3ejyNuPiOxn5insb7sCzOnAASCHoJf6lYlzdGjY7rItxxkKgnHeM74n1eLrI0HrTNo6r7nDZGLqRh7ZwNC3Z60fOzPst2dC+DtyU1OcmYzh7kYcnU7KqpdbmhYlS34bNJEBYy0Yq1yZ5jTFsfIuX0/Pwx9MFSIg9D4Vbc5Hu6//tj3evdK2ble4Y7g0SGmMoG0McKHqRT3nFdJSbHPMf73X4hycTyrrFWIMUkijw+Hjv3TBnhJcfD73IZ1K4gvlmChudgJNpQRwoDpax4N+0D+vFPr6SLKqW05lluxuRBEs/LiEpqgZtBTvdkEHsPJOOpiW+dObq2hiOZ654dX8zodGG2cuY5QrBn93rk4SK97c6pKFHL/Ioa02lDU3rZFdKSoQQDFPXHFNS8clul89PFxS1azb1QtcsMMBoUa3luzc5p7yJeF3j5LaAcUV8V3rat/381xbhcc68bPniLGNWNGSVphcHRIEH1jLKJKV2+dmbicdYGoqyBelMO/d7Md1Q0Yl95nnLdidgUTZ0Yp+8bhkvKqJAYS3s9kOGaYA2bsF4FRu9W+rsu40XTeR509KJ4hd2Ta6yMb2JjezFjt6K6r7djS5FkF7ld6yKBwIXOSWW8at7y+LIswvZwTDBAoGn2OmGPB7nnM5rdjoho6LBV4IPtjpkpeZ4VrHXDwmXiRErlI3mZFYuJR6uUPhsl/LHB30Ox7kzCvUV7292GBUVWdWShh7b/cB19JOAg40YgcCXYu1nsNkJ+exkztG0ZLvr5o5R3rKhJMPE4xdfzkmjgCQQdMOApmkJEsWnpwsGSUDZtG9VjOp1MMlrfv7lCKUki7LmbF5hrSAJFWfzkuNJSehLNhKfOJDktStUx6FHuTQJNNay23OSESOgqh1z7s/vD/CV+prU6nRZQN7thmwd9PE9uS5s9CKf84VjgtwZJhxPHRvK9yShp9johM7ZPSvZ7ARoaznox/zFg+d0usb5t27cnldYS0IPYZ0c5nmSgNXPpKHH+aKk0RJjnafKxe8LPcm8bL/zAfKmsOoOp4GT3/jL5zDJazbSW9nmm4CblKNsdkLKcc5mJ7x0rc3O1RgYf/3ekP/8l08xgO+J9Zj/6/eGV76nv/vsjLLR3Bm6GHBtLOO85u8+O+N//s8+vNK1bvpZHU1yhmmE70uaxjArqis/qxsd80LQ9QWTzFC0mtiD7VRcSyLzfcXLfsb3NhL0eUZjHNtIScH9zZT3NtOXeh9Wv+e9zZSy1ktVkiUOFIuy5tOTjDuDkNZY6hYaY5BYPj2d8x/95V2ejAsWlfMDDJQkDtRyffjmBsmqCNeLfXaXzYKmNQSexRgDwjWblAKxTOpptOXuRsw0q0lCx2L1laRpW4adkKNpQRJ4fLDTvdIz/N7iNY2T2wLGFfFd6WlX/XklBX/3xTmPRjnh0vwviTx6ocekaIkCjx/tdfnt0zmttnSDgF4YYKyjCfdSnz+/PyCvDXf7lmyZS54vfTVO5iV/fn9IXrU8GVckQcBuP3xlG6o3kdJ7iz8dXjSRJ4G/NjBc4SYLaNdh/ayKGHcu/Pw4q8mbliTw17KXlym8ra4lhODheUYaeez2whcaWj0rjTkYJBjnu8akbEgjjzTwCD3FvGx4f6tLqw2PRxnWglKCrGoJPMXdYYyxrAuFq9+1+ptOFzUCy6SoGXZ8Bh3XRciqlk7gM8tq9geRi7xcGi/mdb2WlwkpqFrNNGvxPMnBIKLVhocjF9PZjTwGacjpvKQQlspoYulzMi95sJG+VTGq18Gnp3PS0GdRtdStZZhGtFozq1o204C/+3xEHHrsdGNSH7Y60fKza/CUZWcQgzFIKQh8wd1hihCw14/Xbu9fe5/6MZt3Qg4nBUmgOJ654oWvJFZa2kZjLPzqcMLhpKATeWx1I/qJTzUzbHZD/ELSj3yEgB8d9J87Dl5m4/Ys/R9riZeeLSfzYp0ucrHIffFn2iQkrxu6vk8cqEtjMg09fn80w1eKqtXMy5bWaP7ZRzt/gk/261h1h4dpwNHUGXIrCYvSpS7croGvHzcpR1n5On16OnefceTx4faLafQvwl8/2ODL84wno2I97364k/LXz0RrvwzGeYvVltNFRdsaPE+irPv6VXGTz+oHO10a7fakxUwT+4qdbsQPdq4Wo7oa82nof2MM+cvgt0dTkijkv/GD7rrYM1rU/PZoyt9+sHXl630f8bKf8cW41Rd5KL3s77m7EfPlKKcT+ESeJLcWi2Wn50zMj6YltXbR4+9tdtjvx/z8yzHDJCAK1Ppsc6cX8uvDmqNZQRL49CLva3u2dXNJ4BK5Ck1WNwSeIvIkO92QunWFC09JTmYlG2nAn90Z8uUo5x+eTKmNwQKh7y8Nqh3j9KrP8PuK1zVObgsYV8R3padd5efLRvPbpzOUgDRQTPKGrG7J6hbbCYl8j0HsM84rdjohj6YFnpJsd0P2eiEWyf4gphMGxJ4lr1tC3xnEPRkXbHQC7mykVK1hnDdMspo0UnRCRVlpR1VfDu6bknu8aZTeW/xp8aKJ3CV1vBzF7qrFiJtg/aw2omWj6UTx+jC2ug7wrfcU+S4X/GAZZ1otqbYvuo9nmSSrTsFuL+IPJ3PmlYtY3umGNK3GCsFWN2JRNnx5nmGF4Cf7CXHw1TT/PHPDyJfcH6ZYC4GUGCxlo+mGPvvDmKNJTi8M8KSg1W4jsd2N1gWc42nJ3WFCVjZkjSFQgk4YcjQp8SLBb59O174KSoLOa/xhyqPznJ1uyE707uiJn4fRoqbRmj+eZMzLhu1OSBx4nE5LHp1nnM4qhqmhG/tobekGHoeTHCEEH+10MVYyyks+3E6xVjDKK3683/9acex5zKQVI6pqL0iblhrj80WJMXBnGPN0UvGkLTgYRAxTn6OJ5v5GwoOt9BvH38tu3Fbft34vlUQKWFRwPCudCekLrv1N7J2satnpRfz+eM5sqcVOfcVvn84ueU/8qbB63pGv2OvHjDMnG4qCt2tD+zrwJkpTy0ZzuJTZRb7CWDgc51dONAk9xd++v8WX/Yy81iSB4sFGSuhd/e9LAsmTcUno+UhpaUpL1TZ81Old+Vpwc9Kd97ZSfns0Y7f71fqKcF+/CrKq5d5GSla3lK1x7LXUyXi+LT79WcyLlqZt+e1RuS4cDSOPeXHLlHoWKy+nm0h8ujNM+GS/v75WNSt5sJnw26MFSeCxkfp4KmRStDzYSMiqlvc2U+Z1S9UarHCJXqd5Awbq1lK1Gbu9mGleX/LiWP3OutH8/GhOL/a5O4z5/HTBw0XDT+72SQLFKGt4Oi3ZTAN+dncAgMFFiJ7MSpQQeB602nA8Ky8Zz1/8PW8jXtc4uS1gXBHfVct0lZ8/X1RM8ppO6FNpi7YWbQMWZUtlLB8OY45nJdO8QvmKj3a71K2h0ZbSWPa7PtYanowXGC2IAsVeLyIOPbJKc6efcDQr8KQkCTx2ugGzUnO2lJV8sqRf3aTc423Xgt3i2/G8ifxlKXbXKUbcFOvnRdc5HOdrucfL3NN1F7LVM4oDj58c9DldVGRly/7AXctXzougF/s0xq5NDfvLn3+RueFqY73Xd7GxdwcpFjffbCQBncDDWrs2advrx2u9/vmiIo08xlnDva0Os7zhaFbwxxN3YGyMweAomXltaK0h9RRSQhQsE0ze4UNb2WimRcMka4g8SSEEj0cl47yk1pa9boBSgnHZ0strDoYJv1tUvLfdoWoMBohDyUedDr3E55+8v8HRtMRYvrE4tsLF7lOjDQJBrV2sqRSSOJIMkoBGW2ZFy/G0ZKcffash20Vc5X1fvZfG2qWe+euSlqusPdUyctVTkjuDGE+6qOHTecXhOF9TfP9UuDjPrTb43da7LV58R9ykNPUmr3U4zhnlDWno4S19WkZ5Q3TFdy9vWnqxzyf7ferWOLaUFORXNLgEGHRC/JHCVxKsRXkCIxSDK0o1bhraWP7mvQ2eTou1hHG/75LAroKqNXQij27sr79mrb1ek8xYHo0dSy3yFEYbHo0LfhL53/6zbwmuMh5u8pB+6VrW8unpMt5bQNlYqrKmF3ts9yKq1nAwjNdrxmhRge/x5XnOdi9cJi4Ga4nJs+Mv8hW9JOCfvL+5lh4ZBMPU53hW0o18As81h5Pwq+Ljh9sd9voRk6Im9TyS0HmHOVbxOzSfv6ZxcntqvCI2lxrbujXYpUb3KprGq/x81Zq1qU3iK2LPoxP6pKFHJCXecgHa7qUM04BhHLCRBmykzvjIAOfzmvGiJg4VG2lAYyzbqc+f3xsyLxv6iaOyamspW4sAFlXLVurylleHHCEEgeeMP88X1Wt7frd4O7FarKRwsakvitq6ePB+2XeyWuroL8JXX/k4vCxedJ2T+dXv6Tq4+IzMUgbwTz/cWpt/Xry3QEmwXPobG23Bus3HH0/mnC9ctXyQBOuo2V7s0xpnfrWZBNwZJmx3Q7a6Ebs9x5Q4npU8GuXrZ7LdCV0nuWxojEFJgbXwo4OOM46MfSyC1mryqqEb+ywqzV4vBlzaybuK80XFZhpisIRLn4mjac5Z1qCN4eHEeZhspwFSCRZVQ142VLVmt+9i40JP0WjQ2qKk5N5GwgfbnZc6cK3eqc0kYFY0tMaw24tojMVYu2Yp3N9MORi4qN+DfvzSxYurYjXGJnm9lrT4nlwXCK86pkJPcjypiJbXEkIghTPOPZnf7Ph8GbzsPHeLq+E668Kf4lon84okUOt3z1eSJFBXfveUkJzMCurGzdN1YziZFShx9S38Xjfk/Y0OnVARBY5x+/5Gh73u692DVa2hE3rsdCMOBgk73YhO6F15nV41yS7iuk0y5Tnp2dmi4nBScLaoqFqNugbz5fuKmxwP14YQBEryo/0uwzQgCiSDxOfP7gwIfUXoudCCvX6EFDCv2rWkshc5w09PCSy8cPyt1p6VbYOSgklekVf6hWMu8hXvbXb4wVbC/jBikIR0I4/N1ElJ3hW8rnFyy8C4Ir6rlukqPx96bpA+nZbEgWKcu02tpyQf73bR1iKEYFHWpIHLKjZAozWpL5nmNbGniAKPzU7EdjdkVjRYIXhvIyGvW7Qx7PYj8tLRo7qhR2IM51nFk3HBZhIQeF8tbN9V7vG2a8FucX28TPX+OhKkm2L9vOg61tor+Xd8F6rzi57Rs/c2TAMejTJCX63jZ+dFjRUC33Pu7nVr1wkIe/2Ik3mJJwWbnZDNNIBlClEaejyZFIyzisT30MZwNHV+IJ3Yoxf5+J7zxpgXrsMhpCS64L/h+S1SuqhLISyBgqrRaGOuvEF9m1C1hmQZeXo4KTjLBGnkU7aaprV0YycTbK2lrDUCwd1hTBIotIXjqTNwjZda73lRX5lVsKL+Hizn5ao1RL6kH30lsYh8xVY3YqcXreOOr/L+vuidX319VjTkTcuibElCj6ox9Jcd1FZbAiWvtfZsdkIaY/C1xFcWbaDWmn7sY19T4extphK/LlStQQo4mn71jvVjn+Y6cZ43KHO11snxJnmzNpSMfMlVre20dfHB47zmeO66u8MkQNurz507fcdEejL7yqz5Ti9k43VHg1rL40lJGrqo8tZYHo8LDvpXu6+bNEzU1qKEoLYWrEFbSSAE+h0qul93PNy0pOv+RsLZvMb3Jb52rPFR1vD+9uXUuN1eRN26fcUwDRDLioQ2XzV2njv3P/v+aY1F4Huu2RV4kiSMlxL8r2T1gRL86MClgK3kXdudd8uQ+XWNk3fnCd8gVhuQl+1yXcRVBvVmJ2SQhsSB5GRa0GpDVrWUteFff3bOr59M8ZUkChRJqAh8RdtqtAFtBHXjNsC9yAdrubeR8FcPhtzbSPlgp8tGJ8CTitDz8H2Pj3a6xIECBInvTAJ/83TGNK85mhZ8eZ7xaJx/547pd3l+t3i3cZ3uyk2xfl50nd1+/NL3tKJjGus6AStzzbL5bh4wz96bFIJhGrKZBIyzmpN5wemiJq9ajLVsdEIsjnE1ziqkEGwkAT866LuCzJIuaqzrwEgg9BWTouYPxwswYIG6Nvz26ZRe5DFMQtJA0Ys8AiV4fF4QepLdXsTHu13e20zZ78UcDDpsdl0s2SirmL5M1NlbitBzlFMlBZtpyFYnZKsbOJPXQUTkeyAkSkhaA53I42/e20Rr2OmEfLgTMy1rjuYV/dhHSHEj8+kwef67nobeld/fF73zk7zmyTinqJ2MRmvn8j4rGk4XFYuqoWkNtdYM0+BaRcfIV/z4Tp+q1SyqFnCsEmMtu/34W3/+Ft8TWHfYNRbipSTu8bi41l7lJjv4gzTg8ShbM9zq1hktD9KrdWeVlEzzhm4YcH+Y0A0DpnlzKXXqZfHJXo+TRY0Ugn7kI4XgZFHzyd71PDBuDELgTpfLf9vl/7liksFNspzmZc0gDtzaFrr/DuKAeVlf+VrfV1xnPNz0Pif0JL6neDTJOZ2WBFJgrWWU10xzx6a4+JlvdkI2Ep/dTkRWtRS1pmpb4kCRN+3z5/5n3r/Qc/GtvcjnziBmmAZgYVG0l/4uCxSNphf57HRDepGPfsfWl9c1Tm4LGK8Qq0H82eni0obtZQd15Cs+3O5wt5+QRD792MNYy7DjY4WL0ZoUDXvdBKUk/chDW4s1hla3dCJFPw54bzslUIpxVl+ikWdli7WW3W5AXrU8HC/IqgZhXcb4D3ZSstrwq8MZ2lg8IagaTdGa73zgusUtroPrFCNWG5qm1XxxlvF4lK2r8lfBizZGB4P4pe/pVdExL97bOG84mRduchduod/pxkS+RAmxTj/Y6zuztGnRrP+WVXLJs/c3yWu2OyF5rdnpRgw7Tmry6dmCSd7wh+PZWkYyq1ruDBJ6qY8QkqfjgkXZMM4rkC4GcCMNMFimRcu8eHc2g89isxPiCXh4nlO1GolllNVoY4h9wTDxOc8qp901hlBKxllN4EsejTL+8dGMomr52Z0++4OY42l5rbn52Q2nryRWCJpWX3rXX/R+fNP7+6J3/tPTOYGnyOqW0FckoUc3DumGHjudgCfjYi1pqVvDo5GLEr/qRvj9rQ4f7fXY7TkJjCddce9g8O5sMN963NDhF25W5hoqyVY3Qkg3xoSErW5EqK629dbGsNtzMeOVtgSeZLcXryPvr3ZPrsiZly2jvCIvWyJfEaqrPyv4+j73u+wN7w4ThHAHQiHcv6+Dm2qSxZ7i6bRgkpUUTcskK3k6LYjfIQnJdcbDd93nPPtOKenMwLOydUk1i4rzrObD7Q7tssly8TP/YNt5NO31I1fQxNCN/G+d+y++f93Y5+O9DkI4LzEpWP58cOnv2uqGTLKKxrjn0xhD2xo2rlik/D7jdY2TWwnJK8LzjG9+czhlqxtdyUww8hX3tlIebKf868/PCQMPAcyDhsD3uLfhBtzdTofH5xnj3HfZy1vpmmJcNJpO4JHVLUEh1jTyrU7IKKv4/CwnChR51RL4itpoBrFPFHj04wZtLK1xNN57GylySS2/pcHe4k+N7yJBsrhD2LMJItdxyX4WL3tPrzKF51JSytLJ/dHIUR3TyF+bdQbCFTP3B/FaFrD6m150f0IITheVM8DyJY2xjLNmmRShiZfRkFGoGC0qtnqhW9jzhrLVjvWR+mx3I7pxiAV8T7LTC6nad4eO+ywiX9FPQu4MNNOipdWWg0GMNjGt0Qgkm2lIN5YYA76nCHxJGvmcLSoONmJiX+FJydnST+M6c/PzDGp7kb8uXKxwnff3RT+zKFvuDMSlBBRPCRoj+HCny0Ynohd5zMqWSVY5TXzkXXnsrhoBb1pCxS1uFneHCZO8WZsN3x0mXNH/EbhhmasQfLDdYVo0l6QtV72vxPdo2oY0WqZBGUvVaBL/6lv4z05z9nsRB/0Ys2TrWWv57DTnLx5sXulaN2l4ukrZ2r9wuKyXSV2vC62xREu5XqsNnudMJNvrvFjfU1xnPHyXfc7z3qk/HM5oWuPWvlChlGvGNNpgjH2uDPV50shvmvufff/KJuLRKGOn53NvmNBoyzirORheLn40rWFvkLCRBuvfkQbetVJvvq94XePktoDxivC8DaG1sCgbehfckZ83qJ+VmWAtWa05HBdICWnos92LmCzpU62x3B/GSCn5yZ0B2hqKxjCIfTY6PufziiY0hIEb9JudkMCTbHRCDicFu73ImUv5Cmthuxcyq1qklHQCj37iX8pyvraj8y1ucQO4job8ppJIvus9veoUnmf/zpVp1SSvGSQBR9MSX4llF+WrTspK0znOK4wJLjm4N9qy0w15OMrxl1Gq47xeFjMU2riD5zirXIKRp/j0ZMHdJTvlL+/3yWvDF2cLRnnN6bx0z0JJepHHweDdLYSWjebRebaUNzjvkq1uwM8fTjiauOi4n93tMi0094cxeWtcR6huGOU1VW34+KDHvGpIfA8luZanyDdtOC+uR+O8Qpvg0hr2be/vi975VTEi9CStcT4yK7+LRlt6kUvnYJzTCb3vNHZvfSfebryJh1/46r72+t/tvnqxz6So+defnzFeNAw7Pn9+d3BpHL4sRlmFELCoW8rG+d10AsUo+26Gp/Dd1tWb9K64KSglSAOPfhIS+lA1uNS/a7JV3hV8l33O896padXgeZKhCigajbXQWsPhpGCr+81+Ey879z/7/kkh0Mby68MJ//WnZ2x2Aj7c7n5NtpU3X08c8a5hEv99xusaJ7cSkleElaNt2WieTpx/xKJqmTyj9352UD9PO/Z4UvD/+dVTJlnj9MJZw5fnGWmosMZVuX5zNENJwUe7HR5sdDifl5xnNb4UxL5ibxjxs7sDjLHr9AHX/QucAVyrubeRYozhaFJyPC3phIrQl3SeicK5jT29xfcNN5VE8l3xqlN4nv07L6aRRL5irx+hrcUYixSsDRlX800vcuaf86JZ39+8qEEIxPL6o6yibDU73YC6MSgJnUDhKUlRG46nBUXV0o08Qk/y26M52lq2uyFPxzkPz3LGi4rzRcWjcUY/eXci6S6ibDSfncwZ5y69ZZw1/NefnfH/+uVTPCH5eL+LpwS/eDQlr1qGnZDEV8yLhqax3OlFhL5ilteUtWZ/EKEt15qbX6RzBi6tR/3IafpnF96Pb3t/X/TOf7jddb4agUfVaPKqpWqdqeDFa74pY/cWby5ucl69Sf3+Td1Xow3/8rfHnEwrtNGcTCv+5W+PafQ1JCSB4rOTOXVjSAKXrvDZyZzwGrGPNzk238SEnm7o8+FOSt5qHk9K8lbz4U5KN3x31qzrjIfv8t4/751SQqCEK6gXdYvEFQKPZwXech/zXfHs+3e+KPnV4ymTvMEYy+m84t99PuLJOL/0dzWNJqv0jfjvfF/xusbJLQPjFSH0JPOyZZRVBEoR+4o68DieFsyKhu6y+/Rshdnl3bsqedUaLE56koY+gzTkN8czFnlOd0mt3elE7KYRSeQ+Sk8pNjo+P/EGzKuGvNIkoUegJCfziqzWhL5cU8g7y/+tm1iwgh/fHTDJaqrWMC0aDgYxh5OCk3lJ4is6z6EV3+IWbzpeNfPhZfGqU3i+LY1kZda5+p0rquaq29GLfe5upEzLGildxKldxv892EpR44Kq1ZRVy7RoOMsrtDZklUcaengSgjQgUoKzeckfchfNWTVuPmkM9COPwFP0Yo9m6ePzLuJ8UZE1mo1OwG8O55StKwpoDSdZyZYIXboCArNMazmZV6SBIo19tAArDJ3IdxsnA4LrbeY2OyGfni7WJq9SCJLQI15ql1fvRzf2ubd8P5QUL/X+ftM7H/lOF92PffKmpRuEJIG6RPN9U8buLd5c3OS8epOsgpu6r3/7xYjWQORJxDJ5utKGf/vFiPe2Ole6VuoppJIcT0tqrd3+NJSk19Cr3/TYfNOYUg82Uv7lH08IBATLPfZxVvPP9wev98b+hLjOePgu7/3z3qlBGnAyL9lIfU5mlsNpgbaWT/a69JObkwNefP/+r//2IbNSs5G6ePOmNYyyls/PFtzbSNZ/124/5jyrbsR/5/uK646T75pUc1vAeEXY7IR8+eUIT7r84dZYfE/yyUGP2Tds/mZFw7RoCH1X9DicFutiw8EgoTWW3x/NqLWhKVo+2HKHgd2u2+zWy8q3i9mzriqoBL5SeEpgIssXZwueCHgyyplVDaNFzTAN2EgD+knAMA3Y68c0raNo7XQjzrOKh+OcpjX85KB/5edx05FKt7jFVfAm0VNf5SbteTTIYRoSe/K5G4mVdMBF/bnCZaBcCtEH2x2ejHPnu+BJQHJvI+FkXmKMZVY17HQjTmYlbWv4h5MJReO6LL1Q8WRc0hgXq1W3ltNZyWYakLeGumnZ7IXsJk7i9i5iVjQ8Os85nJacL0pCT9AawSDxqBvD43HBdhqw0w85muT8+4cjWmM4bmGzF2JagxKWz88WbHdDBokrLhxOimvNscJaVwGxgHD/rrQlCS9vxDqRh5RO2/+yeNE7v/r6neHlNeJ8Ua3v/00au7d4c3FT8+pN+xTdxH19erKgFykQklZbPCUIreDTk8WVryWUdMw8H0JfInFMPXFFY1F4s9bVV4Fe6jGaVzw8y9Z71/tbKb303Tk6XXc8XPe9f947tRH7DJKAaV4T+pLtbggIQqWYvaIGyKcnC/qxIgzcZx0Gkr4xPDzPn/GFWtyY/873FdcZJzfhn/PujMLXgKY1jKoagWCr54oC4fIg8aLNX960yGXHE1ylPQ095lXLrGjoxz7v73R4Miq4M4jZ68eczkoej0rubETsLr0xzrOaqtXOtTdQeH5LmbsY1rNFTd60fLDdoWo0vcRnVjRESqKN5aO9LpGvGGfV2mwPBPc3UqyxLKr2Si/aTRo93eIW18GrZj68KXje3/nhdueFf2foSRZly3lWE3iS2FcUtSava8pGXypwjLOaWht8KQiU5MFGh3ndUjaaw0mJ1tZtiIXg09MMY6HVmsDz6MeOTfZ4WnC3nxAFkkHsM81busm7twyVjeZ4Vjofi7alqjV5ZakalwjQTwOixpCGHlmlSUMfEBxNndxn2PVJQw8hBf04wPckBoGn5LXm2PNFRTcO2Ox+dYipW8PJvKATehhr1gUuIWDzhs3Jvm2NeBfG7i3eDLyZjB/L2bzG9z2MASmhadqvyXtfBkXTsN2NqJZpcpGvCD1J0Vz9IPi2j81ffDlhtKiJA4/ItwghGC1qfvHlhL99f/t1396fBH/q8fC8d+qDnS6TsqHRhqNJgZKKzY6PRfDoPOOT/d6Nv3OehEpb6rxeFw2ttTz7Z7+p/jt/SlxnnNwE0+3d2zn+CbDajCWRR+BLZkXL4bhAWBim4deqmRd/blG0nGcVaeiz2QncZrEbMpq7KL1OpCiqFm0Mm92ASVYxLRpX3Eh87m84B9zRouLuMOH3R3MeneX85smcj3YSNyC1oRt6BFIShx7NUqoSBIqDQUJeafoxTn6yNAAMPOmi9aSlbfQ6EullXrRXbaB4i1u8DN40euqrwlX+zs1OyM+/HKGkdO722mKx9GKfXx1OqBuDsS6yuRP66wLH6aJitxeuneyLWhN7kllR88VZRlY3pL7CArZtqbRBCcE0a5jmE1JfcZ5V9KOQD3bSV/tA3kCcLyp8JfGV4Om4pGo1nnCF4tNZSeDFhEowLRvXIfUVk6Ih8CTd0CerNT/Y6hL5HlXbUreWjSQgq1p6sX/lOfZil80VVwpOZtW64O1LySDx8YQgb9p1lPZ1No3PY+N92xrxrozdW7x+3DSr4CbYp3cGEf/qjzmbqSAOnNfQedbw8V73yvcT+4rfTKbMSo02BiUlvUixP9i48rXg7V5X//6LEZ6S9GKPFTUtr1v+/ovR6761PxmuOx6+y3v/vHcq8RXHk4KsbLGiJSsr0ijghzvdV3KW+GS/z3/x2yM205gkFGSl4Twr+O99snfp+zY7IZ+dzMka7bzFpCBdJqC8K7jOOLkJptutiPQVYLUZ60c+Tycl1kIn9DhZVDweZaTh1+tGF4se+4MYBDwa5aS+YrcX8dFej6xu+N3TOdOy4a/fG1I3lqzSbHYCPtnvMs4qxnnDyaLEIvjD8YKq1USeIg4FX45zilYzSHw6gcdnZwuUEEuzUcO/fzTl0ThjXtTUy05bJ/KpWoMn3YZy5RJ/FaOmWxO2W9zizUTkKwZpiK9c1rkQzjdjUTZUtWF/EPNknPOHowWPxhlPpyVVa9jrx8wrTWssAsEwCVBS8vl5xrSsEFimpabRcG+jgxAwLVoa0yIRRIGi1TAtK+Q7pBVdoWoNxhqMtuwPYiJfURlNoATvbXfIK03eGKa5k/gtyoaq0UuFh+VoXPH5WUajNcM0xFeSyJfUF0z9rjLHrrpsZaN5eJ5zPKtQQtCPfWZZve6GSSm4t5HSi3zOF1eX/rzIEG5WNLdrxC3eCNykmeRNGYLu9VM+2knX86gQ8NFOyl7/6sXfujGM84aiaSlqTdG0jPOGurkda88iqzVF1TBesprHeU1RNWTvUArfdcbDTRrhrjDLG8aFSyMJlEIs5SOLunkl68QHWykf7/UQwslrhdB8vNfjg62vj7lKW07nJYeTnNN5SaXfIf0I1xsnLzIOvwqz55aB8Qqwqiyd15qDQUxea6pWI3Cbv+flA6+KHjvdiKNpyU43wqYWbS2ekjwe5QyTgE7gEQaSedGy0QnxlWKnFzrTtcgnVIK6MTRauxQAX/J4PKH//2fvz6Mc2/aDzvO7z6yjMcbMjMy8mTfzzc8275rnAWMoV9kU2BgPq9qUKYwf1dRi0RTdDF0UBqrporqpZaqg8YLG1ctgwGBjpsJlM7gwNmXM5Ge/5/fu8/O9b8p7b06RkREZoVBIOjrz7j+OFFcRGYNiUEgR+n3WisyQQjraOtL+nX322fu3PYf1IKTZjTENg2tVF8tQxGmxJKLXn1e20Yl4vhOSA/WSzdNmUOTksAzqvoOhBokBA7Jcj9SzOp1DMoUQADXP2rNM5cPNLi86xbDJrSBmtdXDMhSbHViZM9FolisuQZTSjVLiNONZq8evPW3RiTIMFKYyyMipujZZnmEok50oYbFcwrWLhKD1kkOa5Txudie8By6eaxlsdhJ2woSKa/G+61V2einPWz3iNKdedrgzX+bhizbPtiM22lExAsZSJFlOkhWrwby9oblW91muuoRJvvsZwsli7OAq21YQE8QptmGg0SzVPLJMF0tzxxmOVSSAbvg2ySnaaIeNtNjuxVQyW44RYiqc16iC8xp9WnZNPnp3gfV+R6LvmCxX3D31fVTP22FxgcowMI1iuHec5jzvL28t3lX1LR5vdUi1Is80hqmwlObaXOn4J18hJ60P4xh1vdGJKFkmCoVSCtMEhcFmJx7LccJ1LP6j9y3zuNkrRr+7FrfnStj7kt2ubvdodkJMw8CzFYahaHZCVrftE+WJusxOU0/OY6TbTHdgjC2xpNY8bgY8bfaoeTZ138ZQxcl/xbMOHCIz6PSIUo1SmtXtYhkexzZxDMUrC2VKjkk3Slnd7vGsF+JaBu+9XsLoH4Cu1VzWWmExbzpMcT2FxgCt+fhbG5Qci7pn4ZVM3ny2wwduVNno9MgyWKg4VBybzk6PD92sF3Pj+xnp58s2z1sRYVLk7ljfCQHFrbnSbs/qUT2yVz3RkxCX2XD9zPKchy86GP18CjtBMYWh6tpoBYuVorN0J0p5z7UqO0HEpx52+NLzNu1eTM226CQJnSSnalsYRs5OmOKamrJtYBiaOMl581mLhbLLrTmfLL8a86VHUeQL6fHgeZtPP9okSqHipqS6yHD+nuVyP8GzyYtORBhrlKFYKntYBqQaunGOZRRXpNL+6DbfsVBRyr3lKlrrE8fYQQN1fSckiFNqXrHqlWuZGKZidStkpV4klk4zzZNmwErj5PH7sGGjvmMTp9nubTlGiKvgvBKCXquXeGejTa1kU3GLJLpZnnPtFCMwtrrFVLRcQ2aAqcCwDLa6s7ka1FHmvCI/XFrkokYZYKnifnG4806EC0WHdq1k0gyKPIGGUqhcEybpuS1DP8y1ipyAixW3mJZpGhiG8VJnyePNLp0oo+zZmCZkGjphwuPN7sx0YJymnpxH/pyZvbwxjiFOg+320pwoyfAsg6jfYO2ExaiLw64qDZLprbVCbNPklXmfparHTpCw3o7Y7BZX4WzL4NXFCu9ZrlB2bHINhoLrdY800zzdCniy1eUL623efLbDG6stVrd79JKcubJDteSwVPNwTaNIumKbXKu7zJVdemnKzXmfOd/hRTui7NjMlV1qJYevurfAzXmfh5vFkoy3531KTnHVdpAP4zDTuL63ELNqEPve2ujsdlwM6uez7R5lz8Z1LMqehWEqFioeO1ExxL8VJOhc0w1T5ssOQZLz6lKVD9yosVQrEecZtmXRcAzKrkEnymiHKZWSiW2ZPGvFxLmmZBW5NL603t2dnnbVhUnGg40Oq9vFcedGvUSmc9baEUGUsVC26fYSmt2E+bKD75goE5aqDhXXpNlL8W0TRdFA+IpXGtya99mJcnpJRqNssxPGfH5th/V2b6QO+TDJeGujw3/40gafftREK1iuesxXis4LoJgmpAxsu3/cUv1/TrHO/WHDRmueJccIceWcxzBpgPmyQ5wXieG11iRpTpwX95+UznOStFjaOohSoqS4rXOZQrLfeqdY9cIxwDIVjlGs3LLeiSddtKl2Xt/7Yb7bv8CLptmN2ezEhGnGzUZ5LMeJsmvxZKtLnOZ4lkGc5gemAGiHKbZV5BBTSmEZCtsyaIfpuZdpWk2qnszsCIxxJZbc7ETUvKKX/PlO2F+G0MCxVH+kxMFXlRYqLr/4pRd0khRTFcOQTEMRJelupdAa1ndClqouZdfGs4yiEZznPG4GfH51m61uSr1kUnYNPvOohe8abOyEGIbBk2bAzUaJeubw1fcXeN6KeO3OPKZSKBTvbHa40e8IUUqR6WIOdjtMWWlkaE1/OolJlORUXIu5srO7sspRrnKiJyEui/2rPbTDlIcPt5jzHWolm5JjYhjw6Uct6r6F1kUs8iyTed9hJ0yoehavLBRT4aI0p9WL6cYZlmlQcR1M0yAnpxdlmIaiZJuEcc7zVo92nJDrnLRk4zs2rquZkf6L4kpDlFJ2bDpRVqzupBS2gijJWKo6bAcpFcfk7Rdd0lyjgSwvcoWEUcqTNGWrk3BrzqeX5FRcm7Jrc73u8nirx9fcW+RmoxjBsNmJ8Gzz0MbdoEOl2Y3wbYsoy1jd6tHqxVR9m9tzPq5pEsYpdxZ86r5FLymulAxG353UUaPx5BghrprzGn3ajVJuzZV4th3SjVPKjsWNhnfgdOTjNHyHTz1qMtxdYQAfuFE70XZmwcZOD8cwyA3IczANhWMYbOz0Jl20qTaOUddzvsPH28VqZ6hiBFIv1SzVzn/0BRR1bqnm8Ww7ZLV1eJ2rehYv2hE7YbKbxNNCsVgdT7mm0WnqiSyjegbjGOI0vF2lDO4slLlW89jqFF/ug64qDaax7IQpqzshFcfEtBRoaAcxlZJNmmvSHGxTk+eaN57uUHZMPnSzTqcX87wd0QpicmCp6tLqJSgDyiWTMMoIM80N36bmO2gNvTjDVAbLNZeKY/H6oybtKKEdJqzvhCzXPOqexbPtENsqhkw934kIooQwLpZWzPIEy1CstXrMH7GyihBiegx33IZJxlY3wjIMojSjFxt86XmHa3WPVxZ8mt2YbpRiKLhR97hWL5HpYrWLlUaJtzc6dMIENJRsg+0gJowzoOgA1Roavk2YZGg0nSQnS6FDQpSm3GwYfGihyhkHvV0aReLOYjm2OM15azOgYptsJylBmvF4K8SzFZvdjKwbozRsBxHLNY+wnzB1J0yLhKtRwmozoOxafPBGjVYvwTaNE3XIb3YitrsR3bhYIrfVy6iWTJYtjwzNajNkseJwe77MYsWlWnp3OOhpl4m76ssuCjHsvL7vO2HKVidC6+Lqttaw1YkwDYObJyxTlGV4rkWcZKRaYymFY5tE2YwE4hNIc81WkGIYgC46k4M4p3rOy0hfNeOI880gZr7i0gpiwjTHs4u8fM1gPFf5R61zy3WPJ80uShUXJLJMk+qM5Xp9LOWaRqepJ7KM6hmMK7Hk/u16tsli1WO55r30oQz3QIVxSt2zybRmuebhWibvvOiQa41jmpRdk8dbXR5v9TCV5rd+2Q0qns2TrS4353y6UUbJtim7Jo5t8nizi4kiQ/OBG3XSLMO2DaIkJYxT1to9vubeAlprGmWHMM2peortIMZ3rH7Ge42PUyz3ZxQrlcxVXCzTQPWH+lZci412yFfeOd0SXEKIizPccdvsxjimidVfgaQbpyzXPXZ6STGnVEPV06RZxlzFZaeX8Mq8z0q/IRIkKXXfIepf7TfQRFlGlmZYlslS1SPPcpI8J0xTLKXBUvi2jWuZvLJQpuzaGMZsZOx2LQNDFUvVdsIEaxBDSw7LNZNHmwFr2zG3FkoslG3eehEQZZon2yFzpf50nrJLO44xjGLanu+aKKVo9xJeWdg7H/64DvmdMOX5Tkit5BBlOZYJ3TCl4lms1H1u1EsY6t2raXE/38ZZr6bJSAsxS87j+94MIjY7CdWShWOYpLlms1OsyHBSQZhRtkwWyy6GglxDL0oJQunA2E9T7B9T0Z86V9yejSPW2Zx3nN8JEvIMbs2Vd49DrSBhJxhP7pZR65xrGlxv+KSZJtcaQyksU+Gas5Oh4TT1RJZRPYOFikucZsT9OYVxmhOn2ZmTwZxku8M9UEmuuVZ3UQpedCK01sUqIUnOnYUS7TAhzWC55nKtWuLBRsDqdkAvzdnshGwFEc1uxLPtHu1eQtpPAKq04nr/6mmUZPTCjChJMQ2DMMrYDhKUobi9UOZ912t82c05LFPR7qWUPYflmkuYZtimYq4/L3u5Viy7uBMmOFaxhKJcQRNi+g3PTY2zHMtUpP3VhKI0p1Gyqffrc7Vk41oGjm3h2QbX6iXcoXruOzaOqSjWqygOWGmqMSyTmmdjGtBOirnWVdfGdxyUglxrTKXZ6SX04oz7M5LoaqHi4rsW3TghiFPqnkWS5cUytGWXkqOKoZRpztpOTMkyWSzb2EoVGc4ti0bZYs53qZeKKYR5Di/aEWnO7jKoA8d1yAdxgtPP6p72H2soCKIMxzTI8pxHm11Wt3sopUjSTPJTCDEBSZJjGKD6S04rpTCM4v6TUkpxvVZciIqzYpW76zV3d9viXaZSOFZxRTlOi/8dq7hfXKws19Q8gyBOWduJ+smmi0Sb4zBynVOK+0sVrtc9Fiou1+te0aaZoe/IaeqJLKN6BuMaynqS7Q73QDlmMUTpRt3j+U5EL8n6jcuUt9e7uI6BZxt0o4yFegnHVLSClE4Y8yzNaZQcgjBldaeHqRQ1z2Kjl+LYBmXbRDkWJqAainrJ5v3Xa6R5sVpKL87w7KIjpepZNHynn4Xe4e5iBc8ukpymOxoUuJbJfNllseIy3+/FF0JMvz1zUw1FL87QFEmAt4OYsJ/b5kajWP6q3UtYb4csV0u7Vz0G8xRrnoVlKN5YbWOZBnNll9vzZdZ2IjpRQrPZY77s0Is0vSjFtRWNks/zdkg3AY3mI3ca3Jo7eSb9y8izTe4vVVi1TR6sd0gz+HWvNHAskyTL6aSaaskkyvLi0oXSGBgYhsI2FZqi02iu7GKbBi/aIWmWs1zzuL9UZqMT83iry605H9Mwjh0l4dsWVc+i1UsATZRku6MHfdfkSTPAtd+dnxqnGTcbJem4EOKCOZbBctWll+aEab57+zTuLJX55bdeMF/2WK459KKcrW7IV63MzpD3UTmWgWsYGEqTKY1pKGylTrV8rTibxZrL64+6NPxiVZAwztjsRvy6V8ZzAWTUOuf2V/S5XrWqvR0AAQAASURBVH93ydDTTrG8rE5TT84jT8pM18JBZ8O9pcq5XlEadbvDPVBzZYc4y8hzuNnwmPcdFJr3r9QwjcE63T1qJYeKa2GbBjkaQxXz1xerLo5t0PCKlUm0VnzoZo2vuFUnzjTX6x6vLla42Shxd7HC9XoJ2yimjDzb6dHsxmx1I55s9UiynDnfQVFUxHrJphulWKaiZKp+5uqMsmOdy6gVIcTFGF4RyHMssjxnoZ+It+xYdKOEsmvtjh7baIcsVT0cy0D1D0iDVYcWKkXnpaE0S2WXaqnoD3dNRcO1mKs4+J6FY5vkCpSGXpKzXC3xoZUaH7peZydIXsrqfZV5tsm9pQrf/totXl0uM+e7zPkOWaYp2xY7QUIUp5Qsk6pr040zlmtuMToCRZhmGEqhtca1TJbrHh++WadRdrk97+PaJs+2eyONkqiVbG42fK7VPTzLJIgzyq7F3cUyrSABFMtV76XPXQhxsQb5h+ZKDjcbJeZKDpnWXBs6aRrVexYrvLpUAQWtIAUFry5VeM/ibIyEO4l6ySFTOZ5jUfOs4pipcuolyYFx0RZ8h9sLZQxD0QlTjP7I8YUx5SMZtc6NazT/ZXKaenIeq1POTsvxAIMEmlGa41rGSMvOnadBD1SUZHSihG6c0eklvLLg0wpjbs2XqZVsslyTa0iynCDOSXNNnucYSpGjuTPvU7LNfkZ6k/uWSZbDynyJOMlY34nwHYuNKOTWvM/1enEVLU5zsjxH5ZDlOTqBTlQsh/OepQorcz7dKCXRsFL3QCmiNCeIE6p2sWLBRe8zIcTZeLa55+DaCmOSLKdWsnntzjzdKN0dPdYou1S9vYeJwTzFwQGo6tmstSKu1TzWWiHKLNYCX+w/t+raNLsRrmVSsk1QUHaKnA45RWKsk2bSv8zCJKMbpdyeL/PGsx16cULZsbg1V6IbJbiWKmJ+Aq8s+KzUSzxpBtgWeLZBpnPKbpGQec63eb4TFp+V73B7zieIR7uKMTj+rNR97syXaYcpG+2QmmfT6iXcmts72uI8klwLMS6Tbs+N00qjRC/JCKKUOCvm2c+VXVYaJ+/AWKp5vPbKPC+6EVGS49oGi2WXpZo3hpJfblXPpFGyaYeaMM+xDYNGyabqXY3v1TQ5rv7WfYdX5suEab672odnFYk8x2HUOieJqU9fT86aJ2VmOzDOYwmXo7Y9yoF0cCLxxmoLDcyViqXrDFWMfKh6FmGSEaUZT5shYZxhGYo0zwmijJtzHhXHxLYMbjRK/fnlxZJ8LzoRjmliK4NXFizmyw5LVZdOVCRuc0yDzW7MzTmfuXJRSTf6ifh6UcrKnE/Dd2bqxEKIy+IsjfXh2DfnF0s+D64YeLa5t843gyOTHXu2yWuvzKE1dOKEF/1lztJUE8YZN+o+Kw2TF57Nxk7IQsXmzlKV5aqHoRRBnPKk2ePecvVc98+0Gt7312oeaZbzmSct0kxTL9l89avzbOxEbHZjTKW4VnXZ6ETkwLWaS47CMgzmfbc/vcOmZBcJxtZaIQtlh9KIK0Ltb3j5jslX3pnHs02eNoOXlkk9jyTXQozDONtz08CzTW42SjzYaBOEGRXPOvV0rlrJ5lWzwnLN2z1+lB1r5LgxS2zLwrdt0izFzBSOqfBtC9ua2VOnsRil/tZKNrZp0I3TC/nenqTOzXpi6knVk5mtheexhMtBTnogHVyJGyxr2OzGdOOUdpiQa00nKnJh3J4v8WhT87zV45X5Mu+/VsU0DNq9GK3U7lSPJ80eL9oh1+oeaEjynOv1UjEFpRViWQa+Y5LnmufbPRYqbn/IcMrdxQo613TjlM1OhGebV+LgL8RVctbG+kli3yjzFFfmfNbbIZ98GGIYBrcbJbb6y3oqckqOx+0Fu78aicY0iukoxepGBq0xLYM2jQb7Ptea5zshvmNzb6nMajPEMhWebRCnGscqVoz64kYX37Z4/40aa60IU4HnKLa6EZ5lUHIs0qxYmjUBNtohr51gRajDGl7nMT9ViIsyrvbctBh0WC9XS9xsFPXxtG20Qd2eL7t76vYsDXkflW1oOnGG55iU0GgUnTjDnpGVsy7KKPX3or+351nnrrpJ1ZOZvZwS9ZeEG2abxRSJsxiuiKPMHR6UI0wy1lo9tIaqa+FYJq8/2eZpM2Ct1WOzE7NYdflN71/GdYqkMYaCe8tV7i9VdpfDWql7zJUdDKVQit3pIp0wwbEMbs/7mIYi1ZprjWKOV6eXYRmg+nOsV+Z8me8sxJQ6aYzZ7ySxb5R5ip5tslwrcatR4u5CmbrvFCO7ShZhBq0gpurZzJcdsizn4YsOb662eLwV0IkTar59th1yiQz2/WAJW7s/eiZKM9phwmcebdOLizwXhqFI05yvuF2n5FrcnCtRKVn0Ek07TLi3XKHqmigFvaRYKapRPp9h8+cxP1WIizKu9ty0OGvMHyZ1e3Rppqi6NoahyPsxuerapNkMZWi8AKPU34v+3p5nnbvqJlVPZnYExiCB5mFDo0/rpGvbDsox3KBNspyya6JzTS/JiiFSCpTWVFwL37G4t2/pweGrDG5/1ZDhDLDbvYQkzXenj1yreSxXXT7/vE0vTrFNhWkU88yu1TyZ7yzElDrN+tnDU06aQUSWO9RK73YcHBX7Rh0eeb1R4t5ylTjLeWujw+Nml4ZpUvYs5soO7dBhs1Ms8WwYsN2LmdM2yzM093oQ7+MsL/KBAGmuma+4PGsF+J6F7xroHEzTZmUO1lohlmmyULFZrLh0wiLxntufOjJYMSZO83NdEWrWh8WKy2Nc7blpcZqYfxSp26PRCuq+RaaL75NtKkxV3C/Oz6j19yK/t+dd566ySdWTqxHdT2FcmWNPurbtoBzdOMU0ikSdcVoso7dY8aiVbG7Pl7nZ8Kl4DhvtaM+2BsPJ39ro8LQZECbZS+9tp5ewut2jExVTQ57vhDzc7JJkmvcuV7k1X9rtuLhe92h2Yx5sdGgGEWEilVWIaXLSGDOIEUGc0Qpidnoprz9qstEOzy32uZaBoRRpVqyOcXOuhIkiTHLavYSdXsxOmOCZCsc0qHk2VdfmxlwJ15ydw9AgNisgSXOSLGd1u0fJMfFMk/mKzc1GmWs1nyBK6YYZb73osNWNeNrs0Q5TtIa7C2WCuNjOrGY+F2Lgqq8EcNKYL87HXMkkTjXdKCeIU7pRTpxq5koyWuU8TWP9lTo3uknVk5n9JM46HOmgjgM4eUUclMOzjWJpIAXX68XSdTXfwlBFp4bWGo2mG6W729oOYn7l4RbvbHZpBTFBnO3OWx5+b5udiIWyg20aWIbCVIoX7bDIQN8o8eGVBtdrHmXXYqsTEac5plLUPWfPexNCTN5JY8xmJyLXsNWNAMVixeV6vcTb6x2aQXKmoZiDOLjTS+hGKc1uSLsXs7ETMV9xKTkKBXzxeRvHNLnW8PBti2fbIcqAm40SqNm5nDWI9wsVl50woReldKOUnSCml6S4pkWUZjzbCWj1EjJAAUGUsLbd49l2wErD43q9xLxvs1BxZRi4mHlXfVrENJ7gzYK679KJEoI4JYwzgjilEyXUfdnv52ka66/UudFNqp6MbQqJUupvAN8KrGutv6x/3zzw94G7wDvA79RaN8dVhuOcdjjScUn0TrOkzpzv8qjXxe53Viggy+G9y1V6SUYvyVAKXpkvthUmGW+utrAMg5JjkmaarW7EfNndTXwzeG/PWz2Wqx5aQStIiLOcsmOj+vsAimDxa6vb5DmUvGJJvsFSq8clwrrKy5cJMW1OGmOiNC9y4PSnqAHUfRtDQc2zRo6B++u5aSje2uigAd82Way6bLQjnm33ME2D912rMld2+OLzNo83A6IkxylZLFZM6iWbRslhoxMXSzTPEM82ubdUYaVR4pcevGBtu0jgWSvZNIOILz7f4Xk74pUFn7mSQ45mO0ioeYqFssvN+TK+Y7Iwf3VO0IQ4q6s8LUKWapyMZjem5FjkUUqswTKg5Fg0u7OTePqiTFv9lTo3uknVk3HmwPhbwP8X+NtD930f8HNa6+9XSn1f//afGGMZxuKojLkLFfdEJ/PDnSF3F8tstCPeedHlWs2j7GhKjkWtZO9m3F3pV/DNToTWYBiw0Y6Is5zBdUzT2HtCoJSCfRc5NXrPlU/PNpnzXfyGWTy+b5S59Vd5+TIhztt5dPid5GDvWgZBklHz3s15keYa3zVHTnK3v563w5TXH29xrVai4TukWTE67Nacj2cZvLpU2Y0jS9Ui385nnrYIooQXnRBLFStpvM+swb511WfJ050eixWH9XaPLz4LMC2DrW5MuxeD9qmWbHINlmGQphnvvV7lgzdqky62EOKCTdsJ3ixoBglZlqFUMXJZKUWWZTSDZNJFExdA6txoJlVPxjaFRGv9C8DWvru/HfiR/u8/AnzHuF5/nA7LmLvTS3jaDMg1xVKlmmOnYAx3hpQci1cWytxfrlIr2dxbrh46pCpKc0xTsbpdrFziWQamUjza7L70GstVl2YQF2XLNaaCXpyD1nvKdpo5X5KpV4jRDToCThIjzmqh4qKAXpyhtd7Ns1Nx7ZHnc+6v590oxTLMouNUKWzLwDGL1Y6UUnviiGMaaK2oeRaOaVJzHTzbwjQNWt2InXA2G4Or2z3aQYJpKLIcLNsiyzXaUFyreriWybPtHjrXmEoRZqBzZEqfEEJcgG6c0o5TXNukVrJxbZN2nNKN00kXTYipMal6ctGrkFzTWj8D0Fo/U0otX/Drn4vDMuYGSUrFK700MmO1GeDa5oFXXI/KdHtU79+gDApVjKagWBrVskzQezshVuZ8Hm0FmMogyXNMw2Cx6nKj7u1ODwmTjCjNebTZpexZLFVcTMMgTrMjeyAlU68QoxtlvfPz5tkmH1qp8+Zqi3Yvx3dNFsoOSjHyfM799TzOcqqeRRBnRGlGq5cQJcV80fddqxKnGWGS0QkTtnsJW+2IZhDj2xYlzyJJcxarLmFcLB/N7bmxvPdp9rzV40a9xDubXVCKpapDkkAv7FD2bZ61AkylSPOcOINbdY+lmjvW74oQQoiCqRSuYRElGbnOMZSBa1iYM5S3SYjjTKqeTG0ST6XU71dKfUIp9YmNjY1JF2ePw5K7+I790siMLM95tHX4FdfTZrpdqLikWc5i1cFQim6UkWaaD12vvpQUz7NNrtU8bs55LFRcrtVcXlnwqXgWO72Et9bb/OKDF2x2Im40PNDwzosuSb/z4qjh7ZKp9/KZ5rp11Y2y3vk4NHyH1+7Mc2exTK3kUHLME03z2l/PHdPAtUzSLOdps0eea9CQa+ilGe0w4fXHTR41A3zH5P0rNaI0J0hSsjxnoVLELUNxpRqDJ6lbSikWay6eY2IbEMY5cZbiuRavzPk4pkGuNc0goWwrFmseLzoRO73ZHLEiZpsct8RFa/g2lqXItSbLNLnWWJai4dvHP/mSkHolzmpS9eSiR2A8V0rd6I++uAGsH/ZArfUPAT8E8NGPflQf9rhJOCy5y2YnemlkxkYnouxah15xXai4uyuH2KbazXVx3BU2zzZ5Zd5nM4ipeAYLFYeG/+5JwX61kk2u7d1yALR7Cc0gxrYMaiUbhWI7SLheL+1u57gTnNOWX0zONNetq27U9c7H4SzzOffX87Jr0exGzJUcoiwninO00rznWplWkLDTS7m3WEEZijjNqXo295crRHFOvewQpzmWKuKS716dXDknqVvLVZfVVsiNeomSbbLRjmmHOe+/Vmax6rPW6uHaFg3f7v84bHbimVp2VogBOW6Ji1b3LHzHpF52UXmONgySJKXuXfSp0/hIvRJnNal6ctG18KeAjwHf3///Jy/49c/NQScDB53Md8OUu4vlPY8bnmJxlky3K3M+GnAs89jOg4PKttEOWap6u50Yg6R7zW7M9bo30jQQydQrxOgua4ff/nruOyav3ZnnzdUWJdfEtUzmyg7NbjFN5EVnb0zZDmLuL1X45DtNbjoWXtkgTHK6UcL9pcZk39yErPSn7qEgTnPuLFqst3rUfBfDgPder5Hlejc5Mv3s3lE23tE6QgghYLFWYqUek2qKBETKwPIdFmuzm3haiP0mVU/GuYzqjwPfACwqpZ4A/0+Kjot/oJT6fcAj4LvG9fpndZqVAg46mX9loYxp7L1itv+K62mvjO5/PSgWG1nd7u0p8+C9xJlmu9fDt4uVTRpltz+PPSXNNbapsExFL8lOdFVYMvUKMZrL3OE3XM8HMUUphaEUc+X+sstZjmUoyo5FmmlsS2EZRUyZL7vcv1bmS+s7bHZiFioOX3d/iYbvTPidTYZnm6zM+fTSNlXPItOa+8s1So6JbRUJmqMkpdkB0zSY8x2Wah5q/5JSQgghzt1yxSW+VuZXn7RoBSl13+L9t+osj5g7SohZMKl6MrYODK317zrkT984rtc8L2dZGnT/yfxgW3DyK66HdaIcdD/AW+ttuklGnmsMQ9EKYlb6J0uOZTLn21RcizjNdp+TZJqG77DWCgHQuUbBoWU8jyUghZhlF9Xhd9q6uv95ZdeiG6V7bg9iyvW6x5Nmj8dbXW7N+SiKVZPuLPg0g2INcI0mTXM+t9ri2U6P+bLLe5eraK14e6NDw3dmshNjsJ+XqyVuNoo4/Zkn2zzaCkBrNoOYKNJUPYOvuN0gyXN6cc7dBeksFkKIcWuUbX7yU9t0owQNNDsxn3x7my/7+sakiybE1JhUPZHJtAc4z6VBBycrhy2HOjDo6Hhro8PTZsD2YNnTfck/D7v/c89afH69w1orpBOlZLlmK0h441nr0PcySEZqKMW1mkua5+yECQsV98gyXuQSkEKIkzttXd3/vF6c8amHW7vTRnINb6y20JrdpZ9vz/u4drHkZ8WzCKKUN1ZbrG73eLjVYXU7IM5ygjhjqepR6k8xMU1F2bV5sNG+oL0yXYaPMzu9hM+vdfr5Q2LeetHleTMky1O2w5Rfe7pDEKUYFFNPhBBCjNcXn3XY6kV04pR2FNOJU7Z6EV981pl00YSYGpOqJ9KBcYDzXilg0Imx0ijmA61u9/acTBx0svHmaou8f5Iw3PHwYKP9UoeE1vCJt7fwLIOqawGKZjfBNOBZs3foexnuXMk1rNRLfO39Re4tVQ68UnueHTtCiPE5bV3d/7xunFJ2bbpR+m68ATrRuytheLbJ7Tmfhu+Qa7BMRcm2sA2DONF0whQNbAUxBsXfHdOkFSR4tkEnHO9a4dNq+DjzaCvANOFFOyLPoV5ysC2DIM6olyxSrYmSjEZ/qo4QQpzW/gtmchHqYJ94uEnJNliul7hRL7NcL1GyDT7xcHPSRRNiapy2npw1DkkHxgHGsTToUVdEDzrZ0Bo64d7l8mxT0QnTlzokOv1hO7ZRPN8yim20egnOMe9l0Ilxb6ly7BSZSS0BKYQ4mdPW1f3PKzo6DeKhxJG+bRJEew80SaYJkpQgSpnzXW7O+9yYK1FyTYI4I89zSrbBs52QOM0xDYiznDDJqVyhjO4nMXyc6UQpSZqDocg17PSKJKimZWAqE88y8GyLTEusFUKcnoykHd1OL8EzTeolh5rvUC85eKYpS1kLMeQ09eQ84pB0YBxgMLUiTnO01sRpvidvxGkcdUX0oJMN3zUJkpdPEiqe9VKHRBBl3Kh7BElKmmm01uhc0+4lvOda9Vzfy+OtgIebXZ5t9whPmOxTCHExTtsJu/95rlWsFuIMLd1pWwabnYgHz9s82w5o9xLiNMN37GL9734sawUJnmXgWiZhnHNnoUySajY6IUmak2aDVUiq5/jOL4/h40zZKUakVF0TrYo8RN0wIUwymt0It5/7yLdns7NHCHE+ZCTt6K7PlejGKc1uxE43otmN6MYp1+dkFRIhBk5TT84jDsmZ5wFGzVsxikEv05fW27xoh3t6lwZXRA862ai4dj+Z5t6Oh/tLL3dIKAV3lyo0fIc0z+klGWFazDd/dbFyLu8lTDLCuEjkZxmKPNc83uru5swQQkyP03bC7n9e2bHoRgll16IXp3zp+Q6febxNpWRjGtCNM9bbIQsVl5pnYShF2o9lcZajlKJeskGBZ1t86EaFKM150Y1ZrLi8dmd+JhN4wrvHmSTNUCg2dkIcy8C3zCKPUQY118I0Dcg1c2WbWsmedLGFEJeYjKQd3dfdX8Q0is7lF92QVpBgGiZfd39x0kUTYmqcpp6cRxySyzmHOI+VAoZXM6mXbOJUs9bqcb1ewrPN3U6LKMl4tBVQdi2Wqi6mYaAUfGilTjdKX1pu0bPNPcswfnClzmYnYqVeohMlBFGGUvDBlfpuR8VRK4rs9BKCJMV3bGqedeBqBZudiGrJoezZbAdx0fFim5QsQ+ZkCzFlTrtc6/7nlRyT1+7Ms9WNeedFlyDJeHWpjGdZxFnGrUYJQym6UcpCxWW7l9DsRvjaQlEMLaz5Np6heNbq0epGmCgWqy62JcuBhknG2k6IaSruLpV550WH9U7EtYpDrIvpgHcXyyxXXbRGOouFEGcyuGDmDMVfGUl7sHvLFW4tlHjwvE2YaHxHc2uhxL3lyqSLJsTUOE09OY84JB0YIzrNkoTDQ2Tmyi5rrRCFYqsTsVj12AkTlNZUSw53F8tsdCK+sNamVrKp+87uScH+1zmoc2XQqWEYiqXq8eUbdK5oDa1egqEUrSDCMhThAUvGRmmO75goZXC9XgwL0loTxDJvUohpdNpO2IOe141S7i9XedbqUbJNlCoOOs1uzPW6RxBneLbJ/aUKq7bJ88HjgDTN6CjFTi/iCy86zJds6r5JlGa82In4mvuLMzkKI0yyIllzDmFcTMG5VivR6qWs74S8ulRmvuzgGBadMOXV5YOTKwshxKgWKi4PNjoEUUquNYZS+K7F/SU5Kd/v6VYPy1DcmiuT5hmWYWIZiqdbPT5ye9KlE2I6nKaenEccki7XEZw22cjwEBnPNrle93AsxU6YYCgoWQbVkrO7HOFy1cN3LUxDMefbJ0pqcpJknPBu50o3TnFtE9+1cC2LbpQeOA9pHIlNhRCXwyCWuZZBmhdxwDIVcZa/lBT43lKF3/CeJX7z+5e5PVciTDRZBi86MSXLRKMI4pySbdGNMz632prkW5uYzU6E1sVUGw104xTLNFBolusellKUXJuSZ3JvqYplyIgVIcTZKa1hEE5U/7Z4yedWW1iGwd2lMu+7UefuUhnLMGb2mCXEQU5bT84ah+TscwSnTTay/6Tfs00WKh7vWa4WVziV2jMHaDuI8R0TDWNPrjQ4IRnktIB3T0gOmoc0jsSmQojLYRDLGr5DnOYkWU6S5v08PYfHgVaY8sqCz53FMpmGOd/Gd0y2ewmWoah6Fqut8GLfzJSI0hzfNenFGUFcrC6VZDmmYdAo2fieTdUtpvQFcSoJPIUQZzaYDvzKfJm7ixVemS9TLTmSxPMAYb+drPvNdK2Kefqh5AsRYtdp6sl5xCHpwBjBaZONHHfSv7+DI0pz0OzN+H/M65x2Hd3Baw9fUU0zjWMaB46sOM/EpkKIi3PWtbbh3VhmKMW1mkua57sJfI+KA1pr6Ic4y1AUHexq974009gzOrLAtQwqrk2c5qw2A160I1a3IxzbYL7iUXJMunGGbSrKniUJPIUQZyZJPEd3ve5hoGh1E55vR7S6CQaK63Vv0kUTYmqcpp6cRxySDowRnHb6xHEn/fs7OJSCIEmZK787H/yo1znLOrqD1y47FlGSEUQpUZpSdq1Dr6iedJqKEGKyzmOtbdgby3INK/USX3t/kXtLR+dluFYvESQpSZpze95nu5eyE8Y0fItenNGOiqWeZ9EgBpccA40miFMgo1ay0VqzXPO41ShRdW28ft4lIYQ4C5kOPLovu1Wnl2aYhqLmmZiGopdmfNmt+qSLJsTUOE09OY84JGNSR7BQcXnaDAD6w3w1cZqNlCDvqER6+zP+L/gOvTTHUAqt9bGvMzy1BdjN5rrZiY4t2/Br10s2QZJSdVx8xxwpQakQYvqdJUbsd5qkoCuNEr1+B+lcyeZW3aMdZxjKINea91yr8uqMJo/zbBPPKaaIfPmteZ42A2xLESYZvm1iAoahSPOcDw2tKCWEEKd1lvbsrFmqeHz07gJPmwFBkrHQPwYuVWQEhhADp6kn5xGHpANjBKddkvAk2x4YrHYyyusMVgYZluU5T1vhSKulDF775tyZ34YQYgodFCNsU13Y6kGDlUkGKzgt1jyaQUyS5lQ8i3uLsrLG7XmfKM2peCYb7RjXzMi15v612qHLWgshxGmMsz175SjFB65XKbsWnSil4lrcniuBms1pj0Ic6BT15DzikHRgjOi0SxKO83X2r6MbJhlPmj1cy8B3TJJM8/SAJVGFELPhPNbaPqtBTBtMZ7k9V97tcd/sRMVIhBmNT65l0AlTNrsxjmXyyrxPL85I85xXF8szu1+EEONzUe3ZS09rNjoxCxWXazWPNC9ur0gODCHedcp6ctY4JB0YU2gwCuOgURTDfwMI45RqycE2FevtECjmThermJx+uLgQ4vKbpuHCm52IXpLx1kaXbpxSdixuNLyZjk9l1+I/PHhBq5fg2QY1z6Hu29yol2Z6vwghxMQpRTtMeLzV3W2PN3wHGqVJl0yI6TGheiJZe6bMUUn39v/NNg20UiRpRhBnpGnOrX2jLSS7tBCza5pWD9roRHz+2Q5Zrql7Flmu+fyzHTZmdPm+MMl4ut0jTrIi1uewFUQkSSZxWwghJmwnTGh1I3JdrNCXa02rG7ETJpMumhBTY1L1REZgTJmjku4Vt/f+rebZuyclrmWQ703qKtmlhZhx0zJceK3Vw7FMSv2cHCUHkixnrdWD27OXiGezExFEKQs1D8swsAxFkuVkOWy0I1bkKp8QQkzMWqtH2XP2LGG900tm9pglxEEmVU/kzHbKHLU27nHr5u5fljVO80OXRBVCiItkKoWhIM01WmvSXGOo4v5ZFKU5udYslB3iNCfNNaaCOM3oRqnEbSGEmCA5ZglxvEnVE+nAmDJHrY173Lq50zRcXAghhs1Xih56pSBMc5SCWslmvuJMumgT4VoGhlKYymC55qIUdOIMw1S8Mi9xWwghJkmOWUIcb1L1RDowpsxRoyhGGWEx6MS4t1SRzgshxNS4v1QlzXIqjsVK3aPiWKRZzv2l6qSLNhELFRfftejGCUpDo2Qz5zvcnfdZmYIpP0IIMcvkmCXE8SZVT6QDY8ocNYpCRlgIIS6rhu/w2p15TBOaQYxpwmt35ots1TPIs03uL1VYafhE/Y7plbrHveWqxHQhhJgwOWYJcbxJ1RNJ4jmFjkq6Ny0J+YQQ4qQavsOvv7Mw6WJMDc82ubdU4d5SZdJFEUIIsY8cs4Q43iTqiYzAEEIIIYQQQgghxNSTDgwhhBBCCCGEEEJMPenAEEIIIYQQQgghxNSTDgwhhBBCCCGEEEJMPenAEEIIIYQQQgghxNRTWutJl+FYSqkN4OE5bnIReHGO25tWs/A+J/Ue72itlybwuudqX92a5u/LtJZtWssFl7dsV7FujdO0fM5Sjr2msRyzULfOc79P47amsUzTuq2LLNOlr1unOGZNS4wbJ3mPk3dg3boUHRjnTSn1Ca31RyddjnGbhfc5C+/xokzzvpzWsk1ruUDKNiumZV9KOaQc0+A83+80bmsayzSt25rGMl0ls7BP5D1OL5lCIoQQQgghhBBCiKknHRhCCCGEEEIIIYSYerPagfFDky7ABZmF9zkL7/GiTPO+nNayTWu5QMo2K6ZlX0o59pJyTMZ5vt9p3NY0lmlatzWNZbpKZmGfyHucUjOZA0MIIYQQQgghhBCXy6yOwBBCCCGEEEIIIcQlMnMdGEopUyn1KaXUP510WcZFKdVQSv0jpdTnlFJvKqV+w6TLNA5KqT+qlPo1pdRnlVI/rpTyJl2my0gp9duUUp9XSn1JKfV9Ey7LbaXU/9H/3v6aUuoP9+//75VST5VSn+7/fMuEyveOUupX+2X4RP++eaXUv1RKfbH//9wFl+n9Q/vl00qpHaXUH5nUPlNK/Q2l1LpS6rND9x26j5RSf7L/3fu8Uuq3XkQZL5vD6sW+x3yDUqo19Hn/mTGV5aU6sO/vSin1l/uf6WeUUl85hjIc+J3f95ix7I+Tfr/3PffcYu0h5fif+8f9zyilfkIp1TjkuUd+htPuoPe+7+8jfwdHrFvHbk8p5Smlfkkp9Xp/O3/2jOU613qmjmj7nrBcf1Qd0e4adVvqmHbqCbYzSiw4dFvHff5Kqf9GKaWVUouHvP7UtJ/O02H7RV3BY/n+unHV3uNBde1KvEet9Uz9AH8M+LvAP510Wcb4Hn8E+K/6vztAY9JlGsN7vAm8DZT6t/8B8HsnXa7L9gOYwAPgXv+78jrwoQmW5wbwlf3fq8AXgA8B/z3w30zB/noHWNx33/8EfF//9+8D/vyEP8814M6k9hnwm4GvBD573D7qf7avAy7wav+7aE76c562n8Pqxb7HfMNFHNcOqgP7/v4twE8DCvha4ONjLs/ud/4i9sdJvt8HlPPcYu0h5fhPAav/+58/LBYd9xlO+89B7/2038ER69ax2+v/rdL/3QY+DnztGcp1rvWMI9q+o26LEdpdJ9jWke3U08SRI2LBods66vMHbgP/Anh40Gdx3nV6mn4O2y9cwWP5/rpx1d7jQXXtKrzHmRqBoZS6Bfx24K9PuizjopSqURzcfxhAax1rrbcnWqjxsYCSUsoCfGB1wuW5jL4a+JLW+i2tdQz8PeDbJ1UYrfUzrfWv9H9vA29SNJqm2bdTHCDo//8dkysK3wg80Fo/nFQBtNa/AGztu/uwffTtwN/TWkda67eBL1F8J8WQS1Yvvh3427rwi0BDKXVjjK93od/5E36/h51rrD2oHFrrn9Fap/2bvwjcOu32p9khn8Gwkb+DI9atY7fX/1unf9Pu/+xPMneedWPkbY3Q9j1JuY5rdx27rRHbqafZV4fFgkO3dczn/5eA/5aXP8eBqWo/nacj9suVOpYfUjeuzHs8oq5d+vc4Ux0YwA9QBKN8wuUYp3vABvA3+0Oi/rpSqjzpQp03rfVT4C8Aj4BnQEtr/TOTLdWldBN4PHT7CVNyYqSUugu8RnElC+AP9Yd//g11wdM0hmjgZ5RSn1RK/f7+fde01s+gOOgDyxMqG8B3Az8+dHsa9hkcvo+m9vs3rQ6oF8N+gyqGsP+0UurDYyrCQXVg2EV/pvu/88MuYn/AaDHgovfL/5niqvNBjvsML7tT7esj6tZI2+sPRf80sA78S631qbbTd5717Ac4uu070rZGbHeNsq1R2qmn+QwPiwWjfn536X/+SqlvA55qrV8/4vVm4vi1r15ctWP5D/By3bhK7/Gwunbp3+PMdGAopb4VWNdaf3LSZRkzi2Jo5f+itX4N6FIMD7pS+idj304xxGkFKCulvmeypbqU1AH3TXxpIqVUBfhfgT+itd4B/hfgPvARiobTX5xQ0X6j1vorgW8G/mul1G+eUDleopRygG8D/mH/rmnZZ0eZyu/ftDqgXgz7FYqh078O+CvA/zamYhxXBy7sMz3gOz/sovbHqC5yv/xpIAV+7JCHTG0cOycn3tfH1K2Rtqe1zrTWH6EY+fLVSqkvO0O5zqWejdj2HXVbo7S7RtnWKO3UE32Gx8SCY7c1/PlT1J0/DRyXN+fKH7+OqRd7HnrAfVO9L05xXnjp3iMnPye8NO9xZjowgN8IfJtS6h2KYV7/iVLqRydbpLF4AjwZ6vn/RxRf3qvmm4C3tdYbWusE+MfA1024TJfRE4p5ngO3mPBUHKWUTXHA/DGt9T8G0Fo/7zcOc+CvMaEhbVrr1f7/68BP9MvxfDActf//+iTKRtHQ/RWt9fN+Gadin/Udto+m7vs3rQ6qF8O01juDIexa638O2OqQxHNncUgdGHaRn+me7/y+cl7I/ugbJQZcyH5RSn0M+Fbgd2utD2x4jvAZXnYn2tfH1a2Tbq8/RPvngd922u2cYz0bpe076rZGaXeNsq1R2qknrS+HxoLjtnXA53+fopPm9f5+uwX8ilLq+hnLeKkcUi+u0rH8sLpxld7jYXXt0r/HmenA0Fr/Sa31La31XYphZv9Ka33lrthrrdeAx0qp9/fv+kbgjQkWaVweAV+rlPKVUorifb454TJdRr8MvFcp9Wr/CsZ3Az81qcL0P8sfBt7UWv9/hu4fnvv6ncCB2efHXLayUqo6+J0iYd5nKfbXx/oP+xjwkxddtr7fxdDw2WnYZ0MO20c/BXy3UspVSr0KvBf4pQmUb6odVi/2PeZ6/3Eopb6a4vi+ec7lOKwODPsp4HtV4Wsphpk/O89yDNnznd9X1rHvjyGjxICxx1ql1G8D/gTwbVrr4JDHjPIZXnYjfwdHqVujbE8ptaT6q74opUoUJ/ufO025zrOejdj2HXV/jdLuOnZbI7ZTTxpHDo0FR23roM9fa/2rWutlrfXd/n57QpHQcm3fdqeq/XSejqgXV+ZYfkTduErv8bC6dvnfo56CTKIX/cMFZWuf4Pv7CPAJ4DMUw2bnJl2mMb3PP0vRQPgs8HcAd9Jluow/FBm6v0CRbfhPT7gsX08xXO0zwKf7P9/S/3x/tX//TwE3JlC2exTZmV8Hfm2wr4AF4OeAL/b/n59A2XyKk7P60H0T2WcUjchnQELR8Pt9R+0jiqG6D4DPA988ye/ftP4cUS/+APAH+o/5Q/3v5esUCRy/bgzlOKwODJdDAX+1/5n+KvDRMe2Tg77zY98fJ/l+Uwyz/+dDzz23WHtIOb5EMX958B35/+0vx2Gf4WX6OeS9n+o7OGLdOnZ7wFcAn+pv57PAnzlt3RhXPWOo7XuG/fVSu+uU7/Ej7GunnqFMx8WCQ7d12Oe/b/vv0F+FhDHW6Wn6OaJeXMlj+b66caXe4yF17dK/R9UvrBBCCCGEEEIIIcTUmpkpJEIIIYQQQgghhLi8pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANDCCGEEEIIIYQQU086MIQQQgghhBBCCDH1pANjyiil3lFK9ZRSHaXUc6XU31RKPejf7iilMqVUOHT7Tymlfm///o5Sakcp9bpS6lsP2PZ/r5TSSqmv7t/+3UPb6Sml8qHbnaHyfNPQNm4ppX5MKbWplOoqpX7poNcS4qrbV1ebSql/ppS6PelyCTFN9h9Dhu7/U0qpt/v154lS6u/37/+1o453/ce82j9e/eDQ9jpDP/lQ3ewopX73xb1jIcan34770UmXQ4irROrV5SMdGNPpd2itK8BXAl8F/EOtdaV/378B/tDgttb6f+w/5z/0/94AfhD4e0qpxmCDSikF/B5gC/gYgNb6x4a2+83A6tB2K/sLpZSaB/4tEAMfBhaBvwT8XaXU/+n8d4MQU29QV28Az4G/MuHyCDH1lFIfozgefVO//nwU+DkArfWHRzjefS/QBL5bKeX2nzd87HpEv272f37sgt+iEOIUlFI/pJT6fL8T8vdOujxCXHZKqfcppX5SKbWhlNpSSv0LpdT7J12us5IOjCmmtX4K/DTwZSd4Tg78HaAMvHfoT78JWAH+MEWjzzlFkf4o0AF+n9Z6TWvd01r/OPDngL/Y7yQRYuZorUPgHwEfmnRZhLgEvgr4F1rrBwD948kPneD53wv8d0AC/I4xlE+Ic6GUsiZdhkvmdeAPAr8y6YKI6SX16kQawE8B7weuAb8E/OQkC3QepANjivWHo38L8KkTPMcE/kuKht3DoT99DPgnwN/v3z7NtI/fAvyv/U6SYf8AeAV43ym2KcSlp5Tygf8c+MVJl0WIS+AXge9VSv1xpdRH+8etkSilfhNwC/h7FMee7x1TGYU4lf60qT+hlPoM0FVK/Xf9qcBtpdQbSqnvHHrs71VK/Vul1F/oT0V8Wyn1zUN/f1Up9a/7z/2XFCNfh1/r2/rTrraVUj+vlPrgvnL8caXUZ/pTfn9YKXVNKfXT/e39rFJq7pj3crc/9fhjSqlHSqkXSqk/PfT3v6WU+n8P3f4GpdST05ZBa/1XtdY/B4Qn3vHiSpN6dbp6pbX+Ja31D2utt7TWCcXI+fcrpRZO8zlMC+nAmE7/m1Jqm2K6xr8G/sejHw7A1/afEwJ/AfgerfU67J5cfRfwd/tf3n9EfxrJCS0Czw64/9nQ34WYJYO6ukPRwfc/T7Y4Qkw/rfWPAv9X4LdSHOPWlVLfN+LTPwb8tNa6Cfxd4JuVUsvjKakQp/a7gN9OcfXz8xSjYOvAnwV+VCl1Y+ixX9N/zCLwPwE/rNTuiNa/C3yy/7f/F0NtN6XU+4AfB/4IsAT8c+CfqL0jbP8zimPT+yhGK/008Kf62zOA/9uI7+frKa7gfiPwZ4ZP6EZwXmUQQurV2cvwm4E1rfXmCV5r6kgHxnT6Dq11Q2t9R2v9B7XWvRGe84ta6wYwRzFU6DcN/e07gZSiEgL8GEWjb+mE5XpBMdd/vxtDfxdilnxHv965wB8C/rVS6vpkiyTE9OvnYPomioboHwD+B6XUbz3qOUqpEkVn/I/1t/EfKPJd/BfjLa0QJ/aXtdaP+1Nt/6HWelVrnWut/z7wReCrhx77UGv917TWGfAjFG2qa0qpVyimW/0/tNaR1voXKEbSDvznwD/TWv/L/sWpvwCUgK8besxf0Vo/709J/jfAx7XWn9JaR8BPAK+N+H7+bP+9vE4xzePXnWBfnFcZhJB6dYYyKKVuAX8V+GMneJ2pJB0YV4zWukMxf/D3KKUGX96PARXgkVJqDfiHgE3Rk3kSPwv8Z0qp/d+b3wk8Br5w6oILcYlprTOt9T8GMooedSHECLTWidb6HwKf4fh8T98J1IAfVEqt9Y9nN5FpJGL6PB78opT6XqXUp/vD0bcpvufDI1bXBr9orYP+rxWKvGVNrXV36LHDU4NXhm/3p/c+pqgTA8+Hfu8dcPulhO2HWBv6PTjB886zDEJIvTplGfoXrX8G+MF+/sJLTTowrqD+sKC/TjEc6SbF0KRvBT7S//l1wJ/n5NNI/hJF4/GHlVLXlVKeUup3AX8a+ONaa30+70CIy0UVvp1iBNSbky6PEFPG7h8vBj//lVLqtyulqkopoz83+cPAx4/ZzseAvwF8Oe8ez34j8BGl1JePsfxCnJQGUErdAf4axQi9hf6Ivc8CoyQ9fwbMKaXKQ/e9MvT7KnBncKM/PP428PRMJT+ZLuAP3ZYRiGKcpF6dQj8fxs8AP6W1/nNn2da0kA6Mq+sHKBKA/j7g01rrn+lnel/TWq8Bfxn4CqXUSVY42aS4uuwBbwCbFMOQfk9/+JYQs+afKKU6FDkw/hzwMa31r024TEJMm39OcUVo8PPHKObqPgK2KeYn/1+01v/2sA0Mdcb/wPCxTGv9SeB/53R5nYQYtzLFSdcGgFLqv2TEleW01g+BTwB/VinlKKW+nr2r7vwD4Lcrpb5RKWUD/3cgAv79OZb/OJ8GvkUpNd+fPvlHzrKx/vv0KE5EBx2fcq4i9pN6NSKlVA34F8C/01qPmmtq6skyNFNGa333mL9/wwH3/S3gb+277wnFvHyA/+GA56xSTCMZ3P55iszuR5ZHa/2Ik089EeLKOa6uCiHOVk+Gj3f9eb4Htlm01t9yXq8pxHnSWr+hlPqLwH8AcuBvA//uBJv4Lyjm72/1t/G3KfLGoLX+vFLqe4C/QjG8/dPA79Bax+dV/hH8HeCbgHf6P3+T4oTvtH4G+I/6v38d8EPAfwz8/Bm2Ka4YqVcn8p0UOT8+rJT6vUP3f6h/TncpKRn1L4QQQgghhBBCiGknw7KEEEIIIYQQQggx9aQDQwghhBBCiBmklPrdSqnOAT+Sz0mIU5J6NV4yhUQIIYQQQgghhBBTT0ZgCCGEEEIIIYQQYupdilVIFhcX9d27dyddDCF2ffKTn3yhtV6adDnOSuqWmDZSt4QYD6lbQozHVahbUq/ENDqsbl2KDoy7d+/yiU98YtLFEGKXUurhpMtwHqRuiWkjdUuI8ZC6JcR4XIW6JfVKTKPD6pZMIRFCCCGEEEIIIcTUkw4MIYQQQgghhBBCTD3pwBBCCCGEEEIIIcTUkw4MIYQQQgghhBBCTL2xJvFUSr0DtIEMSLXWH1VKzQN/H7gLvAP8Tq11c5zlEEIIIYQQQgghxOV2EauQ/Mda6xdDt78P+Dmt9fcrpb6vf/tPnOcLbgcxDzbadMKUimdxf6lKw3f2PCZMMjY7EVGa41oGCxUXzzaP3O5Bz3n4osPPfm6NF+2YxarDN33gOu+/UT/Pt3NujnrPp9kfF+Hzz1qXZv8KcRUdFzdWt3s8b/XYDGI2OyGmMmh4Nkt1lzDRPN7s8nCzzWYnIdeaOwtlfv3dBb7iduOluHzVhUnGajNgvR2hteZavYSh4DNPtnlro8NmK8S2DZaqHu+5VmWp6hImOVGS4domdd+h5lmHxufDPqvB/TthShAn+LZFrWRPTZwX4qoajpFKKeqehesUTe/D2lrDcWK37pfsE9fZ4+r94O8bnYi1Vg9TKeYrzm6b+aB4tdIo7T53+H0tV11W5vw925229qQ4nV9+e4Of+NRTNtoRS1WX73ztJl/16vhXjF1r9fj04ybbQULDt/nI7Tmu10tjf91JnXdIvTmZSUwh+XbgR/q//wjwHee58e0g5lMPt8gymPMdsgw+9XCL7SDefUyYZDxtBuQafMck1/C0GRAm2aHbPeg5/+YL6/zIv3+bKNHcbHhEieZHP/6Qzz9rnedbOhdHvefT7I+L8PlnLX704w8vxf4V4io6Lm482Oiwuh3QjhJ+9dE2662YXpzy1maHf/L6Kq8/3uKTj7d4c7XDWrtHN0750nqbX3zwgl/4wsaeuHzVhUnGW+ttVlshjmXgWiaffbLNj3/8IV9cb/O82eVZO+TRVo/nOz1+4Qvr/Mwba7TDhFYvYXU7YH2nRxBnB8bnwz6r7SDmaTMgiDNaQUSWQauX0DtkO0KI8zEcI13LRKP51dUd3tloYygObGsNxwmNfrfut8MT1dlBPDis3g/iQjOIefC8TZJq4jQniDI+9XCLtVbvpXi1uh3wYKPTv0j47vtyLIPVVshb6+3d7U5be1Kczi+/vcEP/vwDwiTnVsMjTHJ+8Ocf8Mtvb4z1dddaPX7uzTWSVLNcdUlSzc+9ucZaqzfW153Uece0nodNs3F3YGjgZ5RSn1RK/f7+fde01s8A+v8vn+cLPthoU3ZtfNfCMAx816Ls2jzYaO8+ZrMT4fSDrlIKxzJwLJPNTnTodg96zi+/8wLXMlmouNhWcVVsznf42c+tnedbOhdHvefT7I+L8LOfW2POdy7F/hXiKjoubgRRStmxefgioO7bzFccWr2UONN4lsEbqy1UprAshWua+I6Na1u0wmR3pNys2OxEdJOMsmsV+9Q2ebrdI05zWkFErA0Wqh4N32a9E5PnkCQ5b2928V2LeqkYjdGN0gPj82Gf1YONNo5l0o1SXMvCdy1c26QbH7wdIcT5GI6Rjm3Si3NqJZtEw3aQHNjWGo4TvSSn7Nnv1v0T1NlBPDis3g/iwrPtkLJbjO7wHIsk15Rdm08/br4Ur8qOTRClPNho73lfjmVSdi26Sba73WlrT4rT+YlPPWXOd1iqeji2zVLVY853+IlPPR3r6376cZOa51Ar2ZiGQa1kU/McPv14vBkHJnXeMa3nYdNs3B0Yv1Fr/ZXANwP/tVLqN4/6RKXU71dKfUIp9YmNjdF7+jphimfvfVuebdAJ093bUZpjm2rPY2xTEaX5ods96Dnb3RTX2ntfzTN50Z6+q4pHvefT7I+L8KIdU/P2Dp+a1v17mZy2bonZc1zcyLXGMhU7/bhrGoo4K67k2YZBq5eSo9FaYxiQozGVIs4ysjzfE5evgqPqVpTm5LnGMt7dn904xVQQppos05gKHEvRi1O0zgFNO0yxDIVpQK41cZYfGJ8P+6w6YYptKuIsx+r/3TLU7uMnHeeFGMVlPG4Nx0iAOMtxTUWeF/UYXm5rDceJOM0xFbt1/yR1dvDYw+r9IC5043fbsaaCOM3xbIPtIHkpXlmmIteaTpjueV+Dbee53t3uMIkz0+u4erXRjqjva4fXPZON9nhPrLeDhLK793XLrsl2kIz1dSd13jGt52HTbKwdGFrr1f7/68BPAF8NPFdK3QDo/79+yHN/SGv9Ua31R5eWRp9rVfEswmTvBx4mORXv3XQfrmWQZHrPY5JM41qH746DntMoW0Tp3vt2wozF6vTN6z7qPZ9mf1yExarDTrh3+NS07t/L5LR1S8ye4+KGoRRppqn1426WaxyzuHqQ5Dn1koWBQilFnoOBItMaxzQxDWNPXL4KjqpbrmVgGIo0f3d/lh2LTINnKUxTkWmIU03JsVDKABRVzyLNNVkOhlI4pnFgfD7ss6p4FkmmcUyDtP/3NNe7j590nBdiFJfxuDUcIwEc0yDKNIZR1GN4ua01HCccyyDT7Nb9k9TZwWMPq/eDuFB23m3HZhocyyBMchq+/VK8SjONoRQVz9rzvgbbNgy1u91hEmem13H1aqnq0trXDm+FGUtVd6zlavg23Wjv63ajjIZvj/V1J3XeMa3nYdNsbHtGKVVWSlUHvwP/KfBZ4KeAj/Uf9jHgJ8/zde8vVWl2I97Z7PBos8M7mx2a3Yj7S9XdxyxUXOI0I05ztC6uFsZpxkLl8Ap50HO+6u4iUVokXUnSlM1ORDOI+aYPXD/Pt3QujnrPp9kfF+GbPnCdZhBfiv0rxFV0XNzwXYtunHBn0acVJGx1YuolC8dUhGnOe5erdNOEnSCm1YtphzFRklL3bBq+sycuX3ULFZeyXQzpjtOMOMm42SjhWAZ138VROZvtkO0gYbniYBhg2wavLpQJopRWL8KzDSxT8WSry06Y7pkje9hndX+pSpwWQ8GjNCWIUqIko+xYUxHnhTgPgznkb210pmbu+HCMjJOMkmOw00uwVXGCdlBbazhOlGyDbpjs1v2T1NlBPDis3g/iwo2GRzdK2OklhHGKbSi6UcJHbs+9FK+6cYLvFonxh99XnGZ0o5Sybe5ud9rak+J0vvO1mzSDmI12SJwkbLRDmkHMd752c6yv+5Hbc+yEMTu9hCzP2ekl7IQxH7k9N9bX/aYPXOfFTsjbGx2ebQW8vdHhxU449vOOaT0Pm2bj7Nq5BvxbpdTrwC8B/0xr/b8D3w/8FqXUF4Hf0r99bjzbZKnuYVAMvTFQLNW9PZlcPdvk5pyPoSCIMwwFN/vZk4/a7v7n/Kb3LfPdX/0KUZryxrM2UZryXb/+1lSuknHUez7N/rgI779R53u+5g6urXi6HeLaiu/5mjtTuX+FuIqOixv3lyqsNHyqrs2Xv9Jgue5QcizuLVT4rR++zs15nw9fr/Oea1XKjkMQ58xXXF57ZY7f/L6lmVqFxLNN7i1XWal7xGlOlGZ82a0Gv+tr7vDe5SrX5srcqHqs1D1Kts37rtX4ytvzOKZBvWSz0vCp+w47vYTFqsecb+9J9HXYZ9XwHW7O+fiOSd13MU2ol2xKjjkVcV6Is5rWBHjDMTJKMxSKL1+pcXepSq45sK01HCcUarfuL1e9E9XZQTw4rN4P4sKc73D/WhXbKkbO+a7Ja3fmuV4vvRSvVho+95cqeLZJyTLIcni6HdDuJazUPe4tV3e3O23tSXE6X/XqEn/wG+7j2QZPtkM82+APfsP9sa9Ccr1e4hs/eB3bUqy3I2xL8Y0fvD72VUjuLFb4+vcuEyUZ7zS7REnG1793mTuLlbG+7rSeh00zpbU+/lET9tGPflR/4hOfGOmxg4OYMzTsJk7z3S/DeRocNB3LxDYVSaaJ02xqv3SyRM/5UUp9Umv90UmX46xOUreEGMUgzjzeCjANRd23aXZjHLPIwp9pzXy/kXtQ/JnlujVYgaCbZOT9Idnl/gmNZ5sXenwTV89VrVtXvV5MU9vtsrV7L8pVqFuHHbOm6fs3bm/1V9cpOzaWWUyT6sYJKw2fe0vj7cQQBzusbl25yTUXmQjlMmWNndYrFEKIq2M4zigFplJ8ca2N1mBbBrZpoDVTGycnbbUZsBUkWIaB71hYhsFWkLDaDABJ9CXEQa5yvZi2tttlaveKs5u279+4PW/18G0Lu//9ti0D37Z4PublW8XJXbkOjItMhHKZDppy0BFCjNtwnPFsE2UoNBDExWojgyRy0xonJ229HeE7JrbZbzyZBr5jst7P+C6JvoR42VWuF9PWdrtM7V5xdtP2/Rs3pRSo/Xf27xdT5fJH930uMhHKZTpoykFHCDFuw3Gm4TvEaY5lKIIwJcly4jSn4TtTGycnTWsN+2d16v79SKIvIQ5ylevFtLXdLlO7V5zdtH3/xm256hLEGUlWxJIkywnijOUxr7oiTu7KRZyLTIRymQ6actARQozbcJzxbJPrdY+qZxNlOWmec63mYig1tXFy0q7VSwRJStI/piRpTpCkXOsnLpNEX0K87CrXi2lru12mdq84u2n7/o3bypzPvG+T5jlBnJLmOfO+zcoVyKVz1ViTLsA4DA5mF/U6m52IIM5wLWNqD5oLFZen/XnU+xMvCSHEedgfZwyluF73+PDNOt0oLa7mXKGTi/O20ijRSzKCKCXONIZSzJVdVhrvZl6/qOObEJfJVa0X09Z2u0ztXnF20/b9G7fBKkCzkrT0MruSHRgX6bIcNOWgI4QYt6PizCwtmXpag2UXpfEkhIDpbLtdlnavOLtp/P6Nm3y/L4erOQZICCHEhZul5daEEGLcJKYKIcTLpANjRszaUkhCiIslMebsZB8KIQYkHohJk++gmFbSgTEjZm0pJCHExZIYc3ayD4UQAxIPxKTJd1BMK8mBcY6meahflOb4zt6y2KYiiKUXVQhxdlGaYyhYa70bA+slm2T/sqBij+HjxvpOyPW6x/C1BYnTQsymq9Bum+Z2sTieHNfFtJIRGOdk2odZzdpSSEKIC6Y1T5o9cg0lu4iBT5o90NLSOcz+44ZpKJ40e3uOGxKnhZhNl73dNu3tYjECOa6LKXU5ouAlMO3DrGTtbiHEWCkFaBi0a3T/H6UmV6Ypt/+4sVzzAM16O5Q4LcSMu+zttmlvF4sRyHFdTCmZQnJOBsOsnm1HxFmOYxo0/OkZZjWLSyEJIS7WrTmf7SChl2Q4psFS1eV5qwcgw4cPsH+IuGebLFVdvrDWJohSKp7F/aWq7DMhZtB5tdsmNY3jKkyBES8f12/N+eQXcG4j04/EUaQD4xw9aQaUHZuSbZJmmifNgJXG9KwlLGsbCyHGxbUMcg03GiWgaHw83uri2ia+Y5JkmqfNQDpOhwyGiDtWcTUrTDI22hHXGyVuz/kkmWazE+HZpuwzIWbQWdttg2kcjnXxcXh/fIPLNQVGvHxcB4jTHHvMAzAm+b0Vl4NEkfOiNaBgUKlV/58pmic2CAhvbXRkHqIQ4lztH+78pBmw0Y6Jkpy1VkiutQwf3mf/PlvfCQFF3bNZa4U8a/XY6sasbvcmXVQhxJQ4SVtuktM4LvsUGDG5z3CzE5Hr4v9HW8Ge20KAdGCcH6W4NVfCUNBLMgwFt+ZKUzNPTJIpCSHGaXCl0FDQDBKebfe4XnOpl2y0hrVWjyzPidJ80kWdGsP7LIgzslyzVHFoBjG6nzTNVIpHm12J1UKIE7flojTHNve2Q21TXUgc3h/fDIVcQb9kJvUZ7oQpm51w9zioNWx2QnbCdKyvKy4PmUJyTgbDrK7XL3aY1aiGe+GB3SF9m51IppUIIc7F7nDnZsCdxTKWUVz1s/vxZqMdsTI0FFXsHSLuWgar2z0c08Tux2plKMqeJbFaCHHittykp3HI1OXLbxKfYRAnGMrYPQ7aliLJDII4udByiOklIzDOybQPlZtkL7wQYrZEac5SxSVOc5KsiIkaTTdKpyYmTqOFiks3StFotNYkWU7c35cSq4UQJ23LTXvbVIiD+LZF3j8GDo6Fudb4tlx3FwX5JpyT88gWPc6Mu5PuhRdCzI7BiLQ53+bRVkAnSnEsg1fnZfjwQYZjv2MbhHFGahXx+Xrdw1BqakbzCSEm56RtuYtYgU5WixDnrVayybXmWSukE6VUXIsbdY9ayZ500cSUkLPXczQ4UNxbqpyq82KcOSpO0gsvyT6FEGexUHFp92LW2xHzZYflqkucZDxu9nhrvS0xZchw7DcU6FzzzmaXOM2pl2wMpeSKqRACOF1bbpAEeKVRGkvnheRXu9omcU5Qdi3Wd0Jqns29xTI1z2Z9J6TsynV3UbiSHRiX8QR83JmiR03EIwcjIcRZebaJ51i4lsF2kPBgvUOuQQOrO6HElCGbnQitYbUV8KlHTbpRzs25EjthwjsvuiRZLonvhBBAEVsXKi7r7R6fX9thvd07cMTDRbXlJrnKiRi/MMl4a73NaqvHRjtktXUxFyG6Ucqt+TKOZRCmOY5lcGu+TDeSJJ6icOW6si7r2sFRmuM7e8tnm4ogPr8gMUoiHkn2KYQ4L0tVl+c7IUtVD882SLKcjZ2I61VPYkrfTi+h1f+pujYoCKKMWsnmzkIZQzHVxy4hxMUZTNdYrpa42VAkmWazExWdxkNx4qLachfRdhWTs9oM2AoSyq6FZSnSXLMVJHjNgHvL1bG9bpTmVD1rz5QRrbV8r8SuK9eBMbxWcJzlOKZB2Z3+DO7TkqNCDkZCiPPgWgYPX3TZ7MT9q3IGJcfEd006UYJhSFIHgCBJMZRCA5apUKpoJIZJdqLYK/PQhbj6RumYCJOMx1sBqt/52fAdPNscS1tuWtquYjzW2xGmAc0gJu6PhCjZBuvtaKwdGPK9Ese5ct+Ey7p28LRkih4EjWGnCRqXcRqPEOL8lF2Ldza7GAosBUmW82QrIIpTvvS8QzOIJC4AvmOT6xxFMWx2bafHs+0enSihE6YjxV6Z+ifEbDhuFZJBLDANhW0UyZTXWiFhkp3bCeBw+y5KMnbCZOJtVzEeUf+z3miHNLsxG+1iCmg05mPLtJwTiel15TowhtcOVkphWwaGmv61g0fNUTFu5xE0pDEthOhGKXcWyjTKDt0kI8s0lqFodlM826DmORIXgJpnsVDxKLsmj7cC0hSWqg62YfJ4qztS0jKZhy7EbDjuItMgFizXPJI8B110cKy3w3M5AdzfvrMtE9Vf5nKSbVcxJgo2dkJ0Dq5toPPiNmMeQDkt50Riel25DoyLXjv4PEcanGUVk/NyHkFDGtNCiCgtklEuVz0+cKMGWtMKE57v9GiUXYkLfQsVlzjL2QkTlmouhpETRBmLVWfkpGXHXZUVQlwNx11kGsQCzza5Xi+h+qPf0vR8kgEP2ne51qy1Qp61enT701Im2XYVY6JhqVp8j6IkQ6niNvr4pwoxTlcuB0atZGObBt04pZcUa14vVlxKzvkH1MuaMPQ4oyT7PIrk0RBCuFYxfPl63WNtp0cnTlmuuMVoA8dirdXjWs0jkYYQSmvSRFOyLaquQ8kxuF4v4VrGSHFT5gsLMRsG7bPNTkQQF23c4TbncCzwbJMbjRJxmp9bMuCov63nOyGOaVKyTZI059Fml5VG6VK3fcXLXNvk5nyJXpzv5hUsOQZqzEMwrur5lTg/V651s1BxUQrmyy6vzPvMl4vb45g3JSMNDnZeeTSEEJfX4EqhoRSOYXBz3qfmOyzVXGzLwDFNNtrRzMeFzU5EteRwZ6nMjUaJlbkSFdem2Y1HjpsyX1iI2XHUaN1xxwLXMthoRzimuTtVWxmKsmfNfNv3KlquumQ5zJUdbjZKzJUdsry4f5zk/Eoc58q1HC9y3tRlG7Z7UYk1pTEthIBimuzTZsDbL7rUXYtGySlW3NAajaYbpTMbFwbx+EvrbTY7ISXbJE5zkizHNKAbpyPHTZkvLISAl2NBkhUJgle3e+fS7luouHSjFI3enaYdpzlLFXdq277i9FbmfOZ9mzTPCeKUNM+Z921Wxryq4yTPr2QRgsvhyk0hgbNPgRjVZRq2e5HDsY4b4iiEuNqG483dxTKmUTQ8lqsuvSSj159L+8r8bMaF4f1T82ziVBOlCXO+TS/J6IQpnnOyuHlRxz0hxHQbxILhOGOb6lzafZ5t8sq8z2YQk/anaV+vexhKYcvK2FeOZ5vcW65e+BLdkzq/kqkrl8eV7MC4KAsVlwcbHYIoJdcaQyl81+L+UmXSRXvJKGuHnydpTAtxtYVJdmijZn+8Wa55PN7q0goTbs/5JJkmTrOxX8WZVsP7Z77istbqoVAEccpCxaPiWrvx82kzuNCGoxDiahi13XdULD/IypyPhj0dI3GaSZtPnJuFisvTZgBwod+xiz5XEqc3fUMFLhml9bvLCan+7Sl02aa7CCGm13FLJe+PN55tcmvOJ01lqT3Yu38GqwXYpqLVS3b3DSDLUQshTm2Udt9plr2XKWuz4zTfj/Mwqe+YnCtdHjIC4wwGydcWqu/2A8VpPpU9dZdpuosQYrodd5XioHhjGgavLJSnLjZOwv7949kmi1WP5Zq3p/NCrgQJIU5rlHbfaa84yyjb2TDJEQmT+I7JudLlIZ/IGVymnjpJrCmEOC/HxT6JN0cbZf9cpuOLEGL6SJwRZzVr3w9pu1weY+/AUEqZSqlPKaX+af/2vFLqXyqlvtj/f27cZRiXy7RcqAz5E0Kcl+Nin8Sbo42yfy7T8UUIMX0kzoizmrXvh7RdLo+LmELyh4E3gVr/9vcBP6e1/n6l1Pf1b/+JCyjHuZtUkpnTkiF/QojzMErsk3hztOP2z2U7vgghpo/EGXEWs/j9kLbL5TDWLjSl1C3gtwN/fejubwd+pP/7jwDfMc4yjNNV6qmTdY+FEKM6TeyTGHMyso+FEOO2P84kaYZSitXtnsQQcaXOc0Ylx9HLYdwjMH4A+G+B6tB917TWzwC01s+UUstjLsNYXYWeOln3WAhxUieJfRJjTkf2sRBi3AZxZjeGmMbu1XaJIeIqnOeMSo6jl8fYRmAopb4VWNdaf/KUz//9SqlPKKU+sbGxcc6lE8OGswwrpXAsA8cy2exEky6aGAOpW+KizUqMmWTdmpV9LGaTHLfGT2LI7JF6tZfUgctjnFNIfiPwbUqpd4C/B/wnSqkfBZ4rpW4A9P9fP+jJWusf0lp/VGv90aWlpTEWU8xaluFZJ3VLXLRZiTGTrFuzso/FbJLj1vhJDJk9Uq/2kjpweYytA0Nr/Se11re01neB7wb+ldb6e4CfAj7Wf9jHgJ8cVxnEaGYty7AQ4mJJjBk/2cdCiLOQGCJmndSBy+MiViHZ7/uBf6CU+n3AI+C7JlAGMWR/luF2mLLRDpnzHSBgoeLK3C8hxKkNYkyYZHTChCDJUMCHVuqTLtpUCpOMzU5ElOa4ljFSDJ7FbPFCiJM5KrZIDBGzbqHi8mCjQxCl5FpjKIXvWtxfqky6aGKfC+lS0lr/vNb6W/u/b2qtv1Fr/d7+/1sXUQZxuOEsw80g4UU7ZLnqMVd2yDWShVcIcSaebbJQcXnRDunFGWXHZLnqsdmJJLbsM0gilmvwHXPkGDyL2eKFEKM7LrZIDBEClNYwmEWi+rfF1JnECAwxhXazDDcDKq6F0x8u5VhFLd7sRNILL4Q4tW6Ucmu+vBtbAOI0l9iyz3ASMThZDJ6lbPFCiJMZJbZIDBGzbLMTUS05LFSlnTLtZFKP2EMS2AghxkFiy2hkPwkhxkFiixBHkzpyecgIDAG8Oy/yeauHZRksV73dYYOSwEYIcRZhktEMIta2c8qeRcN38GxTYssBBknEBldHwyRjvR2SniAfhhDicjhNvpvT2h9bQNp34ngX+R2dNKkjl4d0YMyQw4LQYF6kY5ncaJR40gx4vBVwa66EaRiSxEkIcSphkrG63ePRZhfbNMjynCjJebbdY7HiovpzrGfdcGwGCOOUaskhy3OeNHuA5tacvztnXealC3H5Dbe9fKfo0D3v+n1YbJEknWIUF/EdnSYLFZe31tt0k4w81xiGomyb3FuuTrpoYh/pwJgRRwWhvfMiDW7Pl1nfCVlrhdye988UqGap51YI8a5BzNnqxtQ8G2UoNjsRO2FImGRs92K+9t7izMeD4dhsKNjoRGx1Y+q9hDjTlByT5Zq3Zz/JfFwhLr/T5Ls5SZvqoHZfTymSNCPJFK5lXNkTUXE+zpKT6awmdf6glYJB3k7dvy2mjnRgjNm0nMAfFYSiNMdQ8Gw7Is5yHNNgqeqS67NdHZ21nlshZt1wvGsGETXPQQO2ZRBnOa1eQpxk1H2bMM54ut3Ds82ZjgeD2JxrzfOdCMcyWCq7ZFqTpylLVZcoyfjCWptunOLbJst1TzowhLjkojTHd/bGPttUBPHBKw4NryIyWI764WaXD63UafjOS48/qN1X8+zd1UWugmlpY19VUZqTpBmfe9ajG6eUHYtX5kvY1nj38aTOHzY7ETXPZrHi7t4nSTynk0zqGaPTLoc3DsclpnnSDNAaSraJ1sXtsxo+eCqlcCwDxzLZ7ERn3rYQYrrsj3dRnLPZCUFr0kyz0Y7ohgm5VjiWScm1aHYjVrd7ky76RA1i83YQ41gGtmlgWwYaKLsWb210+ezTFlmuqXsWUZrzYK3NdhBPuuhCiDMYzLcfdtR8+81ORK5hqxsBRWeEZRi8udo6sF151RMSTlMb+6qKkozXn2zvHn+yXPP6k22iMe/jSZ0/XPU6c5VIB8YYTdMJ/JEHSq0pFjvu/0H1/znj2scSCISYHfvjXdmzMJQBShFnGes7IZZhYFvF3OvFiotvWzxvzXYHxiA2R2mOZRTxMs307ki4B+ttbNPAsw1yFJZpsFz3eLDRnnDJhRBnsVBxidOMOM3RWhOnOXGasTB09XdYlOZ0wgTHNLH7cbbkFBedDmpXnrSD5LKZpjb2VdUK4v5xu9jHtmVgGQatMXegT+r84arXmavkSk4hmZYhZYOpGWutd8tSL9kkZ+sXOJWFisvT/qiK/cmbVrd73Jor0eol9JIM1zK4NVciP2M5JZuvELNj/3Dohu/w8EWX9XYP0zB48HwHz7H5sps1lmsurmUSpxlqxueXll2LN1ZbbLSj4hjhOxgKrtdLGEpRK1n4jkGY5jiWwXLNxTYUzWMakNNyHBRCHMyzzd08ZEGcHZuTwrUMgiSj5tm796W5xjQVj7eCl+r6/nZfO0zZaIfM+Q4QXPqYcNIpOOLkoiyn4dt8aaNNO0ypehbvWaoQZRfTkXDR5w9HnSuJ6XLlOjCmKu+C1jzZDim7FiXbJM01T5o9VurexZaDow+UrmXQ2xfw037yuGEHNYiBQxvJEgiEmB0HNTiCOKXdS6l7NvNlh7WdiE+8s8XyVsC879AoO7z/2uxm9x7E1OWqh2nA480eYZLxwZUahlLEacbthTKWMjBNRStI2GhHpFm+Z47u/thcdq3dq5PDx8GFiks3SqVTQ4gpMWibDTus83Gh4vJws0svzig5RZuyHSakmca1i6vig7wY95YqZLkmzjTbvaITuRelLFc9Kp51JXKSyUWy8dPAZ1db2EpRtg2yNOezqy2+4lZjrK87qdVATtqpeBVc1osdV66WD+YIbnYiHm0Fe25fOKUoUtj2b+v+PxO64jiomPeWKnsqZNm1eLzVJUpyPMsgSnIeb3Upu+/2bx001/DBRoe31tuHzj8cvJ6hIIiz3cRRl6FiCCFOZng4dC9O+bXVFo82u9RLDqZtsDLnk+ucIErZ7EZ044znOz1898r1o49s0MlQLdncXazyVfcWuDnvs9WJd+Plh27U2QpiHr7okGXFUPOiYaUIk+yl2BzEGf/6C+u7x7+oP3Ij1/DmakvmiwsxxY7K6+DZJh9aqZPlOe1egqI4sdNo8ixnkBcjz+HffWGDIM6Y822WqyWCKGWp6lEt2XumW6w2A542A97a6Fy6eHDSKTji5JK0yGXV6qXshCmtXspmJyS5gKngk1oN5LBzpavoMueRuXIdGDthUbmGE1JudkJ2wnQi5bk156MU9JIMpYrb06YbpdyaL+NY7w5TvjVfphu9u88OmmsYRCndJDty/uEsBQIhZtmgridpxjsvuiRpzrW6R6JzdoKEF52Y2wtlFmtFI7ru29xfqvJ0++wJgy+r/fN8Pdvk9pzPtXppN142fIc7cyU8x6KbZNimwUduN1isltjsRHtic5TmbHUjdKbJc43WsNYqRnV0wgStkfniQkyx4/I6NHyH1+7Mc2exTK3kYAIVx6TiObt5CuIsxzQU3Sjd3YYGOlGy57WyPOfR1uU8eQG5SHYRNjsxN6oelqlIc41lKm5UPTY7482BMVgN5JWFMncXK7yyUKbm2XK8OmeXOY/Mlbv0FcQJhioSzgD9hHEGQZwc88yz2z8MB60xTZMbjdLuY+I0x56yKd9RmlP1LBzLoNmNibMcHSakuebm0GP2zzXM9dDokj6ZfyjE7PJsE9c2ub9cZasbsdYKaYcxpqF4a6NTDPXVcGvex7NM6iX72FwOV9lxQ6DDJGN1u8eba20cy2Cl4XGtVsKzzd2RGMBubG52YxzTpOrbhHG+exxsdouh5WVX5osLMc1GyeswPO3EtQze2eziD3WE9uKMaskiHspT4NsmQbS3rm90IsqutWeZVYDVZoBrmyNPF56kg6bgiPMTpzmObbHgKJIsxzaN3dEu4zTIIfhsOyLOchzToOFPJofgVXaZ88hcuREYvm2Ra03SH2qbZDm51vj2ePtqDhqG00tz2r146oe3uZZBO0xZa/V2R64kmWa7G+32xO/PzBsmGZvdiOfb4e4VPpD5h0LMusGogobvUHJMdsKIzz3bYa3Vo9lNsC2TXpLzohPT6iVUvCvXjz6yo4ZAh0nGg40Oq9sBvmNiKsXznYhHm8UV0iTToDXNIOLBRodn2z06YYJlKsquhQaSLMc0oBunKKDi2nteX+K1ENPlpKsgLFRcFEWnxaDNqwHHMkFrnm33eLjZJUiyfnx5N9Z0w5Sl6t726EGjMo6bLiyuroWyw5NmwNpOyHY3Ym0n5EkzYKHsjP21nzSDPaPpnzRnd7TmuFzmVVemv4QnVCvZLFZcjP60DUPBYsWlVrKPf/IZHJR7wzENPMea+uFtCxWXjXaIQu0OE9PAUtXbHUa0f377460urmXSKNtESc6z7R7tXjKVHTRCiIszOCB6tsn1moehFDtRzELFwTIU7V7CdhCz1Ql5uhVwf2l2k3geNQR6sxMRRCmWYaAVPG+HtIOE7SBivR3S7sX00py652AqRZzmbAcx20GMQvG+axUMBZ0wxbMNPrRSRymmvkNdiFk2al6HwUWz1e0ec2WHXpzu5sV4ddEniFLaUUqeayxDoTXUyjZJmu3GmlcWypjG3tOA4VEZJ5kuLK6mimfhWSbdMOZFN6YbxniWOf4LD1oDCgYDi1T/Hy1DMM7TZc4jc+UufQ1Wvpgvu3tWvhj3h7ETprSCCNfqrziSaTY7IZ5tvdTDPW4nzSjr2Sa+a7HeClltZZQdizsLPhXP2jOMSFH0um+0Q+bLLu/pZwNudmO6cUorjPnwSmPqOmiEEBdnePWhIE65XiuR5TlRnPH5jQ6rzR6Wqbg573NrYfo6dMftoPh80CoEjza7PFjvsN2LKbsWlqF40Yl4e7NLnOR86FadqmvjWMWUye0gxvdstrsxH1ypU/EsSo5FxbV2O0V2O0ZmJLu6EJN0VFvssL+NsgrC/tX2bNMgr0HJMkApXMvAUIpOnJJqjWsa3J73MZTa7SQd3g68u1LcVjem4Vl8cW2HXppRsi22uxF1f+9FwMsyzFycTZzluI5BBZtM55jKwHWMPdOTxkIplioOj5s9OlFKxbW4PVe6kEUQtoOYBxttOmFKxbO4v1Sl4Y9/xMkkXOZVVy5tB8ZZgv84HJR7ox1pNna6LFTcC1vS9TTLyIZJRi9KafgON5yi86UZxCil8B1zzzbvLpb7SxoVz/XsIsfHYD72ZfjSCyHGZzgGt3rFlIYsh4fNHmGcs1h1UQpKtsHGTsjbLzp88EZ90sW+EKPE58FjtIYXQYSBohunZLlGKcVK3aPkWjxvhRgN2Ozku3OE7y2W6SU5pf5qJPuPfzJfXIiLcVRdB46MA8fV0+HEe1Dkrqh59p7OiSjtMFd2iNKcZjfm+U6IbSg8x9rNbba/vQzgGgZxpmmHaTF6Lo1JMs1mJ95dCQUuzzBzcTY7vZSSqfArLnkOhgE6y9jpjXlhBK3Z6MQsVFyu1TzSvLi9UvfG+rLbQczHH7wgzYu+kk6Y8WIn4mvuL175TozL5lJGn+OWfZnEyhcH5d5oBTFVz77QYXenySi72YlYqnpo2M0yrFBstEMWKu5L2yx7FoYqEn4OyMFMCDEwiMHvWa5Sdky6UcZ2EOFbCsNQRJnGMAzKjsmXnrcnXdwLM0p8HjzGshSuaWIo6PZyorgYOquBWsnCMQ3eXN15aY7woNNCVn4SYnKOqutnzfy/f/UiKEZEREOJFUfJbQZ728uuZXBr3mcnTDAMhWcbGMroxxyH9Z3w0g0zF2elsS2LOd9hueYy5zvYlsVLGfzPm1LFawwtowp67CMw3njWIohzXNvAd0xc2yCIc9541hrr64qTu5RnnNO47MtBuTcqnk2j/PKwu2iM2XtHObAd9JyKZ3G97u2W37EUc76D189EPbzNhu+Qa003TuVgJoQ41ELFZaubsFCxKbs2GZBpuF4rRsyZhjH2bObTZJT4/O5jFK8uVmiUHZI8J86LhHsN36bq2Zhm0XEsc4SFmD5H1fXTtNOGjZJ4b5TcZgeVueJZ1EsOjmkQpjmOZbBc87i3VCbL9VTncxPnb7HiUvFsciBMcnKKc5vFC2jv35rzUf1zEqWK2+P2rNmj7BXTspRS2KZB2TN51uyN/bXFyVzKKSTHLfty0hwQ5+Gg3BvdKL3wrO/HLct31HM82+R6vVjyNe4vYXTQNj3bZLHi0grjSzdnSghxcYpY4dCOEsqORTdOWay4lB2LNNfEmeY9c6XjN3RFjBKfB49xLYNG2aafygxTKRpllyzPafgOT7dSbs+XdjudXcvg1lyJ/Jj+i0kcH4WYNcfV9YP+hi6mkhxXN4fzDA3nehseBu7ZJnO+Q5Rmu/Hhet3DtYxDc1cMylz1LHINtmmQpDlKgWkUeTQu41BzcXq35316ScZ2EBOlOR4GDd/h9vx4vweuZZBruNF4t30Qpzn2mFNgOJZBluk9Z8dZpnena4npcSk/kaN6n4+bXjIuB2WTn0TW99NklD3uOQf9XSn48EpDhikLIY60XPOwDHh1scxC2SFJc55tB2hylmseH5qR/BcwWnwePKbsWKCh6lqULINUQxhnvGepgqEUSsFCxeN6vcSdhTLX6yVMwziys3pSx0chZs1Rdf2gvw1WFRqlbh61etGwWslmoeLtxgevP43kqCVZB7EnSjKCKCVKU8quJaNsZ9R8f5nequewXPWoeg6qf/84TWp1jPdcq9IOY3pxRq41vTijHca859rsrpY2rS7lCIyjep8PSm4ExbSTcfccH5QI5aKzvp8mielxzxn8fbUZ8LQZobXmWn+khlzNE0IcxbVNbjR8fDtiJ0h41A7IFSxWXb761fkrmxjrIAfF2kGeof2rkmx2IuolmyBJ+eDNueKkQxdzgA0FH1yps9oMeLQV9xMrK8q2yb3lwxtakzw+CjFLjmtX7f+b51jYpjFy3Rwl8d4oIzUOK/Mg9lSdIgn9cW27g9qCg/JL+/Dy6kYpN+d9nrV6dKOiM+tGvUS3n/h/XCa1IMOrixVavYQvrbfphgllz+Y9y1VeXayM9XXFyV3KDgzPLoLp/mVuBvkajppeMomynqZheJaOgVFe86BlgoaX1jroQKQpDrqDA+GDjQ5Ka6ol58JWWRFCXC47vZjNTsinH27TDBOqnkmjZNMOMt550aXRz7UzK4bj82ErFZRdi7WdHp0wxbYMfKcYcej2j30Ab290eP3xNlGaUy9ZLNdL+M7Rh/RpOz4KcZUd1Rbb/7e3NjrYpiJMMprdmDjL96waclyb8LC/71llRBcrGa1u945tV7q22R/BcXzb86A4Ju3Dq2EnTHnj6TaffrJNu5dSLVl85FaDL789v7uazbhManWMqmfz/ms1cq0xlMJ3L+Wp8pV3KT+VQaBerpa42VD9JZ4iPNs8VQ6IaXOapVD3P/+oA912EPOph1uUXZs53yFMcj71cIvX7szj2eaBr10kS333yl2ucx5udkgTzZ2l8p6TELmaJ4QIk4y319v8whc2WN/uESYZ7SAhCBMc02DBtXn9UZO6b8/MMqr7HTQiYqcX86mHTa7VPYIo5dFqgAK+9j2L2GWXBxsdojTjUb/zx7aMYrhrfynVzU504KiOq3J8FOIqGqwastWNcEyTkm3SizPCbsR2EO/GioPahMe1GW/O+e8+xjSwTUU7THn4cIs539ntqICXl3d9sNGhZBmg1KGdHgfFsSBKQcFCVUZ7XWafe9LiZ994znzZZbnq0I1yfvaN59jK5IM3amN97YMutI57xOZmJ6K2L0lpnObyvZ1Cl7LVctQqJJOaN3USgwPJWxudA+c4nmWVlVHmOD/YaFN2bXzXwjAMfNei7No82Ggf+trPW73drNlhkrHW6pFlGqufaGetFRIm2dhXWRFCTL9BHHp7K8CzFN0kY7XVwzQ0uYYHG11Q4NjGTC2jut9BqxGsbvfI0XSijHacMV9x8D2b1x9v04tTHr7o8vqj4mqYaRRZ0n3XIkhzOmHCTpgeegy4DMdHIWbRUauGPNhoH9kmPMnyzLnWPNzq8tmn2zS7CTthvBsjVrd7e7aTa02zG7EZxEfm5TgojuVak+/LKCztw8vn9SdNKiWbSsnCNE0qJYtKyeb1J82xvu52EPPxBy9Y247oRhlr2xEff/CC7SAe6+uedYUgcXEuZQfGUV+wUZMbTcooHQxnqUCjHMg6YYpn7/3oldK8s9HlS+ttNjvhnvLYpkIptZs4tdmNcUwTxzKxDGN33uZ2EMvVPCHEbhyK05wkg8WyS5TkdOMctCZD82C9Q5blM7WM6n4HJaRuBQk6L7Ke57nGMg18x6Abp3zheZtektIKIrbDiM+v79CJUkwFea4JkowgTg49Bkz78VGIWTVYNcSxFL2kqJvX6x4Vzyqmkh3RJhx1eeYsz1lrhWx3E6qujWMpVrcjenHKVjfm04+avGi/2/5rdmN82+qn3jn8YtpBccxQCsPYWyZpH14+nThjueygKM4BFIrlskNnzNMO33jWIohzXNvAd0xc2yCIc9541hrr6w5GQj3b7vFws8uz7R7tMJXv7RS6lFNIjhsGO6l5U0cZTOt4vBVgGorlmodSxoHD6s4yzHeUOc4Vz2K7l5BmmjgrDnCtbkjVd6l5NnGqWWuFXK97u1mrl6vFlbviNTJs06DkmCggSXNMo+gYqbjW1O17IcTFGsShimsR6xzLgqpnsd6JiFKF0gbbZsyT7R7vuzbeYajTbH+SvU6Y0o1SduIUyzJRCrJck2YaRTGUtRMWf5svuWwEIW+tt7m3XNldbtW3rf6JyrtTSOolm6R/fjGNx0chZl2YZARJShTnlD1rd1punOZUPOvINuGoyzOvtno4loEGLFORaYVpZnzheZuVegmnv521Vo/r9RJxlmMZCtd8dzsH5cw5KFmo71qo/iivURKIDu8HSfw5PV6Z91ndDvA9G60h05p2mPDKmJdRfdbs4doGrV5CkuXYpoFrKZ41e2N93bJr8YW1HcqujWcbhElOs9vltTvzY31dcXKXskvpMg2DDZOMt9bb/OKDF6xu90iyDFMp1lq93V7u/T3lZ3l/Ry0xO3Cz4fP2eptHW1022yGfe9bi6U7E7bkS8xUXTdFYbnaj3ddemfN3r9zluSbTmjsLZV5ZKKMUtKMU17mYLMFCiOk2iEOvzPt4psmLdkKUpHTChO1uSpZnaK3pxSk13550cSdmkJB6vd3jV59s88Zqi/feqFIyDdq9hDDK2OzEtMOEWsmmlxRzga/XPDJyFksuYZrxa6stOr2EOd8BrXnS7JFrKNnFKL8nzV6xgokQYuoMRubWPAfDgCjJiyu/vYQ4zbi/VD3RUvftXsKTre7udLLB9LFumKJzjW0owqQY/aZzTbOb8KwVYihFmGYoFFudCEUxUms478BBF9MOGtl1f6nCveXqiUZ7yTLP0+cbPrBEO8rYDmLSJGE7iGlHGd/wgaWxvq5WsNoM2epEtIKYrU7EajNEq+OfexbdKGW55rETJrz1ostOmLBc8+hG6XhfWJzYpezAuCzDYAfBeDOIqZVsLMOg1UuJ8xzHNGl2i7lc+w8IZ3l/o3R+BFHKtXqxvSQvslLfqHn0kgzPNrleL2GbilYv2fPag3K9dmeeed/BGErqdL3m8eGVxtR9BkKIizeIQyXH4qOvNojSlF6Sc63mcWu+6Ci93igx5zvs9Ga3YTCckHqx4nK9XsJUBh+528A0ipMJ3zG4v1wtrkCZBncWyry6VGGx6tJLU0wUd+fLfO39RSqezVo7Ik7SYtko6P9fLL8qhJg+gyl3tZLNjYaPYxlkWtMKY27O+TR858g24XCbsdmNWW+HLFY95nx7txMA4JWFMpnWuLZJlueUHYP1nQjD0CgF85ViqoBGsxMmLFRc5n0bQ6ljL6YNynBvqfJSm3H4vlH2w2nyv4nxWKh4fNdX3eZazSHRcK3m8F1fdZuFijfW1617NuvtHkmmsfsXRNbbPereeC947PQS2mHKQsXl/lKFhYpLO0zZ6SVjfV1xcpdyCglM/zDYMMn4tdVtwiRnu5twrV4Mg1usuLxoR6w0Sv2DQX7gsLrTvr+j1k5+50WHf/9gg195tM2Cb/Pr7y6w0vBZ3wmJkoyNdsydhWIbi1WP5Zp35PrjF70+sxBiOg1OxHd6Ca0gJspyQGFbim4v5d5yla0gwTZgserR8B0s02Ded2iNOSnXNBtusCe5puSYNIOIZ5s9PNvAMm08x6TuW5RdkzeftXh7vcN81aVsm7i2ya15h7mys9vgd00D0ymmn/SSDMc0uDXnk8sADCGmTphkPNrsYhgK1zKZKzvcaJTQWhPE2UudFAc9f3jKhWub3J4v71kRBIpY4zsmv9rqkaQZJdtivRWS55payeFa3cO1TBIrpxcVI70APMciSTOSTI29rSfLPE+fKM25u1CmUXKI+ytdNXx77EktHdPger3Ew83u7iokdxbKOOZ4r7sHSUoQZTxuBgRxhu+YLPgutiUXAKbNpRyBMe0GIy+iOKfqWtimwep2jyjNKLvF3Masn6F5HKNHDur1fudFh5/41BPiRLNYdogzzb/63HNWtwPqvk2SZaT56FNWTtqzLoS4mgbxrhdnrLdDVlshrSDGsRRhnPNwK6DimtxdKFPxbMIkp9NfYs821UxPIRlOvueYBlvdiC89bxPGmsVqcULxtBkUV0W15tZcmVaY8Gw75AvPOxhA2TWolqzdlaB81yTNNTcaJe4slLnRKGEahiQhE2LKDGKnZRXJ0LVmd3rxKHnPDppy8WizS5bvPbm0TcVGO+TN1RYLvsuc75JkmuediK+8O8dy1cXox5gwTnlns0vNc/AdsygXsNIojb2tN8oUaHHxnjQDdH9KotbF7XGLM02UpKw0fN5/o8ZKwydKUuJsvD3xaa75/FqLKM6oOAZRnPH5tRapXAGYOhIVxmBwVa3sWWQaFqrFsLwX7Yik30vuOxbXah5Rf33hcc/x+/cPNpgrOTTKDnNlF0sZZBr+jzfX2GzH2JbJtYo71VNyhBDTZxDvunFKmObUfYey69CLc4I4Y20nYLOdkOQao79qUZzkxEnGtXqJ2/PlSb+FiRlusM+VHR5uBRjKoOyaZLmmFSZ4lsUvfH6dt190CeJin6E1CxUHy1LMVzwqrr27ElTFtXcTfk57jighZs2g0+GtjQ6/trpNrmG56hVxQIFtGKzvhEfW2cE2PvVwi60gJtd6dwRW2bPYaO+dcpFkmrWdkLJr0yg7XKuXeM+1KncXKmx0Iq7XS7sjtpq9mDsLZWol+8KncVym/HYzQ2s6Ycrnnrf45MMtPve8RSdMx55TqZekOJbNUtXlWs1jqeriWEUeqHFqdmOW6x4l1yLJoeRaLNe93Sn/YnpcyQ6M4QPEJBIA/f/Z+7MYy7Y0vw/7rbXnfeaYMjNyuGN118Amq5oNgqQEm9BgiwZsQYIp2LAN2iJMQIYfDPtBhOEB9otlwBCgBxkQDdugbQkQbcsQYYASCMGULEtsDl3drKmr6t5bN6fIGM+85zX4YZ0TNzJvRGRkZpwcz7+QlTd3nLP3Pif2t75vfcP/v6yq9dOQWhmkENzsRZSNZlo2tGPHzhz43msjKjqZ17Rjl5BoRz4KQ+QJZmVDrTVCCL6721t3VKyxxhovhOV6VymDMRZP4FSJKsXRrEBawSSviQJJUSuKuqGoFR9tpNzbbLHbT970R3hjOBuwR74kEOB5gtD3UNrSKEvsCw5nJcLCvGzwEGS14s4g4Xbfzb03yuAJyEqFEPD93d5LcSi9ad+5xhrvM57tmKhqw8ncjfAKYdkbFzyZFOSVutBmz55DSrEghf9G+nS7HZFV6ltJAE9K4uDpkH+nGzLJm0WMGnOrl5AGPrcHT6/JzxLNrwrvCr/dh4Rp2XA0qxjNayZFzWheczSrmJar5YRIAo/tjutWLxuDtpbtTkiy4mfBk5LYl/STkJvdmH4SEvsST76X2+V3Gu8sB8ZFWKp+ZI12IxrSBc+f7nRe2yK4rKo5QsyYcV7TKMudjYQf7PY5mVcYy7kziqvi9dhsh8xLTb/lZLl22jEn84rdQcqdQUor8skq9RTb9Fmspa3WWGON87Bc7yJfIqVAW2Cx2S5qzXFeIZGknmSQRGSNoh36tKOQz7bbH/Q68iyf0KAd0Q5dlfTRKMdYw5fHJZ4UGCEIPcGsbuimAQfTirsbjuBvlNXMKkV8RgnqorX8Iiw3RuEisd5oy+NRfqUNxNo/rLHG83GW8wagFfvMCsWvDmbcHqTc20gpajfOe5VzRL5r6Q99wTivHQmwlNzb+CYJsOStGBc146JBaXvKZeB7go+2Wk+99t5G+q3N2quOcbzI+vC289t9aHgwzKkaw043xpMCbSzjrOHBMOeH91YnLbrRDkkCn1qb0+c19CRJtNpEwkYr4GCi+fJ4yqxUdGKfO/2UjdaHO+r6tuK9SyntjXKGeYMv3ZiGLyXDvGHvNcxsLfGtNriFAQ5S1wZ3du55iVVnuP/8Z9uMippxVlPUTprLCvgv/eAWt/oJndi/8Ppraas11ljjIizXu1boE/uSSV4zyhwPhi8FwkKj3BriCctmK+STrRa1/nDVR87iLJ/Qn/10i0ZrhlnF3ihDAMNpTRx6fHkwZVJUFJVmt5cwLRpaoX9tSlAvqwCw9g9rrHE1PBv79dPQFbi0wZcCpS0Wy3YnvtDuzp5j0AqptcYaS9nob8nen+2ovd1PeTjMyCpF6AmySvFwmPHpVvup1+4O0m+NcUzLhqrRL9WZtV4f3m3ktUagGeU1h9OKUV4j0CsnVv1su0OjNe3IZ7cX0458Gu0khVeJzVbELw9mhNLjo42UUHr88mDGZms9xvS24bkJDCHE//Yqx855TSyE+PtCiD8SQvxMCPG/WhzfEEL8HSHErxd/D17mxi9qdT2cVafEQ0IIAk+Shh6Hs9cnw7QMSBul+fo4Awsfb7UIPHkqZ/W6iYo+3mrzL/zoDmEgGOUNngd/8U/cOp0/v+z6a2mrdwMva6trrHEVXLTmLte7JPTY6cTs9mKEEMShz1YnYqebkEYeoecxrw2BL7nRi0ii4J1ZQ16XbfXTkB99tEFeK8rGUirND+722GlHtKKAJ+OKVuyRRj4/utsnCb3ntlpfdSzkZRPra/+wxsviQ/NZz5JUxoHjSmtFHkWjEQJu9i4vKJ09x1L2XluLtVy6DuSV4lbfdWJ8fZIjJPzw7gD9DDnhs2McjTavNPK8Xh/eDK7LtgIpKJRlkjecZBWTvKFQlkCuVpVj6Qs9D0Z5jefBjz7aeOHOwhfFSVbxJ2/3aMc+WW1oxz5/8naPk2z9vL5tuMqO+Z8959hfvML7KuCfstb+KeCHwD8nhPizwF8D/iNr7XeA/2jx7xfCZRlda10m+nBa8miUczgtT4+/TsQLibvPdjrc22yRhP7pwo21r0xUdFlQetHPbvYS/ou/dYN/8Xfv8rv3Nukl4ZWu/yY6RtZ4Kbysra6xxqV4XhVtGfR+b7fHn/18mx99tMGf/2yTeaUxFsZ5g9KGSmuUNvzyYI4nxLukrf7abKufhvzWjS5/+uM+dwYt0sijqDVxINhohdzqpWykIZ/sdE4rp63I52d7Y/7Oz57wH/x0jz98OOLxKGec11eufr6sAsDaP6zxCngvfdZFMdh5JJWxL/lkq3OqGBQH3qV29+w5pBCkkc9OJ2JaNPxsb8wvnkyfum7ZaB4Mc/pJwA/vDvjRvQHb7ZhWdH6iZLme7/YTRnnFOG8YZm4E5EUTEOv14Y3hWmyrGwUczyqU1osuIc3xrKIbvZ8jFfNS0U0CNtqOPHSjHdFNAkdcusZbhQs5MIQQ/wrwPwA+FUL84zM/6gD/v+ed2LqMwXzxz2DxxwL/PPAXFsf/BvB3gX/1RW762TnCsxwS/VbITx6O6CYRUSCpGsPxrOB37r5Uo8croVIGKeDJuHpKPxkhuN1PTueeX1Rb+7JZZeDcn222o9PvbdAKCTzJ0axEmYhu7F96/WVgG57RQX5d0lbr2ern41VtdY01nofL1tzlunPWVh+eZOxPK6ZlTVnXlI1GGccLlFUKTwrSwGeUu5+9rTb9pmwr8iVF5UhR56WiMZZ5o+lEHsbYp9brcV7z4/tDfE9SK4Ox8OXBDF8K7p9k7HTiK/EtbbYjJ//daOZVQ165ivD3dnvPvdc35R/WeDfxPvus53HJnOW8iXzJ93Z7nMwr6sVGv9GWadmQ+JKvjubfinuePQeAsBZjYVI4Qs5JXuFLQbm47sm8ohX5CMSiM9nZ6tG8Yrd3Pony8nOUjaGzUNTbn5Tc7MVEvrxwhODZmA1r1+vDa8R125aQgo12SN4YGq3xPI+Nto9YcQfG0q+1ooBBGlI2hh/fH668CyPyJL/cnzKvNXVjCANJO/T4fMWjK2u8OC4j8fx3gL8N/G94uktiZq0dXuXkQggP+EfA58C/aa39fSHEDWvtEwBr7RMhxM6L3nSlDGn4dMAbeMI5BE+y1YlpFjOBUgq2OjGR92YWy0ejnFYYkASOVf7RKGe3n74SUdFlmwn372//7MujGTud5PR4JwmIAu+05XDprM5LFCwDW+DUwdZKX3r/15F4eBVSuQ8Mr2yra6xxGS5bc+FpW5UCDqclh7OCk3nNcdbgeZJGK7pxwHYnJvAleaO4u9ldKXnxNeC12tZy3ZyWil8fzWiUI0/bakWUSuN7rgX77Pr35dGMVhQwrxVx6ONLQVFLnoxL0shjXjV0km+qZWd/b2cRBx6b7Yif702wuI6NduzGfOLAIw68c9f1l/EPa3zweG991vOSvefFfnHgfSshEfjeqT09G/ecPcfjUU7ghQyziihw49ONMmSVOi1cVcqw3Yk4mJYA+J7AGktWKjZvn995uzcuGGY1k7xhXiq2OtGpVPNGKzo3AXFezFYoQ9loOkl4pfVhXbR6ZVyrbRW1YreXMC4VRaNJAo9+7FPUq+1IWPq1NHLb1HRB3vnl0Yw//dHmyq4rPPjlkzlhIAmlYFJYHjeG79xcJzDeNly4q7fWTqy1X1tr/5vAXdw4yH1ACiE+ucrJrbXaWvtD4A7wZ4QQf+KqNyaE+KtCiH8ohPiHR0dHT/3s0lZXIfh0u83NbnxKbPbpdhvEarOF58JaQMDy0mLxf684zlIpgzaGJ+OC+ycZT8YF2hgqZS5s15uX6sI2vqu2h19V2uq6SJvWs5NXw4va6mW2tcYa5+F54wVnbXWcN3i+JJCS2YKgTuJmtLOmwVrLIAnop8Gls95vA16nbZ1dNwdpQCv0mZeaaalAQCfxKWrD/ZPsqfV0XiriwHVfLJf4yHdSq2ngkVdPr7uXVT+zSnF3o8XnOx12ByndJDhdcy9a14G19OEaL4SXiS/fFb/1MiMTZ4l8I1/SScIrxz1nZaz9RVXc9wS1/uZ4tJCBvNlLEAKKRqOt5d5m60LenAcnGZ4Q9BOfJ5OSH98f8mSUcZLVF44cnxezdeOAOPSvtD6sCT9fHdfts+LQY39W0jSaQAiaRrM/K4nD1a7vS7/21L0EcuWjHI9OCm70Q+LAQ+Ns80Y/5NFJsdLrrvHieK6MqhDifwn8HvDbwP8ZCIH/G/BPXPUi1tqxEOLvAv8ccCCEuLXovrgFHF7wnr8O/HWA3/u933sqcr6s4rOUKL15pi2uVoZgxfmL87LGCMGdQcKkaCga1y54Z5Bg7KtnmS/q7Lionbcd+8xLRVarhSO1KGURAkZ5RS8OL20zfpGOkau0m18Fz6v6rvE0rmqrl9nWGmuch2fX3HmpOJqV9FsRjHKOZhXWWrLaERcfz0rKWtFJI8JA0RjQusIXkqI2KAtlY5iXimTFgdB14HXY1rPrZhp4bHdDpmXNvKiplGW7HRJ68jSwvz1Iacc+ZeM2R4fzCmMsRa0JPMGoaMiKhp1uTDv2n1v9vGzNfd66vu64WONF8SLx5bvit151pOpF456zMtbKWALPqZmE3jdJ50oZfn04Q2tLJ/aJA0cEvNv/9vhI2Wh+tjdmUjbMK4U2lp1OxKxs2J9VbBsujFcvuvdGc6X1YRm/n8y/GbtuRf7b3qX3VuK6fFboS6ZZw8G8olKayPe40Y5O/cCqsPRr6RnZ1LJxpJqrxCir6YQhaQDKGHwp8YQ7vsbbhas8gf8C8F8DMgBr7R5ulupSCCG2hRD9xX8nwD8D/DHwt4C/vHjZXwb+/Re96cs6As4jSXpRgswXxYWVKWtPs94fbbZONbqx9tWyzJd0dlz0+ZcSWlVjEFgeD0sejTI22m627HhRYVviVUiWrou06WVJ5T5gvJStrrHG83B2zR1lNYezkq1OzCANKGrNF4dTTrKKaeGcfK0s80qT14oo8PCFoN8K8KSgVgZpnR0/HGa0otUGJNeEldvW2XWzbDQWqBuLNhZfCsJAUBkLAoy1p1XZz7Y7jLKKSV5TlIq8UuyPCyzgC/hkp83hrGSU1c/tjrhszV2T8a2xArx3PutVY9AXjXvOylhXjSavFJVStCKfadlQ1i4JkXgCg+VoVlEtlEWexVnei91ezPGsYpQ5OeyNVsggjfjebo+sOr8K/qox27RUnMxLrIUk8LAWTual60Jb40VxLbY1nFUc5xWtwGenFdEKfI7ziuGKlR0/2+6QVQ15pTDGkFeKrGpWLqPaSQIOFqSlLhmoOZhVT41hrvF24CqRY22ttUIICyCEaF3x3LeAv7HgwZDA37TW/r+FEP858DeFEH8FeAD8pZe58Ys6As4jSVp1O+tFlalGO8cFT3eKCCEIPXlhJeui7ozl8YejfMFUrWm0eKqz46LPfzKvuLPRIqsUj8cFaeTRTWKK2tAKnaP71f6MXhqcZr2fzaSfh/Pu9bpI3daz1S+Ml7XVNdZ4Lr5Zc3PacXC6fmW14mY35TcnM7bbCTvdiMNZiZCQeq512fcNw0wxLWuSoCEMBDf6KR9tpmSVWrk02jVg5bZ1dt0cZTU3+wnHWUVkPNRis5HXirrx+XtfHbHViskrxec3u8ShR6RcMv8kq/h0p00/DYlCj+1OTC8JX5nv6GRercn41rhuvHc+61Vj0Od1uz3b/bC83m+O5jwe5oyLhkEa0EtDEl8SLBKdnSRioyPdSJ+AThJ+i4T5Z3tjysaQ1woZBWy2I/JacZxVbLVjbg9cJ9dF3SCvGrPldYMUkmCxpgS+oNGSvH5n1KreJlyLbT0cFWykIdNKMy80ceSxkYY8HK12pKKfhnyy3eY/+/KIk3nNZjvkz3+2vfJY4VY35nBWoi2YxmCBJJTc6sYrve4aL46rJDD+phDi3wL6Qoj/PvAvA/+H573JWvuPgR+dc/wE+Kdf9EZfBK9CkPkyeF7b3LOObG9cnFvJymt9IXHlWRWRbhzQaDdTfrMXEwfeU2My533+Sjkm6W4SUGtDsnCARaPppwFfHk7xpMeNbsSkaPjyYMZnC9KaZxMoy8B32dp30b0CaGM4mldkpeLeZuuFFAfeRDLqHcdL2eoaa7wIpqWirJ0yRuhJ5lVDNwmIFkncWhs+32rxwJMUjaZRmlAIGuM6zmLf42Ra82A4J/QEnhDcfv0iUS+KldtWK/L5xd4Ea2GYu4CtmwR0+j5Hc9dh0Q59lIG81IyzGTudmKNJztG8QgrJvc0Wt/opvUW1qFh01WljeDxxlcxxVrHd+Wak5CxB4GVr7jqhvMYK8F76rLMx2IuOC5+1wVFWM8prtjsxnXPsdYklZ0Uc+tyKfKyFB8cZN3oJN3s+80q5TpDFWEboS25042+RMFe1ixM9Idgbuzh0Iw2ptaWXBNzoxpcmLV81ZksDn4lqaLTj81DGYqylE6yr3y+Ba7GtUmkOJhWhL4kCgVaGg1IR+quNw8d5zS+fTOnFEf0kwlr45ZMp/TRcaRJju5fwWdnw9TgnqzRp5PHZZovtC9R61nhzeG4Cw1r7vxNC/LPAFDdL9b+w1v6dld/ZO4TLOg7OSyZc9vqLujnOqohstCP2JwUCwSir2GzHzw0kz15zOSuJhdCT5JVmp5tQKcO0bJgUihu9BGvs6XjLZjtib5STNRpjLEpb9iYF262IQdstKEsnlVXKJWpGOQ+GOa3I5+OtFp6UL6wi8rqTUe8y1ra6xqpRNppxVuFJSRI6/p1x3jjiyVbIIA0JfFfl22hHPJmW/Cd/fEilNZEP1nqusoHh66McrKDzDoyQrNq2lpucrU7MvGxQM8P+tOJ2L6EVB0ghMAZqrfEkaAyx7+F5gkmpqRUMWh5H05pRXpFGPp04oJ/6lI3m0agg8iXTouYkq9mfVuz2Y272ktNRlOfxHa0TymtcN953n/WySmrndbuVjWac12SlYlzU/GC3f3qOnz+ZkNeGTuKfbvxnheLBMKMd+YzzGl9K4kBSKkPRqKf4h5ZxZyv2yRtN3mgQgvFi7KzfjrjRjZBCPDfWfJWYrZsEBJ4kq9Upb9xWO3oneJLeNlyXbXlCUGuNNhYNeIC2Bm/FwggXPdM/fzLhz3+2vbLrRp5AeJJBEpIGLukoPEnkrfbzrvHiuFLkuHjo3xunct140crUZa/fGxfndnPMS8XtvjOgOPC42UsYzismRcN2J36uQzx7zV4S8GhUAJY7g5TH44LAc9W7cV7TigInxdfo00TKz59MMMZVCTWGg2nJyayiHfr0ntEHX5LdHM4qfE9isBzOKte1Eb4YIdNaUuvFsLbVNV4WV7G1k7mr3p9kNcpYfE/QT0L2JwXf3e0yLxsaLSkahTZwqxfz27c6DLOaB8OMojH4QqCNYVw2xKFgVrXf0Cd+MazSts4mrrtJwEY74uEwo9aW8Sjj8ahAYBkXimnhFKVubydMS82NrputrxrDybxisx0yzmsETo3k4SgHLL004GePJ3SigMi3THIFFK6qeg4l4kXPwzqhvMZ14n32Wa9KaL7s7i0bzf2TjKLWaGOoZ4Y48Plsu00ceDwZFUSBZFI2Cw4Mx3XWaEMvDugmAfOyoWwcf043Djialfzoo42nrpMEHl8eZqSRRz8JEEAS+ny0GFEOVqwwtIxTN1rRU7HxKjns3mdch221YtfR01iDEJbGCsTi+CrhnmmPSd7QGEMgJVEgebLi0ZVKGYZZhcCN+lsLw6yiUu/8dNt7h+cOrwohZkKI6TN/Hgoh/l9CiE9fx02+7XhRmdHLXn8RCdKy3ffsObY6MZ/vdK7kUM5e01jY7cXs9tMFb4bLcseBdyrFtWSxBpdAeTJyiZXAk0wLRSt0MojHs4pg0ZI4zmvmpWKU1xjrOECG84qDSXl63eN5xbS42jzjWlLrxbC21TVeFle1tUo5FvCbvRi5kONrxx6f32gzSEN6aYTngUDQiX3ubrTopxFb7ZBASpQ2BL7EEwIPQdNYhvnbz+69att6liAzDjy22xGjWUUrCkgDj1pbksDj8+02u4OUk3mN0hqsSyz7nqAVeUSBRz8NuTNI8D3JaFZxZ5CSV5o08hFSECwSy6HncbRILp/Feu1d43XgffdZr0p8u4wH96fFaRdF6Hskkc8oq9gbu82cAA6nFbUyZKUj7ZwVDR6CShtCT9BNQjwPurFPO/Lpt75JUC+vUzSa3UFM6EmKytCOAj7fbtNNQz7dbq+84+pFY+k1LsZ12VYgJbuDiF4aEvk+vTRkdxARyNVzHx1NSyyuO91iOZqWq7/mrHLdjVIgBHhSEPvOT67xduEqKbR/HdgD/h3cOvnfAG4CvwT+T8BfWNXNvUt40crURa+/qDvjs+3OKa/EdcwfR4uZZsdtkfB4lFMr5+iKWmOxp1K0bvREwiJ/UmtD7Es6ScD+pKRRBk863ea8Umx3YsIFa30YeATSJT12ujGNMuTN1RilT+YVRaP56igjqxWt0OdWP76werHu1ljb6irwITxXV64UWsvDUY61Lui90Y2RQpwGmrcXL/vqaE4aeggh2O3HPBpm7E8qqqYh8CTWWHa6Kb00uHJC8w1jpbZ13ljhtFLc22pxb7NFK/I5mBQYC/OyoROHjJXrcMvrhp1ewtGsopeGGA2tKOBGLyHyJRLwpOMm6YQeXx3n5LXCYsmqBmvhOzeeZna/LinsV8GHYHdrvN8+a2nXxhrGee06IwRsXnGGfxkP7o9L0sADAY2y7HQj6kbzs0djwIVm86pZFKCcUF2tLR93YwZpCAI+2f6mglwrR+R59jpfHc64f5Th+xJjLLU29Fo+88pxUrwunqJ1l9e14Vpsqx15eMIjCS2hB57n4QlBO1rtWrzVifj6eMbhrERZp6jlS/h0Z7Udm5O8Jg190jOjrXmlmLwDhZYPDVdJof1z1tp/y1o7s9ZOF5rB/xVr7b8LvP3Ua+8YLspA99PwlTLTl1XUzl4z8j2UMWy0nJrIUgLs8xsd8kbRKEMgBWVj0AZ++0YHIWBWKaJQ0m9FdBatZXHgHKHFUilNowzGGtLwaoRMR/OKXz6Zoo2lF/toY/nlkylH829nQtcVQ2Btq9eOD+W5ukqlsGw0hTJUjV6MgVgeDnNmRf2tFt9l4F42msDzuL2REHpOAjSvNXHo0Usk3dinu+JW1GvCSm3rPOnFrFRsd775Xm/1E9qR7yqwocdnO236SUgU+ihjF5JvFiEtncRnf1IyLx2fUa00jXZy2UkgmdcKD8msaNhsOTWCs8/0m5ZM/VDsbo3322dttiNmRc3DYe7kkIWgWqyjV3mWl7GZJwSF0ggBO4uRsaN5hcHZx8aCf6ioFXmjsdbyyVaLrXbEdiciK9VzZV2tEPiBoGgUx/MKu7h+rSyjvF7b3ruHa7GtdhTQGIsxBmsFxhgaY2lHqyVWjUMPIT2UsVirUcYipEe8Yj6UbhrQaI3SFmsd31+jNd10TST7tuEqkaMRQvxLwP9j8e//+pmfnTM5+2HheVWi66wivUpm+nkVteW5bw++ueezRG3gRkDyShH6kllZ0U0C7mykeFLSUf63pPY6cYDvSSZFgzHWVR7a8ZXkWQH2J8VpsA6QhG4sZX9SwN2n19+3oWL4FmBtq9eMD+W5erYDoGw0h9MSbezpunUyr+jGAe3IZ5TV1NqtaXHof2tNW1YOh3lNK/JIg4Dbmx3mZYMA2pEkCQO0hbub78Rs6Upt6zyCzHubjvgYOJ3FbcU+Fkd2JwR8suXGSX62N2aQBo77QniMshptLHmt+HOfbQGuHbdSFm0tv73TIQ598krRWiRFzj7T1yWF/aI4lQof5nhSsNONEUK+t3a3xvvts+LAIw59otptwEJPcnejhRTiW8/yRbFiHHh8f7fL3qR0o2JS8GRSorTlziBBCMGgFeF7kjDwSEOfVuSTLt7rSbeWLItf55HvLtf2H+z2+emjMa1egCfhydiN/6ahxx88GHKz67py1x1R7wSuxbY0ll4cMC1qCmsIhaQbB+gVm+coq9ntRcxrn6LRJIFHO/ROOfZWhbsbLZSxKG2otUUKQSsOuLvxTsQpHxSuksD4bwH/BvC/xz30fw/4bwshEuB/uMJ7e+vxPIbpl2GgflnW6uehWrQMPhlXp1Ja/TQ4l7ztokTJZ9vtUwd7e5CCtd8idnqWLHRWKlqhx50bHdfG/AKETJ4QaGFRxuIJ0Bak4Fz244ukbC/SK39PsbbVa8aH8lydtVttDI9GOSC4syBvezzKqbVlkAYIIbnVd4Gstfbc72K5hhxOS0pjOZ5XfLad8IvHyilqCEkoBWWj+XTrnSDxXLltPbvuLn0BQD8N+OpwxnHWcHcjwReCvFEUi46IQRqx2Yp4eJKRK4NZEKw2Sp+ee6eXcLOf8IcPR4zyBlEoNlqBk+B+5pl+E5KpZ32fWKzz+5OCm72EOPDeS7tb48PwWXc3UsSZuOXZdfN5cd/uIKVsNFmjqZWlaBRbLTcmBk4BqmwUN9oxcei5NdYaWpF/areXxY9LPyeEpJeGVI0mq1wnxvd3e3gS7h/nGOOI35c+4XXwU6xHyV4a12Jb2sC8blDGjXGoxb/1ipvxtHaKhu0oZKMVUTeGrKrpxKsldN3tJxSNJq8UxroERhr57PbXMqpvGy5NYAghPOBfsdb+Vy94yX96/bf07uB51dmXqd6usuL7aJTTCgOSwMkfPhrl7PafXwFYYhlgX/a6s5XEZkEWihAXMlhfdq6NdkheaRpjKZU5ZehPz5m9i3zJvFRktTo9Vyv0Pxj5rbWtrgZvqhL9unHWbh+NHfv3Tid+ylbHRbEYYbj6dxEGkq/3p+yNcqZFg8GSVxqvkZge/N5Hm2jzdhda35RtLX8ne+OCg0nBKG8IfUFRG+ZGk4SScVbzB8UQiWCYVwzSiK04YJI3ZLXCE4K9ccGn220iX1LUGl96bHV8Yl9SNoZJ0TAr1VOJujchmXrW98WBGxsJF90kt/rJe2l3HzI+FJ91FR9ylQ7ZT3ccD9p0QZReKMOvDqYkgX86WjYuGprSoK3lZjchDc9ynV0ca529x3bk01qMpd0ZtGjHAXvjgk4a0AoDxnlzmsBedUfUqgp67zuu07YmRU2tDKO8oagVSegzaAVMitV2QnieI6fOasVRpkkDj1bk46341x4H3lPF2nXS7O3FpdGAtVYDf/o13cs7h+fNCb/MHPHyPWWj2Z8U3D/JOJmXr050Zy0gHJUPLP4Wi+Mwzmt+fH/I/ePMtYrV+tyZ46vMJi+D30+323y603F/n8Ng/bxzfbbdQWlDO/TZ7cW0Qx+lDZ9tP004B26hezjMqBpHMFo1hofDjFb0TszXvzLWtroanMdN8L7Kui3t9kYv4e4zthp4gjTwr/xdLNeT41nNH3w95HBW8mCUUdWaOJRsd0MKbbjVj18br8LL4k3blrWWOxst7myk3OjEjPOaTuLGdo7nJXvDgkEakJeaveHcya8qJ1c7SAO+OJjx1dGcaan4xd6ENPCwxlI2jpOokzhJxWd/j2fX8fM2DMv1+6uj+bXwU5z1l/00dM/Zgj/pfba7DxVv2q5eF67iQ64SKy47XENPcHeQMi81ZW2Y5BXH85KfPBwR+R7dJGCzFRGc2Xg9L9Y6e4/9NCCrG47nFdoY7h9nPBrmtBdKR/Wi9P46OHHOJnaEEIS+PB13W+NiXKdtzYqGhyc5vvS40YvwpcfDk5zZism3B2nA4aymqBU+UNSKw1nNYM1FscYCV9nd/VgI8beA/zuQLQ9aa/+9ld3VO4LnZdZfpnq77CQ4yWpCX5IEHkWtyev6lHDzpSBcO/ikaCgaV1FbtoeXjebnexN8KUlCR5pzktWn5G5nM+xX7RC5Stvf887VT0N+9NEGXx7NGOU17djnRx9t0D+HwTurFHc2WmSVOu3WGLTcv897/XuKta1eM95EJfpN46J1q5sEp1wYl30XZ9cTYy21thS1IvA85o3GCkFjLIkvmFaK3fidCEjeiG0925VwMK1IQ5+8chsPKSTKNHxxlJFGPk8mBYFn6Q5CemlAow3ZYi2+u5HSTgLmZUMrCtDG0g4dp0nkey/0TK+iMnr2uYsDj5u9mMNZiTF2Laf4/uK991lX8SFXjRWX68G8UtzeSMgrTVFp9sYlUehTK8NWO0Jp62RWA49PF9Xk82KtvVFOFHhOHQXHMQYuofFkUlI1mk4asNUNGWY1nhCn9/06OqI+lBHOFeFabGtc1NzqubGK4dwQB5JbvYTxijswtIWNVsS8bqgbQxhI2gverFVi3fXz7uAqCYwN4AT4p84cs8B742BeFs+bE36ZOeLNdsSP7w/xpMSXjlXeYtnuXCwfehVEvsRYTqVRwUlpBcI5RQskC9nDZSVgXjVI+XRV4CoO5aoLwFXO1U9D/vRHm8/9fJUydGKfbvLNZuii+fz3GGtbXQE+NFm3y9atq3wXZ9eT4VFDLw0ZFTX9NHRz2YFrP/1ss0VWKjZvvxNV9TdiW2fXyH4a8tVRRjvyqJSmaDTjrOFGL0IKNwd//ySjnwZsdyKUsRzPam52Iyw4sr80pBX6RIE89QXPSipeBasYdXz2uZNCsLFQ31oHju8tPgif9bx186qx4nI9qJShFfq0owBrLQdfl9xqhWjr7DzwBal10sufbrfPjbW0MTwY5ny20zmN05bXPJlX/PDugGFWEXoevSTgwUnO/qTgh/cGp10kq/aLH8oI54pwLbYVBx4nM+e/o0BQNZZp0bC14jW5UZZO7HGrl+DJBRdHVdOo1WYwPhTi9vcBz01gWGv/e6/jRt5FPC+z/jLV2zjw6LciylpRNJrQc4Fm5MtX2oxf5iD3xgXpghcjWBirLwWzQrHdedpRXMc854uc66pYO7q1ra5xPXjVrpNKmdP1RGBJAo9eFLigOwoQQCg9otDj3mbrndicvinberYrYXcQczSrENYlHrY6IZHvSPvaUcCNXkxeqdMuu37qE3neaSJ60Ap5Ms7JSoPt2pcm51xFZfRD7Hb60LH2WQ5XffaX60Hky6ekk4NFsSs6+3rBKXHoefHR0bxaKBB9O05bFoRCXzLKaoyB2/2YUpkL+cxWgTdBJvy+4Lpsa7sTU9YGbQx5bQikYLMdsd2Jr+P0FyL0hLt2Y1xXtSfZ7sS8YK79hbHu+nl38NwEhhAiBv4K8APg9Im11v7LK7yvdwbPy6y/TPW2Gy9Jmb7ZfNeLUYxXvc/zHGTkS9pxwDBzc4W+JyhqvZA9fbo6ehWHctUF4Dqd09rRrW11jevDq3SdnF1POnGAJwXdJGSUVwzaARIYpCG7g/SdYfZ+U7b17Lq2mUbkpRuX258UDLOKotbc6sc0yrCVBhSRz61eQrCYV88bdSoB5+boY6Zl/UpJglUljD+0bqcPHWuf9Q2u8uwv14NW6HM8r2iU47G5M0g5mpcM2iHWOuW2vNaORJ3z46OsVHy89bQ05DJOW9p3HHinhJ3LTq3XaZ/rpObL47ps63u3ukzzGiEWXeHGYq3he7e613zHT+NGL2FvnDNIQ/xFoi6rm6eEB1aBdTH03cFVfiP/V+Am8F8G/mPgDjBb5U196HjdxIGbbdeC3Ip8juYFv9yf8GRa8Ml2+1uOYulQGqX5+jjj0TB7Sh4MvlkAzuK8BWB5rqU++avMOV/nud5hrG11jTeOzXZErQ3KWIqyYZzXVFpzb6NF5EkiKRm0InrvBvfFEm/Etp5d15LQ43u7PaZlzdGsoll8z49GBcfzio1OzHd2Oqev30xDBq0IKcQ3vkQbBsmr8QJ9SOS2a6wU75zPelHy2usku12uB0noxjo8D3ppxEebKZ/f6OBJwTiveDIuyCt1ev3z4qN7my08+XRMtozT3ib7fh6Z8BoX4lps684g5U/dG5A3NV+fzMmbmj91b8CdFSeydvvJKa/TF4cznkyK1yJn+jY9+2tcjgs7MIQQvrVWAZ9ba/+SEOKft9b+DSHEvwP8h6/vFt9urEKj+mWyzs+7j+fxUmy2I36xN6EdBux0YtpRQFYpxnlNVqmnzgtQKIMnnTzqybyiaDSfLRIeV+mGWN7vtFTkdUMa+OdmOMd5zZdHM+aloh37fLbduZCU80Ot3q1t9d3F+6Rxf9amjyYlAL7v8cN7Aw4mBbNS8esnc7Q1PBgVKK0JA8n3b/Xe2s/8NtjWWfnqvXHBg5MM35fEgeDHDzN8Yfhkq4MxlqOHJd/f7dKNAxCCKPDYaEdklSKvNdOi5teHc5TSIAQb7YhO5PP93d4LkR2vK6NrvAreBrt6GVyV3+vsWjjOKrY7Me3YP3395sImTyXfI/9bcdbyfOf5iNuDlNuDp6+VKCeJXNSa7W7EdjvCk/Kp+3s2BvvyaE5eKYx142SNNqfcOJvtiGFW82hYIIRgp7PewL0LuG7b8qTgH359wsOTgrxWZJXClyf89s3VdmAARL7HdifCWIsUgshfvX9Z7mGe3Xe8Dt/2puLBdzUOvWyE5O8DvwsstXLGQog/AewDH6/4vt4JnHVmUsDepODXBzPubbbY7Sev9AA8bzN+9oEDKGtFJwkvdKp744JhVmOB0JMMWuGpHNXtQUpWKbY7MVntnGhWK3wp+PnehLsbrafOW2vDKKtohcFpa9dZxmuAutH8Ym/KvFa0A487my7YXSZAlpJek7xCCslENQTe0852KcXYigIGaUjZGH58f3ihEskHjLWtvoN4n9iux3nNz/cmVMqwPynwhaDUho82W/ie4OvjOf/Zl8fkpUIImJWKaeG6MxLfdRW8pXittnVRILF8VoZZjQB+8nDCHz+Z0Iqc7/lPvjjkTr/F7X7M3//yhEE74u5GwmY7pmz0aQLk9786Iqs0WakwWB6d5Oz2E45nFf+F3955qSTGGmu8BN5Jn3UVfq+z63pZKzwpOclqgsV79icFP34w4qPNFtudiKLW/Gp/yp2NFp1FkuMXT6YUjSKrNOVCcUQKQV5pHpxkfG+RcHw2CTHMK2LfY6cTP+VDLiIgFNaCgLoxHGc1vcgjCRzh++NxgVhIOAeeYF4qfnx/SL8V0Y39525y3tVN0XuAa7Wt/+zXR/z+lyeM8wqlwffgcFryyWabf/H37l3fXT+Dk3mFtZZx4YqorcgnCb0Ln+XrwvK53ekk3O67AuzJvCIOXkyp62Wu+ybiwXc5Dr2KCslfF0IMgP8Z8LeANvA/X+ldvSNYOjNjLQfTitCXdOPg1PBW9QA867ROMue0WnGAEBJjDcO85nBacm+zRSvyeXCS0Y0DAl+itGV/UnCjG9MsJj2mRcOkaIgCjyRwUqq/OcpoRd921j/fmxD5kp8/mTArFZ3Y5+ONFgeTgt1+wleHMx4Mc47nFY+Gc5QRHGUlv32jxySviUMfa+Hr44y6MSSRRxp5ZLVioxWdLlBfHs1oRQFp5B7TNHL38eXR7ErKJB8g1rb6DuF9YbsuG80v9ibktWJ/UrI/KQg8SV4b9sc5yrgN98EkJ28s0kJWK/I64g8ejLnRjd/mBMYSK7etywKJvVHOMK/5+jjj6+M5j8YF47zmeGaolaWXuGTy/ZPMyWFHPr/en3PSrvloq8XJvOL+MONk3pA3mkZpilrjScGkqgkDj//vLw/5/Gb3uZuT8zYmwHqzssbL4J3yWVfh9zq7rjfGnkrT708LsHCS1UyKhj/em/KPjWEzDdnqxGSVopsEFE3Dr/cntKIQgeVwVvFHj6d8/1aHe5spxrgY7Hc/2mBvXDxVTDqaVcxKxf604OPN9rn3d/Y+O0nIZkeyPymw1vJoXPL1yQF3N1N8KWjHAZsd6Ww+q/GkpKwV7cg/t5NkaffjvOYXexOqxtAYg+9J4kXiJQ689VrxenAttvW3f/KER8McDRhrkEIyL3P+9k+erDSBcTSr+MmjEZNSYYxBSsn+uOB37gxWGh+9qbhs2cn+1fH8NGFzq5e8luu+q3HoZQmMHSHE/3jx30s2239z8XfrnNd/cKgWpEa/PphTKk0r9Okmvuty8FeXKbzMad3sJuxPSgJPYBYjHj/fm+D7ktoYxvOGWhmEAKUNH285J5c3CikEgece4sBzZD2NMU9dO1hcb3+S008j1xlRa/7h1yf8qbubnMwrDqYVXx3NGc0rRkVDoyzHswpj4JPtNlpbOklAqTTtyENby2heo5KAG9341NnOS8XgmYpgHEhG+Wr1p99BrG31HcS7xnZ9UUXtZF5RKMP+uMT3JEkgeTAsmBYNCstkXvP1cM4ot4QeCA9qZRlmJULC/ZPiTX+0y/DabOuiQGJvlPNgmNNNAqrG8GhYcJK7EZ2yMRRKkVU107Jmu5twoxtRNIpOHOJJyddHc7wbXb48mDMpaqZFszi/jzGGh8OCXhwSSEFZKwIpLqy0npdk+fJojrD20g7ANdZ4Bu+kz7oKwd/ZdT30XMHI9wR7o5rNdsjjUUHRaFqhR9UYHg5zfnCrw62B+9j3TzI6cUhjLAeTknFZY4zmi6M5nie43U+oKs3P9sZ8fZTRjgKS0EcISRr6VI3meFbz8eb597fEtFSUtaIxlq+P54yymm4SEgceWsMX+1N+61YHaDHOa0LfkTgWjSb0JVWjz+3Q3WxH/HxvgjFQNBohBU2t8aXgD+8P2enG67VitbhW2/rF/ph5pYhDDwFYa5nXml/sj6/hVi/Gl4czvj7JiHwPgcCiGGUVaejzw3uDlV13ua97Mq6otVM/6afBabF3VTiaVfzx3gSFI6ecV5qTacV3d3srTSS8a3HoWVyWwPBwGbvzVGtW/Kt8d/DV0Zz9SYknoag0o7zi7qLl7uwDcJ3tdAeTgjTwT1sSzzqteBkAWzc/FvoSC1htuD+s0IuEhLWWA2P5we3+4hwBk9yxWi/HQnwJgfdN4DrOa7JS8Xic4QmPKPDQxlI0hnmp+eJowqc7bb46ntNow7zRWCNIQsm8UjyelGx1Yo5mJX/yzoBW6DtJrkWypGz0U862HfuUjTntvHD3YWjHV2kc+qCwttV3EO8S2/Vl3QGVMuRlw8lCxejLo4yybigaQ1E1TKqGsjJYQBn3QFrr5PjmVY3FXHrtN4zXZlsXBRKPRxWBLzmaVTweZxzMSqpG43uCXBmUtlgM06qhGlp84RLXdzYkm+2QprFM8pr9WUnse1S+m5W3ViGEZV5posCnsYYvDuckoU8/CZ6qtC43GOclWfJKgYDNzrtXwVnjjeGt8FkvGpddhd/r7Lo+aIXsTwoaLbBYJkVNVjVIKfE9SehLpmXD/WFBGjlS46xSpKHPqKgpGoVSlm7sM68007xBK0PoSyLftbQbLIfTip1uRC8NeDSsEdaR9l6kxlY2mnFW4UlJEno8GZeM8pqs1DTGcJLVHC++l893ulTKuM5cbQkXRa551SyKdU/b/ZdHMywwqxqmpXuNFAIhLLWytBK9XitWi2u1rbLRaAMgFokE0IZXIqO9Ch6PcuZFzdgKtLF4UuALe2p/q8RXR3OUBm0NnpAMs+q02LsqPDrJGOY1QeBhtEV6gqbRPDrJVpqweZfi0Gdx2U7wibX2f/3a7uQdRFUrHpzk7E9yamOJPI8k9LjRjp56AF50xuh5TlUI8dTSdNZplY0mkJLGfEPGlAYeX4wLfE+AEBgDjTYUjeGPHoz4/EaHyBNstl0bY9FoQk/y8XabadEwKxon2aUNk7wmKy21KsjrBmWgGwfc6EcIKxhnFXujgtATnMxrAinxfZ/Y98grRehJam0oGkVeK45mJYHv0Qol/TR6ytl+tt3hx/eHgOu8KBtDVjX86KONS38vH+Ds5dpW3wE8+1y2Ip+Tudv0X7f073XbwGVthljLtFRoA4fTAqzFGAilZGYFoe8jhfuctQW0+yOA0NfcHry1BVd4jbZ1USBRKY2wlnmpmNeKQMJJ1dBYQ+T5SAFKgxWCWVnz072GG52I7U7E3qggCSSPhzkSy5NJiS8Eo6xCG/fc7Q4SpkVNL/E5yUuyymeUV2y3Y4QQZLViXNT8YLd/bpLFWPutsPhdqeCs8cbwxn3Wy8x+X4W89mySI/IlG62Io1lJJ/KZ5A3dJKBWdhGLWQatgFnRUDQaay2hL8lKTVYppIBpWTMtBP1WgC8FXx7N+Wynw2jRSZVXGt8XfHU0Jw18Km3Y6cRP3R+4DeHSH1SNppsEfH2SUTWag8V4y/2sJggkYlYR+4LDueaLwxmhJzmaVtRasztIKBtNXumn1oKy0Yyyil8fzGmHPg+HOVudEN+TKG3YG5VstAKMsU+9ZzivmJbN6Xf3nsdqrwPXalvdKGSWV4wyhcX5bbk4vkrMKsUkV5QatNF40iP2oJuqlV63qhWPJwXSur2WtRYj4FY3fv6bXwGjsqFs3Fhn6EtqZZxNlc3z3/wKuEpS9m3FZQmM87J3a5zBo3FBVjekkY8qHB9FXjU8HOXcGqSnD8CLzBgtnaqxMC/dvPL9k+wplvidTsRP9ibsDXOy2rUibndjdgcx1oK2lpu9b0hE23HAOK+5009JwpCiNuxPc272IuaVcmSapWKa1wSeJI082pGPEE5C6cujGUXtWOw7SUA38ZgWbjazEwcUjaKbxmx3YrpJwLxqiANHBpVVimqu6aYBaeBRaydHpLUh8F2FcF4aikpzq/t0MNBPQ7632+MPH44Y5w39NOCHdweXEs29y4Q0r4C1rb7lOO+5XJLaLhUirkvJ4bptoGw0D4c5QrgAvp+6NuPTTaoQpKFHHAhmlSIrFbOyYbMd0UtDtNGczCTT+ulOCwtUyi5qOm8tXpttnRdITEvHTWS0I+ibFg2FsggJgZbUSqMx9OOIRhvCwCMAGg3/6OshH23EfLzdJfRB4Mj59uclSeRT1ZpeGhBKSeAJpqXC99wY5Lho+PneiH66QyfymZeKx6McIcS3kizymYQ6vDsVnFfBB5gov068cZ/1srPfzyOvfTbJkYYev7souvz4/pCTeUUrleSNpmg0G2nEzV6CsIKvjzMCT3JUFBxOCjZaITvtmN8czRFYfqM0j8cl7cjjo6027cTnYDpnmFUoA/c2EzaSkO1OfEokf54/+OJwvpBWduTzyjgi+GWHaxhKpIAkcpxuSy6LXhIwmtfMS4UvBNux29SVjWZ/UlIpl4R5PM7Yn5SEgWSjFaIN+J5ASomU4sx7CgSCXhI44tD3P1Z7HbhW29ruRtwfuQLEMoFhFsdXCdUoDmYlVgi01nieh7CWW73VXvdwXoM27E0rskbTCjxudiMO5zXfW+F1jbb0k9CNXGlD6HsEUmL0auOjd1lR7LIExj/92u7iHcXepCAOPISUeNJ1FtTKcLhwgMsH4EVmjE7mFcbCMKsIPY9uHFDUjiTve7s9skrxeFzw9786xhcS35dkteJ4XnF3kNBNAkZ5Tb0IqhptkQI+3myhjaVUhnndcKOXEEpJpTTGWrKqcfProUdWa/JanyZNBmmERNBPBaO85qOtNr//5QkW6EYe0pM8Oin4s59u0mjDD2732BsXzGsPWWuUcqoldwYJoe/RS0N8KRlEPtoYTuZuLts8s+yWjatC/GC3fxrQZ5U61TU/D+8yIc0rYG2rbzkuei6zSl37c3mdNrAMfj0p8BajCfuTkpu9mEYZJqULZjuRx7ho6MQ+RaUW16u5PYj5zZELkM+mLwTO+aSBx08ej1/9Q68Or822ng0kwKkEdBYJ6N8cZWAEd/oxh1PBwbRAAr04xAqBFZZeGHKcV9RVTRTAk0mJkB6+hDgM6KUBsS+xWDZ22vhCsNGJGeYlH291UNq6DrlK000i8kYTBR6t2Cf0PRqlmZbNKYG0FALfk0SeoFbmnavgvCw+0ET5deKN+6xVzn5flOT43m6PR+OCk1lFPw3Y7SdoA6EniBcbh8AT+ELweFzw9dCNC+9uxE4SdZiz1YkIfB8QjLOaSml8KbnVj9hsxSShR+TJ0/X+3LGvRvFkUrKRhhhr2e1H/MHXJWnksZEGnOQ1x9Oaz3c8fnM840Y3ZbsdMykasqoiDiS/daODFFAv4rtKaY5nJbf7CWVjuDWIeTTKqRuNspbtdkheKTzp1orhvDodSRi0otP7e89jtdeBa7UtYQVJCEq50RFPgu+746tEqSGvFcqC1RbhGXzhjq8Se5OcR8MSz4dW6Dly22GJv+J1fXeQ8MuDKR4CIQSlVmgsv31j9XK176qi2IUJDGvt8HXeyLsIiXDER3FIGvkEjUHrmo306UrMi8wYVcowLxtCzzvluEhCj+O5OiVM+s1RhgX2JiUCSxr6JL7k509m/MXfueUy+LMSZRwJ2+1BihCCvXFOKwyw1hJISdEobvQSRllNGvjkjUZKR+QpBAznFf00JPJdtSDyJU8mJdOi4c5Gwt4oZ5xr7myGfLLVJvA8slLxWzc63O63+Pp4xs/2pjTKEAaSQRyhlKHfS0gCya+P5jwe5vSSkDsbCRi+NW89KRp+dTBkWrjWy9+60SEOLnZwb4qA501ibavn422qkL5OoqTrvNYy+N3pxuxPCkLhOi8eD3Mqpbmz0cITgkdjtSD0VfQX3/PBtGJvWtEol8Q8CwtEnqve743LV/m4K8Xrtq2zgcTjUU7ghdTakpUaYw1JKIlCnzj0acU+j8c5k0IR+AIP+PpkTjvy6bcjhJR8eZxzZ6NFEvqEnmSyaFnPlSWQgp1ujDIwLRTzsiH2fbRxbey91Hds6KHPzV5M4AlO5g2T3P3xPMEgDfEl1Frwhw+G1Mpwa5Dw/Vu9F5ZYhHdHyeQDTZRfG94Gn/U6Zr+Xz/m0VOR1Qxr4/InbPR6d5BS1BgtbrZBZrQh8yZNJQehJrBD89s0Oo7xBGe2SxUVDvxXxex8PGOeKWdVgLZS1ZtCK+O6tHpHv0WjDSVZh53A0K/mjh2OS0GOQRny0mdJLQyebuhgbKSpDozTaGh6PCh6NCiSG25uOy+3XRzlaw3Yn5s7AJVyyyimpfPdW7zROq5Rmt5/SjgPyxjDOKxoNyjhFvlbk1qzYkzTaMC0beknAoPWNna9Hz14d121bpVa0A5hqsAKkgHbgjq8Sk7JGaUveGGqlXbI4kEzK1ZL4j7OacdUQGw/HXCMWnDGrve6djZTHw5x5ozFaI6WkHfjc2Vj7k4vwXrIhvq6NSy914xJOR1sjhKAV+fTS4Kl7qZThwUlGK/bZbkeuW+OCCtUyWdCNvzmHMhblWHQYZhV/8GDEcF7ST0PSyKNuLMdZTXA8RwhBJwmIAg8pOL3Gbj+haDR5pdDGoo2ml4bc6MYcTEuKWvFgmLtzhq6q9GCYs9GOqBrNw5PcOSTlCJ5C3+PzGx3asc/NbkrgQVYqhHAjK1IqhBBstAIsliTwiSOB70vGRc0wg1nREPoe47Jm9Kjm3mbKTjc+DQIfjXL+3ldHSOHhS6d+cjDN+bOfbl8aJD4auURNEnhkleIPH8wZtKK3Pihe4/rwtlVIXydR0nVea5kMEUJyc5HsrJULkL97q0c3CQh9yW+Oc2LfQ1tBNwnQBm71BA9GGaWyFOf4/rkGv1C83Ryebw7LZGylNY/HGYnvY7CoxjAvahqtwTqZRikFR9MCbUFIVynLSkXkuVn0T7Y7bLR8CuXUn3baIUWj2JtUNI3mwTBnb1zQT0JuDxJqo0kij0HqMUgDRlnNKK+5fzLn0+0On+y0UcbxcuxPK6pGc2+jBQLyWrM3yokD70KOp3ddyeRdZm5fw2HVs99nx4EneYUUkolqaMeOgD30JVHgEYeSB8OcJvRIY5809Nkb5rQTnxvdmGFeY6yiURVx6Ig0PSE4mJRY4yiQt9oRke+ex7xW/OzxBCng4TAjW3Q93B60eHCS8Wc+2+BoVlJrw7hoUI3ieN6gFh2urUgiPUmjNF8eZWAF0WIUpR35+J4jd5/m38zmh55knDdstJzP2e64kTZrLGHg0Yp88lrTTwMC3yPyJZ/vdDD2GxJQ+DBGz941NA3Mawg8130hhft3s1pqBma54nhWUTaONsvDkAewm682cdJoizWGeWHQ1tmaJ93xVSLyJPe2WjTGYox1xWQpiLy1PVyE9+6bOes00tA7natbBWPuvQ2XVa61pmo0tda0Ip97i4zZ8l4CT/LxVgssfH2c0Syc5HmB2WY7QgBFrRcs0m4sxRrHieG4MdxuIKs1w6ymMQbpCY7nFfuTgvsnGSfz8lQuD1xl77PtNrv9hM+222y0Qm71ErfZUZqfPB6jtQtIj+cVe+MCawy/2JsQ+B7b7ZBJ0TCv9alBH2U1s1Ituj0sUSj5ZLvN0bQEKxACktCnFYZ891aPnU5Krdw8/fG8ZF4qykZhzoyGHM+r0/v+xZMp00JxklU8GmWcZBXTQvGLJ9OLfyl2MaUnoFKaw1mFtYLIFyt9FtZ4u3C2QiqEI0VaShu/CWy2HUFtrQzWWmrlqgrLyvPbeq1lMgTcGnKrn7DbT9nuxHQWakCuayBGWUtVa8pa4QtACG72YvK6uZDlojIQrwPW82Etj0YFoedxdzMliTz2JxVZ0zApG4ra4AvJvc0W/TRCCPAFGGOZLvgydto+TWOQwvJgmKG1YV40DLOKrw4yTqYVs6qhE/kcTQu+OpzzyydTRvOGX+xNOJoVPDieMy8VD09y5pXmwUnGvGwIPEnRaEbzikBKwsAj9N1mJVsUEc7DebaZV4psIc/4Ntjr83DWLpZYb77eLSy7neQi6bYs+FxXwmz5nGeVIvJ90sgH4WLANHSFrs12xBf7c2LfIwo9SmX44jDjOKv4ycMxj8c5s6Im8SU7vZg09Pn1wZyiUez2E/ppRBJI4tCjUYaycfFRrTX3j+eAQAhJoSy/2p9yMC342/94j6+Pcualdt1UpaIxhkZrQt9x4PhCcDyvqbV267yFolZUyvFWPBzlZJXiy6M5xsKtfoK1locnBWWjkELQT9xo2zirEQjubiSEnudi01K9Vp+4xitAWJoGau1UxGq9SF6I1W7o9yYZswYaXAKjAWaNO75KBL7jf+nEAf00ohMHSMFpR/zKIASfbre52Y3ZbEfc7MZ8ut0G8cbpgt5avHfe9nVuXLpxwE4nYasdk0Q+npRYKyhrfdoFsryXJPS5t9nis52Oy7pfwnL9/d0e2hhmRYPAstkKqZTrmAg8SScKyBpN3WisNlSNYTSrkbhNehJ41MoyyuunNutLh/293R6/+9EGaeiR1xplLHrRrRIFEmvc+Mi4dC2KoS8pteVP3Onz2XaHXifg8aTk8cmcn+6NyWpFrQyfbXfQxnJno0XoSyZ5Q+L73OwnVAt51tDzOJyW3N1IscKitCWOfG71E8rGzVTnjcuwHk1KxwminVSs0e73ezS5pOVcCLbbISfzin/8aEJeK3Z6EVLKtz4oXuP6UC3m8c8i8ASVejPl/lUHy6u61kVB5k4nOt3ALbvMDqcVUehxq5cQB5LGaOrGkteWi5ovA8Eb+5289RACcAof/ThASkkr9tAG+klEHPh0WwGtMKAfB8ShRxIHjpPJE+z2Ezzfp5MGSASJ76GUIZBiwUuiKZWiaAzKWO5utElCyTBvKBvDvUHK0bzip0+mfH0ypzYaYWGY1/xyf0alNNoY8sZ1ayzhS6euMC0aHo9yvjqaP5U4PmubZaN5Mi54NMo4HJdP+as3aa/Pw3rz9X5guVZ+ut2+9vV4+ZzX2sU+sOhStYIk9NxoWKXwPEEceuSN5mRWYaxTWxPCdVNIIRiVDZvtEE8K+mlwOu7bTQI+3e6QBBKwPB4VGGVohT6+7xN4gjjw8CwI6RKFx7OKcVmTBo54uWoMh/MSIQQ3ehESSSvy2G5F9NMIbQVlo3g8KvhPf3XIz/bGDGduLOZgnGOsJQl9vn+7hxCWvWGBwHKrF9MOfX7rZpfdQUIc+IvNoSSvHdH7ZjvicFbwy/0ph7Ni3SH7FkJbS+AB1qldYV03hrarTWCczGoMThM2WPxtFsdXiUEcEviSWVlzPC+YlTWBLxnEq1VdiXzHpXizl/DRZoubvQRPynVS/BK8dyMkr7W1UwhCX9AOA4pa0Qp8wkCgcZX+WhkGracf+qvcSz8N+dFHG0+NwdzdbFE2ikYZtrsR07LhaF4zMoZBOyKJPLa7Ib4UKG2xWLY78YUzuWdnrQ8mBZ9sdygaF5AFvmS3n/J4lPPJM9rH2loeHeeUlcLzJL6QzIqKo0DyZJQThT6d2KebBHy82WJaKsIFwZsyjiAuDV1GP/J9ZnlBOXdBtZSCu3XEdm/RwWI0aehTG808cy3xaehTmku+P2s5mtdstl0Loy8Fw3nNzoIxed3m+2HgbdS2fp1ESS96rYvG7i5iqIaFLN+ia+p4WjFIfYq64XBagRAkvs/+eIa+xNyEBE+uKwwX4c4g5XBacjCrGCQ+260uv//1CGMcS7nWhsNZAVhaUYAnJLHnEfiOHG+SV9wd9NjoRFRKk9eKu1tt+mnD8axASo/DmUvobrZDKmXxpSCvFA/HJbf7MfGi86OT+ChryCpNXjbc6MUYA55w6/ISyli0dgn0dhx8ayRkaZvGGser4nmkoY/SsD8pThW03rS9XoZ3mbl9jdeDUx/kSZS2BL4gb1yXrjLu2Z6VilppRvOaOPIQEmZ5Q+x5bHRilNYobdDa8ssnc/pJQNqS9LyQz7bb9NMQay37k5JeGrLTaG52I366N6ET+5zMKjQG4UlutAL06ciJs/VcKUptsNowKRtaYUoSSjeKJiAvG4QUZJ5AWI0B0shj0A4pleKL4znTUvHxVptBK+SH9wY8GRd0E8eddm8zpWzMaSymjMVYSycITn3OTifhdl+cKnNdNHq2xpuBI2sGhRsfWfJgmBUnMJSBEAhCTuVPRO2OrxKdxMcYgbJOpUdZgTGCTrLa7fK7LGf6snhVuof3LoHxOjcu1UKzd1bV+Iuql+9JN/fne4yLmrYOCP0FCUxeu7nkUFI2yQv9orqxj+8JnoxLjIVxUdONPWLfJw4CJmXNrY7juQg9l8WLfHmlzboQgl4aMB0psBbfE24sRUjakePi6CU+v3gyY1bWTtM8DrESbnViWlGEMJafP5nx8XbKk4lzVlYIsloxq2rSMEAZQyf2+c52m4ejHGMswhM0tWFSKj7aatNYTn9X2+2Ef3RyjMADq0F4WDR/enPrsg9DrZxG+TCrESxmLBePw9scFK9xffgQncFV8azTaEX+abfYefwDy83a8n174+LU2Swllkd5zb3NNvc22/zqYMa0aPjerQ5fDzPCgHM5MNy9wMaK5djeVUS+XMyIe3y82SYJfPYnJUngYYxEeoKytByNc6rabS42Yo8olISehzIuyfybo4xKGW73XUUn8T2qQFMqi+8brDGUyjDJBZOiZrMVoIxlktd4wvmystbcHsRYY7ERzPKaXx1M2e2npJHPL/YmdNOAVuiqrL4Q7A7Sc0kul7Y5zGoC6dbmJPQRi/8N5xVbnfitt9d3lbl9jVfHVQLvVuTz870J1UJNrZuGYF1Co1aGQRrwaJjje5IwsDSL5GHgS7pxwk4/4j//9THHs4Zb/Yg0lBSN4fGw5KMzhSVPSu5upKfJwbzWBP6cdgiHtmCSN6SBhzWgjaUyFlVr8kaz3Ynwpc/joUEISehJAl9QFA1lA1Wj+J07PZJAMq0UgRBYBE9GBXPtJCZDz8Nal3zcaEXc22w9ZRdFrclqRbEggt9qRyShtybCfUcQepJiQTthAKmhWBxfJXqJz9FMuXGVpX7r4vgqUTQaZQxF01A1migwxL6gWPHo+YeWFL8Onrr3LoHxOjcueaNIAt+xKC9GVopaUyhN4AnSMGBW1AyLhsOFJnY39NiO40t/UeO85ud7EyxOZrAdB8wrxeGkYNCK6CVuHGWS17TikH7is9kJCX3JR5ut0/MspVSXuMjp9mKfn+zldOOAWimyyo3A/PBOD7GQyQo8SSf2eXSSE3gengCD62aIQ82s1JSN4U/d7ZOVBYeTCmMUoS94cFzheTVY+O7tjtM6HguKJgcjGKQBN7oR290FEdUis9tLXFA7zpy+eOR79FvhhQtY2WgenmQcLdowI1+SlS6hUzfmtM137Rzff3xozuCqOM9p/Hxvwk4nvjSQPO99J/OKNPCRqeDOAKR0ccatXryQ21T044DwkjgniaAfv3du6Fqw9GVZ7brYnFx2yXYr4jivyCvNpGjoRgEz6ypEcejz2VYbXwp++nhMO/K50QmJQo+vT3KiwGNW1HRin3YScDAueDIpaLSTQhRC4EufyJeEgUQby08eT/h4s4VZjEo8mZRYaymbkn/yO9tkpeJkXjPMK6yF7SAiDj3mZcMorwk9yaAVPpVQF8CDk4w48NjqRqd+a5Q5RYOdbnypvb5NCkNrfFg4y7M2nJfsTyuUMnz/do9PttvEC8JL110QL4jeBZOsZqcXY4wbC56VTlmtmlnubTqVp2nRMC0bugOfnz+aAoJ+y0Nbi25c6/6kaJjmNXmtmJWKjTRgd+A6ZqeFs7nv7LT52eMxO92ESdGAkDRKcXsj5RdPphzOKwJPcjit8D03ihKFPmnkMa8UtYYkkNzqtbjdTzjJG5LAY5I3NFhCKdlIQg4nBQd+hb5tEAiOZiW/+9HG6XfVinwenGRY6zo3WqGPEG5t2xsXayLcdwCVMkgcDwU4H++x+tHPH+z2+P/88sTJqOIoN/zF8VXiZFZzMispNVhj0cZgVLny0ZUPDdeRwHzvIsfXuXFJw4DDacEoq1DaLlilJVtxfFrpLxrLNG/wPeGqTQsuBinEub+ostH8Ym+CLyXJgnF6mFUobQh8j0lZ83hcEHuCj+8OaMcBvSRkkpdMF1wU5yVuLst2Lcc+xnl9GhDudFK2uwm7/YSTeUXZaG73Yp6Mcsa5z7hU3OiErlujMTwclfyF73acAkpekcYeo0xzPKv5ZLuNlACCadaQBD6fbbepGkM/Cam1u6YnJHcGCWbRmZbXCmElt/qpG0PRlrI25PW3WYiXny9rtFNG8DxqrRfPQs0kb1bKO7DG24d1hfTbOM9pWGBeNXSSb5SPng0kL3I246KmbAyt2OPXBzOGeU3sCW71EjxP8sXBzPWbXkDjGfkg5boj6jwsn99xUfP4pKAd+3yy3eJgUuH7kl8dzEgCR/CZho4XqZf4aKV5PCqIA49BK6C2kAhJ4EtGWUmtNEngs90OmeaK7U6MFTAvGnwJRlh8T9KNA0fYLNzm46ePpyS+4O4gZjhvsAL+6MGEQRrQa4XcGiQkgRsH+eO9CTd6yakPW1ZnPSlO/dDtQcLJvGFv5DiNbnYTNtsx2534Urt92xSG1viwcDKvMBb2xznjQtGKfBrP8Mv9KQb4bLv91HrZSQJu9V0hSC427yfzisfjnF4ScKMbUzQaKQS+LAikoKg0xlqEAIEABFa6ca27Gy0KpfjjJ1Nu9GLa8TfdDINWiLaWrw7nbLYj0khzu3+TolYIaakaSysM0LrAWOsIfiXsdCI3nhIFlNqS+IK9SUkcSHLl1oODaUleNcTGqemFnqTXDokjycGk4vYgpuOHpza4TOJsdWLmZUNWa/Ja8/1dJ7H8No55rvFtVNrgeQuCaLsYI7Hu+Cqx0YnoxYK8sWgNngdpINjorLZj89FwTqMdaacxbrS9UYZHw/lKr/uh+bXroHt47xIY8Po2LpEv0drQjgOOZyXSgKfsomtBI3BEn1udiCTwEMIZwiirF+z83/5FncxdFSsJ3euDxeK+Ny6w1vLJVoc7gxaNMZS1wdiGfhqy2YkZaE6J+55N3FyW7aqUIRCglGWS1QsW+xpjOK1uVY1mb1Ly+c0ujTHYYUlWL8j7VEWpDNOiYZI7xunNVsj9kzkW6+Y9PYknBa0oYH9SsNmK2O0nWOsWikY75+5JSbDwZ+Os5mYv5MG4JKsVrdDnXj8+V495+fm6sc+0UCAgkJJpodhqh/TSaL2ZXeODx3lOIw088urptejZQPIiZ+O6zAqGWYUnIPEkpTaosibyPA5nJbP8/OSFhxtfq9aqQBciDjx+sNtnVii6ceA2N42hm/h4EqrGsNGKEBI6xkdiOS412lg+2W7hex7eglTz8dCx/we+R+Bb/vjJhFYU8p2bHXb7Cf/o/hBfSnzpRiGnZQMWBmlI1RiyomFiDEezmnmt2OlGDOcl3cSnbJx0auR79JKAyPewOD4M3xM02lVnb3ZjQt9z3Rzaoq0h9iXjrKZRlo004NOdzqXfybr1fI03iUoZ5mVDrgxp5Dt7kQJjIK/UaUyVhq4TY5TVzCtFXimEFHz/VveU7HUpI9oDbvYcq76UgsOp6zrFun/f6ERYBKVSNNpwo5PQTQNudGK+OJjzp+4OHNn64nqelGht6acRvhD89s02/+DrIaN5hbaGnW5MVmvKRlE21qnfCUk7DridBMzLhqNpxUYaMppXpJGkrBSVMjSqYasVMS8buguOGwS0o4DkjI84a6fdRXK8VoasUi5mvaRbet1h9fZASoHVULEYIcFxU8gVc1eNspp7my1mtVPICTyPTigZnRP/XyfmtaExisgGi6SNpTGKeb3ahM2b9Gtvwt6uI4G5TnW+CqwlDHzuDFJ+506f7U6CReLhKv0IQeAJIl+iFm0F/oKV+qJfVKUMaeSdvn75nkleE/luvvjeZuqSHJFji25FPrWyfO9W50JG7ctUGUZ5xUnegIDtbkwQSKalZn+Sk9cuK1hpN36BBW2gG3tkZcPjUUYa+PzevT7Gwk8fT5kXDU8mJaNZjdKGYVbz1dGck1nN0bxELxxVK/KplHPsVaNphf5TTO7Gwm+O5wSeZHuhwPKb4znmnP3Q8vN14oB25DGcVzwa5xxNS9pxQHfdpr7GGufKP7bj4HRU7CJFhYtkI7uxz41OhBSSSlu2uxE77YhHJwW/2p+S14aLVNs1jpDLX+ucX4o48Li32UIv5udbC9nEYNHNN6vUonstRQqPNJR8tO3I8w5nJfOy4f7xnFlpaMchgzSgFUoiP0AKS6Ncwvtuv4VZkAbe6EaEUnI8q9juRRS14sujGV+dZGRVQ6MN80ozLmqGmetwA0DgVKmMZpA6+bmi0YS+YJCGpz5xnNd04oDbC56M5Xx8HPrPDZzeNoWhNT4sRL5kXDQcTysOpyXH8+pUicdYe7oJmJWK/UlB2WhmRUOlDFWtTmMqF7c9rWQzrxSDNOSjzTa/c2fA3c0UrGBeK7SxTPKGVhTQSV2SUEgBFn5zPOP+ScZPH4/5+mTOF0dT/sFvhnx9NOdgUvCr/RnWQOBJdroJdWNpxy523e5HHM1q2qGLJw2Ok+bPfb6FLz0EEEifja5TFekmAWkkacUBg3ZIO/KdhOowoxW5OKtsNA+HOXvj/PQ7gKft9CK1LOB0RCcNPYzlKRWjNV4vYiEocP7aLv4uFsdXCa0sSeRzsxtxq5dysxuRRD5arZY8NPIFkXTj69q40ahI+kT+aj/vm/JrZ0fiXqe9XYeS13pX9yoQgjsDN2PYWLjRjfitG22M5akWuX4asr+Q/rTGIuBCLobId8SZJ4ssoy8dr0bku/PtjQvASaXmVYMUAmMt39lp8ckllavLsl1NYyhqRRz6ZJUi9CQiFCAEWeX0uh8NczzpZGm32qHbvKQBu4OE3X5KtqgwWCxfHzd005BZ1SCEIAkE8aISeDwrudVLT8d8VBqR1w2dwGXvz2b+DIZGWSpdL5iQBdJaDN826OXnSwKPL+f1QsM5oNKGo2nJnXVlbo0PAM/LpJ9X9ZICvrfbczZ8wdjdZdWyShl+eK/Prw/mTMuGLw6ngOUkbzDW4vFN8HMWAtjpJOeOhK3xNFy3miPUvLOR8nhckFeOPPVWN6EVeU7hKfLY7LQZZTUn85rN1OfRsGRvkiOEpJv6DDPFdifE9wXjvIFE8LO9qXtvN6FSikejnLwy3BmkbLViDkYlyljS0CeNAgJjKUvFsdJU2vLRIKWd+LQICBcz9UWjudlLgG/a58H5nUqZRVeiZKMVOd37C7oSn8W69XyNN4lW5DOcubHhxINGGaZFzafbHaQQp+vu/UVHU1a7zgtfOL6vZUyVVepb487dJEAKQTt2XRg73YRaae6f5LQjgzWWWrnESC8J3QhfrTjJK9pRxU8eTZgUDUkgSUOfeaXYmxTcHqTcHaT8g68LWoFTrJvXhqKx9KKAjXbIRjtmIw25OYgpG0PoS369PyUJfaJQ8r1eh7xK8SWUyvDRZotJrvCEYKcbM0hDskoRBx6PRy5e9IRw4zaTkpu9+PT7WeK8bullG/26w+rtQKGM65bE+fGFoirFijfWtwYx//D+iMD3ENZghaRRmt/7aLDS694epJzk9eLZ9ZECtCdX/uxFvmReKrJafUOwHvpPdTWtAm+q8+M66B7WCYxXwJIlfhmkwYLwchFXLYP+0Pe40Y04mldkpeLeZovd/vkqJMv3bLZC5lXDrFAIAd+71WGYN2hjCTzJ7Y2Eso640Yn4/EbnVEngRTYuyw3Ig5OMbhxghZP5SgOPVuRagOdlg7WWXx/OuNlLuNVPHInPIhkxLhTd1GmSG2PJq4Z5pbjVTxjlNbNCkXc0dzdStHGzlJEvTh/e25d8v1q7RM+oalDK4vuCQRScK8u4/HyTomGzFfJkWjLJG25vJK5dctG2eBWs2xfXeBdxlRnKy5zGZfZx2fsiX1LUmm7q84cPh/z08RhtDFPHgkUUQnVO12fbB4thXVh7Ppbf/9644GBS4AnBP/n5Nmnk8/XRnL1JSSAFP7o3YJLX3O67Trz/5FeHnOQNgZS0omDR/VByMC0wxp52+jVK4UcBbd/j8502vznOaUeC7V7EvFIY4eTlPOSCzNMRiiaBTy8JsViK2rDdlnznZpvhwtfZrv0WH9PjUY4QjndlWijyWnG7nzAr1bfGlM7DWmFojTeJrFJ8d7fLr/bnnOQVnchjI40YZRVbne5pvDBIQyqlmU4aogXJ+yivMRb6aUCzKHQtCS0fnGQ8GOYEEm4NWmx3IvbHBda67qXtdsy4qNkfl2x0QrZaIXujgl8eZjRa850bbYZZSV5qMk/wg1uOmDmvNE9GOZ9stvGEUwvpJj6hJ9juxXgedJOQOJDc3UzY6iRoYziaV7Rin04SsNGKacc+HvCbk4zfHE/ZSCM+20q5u+WIS6215LVmb1wwzByf2iR3kvahLzmclWyk4XPt9Dpm49e4PlRKEfINiadkSeK52sLD3X6Lnz6ekNcN2oAnNWnoc7ffev6bXwGfbrf58mjGo1FBWSniyOfOIOHT7fbz3/wKaEU+P3k8QS3G6Y113al/9tPNlV63WhQXnowram0IPXm6Pq0ar0r3sE5gvAKeF0idDfobC7u9hM3bl2+Glw7ty6MZ81LRjn0+2+4wzGrmtWYQBvieQGlLVjfs9tOnEiUvs3G50Ut4OMxRxuALQa0MAuglAZOiIfQ9NtshZaP46aMxWaUpakVjFJ7wyCvFvGropRHbnRCDU1JJo4AkcBJbvz6c81s32vz2jS5R4F8pSTDMawpl6UchNrIIBIUyDPNv74aW39sfPRizN83xEG4cRkqO5xVSCG5fIXH7oRHprPH+4KqZ9Oc5jYts86L3tSKfX+1PKZTmi4MZShmyRlMpRdMYPCmQ2G/1TWkgqzVJsK6cXxXWWu5stE79zUlW000Cbp859tVRRq0UlbbMy4Zb/ZiiaphVmqNZRexJJzVdK+JAOiWT2CNE4EnXsnqn53g1pqVCaUsauE6JaeFm8GtlCKQkkBIt4Ghacauf0kt8It9DW9hfbGQ6sc/dhcrI8hmqleHHD0Z004A7gwRrBY+GGT86o2BwEdYKQ2u8SVTK0Ip8troho7xib1zSjX3ubbX5bKFCAtBNAowNqLXhYFq5dc4KtLU8GhXs9mLKRvPl0ZxR5hSd0tDj0bBgb1IR+BKBBWvpt0JuDhKssKSRjwD2pyV7kxLPg34aMi0VR/MGX1hCfLJaEYU+noBh3lBpzb2NFpUyHGc1rdCRwneSkM005EYvJgx8GqVBCHZ7Cf/M925ykje0Ih9tnAJRNw74Jz/fYqebUCrNwaQA4ahG27HPweI1vSTAk46svhv7+N7V7HTdYfV2wZMCBQsqWQe1OL5KGAE3ujH704piofh4oxthVntZ111SGSJP4ieOyLqozAU05NeHYVaDNUxLRa00oe+xkfoMs/rKxdeXxaNRTit0+zWlLY9GObv9t78gsLIEhhDiLvB/AW7iuF/+urX23xBCbAD/LvAx8DXwL1lrR6u6j1XiKoHUi2aYvpHfSrjdF6dyhbVy7bzjvHF6xNZ1YjwcZozyil4cvvTGZaMVkkQ+h5OC0BduJMZI0tCjl4YczirUYv7Sl5JxUdGJQ7a7KdOsJgk8qlpTVg1HU4EUMFOafhwwKxo2uo6FuhX5eJ6TbX1ekqBsNMezikZrhAe+EHiewFsQZZ33vT0eF0zKhmnW4HmCrDbc7MUE0jp51itgTRC3xruKaakoa0Vj7LnSlVfB2QSeFLA3Kfj1wezSrrGsUtzZaPEf/vQJ1sCdzRbTouH+MGOmGox2jubZtKPRS1t+Dan+9wDnrU155QiLNzvumLGO8KzWluNZibIQepKxstTa0I185pVmXjkiPikcYWcvdQmLpjZUShMHHkWjmeSuA09pOBiXhJ6HxVAp47oBA49WILEIHk8yKqV5MsnpxBFb3Ygk8DHWvfbsGt9NAv7MJ5vftMsGko1W68qdcmuFoTXeGKzly+OMrFLc22hhscxLTfjMhm5ZWFLKum4nbTHWMGhFaGNgoUSXV4pWGGCwlAsejGlRE4ceW+2QSdGw3YvRxpDVCmuhqBqmpSKNAqfgJgVCCNLYYzarmZmS6YOa39rpgjAYY/jF3pSdTsStXswoq8hrww/vdtnuxiht2O7GJIH/FBfFZjvCHs7IGs3BpEQI2G6H3Ogl7E9LjmclaeSz03HjX/mkJPAkYnE/nTgg9j2UMRf6j2ex7rB6u9CKQqAgDFz3hQGqZnl8dZiWNYeTkmFeUzeaItBIa5mWqyXx/OpwhpSWG90UTzrOv6Kp+epwttLrPjzJmJca3xMIPDxPMC81D0+y1XZ/WAuIb7JTYvF/9u2Py1bZgaGA/4m19g+EEB3gHwkh/g7w3wX+I2vtvyaE+GvAXwP+1RXex0px3YHUZXKF7TjgVj+hbDT7kwKBoJcEZLWmUS5jv3QQL9Jyl1WK797sMkgDvj7O6ERu1CNfsFRvdWLGmSCrNBJBPw6JQklRaXxfcjgrGOcNg1bMvY2EXx3N+Wyrw7ioKZRmXjaA5cFJzu9+vEEU+gSevDBJsNxE+RKwcDwtaZQlDiWDJPoW0Q04lZZRVlHVDUWjsA00pqZUDYM0ZKN1tUVv3b64xruIstGMswrvjPzyUrryKm35S+yNcoZ5TdVoxrliqxPSjYPT0YV+K6Ib+091TFXK0Il9ZmXDoB0wzJxstC8FvoDSQuDDs1QXtXXKR3nZXOdX8d7ivLXJWPtU/meU1dzoxvx8b0onDvl0y/JgVDAtFb50KlVxJNkNU6yxTErFb91ISUPJwawCoCgbjAWl3Wx/WTtujcATWGnIKoHShiTy6ac+J7OaXBnyqmHYqpEeGAT9Vos08pmXDV8fZ7RCj3FR84PdPpUytBft6UssW9BfFesRwDVWCiGYFQ1x4ON7Am0FnmcIPPlUoWMZGx5OSzbSgFIb2kFIEngkYcDBpKDWhnmpuNGLOZ67ddcVdSRV44jtfF/iC8n9kxxhYVYqslJzlNV8loScFA3GWKywDCc107LiRtuNfDyZFFgBHw0SBG78o6w0dwcJx3nDMG+4PWix3YnJK003Dp6ywTjw+HSnc5po6cYBGwt7GuU1rdBx3XhScHcj5fEwR0o3Sg2gjeFk7oh+N9sRZaOfa4tvW4fVh76eDNKA46hgVkEDBEAncsdXifsnGY8mGZ7nIz1JYyyPJhn3T5Lnv/kVcDir2OlGVBpqZQlDQSeJOFz4x1XhZF4zqxo6cUAQSLSxzBY8hyvFGS7HJZn2nUFyrljC24aVJTCstU+AJ4v/ngkhfgHcBv554C8sXvY3gL/LO5zAuO7F7TK5wlo5xzKcVwjXXMigFQE107Lhp48mLnu2mLG81YuvfM3AEwSe5Ae7fSd7pwx/8GBINwlpRwHj3FXs7g8zDqdOOq8TeQwXkrA3ezFYmFYaXzg+jE4S4EmYl4pZqVyVYMHSvfyMS9mvSmmMsaca6aHvEXiOACsOfFq+RQmXlfXEt7ORy7nwo3nNONcYCdaYRdJF8sVRxvdH+XN/P+v2xTXeRZzMK7Y7MSdZ/S3pyt+9Qls+OFt8MMzpJoGrsFvDF4dzIk8yKxs+v9GhrBXtyP9Wx9SXR3P2piX1gnBYGUs78rAmIjIWT0A2ejqJaICygZNinRy8Cs5bm6Q4UzkBam2IAo+NtiNHzhtLO/TZaIXkVcP+1M21b7VCsqKhHfqEnqQTB4yyBmssg3bMjV7Cr/anLtEcO2lcT0qCQGARDFohJ/Oanzwe04kiNhKPNPDISoUnYFYoDiYlY7/hySRHCsn3dzuUjXEcGPDS6+xlPnc9ArjGdeGy52yzFdIY1zER+pLdfow29luKAUsFoaVc6vK8D4cZUeCRhB6zUnH/OOfhMHOqQmVNLw2JfJ926HEwKxkXFY0GKaFsDIUytAOfeamQWL4+zpjVFZWytKMQK0F6EmHdfHttHGeBUoZaW+aVU5T78nCGWUgub7VjNtvRt2zwbJEur128VmvD8axiox1yM4xPeeDSyCOrNXf6MQfTgsejksAXfLqVEnjyyrb4tnRYrdcTiAIfbSD0wTfuGdTGHV8lHhxnKGVp9JIDA4R1x1eJJBTsjWqnuGKhrJ2L3R1cXR3jZWCx325GtYvjK8TzuBzfZrwWDgwhxMfAj4DfB24skhtYa58IIXZexz2sAmWj+WrRXmeMRUond/rpTuelF7dlkGqsOXUUAtdWt9tPOJlXTMuGXhIwaDmHmkYef/xkzPGsYasbUtaGR6M5nrfB7hVnDvfGBdbCqKgdB4aANAyY5jWdKAALe+MSbQxJKJGeRFnD3c2UThIyLxUb7YBuFGKMJas1nrRobUlDDyEEn2y1yGpDoSrakWst3p8UhJ5LVmjpnEOtLYM0QCHwpKQxriUaCbHn0/Bty2q05evjGb9eEGu1o4Bu4i0kuhQbreBUHugy57NuX1zjbcJVE6TLinbgS8Z5fSpd2fHDK69FJ/OKVuTkw/LKVfl8KTjJKjqLSroUgl1fUjaan+2NScOAw0nBwaziVjvmN8czGgGJL9nupFhbEmvN4bQ495q1dd1lazwf561NaeQjFhJkgefm0Md5TehJhotE8WYrdMmofUXguxG+wJMMi4Z25HMwK5lXjZNnjX0MTlnheF4zLmo20ghpBL3U52RWEYcBWljKWlErxUgLhAz5zk6botE8GhZstS0/fTRh0Amw2iClx9G05Ds3O+x0YjwpThPygSeYlYqjWemkVrk40fy8DcV6BHCN68Blz9lS7rctJcHiOZtXDcOsxhj77WTHM3Z7OC0BwU7HFZiO5zUPhxnTsmGnHaIMjPOGWz2fvWmJ0o40d1I0Lq6JPVqxj9GGWeHGenupz3FW0o5DtjsBUkiOZiVqsQZM8orjeUkvDhgXNYcznGx9o/nqeIawlvvHOWno8cN7g299FyfziqN5xZf7M3Z6Mb0kwAp4OMz54d1vXt+OgoUkqiD0JLf7CRbLzV5yapNnbfFt725YrydQ1ZpaO8lzDXgGjHTHV4lJoSgbEGJxXTc5z6RYLXnozV7KTx/NaUU+oW+plVNj/N2PV6t+stWJsFiMgUYbPCHoJD5bndUmTt7lPc/KExhCiDbw/wT+R9baqbhiO4wQ4q8CfxXg3r17q7vBV4Brt3bcDr4vUMYyzBviUc6nl0iaXgZH4PkNqZMv3fhCuei/Xj5UZzP6eaURQlIpw9HMyf+0Qp+HJxk77ei597LZjvj9r4758nBG3hh8CYM0ZrMdOCIpAbOqYVLWbLZDfOmURL56oigbSzsJ+c52Gyklm+2QT7dbWGv5j395hAHakc9H3ZSPtloIYFY01EozzGoCKUFAo+ypzNa4KGhHPk2j2Wj5VGoZoEu6sUdzjmzBrKj5g4djSqMJPSiU4vio5N5mC09YpoU+3aBd5nzetvbFVeBdsK01Xqz6s0x8xoF3rnTlVVApw3Yn4mBaMqs0QoAnBPNK8el2G2OgaNQi6CwxBiSKJPSxtmK7F2GA46xEa8tmO6Qde+yPCvYm+bnXNLgRtvcFq7St89amzxazsctj7dhnOK/oJD4HU0vqe0zzmtALuLeVspUGjArFMKvxpcQaV/WZlg1pJ2IzDYkCn8N5SaM0/Tgkrw2VdhXb2lhM3dCOA0Z5Q+RDEELqS4bzmp1OyHHW4EkPi2U0Lckaw61ejAg8juYle+OAnW7CJ1stTuYVo7xhnFXsdFzb+2XP+fM2FM92MLoOv4pJ4caU3rYN0hpXx+v0W5c9Z5vtiHHRuBjN+lRa83BYsNUOudVPTgslS6nUakGK3minuKSN5c7ArdGjrGZeKpLAI5CSrLHsdGPGWc2kqClLxf60osbSjwNu9iOK2vDbOx2kFHx1NGN/4jjQbvfTRUeu5fG4IPZ9MtMgfQ9fShqtOc5qlDEUtWHQCgk8SV4rcm2404l5NMz57q3uaVKhUo77IvAlWdXQb4VMFsp4252IkZB8cThnsx0ipaAVeHx/IcntyIEDNtrxuaPN70J3w4cwUvw8uxrmNbXhlIRbAcZwLpn+dUIbgzKQxoIId/28tI4/ZoVoRwG3eiGPxwVZY2gFLhHXjlY7MnN3o0XRGIZZ9Q2JZxxxd2O1qivv8p5npQkMIUSAS17829baf29x+EAIcWvRfXELODzvvdbavw78dYDf+73feyuncQ5nFZ7ktFMi9CRJKDmcVadJg3Fef0tR5HlyhYkvyQMPZS2RJ7m7kSIXhE+3B+m3MmZZrRjlNf2WTy+N8IRzkqOs4uGoeG4Co2w0j0YF06KhFQVI6TYtcSjwpcf3d931futGm3mpMZ4lbwyf32o7SbAkYH9WcbufsNWOSEKnCPJoVFBpgzVugzXJG+LAcV/cHqQczSqMsMSex81efCrFlQY+tdIEnptBq5ShbgzSk9Qa4nN6mx6MCyIp6EQ+hSdQyjK3DYfTjHubKYPUx1o4mZeoNLpUvvVtaV9cFa7Dtt72ysn7gBep/lxLFt1ajrKaRhuqBRloK/TYSkOOZiW1smy0Qg6mJVJIktglTaV05JFFrfh4K+XeRsLhvGK3l3CSlYznNfqSmEOvWE/+dWLVfuuitemsROmnOx2ySrkxksrQb4XcP874k3e2KGpDczjleGaRAial4tZGSjv0abSmNJbN2CcJPI6nJXvjgnHRsN0OmOaaWlnmjVvH+6lP5Ps0RlMoTeh5PB6WIC3TqqETeVQK+oGPlJJ27GMM/NGjEa1gTl433O6n5HWDtZDV6ikep/Oe8+dJvp0ds3FcUSUC6MZX68Bb4+3F64wJL9u4xoHHZ9tt9gKPg0nBybxmt59wd+Ob56pqND/fm3B3o3W6OV+ux5EvGeU1948zJ1VfKfqtkG4a0ot9DmY1daP48nhOXRtuDlL6qc/944In45K80TyZlPSSwEmfbsTMSs2NfszhrObRKMNoQ6sVMK9rupHPVidmVjYczipSP8AaRex5NBjubCRstELubiR8cTDjP/jJE7pJQBQIvjyYYxDs9mPG+SIh0QooagMIsqrBApuErt1diKckuc8W2uDpMbF3obvhQxgpfp5dncwLfMD33YSDAJRyx1eJNPTxpGJeOgUzCQTSHV8lslJhrKDXimlrhef5GCvIytUWWjZaIbXWKGWxC36wWms2WqslS4V3d8+zMisUrtXi/wj8wlr7r5/50d8C/vLiv/8y8O+v6h5WjarRHE0rjLXEvsRYy9G0olp0CIzzmh/fH6I1DNIQreHH94eMn5e5FIK7g5SPNlvc7Dnm5sATp/OVy4fNjUdo4kDiIUhD17HhvnpBHPhMr9Ce/eXRDG0syriAtlRO+nCaK7qxY6UuGzfb/t3dLnc2WwzSgF4SIrD04pCdTkQ/CRDCbabAyYjtjwtHhOM7edZHw4x+y7W1391I2Wy51x5MS/YnBfNSOVnAQcqgFXI8q8irBjAUVcPRtGTzHIOe5g27g4Q7gza9KCCJPDdCIj16kU8QeBgsUkjyek0a+CpYVk6MhTT0TjcG5TmdMWu8PJbcNGdxdh04i2fXhCWT/FU3amWjKZRxJHKBz61+4mTwPInve2jjSLsiX3L/eE7ROLUIay1PxiXdJCAOPJQ2HExKPAHjomFvVLDTTwjPId49vfcXIBld43IsCVVv9RN+dG+Dz3ZafLzZYrsbAQJtNE+mFaVy3ELbnYRGuTbd0PeJpMATgjSSlI0hkIIb3RiMxEoIPPB8j1ml2WjFBL5ksx0jjUVZQ6YUN3sx3cinHfnc6CUkoUfZaPamOV8ezjie1pSN4g8fjPm3//Pf8KsnMwJfYCzsT0rKRl/4nIOTfLOWU4nuR6Nvuns22xG10tTKMMqqBSWUZaMdEfqS0HdjJmuscRmWG9ezOLtxjQOPT7fb/LnPt/n+7R6f77SfWmvni4196EuEEE89e63I55d7U4yFVujGXI+mFZutkE4SkgaSeWWIA5d4CD3BSdaQRpLHw4K81BxNCqZlw9dHGfNCkZeKJPT4/q0O7dDH9z08Kfh0u8N2N6ZeKJhEvqSXeOz0QvxAsttPuDNwnbFPxgVFo3k4zDmalvzk4ZiDWUmlFFnp3nswK/nicE7dOCnl0PdIFl1/9zZbdOPg1L7O2qJdjLnVSp/Ghy/i35ZYxh5fHc1fS8zxvM/wIUAK13WhjVMO08b9e8UqqnRiHyvcJtXD/W2FO75KjPKKXGkCKQg8j0AKcqUZ5av1G8Osph363Owlp3/aoZNRXeN8rPJJ+CeA/w7wEyHEHy6O/U+Bfw34m0KIvwI8AP7SCu9hpYgCD5U5Qk0AgUAZR6IGLjHQigLSyH3NaSRPj//pjzYvPu8Vsr5nM2Zlk/Dr/RlF7WbWBYJCaZJQ0o2f3/a0P644XLBVK23JZw0TT3B30KKzSCZ8/1aXXx7M2R87QqlW5DMtGnb7LTwPNkKXvFje01eHM0ZZgycE46IkqxpuDWK2OjGR52bop2XDj++P6CUhO92QqjEM5xk/+miDOPDQGm71EyqtT5Mgkecxzr+dCd1qRxzPK9JQ4klJ7AvKIHAVunbkfj6r6CUBnWC1rWDvO66zcrLu5LgYL1r9eZUs+sm8ohsHtCOfUeYUj8pGgxDcu5FSK8PxvHJVdHA2FnhObYv/P3t/HmXZluf1YZ995uFOcWPMyOm9zFdzVXdVdTeNm6ZBbmQ1g2lAGINhCWwQRjLLko0sWkKSAQkvIUsWC9nLDALTFoOAZVhqYfCiGwStFj2oi6qurq7qqjfUy5eZkZkx3fnM52z/se+9eTMyxoy4ETcy92etyIy4955z9j1nj7/9+31/ElOYygUyK/j6Vo/1hkfDs2j5Lu/uDkizozdMvVOmONacjGsZDJNimp4UAVFest7w2B2kPNyPVdpFYZBWJXXfpigr3ns2IvAtfNugqCokBp+8UedrW318x0RI8DOTB3sj7rY9oqxite4xTHNG40DljaYSAWyHLqYweNgd0R1m1B2TyhA86ad4wlBGa0MofSch2BkmOGMtp6KUDJKct5ZD/MMMWyekfJt1hz3JhV2jOYqzeLQd1k9HaXlM6EHBck2F26VlRTt0cS2TeOzdgYCiqpThUEo6UU5aKB2wWysBUVpgmwLXMGg0XB51I4QweNqLaQbKK+PTrQahZxE4Jk97KQg1R1oKbHZHGW83fPppgWMblKVKcxxnKj3yUmDTCGwedSKitKQVOOyMMtbqLk+7MbKSbLYC4kxlH2mHDp1Rxo2W/0L7Osk1/bD7NkwKeknGBzsshEDvdXavvyhCz2YQ5+TV2ANDqoVjeIq1xXkwDQPbBGGBLEGYqps3jfl6v6SF8kBlHNaVlyVpXh5rWLsInvViWr6DM1O3srzkWS+ebxrVa8w8s5D8FByitqj4wXld9zJpBg5pUZLkStnZEILlmktz7D43TIqxKNlzPFu5Dx7HWd3BPdvkO28v8YuPe0RZiSkEzdCm5ljcbp+8oNkZJpRSkuZy6sKbjGOx1uoq9VUlBA3PJKskRSHZzzLeWqnxzrraeZjE23u2yQfbA/ajHNMU3FoKeNyP6UQZvmvy8bU6aaGU6IdJwVsrIYOk4FEnYbPlcasdMkrV7m5SSELHIDAchJRIIRBVQVK8vBj67K0Gf++rW3imiWMKkqygLCRvrQWYQrA7TDENlS6o4WsDxnm4qLjQ6xADe5VcprjS5JkKYXCjpeKzby35/MwHe2x1IgzDYK3ust70kVKp3meFmtGs1Fw6o4ymb2OZgu//+BqmMKhkxftFn629iKM2ynwBzTmnY3uTCF2Lbz3tE7pqIZPkFXlR8D1vL/OkF/O4G+M7Jr5jYZoGwzRjGBcIIdhoOFQShnGJMAvurtQIHJOH+wn74+w2S6GD51o0fIOslHi2AdjcXgr4zK0mnm3yrJfSizPStGCU5iSZyVrdwTcFhhDsj1LWWz5pXlL3rHGaxZQ4t9hsevTjgof7ypD9EqdI+TZryDvOhV2jOYqjFq6gvA1nDe6H9dNCQO3AAm9S99KiohXaSFTmN4AkL3jciakqJXy+3nApSglCkBYpQkIvSvEtg0FScmfJn6bLzoqEmy2HgaEWeO54w6zmWQziHNMQBBh8crNJzbPYHagNqNVc8s2nPRzboBU42JZQBgvfpqgktm3gVSadUQZCcKPhEjoGw0xtPtVci3bNIXQs4nEHf9xG20EO3rdhotr9rZmwm0UQ6L2u7vUXxUYj4Emvhzuzmiuken2eGAY4BuSl0r8wK3BM9fo8qSpYa/kkmVrbebZJM3SYs/SG8pw/uGIW49fnzHXdSLyULCSvKw3PwjICRmkxjccNXWu6uKt5FkleTT0vQKXAqp3gAvUqVt+3V2tIKV/IiBLaJpun6HirqkIgUKFlkjhTYn3rdZvNcTkank1tvaF2Z12b3UGCbxu4ljF1q5t08tuDlMAxGSYGO1HKSujS9m3iXLIzzDAMuL0UIoG6Z9PwHfJSGUDqnjVdCPuWwLNsLMsglxJbCIpC4FsvN+jVmsf33F3hw70hj7oxUgjW2z47o4zy2YCmb+PbBu/vjPiBjx9/T65rY74sLiou9DrEwF4ll7n7c9QzDW2TtcbzyfLTXkw7dLnTVuEqUoJtGnz2VgvPVjv0jpHz3vaIb+8O+fpWn6Kq8Cw4GEJqAs3AYK1xunTPmpMZpQW32iH7Y/2jSUrt/WGKa5l8x+0mSV6xM0j5xuMe7/Zj4rxiybcJfJu6b9FPc6qqwrdtQt9mc0mwWnd40k+o2SadtKDuGNiWSZSoHaK1pkqr+tZKjeWazcPOiKe9hNvLASt1h0GiZqGuI0gLydNurPSWqJDAZsunO8oZZSWha71gyJ7lLCnfrrO6uubqObhwPc7gfnMpYKsb82g/RghBy7fJymqaHWg2y06UF7iWyShV8xzLEFSVEsVURrt9lmsO396N6EYZLd9ilBbEeYVhGKw3XAQGu8OMrChphzbrDR8poe7bCCR1z0YIwYfbQ1bqDm+ttrAME0MY3GmH7AwS7q2GfGyjxigt+eaTHkUl+fhGXWUp6Se4pkFqlCRZxXrLJSsktm3yHat13l6rk5UlSEGcqZCvg/PAyT07ai51cHzrJRm32uF0g+kkgV7QHlWXQTt02KibRJmkkBJLCAJHzF2boarAty0sk+n6yjaYuyFhteHw7JEKi12vC+JM0o9z3lmZr5jmWt3lW8+GdOOMJFfeWC3f4ePr8/W+uM4bidqAcQ6Way7dnSF5qeLj8rIiKytu11QHfn+1zpcf7ANMd8NGaX74ztIBzmr19WyTe2v1V1p4m4bBvdUa/TRnf5Tj23DTdVipKf2NycCRjj0fHEvt0iZZeejCSkr5XO1n7PIrhEAYEpDkhRp4HNOgKCW2JbAMQZyXLyyEP7ZR56PONmVeqF7LMDCF4FduHCJKKgTfcbtJJaux7ocgKwo+3IsZRiPaocW9tQZ7w5gn3fhIIdXr3Jgvi9mFQVmpxdAoLbjTDqYd72nQE5KTuazdn8MWezuDhHtrNYZpSVFJLFMwTCu+/qTHx9fquLY5Vaw3hEBKJRz8pQf7ZLnkUSciKwtKWSEscAuYRJHaQM0F0zT4xPqrZWzSvMzzuHLBZsvHMgR5WfHRfsSddsBmK+BbT/us1l26Sx4P90c4psnHN+oshw5xVlKMM8ioWGPJcmjTSwSWadAIHe4s1/lgr08vLlgObL7r3iZpVrE7yNgdJuxHGa3ApnV7SWWtMg3WGqpv7UVqRzjKMrYHCSBphx5POzGjvCApSj6+Xj8yFv4sRomLNABehlFbG84Xm5Myk0gpudUOp/VydxDzOM4ZpAVJWnBvraYyfyQG728PsC2T3UFBWUqagc133lnCs03Wmz5bXZUNpBtlPO5E9KIR33NvmcAyGWUF/SRXWX5GGZ+52SQtSjDAd0zKUpJXsN5wub0cMEoKRmlF3VPGj6f9BNe2uDkWHX3ai/nYRoOvPewwSnL6aYmsKpXVylXabjfqHo3AZb3l4prmNHvRcqgEnuu++5Lu0mnmUrPj2wc7HDsfeBMENReR0LNZb/rsDHKlnWRZrNbtuYeQhJ7FYKzb4pmCkopBVvHOnDUwbrZC5WUU5fSTEt82eWst5GZrvgaMwLV41ouQQmAbSoT6WRbx+TutuV73Om8kagPGORFSjhfqKHcf+dyXtRU4fOFum/d3BnSijJpn8YW77WOzkJyHV13sbC75fHt7wO2lkPtrBlle0Y9T7qyoc7mWwSAp2B+lOKYSbYqzEsdSIlAHJ1nrTZ8PdwbjCWrF7iAFWXFnOeTWUsCTbkxeKnfkpz2lZCxRbpezk9G1mkqrt9OLSUuJa1asNn3Wai/v2E525oZpwf3VBpYp+Ke//AzTMFgJlaL2rXbAIM75+uMen9psHnovrnNjviwm9WyrG/PR3ojQs3hrJcQ0jDMZe/SEZHE4bLG3FDgshQ41r6IbqbR+vbES/VLokJdyOnnfH2X88lafn/tgj6SoWG+6bPctQCAMA88yyCyVi62qIHDAdZX42/rMbrrmfLiWwVYvxrGMqXu6QBC6FgiBb5t8fKPBVjeiqgS3lkM+tl5no+mzH2UkaUE3zqn5NptLPrvDlAc7Q+qexcfXa5hCnXet7iGAe2t17i6HvL8zZJAUvPd0gBDq9XbosDtMibOS7X5M3Vfu5qOs4NF+ROjZvL0cMMorvvG0z6duNNloqGwHeTnkrZWXd57OapS4CAPgZRi1teF88TnO4H5w3lDJilGmDFEroUPu2QzTkppXYVsGEtjqRYSOhWuZ1AN7+pw3Wz5xXhKlBe3QYaXmstHwWW2otKyPujFCQJKVLIU2hoCab1NISVXK8WZaST/OcSyLh6MY104ZxClCqo2kjaZHN8rYaPoMkoJBkmNYBkYlCWzJziDHc0w+sVbHMlV2uFZos9FQffV2P1FCuo451Sw7yFnnUifNB7RH1dXQ9i2+EqnUuYGlhDU7UcEX/PkuHw0kTd8mKyV5UWJZJk3fRLWe+XGrHTBIc9brPoZQYYimoV6fJ4+7EW+v1VVY2NjjxDIFj7vRCx6HF8113kjUBoxzMOmg80qSSlXhJkrTk061FTjHCnYuAvdX65QV7I9S+nGGY5ncWalzf1XtjC7XXB482McyVIMqKokEVuve9LsmeclWN+ZZL2aYFny0O6SfFORVRVGp1KiNwKYoJetNf5rneL3hvbCDvzkzYduPclZCW+VBHhuI4jRjP3o5i8hkcItSpcY9yCp6WUHTtUHAICnpx8VYVPToLCTXuTFfJp5t4loG99fqL8SYw+mNPXpCcvGcZxf35cVepHbhxirzAI5pzijrq4nmk67SuHnUTfAdi6LM2OrEgMpqotqOwBYgDCgFuLbF/ZUaH1sPkfOdj7xRLNdc3n02oOHZSEOOJ0NKxLOSTBf/gWPhmibDtODDvYgn3YidgRL78yyT1ZqHIQTtwOYBAs+2WWu67I1StvsJVSlZbbrcXQ5Ji5IPd0ZjlfYK2zJ50osxBLRDlye9iH5ccGfZoeF7PO7EbLZCfMeg5ju06wardZd6YBO6FklR0Y8LjqoYF2WUOG07uQyjtjacLz7HLbAPzhu6UUbgmBSVJK8keVXx0f6IX9rq4ZjK47TpO7y1HFJUklFasDVOgQzgWwa7g5J+nCkh2rrDcujy1kqNz9xskeQlDzsR3342YJRVNDwLKmX0aoQOjimoKskwzVmpu9Q8ZTj8cG/I5+8ssdNPedrrErgWO/2EClhv+Kw3PR7sjbAtE9c2uLfWYL3h8XA/wkBM70E7dE40rp11LnXSfEALal4NWVEhkchKko4X1tJQr88T1zYJPRu/hLyssE0Dw2SaJGFerNZdLLPFk17MKC0IXYsbTf8lPcOLZpgUBI7JoHzePnxbiXLPk+u8kagNGOegH+f04hzXVl4JRSXZHapMFzeXLr88r7p4mVj8l0OHSiox0sC12ByL+Xm2ydJYsHQinLbR9HAtgygrSfKSrz/p8dHuCMsw2B2ldMdK2XEODc/Gcwx2Bil5UU0t9nvDlFyq6x9W1jgvqHk2T3sJUaZUvTeaLnH+coOeDG4rNZevPx2wXHNYCW12+ilZKViv2+yOUvKi5J3Vo13Wr3NjvmxmJyhJXtIZZaSF0mA5Td3TE5KL5TS7uGfpIw5OKEdJgWHAUuhNz/W0F/OlD/e5u1wjzlQIQFZKQtcmHvcNJoLSGGtgCGiHJst1j9W6h4mBa+u2dVF4tsmd5ZC9YUqRlzimwUbTxxDKgDS7+Hctg26UMcyKqSdcaNvcavvcaQfEeclWL2EpsImyjJ95b4DrGIS2jecaeLbFIMn5pcc9tnsx3SSnKAuKCqQsMISg5tnUXZulQAm8erZJzbMIXRNTGKzWXFxbpZLcHeUk4xAY2zPZHqQgxKHZCM4TanFYO/lge4CnRKBeOudlGLW14XzxOW6BvTdMX5g3pEWFJVSY7P4g4Z8/7OFYAssw6OQFVSn5xI0GWVnRi3KitKA7ymjXXLY6EZ0oZ2+Y4FoWQggans3D/RG32yE1z8IQghsNj89uNvlwZ8BXH/WVXkbgcG8l5HE3YXeUAgLXNskLiW0aJHnBt3Z6RHGBQFD3LOJcsjeKCV2LNeniWxZ+3aA+1qLwbJNbS/50HnbacfpVs2gdNx940wU1r4LtUQZVRZxX5BWUVUnNMNTrc6QZOLA3QhgCG7X5gZTTJAnzYrnmsj1IX5AGyEs599S5rmXycD+i6bt4lkFZwcP9iM3WfOv7dd5I1AaMcxDlBXlZEeXlOCe2oXIGH7LAnjfncUH1bJP7q7VjJ4UN36aS9gu77dn4s1udiAe7Eb5t4dkG394bYRsCwzC403bxXYs4KxklBZ+92ZqKs53YQCrJk25C4JiErkVVVTzpJrT9wzswzzb51GaTuCiV27RtsVWluKYc7wxX5IWkXT+6A7zOjfmymUxQKlnxtBfjmCa2aVAaZ6t7+t5eDCft4h7sIwZJwYMH+ywFDg3ffqnNvzShdAwanjPOUlTytJewM0gJPQvHEnTjDG+8GN3qxkRpyUro0YtTLNNipWFgGQJ7LCPu2QZLNZe6q4ehi2SzpTLFOJZ5bB+2XHP5aG/E28s1Pn2jqXaBuxErdY8oK1iueTzrJQS2yYd7Eb5jICX004xl2+X2ks+3t4d8sDOkGdjUAou9UcaTToJnCby8ICvU2Pipmw06o5w0l7i2iYlQKvOWOdZPgRsNj7WGSs36pJfQ8J2XxjLg3KEWh7n770c5blZyux28dM7LMGprw/nic9wC++C8QQg1P1xrePzzBxGGIfFME2HA7rDEtQT7UY5tpSolqmUwygq+8mCfCqVb0/AcENBLcjzH4FY7pJdkGIZ4IStK3Xf4Fz61Ps3ksTNIKCQ87cfcagUYhuDdZ0PKsmKl7jCMVHaF0LPYjXJMU7JS8ylKyU4/xbEMHNvGsyyccRiaaRjcbgdnGqtfZS6l5wOLx/YwIy0FzdDBBEpUmuDt4XwNGEuhTcu3kdKgQGIhEKJiKZyv9kaSl2z3YmQlcC0LWcF2L+btlXCum2tNz+KjCvKqwhCCvJIUlXp9nlznjUQ9czwHpjDY7g8JXQfXNkjzik6acX+tcellOa8L6mQQnhgxJrHtk0p83GD0lY86mIZakAihdhmQkt0oV66NE09gwZHibIdhWiZpURJlalfPMsA0BKZ1dMNybZPP3WzyjScDsgputlzqvoNA0A5tmr6Nax59/HVuzJfNpE7sjzK1KBWQFyq+1hBCuz9fMift4s72Eb0o41vPBhSlcl9+26wduhCcnVB2I4dvbPXY6SeMsgLftsjLirW6h2EYrNRcHvdiXMOkO8rIigrftfBdpZvQGWXsxxkCiWcaFGVFM3DmvqPypnHaPsyzTVqhS5IVxGPx3c/eajFKCnpxzmrdo+Hb7A0zfNtgpRYghBIXY7wzNcyVZ1yUlXx7d8gwLVBrHrXwD2yTu8shcVayWveI0pJebLA/yri3UsMAskplt1E7UCO2+wk3l3yaQeOFUKW9oZKAPW+oxXHu/gevd3MpuBSjtjacXw+OWmAfbHPLgUNcKO+KSkrW6h79pKDu2LSCirwsedaP8SxBUSkx7PtrNfaGyggsActU4udSSnYGGXfaIaYhuLf6XBtmYsybtIe6b+PaJgJ4Z71OnldKbLfuUBYV2dgoVkmT0DFp+g67SB7sxiBgpe7g2QYP9iPWGy53l/1pdpFJHZ3O36Q81EPqqHty0lxKi9guJqIokVVJlIGQIAXIqkQU8/UOa3kuTd9mq5eR5DmebbPZdGh58/WEeH9nwFLoEsxsrERpwfs7g7nKAbiOxXfeavKwE9NLCmqu+ts+Zr1zUVxXw6E2YJyDUlasNpTlOh17YASuTymfL9DP0imfpwM/rwvqSR4cxw1GUkocU7k8WaaynD7rFZR5QTdSmhpSSlqBzaNOzGbzdGkTy3E2kygrKcYiPnXXUq8fhZT0k5KPbzTGEwOlfVH3LG63Q/xTuKtf18Z82Uzu084gpRJqh2mj6U3rhHZ/fnVepS84aRd30kckecm3ng2wDIPQEQyzkr1RxnLoHLkQnJRnpe4xTHK2ehFJXrJac7FMg06Uq93qcW7VwLXYXHIIbYP3dyL6ccYgzbENg/W6Szt0SDK106B3mS+e2T7suLrU8CxqrvWCZ51vW6w1PG4uBfQT5ZVhGYKylDBOY1dzTbqjnEGUYxnw/vaI/SjHFGAbJv24oOHaNAMHWUk8y+DZIMUyDG61fT57s0kvySkKtSsc5wVb+zGeZbIUKiPzs16Ca6mxZ3YsO2+oxcF2Muvuf9g5T1qIXcTCSxvOrz+HpV39ykcdXNPEQPCx9TqOqTKBfG2rRxSpkFrHNvEdC1kpb8a8UCG8k/mUEEolfrYvn9S597aV3k17ps7ZpiAtK77zZot3t4ckRcmq5xG4Fk+7CVJIon7KVjelOyoIXYNbSx5JVvLtnREfW6vxnZsNDMvkSS/hTtuYbm4pjyl41IkAwa0ln0pypBfUaeZSE/20iSD4as099pyay8V3bUCQZAVFWWGZBq5pjF+fHxVQlpLNlofERSAoi5I5Z1GdalFs95OpmGbdMxkm853PumPh7c/dem6gyYoK45AU4RqFNmCcg8C2yAtJ3TOxDCVumeYlga1u61nCOs6rQn5eF9TzeHCsN32ivCRKc3zbou5ZbA8Ejm1ij+9LwzNZqXuUVQXidC1yf5Tg2jaB51BUFZZhUJaS/VFy9EHjwR4J7dDm4V5OUSoRonz8/9uHqNtrXg3PNrndDqgkLyyC3mT353nE6J+mLzhpF3fSR3SjDInymColhOMF7DDNMY4YLWf7h4ZvI4RQ4l5CtbWlwOZZL8IyTNaaPh+/0WC7H/Ph3ohKVlimSSkFVVlSViClwHEsXFOcuj/QnJ2T6tJhdaaf5PiWwQc7Q6IspxW4jLKCvWGK75g0AwsJDJKcd9Zr/POPulimoGZZxEVOkpesN1ySsmJnkFBzbd5erYGArJQ86yWMUrVI//SmCl1Zr/vcbIbYlsH2ICErKuKs4lkvxhmnjvRsgyXfOXeoxVHu/rfbz9PkHTznUQuxi8weog3nrxeTsbHmWXzr6YCylFSiIs0rPNPgzs0lXFeFxzZ9GwPB/iijqCp8x6QzSslLg7RQhuKJF8QHO8PpYt+zVZ172ovZaPrTv2ueReDafHy9zijL6ScFRSW5uRTw3k4fE0maFzgm7I1K1usOjmPy6RtNGp7NjbH+2WQBNUqLaf//pJsSOkocvRfnU4HnrU6Ea5tnGvcm7Wd/pMRKhSF41k/ZaHovCeJrroaaa2IYgpplT5xuKKuKmjtfw1JRlliWhe+a09CVGEFRztuQYPLBzhCBQSklphDsDCruLs933aC98M6ONmCcg4ZvY5sqdnEibrlSc/HHO0RnMQqcNwTkvJX/JA+OJC95f2dIlBZToc9unHN/tTYVAe1GGZ1hSinhk2t1hCHwLIOkrPBtC982aQVKDX/CcYs90zAYJqnagZjYJaTENI734Li1FNCNclzLpBx7fkipYsuQgnaoXdYvksvoeK+Le+lFLGhetS84aRd38pxGSYFvGSR5hQTWGi6WIRjEBav1wxeC/aQgyQrySnlbBa5JkhdUpUrDvDNIcW2T73qrTVKUjNKSYVqOQ4sEUZoR2gbNlk+RV+z0Mz57y2UpnK876JvOSXXpYJ0BlQrctkzKqiLNKt7fGSJlRcO3KcqK3ihjs+XTarm0AptfeNjFMg2EKHAsA8u2uLus6mlVwlKoNFYkknefDkgyFRa41vD5xlYP37GopMQyVdmavq2MHHnOMM24tRRiCkHTU275SV5S951X7muOcvc3xu76Zzmnzh6iOY7lmkuSl3x8o85WJ2ZvlOGYBt/11hLrDZ9nY80JyxAM05w4L6l5Np1RhmuZpGWJbyvPxvbYC2J2sT/MCiQVBoJffNghySs6ccZmw2evn2JaBneWQrYHKVUFUZqzVnPpmRZSJEgpqLtqN73hK82BZCbE9zDPp6ys8MdjSpyr98qq4qP9iPtr9TONe5P2IwF7nN0KVFjXesPTXpwLQOjb+I7yfK5KiWEKHMsi9OfrgSGEYCmweH9nRJSXBLbJ/dVwWkfmhWcJdoYZLd/Gtw21tolzPrE+5+tqL7wzow0Y52CyIGiH7guTqYla7VnCOs4bAnLeyn+SB8dWN6YzUpZ3yxSNIyLnAAEAAElEQVQUpaQzStmyTe6t1qYioDeaPq5lELoW7+8MSPKKVd9hKVTif1lRYY8vcdJizwQ8x6SomLquWQYc941UfCfcaPkIAV+4u0Q/UmKrt5Z8QseaiohqLoZ5d7wXucs5by5iQXOevuC4XdzJe904Iy0N0qJguebimAZxViIEhyptJ3lJd5RiGga+o1JvPu5EWKZAAku5y2bLp+aY7EU57ZpLWSkdnUGSc7PlUXctelFG4Fg4oWA19FlpOKRl+cZ66lwGp6lLs3XmcSfCNlU2qmf9FMNUk8heXDBMSpqBzWro8vm7S4zSgigrqfs2zbSkEdhESYnvmCyFyuVXGCotHSjht+WaO47rh5WaS5yVfLQ3YrnmUJQS2xK4lkm75vDedkrdtXFtg1agxg+3qMhLtSt8nr7mMHf/2f5rVg/qOIOpzh6iOY7ZsTFwrBfqViVho+nRjTJ6cc7TboznmDQ9i0FWUErJJ9cb09TykzFwdrFf8yxGac52P+ZhJ6Lp2azWXEok3WGOY4HbCthoeQjgo92IwLW50QqIsxAhJALBIM250fJI8upIT8rJ/NAxDYpSgmD63s4wnXrywenHvUn7mZzTtlSK2Tgv32gvzkXCNQRvLQdEucpE4tsGgW2ocNE5UknJg/2IZuCwYkBewYP9iI2xd9C8SArJ52422R6kDMfZDz/XDkiK+ed71154Z0MbMM6BZ5uYhuC/f/cZe8OM5ZrD991fnU50zhLWcREq5Oep/Cftoj/rxQS2hT0uj20JAmnxrBdzb7X2Usz1405E03PIi5SsqHjSjViueRiC6edOWuyFvlLCXgpdXBvSHGVEOcbyu1xzp54ijzoRplAhLGsNNYm2ziAiqjk98+h4J4uKh/sRpiFYa3gIYcx9l/MqtWjg5b4gyUu2+wllJc/tfeLZJp/ZbPG4E1FJGCY5/SRHAJ/ebB563r1hymrdY2+UMcoKOiM1+c7Lik9uNKeGj7SoIMpAojQQPIs0dMnLitAt8R2bbpSRpiW7MsaxBNXK4UYTzcVw1nFlUn8nO8OdUUbLd6l5DusN1X+3Q5dRqoxfDx7sc3c5oCgrulGBa6swym8+6fN9H1vh/lqdvJRs7w752uMecVbiWILQs3jcFTjjDAx5KRllOYG0QEBRStZqHh/fqOM7z6cpamziwtv9rIh1Pyn4aG/Eat2j5lnHGkx19hDNSRxmLEuL6gXNh1FSUMmKpcAnrySyVGFNaanmKo87Ee9tD/Bsk91hChX4nkXDU8ZFxzZZrXus130sU2Ux6UU5dd+l5j4PCZESnnRjBJBXylMucEyVyj5webg/YikMD/VEmswPlZbZcw2MrKgYJQVvrYQvfO/TjHuT9rMUOtNUzhKJEGj3+QVhremxO8pYqzsYAiqJ8qA7pZbdq1KWUuk/yHFfKsEQ6vV5IqWq990oU/MY36LlWy9oJM2L6+JpvCjoUfYcPO3F/PjXnioRw0qyM0j58a89nXbEy+O4xayoxo2iesFDY5azfHYeTAbZyc7WxNAwaTzTMI5ZBIe6c00ME3VfDZyubVBV0E+yF86ZFhW2+eLxs1lKVkOXt1cDRlnBw07MKCt4ezVg9QS3cyHV7oCUsD1MkbLCs00qCY86sXpDs9BMjGDVOObSFIKnvVhlQOBs2Wxe9bqBY07FxCbXPYnJhGyWV4nRn/QFcVbwcH9EWlRsNL0zl+cwJm09cEyagcNbyyFfvNt+yStpci/e2x6wN0rJi5J3nw7YHWVYpqAVuNR9exqrDCp8SwjoJ8oTY62uJudZUTJKM4ZxhmObtEMHy2SaUlUzH846rkzqb1pUlFXFk27Mk37MIM5VSMm4z04L1acuBQ4rNZc7yyG2CZ5lsNF0+dztFvdWaiwFDh9sD3jUiQkck1FW8uFuxCBRY0xWKG2iVugoI3o34ts7QwwDbrcDzAP1Y9KWJnXzg53hudsDvNjuk6zANAz2RtlUnHu2jp/n/mrebCb1zDYNteCX8OHuiK1+zFrDI8oqJMrA51omX/moyzee9NnqxuyPUr72qEs/LsiriiyveNyJidOCLC+puRaTNVZVSXpJwcP9iMddNW4meckoLZBCYJoC01B6Akle4lomvmPyhbvtaVah2Tng7PywkrDZCtgcj0eGgDvL4ZFt9Tgm7ccQgvWGR1FV9OOc5cBZSA/LN5H7qw2agcUwydgZJAyTjGZgcX91vtkWs0LyyRt1HAuiosSx4JM36mRz9oQwDMFPfmuHp/2Eoqx42k/4yW/tHKkPdlGcd+75JqI9MM7BT727w94opx0qz4S8qNgb5fzUuzv89u++M93VeX9nwDApqHkW91frh3bKixD/dNwu+lrdZauXjNOkKq+GKCsPzSgyuwvt2SYbTR/ZUJ+f/T7H7V4leYltGjzaT9gepJSyoiyh4VrcuHu0C9neMMW2TOxS6XRYQmBZJr0opx26gNSigafgqi3Bs945E+OTI0w6o4wbLX9uu5xXrUUDL/YFj7oxrm2yVvdeuP/n9T45yWNmNmxn4r5sm2qSW0rJo07MjZYcT36NaZ81G74V5yWjrODWSsAHzwZ045yskgzTnLyCt8znWkF6p20+HDeuHNbGJ/U3Lyp2hwlyrD0UuhZb3Zj1pscwKeglGR/sqF3ipuew2RJsNH1sU42DQkDdd3jcjQh9G2EYpLlBkg1xTINnvYhelFPzTDxTKbyvtzyWxuGYhhAkRYWMM+q+Q1lV7AzSseCnSzfOaXj2hYWUzbb7vJL447Sq3Sgbf6/Dd5MXYdzWXB9eHF8M7ixbZEXF8KNibCwzqaSkG+X044wPd4bsDxM+tt7EQGAYBmleYpvQiRI6o4zAtbm7HJAVkrKCSlY8GyTUHBM59mT46lgfwzINbrc9nvYyBLAceoSeEl6fjPETQ/ZR/cP0tfH8dtKXnDTuHTWnmLSfXKI8QfSu80IReiZNzyHNK4ShNFmankPozfcZNQOL97cTXMvAMgxMA7qjgvtr8/X8eLgfUUlJZ5BOs5D4rsnD/YjvvTe/616lntJVz/dfFW3AOAfvbw9p+ibu2MXVdQyaVcX720PgeaVYq/vcbKlOfW+YTi3aB1nk+KfNpUBZ8POSrJAYhqAd2GweUt7TutUetdibTqLLig92h6RFiZRKCbuf5Hz/x1ePLGc/KdjpxyS5pBtnmIbB/iAl8yuWay63loIXREQ1LzO7eDUEbPVi3n024M5yyGbLv5SObdYI1gocnvYSbFOMdzirubmXXrUWzcHzTMoz8XRK8pLOKKUX5wCnVno/ODgBxw5YBwdT21Sx1097MS3fwbMMpJQ87SUshw6+82JGi6Zv88HuCAP49I0GvSjnwX5MLkqqChwDBmnB1x53WG96C9vvvQ4cNq4cpytzcyng2SAhLyQN30JWaleKEkZJSZSMuNUOCRyTsnJ4uD9CIGjXHPKiIivL6aJ/f6i8GExDYFsGzcBid5iy3U1wzQzTgHbNxUAQ58rzoRnY+LaFZTI2Vj53t39rJWRnmJKOd5wvKqRstt1P4vEtU0xFCo8zmC7yuK1ZLI4aX+qexc4gxXclvSinqCSdUY4U6piiqujEOb5j8t6zPk96CZ+92eKTN5RhI81LpBCM0oxBotJdNnwHzzHIsoqylMR5yceWfJ72UlbqLrZpsN1P+NbTPnvDlGeDhC/eab9gkJjtHz7YHiCFONJweFKq4eN0rHT7WVyGaUEvyYkS1bfLUtCzc4ZpMdfrbjQC/scP9/FtG9eUpIUgznN+VWO+deXB7pCqqtRmram0Zqqq4sHucK7XvSo9peukMXcQ7b97DiwD0nFawt1BquK7S8lknjO7CBBCHOuKuuh4tsm9tTqbTZ/Vusdm0+fe2uHeJKd1qz0qbGWSsuurDzuYwsC1LCxTIITAQPAz728fWc5OlLI3zDEMqLkWtglCGASOyY2Wj2kYOj75BCb1diLkZxkGDc9mb5hemkvbbCiGN1ZhL6WkquRL4U3zuu6EV9WiubdaO3c5Z8uT5CVPewlZIWl49qlcDA9zS/xge8D7O8NjXRVnw7uEENxoeaRFiWWotKft0MEyDASwM0he2E3LC1XONCtxLJNnvWzsfSVYqSk1/bVmgG2ZjNJyGnKnuTyOG5s822Sj4fPdb7e52w5ZrjlYhmApdIjSglvtcJpKt+Hb3GqHJGXJIC0Qgmk6x2FSEOUlCLBNg16UUY4zSTV9BxDYpkE/znnaS/ilrT55NRbpNGCYFGz31A7c/bU6d9ohvmMhpUph3hll0+9z3pCy2Xa2FDpkZan0OqZG05fHr4sOY9G8AUjJw07Eg73RNCQyLyW3l0NW6y77w4xKSuKspBXaLIWqX42zEikl33zWxxCCWy2fpcDm/Z0RliW4v1an5Vk0A4c4K1kKHG4v+ayGLm+t1Li/Xld9tGMhpKAzzHjUiZS2mas867b2Yz7YHkwN3gf7h1FeEqXFkfPZ48a9q5wL63Z6Pt7fHtAZZQgTHNtEmNAZZby/PZjrdUtZ8amNOp5jMCoqPMfgUxt1SjlfDbt+nJMW0Ko7rDU8WnWHtFCvz5OLmHu+Ctd5nao9MM7BJ280+ce//JTl0CdwBaOkYm8U8z/95AZw/RTKT3IjOq2l/Cy70Iedc3Lfvr0XYZkQWBZSGlRSYBnw7vboyGvneUVS5DzbiRklBYMkx7UEae6y1vAIx4YYzdEcFPKzTQNpSIq8vJTc7IeJnJmGQfsS4mIXLRf3bHk6o3ScTVjSrnlT74jjnsdhbomjvIRxFojJawfPM+tF5ZjGdNHY3mjQChx2ByllJdXuoe++sNP2tJ8ggXbNxrMtnnaVgUKgREOf9RO2uhG+bfLOag1Th3RdOieNTZNwoI2mz0ZThez145xulLE/UqEck8xSdc/i7nINxxQ4ljn1lNoZJNxfrdEZpnTjgryUGIYSeG0FNrKSJJmkVPmxESbsDlJcy8Q2DSokD/YiEMqjZ7KYcy2DspJk5fOJ7HknerPtzLUM2qHLziChbjmHGkyP27WC472bjuO6uvJqjmbyTPtxzrNeTAks+Q5RVvDtnRGBY/DOeoNP3GiwM0xxLQOBoBXYmEKQVxVxURHnBXkhkQJuNH0sy8TKK7pxzjtrdQzD595qjXfW6irk0jJ4sDdSWeMqyUrdISsqLEvwpKe0wPpZiWWadKIM3zEZzdS/g/1DdYjr6myfcVzdPex8ZVXxqBvPta5f593lReFpNyHLSgzLoCzBNCVVUfG0m8z1unklcR2T0LUwBPiOheuY5HN2oW6FLjvDPvsDsISgkJI0L7jdnu8c8KrmntdtnTqLNmCcg3srIY83GuwNE7qR6oQ/sdHg3liN+ToplF90R38et8BZS+T+ICWtlNCbZQjqjsnaMWmUsqKiM8qVJdFU59kfZhSl2im2mtpV8SRmhfwm+d6LUuKYxpk7trNOyLtRxje2ekgJvmOS5hUf7o640w5OndrwPCxaTPtseXrjuP927bkexknP46iJaJaXPOnG0xjPVmCTz8wLZgfTiep8Xla0HRtjPLneaPoYQjDRtkrykm9s9bDG6VZNIdjqRgyTHFlWyAp6SU5VSeJMEmUF7ZqLo4U8L52TxqaDk6lBUvBof8RyqFzPpVThRJM60BjH0E/aDVIZGDrDlEFakmQF3SgjSQo2Wz6jXLm5l1VFVlU87iQ0PIt8qaIRWIwyh8edGNswGI5TuA6SkjvLAa3A4eF+hDsOY7qIid7Bdh84Jl+82z6y3R8Vr7zVjZFSvtI4qhdbi89Zx7PZZ5oWJYFrk+bKM2lnkGKbgmbgYJsGo7TgM5tNhmmBaSgDcTt0eLQ/IiuVvtpazSHKS571E3ajlKZn4UTG0W3XEMp7A6aGyLyq6D9RoV03Wr7a4CkknqUEbCffbZgUjGb+Lks5zUI34aCo7lF1d7a/Scblf7A7JPSU0PvEC/Ci6/pV6gq8LiRFSS/OGOaSoiixLJOaLViqz1eoWMiKR/sJ7dChHdgkufp7bc4CyZtLHlvdiGf9hCSv8GyD9YbH5tJ8tTeuau55ndapB9EGjHPgOha/5uNrPOzEDNOCmmtxe8nHtlSFW7Td3ONYpI5+ct9qjsEvDRIc28QQkkoaPOnnfPzG0R4UaVEhkFiGSWeUkuUVhlBu76Zh0BkmbHVt7q3WLvEbXS8m918IlSpTIKZx7Wfp2M46IU/ykq/PLICLSgIVGw01cEzq6Lwn94sWkztbnsnO2oTTPI+H+xESFdu/FDqUpWRvlFHzHHzbpCgljzoRm63n3/llcbWA5cDh2SDFMirWG950l30pcIBIxWGPDU9CCGqezUrN5cHuiG5S0E0LyrKi7jsgJaWUjJJy7rG0mpc5aWw6OJnqJxm32yG2ZfC0l+BYAttQMfTt8Lln1M2xVtLjToRtGOwMUxCQlhWrdZdRVhI4BqFnkhcV26MU0zBoBcq1fXeQ0vRsbNOkkhWbSyHrTY+tbszuIMWxYLMV0g5sPMc6Mt5+dpEZuhajtDhx0XmWdn/UrtWj/Zhb7fCVxtFFGoM1L/MqBqbZZ5qVShzWNg12hylvrYRYhtJZmTzziQu375h880kfxzLZaPlIKeiPMhq+jWkalE5FYFuM8oLHnYjdQcynNlvAi23XcyySUUrDt+mMUrqjnEGSs1Rz6YxS8lLiOwbrTZuykgzSctpmvvW0T+jaeLZBN855vB9R99WSYbWuvCInfcZJdXfS36i2mbA7zHAtlY3qWT9lo+nNxbvzOu8uLwxVxc4oxRDq2ZZ5QZxVvFWFJxx4ToRBw1dziayQ45BFE8R8F9Y12yKvJDdbPrZhTD2gavbruVy+TuvUg7yeT+SSmLiyrtRcGr6NYxoYMxoLi7abexyL1NFPY+kr8FyDJFPCf7YlCTyT7Jg80GKc2rUoSzqjjDgrcW0Tx1BKxsMk5+HeSBswjmFy/wXw0X5E6FqsNzwMIc7UsZ11Qr43TJE8XwBPNBiGaU6SV9xcCi51cr9o7txnHWiSvJzuqAWOSVVJHu6PGKUldd9+nhZZjP85kF744IIuyUtcx+JZL1au/VJycymg5lnkpeSj/WhqeFKaBCXDtKQZONR9m0GSU+Qle6MMiWTFd7nRcnjan68rquZlTjM2zT7/D3aYisluND3lTVFVSMlLxoNf2uqS5BXdKJ+6vVuGCn7abLk82BlyZ7XGu8+G2MJEyoqa55DmJTdaHpYhGMQ5d9rBeIdYlWOnnygDwVJ4pP7SwUXmICn41tM+t9vhtJ6exfB5VB9w1K7VbL814bTj6KSdJnmp9LSKCscU4+//auXUXByvYmCanVe5lkFRKXHYUVawYXhTz0aY9OmqPf3SVpd2zaWoKnzLpubZ3F0J+Mff2Ga15uI7BvvDjKyQ3FkOlQfFIW33Jsqr8etbPdKiYpjmNEOHUV6wWncZJiWeZSiPqbycZs7bG6bcaod0oowPdobsjTKWAmXw3hmkvLc95O3lgE9uNvFs81TzRwH88laPSkCWl9Q9m26Uq6RwQnK3HRJl5YXW5eu8u7woDDPVz2dFQSnBFGCaBsNsvloUliH41I0m+1FOnKvsJ+0gPDhNuXDSQnKr5fO0n9KJU2quza2WTzrn9K1X5YF3ndapB9EGjHMQuha/+LhHUVbT/NiWafAr7y1PP7Nou7lHsYgd/TApqMau5wCyklRlST8+esfWNAWha7E9SNkeZHiOQds1sSwDa6yEP0j0ju9xJHnJVjfm4X7E/jBjf9yx3V7yz9SxndUolhYVwdgjwB7XQ7WYUeKABxcGZVXxuJfMZdJ+FYPJaTVoTjvQ7A1T6r5D6NnTBZFrm5Sl5O5KSC9WEwPXMri15B+bnWf2fry9WuPhfqSEPqfCT6rdDZOCnYEyRMVpgWkKAtdilBQkRUkpJe1AZS1xLYut/YTlcL6umZrDOcvYNDs+TFJjZ4Ua9w5mGkizirpn0R3mxGmp3M6FIM4rNho+nWFGf5xRYW+Q0gxsXNukGdq4lkFtnNZxc2y8SIuSXpxTFEoZPh33T0dlz5EStnoRuwPVd9Vcm9BLqfv2iYvO2TaIlMRFdWjWhaOMiWt195XH0Ynb/t4oU7vwY/HGKMtI8vLIdq5DTy6Hs4xnk3r0rBdjWQZrdW+aTSsHgokwJ5KNpk+Sl2wPEopx3x/YFjdbwTT7FCjx25WaQ+CaxHnFSsPjO5d8ao5FJ8oOvX5aVGz3YiqUULprW4SuxVLokuUVdQ86Uc5S6NCuudMsYxMRZykllmEQOhbdOOMbT/p8cqNO3bXYj3O2OtGRBr3dYcqjTsT72wPirOTeWo21pkclJV9/3Me1LBq+MnhvdRKWAxdDcKF1+TrvLi8KgyRHCIk0TCgrpGEgRMUgma+o5Y0ln29u9dkfZURZQeBYmMAnNhtzvW6U5QzjHFlVWEIgq4phnBNl8/2+k7FrfzTjPehYl+KBd13WqQfRBoxzsD/KcEyBgUkpK7XLb6rXJ7m0rwuL1NFPJmTDJCPLwTZBCiWok2SSQZwdeWzoWPz09gDHNKm5Br2k4N0445M3DJ72YywEK3OO3bvOJHnJ+ztDnvVihkmB7ypX77Isic+o8n9Wo5havNjsj5T6sWWq+F0hYH0cvjI5V5KXPOqoRcw8Ju3zdOc+Kq3paSZuZ3VzNwT04nx6raZv87SUmIYxjYkGpR1jH6OlefB+SNSOfDfKpudp+JZKt9sOSYuSJ52YUpa8tVJjueYQfbVkf5TiOxWO5ZEWBRWSrNLuvIvOacaHSR0JPYtSgu+aiKHAd0wCx2ZvlJKWJTXPJiuU4axVcxAIHFPt/AopaYUOn9poUlQVwyRnf5RhCEFSqkwM33o2pKgqkrER73vuLb8gNLo9SOjFxXSxuR8lPBskZEVF3bNp+i/qvUw4aAh42InoxzmjJIexplLoPp9QHmZMBF55HF2uuXz5wT6moYztRSmRSFbr3pmFeievX8dJ6aJy2vFsth7daPk86kQ83I+4teSzHDrsDBLWmh5RWrBa95BS8qgTA3Ka5r0TZdimoTzlZq51o+XTDlwC9/nUPUoLbMtQxsPxGJ1kBbZlsj9M+NJH+9Rci9CxwLX4xpM+nqWy/3zqRoPVustmKyArSjbH+mKuZbDVjakkPOnFSCTP+gm9pODBfsRnNhtkpWQ/yvE6EZtLwQv1fneY8gsPO9xph2RFiRCCbz0dsNbwGKUFy3WXQZoRupbSjDENdgYJ600fxzQurC5f593lRaGSIEsIXRMhTZXaN62O3fC4CJYDh1983CPJC9SMQ/C0a/F976zM9brDtORJPxmHT6ksbU/6CRut+fal/TinF+e4tqlCeyvJ7jCl6dsneuC9qWg/qnPwrBfj2+Y0xadlCnzb5Nk1TAt4VErTq+joJxOyEiiATEKaQ1RIcgn5MT5knSijETikZUkmUSKFtkWUFpSlJCkK1pp6x/co9oYpUVpQlBC4FoFjEXpqwh+lxZlSK502ne7s5w0B7dAFVOf9pB/jO6ZSTE/y6bm2BwkgWWt4c0n9NJtGdMJ5UzXC4WlNH3citrrxxaeykpIPdoY87SfsDVOe9hM+2BnS9KwzPRd48X4kuRL1etyJeLQfT9PS9eOCt5ZD6r5F3be5t1ZjoxFQlCotYOCaeJa69rN+QiklNdvC0MPQwnOa8WFSR1qBynYQuCZVVfHh3ohvPulRFCXb/RhhCHzHoqqgGrvQmwYUZUkvKkiKimZgM8pK3tsZEGfKA8sUBkuBx8NORC/OWK45IAQ/9a0duuMd6CgvGKSFWhgBw7Tgw72Iziiln+RUErVYPGQMOZhOLs1LRklOJ87xbRMpYW+Y0B978B2WNvI846hnm7RCF9tUugiTlLR1zzq235lXX6V5kdOOZ7P1yHcsbrdD3LF2jO+YfOFum8/fXuKLd9sEjsm720M+3B3ypBvz7vaAOFeGjZ2x0W32Wp+/vcQozemMUp71It572ueD7QEGYjqm7A1TnvQTnvZiuknBcuhhCoNHnUSlRRdQVpLVusvTfkqaVy/V0+Wayygt2OnHxHlJUUqitGQ5cNTrg5TQtQgck+1B+lK9f9SJuNMOWQpd8grqnppL9CK1mx46ymtje6DSm0oqfEcZZWxTjFOGxzzYG6k2d44UlheZ1vxNJLQFwlBCrVFWkOQlwjAIj9vxuAC+9riHYwnKShLlFWWljIdfe9yb63XjsSbXKC3oJwWj8d/xnLW6orzAECq1uBj/bwhBlGuP8aPQHhjnIC8l3TgjcCy8cXzjzjCl5V8v74sJi+JGNOuq6RhQAggVQ+mcsNbpRzlVCbeWQhquxbOBzSApEKhB2TIFrqkXTEeRFhWVlGOPIvUMTAFZJamkPNOk+Ky7H7OfLyqJl5fcvtGcxq4neUleVuQlFEXFrQPnukjNlnmFVB21W/pof8TbB3RZzvt90rJid5DQGKc5TfOK3VHCjZZ/5l2pyf2oZMXTXkzdtYlStUB70o1YrqmdtbdWwulENMlLvvThPk97CZ5tYhqChm8jUWk2bdOg5ts6jeo14aTxYVJHVIiJx9N+jDANTAmubWAagsfdlI2Gy83lGoMkx7YNZKnEAxvC4EbLJs9KLMPgE+t1kqykrCRLoU3oWjzpxdQcA2Eovam6Jyiqivd3BnzX3WVMw+BZN0aMQ1bSosASqmzPeintQBlHOaTOHQwRiLMK21SGCyEEtiXIS+NEV+LzjKMNz6LmWi8I9WZj76mjWMTwz9eR045nB+uRZ5vcbgdE2YueOJ6tUkTu9BOWQxdvnHXra4+6fOZmk1boTg0CB6/1cx/skZUqvKkROBSVGreFMJDAKMnZzkuyQhkISykpK8kwyfAtjzgvuLMcUlYVm63gpfrq2SZ32gH/9Fsj6p5NnJcEjoU11j/YG6Z8arOJyoAsX7g/AA/3RzTH3iOOZVBKcC1BL1HiiI87Mf244NZSyMfWbaoK4qyg4duvFEalmR9LNY+wl1AikKVEmAITyVJtvhuBv/ioS1FU3GiH2AbkFQxHKb/4qMu//N135nbdtJI0fZtRVpEVBbZlEToG6ZxdTgLHphel5EWlUh+P51t1R3uMH4U2YJwDZ1zJJnGKSjxS4ph6Qn4ephNhywIBBgKJVOkaBfjW0dW2rCQNzyDKCnZGOYFjENg2hqEm1U3fnrvr23XGtZTV1xTGVIwxyku6UU6al1imIMn9U08kzjqZn36+E70wkXcsQd13pjtFrmW89BwvctI+r5Cqo+KohRAXvgjpjjJutUOSvFKCgJbBrXZId5Th3Tjbc5ncj/1Rhm0YZJXaEalkxbN+CgjutAPMmZSonm2yFDh87VGXmm9jG4KikpimwLZgEBc4pslnN/Uw9Dow22Zcy8BA8LG1Ot7NBj//YUeFfpQVVc3FtUxagcN+lLFUd/nsbZ+lwOXbOwOKSvKzH+yyFCqDczt0cC0Tx4RBVFD3TYyxEbqsoD7WXulGGQ/2RhRlRSfKcRyTKFOpIqUE0xAM0pyPrdUPHQMOGgJ8x2R/VOCaJlJKirERt27bLx88h3t42n5nkcI/X3eOG88O072YjJNH9eXv7wxo+g72ZNw1BVFe8dPv7vK5Oy3eXglf0ph5uB9xo+Wz1lDnf7A3whKCzijjRssny0u+9WygtCs8C0NAKSWmgUqLLiRLgYtvm7QC78j50OZSQMO1CFwL0xBUlerrV2sOdU+l0x7l+bT+zYZE1jyLJK8IXBW2uN1PKUqlcbUUuny0F/Hx9QbNwKaoJGVVsVr3QEp2BsmZw6g086Ndc2nXPWSljGCmIRCGoD3ndKbDpKCoJJ1hSjZeVwkpGc5Zwy5wTR7sqhDEwHGpqopBUnBreb7Gs4ZnUVYVT3oxo7EX4Y2mT8PT86Oj0Cb6c9AMXVZCm6KqlJtdVbES2jRDbTE7DxNXzZo3djOupNoFQ3n+NoOjJ5ArDVdZ702DjYaLa1kUleSd9TobTR9zJkuM5mWWayq+1jJVyEgnSnm0H2FSsRQ6ND1nmg5tnpzkFn3W8JSzMq+QqskiaZa8lKzVL/77CKEEF9caHreWgumEV7yCx8PkfpSVZJTl7A5SNls+76zVuD1Ondk+8EwGcU5WlKzUHW7UXRVSQEWSl6R5SVaWuAZYph6gXwcOthllTDb5aC9RaXhrDutNl/d3huwOlBdP07fJ8grHEIyynEFaKOE0qTYIkqzicWc01pWyEULSjXLqrkVRSrKyxLFNXMvkG1s92oHDesvHMgxsA+quySgvudEKeGc1JC8kj7sxnSh9qQ872Ke4lkHNtWkFagfaEEwzjl3WPTxNv7NI4Z9vKrOhgTdaPmle8nA/Is6KY/vyYVKw1nDIS8koK9jpJ5hIFUY1M9bOnj8vS/ZGKf/8wT4P9kZI1OQoK1XfujNIkKgwxNAx2emnyoupZnOjFXBvtcEX7i5xo3X8fMizTT59s0lalOSF5J21Bp/ZbBK6Fq3xvDd0bSWufiAk8mYrYJTmSp/DENRckywvWWt6BI7JO+s1ap45bVcbTY+aZ4EQrxRGpZkfm82AjbpLw3dp+BYN32Wj7rLZnK8xqR1aPO0mRGmJLSqitORpN6Edzne+sOTb+K5BKVXWvVIKfNdgaY79PqikEI/H4uiOaZAWFY/HWQA1h6PvzDloeBaWETJKC6W1MBb5OrjDqjkb0wkZglpgISvlpmhbJqYBxjELsOXA4fZyyCgtqSRUSNaaPi3Pmk4ktBX/aDzb5P5qDd82ebg34sFeRDuwub0SstFQnhdZUc19N+Qkt+jLEOeaR0jVSbulF/l91uouW71E6fOMvR+irGTzFTVgJq7QW92Ymqt2DQGEIQg9S4mz1Vze3xkwTArivORWOyD07LESfUVgW3iOTWALfMfGswXDOauZay6P2TbjWga/8KhL4CpRso2mT2eUsVJ32RlmfPZmCwkgYKPl049zVkIHIQx8x8SxTJqBYG9U8qQXYQi41Q7Y6kaM0oK6qzIqlGVFM3ToRDmtwFFZb9KS3UFKJVWda/kWu8MMwxCYQkwXh7Nt7GCfslxzCR2Tuu+80FYvykh6mns4z2M0F8eLoYEGt9sh2/2Ep72E2+3gyL685lmUJaw1XD7YGVIhMIDb7ZC6b0/HWgDHMqmkpBcrT8i6a9MZZQSOybAsaHg2+8MUhODt5YBBWpIWUnm7jTIsy2SjabAcOriWcar50NurNZXBJC2opByHc1ZsjHeG07zEPiQksqwkX7jb5v2dAZ0oo+ZZ/OBnNl4Qt68kh4ZKKcPh2cKoNPNjpa7m1N1RTlIoHatWaLNSn2+o/FozYH2Uk2cVUVbimCbrbZ+1ORtOAsfm3kqNJJfTdZ1nCwJnvgaM/WGKbZmIsUeSM/ZC2h+m1y4pxGWhDRjnYLnm0t0ZkpdqxyYvK7Ky4nZNTyTOi2ebtEOb3ZFJkkNZSgwhcC3w7aMHsmbgsNHw2R2l091m1xQ4tql3pk6JZ5vcW61xb7XGBztDAufFXfvTaDOcN5f7adyir+Ok/STDy0V+n82xZ8RoHAttGIJ2YLP5CteYPM9+UvBgb8TNJR/LVO6/w6TAsQRf3+pRcy1W6x43WwEfbA8ZJjlrDZdKSr7yUYcsLxjlBUJYhC7UXRsVG6a5SM7b/i6C5ZpLL1JGCSklDc8mzkput1VGobvLIUuhg5CSuq8+03csunFOu6b+TouS/UHOJzcbfGKjQV5KVuoqhj8vKkLX5P5qi/1RRlBWFJXEtUzurYRICd0oJXRNfvnZACrJO2t1hAH7UYYY6yrdW6tPy3ywT5ncx4NtdRHur2ZxOK3uxUHur9b52fd3yaVkmOTYptKK+di60kOaHWsDx+RZP6XhWzzcj5BSIgTcbdcwhWC55vJwf0ToWGOtIckH2yNavkvlqbrfCh3ysuKbT/oMkoK6ZyGEmKZPnTBbv33bxB+nQj5Y1z/YGR7qKam+t8N33V0+9HufNL7rkKjFYb3h8Y3HHfKyopJC6ZDlBeuN+Wpg3GgGDJKc3WFKXljYlmCl5nJjzgaMlZpDWpQMkoy0VJp5dc9hpTZfI8L2IMV3DOJM3WfLEPiOwfYgfWGM0jxHGzDOiZjGNqCEJo/JkKE5G65jISsDgcqXLgBZmbjO0dXWtdQEoB26VJVatNmG4K3lUA+AZyTJSzpRypNeRehYLIUOnm2eqM1wMB3hq6Q4PWyhv1xzX4tFw2UZXjzb5N5a/dz3bPZ5LgU2N5oeT/spqzW146bapoFEpWfdG2XYloq/TnPl+nl3OWS17rE7TFiquayGDsIw6MUZd1dqJxdCc2ouov2d59qz9W2z6TFIC0pUfXx7JeSj/YisKNkexNxfrePZKnOClOC5JvfrLqWEpKgYxDk3mj5LgTPOzqMmsYZwX2hDo7Sg5trsjTLSoqQT5VgmpEWpUvZmFXdWQrpxQeBZ4/tS8dG+SgF5krDwwe94VfdXs5i8qpCqZ5usNj2edhPlMSphue7hHqKdkZeSQVIwSgqWQodBlJPkFd045dY4y4ZrGUSZSlfdi9Qis5CSopTcagdkRcVWJ8I0DTaXfJCw1Y2I85L7qzU8W6XG/vpWT6XKtk1qnq02f1ova18d972PM/KdxpCvU58uBiqUx8Q0KwpZYZoGQqjwn3myXHNoDhyyAuKiwLcsmoGjsk/NkbWmx6P9iJrrUhcqbF1W1dyzF6Z5SS/OCdyZpBD9dCqGq3kZbcA4B3vDlLrvsFx/0dVNiw1dDK6hOkzXtghsSYkgL0tc45hYyHEKyiXHnir5jrL8UNV5zdFMJulNzyEvUrKimmabmHiyHMVRmTbO2i5mFw960fBqXISx5ODzvNUOkajMErYhQCojRuDY+I7KX96NMlqBw5NuzCgr2Gh6rDQclgc+gS2QgCkrQs9RaXI1F8ZFtb+zclgbrQc2SV6ODRCSh/sxnm3wvW+3CVx7WqabS8E4/GhIZ5RSt5WA8zDOaddslkJHGVTHBoqqki8siCY7usuhw7d3h2P3eMn3vLVMu+bxuBOxG6UsBS5RVlJzbQSC0LXOfF+u6v5qFpdXFVLdG6as1pTHmkodmiBQ7uQrde+Fc3ywPeDDvSFFIQkcC981eWejTllKyvHG2XLNJelEtEOX3UFKKpXo4sfXlaFwf5jSi3Jur4TYYyFcIcQ0RfpyzeUbWz0sQ4VxFaVkf5TSDt1D6/dR33vy+nHj9XFj03X0rnxdedZPALizFKpMTIUa3yevzwvPmnjyePi2QZxXdOMcz5rvXN41DW4s+eSVfGETdN7ZC13bJO7HJHmlRHeFQFKxNmdPl+uMDio7Bzr/+nzJpMFazVfx+xIsQ7BW88nk8dX21lKAEExFoG7pgfDMTCbpdd/mRsvHtQ2qCvpJdqLRYB7tYnbRIMZGKscyp/HBmvlx8Hl6tsmtpYCiqOjFObYp2Gj61MbCipahnrVnm6zUXDxb7QoGtsVmy0WM1eVLoOlbShlfc2Fc1bh0WBtdrXncWQ4xTcbGC5PP316iFbovteGJ/s5mKyAdi2lutn1utFT//bQXIyXYpoFlGS+ICU8WPEo7w+DucsCtcajKo05EVamNBRO105UXFVlZslp3z3xf9Lj/ZjIx0H2wM3xJyPpVhVRn69Ik/bBjCfpJ/tI5pBB4pkElVahyJSV5USmdl3F8/qQcgWPSDh1utHw+e7NFcxxDH+Ulpqnc0ydYppimSJ94QvnjsFHbMnBMk2GSH1q/j/reo7TQ4/VrwiDOWWu6WGNvG8syWGu6DOL5alclheRzN5u4tskwq3Btk8/dbJIUc/ZyF4KbLR8D1acbqL/nvQnq2UoENxtLEqg2jt6gOwbtgXEOdP71+WIKgWlKPMvEMMAxTExTWSaPYpJe80bLn76WFRW2dsA4E7Mxvd5YgE82JJ1RdmJIwjzaRT8pSLKCvFJ57ZfGQmQnaXFozs9hz9M0DO4sh8BzMbal0OFpLyYvlat/VlQIAZ/ZbOHZJl9/1GXfNjEMJSDnjMO9pM5rfKFc9rg0cRV/b3tAw7Npz/QJtilwbZNPbTZZCtwT9XRm9Xcm537cidjuJ9iGQVoqcc7AsdjppzzqRLyzVp/2Q5Nd2ygredyNsQwDzzZIcggsi2FW4FrmNLuBIcSZxwY97r95nMYD8FW8Bg7WJc82Wa55Skdo5lx7wxTHNGgGLoYhKKXK/DFIc95arr2kvzHxaHrciTCEGGu0qTDcpcCZpkgHKKb6YirzQeCajLKCKFNGRMcUCHhhJ/gkDZij0oXr8fr6sRS4fLQ/ohNlJEWJZ6n06Hfa4VyvK6Wk7tos157XuywvSYv516GdYcpKzWXD9ChKyc4wZbM1343QUlbcXArG2bWUeKhlCkqpDeNHoUfcczDvVI5vOi3PYG+YkZYSU0JaSvaGGS3v6Gqrn8nFcFi6z2FS0Imyl1KmnZSO8LzPIMlLuqOUvJT4tomUajd2kBTXftFw3K7eonDc85x9z7UM2qFLUVW41suiucJUGUeC8U5jYKudPWFq6+JFcpl94Gx6x6Zvk5eSp714Wo9nF/ZHpRA+rg0flr634dmkeYngedae2bazXHPZGSS0fIekKNnqxjzpxdQ8izgr+Nh6nY2mhyHEK90XPca8eVyUB+DB/j50rVPVpX5SsDdMqHsWvm1Rdx1cU2AZBobg0Lp3mHfEpzebtAJbZc4rSrK8ZJSpuPvlmotrGdimwVYnUX26KRilJXvDbJrOcbbNHzUPeJW2rllM1hoO7z7rszdISJKCvUHCu8/6rDXmq0Wx3vSJxmLNcuxtFOUF603/5IPPg5wIGo7/FuN/5qxvGNjWdHPuZstnKXRwTIPA1n4GR6F7k3Og86/Pl7KEumNTVSXDrKSqSuqOTXnMGk8/k4vhsEn6ziBhte6dOIm76GewN0xZrXtIoKgklikQCHYGybVeNJxmIrgIHPc8D74XOCZfvNvmU5vNFzI2PO5EPOnENAOHQZrzsBMT5yVvrdSoSu2BcZFcZh84u7BbCt2xlrVK/XZwMfaqC/9JRgfPtrjZCtTusWXg2CahZ7M/StmPMr78YH8aj78UONgWpHmFMMaCcIFDw3MwDXHm+zK78JxoBegx5s3hIsKGDuvvT1uXoizHEAY1z2atqcbgvFQitcfVvUlfcG+1xs2lgFbgcG+trsR145wP9oY866Xs9hO2ujGha9GPc9bqLo5pEKXKi+6Tmw1GaQGczpijjXyvDzu9lLpvU0plSCsl1H2bnd58w4E2Wz5L4w2RKCsoqoql0GWzNWcDhhDcWvIxxmHohoBbS/MPIWn49lig+vl1V2ouDS3ieSRzM+0IIf4y8JuAbSnlZ8evtYG/CbwFfAj8DillZ15luAy02ND8yCpJJUpGWUFWVOSVge8IshNczvUzOT+HqYS3Qpe697zLSPKS/WFKP1GxkIepjF8EaVFR8yxsy6AbZcR5iWMJ6pZz6MTtuqQ4vE5igCcJrs1miJlMymeNF5WEsqx4sDtCCMFG08OzTHpRzlp9zhOSN5DL6gNfDjXz6IxSdoYZFZLAtl6oD0qoc8AwKah51jQLyUks11zefTag4dukRYltGgzTHFlJPtwZcnc5JHStqRHQtQwMw+DjG/WpWGFeVGPvIOPQe3NUv3FY+MCkjR4s+3XpezRn4yLCho7q70dpwc1xyuu9YcpWNwaUVks3yhBCMIhzHNsYa1KoXdrAMWn69qkNcLP1sl1zSfIS0zRU+53JRuK7FrKSOJVBO3ReCNdM8pKP9kYYhsC1zGlmssNCwXQmkdeDjzojhJSErqprpmEgpOSjzmiu1/Vsk9Ax+YWH++wNM5ZrDt93f3XudWgShr7RvNww9OWaywfbgxc0MOyi5FZ7seaCi8Q8PTD+CvBDB177EeAfSSk/Bvyj8d8azaF04oydQUbg2KzWXQLHZmeQ0Ymzqy7aG8HB3ZuGZ03dQpViekxeSpq+PVfvgcnkcaLFcXc5ZLnmHWqZvi5eDfD6iAEed8/3himVhP1RimWbWIaJKeBpPyWrJHn18j3QXB8Ouop7tkno2tQck7W6coOd1IdupPRz1uo+n9hosFb32Rump2qbnm1ypx1MY/+jvECgdq1bgQ0I+nFOJSWOZYIQjJICWcmp+/Fxop0n1eHThA9cp75HczYuwqPguP5+tu4YAr69O+QXH3cBpS80ykritCAryzPvzh5WL7++1aMb5YSupeq2bRI6NlFaUFYVK3WPu8shN8apUydt/HEnwhqHmUxCOZO8PNSYc3D+oI0X15NuVJAWkqXQYa3hsRQ6pIWkGxVzve7TXsz/8N4OddfhM5tN6q7D//DeDk978Vyve5XeQ1IImAyncvy35kjmZsCQUv4ksH/g5R8GfnT8+48Cv2Ve19dcf3pxQWjbhI6Fa1mEjkVo2/Ti+XacmsOZ7dj3hykClQ5z6ZCMAvO67kkDynXKVvK6xAkfd8/TomKY5DimiWUK1pouy3WPmmvjWcbchbE08+UsoWbv7wzO1TY3lwLagcMn1usIqUJVlHeWjRyXpTPKpovEO8shpZTTbFQbTR/TMA5tXyfV4dMYGq9T36M5GxcRlnVcfz9bd7pRTlFKGp5DnFc4lslGyyMuJQaCO+2AdugijtC+OMhh9VICnSg7NBtJ4NiHjreMjYNrdU99DwG2YbDdT3R4yGtM01PZxbK8VPUhLylKSdObrzbDVx52aHgODd/GNAwavk3Dc/jKw/k67V9VGPreUOk73VkOeWulxp3lkIZn6/HjGC5bHWRdSvkEQEr5RAixdsnX11wjPNOk3XDY6aekeYVrG6w2XDxTW/Kvglm30H6S0/RtAseiG2WkY7Vy1zK5uXT0OV7Fxfos7qjXSf18ohIPqox5KcnGMc3XiePuuWsZRHlJw7OxDJNW4LAzSBFI8gpW6y6updvzdeWwtrkUONQOTG5tUzBMCm62XjQElFXF415yqv5g9lqTzywFNpZpsFJTMfvxzG7wcs1Fjj02hknOo06EQAkZwot90bNePM5c9dy4MVuHTxM+cJ36Hs3ZOS4s6zTjmgqfGhKlBZVUmT8C1+L+ao2tbjytO5MUqZ5lkJbKSBY6FiuhQ1nJM4dkHFYvA9tkr5SHZiNpeNY0JHD2WlvdGNsUCGGw0fToRhlJVSHlyQs8HVp1fbm7UqOU8KQfsz0sCR2Tu8shd1dqc71uN1KC3+8+GxDnBb5tsVZ35+75AVcThq7Hj7OzsPKmQog/CPxBgDt37lxxaTRXwY2mw899O6Lp29g1tcDrDHI+9vZ80ze97pynbc127HFWsjfKcCwD3zaJs5Ioy0jy8khtipNS0Z3musdxnVIcvi5xwsfd8+Way4O9EXFWUncNfvlZhGcJbjZDJPCsn/K5zcbVFf6CeRPHrZfbZnRofaiNQ9Amryd5yaNOjGsZp+4PZq9VSaik5GkvwRCCvKgQMDUCTjQ3vrHVQ0oIXZOa+3xHa7IzHTgmlmXwqBNxux1Orz1bh09jaLxOfc91ZFHb1lnGNSGV5wKTRAfjzAazdccxDQwhSAs51csoKonnmGw2/XOnagWoeTbNcTaSiQZGlBcshe5LKYkPO88knDMrKgzBicaLVx33NfPnpHZ1bzXgQWfE2yshpoBSQl5J7q3Od4FvGYJfetynXbOpuRZZUfFLj/t8bGO+hpOrQo8fZ+ey78wzIcQNgPH/20d9UEr5F6SU3y2l/O7V1dVLK6BmcbizXKMRWLimhWUYuKZFI7C4s/x6dmCXxUW0rUmqQoEaaIpSIpGs1r0jXd4uw8X6uqmfvw5xwsfdc882+fRmk7KqyApJO7BpeC5pWdH0HVZCG9dZWDv6mdHj1tH14f5q/YXXtwcJIFlreGfuDybXMIRgvaGU6vtJznLNfaEdjdKCW+2Q++t1brQC6r59aDjLWt0DBNv95NA6fBqX4uvW91w3FrVtnXZc2xum1H2HO+2xi3g7pO47U5HbSd1pBTaWKegnGb5tkBUlo7QgHBvkzsph9dIQ8J13lthsemRFRVqUbLYC7q/WjhyDXrV+69CqxeakdtUIXD61Xme57uK7Nst19XcjmG+/1vRtSllSVsreV1ZQypLma5qVQ48fZ+eyZ44/Bvxe4D8e///fXPL1NdeIwLP5DZ+7wVcf9+hHBY3A4jtuNnF0XuQrx7NNWqFLkhUqK4hpsNH0p2rlh3EZLnKvi1fDdeKke94KHL5wtw3ss95wScoK37aouRatQAnAal4fjqsPnm1OXy+KilsH2uZp+4PZa+QSNps+yzdfdks/qs85GM7i2Sa3lnye9pJD6/BpPMB03/Nmctpx7bjPHazPb6/U2Gz6dKOMrKjYbHpsvmJdOq5eTtKqnvc8x6Fd468/n9xs0o1ysrLCMY1LGbcdy+D73lnlve0hnVFO3bP4vndWMQ1x8sHXED1+nJ15plH9G8CvBVaEEI+A/zPKcPG3hBC/H/gI+F/M6/qa608rsNnpF9xo+NT9kpptIgRj1XnNZTGJX+0nBVGWE9gWDd/GtQxqrjd1cwWVbuool7fLcpF709LoLkJ88Un33LNN7iyHVJKX6su805NpLp+j6sPs65N0dbMc1R8cVcdPaudH9TkHw1lAaQDYlq6MmrNxmnEtyUs6UcrTbkXoWbQCZ5rdY/K5w+rzbL2fTUd8Vi5qTDypjIeNP9o1/nrjWgadKGNnkDLKCkLHwjIFS4Ez1+vWPItRWvLOWn1qOLFMQei+vgv6N23uel7mZsCQUv6uI976wXldU/N6sdn0+Ns/9xHDJJ/GjdY8m3/jX/z4VRftjWE2BVsvSjGEQa/IsU3l2hoLQcOzj4wNn53cICVxUU0/P0wKdgYJrdCFTqSFvV6Bi4ovnrcRJMlL0qLio70RoWexWnMxDeNaipZqLobTaEskeclWJ+Kj/YjQtVitu9P0pAfr+GF1+Khr3F+tT13YJ33Rw/0Rt9ohgWMySAoePNhnKVAq+KdpD+dpi4tghNS8GrN1rKwqdoYpo6TgznI4TaH7uBPR8Bz2ioQ0r3jSjVmpqUwixwmDHlWfgFPXl3nWrYNlPKzdvC5i1W8qpiH4mfd2GKUVE/GWB7sDftPnb831ujdbAT/2C4+J0gKBRKJEb3/zd96c63U11wdtAtUsLF/9qEtSVsR5RS/OifOKpKz46kfdqy7aG8NWN2Z/lPGtp316SYFpClzbZJQV1H0H3zKOjA0/mH/etkyElORlRWeUsT1IWKl7LI3dER93oumET3M6LiK++OBzuuhnMTm/bRrcaHrs9FN++v09Hu+P9ELtDeYkbYlulPHlB/t87VGPtCgpK8mzfkI1Tuc4W8ePqsOgzpmXFd/eGfJ4nInk4LV7ScatdkjDt0mLiv1RimUYpEV56vbwqm1x3u1PM18mdSkvSj7cHYGEt1ZCbNPgcSdia7zAb/g2N1oBjmVQSkkvyY41bh1Vn7Y60anrS5KXvL8zZKsbszNI2OrGvL8zvLC6NVvGSbupKnjUiXiwO+LLD/ZJ8vJK0lJqLoZvPenTGeXsDBMe9SJ2hgmdUc63nvTnet3OKMMxBbZpIFD/O6agM8rmel3N9UGLCWgWkiQv+YlvPCPNCtaaHv44fKQ7Svln7+/ye37Vvasu4mtPkpd8tDei4dkYhsAUgu1+ymrdIZeT3RRx5E7K7OQGwLEEdd/BEMotsebZL7w3OUbvzJyeV40vnt2V60QpTc+Z27OY1INKSrpxwY2Wz0bDo5RymhJTT2bfTI5ymU3ykq9v9bAMA9s2MA2DTpSzFNh0RhkbTe+FOn5YXzN5fZJO9VY7nO4AT3ayJ9f+YIdpO1ITZxPLFErfZ3zOw9rDbDva7idsND0OS8V6HMeVXfeF1wPPNnFtk/tr9RdC5EAZF95aCaefu9HykVJOtS+O4qi+/XFH1YuT6kuSl3zlow4P90c0fZd2zcYUBp1RypZtcm/1/GLos2XsjDKkhEGSU0jJRtMmzlQ7/uLdtq7L15SvPurST1SGGtuEvITuKOOrj7r8wCfX53bd954NWPJd6q4krypsw8AyBO89G/CpcSpszZuN9sDQLByTHalBkuOaBoZhkOQVQhjYhkE/zq+6iG8Ee8OU0LMQhsC1TARqF2hvlE3jWo+LY02LappjfoJtCtKiOvY9zemZPIdZTnouB3d8k7xid5i+sCt3kc9i8qy7kUq5a5sGtmUgQavRaw5lb5giAd8xcS21QHIsgygryMrqpTp+XH9yGs+I2XaUlRWWKSiq59c4rD0cbEemIXjUiV9oR6eJ9dd94evBUc9RSnnmPhqO7tullCfWl0ndfNqLafkOhgE7g4wKSWBbPOvFr/IVjy1jVlZEWYkwBKFrIYTAd0wk6D7+GrM7THFtgWMbCMPAsQ1cW7A752c6ykv6SYZEtRWJpJ9kjLRnmmaMNmBoFo7JhHOj5RPnJcMkJ0pznvViRlnBxpJ/1UV8I0iLitWaS1ZUBK5JWhRkeUl3lDJICt7fHpDm5ZHuqMctrl9l4a15mVdJvXVwQRc6FoZQBoYJF/ksJs86LSqssYJ4UUoc09ALNc2hpEVFYJsUpaQZ2OSlpKoqoqRAwEt1/Lj+5DgDwWSh149zHu6P6Mc5tiGIs0lKS+eFc81ysB2tNTxApYc9Sxo83Re+Hhz1HNeb/iulRzyqb19v+ifWl+d100QYyv3eNgW9SOmJCXExYrWzZbQNQT/OqSo5TXVZlBJLwEd7Iz4Yh3Dp0KjrxXLdZZQU7A5S9vopuwOl8bJcn296z5qtNleY1FUhSPKKmvbW1IzRI6Rm4ZhMOL/7rTaGYdKPczpRQj/OMQ2T77u/ctVFfCNwLeW6vTEO4Wn4NllZUUlwbUPF+VrmkZOS4xbXOuf1xXCSjsBhHFzQLYUOlawYJcVcnsXkWQsBwzTncSfiw70hWVEySAq9UNO8xCTELCtLDASrdYeskKRlxXLNfamOH9efHLWwBKYeFEuhw1rdY3eQIISgrCqWQwfXMo5sDwfbkUrFGlAU1UttcWIoOWwRp/vC14OjnuNmy38lDYij+vbN1skGkUndXKk5xFlJUUlMAXFWEmUlaxe0+Jwto+dYmALqnoVjGuRFxTDJGGYllmW8pNdxXJvQLA6fXGtgWIIiL0iLkiIvMCzBJ9cac73ureUQ1zZ42o15uD/iaTfGtQ1uLYdzva7m+qA1MDQLh2sZDJKCmmcReAZ7ewl5XuJ7cGPJ497a+WM3NSczUQ93LJP1hkc7dDHEiLV6k/p4hyXJS/ZHKsXW7XbwgijjSXmtT8p5rZX5T8dZU28dTGvn2SbLNY9+kr30LC7iGUzKlxUVP/XeLnGW49kmg7igVUv4gY+tnel8mtef5ZpL0olohy77w4Sn/ZSiqPj0zSabLf+lOnhUXwMcmf1GwAvaE3XfxrVNDAHLtcaRfdOkTWz3E0xDeV5M3jMNg/WmP/X82BumhK413RE/LDvJSf3kYei+cfE4zXh3HtKiYqsTgRAIIC8r8pJD68ukj19v+qR5STQ2JsTZc6NbN8oYpcW5M5lMvvdN4EbT4+tbPfpJTmCbGKaBa8Ba3RuHb6lrb3Vj5FiM9zzZszTz59ZywPozj/e3hwzTnJprc3+txq3l+WqaNHybpm8zTAuSVBK40PRtGuO55zzR/ev1QBswNAtH6Fp862mfD3dHVJVks+lTlJJ26JCXkm/vDPn87fZVF/O157AJ2VLgUPNUt5HkJU97MbZhUAl5aHrD4xbXx713UelBNS9zWFo7Q8BnNlsvGZAu6hlMPh84BqHjTV8fxDlPuvHUVV+jged9w1Y3Js4rNpf8qfHhqDp4sD+Zrb9vrYTsDFI+3B1xpx1Mz31YaMlEXPEocdHJOTeaHo86anfw1lKAaRj0kxwhJbbpTNvMN7Z6rNS9Y0UXz2KE1H3j4nJWY/JxzD5nQ6jMHiC4teRjmuY0Felhz3x28+H2csjjbszeIOWt1Rq3Wmo+9eUH+9xqh9Q969g6dJb61gocvni3PV38pf2EjZb3wudsU/BoP+ZWO9TCtdeAfpKTFyVrdY/Vuo9Akhcl/WS+WnRpVpAWknurdVxTkJaSfpyTZsVcr6v71+uDNmBoFo5RWnC7HfJ3vvSQhm/TClwVL28JylLytYc9fusXr7qUbwYvT8ii6e79RK0fAZ75fCfzIiYhWpl/fpx2x/ein8F7zwa0A5fAfT7sRGmhVcU1h+LZJq5lHJrZ4TR18MX6a3Bn2SIrKuXuPj73rCcSnKw9cfCct9sB24OEJ92YO8shvmVgH2gzUsIwyV/YOTxNdpLTlUH3ja8rs8/5STcldGwQ0ItzNpr+9DOHPfPZPj6X4NkGv+Lt5ann5NNeTOjajNKChm8fW4fOWt9m5wyuZVC9GL1FXkqEEEcaDzWLxfs7A5ZrPq3w+SZDd5Tx/s6A7703v3DuXlJwu+0TZxVpWeGYBrfbPr1kvgYM3b9eH3TwsWbhSItKhY+4FnXPpqokozRnf5gjkWjJv6tjNs43LUok8gWxu4sSZdTK/PNlMsm8t1o7NHTncSfive0Bu4PkwrKT5JXEOvBMLVOQH5zhajRjztMPnHTsq2hPHKZ7sTr+fFpUbA9SyurFsgWuSXQgvv88Ip26b3wzmH3Ok8w4lvH8OZ/0zGf7+KXAnXpOTs7t2QZZ+fz4o853mvp2lJ7FUW1sre5q4dprQlmBZQmKUj3DoqywLEE55+5GSgkSmFQ9Acjx63NE96/XB91baBaOyc7YRtNnlFSUlQpPEMAwqbips5BcGbOiXVUlKaVko/ncRfSiJiFamf9qmE0N2fRV9oenveepIc/zDDabHoOkoKhUKsCikgySgs2md/LBmjeS8/QDJx37KgK4B8+Z5CWPOtFUpPCwVKo11x5nTrkYkU7dN74ZzD5nxzQoSvlCat+zPPODdca1VGp6x3x+/FHnO6m+HUwnPCvUeaQQ6VKghWuvCat1F9+yEKhFvEDgWxarc85C0godHu6PyHKlQ5HlFQ/3Ry94gswD3b9eH/QT0SwcE6v9/bUQ2wKBxBaCmqvyT3/ulnY3v0omk5Iv3G3TDhwMIS58EqKV+a+GWffJpdAdb4AI9ofpuZ/BJzebhI5JnBdEWUGcF4SOySd1+IjmCM7TD5zm2OM8kU5zzu1+AoipSOFhqVSFgE9vNs+chWIe90RzfZh9zq3AZpTljNKCpm+f+ZkfrDOhYzFKc0LXOrEOnVTfDqYTdiwDxzLZG6bA4W3sVYyHmqvh87eXSIoCxzJYq7s4lkFSFHz+9tJcr+uaBst1DyGUkUwIWK57uOZ8l626f70+aAOGZuGYDG5rdZ9f+4lVlusuoWez0Qr44c9vslrXHhiLwDwnIXqCczXMuk96thIqdCxBP8nP/QxagcP33l/hRtMjdC1uND2+9/6KFvDUHMl5+oF59CEHz1lWkltLz7OiHJVKtRU4ZzKUXPb30iweL3g7SthsBWw2PSrJmZ/5wTrjOyZfuNsmcMwT69BJ9e1VXe7PajzUXA0bTZ8f/NQGtiXYHqTYluAHP7Ux1WGZG0Jwf7XGRtNjueay0fS4v1oDIU4+9hzo/vX6oEU8NQuJZ5vcbges1FzeWqlP0xmFjqVduRaIi1Rdv8xzaw7nqBSrq3XvQp6FZ5tsNHzSQLVnPSnQnMR5+oGzHnua9HkniRSahsGd5XCufZfuGxebi0rDeJHP+bBzndZ4fFw5XkUMV3O9aAUOn7vZmtbny9h0mPSts4aSrKiw52u/AHT/el3QPYxmYQldi4f7I9K8wrMM0nEMXOhqu5tGMw/m6T55XKy0RnPVvEr91O7GmoO8af2cbgOvN1dVn3W90pyEXglqFpZRWtAIbN7bHtCLcpqBzTtrdUZpod3ONZo5cNoUq6fh4C5kmpdUUsVMZ+O0aKFr6fRkmgvjPDvfr5I+72B7ASU2vdWNz7Xzrrm+XHUaxvN6f5z1+IscMzSLx94wvZJxW3l/ury/M2CYFNQ8i/urdV2vNFO0B4ZmYdkZpny4M6LpuXxsrU7Tc/lwZ8TOWBxKo9FcPBcRm3zYrs17O0OedCOkBN82kRL2hgn9Oed117wZnHen8Lyx/JstHykltmW+ETvvmsO5yjSM520Dr3q81rN4feknBXvD5NLH7Ykhba3u84mNBmt1n71hqvtTzRRtwNAsLE97MY5l4jsmhmHgOyaOZfK0F1910TQazTEcpkxfVBWDpMQev2ZbBoYwiLL8qoureQ04KRvCSZw3fd55r695PbjKNIznrYO6DmsOEmU5hjAufdzWdVFzEtqAoVlYTCEwBBSVREqVA90Q6nWNRrO4HLYLWXcs0qIkL1VMa15WVFIS2DqSUXN+zrvzfd6Y66vcedcsDlcZu3/eOqjrsOYggW1Rjcfryxy3dV3UnIQ2YGgWlnbNoeHbKg90USEENHybdk3rX2g0i8xhu5CeY7HR8DAExLlKT7ZSc2n49hWVUvM6cd6d7/Omz7vKnXfN4nCVaRjPWwd1HdYcpOHbrNTcSx+3dV3UnITe+tIsLPdX63z5wT4118YLDZK8YpTm3F9tXXXRNBrNMSzXXB53IkDtmuSlJHAthCOp+870Na0qrrkoDqtzWVGeSWjuPOnzLuL6mteDq0rDeN46qOuw5iCTOtEO3Usdt3Vd1JyENmVpFpZW4PCFu21MEzpRhmnCF+62dQYSjWbBOWwX8v5qjXtr9SvZmdS8/lzlzvciXF+jOW8d1HVYc5CrqhO6LmpOQntgaBaaVuDwXXeXr7oYGo3mjBy1C6l3UDTz4qp2vhfl+hrNeeugrsOag1xVndB1UXMc2gNDo9FoNBqNRqPRaDQazcKjDRgajUaj0Wg0Go1Go9FoFh5twNBoNBqNRqPRaDQajUaz8GgDhkaj0Wg0Go1Go9FoNJqFRxswNBqNRqPRaDQajUaj0Sw8Qkp51WU4ESHEDvDgkLdWgN1LLs5Z0OU7H4tcvrtSytWrLsR5OaZtweLef12us3HdyvW6tK0B8M2rLscJLGrdOMh1KOd1KOPr0raOG7cui+vwvCdcl7Je53Je+7Z1inZ1XZ7PRaG/72JwaNu6FgaMoxBC/LyU8ruvuhxHoct3Pha9fK87i3r/dbnOhi7X1XAdvt91KCNcj3JehzJqLo7r9LyvS1l1ORebN+176++72OgQEo1Go9FoNBqNRqPRaDQLjzZgaDQajUaj0Wg0Go1Go1l4rrsB4y9cdQFOQJfvfCx6+V53FvX+63KdDV2uq+E6fL/rUEa4HuW8DmXUXBzX6Xlfl7Lqci42b9r31t93gbnWGhgajUaj0Wg0Go1Go9Fo3gyuuweGRqPRaDQajUaj0Wg0mjeAhTRgCCH+shBiWwjxtZnX/q9CiF8WQnxVCPF3hRCtI479UAjxi0KIrwghfv4Sy/fHhRCPx9f9ihDiNxxx7A8JIb4phHhPCPEjl1i+vzlTtg+FEF854ti53j8hxG0hxH8nhPiGEOKXhBD/xvj1thDix4UQ747/Xzri+LnfP83V3ucj6u+R9UMI8e+My/lNIcS/NKcynbneXlK5PCHEzwkhfmFcrj+xCOWauZYphPiyEOLvLVK55smi9lFnbVdXVMZzjQ+XWM4ztzvN64c45bz0qljUvuggR7X7ReXguPa6c13q0UVx3erjRXAt67SUcuF+gB8Avgh8bea1/xlgjX//08CfPuLYD4GVKyjfHwf+rROOM4H3gXuAA/wC8OnLKN+B9/8z4D+4ivsH3AC+OP69DnwL+DTwnwA/Mn79Rw57vpd1/970n6u+z0e0r0Prx7ju/ALgAm+Py23OoUxnqreXWC4B1Ma/28DPAr/yqss1U77/I/DXgb+3CM/xEuruwvZRZ2lXV1jGVx4fLrmcZ2p3+uf1/OGU89IrKtvC9kWHlPXQdn/V5TqmvC+Ma6/zz3WqRxf4na9Vfbyg73zt6vRCemBIKX8S2D/w2j+UUhbjP38GuHXpBXtelpfKd0p+BfCelPIDKWUG/NfAD19o4Ti+fEIIAfwO4G9c9HVPg5TyiZTyn49/HwDfAG6i7sOPjj/2o8BvOeTwS7l/mqu9z0fU36Pqxw8D/7WUMpVSfht4D1X+iy7TWevtZZVLSimH4z/t8Y+86nIBCCFuAb8R+C9nXr7ycs2Zhe2jztiuroRzjg+Xxiu0O81ryCLNSw9hYfuigxzT7heOI8a115lrU48uiutUHy+C61qnF9KAcQr+N8A/OOI9CfxDIcSXhBB/8BLLBPCHx66Ef/kI19GbwMOZvx9x+Y3iVwPPpJTvHvH+pd0/IcRbwBdQu1frUsonoDoPYO2QQxbh/r0JLOJ9Pqp+XHpZT1lvL61cY9e/rwDbwI9LKReiXMCfAf5toJp5bRHKNU+u2/c4Tb97JbzC+HCpnLHdaV5/jpuXXgXXrS8CXmr3i8if4eVx7XXmWtaji+Ia1MeL4M9wDev0tTNgCCH+GFAAf+2Ij/wqKeUXgV8P/O+EED9wSUX7fwL3gc8DT1BhGgcRh7x22WlgfhfHe19cyv0TQtSA/w/wb0op+6c97JDXdBqdi+c63edLLesZ6u2llUtKWUopP4/a/fsVQojPXnW5hBC/CdiWUn7ptIcc8tqi1rnjeF2+x5XyiuPDpXLGdqe5pgghfkII8bVDfn545jMnzUuvgmvXFy16u3+Fce114NrVo4ti0evjRXCd67R11QU4C0KI3wv8JuAHpZSHNiAp5db4/20hxN9FuT/95LzLJqV8NlPOvwgcJoTyCLg98/ctYGvORZsihLCA3wZ811GfuYz7J4SwUZ3CX5NS/p3xy8+EEDeklE+EEDdQu1oHudL79waxiPf5qPpxaWU9Y7299HsopewKIf4J8EMLUK5fBfxmocSMPaAhhPirC1CueXPdvsdp+t1L5Rzjw5VwynanuaZIKX/dce+fZl56RVyrvuiIdr9oHDquSSl/zxWXa55cq3p0UVyT+ngRXNs6fW08MIQQPwT8UeA3SymjIz4TCiHqk99RAktfO+yzcyjfjZk/f+sR1/0fgY8JId4WQjjA7wR+7DLKN+bXAb8spXx02JuXcf/GGhx/CfiGlPL/NvPWjwG/d/z77wX+m0MOv+r796awiPf5qPrxY8DvFEK4Qoi3gY8BP3fRF3+FentZ5VqdKN8LIXzGbfyqyyWl/HeklLeklG+h6s8/Hg+IV1quS2AR285xnKbfvTTOOT5cGq/Q7jSvIaeZl14h16YvOqbdLxTHjGuvM9emHl0U16U+XgTXuk7LBVASPfiDCnF4AuQo69/vR4m6PQS+Mv75c+PPbgJ/f/z7PZRC7i8AvwT8sUss338F/CLwVVTjvnGwfOO/fwNK0fb9yyzf+PW/AvyhA5+91PsHfD/K/eyrM8/yNwDLwD8C3h3/376q+6d/rvY+H9G+Dq0f48//sXE5vwn8+jmV6Uz19hLL9R3Al8fl+hrj7EJXXa4DZfy1PM9CsjDlmuP3Xcg+6qzt6orKeOZ2dkXlPHO70z+v3w9HzEsX5WdR+6JDynlou7/qcp1Q5um49rr/XJd6dIHf99rVxwv63teqTotxoTUajUaj0Wg0Go1Go9FoFpZrE0Ki0Wg0Go1Go9FoNBqN5s1FGzA0Go1Go9FoNBqNRqPRLDzagKHRaDQajUaj0Wg0Go1m4dEGDI1Go9FoNBqNRqPRaDQLjzZgaDQajUaj0Wg0Go1Go1l4tAFDo9FoNBqNRqPRaDQazcKjDRgajUaj0Wg0Go1Go9FoFh5twNBoNBqNRqPRaDQajUaz8GgDhkaj0Wg0Go1Go9FoNJqFRxswNBqNRqPRaDQajUaj0Sw82oCh0Wg0Go1Go9FoNBqNZuHRBgyNRqPRaDQajUaj0Wg0C482YGg0Gs0RCCH+nBDi37/qcmg0Go1Go9FoNBoQUsqrLoPmHAgh/jjwjpTy91x1WTQajUaj0Wg0Go1Go5kX2gNDcykIId4SQkghhHXVZdFoNBqNRqPRaDQazfVDGzAuGb2A12heDSHEF4UQXxZCDIQQf1sI8TeFEP/R+L3fJIT4ihCiK4T4Z0KI75g57kMhxL8lhPiqEKI3Ps4bv/f7hBA/deA6Ugjxzvj3vzJzjV8rhHgkhPgjQohtIcQTIcT/euY4VwjxnwohPhJCPBuHn/gnfKeTzvlPhBB/YObvF8o7Luu/LoR4d3xf/kMhxH0hxE8LIfpCiL8lhHBe9Z5rNBqNRqPRaDSLhDZgXALjBdQfFUJ8FRgJIf49IcT74wXH14UQv3Xms79PCPFT44VQRwjxbSHEr595/20hxD8dH/vjwMqBa/1mIcQvjRdy/0QI8akD5fg/jRdyIyHEXxJCrAsh/sH4fD8hhFg6xff5/vEisSuEeCiE+H3j13/jeIHZH7/+x2cO+8nx/10hxFAI8T95lXupeTMZL8L/LvBXgDbwN4DfOn7vi8BfBv63wDLw54EfE0K4M6f4HcAPAW8D3wH8vlcsygbQBG4Cvx/4f8y0mT8NfBz4PPDO+DP/wTnPeRp+CPgu4FcC/zbwF4DfDdwGPgv8rjOcS6PRaDQajUajWVi0AePy+F3AbwRawDeBX41atPwJ4K8KIW7MfPZ7x59ZAf4T4C8JIcT4vb8OfGn83n8I/N7JQUKIj6MWdv8msAr8feC/PbAD+y8D/yJqofU/B/4B8O+Oz2cA//vjvoQQ4s74mP9ifI3PA18Zvz0C/pXxd/yNwL8mhPgt4/d+YPx/S0pZk1L+9HHX0WgO8CsBC/izUspcSvl3gJ8bv/evAn9eSvmzUspSSvmjQDo+ZsKflVJuSSn3gf8WVW9fhRz4k+My/H1gCHxi3D7/VeD/IKXcl1IOgP8L8Dtf9ZxnKNOfllL2pZS/BHwN+IdSyg+klD1UW/3CGc6l0Wg0Go1Go9EsLNqAcXn8WSnlQyllLKX82+PFVCWl/JvAu8CvmPnsAynlX5RSlsCPAjeA9bHx4HuAf19KmUopfxK1GJvwvwT+v1LKH5dS5sB/CvjA98185r+QUj6TUj4G/nvgZ6WUX5ZSpqgd7pMWO78b+Akp5d8YL7j2pJRfAZBS/hMp5S+Ov9dXUcaUX/MqN0ujOcAm8Fi+qDr8cPz/XeCPjD2CukKILsr7YHPms09nfo+A2iuWY09KWRxyrlUgAL40U4b/3/j1Vz3naXk283t8yN+v+l01Go1Go9FoNJqFQhswLo/JYgshxL8yE6/fRbl5z4aCTBdbUspo/GsNtSDrSClHM599MPP75uzfUspqfN2bM58572LnNvD+YW8IIb5XCPHfCSF2hBA94A8d+F4azavyBLg544kEqi6CquN/SkrZmvkJpJR/4xTnHaEMDwAIITZesXy7qPbzmZkyNKWU5zUevFA+VLiJRqPRaDQajUbzRqINGJeHBBBC3AX+IvCHgWUpZQvl9i2OPnTKE2BJCBHOvHZn5vct1G4042sJ1CLv8blK/iIPgftHvPfXgR8Dbkspm8Cf4/n30vl6Nefhp4ES+MNCCEsI8cM891r6i8AfGhvQhBAiHOux1E9x3l8APiOE+LxQwp5//FUKNzYW/kXgPxdCrAEIIW4KIf6lVznfDF8BfpsQIhBKWPT3n/N8Go1Go9FoNBrNtUUbMC6fELWY3wEYZxz47GkOlFI+AH4e+BNCCEcI8f0oHYsJfwv4jUKIHxRC2MAfQWkB/LMLLP9fA36dEOJ3jBeSy0KIz4/fqwP7UspECPErgP/VzHE7QAXcu8CyaN4QpJQZ8NtQC/gu8HuAvwekUsqfR+lP/N+BDvAepxTplFJ+C/iTwE+gQrl+6vgjjuWPjq/9M0KI/vicZ9GyOIz/HMhQnlI/imp/Go1Go9FoNBrNG4l4MaRcMw+EEB8Cf0BK+RPjv/8U8K+hFvT/b1QGgf9KSvlfjjN6/AEp5ffPHC+Bj0kp3xNC3EMtZL6A2pX+JkoY8/eMP/tbgT+FChv5CvCvj8X9DivHXwXek1L+8fHffwD4nVLKX3fC9/nVKH2NTwE94N+TUv6oEOK3A/8ZKkvEPwU+PFC2Pzn+3jbwQ1LKnznrvdRoJgghfhb4c1LK/9dVl0Wj0Wg0Go1Go9HMH23A0Gg01wIhxK9BGex2UWKyfw64J6V8cqUF02g0Go1Go9FoNJeCDiHRaDTXhU+gNCt6qPCo334djBdCiH9XCDE85OcfXHXZNBqNRqPRaDSa64T2wNC8hBDidwN//pC3HkgpP3PZ5dFoNBqNRqPRaDQajUYbMDQajUaj0Wg0Go1Go9EsPDqERKPRaDQajUaj0Wg0Gs3CY111AU7DysqKfOutt666GBrNlC996Uu7UsrVqy7HedFtS7NovC5tS6PRaDQajUZz8VwLA8Zbb73Fz//8z191MTSaKUKIB1ddhotAty3NovG6tC2NRqPRaDQazcWjQ0g0Go1Go9FoNBqNRqPRLDzagKHRaDQajUaj0Wg0Go1m4dEGDI1Go9FoNBqNRqPRaDQLjzZgaDQajUaj0Wg0Go1Go1l45iriKYT4EBgAJVBIKb9bCNEG/ibwFvAh8DuklJ15lkOj0Wg0Go1Go9FoNBrN9eYyspD8C1LK3Zm/fwT4R1LK/1gI8SPjv//oJZTjlUjykr1hSlpUuJbBcs3Fs80LP+YiytKNMt7fGTBMCmqexf3VOq3AufCyneY6Jx1zsxVQVvLYcszj3h98P3QtRmnxwueBuTw/jeZVmK2zAEjVbqK8IHBsGp51aD3f6kRsD1KklKw3fTZbPp5tTs/XTwq2+zG7g5RCSnzb5E47YLXuvdQOJtdFiBfaxGHXaYfOS21qUrZ59Y0ajUaj0Wg0mjeDqwgh+WHgR8e//yjwW66gDKciyUsedyIqCYFjUkl43IlI8vJCj7mIsnSjjC8/2KcsYSlwKEv48oN9ulF2oWU7zXVOOiZOK/7RN57SibIjyzGPe3/w/Sgr+fKDfeKsnH7+g+0B7+8ML/z5aTSvwmydNQRsdSM+3IvYHiSUJfSilCgrX6rnH2wP2OolOJaBa5lsdSPe3xnSjTIed6LpMV9/3GV3mDKIMp71Un75yYBulL3QDibX3eolGIJpm5h8bvY6H+4M+JkP9l5oU5Oyzatv1Gg0Go1Go9G8OczbgCGBfyjE/5+9f4+NbNsT+77vWvu968Uim+z36XNP3+eMpJk7cy3FUWAIUuTIiWM5QSQ4iI1JLESAkQAJEiBWgiQGAgRxgMCI/3AAT16YxBGigWNBgoEgEBTIgSNn5BldjUZzH3Nvn3vO6W42m2yy3vu59l75Y1dVF6vJbjYP2U12/z4X557TbFbVLtZeG1y//Xuo31NK/dX5125aa58BzP+9c8nHcG6H0xzfdfBdjVIK39X4rsPhNL/Qx1zEsTw6mNAKPOLARWtNHLi0Ao9HB5MLPbazvM6bHlNUNd3Q59koPfU4LuNnv/73s9zQCjxmhVl+/6ysSHJz4Z+fEOexes4Ok5KW72FqS2Zq4sAlcJsMovXzfFZWtAK3eazn0PI9ktzw6GCC7zrMcsP+JKPfClFKYZWm3/KosTwbZcfWweJ1W4HLKC2Xa+LRweSV1yktmKo+tqYWx3ZZ10YhhBBCCPHxuOwAxp+21v4a8M8B/x2l1D9z1gcqpf6qUup3lVK/e3BwcHlH+Bq5qfEcdexrnqNeplRf0GMu4limmSH0jn+coaeZZuZCj+0sr/OmxxRVTStoNlGnHcdl/OzX/76oakJPH3vOurbU1r7V6143V2FtibNZPWeLqsZ1FFVdU9fNOeo6iqKqXznP69ri6pfnuusoamuZZgZv/pjCVPiexlpLXdc4WoGFaW6OrYPF67r65Wt4jmKamVdep64tWnFsvSyO7bKujUIIIYQQ4uNxqQEMa+3u/N/7wN8E/iTwXCl1G2D+7/1THvub1tofWGt/sL29fZmHearA1ZTV8c1sWVkC9/Qf23kecxHH0g5dsvL4RiAra9qhe+bnOIuzvM6bHuM7mlne3Lk97Tgu42e//ve+o8nK+thzaq3QSp36HB+Cq7C2xNmsnrO+ozGVxdEaPQ8amMriO/qV81xrhalfnuumsmilaIcu5fwxvutQlDVKKbTWVLUFBe3APbYOFq9r6pevUVaWdui+8jpaK2rLsfWyOLbLujYKIYQQQoiPx6X95qiUaimlOov/Bv5Z4J8Afxv4jfm3/Qbwty7rGL6urXZAYSoKU2OtpTDNXctFg7uLesxFHMvD7Q6zvCTJDXVdk+SGWV7ycLvz2ueYpAW5qfn8YHqmevSzvM6bHuM7mnFWcLsXnfozuoyf/frfNw08S1q+u/z+lucQB+6Ff35CnMfqObsRe8yKElcrQleT5IbcGFqB+8p53vKaDKfCVBRlxawoiYOm4W5hmuDhTidkMMuw1qJszcE4Z5SUVHVNkhlcRx973Vlu6EXeck083O688jqeAtfRx9bU4tgu69oohBBCCCE+Hsqupctf2BMr9RlN1gU0007+urX2f6mU2gJ+G/gE+Ar4S9bao9c91w9+8AP7u7/7u5dynG9ynaaQ7I1S/tHjAcOkZCP2+NX7fW71olOfA2tJTU039PAcRVlZClNxtx+/9nhlCgkopX7PWvuD1x7MNfA+15Y4m3cxhSQpK7LS8Mlmi51OSDv0KE1F6K9kVr3FFJKjWcHzeY+bnU7Anfk15Sxr+kNZW0IIIYQQ4uJdWgDjIskm680WHf591zlzMGIxEcBfSeEuTI1WcLcfv6tDP7f3OZLxQ9lkydq63i5qDVzkteA816JVH8raEkIIIYQQF0+Kjz8Q5+nwf52b6slIRvGxu8g1cJHXApk2IoQQQgghLosEMD4Q59mAXOemerJJEh+7i1wDF3ktuM6BUSGEEEIIcbVd/Z2qOJPzbECuc1M92SSJj91FroGLvBZc58CoEEIIIYS42uQ3yg/EeTYgoedwtx+jFSRFtax3f1d9JL4O2SSJj91FroGLvBZc58CoEEIIIYS42tw3f4u4DhYbkMNpTlJUBK4+0wZk8bjrZqsd8HSQALzSKFCIj8FFr4GLuhac91okhBBCCCHEm0gA4wNyXYMR5yGbJPGxu8pr4GO6FgkhhBBCiHdHAhjiwr2r8aaySRIfo/c5PlgIIYQQQoj3SRoGiAsl402FuDyyvoQQQgghxMdMAhjiQsl4UyEuj6wvIYQQQgjxMZMSkvfkQ00Dz01N7B9/H56jSAq5QyzE13VV1teHev0SQgghhBBXm2RgvAcfchq4jDcV4vJchfX1IV+/hBBCCCHE1Sa7yvfgQ04D32oHFKaiMDXWWgpTU5iKrXbwvg9NiGvvKqyvD/n6JYQQQgghrjYpIVnzLlKjr0oa+GW4yqMdhbjuLmt9vc1170O+fgkhhBBCiKtNAhgrFqnRvusQ+w5lZXk6SC58A75IA/ddtfzah1RmIeNNhbg8F72+3va696Ffv4QQQgghxNUlAYwVq6nRwPIX9MNpfqEbhq12wKODKUluqK1FK0UcuDzcbl/YawghxFm87XVvqx3wdJAATeZFWVkKUy2/Vxp8CiGEEEKIyyK3zFbkpsZz1LGveY4iN/WFv5ayFhYvpeZ/FkKId+xtr3uLDBCtICkqtGKZrSENPoUQQgghxGWSDIwV7yo1+nCa04l8tjovn7cw9YVnegghxJuc57p3WhnLu8piE0IIIYQQHyfJwFjxrjr8v8tMDyGEeJ2LvO7JtU0IIYQQQlwmycBY8a4maJw300Nqy4UQcLHXgou87kmDTyGEEEIIcZkkgLHmXUzQeFMTvJO8qwkpZyGBFCHO5yLWzmVcCy7quneea5sQQgghhBBnJbfF3oPXNcE7zWptuVIK39X4rsPhNH+r115sfj4/mJ6ruZ406RPifC5q7VzUteA83nT9OM+1TQghhBBCiLOSDIz35G3veOamJvaPbwI8R5EUZ9/8XMSdW2nSJ8T5XNTauYhrwXmc9frxLrLYhBBCCCHEx0kCGOfwPkooLqK2/CI2UO9r8yTEdXdRaydwNdPMMCvM8hrU8l0i/3KvQRK8FEIIIYQQ75uUkLyl91VCcRGTAi5iQsAikLLqrA1Iv07pihDX3XnXzrpW4PL4aEZe1oSuJi9rHh/NaAVvH49+m3UpE0aEEEIIIcT7JgGMt/S+6s8vorb8IjZQ5wmkSN8MIS5uXOksN9zbbOG7mszU+K7m3maLWW7e6nnedl1eVABGCCGEEEKI85ISkrf0Pksovm5t+UVMCDjPyMWLSj2X6SfiOruocaW5qemELt3IW37NWvvW16C3XZenXT8WX5d1KYQQQgghLpvcOntL1/ku5EVNCFg8z2fb7TM9/iJSzyWLQ3wI3nbtnOSirkFvuy5Pun5stQMOp7msSyGEEEII8U5IBsZbuogshvfpfUwIuCoNSIX4EFzUNeg863L9+rGYSiLrUgghhBBCvAtXP23girmoLIaPyVVpQHoSaS4q3rWve85d1DXoKq9LIYQQQgghTiIZGOfwPrIYrrOLqP2/iCyOdYuNpO86xL5DWVmeDhIJSIlLc1Hn3EVcg67quhRCCCGEEOI0EsAQx1xWo8yr0IB0nZSliHftXZ1zZ13HV3FdCiGEEEIIcRq5TSaWrnKjzMso3ZH0d/GuvYtz7l2uYympE0IIIYQQ75JkYIilq56RcNGlO5L+Lt61d3HOvet1LCV1QgghhBDiXZGdmlj62DISLqKJoRBv412ccx/bOhZCCCGEEB+PSw9gKKUcpdQPlVL/4fzPm0qpv6OU+tn83/3LPgZxNou7w6s+5IwESX8X79q7OOc+tnUshBBCCCE+Hu/iN9r/HvDjlT//NeDvWmu/Bfzd+Z/FFfAxZiQsNpSfbbcleCHeics+5z7GdSyEEEIIIT4OlxrAUErdA/5LwP9h5ct/Efit+X//FvAvXuYxiLM77e4wNE0APz+YXpmmnkJ8KBZNNy9qfUlmkRBCCCGE+FBddhPP/y3wPwI6K1+7aa19BmCtfaaU2rnkYxBvYb0h32Jz5bsOse9QVpang0Q2REJcgMtaX9JYUwghhBBCfIguLQNDKfXPA/vW2t875+P/qlLqd5VSv3twcHDBRyfOanWigVIK39X4rsPhNH/fhybOSdbW1SHrSwghhBBCiLO7zBKSPw38C0qpL4D/O/BnlVL/HvBcKXUbYP7v/ZMebK39TWvtD6y1P9je3r7EwxSvIxMNPjyytq4OWV9CCCGEEEKc3aUFMKy1/2Nr7T1r7afAvwT8v621/zLwt4HfmH/bbwB/67KOQXx9MtFAiMsj60sIIYQQQoizu+weGCf5N4HfVkr9FeAr4C+9h2MQp8jKisNpTm5qAlfTCtxlOrvnKMrKUphK6uvFR2l9fWy1g6/Vq2KrHfB0kACyvoQQQgghhHiTd3Kbz1r796y1//z8vw+ttX/OWvut+b+P3sUxiDdbNBSsLcS+Q22bGv2tdiATDcRH76T18XWnhsjEECGEEEIIIc7ufWRgiCtqtaEggO82tfmz3MgdYfHRO219HE7zr7U+ZGKIEEIIIYQQZyMBjCvqolPVzyI3NbF//DU8R5EU57/DLMSH4iLWx/tY10IIIYQQQnwopFPcFXQZqepnIQ0FhTjd110f72tdCyGEEEII8aH46Hemi03F5wfTK7OZWE1VV0rhuxrfdZbNNC/LVjugMBWFqbHWUpiawlRstYNLfV0hroOvuz4uY11fxeuXEEIIIYQQl+WjLiFZ/PLvuw6x71BWlqeD5L030XtfpRyLWvzDaU5SVASuvrSfxWWl0kuKvrgsoeew1Q54dDBhmhnaocvD7c6Zz6+LXtfr169JZvjyyyP6sU838uTcF0IIIYQQH5yPOoBxWU35vq7A1Uwzw6wwL8eZ+i6Rf/mbkXfRUPCyAkdXNSAlPgyL4NhOJ+LuRjPy9HCaE3rOmc6vRQnK4joDr5agvE0AbvX6lZUVR7McV2tyU1FbT859IYQQQgjxwfmoS0hyU+M56tjXPEeRm/o9HVGjFbg8PpqRlzWhq8nLmsdHM1rBhxFvuqwSmfdVeiM+Dl/3/HpTCcrb9shYvX4NZgW+4xD5DkVl5dwXQgghhBAfpI86gHFVm1bOcsO9zVZzZ9XU+K7m3maLWW7e63F9Hau1+l8dzqjq40GiiwgcXdWAlPgwfN3za5HdpBUkRYVWHMuQeNsAyer1q6hqXEdh6pfXr/Vjk34ZQgghhBDiuvswbumf01Y74OkgAZpf9svKUpjqvZaPQLNR6oQu3chbfs1a+9a18lelH8R6aYfrap4MEu5vtpbHcxGBo7Ok6AtxXhdxfr2uROtte2Qcu35pRVpUWOBWL3zl2FbXoFawO0z52fMJn2zG3JEyEyGEEEIIcU181AGMk5ry3d2I3/um/yI2ShfZD+LrBkLWe43sdEIeHyXsjzPub8YXFji6qgEp8WG47PPrdev+tDW4aLob+i7ZLGe7ExK4elmesji2xRpMS8PP9iZYwNWKZ6MMO39vs9y892CnEEIIIYQQr/NR35pebcr3nVtdeqHPj3dHJEV1phr0y3IR40wvqh/E29bln2Q99T70HLbbPnvDlJ/ujdmfpBeyYXpTir4QX8dln1+nrftW4J66BhfH9L3bXb7/YJPId048ttzUVHXNz/YmOFrTDlxcrdmfZKRlxY92Ryc+v5SdCCGEEEKIq+SjzsBYzwyYFYZW4DHLDd3Ie29TSS5inOlFjWy8iEkt63eWs7LiYJpzqx9xvx+/9TSH13kXU1TEx+syz6/T1v1Z1+Drji1wNbvDFCyEXhPURFlavsfuIKUVuq88/+4wxVorU32EEEIIIcSV8VEFMNbTsMdpSb/lL/8+NzWh1zTOXDjPpv8ifN2N0kX1g7iIQEhTpjMlyQ21tRzOcgLX4f5ma54dcjXG1wrxvp207r/OGhwmBY8OJhxNC748TNiIPYLaASxlZdnu+HzxYsZ253h2l+conhyly2bCcHXGTAshhBBCiI/XR1NCclIpxCApmGYvJ3s0teY1vvPyx3Jdm0BeRBkKXNyklqI0HExzdocp+8McWx9/TpkWIsTJzrIGTyr1GCYFP/zyiKqCm92QzZbP83HG3jiltrDd8alr8B1NO/ReeX6llEz1EUIIIYQQV8pHk4FxUhr2difkYJIReA6eo2j5LnvDCe3Q44sXU7RWtDyHz3Y67/no3955y1DWs1Ragbvsm7FoXDjOSiJX8/nB9EwN/3YHCbOi5nYvwtWK3VHKJKvYG6V8eqMNnBwUuSpTVIR4kzedq4u/H2eGpCiJvWbK0Enn9FnW4GqDztMa9h6MM1qBRxw0l/kHN1qARWvNTscnySuUgj/52Raz3FDMe9Usnn+nE8hUHyGEEEIIcaV80L+Jrt6V/OpwRlUfv3PYCV02WsGxpnw7vWgZ5MCCVeqEZ74eFkGMz7bbZw5erGepHE5zttovf0ZlVaOsxZtvls7S1HN/khP7Dp7T1N7faAdoDXuj7NTskItoHirEu/Cmc3Xx90lRMUpyqgpGaUlaVK+c08Ok4B9+ecQXhzNGSUFSVK+swfUGnac17N0dZYTey0t8U7YVU1U13cjnwY0W33+wya1edGJz0jv9+EKyuIQQQgghhLgoH2wGxvpdSdfVPBkk3N9sLX/xLytLN3SXdzKfDhJurGRpABSmfmPN94eSKXBas8BZbo79jDzHf6u6eGstrGTAB67DTifgxWuyQy6ieagQ78KbztXF3x9OcwLXxXM1ZVUzKwybrWD5fVlZ8ePdEa7WRL6DqSxHs5zNVnBsDa7LTY1W8GyYU1RNCdxG7OFpRVbWxMHL65m1ik+3W3y23T72HKf13Pm6zYSFEEIIIYS4SB9sBsb6XcmdTggo9sen3/VfH/cJb675/pAyBc7y/s/zM7rZi0hKQzm/k1uamspafvnuxqnZIed5HSHehzedq4u/L6oad/59rlbLry++73CaYy1EvtP0n3A1vuMwzco3nvdPBknzWM/B2ubP92/EzPKyaZ5b1yS5YZaXPNw+e0nc22ZxCSGEEEIIcZk+2ADG+qYi9Bzu9SOq2p6Yhg3na1h5Wvr2omb9OjnL+z/Pz+jORkS/FWDqmqQwmLqm3wq4sxF9rWMR4ip407m6nAjkaMz8+0xtl19ffF9uauLAwaw0uHUdRVJWrz/vrQUULC53qvm/buDx/QebOE7TsNhx4PsPNtmI/dOfSwghhBBCiCvsgy0hOWmMqKM19zfjU1Oxt9oBTwcJcHKzvJNcxJjRq+Is7/8s33NSSc3D7fZbldmc57MQ4n1407m6+PumGWdGWWlqa+mELk+OZmy0AhgkYC3twONwVgBNlkZaVKj5c5xKKe71o6avxjzYca8fUVvYiH1+/cHWZf8IhBBCCCGEeCc+2NvZ5xkjukiXPq1Z3kk+pEyBs7z/N33PaSU1wFulop/nsxDifXjTubr4+9h36MUBjgOhpxmlJTc6If3Yo7aQLq5RLR+FZZKWVHXNL93pvfEa5GjNrV7Eg60Wt3oRjtbX8hokhBBCCCHE63ywGRgnjRHdagdvzAI4rZndaT60TIGzvP/Xfc95m2+e1gj1on+OH0rDVXG1vOlcXfz93fmfF0G+1XXSDT3KqjkvtVZsd04fx7p6/n6da9Dr1oOsFSGEEEIIcdVc2wDGWX65Xt1UrE8lKSvL00Hyte/qnxQouYhMgcvaPFz2puQ8JTVn/Wy+7rFf1jkgPg4XuXZOWydlxSuBh8XrjjPDcJaz3Qlph+6x83f1GoS1KKXYHabNE1gLSp0YoDhtPQCyVoQQQgghxJVzLXOMzzP54zKbbV5Ep/7Fe/r8YMrn+xMeHUwvfLLJRU1MWT3W9cdfViPUizj2D6nhqni3Lnra0Oo6ycqKZ8OURwdTBkl+7DlXXzcrDKa2/PT5mJ/vTzmaNVNLDqf58hp0ZyPCAp6j0Qp2hwm7owyteOWYX7ceZK0IIYQQQoir6FoGMM7zy/VVHsu5vjk6TAoGs5x6fif1tPf3ukDCSS5iU/Kmjdx5eo+c5bO5iGO/yueAuNrOc/69bn0u1sk4LXk2TChMjaMUvdA/Ncgwyw2TzOBoTWFqagsvpjnjtDzxOIdJScv3aAUuo7R85Zhftx5krQghhBBCiKvoWgYwzvPLdeBqpplhb5Ty5eGMvVHKNDNXotHd+ubIWog9l8F8GgG8+v7Oc0c4NzVVXR/7GVR1/Vabkjdt5C6rEepFbKg+pIar4t162/PvdeszKyt2BwlPjhL+/qMDngxSUJbbGxGdyDs1yJCaCq0UoaspqnqeZaFISnPicRZVjesoXP3yOFeP+XXrQdaKEEIIIYS4iq7lb6Pn+eW6Fbg8PpqRlzWhq8nLmsdHM1rB+28Dsr45ClwNqtmALKy/v3NlJFjLk0FKbSHymk3Vk0Ha1Mif81gBqrrm8dHLO83wdhNHzpK1cREbqvNkhwgBb3/+nbY+d4cpn+9P2B1ldCKPzdjHczRZ+XKtnxZkiDyX2tZkZY3vaEpTU9ua2PeOvfbjo4QvD2eM0oJZ3pSdLI5z9Zhftx5krQghhBBCiKvoWgYwzvPL9Sw33Nts4buazNT4rubeZotZbk59zLuyvjnaiH2SokLBqe/vXBkJSgEWFi9loTAV+5P8zGUo68ealRVPBimOVufuDXCWrI2TPvNxVpKX1ZmPXUazivN622vOaevz+ShlVla0AhffdWgFHoHrkJYVw6TJuCorC7ZpmjlOSx4fzRinJS3foR16mLqeB0Zgqx3SDZsgbFZWZIUhNzWuVrR8l5/vT/jZ8wnjtOSrwxnjrFwe8+vWg6wVIYQQQghxFb3/9INzOM/kj6tc070+BlErxWbsEfruqe9vEUhYjCmFs2Uk3OvHDJOStKyw1uJoRWXtmScNrB/r/iQDLDvdcH6n+WxjU9eddQzlctICoKzFc53l6MizTEm4jNGs4mq6yKkhb3vNOW19KqWoa4s7/3ov9ng+SqkLS1Y2AZJJWmCVwnMd+q0mQ+NgkhH5Lp5WfPdWdzmFZDWIcjjN6UQ+rdBjmBTU1hK4Cs/VzbhW1ayZk97X696zEEIIIYQQV8W1DGDA+X65fjJIaPkekedgKsuTQcKdjcv/Bf2kjRTwytdmuVluju70Y2a5eaXvxeIxWEtqarqht9zAF6Z67c8kcDW1hdsbEQB7oxSFWklzf3PwYX0jZ0zNvbWN3JvGpp7X6mf+dJDgOX6zMYNzB07Eh+kyRua+7pozTAoeHUyYZoZ26HJ3IyabZ3dVdc3BJGeWG3xPQwWmtniOInAd+q2gmT5SVOxPUqZZRew7tAMXpTSdyCPwHLSCrXb31CDKYjSrUppbvQhr4eF2F2MtD7ZaABSmljUihBBCCCGurWsbwHhr1tLcgpz/Wc3/7y36P5zHSRupz/cnWKXoht7ya4tNReg5Z35MVlaUVU1ZcaYslPXsiVlm0Br6rXD5PWcJPqxu5BZBkVXvotnfYrO26rICJ+L6We1BAZcb4BomBT/88ohW4NGPfbKy5se7I753p0dSVHx1OKMVunx6o7Vcy5mp2Ih9sE2A43YvJnAUncjHVAmOUuyNUm71IkLPWZ7brwuirGd9FFVTShI4L9eirBEhhBBCCHGdfTwBDKW4148YpU35ROBq7vWjVzbfF+2kjdSsrMDCjXkmxvrm6qyP6UT+sjb9JCdlfhxLg/c13dA/FvQ4T2PM1aDIWTJBzmv1/QySnKRoMmmKqmlq2ArcV4Ia4uN0kQGuN5WiPDqY0Ao84nlD4Dho1s/TYcKtbsTDnc5yLUfA3c2Yzw+mDGYFvqv55s0OgaPx5ms+nDfY9ZXDYFZweyM607p8ZS2aiqfTgu12AKRsxD5aKZkkIoQQQgghrq2P5jfZwNU4ukmtfrDV4lYvwtH6nWQKrPfeqGtLvZb5sdqP4zyPWXfaGEd4OSHkl+9soBVvbEy4eK6TmmW+q2Z/6+8ndB1+//GAcVY2YyVNzZMrMlVGvH8XNQb0LOOKp5kh9I4/b+g1Y5vX13JWVkwzw1Y74E9/a5tf/WQT39HLEcfPhimTzDSvYQz5vHHoWSaArK7FQVJSVJZe6BJ7DlVteXyUMEkLmSQihBBCCCGurY8mgPG+xgKetJHSumnUuWp1c3Wex6w7y5jVk4IPW+2Aw+nLqSTDpHjjBm7xPGcdm3oe6+/H1JYHm23ysiYzNYGnuX9FpsqI9++i1vtZ1lE7dI+NQQXIypp26L6ylodJgVbNhJDV5xulJU8GCdZCL/K40Q54PsrIyrcLCoaew1Y7IClKAkfTCl3Kul6OUg19VyaJCCGEEEKIa+ujCWC8r7GAJ22kWp5DHLinbq7O85h1Z526shp8WAQvVoMVP9odYS2v3cCdx+uyOs7yfnJT041cerG3zKhph+6VmCoj3r+LWu9nWUcPtzvM8pIkN9R1TZIbZnnJw+3OK2t5lhlqW9Nv+cefr6xY7dETeA43OiH3+/FbHfcwKfiHXx7xi4MpSWHmLX4UN7sh9zelcacQQgghhLje3phvr5T6X1tr//U3fe2Ex4XA/wcI5q/z71tr/w2l1CbwN4BPgS+Av2ytHZzv8N/ORY0FXJ848HC70zTke81rrk4O+GynA3DqNIHzPGbdecasntR7wwLTvKQTecvvq+qap6Ps1J4Ab+oZcJ4JEevvJ3A1WVkvj/Us7+9Dd961+qG6iPV+lnW0Eft8/8Emjw4mDJKCdujy/Qeby2vCmfrOeA63euErPXrSolkr48yQFCWx59KNvOWaOjaZCPjqxYw4cNlsBRTGMpgV9Fs+w6RgsxWcuD4uctysEEIIIYQQl+ksu70/f8LX/rkzPC4H/qy19leAXwX+glLqPwP8NeDvWmu/Bfzd+Z+vjcXEgaqCfuxTVfDDL48YJsWpjzmpxOJNZRfnecyq86TQn3S3OfYckvxldkRWVjwZpDhanVhSkpUVjw6m7A5TDiYZu8OURwfTYxkWZ0nLf9P7afkus7ykFbjvtCToijvvWhWneNM6WgTjjmYFt7oRf+qzG/z6g61jAc3VdXta35mdTvBKjx5TWQZJQVJUjJKcqqIJcMyDGuvlXYfTnINpjtbQi32auUuKaVoyy8xr+9u8rkRMCCGEEEKIq+LUAIZS6l9TSv0B8B2l1D9e+ecXwD9+0xPbxnT+R2/+jwX+IvBb86//FvAvfp038K6tThzQWhMHLq3A49HB5H0f2jGLWvj9ScpP98bsT9I33lk9qfdGO/RQKxuu/UkGWHa64TL4YC384e6Qzw+m/KOvBjwfpbhaE/surtYMZjm7w3T5nGctb1l/P6slAZHv8P0Hm8S+805Lgq6ir7tWxeleV4py1s3/4vt+/GzMH+4OmWQl+5OUQVIun+9OP34lUHIwydjuhMxyQ+C6xIFL4DnMCoPvOjw6mBwLBFqgG3kczgoC12GnG+C7imFaEPgnZ2ydJ5gohBBCCCHE+/K6EpK/Dvw/gf8Vx7MkJtbao7M8uVLKAX4P+Cbw71hrf0cpddNa+wzAWvtMKbVzvkN/P6aZob9WLhJ6msFKBsZlpWS/zfNmZcXTYUpdN5uwuoanw3SZyXGSk0aiagXfu9NjlhuSosKYmnsrG6GsrHgxzamsJfYd9kYpWil6sY9SGs9VxNbl+Sjls+02cL7yFji5JOC00p2PzNdeq+J0p5WinFRytfj64vuHScGPdkfkZcUsN3RjH9/RtEOXwSxn3qTi1RHHrmajFeA5it1hilJNX4xu6FLaZn1OM8PdjZdryHc03dBlb5xTzkcLtwOP0HP45TsbJ677ixw3K4QQQgghxGU7dcdorR1Za7+w1v7Xgfs05SBfAlop9Y2zPLm1trLW/ipwD/iTSqk/dtYDU0r9VaXU7yqlfvfg4OCsD7t0r5s40Pz35aRkv+3z7g5TBrP8tZkQ606727wR+8sU+E+2Wjj65Wnz6lQFB8/VjJLy5RMrUCsTVN7XRJgP1duu1au6tq6bN2USZWXFj3dHuFpjAddxmOWGoqr44sUMV2tyU5044vhuPyZwNU8GCY5WeLrJdNodZlgsZWVph+6xjKl+y6eylu1ugMIySUuquuaX7vTe2Ftm1cfeS0YIIYQQQlxdZ2ni+W8APwC+A/yfAR/494A/fdYXsdYOlVJ/D/gLwHOl1O159sVtYP+Ux/wm8JsAP/jBD+xJ3/M+PNzu8MMvm5vaodc0kpzlJd9/sAk0d1+thaPZy0yJlu8euyt7Hic9r6MVf7g7pB8Hr2RkPB+lxJ6LN9+InJQJcZI3NT5cz9KYZYayrgGHLw9nWOx8GgNYazG1JSkq7vTCV17jrA1Jxdmcda1e1bV1Fb0u6+mkTKJpZhhlBZ8fwCDJyUzNjbbHUVIQepqqhr1RSsvziXyHtKyWGRy7gwSU4vkoRSlFZiqq2tKLPY6mObrWMA9eFKbi4XZnWerhOc2Y5X4rIHI1KMV2583ZXydlXRWmupBmx0IIIYQQQly0s9xm+68A/wIwA7DW7gKdNz1IKbWtlNqY/3cE/OeBnwB/G/iN+bf9BvC33vqo36PFxAHHgUFS4DgcmzgwTktezEeRRl6TKfFimjNOyzc88+utP29aVvz02ZhJYk7MyFDq5UjGpbVMiPN4JUtDK6qqxnMcIs9hsxWQFzVVVZMUBlPXbMYed9Y2RG/TkFSc2bnWqjjZm7Ke1jOJJmnJ46MZ3dAn9p0muJmZec8KTWXB0TDJDFHgYOqXmQ5VXfPz/Sm7w4RgXpbyYpxja4tSTW8LRyv6sY/D8cyo1Yyph9ttPtvpnHldva/x0kIIIYQQQpzHGzMwgMJaa5VSFkAp1Trjc98GfmveB0MDv22t/Q+VUv8J8NtKqb8CfAX8pfMc+GU5S5+Jjdjn1x9snfj4pDRopfCceeaDoyhNTVKar/W668+b5BW+62CsnZduHK+/3+kE7I4ylFK4Wp2YCXHW97vuWJaGtezWdhksCT2HW/2IyHfY7oRfqwfIWcaxyvjHY867VsUJ3tTjYj2TaJQV3Nts0Y08srIiySuSouJnzyc82IyZFk1GhecofEdTmJpb8/V4MM0xtqblh8usqU7skRtLx0In9ICScWpoB01G1+J832oHy3Ww+vWzro+LGi8thBBCCCHEZTtLAOO3lVL/LrChlPpvA/8q8L9/04Ostf8Y+P4JXz8E/tzbHui7sLjj6rsOse9QVpang+St7kjGvscoySlNjesoTGWpbU3HP72/w1led/15k8KgVVPGsrDafO9OPyYrK2ZlRWEsWqtXMiHO+35XN0bPxxnbbZ/M1KRlUw5ybyNikHy9jJM3HdtFfFYfoHOtVXGyszS4XN38f37QZGqMkoI/ej6lqCpy0wQex6nBcxVVZfnOrR51bdlq+QRuE8iYZYZO4OGu9NTYavk82p+SFIZ7mxFH0xxTQytwlqNUt9oBu4OEWVlR1806HyUFd+aBFVkfQgghhBDiQ/LGAIa19n+jlPrzwJimtv5/bq39O5d+ZO/BWaYKvEk3dHG1Ypabpr7d0Wy1w1c2Qm/7uuvPG3ia0HXmd2Ybq/X3gau504+Z5ebUO7Dneb/rgQPX1RxMc+5vtpaBhcdHCYGrX7txetPd4Tcd20V8Vh+aj2mtvgtvOy0ncDXTzPCz/Qmuo2kHPlopJllBK3TpRu5yGsji/F/0gPlkq8XhNMdUFm/+eo7WRK6D6ykeHyYczAoCR5NXTenWp1ttfvRsRF1DK3Bx3SbT6igpGacj7m62ZH0IIYQQQogPylkyMJhvgq7dRuhtSwwuYqTgVjsgm98ZXW2K97oJG2d53fXnnWQ+T45mtHwXay3TzPD4aMa9zdYycLCa6n5R73c9cLDTCXl8lLA/zri/GbM/yQDLTjc8sbQFzpb5kZsarWBv9PLzC13N0axoMj9GKbc3IlbbuMj4x+u7Vq+i1zW4POnastUO+OGXR5RlTdxyqeomqHHrZpfQ1XQjf3l+r5d+ADiOYpaXxNaFeU+K0He4tRHw918cshV7+POMjT98MmanHfBskHKnHzGYFRTz0amRr9kdZny61qxX1ocQQgghhLju3tjEUyk1UUqN1/55rJT6m0qpz97FQZ7HecaZXsRIwfM0xTvL664/b+w7fP/BJpHvvFJ/3wQONL7rLKcUXNT7XR8dGXoO9/oR1bzHhjE199be7+poSTgeBDn1WK3lySA91rT0958MqWCZ+fFk7fP82Mc/Xte1elWdtpaBE68tAButgDhsxqUqBTvdkJbvkuTVsXNz/frkOZrAddhqBeTzxqB3eiHfvNnhyVFGJ3RxHQetNa6j6UYuj17MUMDBOMNaCN1m1GrzZyvjUYUQQgghxAfnLBkY/xawC/x1mlaN/xJwC/gp8H8C/sxlHdzXcZ4Sg4saKfi2TfHO+rrrz5uVFbO8aQ5alDVe6/iEkZPuuK7eOQbICkMn8s/8fk9Kq3e05v5mzN1+TOBq6rXBnOsbp5OyK3qRR7n6OKUAC/OvjZISV2s8R6GUeiXzYzXT5ekg+Vgbe17LtXqVnbSWP9+fcJQUWNush43YXwbguqHLN250OJrl+I6D6yjSokIpjmVhrV6fsrJimBTMMkPga77/YHN5zmZlxe98ftiMUp0VJFlFUVf0o4Bng4SN2Gd3mLHZsWyEHo6jMTVszyekgIxHFUIIIYQQH46z3I77C9baf9daO7HWjq21vwn8F621fwPoX/Lxndt6pgC8mgmw7n2NFDzP667fwT1LRsJJd32tUpSmOvPrro+OLEx9rETmTX8PvJJdUVt4MkjBHo983OvHKAVp2UxvuL8ZoebjTtYzP/R8g3g4HzV71qybD8y1XKvXSVZWfHWU4Ci1PHf3RhlVXZObmq12gFaw2QoAyzgrMXXN9+70jq2rxfUpKyv2Rhm1hXbokpX1sXM29By+sRVjjCU3NUrDRhyQG0NqatqBy81eQGkqng4TksKw1fbZ7oYyHlUIIYQQQnxwzpKBUSul/jLw78///F9b+Tt7wvdfCW/bgG/hpCyH9Tv6wIWP73zbrI039aI46Y7rYnN/OM2X9fKtwCV4i9deHx0ZuPrYxuhNfw+8kl3R/NvOv95YZHI0fS5Yjp0MVqaurGZ+AMu+Gh9x48JruVavk8NpTitwUTSZQIsg6cE0504vOnb+O1qx85rrw+OjhP1JjqsVNzoBWVmTFIa9ccYwLZYNP797p8fTQcqtbkQ7cMhN0zPme7dazRrpxSTzbKzIc7i7EaO1khHDQgghhBDig3OWAMZ/A/i3gf8dzSbo/wf8y0qpCPjvXuKxfS0XUQ5yUrPJRwdTlLV0Iv+9jidcb8C5yEjYG2WnBg7GmWGU5ASuS+Q5mMpyOM0wccDdt3jtNwVbzhKMudePGSblclLLvX58rPRk/fNrBS6D2YzNVmtZ37/+eV5EE1Z4++avV8i1XKvXSW5qtjsBz8cZAK6jsLVllhm27jbBzTed/1lZkRXNdCA7H336xcGEsoZPt5omvNPMLK8rG7HPw1sd9kcZo8zQ8l2+caPFjU7AOCtRCvqRz42WzzQz5FWNMhbPefUaBRcffBVCCCGEEOJdeW0AQynlAP+atfa/fMq3/McXf0gX40yZAG9wUh+NJDeUpqas7XIT0PLdr32X/203zW/qRXGSpCgpKktSvJxY4DqKpCjPfdznsZ5dAVCYGm+l4mcxpeHRwYRpZmiHLt+701uWjJz0eZ4362bVWSakXEXXea1eJ4tz91avmfyRlhUK+GSr9caSr8X6HiQ5vdDn/qZHVlakZcUsr7HKMkxLRmnJRstb9tW424/ZbgdstYLltejZMCUrazqhx0bsM5gVTHJD6GsiV+OtXLdqW3OUFDw5SvBczXYnpBO6EtgQQgghhBDXzmsDGNbaSin16+/qYC7a25ZlrDvpjn5WGA6mBd8I2k0WQ215Mc3pRR53z9ll4Dyb5vNkmDhaczCe0Qo8ArfpBzKYlXRvds534Od0lmNfbPh2OhF3N5rvmeXmjT+TRwdTktxQW4tWCtfR9EKXzw+mTbApcJnl5tSN2nmav14F132tXheLc7e2zDOBahSw2fJPfczq+tYKfrE/ZZQaNtsB2x0fsOwZQ+g6OAqysqYoa6q6Xja2fV1G0uI87hiXu/2Y3WG6LG1Z9NjwHMUkN+z4YdNg1NXL8353mGKtvXZBOyGEEEII8fE5y63pHyql/rZS6l9RSv1XF/9c+pFdASeNGZ0UhsBtGmA2NfAarRRJac79OmcaK7rmPI0/q7rmZjfCdzV5ZfFdzc1uRFWf3tj0Mpzl2M/zMwFQ1jLv80lhavZH6bKpZ1pU/PDLo+UY2pOafJ6n+esV8tGu1XdlkRn0YpKRFhUt32GnE3I4zU9tFrs4l2tr+eooYVZU854uhkFS8mJa4CoHqxWO1tzpR7QDj4NJvsweetMY5dU1tHrdGiZFs4bm/4t8B99xGMwKoDm3n4/Sc601IYQQQggh3rWz9MDYBA6BP7vyNQv8B5dyRFfISZkCrtaEvqY0Na6jMJWltjUdP3jDs53uvL0b3jbDJPZcSlPSCn1crTC1JS8rYu8sp8HFetOxn+dncjjN6UQ+W52Xafaeo5kVhk7kMSsMrcBjlhu6kXdidsVFlKG8Rx/tWn2XZrnh3mZrmaUDTbDstCydxbm8N8pJi4obnZBRUlBWitDVHIwNG7HPjW5AJ/RwtaKsama5OTa956Q1sxG/mvmxet3KygpPa8q65kbXx9S2Ge06D7aUlT3WjHThPL1jhBBCCCGEuGxv3Llaa/9b7+JArqKT+mh8c7tNZZtNzKIB5VY7fGWz/Tbe1aa5G3nLDX1aNu/nRjsg+hrHflnO8zNZD3oUVU3oabJ59kRujv8ZXt2oXUTz1/flY16r79LbBtcW53JR1dTW0vIdlPKZ5QZTWzxX0W/7PNhqMUzmfTUUfLJ5vhKO1euWtVBZy61e029mb5RRzo93MeJ4pxNc56CdEEIIIYT4iLwxgKGUCoG/AvwyEC6+bq39Vy/xuM7lMqZHnDZWdasdHNvgrt4pfVvvatO8eJ3N1sUd+2U5z89kPejhO5qsfDl6NXCbP6/eOV/fqF1E89f35Tqt1esscDWTzDDLzbFxxKcFMRfnsqKpbsrKGoXis+02Wim6oYdWoJXiZjdcnut3vsb6X5zHi9fW8yyLrZbPwSSjEwXLshPg2gbthBBCCCHEx+Ust9j+r8At4L8A/EfAPWBymQd1HovAwqLfwUn9DS7CeXpPLI7t84Ppicd0nud8V8f+vpznWLfaAYWpKEyNtXbesLOk5bvNn32XwSxnVhi+eDHlq8MZ46x8JYCzeO3PtttX9udzimuxVq+7VuDy5GhGYWpCV1OYmidHM1rB6fHgwtR8dTjjj55PeHw0JfY0iiaTqx97fO9O71LW5fo6iua9M753u7t8jet0XRBCCCGEEB+3U3/jVkq51loDfNNa+5eUUn/RWvtbSqm/Dvy/3t0hns1J0yPysuIPd4f04+BMEyjO6m16T5x3LOdJ2SSL9/l1jv9Nx36WLJbLyHQ5y7Eufpanve569sSi0eEsN8uN2XYvpKotdd00+1TWnvTS18p1W6vX3Sw33N9sMSsMmWkyfDZbLY6mOUfTnP1JjrWWm72IzZbPL17M+PLFFBT0IpdhUvBPdkd8+1aXhzda3JlfC07qZwFvtybHaUlSGmLfoxu6Z77mfd2JTUIIIYQQQrwLrysh+QfArwHl/M9DpdQfA/aATy/5uN7ael16Vla8mOZU1hL7DtPM8AdPR3QCB3c+OWSYljzcbh/7hf6iN+dnGcu5HuSYZoY/2htzb7NFJ3QpK8vn+xPsPN38tEDI1z32rKxeGUO6/jM6KSDzw8dHHI5ypmXFRuzx3VtdPEdfaIDjrIGg1zU6fDpI2F75LODk5ovvKkBzga7VWr3KzvLZ56amHbp0Im/5teEs5z/9aoCnNb6nKaqaf/xkSG5qtIab3YjS1GilUWhcpcjyZpTq6traHSTHAiCx7/D5wRQLxJ5DO/TITlj3TwcJ1sIoLdFKMUpyqrrmj/bG3N9s0V65joR+c9m/Jue2EEIIIYQQS2cZP/GbSqk+8D8F/jbQBv5nl3pU57De/2CYFGilCD0HpRSHSc4wyRkksBH5OEozyUoiz+Gz7TZw/myJ18lNjVbwbJgv6+U3Yo9pWcM8m2CQ5PRCf7mxPmlaxqyswMKNeSbGeiDkpGN/dDAlcjUodaYsjt1hymCW0/K95YSVwSxnd+VntB6QGSYZv/fFEe3A45PNmEFS8Dd/+IR/5tvb3N2Ilz/DrXbwtbJfTgoEZWsZNm96zrM0X7yMc+AduhZr9arKyorP9yfMyoq6tmit2B+n9OJm3SzOsfVrTVZW/GhvQllZupHDk6OUZ+OMju+wN05BK4azgsjzqGpLHGiMtVS15Ue7I37twSYAn+9P2BvnlFVNaWqeDGYkZc1nN9pEvsPuIOX5ZEA38jgYZ/zqg01Cz1mujaNZTuA1I55LU/NslNIL/eUUntrWHCUlQVFxfzO+bue2EEIIIYQQrw1g7Cil/gfz/15MN/h35v9uXd4hnc36ndJW4HI4zYFmUzrLDFpDv9X0Mtw9yijLGqUVkedgass0Mzw+nJ26OT8pW+I8ngwSWr7XvO48sOCgaN/sEPsOz0Y10ywhShxAcTDJ2en4FNXLaRl1/Wqpw+rme/3Ya1szmOUknsP9frwMaOSmoqrsiRkWz0cpsefizZ/DcxWxdXk+Spc/o/UgwI92x/QCH8/TOLoJlvQjn58/n3Kv31qW8vxod8T9zda5gwInZdgcTjPqGuKNsz3nSZNNJplhnBV8ftD8fW7qSzkHLtmVXqvXxe4g4SgpaQUurquYFYZfHCZstwo2WgFJWfHl/HqR5QZo1uD+JMOYJvtonJYcJQWRq7DANCsZpYZp5LPTqejEAdPMoB1FWdfsDhMCT9OPfI7SkllhiDyHIHQZZQV7w4xe5KESxTg1eI7mYJSyP87ITc2vfNJfro3c1ETzc991FLPccLMTLqfuDJOC2G+ufUqp63JuCyGEEEIIsfS6AIZDcwdXnfB377VxwEmlDnHgcncjWvY7CHxNN/SXm9lpUVLUNdSKvXGG52ocBS+m+bKvwv4441YvZLW36evGI64ez6lp59bSNFuYf7OCcWrY7gbLTbKnFc9HBe3Q43YvxHM0jw5mdIKXqd5lbQmc4z1XVydorG/wB7OC2HMx9uVmZZgUHIwzHmy1T8ywUEq9+mkrmq/PrQcBRmlJy9dMc8OzUcogKdiIXEZpuXzMNC+x8MYymtf1/BgkOVXt052n7Q9mBVppolAf24ztDtNlIGL9s1ifbDLJDJ/vT+iEHgdVhtaKwbTg27c6b30OvGdXdq1eF1lZ8aPdMdCUFfVijySv8F3F54cJv9YK6YYeaVHxi4Mp37vTW15rjKn5ZKvFKDF8dTRDY3G1Zm+cUdbgaBgmTWbFtwKPSV4yTQ2O0gSuglrxzM94OmyuQ6DwXEVWVJRVxaPnU+5txThasT/K2BtnhL7GPKnJq5pvbreX1wJTW7z52m4F7rEpPLmpcZXCd85+bl/DciohhBBCCPEBe10A45m19n/xzo7kLZxW6nC8HCTi6SChMDWeo9BK82Q4pR95lKbG0owK3IyD5eQSRyueDFLub768iz/NDKOVO/Trv8CflHY+Sgo+2+k036cU9/oRo7QkLZuxnDfaPp5e2WsqhauhLJs7paGreTHNCNyYcD76c5aWOC2Pr45my9dpeQ6f7XSAV0c7HowzNts+sf/yIx5Mc1ytT82w2OkE7I4ylFK4WmFqS1JU3OktJ3K+EgTwHMVXhymfbrcIXN38DI8ybm+8fEySV68t3TipbGO950dd+zw+mi37gswKg6PUscaHVV3z8+dj+u3gxM8i9Bxagcs/ejxgmJTkxtCPA3YCd/l+Z2XFk0HKt252ls+7Pmr1Crqya/UqOW0zvjj/TF3T8l1qa9kf55iqZpyWzHLD80mG72q6oYup4GjalGsA+J4mcB0KU5Mbi6ksv3gx4WjWZEW1PJdKWwpjeDrIULom8DwCV9EJPY6ygtnI8HyUcm8jYpob6kyRlgZbW3aHM5S2aKv4apjia4fbvYi8aHpc7HQCfKdikhv2Rxm+p+n6zfccjDM2Wy2stSgFSdk0IF143bm92ltjmpckecVXhzO+d6d3asNRIYQQQgghLtPrdmUn3c29ElZLHZRSeK4m9pqN+ML6aMDQVUSOQ5JbjmYFo6RiMCuJgqZcQCnFTjcELPuTDGstk7Tk8dGMbuifOpp1kXbuak3su7hac5SU7M43+YuMhcWwC2tBa4XWx3+8290Q39OkZUVuar59s8MsM3z+YsooK7jRDciL+uX9dAt2JTNifbSjVfD4KFmmlANUlmXwYmklw+JOP2Yz9jB1TVIYTF2zGXvcWUkvX/+53uvHhL6mqqG2FlcrZqXhRifAWkthapSCdugde9nVjdNq+UuTTaGZlRVJbpZf60Qe9zdbjLOi+Tw9zY21YNLTQUJS1Kd+FsOk4Me7IzbjgF+63aWqYG+YkRWmOY8cza1uwN4oXY5iLUxNYapXRq1eMVd2rV4VrxuzvDj/7vRjMlOhaAKKg1nB48OEzZbfrCkLu8OMtDT88MsBXxzOGCUFCsVPdsckRUXH0zyfZDwfZdxoBWy3fKpaEcUu39rpkFcVdaXotVw222ETtPMc1HztDFKD42i0sozTgspaPt1ukRU1f7g3RivLg+0YV2uiwGEjCvj5wRSrFIGj2e4EaBRpZYl9l+8/2CTyHZKiYiv26bcCtFJnOrcPpznWwuGswNKsQUdrfrQ7uvDx1EIIIYQQQpzF6zIw/tw7O4q3dJZSBzg+keLR8wmt0EGjUMptfoGvDdVKb4nQc7jXj3k2TEmKilFWcG+ztSxbOKn0YX+SE/tN4zxoMgti32F/kvPZTodW4PJHe2NagUfoNdkU07Rkuxcus0MUUNXw7VtNpsDPzJijafM9d3oRprI8HczwXIeNuJlw4Dka39HLY1kf7bjdCZh5TSlHN/IoK0svdKlRlFW9zDh4Ps4oq5r/6KfPaYcuW62A1FQkZUU7dJcjHk/7uQJsxB6/9+URj49K+i2PP//dHbTWTSmPq/nenR6H03z5fsuqyX5ZPMdJzTVP6vnRDl20Vk0PgrUMm7Ky7I1y7vTDUz+LRwcTXEczLQxHSU1aVkSew9Nhynej5o5y4Dhst4NlgCZw9XVocnhl1+pV8br+Novz72Y3JCsr0qKiqmuyyrDR8unMg2/WWsqq5tF+wnYnJCsqnhwlPB2k9Fsela3pRD63eiGRq3EdTVFZtK6wNXiO5v5GRFpWpHkTONmeB/qshQc32oySkllpGExztNZsxD6fbUbsTXIiR9MLPTzd9JVphx4bLZe9UUY39JYNfqEpg9GqmcCzmi2xCNgszu2tdnBqiUhuaqZ5ie/q5ZqKfIdx9urkHiGEEEIIId6FUwMY1tqjd3kgb+MspQ7rclOz01mUchgiz+V2LyQt6mPf52jNJ1st7vZjPj8ArWBvlC5/we9FHodpyd44ZZoZvjiY8emNFludlQ2ubTY7ALPcsN0NeTbM2B0ZWr7L3c0YB9ifNM8RuA6uhv1JRl1bvngxw3M0dzeDeYaJIikrJuMMhaKyNY7SaJXhuc6x/h23etHyMNLCsDfKlpuVX32wye4gYVZWFMYyyyueHs3YakfM8orBtOQPngz5wadb3L3VNP5cNEZ93QSR3NT8qW9sL8t5ZkXJzV60LOdZeHQwYZoZ2qHLw+3O8jlOaq6ptXqle8Nq1sYiiLK6GbvR9gmc44GGSVryxYsZuWl6HHRDB9dp7sBba9kfZ5TGYm81qf9Jabg///yvi6u8Vq+CrKx4fJRQVhVZaYl8h3bgshF7lBbywvCTvTGFqXEdRS/0MLUm0A73twKejVJeTHNCT1NWNePccLPXnPeHs4KyqvjZXkYraoILkavJfc0kq1BKsdn2MVXNJK/oxi69lk+aG/LCcDSFg2mOi+WbN7vc7IZ8eTijqizW1miteDLO2O4EPLjR4tk4p182WRO92Ccvavqxj+eoY+93MMs5mOTsjZtstW7kLdftaeOb1xvhBq4myatj42JNZYk9Z96rQwghhBBCiHfrLGNUr5w787Ghi4241uqVUod1gavZHaZ0I5fNlkdhao5mFY5b89Xh7Fgz0IeLjbe1PHoxw6xM7fjixYwkNzzc6dCPfY7igj/YHfIn7vbpt/zlJvjORnMs48wwzUputANuOSGmshxNczJT873bPe5uNM0kHx1MaQcunqMIXAdT15TzsaumtkyyktRUaA2+blLCvzpMuLUR8J1bnRP7d5SVxVsJCoTznhmLO67Px0M6UUAnanpATLKS0sCXhzO2O+HZJoic0KS0MHUzPnL+c19MiNnpRNzdUMvAyKIvxXpfjbKytDwHq9SpWRvQbMAWgaR26NKLPaZ5Uw7iOorBrOAffH6I42rqg5rP9yeUdc2vfbJFJ3LZaocMkxGpMSSFQStFvxVwZ+NlEEhcb4tNemUtg1mB77pM0hJXK54MStqBy944JysMncDDWMsXRzM2Ao+Htzo4ChJTM81KOqHLi0mBspayshxMU54OZwwnhsJWjNOS0tYUpeX+ZkR3PsJ0mJTUdc3tnkvsucyyClNbrLWEvsV3HDRN883SgFLNdBxfw5SCCoUpK25vxFiruLvRIvA0tobY13xyo8M0M8wKwyQzjNKC0NXkZUVVwciUeI5+ZUrPm6YubbUDvjqckRYVkd9MUCqqis1WcNV7wgghhBBCiA/UtfwtdLERv9OL2O40ZRbLppkrFpuXzw+myzRxrTS5sWilmwaRgXts863sy9v+eVWzN0w4nOYMkpLDac6PngzRugl06Hm2xo12wFdHs2XfiNVNcFKUaKWP9euYZBWmrpf9HWa5oeU3zQTVvDHlzU7ENDOkZYVW0PJc2r67LJOZFqbZcFhO7N8xTkueHM3orfXvALjbj/lsu01palqBZpSW7I0zjmYlkafYH2fLn8HqBJFFfwrfdZaZGYsmpVpBWlYUVYWrm34Bi9dd1MwfzXK+Oko4muWkZcUf7g75/GDK4TRna6VsQyv4bKfDw+32sa+tbr6GScEPvzyiqqAf+1QVPB9luFove3j89PmIqanY7gT04oDAcxhMCz5/MV02NezHIbe7YXMebUTL4NXivFnveSKul0Ufh+GsYH9SMM5LamsZZwZQPDlM2Ix9Htxo4zjNOW7rpqTjfj/maFbQClzubsQErstON2SrE/DVUUKSV2TzJr+T1ICj2I4jsrJid5QT+S62tiR5hanVMrhnqSlMTTWfEPTLdzv86oM+G7HPrDTM0rIZo2xq9ic5pTFU1mJq+NbtDo7TBPocB272IqgtPz+Ykpc147TgYJLze18MKCpLVdeMspKfPp9wlBTLfjDQZJCsZm5A87yL7IrQc/jenR6mrhlnJWDZbDXr9Ir3hBFCCCGEEB+oa5mBAa/2YViXlRU/3h3ybJyTlxUvxjlKK3qxj+sotFJMc+i3Aj5Z6cpfmJf13fujjNB1MdhmqoWjqIAkM8vvD1yHh9ttvjps6uLXSyxiz2VkymN9J3JTsd1+WZc+zUrGaQkooq5DHVm+OJjiOppO6FJUNSj49EaLGshMTVlZdjrBMqCx3r9jnBXc32wt07+XY0YHCcE8BfwoKSjKGt/T1LVllpdMEsuN3tkniASuprYsS1f2RinKqpWAR5PF8ZNhSjvyqGtLWdckmeFWN+LuxstSlZN6TZz2GT86mNAK5gEoIA6aWJyxNfc3YnJTM84Mn23Fyx4G3Sjg3kbF4xdTOpFHN3T59s02nchfmV7z+rR6cb2M05JRWlID9zcjhmnJ/iRjIw749s02TwYJn3garTU73ebzzQrDi1ne9IcxFseD0tbUFr59s8PhLMdVisIYnoxSJmlJHPjsjzK8viL2NXVV8ePdAZWFyHe51QsIPY9RVjBKDJ9tt9juhtzsRiS5YSPy2O6GeK5Co8iMYZQaUDVZUXOkSr550+H+RswkK7m3GeO7Dp6jeDxI8DUUpimV6UUeN7oBSWH4yd6Una6PVgpHKb46SpZ9bU4q3VqfSrIR+/zag00ZpSqEEEIIIa6EaxvAeJNf7E/42f6MbuSxEXmkZcXBNMNYn5vtGN/R+ImmHx+fjrG6OZ9khjh0j40iPRhnDLLy2GOsVXy63Xql5wNAN/LwHM2sMMsxqre64bFpIKmpqC20Amc5DSMpK/ZeNNkJrcBdZjP0FwEYFNO8aTK6sN6/Yz3wUNU1Xx0lPNzpEPvNSNGfPDvkwVabdujiuQ6/GExpxy5fvJiilSKvarbD471FVjc5W+3g2BjZvXFGP3S52Xs5hjTJDQeTnI1WgOPAeFwyzSpmkVkGOYC3agw4zQz9tVGOoacZJGb5HL3QWzYfBGgHmt1hE7T6tfsb5JXl6Silk5llE9PYdWhH/qlp9eJ6ScqmNKjlu1gLt7ouaVnhaoWjNRuxR1bWywDYOCt4dDBFoXgxzZrsq7RpTrsVegySgrKsOZwWbHY8fMfBdy3YGtAcTQvAEngunbApzZrmFcoqtGoCoUopNiIfxaLPi8XYJhgYey5HSc7eJGM2n8ITeU22V1o2gcxJZrAWjmZNUOFgkrMZe0wLwzdudNC6yVB6Ps7ZavtMc8N2O0ShluVcixKR9dKt9TIteHOwWAghhBBCiHflgwpgLDrs56bmP/1iQC/2lmNEt9sheVkxmpX80581d/2TwuA6mmfDlGLeb8J1FLmp+PwAsqoCY/FdB0c1Y0i32j77k4IkN8upIrO85PsPNk88psUmYbMVLDcJnlbH+ju4WlOYcjmR4IuDKU+PZoS+Ryf0qGnuJPuuQyesKSpLHDjUePRjfz4d4fjm46S7qwfTHNfRy41PXtTc60ekRQWq6fFxuxeSZBW7w5TAc5qNUW4YJsXJfUKYj3OdV954WlOuNd9sAjQVP9sfU5TNZIPN2G8yS+aquubpKDvzXd526B7beDaff007fHlKf/Nmh5/sTtDz0peyrnG05fZGRGZq0rzJQulFzc8xK2t++GzIrz/o47svU+RXg1rieol9j1GSE/kOg1lOWWmquiZwXQpT8av3+/x4dwRAaQy/8/kh46LiZtvji4MZ08xQVjVfzDJ2PYe9SQ5Yvne3w4tpwe2NCDNIcOajVysss6yiG3ooBVaBoubJKGW7HaAUdAOnKTezlsNZ2mRGvJjR8h0ePZ/ys70JVkPgOZSmoq7B1TVPj1JagYuvFC+mOYHnEHnNBKT9SU5hKr6x3eZgUuC5mtIYbOWSVjXxpkNRVdzshsdKRNYb4UqmkRBCCCGEuMqubQBjNVix2ihykfqflQaVWGLfnfdt0Oy0Q56N0+Uv659tt/nx7mg54nSYljw+mvGr9/vEvsPtbsQXB1My16AdhdaKm52Q793pUdWWQVLQDl2+/2Dz2KjCVSdtEj7babITFl/rRi7dyOVoVrA3TvmD3RGuVmy0fCLfobIwLiumqeH7n0TL9+xoxdNhwu4weWWyx0l3VwfTAqVgVhjq2jLOC0LPpd/yuNULOZrmaNWMdA09B60Vw6REK0O/7TdBirU+IYfT/NgIx1u9Jo19f5xxf3MRKKrJSkuRlVR1RZLXmCpnsxUsP8sng7S5A/2aso3Vzzz2Xb56MZv/jF8Gkr53p8fTQUJuam52Qg7bOUlZkZYGayy/fLvLt29v4LuaX6RTPtloJtHsjjJ8RxN5mkcvZvx662UAYz2tXlwf3XkWxCw3VJFPWjZTf7qRuzy/Qs/h978a8J88OiTJS+5vxcyyiqejGaGjsEBRWxzdNAKNAk3oOnQCj7v9kK7v8NP9Gb6n8bXCpSk3C7RCaQc/gsPDhBdTiF0NWjF8XnKrHdK62SHyHKZ5zu88OqRWTXPPQGsizyHRilFSstn2iTxNL2yuE2VV0w49clNRW8vjoxnjrERrhe86VJWdNzuu6cdNMLDfakpJvJW2F5JdIYQQQgghrpNrGcA4qU/Bj3ZHdCOPSWYoqmaDe5TkzMqKXuTTTOW0/LG7G8tSj6eD5NiI09w0fRnMPM373mZMZipyU7E5/+V/kX3wNncpT9skLL42THx++OURvdDnZifk934xoFKW2GuadroKIk8zyIrlY/OyIp2Phj1pssdiusfq6NLFdINe7OM4sNkKeHKUEvsedzcinh7NGM0M3ZbHMClxtGI0K+i3PX7lk/7ytVf7hCyao66+1+22z8+eT0mK5nW1ahoGbrUCPLdJqX98OGWUlM0o00lGURp81+erowTf0cdS3Ref+aODKUlulpkgvdjH2JpB0rzO9+705mn3zXnhOZpv3GxTFBV5VZNuhNzrx2x3mpKYL19MSYqawHMIXU1VAwoOJ9lrp5+I62OrHZANErbaAbd64bHPc7GGQ6+ZxPHdWx1SYziYFAySAkfDICvJy5qtdoDSqmkKOlNstUMiX/N8XKO05sGNGFNZTG0JfJde6HOrFzDNK/7hF0fMckNWGA5qy91+zI2WP8+sMlRVTVFBK3AZZyWfbLV4PEgIfcVG5HF7HmR7uNPh4U4HDqaMkgLP0RzNCkzVBD2w8OPdEXd6MZ9stbi9EbI/zri32aITunIuCyGEEEKIa+9aBjBOGv+Xm5ovDqbc7beIPIdbGyE/ez4m9j06gUteW5S1fHrjZc+I9RGnXx7OyMqKSVZyqxcRek2Dzr1RdmKDzq9jNZtgkOTsdENMbclMTb/tYcqmqWbsa6raMk4NZVWxO0qpa8vhrBmV2A5clNL4riKbT/boxwFYyygz1PNsirqGvXFO5LLMpNhqBUySgsJUJIXhKGkyNDZbAaHXvO4wKdFrb3e9iedqqUpWVhxMC272wmUGxv939oKNyENpKIwl9DSf3WjPp4VUJJnBcTSebkp4TGU5nGbMvOb0zE3N/ihlVlZsxsHye3JTcmcjPhaQWj8vttvhcoLJIvC1CE7kVU1uKm734/noVXC1Qz92ltNPJK3+ejtLmcRiUkkn9piNKmqgqOqm3Ckz+I7m6TDj7kZAO/JwgD98MuKffniDTuAxrg2bsaZGkWQGCwySjMdHM9qRwyAp6LeaUjBHKUwNh0nBZqxpBw7744wbnZDY1xylBb7XrOukMDiBh4OiH/vc6DRZXpuxhwIm84kq06LE91we9iJavsskawIwcejw/QebzHIj57IQQgghhPggXMsAxvpdf4CyqkjKikFaUJiaaVbyzZ0us9LQCj3agcvtXkhVvyx/WB1xChD7bnOntHzZm8HRmvub8bG7lieVr8xyc+b+DesZJM9GNaVpejOEnkNutvj9r4YkuSGdT9lICsPNXoSrNa6r2J/kTDPD3ijl0xvt+TFl1DXEGw6P9qc8Hcz4ZKtNK3AxlSUtSmLfR6lmkknoOfzyvR7jxLDdCenHAXVd4S8bXyocF+q1nhbrTTxXS1X2Jxlg2emGywad3dDDYulGPmVV4zkaR4OrmjKeQZJTVSw/B89VTHLLwXjGVjsg9h2eT3OUtWzEPkppPFcRW5fno3QZwMhNjVawN3r52fQib9mTYz0rxVWK0HOoakutavLKUpiahzstuUt9zayvydU1+KYyiXFmmObNPweTZoRwL3LZzQy1VSil0FQ8H+Xc7Cnu9EJ8V/HFiynfvdtjf5xxMG7Kr9qRR8t3mGQlyqnZHebc6AS0Qo/9cYqvm3P8aFY2I1nbPk+HKZ4Ds7wJCloLG7HH4yPDXprgO23+qXsb+I7D3qjpgxG4Gh/NzY7L7z8eErlO02dHK1xHs9MJKEzNRuyfWt4mhBBCCCHEdXMtC/sXd/1XWdukYxemJnAUs6xiVhi2Wj53NiK2OwGuVjw+Svj8YMrTQYKjFLW1lFWNtU1jzFleMpwWfPFiyldHMyZpwVb7ZT+ERfChts2Uj7So+OGXRyRFtZwU8nSQkJWnN31czSBR8wkJWimGSVMi8slmi2/utLnRDYh8h43YZ6sd8o3tFp4zf0zgUmP52fMJXx7O+KPnY4rK0gqbspNhUtIJfZKyaiabuJrb3ZgX44J+y+fuRkS/5eNoh1++2+Oz7Tbf2mmz2Qqp6pqsrKjqmlvdkHbgUpjmZ1SYmsJUy5/JYnO4yFgwpube2l3ehzdiZkVFK3C52QloBS6T3NCOXD4/mDJNDaO0YHeY8vhoxu4w5WCc0Qm95c/I1RrPcRglKxNgFMsxsouT4MkgpbYQec1n8WSQNicHLze5O52I79zq8nCnw3aneb+jzOBqxXdvd+iGHk8HL8+T132W4v1bX5NnWYOrjx3OcmLfJfIcNiKfYVLgeQ6f3mzzgwcbHM0K8rKirGr2xzn/6PEAR0Mn9vnOzQ7fudWlFbhEvsPNTkBZW252Q757q0vgaFqBw9E0Y5KWZKYiLQx50ZyTjw9TbnVDQLM3SumFHr6jeXyUUFY1D7Y7tKOmkW5laxSKcVryS3d6hJ5mmjWTfLY6Pr7TlEH5jgZLU1YihBBCCCHEB+RaZmA0d9GP90OYZIbPbrRBQV7VeJ5ilNYcTDPaoUdVW15M82Z8oQKtFbPMsN0JMLUlLSuUgl7sYxcjNex8wsaK9fKVWWHwHIcvXszoxV6TkeG7rx27uZ5B0m/5PBsmzLIa223ezyebMd++1QWagM3Pn08InJePiVzNz8c5jlaErmY3NYxtOd8MAQoqa9kbpRSmmbDSjV1mhY+pawpj0VqxGXvcmR/n/a0WlbWYCipb4yiN68DtjejMJRW+1wSXopWv3eq3OJgW/Hx/zDg1xK7DrV7IvY2Y2HdwXM3zYdKMnNUaS1NKE61MGNnu+Dw+TDiY5OSmQiuF6yi+sfWyJAil5h8ay88P7Pzrr352O92Q3FQEnsP9flPuMkkLUlPjrfRXOamhqLg6TiopW3z9TZk0h9Oc7U7I4axoGtUqeDJMGSeGP363yygp6cUes6yiqiocT2Ot4vm4IC0tf/+PDui2fAIHvjhMeWxqqtqy2Q6YpgXd0KGsm+k8tbJM84rKwt2ej6s0z8YJ/+wv32KUGPZGzTp/Psm50fb59s2YzZbPKDMAPB/n3N0I6bhNVsUv39lYZj8dTHPSoqK2Nf1WQFIa7mxIFpEQQgghhPiwXMsABkBRGg6mOXnZbED1vIdBJ/RxnaYWfZqXbAchoav58jDhyWBG+45L7LuY2lJZy4tJzmc7HTxH8XiQ0Ald7m+2lpvVSVou+0oErmaclkS+syxTeDpIAYvraG55TR+LF9OcXuRxt3/ysa/3jWhKG0LGWbEMEtzpx8uyFICdXsjhNJ/3alCMc0MvcmmFHpmpaUceoeuQFBW9uJm+8IdPx3Qih2De72E8LfnurTbb3eiV6S25qcFa+q0AU9XHRqbe7kXMcnPie1kvh6lrn8dHs2ONA6e5wXUdPt1qoxW8mOYYLLVtmqV6jiL2XALH4c5G1JS75IZq5Qb6RuTzo3zMOC2prG2mtEQemyvZMQD3+jHDpCQtm1KY7U7A81EKwPNRyu2NiEXiUeg53OvHPBu+nEwT+i6eo8+1GRbvx0klZWcdfTtOS3JTUVYVWVkTuA7f3GlzOMkIPZcvkxmhpzmaFsSeJq8sgaOZFRWdwOGnL6b0Jh4H45T9aUE7ctlq+aRlhTHNJJBZZviyqOgFHlvtEEfBZickKyt2uiHd0GeUGDwHPE/TnWdzzIqaVmDpRh4t36UdumzNe7rAy5Kop0cJXx7NqCrL3Y2QXuzTbwXc2Yhe/+aFEEIIIYS4Zi4tgKGUug/8X4BbQA38prX231ZKbQJ/A/gU+AL4y9bawds89+4gYVbU3O5FuFphassXL2ZUdXOzPS2b8pFPb7SY5hVfDRL2Rim3uk1d+GLT3I99DmcF+5OUaWYYJyXfvvVyFGlWVryY5lTWLu/GPx+l1Cj6LZ/Ic8hNxSQtub8ZL5+3NDVJefKGH07OIHEdTT9qatVzUzNKEjqRv3xdW1tagYepaor5Bv9WL+LTG81ElKys+PLFjC8PZ+Sm4mhaELqKjdAnMzVaK260PLpxcGyyx/o0l8Cp6EVNUOCk8bRlZXl0MCVyNSjFIMnphf5yw9+JPO5vthhlBY5WBK4mLQ23uiHxvJ+H1hprLV8dJfzx2EehuL8ZcTAploGH793p8mz4chrI/jTHdRSfbrfwtEZrhacVR9N8WeMfuJraMg9SNO/v8dGMwGuO3XU1TwbJsQCVozWfbL3sefH5wZSqrk/toyGunvWAILzs0/K63hhZWTFIClyt6UU+rcDydJBydyPisxstfNfhR89GeMrhwVZMXlaMs4pZbWhrF+U45JnhyNTEoYubljwfpARa4zuKzXaAQs0TgSxt32Wj5fMn7vZQSvPkaEboN9eQJkDYlEq1wqanzuG04HCa8a2bXZ4UCZ/dbB+bIpKVFbuDBO1o/qlPNxknhsNZxrNhuswCu6imw0IIIYQQQlwFl5mBYYD/obX2HyqlOsDvKaX+DvDfBP6utfbfVEr9NeCvAf/62zzx/iRfjsmE5m7rrV7Aly+mtCMXay1Z0dxV/XS7Q+w7TDLDNK9wvZcNOvOy4sUkZyPyCD2HmWv4yd4ER08xtSUvm14PN9rBsiGl5zkcjDP6802z72jyqmJ/nGEBrRShp9mJXt79PKnpp7IW5hUPhak5muZ0gg7twOHxUUJualqht5ww0ol8wnm5Q25qXEfRC/1jmxNT13iLTZyCe1stuqELSuE7mo3YO9aQ86TUe891GCR5M8kEOJoVWAtHs+b4LZZZZppART+eNyDN8Vy9PBbXUZTm5QvNMsNG7DXjUk3NJC2JPL3MLglcTV7W3NmIlsGHwtR8svVyGshgkvNwu00nfNmQcJIV/Gh3DEotf65Ph+kyMHQ4ywldh/ubLZRS7HRCHh8l7I+z5YSUV8ZKWsuTYdb0NPAcTN301bjTC9/mFBXv0Hoj2cXnuvi6f0o50KJ8ZG+UMkxKKltzMM4oSpc/dn+DJK9QKDwH0rJmnBnANpNEqpr9ccp2J8TUNaayeFoTeA7jtCTwNEdJSTt0iT2X797tkmUGreBw1jTgdZwmOFZUlllZ0Qo9jpIS33NIy4qsrAi9JtiXmgozvx4t1tnhNGeQlMtMrWleMkoNLR/y0lDbQMqfhBBCCCHEB+XSAhjW2mfAs/l/T5RSPwbuAn8R+DPzb/st4O/xlgEMa1f6HCy/BjV6+XXXVaTVPEhAU4Lw+CihbxXWWkxleTxIcLVtJns4ikla8g8eH3C3F/Nwp80vJnlzR3Yz4ovDKa2gabbZCV1eTHNmhWFWGHq+y/KFFFRVvZzScVKWw493R3Tm/R4KW5OUJVHgMiuawIClaUY4TApu9ZoNfbMxUyt3XyMeHUwZHM6azfq0IPA0v3xng9BzCD2HUVoyykp688yOsrLHUu3XU+/XJ5mUlW16b3iabtRknOwOU/KywnedZQPSwtTLY83Kis8PmnG0i14jL6YZR7OCG52mnKcOXb58MeX2Roy1lpbvcjSd0W+1sNYeCywsNl7PR+mxHiC5qTgY59Qr2TFPhylFaZaBodJY2v7LPhpNyUjE3ig7vZ/HG/poiKvntFGpp/XG2B2mTV+Z/UkTPKuq5ccduIpJbng+ymgHHtvdgHFa8PP9KdqBlu9irWJWWtqBwtQVh9MSrRSDaUFZ1ySFYbvjM8lqupGLdsBTUDia0lTkZd0ELkvD08MErOJwnGN1E9BTgKuaEqnAaTKH/nPf3ibymsyMRcbRODM8H6coFHvjlKNpgQKcDuyOMm5txPiuI+VPQgghhBDig/FOemAopT4Fvg/8DnBzHtzAWvtMKbXzts93sxexO0yW/SBMZdkfZ3y6GfPJvKljWVkeH8348sWUyHfRKG52m5KMpDBopagqy52NaDl69fHRjBtxwOEswx84zLKSUVrgjx1++W6XvKz5o+cjWpHL7V5M4GpGtWWcGz690eZeP8bUlsEsZ2/c9F0YJDndlRIL31WkpubwYMrdfovIczgY1RRlhVZwqxfhO5q6tssMhcX7WQRFFnJTLZtaDpOSe5svsz4iz+HHuyPSvKLcqKkBTyn+1MMby+9ZT70fzAq00kShXmacGGspMsNWu8lAsDTjThcTHvotny9fTNkblmRlxbNRxjQv+eZOZ9lrpLaKw0lGL/LRrkKjaEcem5FHUlREvsP3H2wyy82pgYWbvYifPh8zmJYUVcUsr+hGLt+51V0ea5I3wYtPNlvz9+ccC67AyWNx16330bjXj18ZJSuulpNGpZ7UG6Oqa746nPFwp0Mv8ng6yKhszd1+TOA69GOfHz0bcTDJKUxNXVsmWcmdXgwaMlPhKM3t2GWU5jwfVpiqZlJUoBRJYVAaHBSBqxinhn7sU9UWYyyObsqYOqHPNC9xtMPTUUJaGv7xl0N6LZ9u5PJsmKKVw7d2YrbbAb3Ix1p7rK9HUpQoFE8GCb7nEPgOxjQ9eO70Ywazglu98Ey9QIQQQgghhLgOLj2AoZRqA/8P4L9vrR2rM97JVkr9VeCvAnzyySfH/u7ORkRaViS5oajmzSZ9l3bo8AdPhkxzwzQrqWtLHHjsdAIc3QQFNiKX7U5I4GqGs4JhWtIOPUJXM0wKRrOiuWvraCZFRVlWZKVp7oo6ilpZdgcZt7rNBtsCtbW8GGVUtcV1FKHjYOcjHfeGNX80HHM0a/o79CIPpcDXGm8ekIhCl1lmSIsmYNFv+cveDesZCQu781KJ270I11E8G2ZM0oLn44wHWy0GSYFSmjBsRo36WuOu9YxYT72fFQZHqeXfA3QCh4NJTjkvW1E05R2d8OWpMysqxnlJNaz58sWMm71wOe7Vc5qMFc8BRytGmaHlu/zJB5t4rsNn2+3l86y+7rrYd9gfpljV9L5IS0NVGSLvZafU2lqKsmJvlC7LXfKywlQa27XLKSOh34xvXZSdLFLwFwEiR+tlKQvz9+t9QAkYr1tbV8Xrelec9ftO6o1xMMlphS61teRVzZNBQjtweFLPcBzN/ihjkGZ8vj/lXj+mE7lEvsvI5BSlJfQdNBpXazZbEcNZjrUOkddkctV1jVaKvFZEgYenYZCU9CKPVuAwygqqGlxt2Qg9tLIkmeHJIMFxFdOs4MUkRyn4xo2QVuSzO0x4uNMm8txjQczYc5tzvKoJPY2ylrq2uK6Do6Co6hMDn0IIIYQQQlxXlxrAUEp5NMGL/5u19j+Yf/m5Uur2PPviNrB/0mOttb8J/CbAD37wg2P3v0PP4eF2+9jGxdPwk70p3cijF7oMkoLdQcJ37/SazIjKMitKdnrRctP85dGMaV41JSmqab45SivubnqEXjP20HU1ZV2RzUeRdgIPi2KalzyfNM33PKVxPM3D7Ta7o5QXs5xO5fLVUcLjQcKP9kbcaPnc6UWkRc0f7Y/5xlabp4OE2lrKqmaWG9ph079DK0W/FRC5+tSMhOejlNhzl0GQrY5PVhp2BwmfbMbsjTJCT3Nvs03gNo8rTMX+fOrK4ue4mnofeprAdRjMCoqqeb9aaW52w2Vz1H7LZ5oWy+DK06OESVrwcKdDO3CZ5BXjtOQnu2O2OgG+o1FA4Ln8ifsby+MvTL2cpnAWT4cJD3e6FFXdHJvn4KgmdX5nPjrWVDWH05J26C/7V0xrg+s2fTSwtgmAOBrPaUbv/pMnQzqhh+MotFa4CnzPpRt6x/opfEgp+K9bW1fBSWVXJ/VyeN33QdPj5qujhFbgsj0PYs5yw+1eyN4oW5Zq7Q4z9icp97diOr7H7lGGReFoTSvwUEphrCYrm3MrM4ZxBrc3AnY6XaZpydNxRmkqvnuzwyRr+u9stjyOpgW+Y3FQDPMSR2nubPg4SrPZ8RlMC3anCb6r+Wwr5uko40bHBwvjrGK7smy3Q36+P+E7N7vLoGM+bxQcBx53ehFHSQ5KU9qS0NHsT3K6kffBnbtCCCGEEOLjdplTSBTwfwR+bK39t1b+6m8DvwH8m/N//63zPP96yvjjo4Ta1oySgtrCLCvZiDzSzJxaCtCPA4ypyUpLWlV4ShH7Gn++OffR5LbiRjvi3vy1fvZ8TF0340ZvtOHxIGF3kC43VtPcME5y2n7TBHJvnFGVFmub6RthoIk9j2ejhLv9FmAJXRfqpjnmT/fGtEOXh9udVzISVu82H04LOpFLlZbLYEMv9pikTRmGVnCjHSyDF0DT2sEe36+u/hyHic8PvzyiFTQBnKysmWZN0GerHSw39OPAXQZXDmf5fGSq1/xMQ4+9YUpqau70I/KyZpyU3OiFy4ki5wkKTLMmFV/rJmCTm4rno5RRUiyzVMrK0o3cY/0rAldzq9sErZ4OEirbND8sqpqDScYkM6AVd3oRprbMckPo2mXz0BP7ZIhLdVrvivVeDq/rcWGtxXcdPr3R4mCa88WLGZ9stfhkM+YwKbBYBrOCrXbAcJ6VczguoKNoRz5aWZ5PU8q6phd77E9SNmKffuzxfFxhTEU78AlcRSf0aMcuP3o64XBWkJcVtbXUVd0E0TJDv+WzEXqkpSH05pOFLHQjj2jqUFGTVBD5Lv3YxVSQzZrsr3FW4jmKrXZwbCJQXfv84mDKTjek5TdB243IRWtFXlYUlZUpJEIIIYQQ4oNymRkYfxr4V4A/UEr9o/nX/ic0gYvfVkr9FeAr4C9dxItNcoMDHCZNj4R0nlGwWv+93sSyG7q4OmaWG4qq5vZmzN2tiFlRM8krbm2EuNOmBv6rwxnWMp9M4i+zNhSwEXn4viItK0pTc7MX4bpNCYWpLf3Y52hWonRK7DlstVz2JjXb3QBXN6Ubw7TgTsfnmzvtZUPKo2l+bMLG6ual5Wv+4VcDNls+ntagmkamv3Z/Y5lhsjtMlqUfprIkpeHOxulBg1luuL/ZYlYYMlMTeJqHOx204tiG/uF2e7kp2h9nyw0kgOc69EKPrGqmKGituN2P2JxvAqeZWQZo3mZj1Q5dsrImDprXClyH0HUZpsUy6LMRe2zE/qn9K8aZYZTkBG4TXDqaFNS2pvCdZblL7DvN3evXlLOIy3VS7wrPUa/0cjipCe1glvNof8onN1rsdEIi3+WTTXeZ8bPVDvj5/oTdYcY0NyilmGYV2tZopUmLijsbIXUNw7Rkf5yx3Q7YigN8rwlu7nQD2oHHZuyR5BW5MZTGEgcOaVGhHY2LpaqgH7n02wEbcUDkOVgsz0cZs7KiGGcErqaoKjztoB3wQ5fU1BSmJnQ17dAjK2vSwvL7Xw2IQ5edTohSmk7kcbcf8zufv2CSlriu5n6/RT/2+datzitNP4UQQgghhLjuLnMKyX/McjTHK/7c133+9dr3yaxgmBpudAIc1WxW//DJkFsbEaHbZBPsjac86EfHxplm89GEntOUkHxxMOVWL8LVTfAhNxWe1uTGEHgO9zab0aR1DWlV4TiKrbbPrY2IB1utpgfDOCUp82aca14yTAy92MPXitrC83HB3Y0QPS/LmGaG+5sRjm6CHrWtGcxyEs/hfj9eTi650QmXwQJvXuc+yUo24wBr7TKoAif3Cem3Au6s9HZYl5uadujSibzVz5GkOD1bYqcTsDvKmoaqWlHWNVudgMh32GoHBK4mdDXPRhkPdzrc3WgyMA6n+XJaylk83O7wwy+PAAg9zTg1PBsn/Mr9PjfawbJpazuwp/avSIoSrV72HtGuhgqy8vho3YNpU2bzuvIFcXlO6l1xUi+H1e/Lyoq9UYaiySpylGJvlHGrFxJ6DlVd83SUMU5LjmYFz4YpncjFcxSBp5lkip2uR25qctOUhsW+Ryd0aYUuka/51q0ercAlzQ0vkgKlmr44kefxdJjSizy2Wj6DJMd3HL5zp0c/9vFcjVJgyorUVGx2fHqRi7XwfJKx0wk4TEo2Qp+yqvnxszEKxR+/22OaF+wNUz7Zitgbp3wr6i7fV15W7A4y7mzEFO0aY2qKsuaTrdaJTT+FEEIIIYS47t7JFJKLdlLt+6ysKKoaYyq0q0myko7vUFY1n7+Y4ToKVymmZUV/vuE9nOZstYPl9IvNls9h4jVTOK1lMC2IApc/9ekWvfldzK8OZxSmphW4FFXNVstnkptlTwilIDOWjfno0m7s8/lhQhw6uBpmRckwLfjV+/3lZIwvD2e4qunBAM00kNhzMdYuJ2xYC0fTbJkt8sVhwv1+RFLCZtvHdzSRrxmlJXByn5A3pZOfdeO46k4/Jiur5udvLI5SbLYCHu68zNL46mhGK3DfWBLwOhuxz/cfbPLoYMIgaRqi/sr9PtudcPmc252Qg0lG4DknlqrEnsvIlJRVjasVvdBld5DSmvceMZXl+Tjjdi/6Wscqvp715rKnlRytft9gls+n51q2OwGKZt0Mk4KN2OfJoJkK9GSQME5Ksqriph/QbwWEnmFvlPFskHJnM0YrhdaaJC+522+a5H56o0NR1mhKjIUbrQDXaRq++q6mE/h0IpfQd+jGHnlRU1uL1rDd8TmcFEyKijvdkNueBmtJi5qNVkDkaV5MCsZZUw62EXnMcsPuOONmO+CX7vYIHc3TQcqDrTaB14xYPpjk+K6mFTTXmnp+Di/6wkgDTyGEEEII8aG5lgGMk2rfm0kXinFumIwMs7ykHXk4WjcTR5ICTzcp2YugADRlE4uN0dNBwi/d6jErzHyKhWrSxIuK3nzvtN0J+OLF7FhPiFZWLntCOFpzpxfSjwNcR/FinPPH73XJ8pphWtENXf7M97bJimrZE0IpGKYFrdDly8MZB5OczZZH7L/8eBxH8dXhjG/udIk8h9pahknF7X687M8xSQsOJtlywsZWO3irTfdZN46rQs/hs53OMlCy3QnJ5mNqF70pZpnh0xutY49b3BE/a3Bl8Vq3uhF5XPN8lNIOjp++ndDF1MGp/Su6kYfnaGZF0xdlZ17CU2OXo3XjwOVu/3iWyknlC+LyrDeXPa0Pyer3jdKSbuixOR/3uzdK8bQmq2v2JxmFqXAdTWEs7cjjvqt4epQ2pRihy/1+yDApaQcujtJEnmZaNH0kbvdCUPB8lJGXlihwCDyH2HPoRh5PBgmfbsdYFFlRNdOEbJPJEcx7yVTWcmcjJHAdbvWa0pbFcT4bpux0Ar5zp8PnBzMmeUlZGrY7MWlpmqClo4n9pozsdi8iq2uGs4LIb3rfAOyPcxwN06ykMLU08BRCCCGEEB+caxnAOKlGfqsd8I+fDHi43SVwFb//dMjuUcp37zQb/sPakpUlcfryLa9vTNdLKAJXU9WWonpZYuDoZirHej+H1TpzrVj2YVBa8aAfk65kSoSepgzq5Ua77TkcTgvaVhF6Gmstj49SfnVlakdZW1zHWRblbLQ8nh4llFWNtU3zycfzUofzlj6ctnEElpMP3hRsCFxN7Ac8HSbLn8/NXoijX94JzsqKJ4N0/r1nO9b1rBvX1TwZJNzfbC0fU1aWbuieumlbBGg2Wy+DT23fJZxvJgNXs9Xyjx3r4nnlTva7td6k9018R2PmDWpDz+FWL2J/nGEtmHnGlO86mMoyLRQxDp3YIylKHK0IfIc/80mfTugzzQ0vJhm9uiZ0XbbaAUlp+ObNDpmpeDZM8V3FgxtNedfP9yeErmaSG7qRT+xr0gKOpjn/2YdbjLOKbuRyrx9zMMl5Mki5v9mc6xuxzx/tTehGLllRc6MdYKoOu4OEaWEIHMUsMwS+Qzd0iQKXyjYNQNuRuwxyjpIms+jFpCAKHLRCyp6EEEIIIcQH51oGME4qddCqKSFoSjhq6nreXNOZ94xwmhGKe+OULw9nTQ8M3yVaCYSsP+9G7PP4KCFw9TKbYJIWWKXY6UQn9nMIXE1tWfZhKMqKP3g6ohN6BK4mL2teTFL++P3+seDAQ9dhljfNM3e6IUfTjJ8fTNlq+WitSDLDL93ukJmatKy42Q2J5o9JCsPRfKLCvX58LMNkvfRhvXfIejBifeP4ppGW638/yQyPDqa0A5fQc5peIWVFbVmOJt2fZIBlpxu+9lhXrWfd7HRCHh8l7I8z7m/GZ84WWQ/QfLZzvJno4v0058yHOUb1Q7H4rGrbBA2/OJjy5Cjll253cLTGVE2JRlKUTBJD7Lv0Yo/DacHPX0zRWGpPE7oVoevSbwVsd0KeDVNmRdOjwneaxp15VbM3SvE9h+/c6qJQ7I9zLPCN7RY/2ZsQuQ5pUbLVCol92Ig9vjpMudkL2ek2vTh2uorHRzP2Jxn3+/H8utWMG96f5nRCl2/favNimmOLCt/V7A5TdjohNnSZJAUPNmPuzku3fufRCw4nBa3QwdOKwFU83O7I9BEhhBBCCPFBupYBjJNKHcqq5lfub5AWNUVVs9MJiLci0rIJaMS+w+GkxnOcZVPPo+mM7z/YPPV5tVK0fE1u7HLSRey7dALv1B4J68+BVnQit7nDOp/KcaMTEjgv7+jnpqYTunTnmR9ZWZEWhmHS9LPAgu9qzMoM2NB1aG+4ZKaiHwfUddO8cnXTUtU1T4bpsaalq5NMTsp8GCYFjw4my+yJ2HNph6e/3/XAwiApSPISjeL2RoipLLO8JHKdZcaJMTX31u4Ov6lMYz3rJvQc7vUj9kbZW407PS1AsxrQOUv5gnj/Dqc5tYWjWY7vunxju83eOOOHXw241Yu424/phC6uVnyxP8N1NKGvGaUF46Qg9DVx4HKrG2FszU+ejRmlJcNZQWYqYs+l12nWZJKbpodOZtgn5yjJOZzkdCOfb95sczDOm+yJ2qK14l4/5pPNmC8PZ9zfbIKKsDhvY758MeOLFzOstdzshdja4nkaRykUitvdgFlhGKcVD7ZabMQ+aWFITLUMToSewyc3WvzixZRRUlBZ2OlEmKpmd5gupxEJIYQQQgjxobiWAYyT7qR/stXCczQb8cvAwJOjGdttn9sbIbvDlM1OM/4wMzW+q+m3WsfGDK4/L9biey43Ot4yUPJof0J0wwFWRoeubL7Xn8MB/sTdHvuTgmluaAcudzei5bQQeDXzYzArcFQTcGgyFDRau/xkd8z9rRbhvK7+KC/5/oNNNmJ/mfmx0JRpJE2t/jxY8aPdETsrk0zWgxHDpOCHXx7RCjz6sU9W1vzw2YBff9DHd4MT3+96YOFgnNEJPCqaBqSeq4ityzAp+N6d3vL9rh4rvLlM47QGo97Kn9/W67JLJOPi3XtTdtC63NRMsxLfcfBcjYfmwWaLz19MaQUvA4LdyOM7d7r8ZHeMBZK85Fu32qSlJfQ0tbWUxmKBlu/wYmIZpYZe5DNKSwqTsz/OiH3NdJ7x1PIdlILDWUZ76HJ3IyYOXeq6Ke94sNVCK0U7dE88b/15YGxxXRlnJW3P4fkkpxW4fPNmh91BSuCWbLZ8WoFHHDg4Wh27ZgWuwy/d7vF8nOE7Du58mtJXhzPurAU0hRBCCCGEuO6ubWH/IlDw2Xabu/2YOxsRhWkaY1pr6cc+ruOQFIaf70/YHaZstQL++L0NHmy1uL0R0QldclOf+ryB59CdZx8sAgmt0OVgkh97zOs231bBi2lT3vFwu81WO+BgWoB9uYPfagfHjn2QFDwfZ7RDd96wE54NU9pRcyyLAMy9zSYAc9Jz7I+bBpl1bfnqKFluDKd5eez4PEctfwaPDibzjZKL1s3d6W7s8ehgdur7XQQWFpRSGGuXpTvNF1negT7pWBcNB7faL4Mk69YfM05LnhzN6IU+sd/8jJ4OErLyeBbHIkjx+cH0lb9fzR5ZfL6+63A4zddfXlyy1XKQ132eqwJXk5QVrvPy3DJ1MwmntscjZDfaAb3YpxW4zPKSvXFGN3TZiH12RymHs5xJVi6bdm62PR4dTMnLJghZmoq9cUbLb0a0Kq0JHAdr4fHRjKKuMVVNO3C53QvRSlGYiofbnVfO9YNJxvY8kLg477qhR+C7fLIZU9WWrKjITMW3b3X49EabfstHodhuB8euWYGrm2kk8yCOUgqlFa3QlfNYCCGEEEJ8cK5tAGPdIvCwKFNwFNzfjLnbj7izEXGzF1DVdtkDY2/UNOF83V3/fD4lZNX2fOzq6oZknJXkZcXnB1M+35/w6GC63IjZGl5MMvLFRszO/29lQx96DlvtgP1Jyk/3xjwbJWzELu2gmZjiORpjLIqmt8ZJAZj1958UFZ5W+I5D5DUbrVlWcpQcD2CsBiOmmSH0jv88bnaC+V3ok4MN64GFXuQyyQxx4Mz7htQkRcVO52VwYv1Yz9JwcP0x46zg/maLTuSdGnx406b4pM93NaAj3p3zBJO22gEKSItqea4Vpmaj5aPV8c/1xTTnixdTTF3TiT087TLNDXVtGcxynhwlDNOCaWaoLdTG0gk9agtFZfnO7S79OJj3qAmo6pqybgKEUeDQCVx6oc/zcYpS6tg5rWjOu18cTCmrmn7s0w6PJ79VdZM14bkOn95o8dlOhzu9aNlDRiu4NW+Gu3rNWoyBtthjP4P1QIcQQgghhBAfgmtZQnKa1f4GTwcJbduMSS2qmm7o88WLCcZaPunHJ/bAWHdS2cL6FJLAdQhcRTeM8BzF40FCXla0AxelNN48U2KSl2it8B3NvX78SrnH4TRfNgatLAymGa3AoxW4mMriOgrXff10jNX3P0hyqgq8+d97rqIX+wxmxXJ863qDynbokpU1cfDyOa1VfGMrPnU06XrJzO2NZgqKsTSjSXUzinZz3htkvdfEeT/fzw94ZRLNeh+Nk8btLr5+tx+fWpYiE0fevZMmC72pL0roOfzSnR4/3h0xSWviwGGr5VOYCqvU8jyfZIafPBux3Q6IfZeW75MVGVVt2R2mHCUlvXmvjN1hAkqhreVGJ+RXPumvHI/mR09HFJVlux3Si3yysiIpDNCUi/xKb5PYd5ZNNh8dTBkmBYNpTmUhLytubkSvnHcHk5xW6B47V+/2Y/YnGbd70akNZUPP4ZPNmMOkwJTN+rw1zwDxzl9dJYQQQgghxJX0QQUwVo0zwyjJCdymDGM4Kwk9B2PqU3tgrDupWeg4K1HWLoMNj48SBomhqBMUioNJTtt3+KO9Cb3YY5yWtAKHXuTzYKsF0GysVjYX6xvtrZaPq9WxoMen220m80yIs0zHiD2XkWlGK7paYWqL52g+WQtGbLWDZXlJ7Lt89aIpF1n02Zit9Nk4zauNMaNjvQzO0jz0bZ0l+PCmTfFJn+8iu+SsY2PFxThvMGkj9vn+g81j59u9zeZcXATVxlnBVjukE7ocTApaoYsmJCkNaVFxuxNxmORYTFM+pRSDac5WJzz2Wu2gGbGcFRW+o0kyQ0VN5Gq684wKz1GM0xJI+Pn+hOeTDAdFL/JBwVFSUhjL3a14OZWnrJoxyJ/eaB1/vdClrPxTg4cLd/oxFvBdRybnCCGEEEKID9oHG8BIihI9z4AAqLG0fA/XVctAgrX2jXd415uFRq7GWwk2LPpKlHXdpHzbmp8+T/7/7b15kGRbXt/3OXfPvSpr6b17pnt2GJjHjAAtMCODAcsCQdjIYNkYBwpCtmUbYxxCyBY4bIVwCCOMkYyRhU3YQFiyjcAESAKCQQiDzcy8GTTMMEv3vH7dr5eqriUrt7sf/3HuzbqZnbV0dXUt/X6fiIyszHvvueeee05G/b73t7DU9LnYCci15vWNEVcWgkkp1lnjYtbQNhUHMmxLcb1SInS56fPG9mhSIeTWSmtPw7pdc03p2DhlXDyZXW761LxdsWE2iaVrW6x2aoyTlK2ROcdB4sV+41ZSnmMvT4ijsJf4UG3vIKN43v0tBZ3jFFuEgznM/dyL2flWUvXWsZVCo1ht+6i+CafyHZu3Lvs86I1pBx7tukOcAtqIWFGSTQTDQZiythPyrktthmHCo52IxztjOjWXa6utiafUnfVBkbzTNYJjnKOVol0zJVnbNZdhnFJzrClh4nq3jm1NizWDMGWUpPhFeea9hLR581jmqyAIgiAIgvAycm4FjIMqFsx6IFhKMc4yWsGuMX6YJ7yzxtGd9cFU3oRxnOFaFlqbRJWObaGAODXCiG/bLDc9bMva07iYNbQD12a56dML46cM69LzI8k0b2yP2RxEoNRTY1AahN2GP2UQNnxn4l2wNYpoB96UsLDc9LHUs4d3VJm9NzthymLdndrnoPCAgyjzhlRLvs4KOocxik9CbBEOZj8x6Xk9YXzHoum7bAxjU/1joUbTc9gcRsR5TuDZLNZtGr6LbcEwTMm15vpSA0vB1ijh7sYApRQPe2Nqjs2lhRppmrExSuiNExxbYVsWO+OUlZZZU6k2ZYUtSxGlphwq2iQZRam55XyBiWByb3PI1W7jUELaXiKOIAiCIAiCILxMnEsBY7/yl+U/97MeCAt1B8cC37X39IQ4DLNiQ82z2Bwk+LaD1po81aw0XbBsxolxNb+50iTXcHOlObfNeYa2UvBFlxcm1/PG1gitYXNoDDqN5tF2SD9MaPgOvmNzcSHgPZc6BK4918C/slCf8i54tJ3zcDxka2TEBc+2WKi7JHpuN6fGfy/Dct692R5GOJaalLWE5881MZs3JMk0G4Nocu1wtCfTR8nFIBwPVSP8MGv8sDR8h9c3hkRJzs44x7EtAsfiq9+5ysPtMbfX+2QakjRnGGVoBRfaNdo1lyjNedwbMxinODYErsuTKCLLNZsjs/a2hjGvPRmw0g5Is4y1vsZxBsRJRppr6pYiSjLubQ5JM1MhaWsUESa1PedqL4y52m1M1sxhhbRnLUUrCIIgCIIgCOeJcylgHJScEeZ7IPS9mMBznsvNelZs8F2bRuDS8h0jWHgWLadGp+ZysVMDYL0fcn9rxL3N4cRToBqWcRhDe2dsnvT6rqkq8tnHfT7zsMdqs8aVBZco1Xz+cZ+aY/Puy525Bv6d9QGrRflGANtRPNpJaKSayws10kxze31AozjvPAPoIMNy3r1ZaQWs9UMC9/hi9DcG0ZSg4zsWDc95ysB71ifTktjzbHCYNX4YynWw3AoYhAmjJEMB775shL5RkuJZNo8HIQ3fYanp0x8n3FnrszmMqLkOF9o+SZ4ziHKudD2icY7C9OfOWp+3rjSpezYbgxilYLXpsD1MsC2TUPPhTgi5Jk5Sap7LhXZAJ/CeEmSeNUntvGs9LtFHEARBEARBEM4i51LAiNIcS8Gj3q7x2qm5DOIMmE6+OIzSiShwc3XvnBF7Me+JZlVsWKp71D1nkpCvH3rc3xzS8IxHxpNBxCfubXG926BTcwmTnFfvbj6VW+IgQ3uUpKaygG0MuofbYxq+AzZYlkXNA61dPv+4z7svd+YagBoYRAmt4qmuAhxbEWem3GKUmWv1F+t7GkAHGZbzPBgOm4zwWZgVdNLcjHWn5nJlt3DEMz+Rfp5cDMLxcVyeMNX5WnozxGnO5jBGa0078EjSnLrfNCLjxpBhnLLaCqi7DmuDCAW4tk2a5WwOjPdFlKZsD2Pcoqzp1jCmF6Zc7dZJtcbKclo1hzg1ZWEfbY/Ic4Xn2FzsBLRqLnGaPyXIlPP13uaQYZTRrrk0fYfFojTsfkLacYk+giAIgiAIgnBWOZcCBlpzf9s8MS2N12ryvNL4Lv9xP6qhvN8TzXlGxyjOqHs2r9zoToST+1sjrncbLDZ8gEmJ0tvrfd5/Y+nQfal7Lr1RRJLmE9HBtSFwdq/NsRXjIv5jngFYd21GUdUAVKw0fQZRxjjJ6I9Tri3WsW1jdM0zgA4yLPfyYGjX3Oc2oqpixN3NIXXPoRm4kz4kac4oSaf2n71/d9b6BJ4z6eusoCEJEc8Gx+UJs9d8vbNu5o/GCIBkGb1xglLwJVcX2R7FJtmma8LQXMdiqRGwHcakuWacZDRrbiFSxqz3YxYaDguBQ6vmMU5SoigjxXg3NXyHwLHIMTk1ysScVUGmnK+5BqU1YZKR5jm2MsLjYsPn1h5haPtdq4Q/CYIgCIIgCC8L51PAUIo4SRnGKXmusSzFzjDm8mL9WJ8+HvWJZuDaE++Ke5tDOjV3ZrvF1ih+pr60AwfHUgwjk9NjtenTDxM8x0JrTabhcS8k1Zrf+sxjxknG1cU6K5VSkM3AJaxUVlAKMq15x0XjmXKXIY6lsK1do3HWADrIsFxq+txZ6zNMssm9abg2N1dbU9ezPYqfSsC5X7WTWTHCd2zWd8a4tkWzqACR65yW50+Omb1/uc7ZHCX4cca1orrLPBd7SYh4+jyPJ0xV6NoaRWS5N5V/pR+mrPcjbi67uI5FmmnWxiHLLZfNoTl+EGZondMIHJIsx3dtkjyjE3g0A5vXngxY68estnzqvkOUZKRZzuubQ651FW3fZj0KWdsJebITMkoyGp7Ley630Wg+97hP3bXxPWuSC6OcrxuDiFbNp1HzeDKI2BwlrLZ9ao61r5Am4U+CIAiCIAjCy865/M82SnNs24Iy2aSGDGPAVnFtRZTmTzfwDOepVhyZ12b1qWnds8m1SbgZJsbobwYOYTLdhzDJaQbPph0tNX2SNCPJc7TWXFms41gWjq0YxSmb/ZBHvTFXF+ss1j2anssn7m2x3g/RWhMXYTeXFmr84YNtPvyZNR5uj3FsC0sptNYoTIhHVUiYNYCWmj5xakSQst04NWUnS7RSU/dGq+kx3B7FvHp3kyyDxbpHlsGrdzfZnhF1yrG9sz7gDx9sozV4jvEO6TY8Vts1BlHCOMlQCpaaAe3KuM7ev+1RTN2z0VB4mFgTg1E4W5QiUhl2ZCkO5Qkzux47gQnp2hknk/m63g+5uFBDWQqlFK5jobRiEGaMo5Q003SbLrmGtZ2QduBgK8U4yRinKWho+S7Xl+poTILOZs0hy0y+m0+/sc2vf3adz6712Rwk9MYpDd9hGCd84t4Wn3h9i9c3RqR5TrvIhREm2WS+xpnxsvIdm8udGistn2uLdZhZR7McZm0KgiAIgiAIwnnmXHpgjOKEmuuw1NztfpLn9MNpV+nnffp4mCeaB3lp3Fpp8erdTcB4XoRJzjBKeOVG95n7UxUGmoHDe68vQK6Jspztccz7bnQniUMXGh5RWuMP7m9xZaFOM3BYavh8YX1At+5zuVMjTHK2hhGdwMUvqpZsj2PWdkJyrbGUou47U27rB4VYbAwi2oHLcsVomo31v73ep+G71H1z/+aF1cx6XDzs5SRphFs8hV6oe4zjDMtSXC+8KWaNNd+x6IcpwyglznLWdyIWGy51b3feiIv92WXWE6acE/vlM5ldj62ay7Vug14YY1smh8Ri3aPm2TzeMcKVYykcRzEME1bbNZJcU7MtIz6mGaMo41rX50q3QytwSDJNmOXUbIXnOtzbHJLlUPdTHvczmgseNZ0TxYCtaPiuOSbRPOqNWKj7XGjbbAwTLCvEL0S5ye+NbbxCXEeR5nry/WFLPkv4kyAIgiAIgvCyci4FjLrr0EsTkizHscw/+S3fIUrySXjEcSRfPIwb+0Fx5wt1j1dudLm93mdrFNMMnKcSeB6GjUGEZ1sktlXkv7BY8B3qnjFafuszj1mstBmlGWGS4dk277zYJsk0H7+7SafhPSUcjJJ0UrmkN4pYH0RESYbv2lyaYzPtF2Kx13hsDWPKBKuvrQ+5vjR9/GxYzawh2vAcdsKEzz7q06m7eLaF6yi2+zGfebQzCUOpGmsN3+Gzj3Zo+C6Ba9q5vznkfRXxqB+m7IQxd9Z3c2KU55dSlGeHw1bY2CuJrGUpbq40CZOMRztjNkcxjqWIs4wkU3i2hVIWKM1Gf8yTQQRK8d4rHbp1n1sX2niORZhkbA1jwjgjBC55Dq5jcbXh88YWXF2Eyws1vrA+YpAkND2bzz3u0W34rLQ8RrFNlmU0fAdLwcPemJpjc3djyJ96+wphZLw1NgYhSWaRa81y4VlxmN8yCX8SBEEQBEEQXmbOpYDRrrm4tkmuN06KJ40Lxt18v0oXz1qRYq8nmsDkSfDWKDJGSa6nynnWKkbUQt17poSd89gJU3qjCN8pEpdmmo1BSFr3uYIx0nbGxtMgznL6YYKFolPzJgk5ozQnTqa9DarCwYOtEcM451KnNhGGhlHKg63RUzks9mKe18ogTAvxxiRYrfk29zdDri9b+EUS0tmwmllDtO7b3F7bwbZsLrR9dsYpn1/f4Xq3SeCa0J0HWyMC157c02GUstoOeNgLedBL8WyLds2jN0poBy79MOX+5pBr3cZUkk+tFO1KMlgpRXn6HKZsbphkbI0iHm3n2I7xVlLKFDxdavoTEaQTeCRphEKR5ybPxTBMeOtKk3sbI9IcVlo1bnRrRJnJVxF4Np5r0R+nZLlGa80b22OiNMO1LZMEN4pZrLk86ZtyqnXHIckyEg0oSHKouTaeqwgLsTXXJowKC+6sD3jP5Q7DKCWt+4zihJbrUvNsEdEEQRAEQRAEgXMqYJSeEd2GP+UZcXkfI/OwT3Bn2cuNvWxnHNt8/N4W17oNFooyqZuD4ZFCRPZjFCdYysItPBJcRzGINHc3BviOhW0pbq/t0G0GNHybnWFMnOW84+Ju+Een7tKPUi5OjcuucLDWj6h79qRUq2sr6p7NWj/aV8CoCkNozTjNJ2Vlk0yz3g9ZaQUTb4q3rbb4+N1NHm2HXOvuhrJcX25wZ91cD1pPhX/0xjGdugcowjRnJzRhREmWU/d80lyzOUoIKmLLzjihH6YsNX0utAPSXNMfJ4yKCjE7Ycy1bmNSVtZzFMMkA80kBEZKUR4/zyokwv5lc5eaGQ+2Rry+OcK1FeMkZ2cnxrEsVto+WQ5hbIS40qvHdSxTaSTMub814m0rLTZGEY96iquLdRxbMYhzxnFC4JnqPWv9iC+s9Vlu1bBtyHLN/Y0hnmtR9zy0hijLSfMM17HoNB3urid4rkU7cGl4Nhc6AVuDiO1xzFLdxXPNb9HFdkCU5gyj1FQ5OqF7IQiCIAiCIAjniXOZxDNwbRq+M0lG+YcPtmkUYRFl0sdqIk2YDkl4ngSOs+2kueZ6t2FCNtIcz7G42m0wjJ4u5zmvX4el7jrkWpNkJkHfIEpY24nwK4LMhYU6lgU7YUKj5vL2iy1yvdvG5YUaWaYZRSl5njOKUjZHMXXH5s76gPV++HTfNGit2YvZpImuY6OKfpbJFxcaPq2Kd0Wn5vGl1xfJdc7WKCbVOaudGk3fnSRC7YUpd9b6xGlO4FgMxym9UcL1bp0bSw00sNjwJgk5XduaiC0loyTFKraV+wSuTbPmcHOlyWLdfyqZap5r8pnrfd5ksMIus/NlHGe8eneTj7++xUfvbvDpB725a2TevbSUojeKub0+4I8e9dkJEwZRxuYgwrdtlKUYRqbijOfYfOrBDg+2RzzqjQG42Klxc7VJzbVpBg4KRbfh4hTC28445tJCneWWyQ3zhfUBNdcizlIeboU83gnRSmEpi7etNunWPR70xrQClwstk0i3WXO4vmDEu07d5+pinYvtgDjLCQuhb7XtYyuLumvLPBMEQRAEQRCEfTiXHhjbo5hPP+hNJaP8xOtbrHZqLDf9uR4WB+WqOCyz7URpTqfm4qc2N5YagDH4y3aP6vkxy2zYzCBMudAOjOGlFFrDatPHshSXFmqEScbD7RHDMEW3NUmmCVyb917t8NHXN9kYxHR8lxurDZo1D9dWLDV8E1KxpCalSUdJyuWFvT0P5iUxbdW8SdUIALZGU94Unm3R8B2+7EaXK4v1iUFbbSPNcjzHZidMeNBLifKclUbAKM7oFM1mmcavjuGM2FL3XHqjiCQ1VR1mS63OC3exrEoFlQIpRXl8VOdLmGRsDGPSXHN/c8hqu0YvTXBt66k1Mnsvh1HKk37I9jih6TtFKIZLrhU7YUKr5nJ9sc64EEKeDCLSPMe1LHINj3ohFzsBllI0i8ScvmPhew4Ny1Q4ynONUjAMU8LI5JRxbIc4NmsryXOGYcJi02NrZEJQlG3CtuI0Z7Vd4ytvLU08R1aaPuuDCM9zuLFY50K7RqfukmaaOMvoNnyZZ4IgCIIgCIKwD+fyv+VqFQvLsqj7DmkOD3ujPT0sSmO1Svn5WbwjZtvxHVNZxLN3h7Jq8B6X58dS00cp6DZ8rnfr1F0bxzZeCGU/UBBn5glu4NosNQN8z5p4QjR8hwfbY9620uaD71il2/Z53AsZxylKKa5067RrHrfX+nx+bYeHOyMavsvlhdqe/TpMqdmG73B/czjxpojTnPubw4nXzLw2wtjkzVhq+txaaXJjqcHWKGZrFKO1ZrHm0g9jap6N1pokzRklKRc6u31tBw5LzQClmFtqdV7ZyYZrU/cdKUX5gqje6+1RjOdYJFkORcUb37UZxulTa6R6L3ujmI1BRODZrPXGvPZkyCcf9HhtY0iuNc3AZb0fTSp4bI9iLKW4vFgnyXPQZo6u9UPiNOPWSos4zWh4DoFj0RvFDKOYwFO8vjHEs22W2j43lhqM4pSNfkSU57iWIs3BUoqNUcSTQcTldo13Xmjx/htdvvhKh4W6z2LDZ6nukWu43KnxwXes8jXvuTjxlgJNt+FjKWSeCYIgCIIgCMI+nEsBYxCmk6oSJUpBNCM+VA3pecbqTpgQxunEnT3XHChizLbT8ByGUULDdybt9scxUZpzZ33A6xtDsnzaLfwoIQllLo5JklLPYqkZTJ5QL9Q9RnGGgkk/LAVfdHmBmytN4+mwPZoSfhzLouW73N0YTc5T9xxagcvlhTorrQB/RliYZS9hqPokeRilXOs28F2LMM3xXYtrlTCbeW304xTfsSchA03fuNpHacYozrjYCXj7xQ6OpRjFKWmes9jwp8SWpeauUXi9W5/6PG9MLQU3V1vcWmlOfScJPI+P6r2OUlNFaBxl1IrxdSw1ETmqa6R67xq+Q7vmsjFISDKTiLZbd3htc8S9rSGerRjHxuOnU3MZhim5zrnQDrjYqaEUJFlOmuZcWayzUPcm80Ch0FqT5pCmOUuNgCtdE97UrrtYymIcZ7QDh0Sb5LnLTZ8wSnjUC7nWrT81p26tNLm52pqsw7IM8Jfd6PKWpQadujepJiTzTBAEQRAEQRD25lyGkDQDhzDJJ2VAAbRmOpyAaUN6XkWRmmPhzoQ/wP4JG2fbqXk2r9zoMiwSQ6I1uojRd22F41jc3xpxrduYGCdHDUmoJhQNkxpvbI0mZWMtpejWXQLP2bMKyyBMTZ6InXBSqaRePPEG80Q8cE0ozKVCCIjTfN/xOGyp2WbgTJJlwnSYzbw2HMsi8Kyp8A/XVtxYanJzpVmMwf7JIPeqIjNvnypHyVEiHI7qvTZCQwaKSWnf0mtido1U7+VOmEzmfSOweDKIqfsOLc8hjDOeZJp3XWhzuROQa/A9i3bgEbg2YeGJk2Ua35tegxp460qTd1xskWSa22t9LnUCwjQnzTROonjLUo04SWnUXPxxSrfuoTBiS7fhThIJS8lTQRAEQRAEQTh+zqWAcWulxat3NwHz9DVMchwLVjv1iWEzz5CeNRjurA+eCl3I8pz72+N9KyTMMzwW6iaU442t0ZQostoKuLc5Ym3HPJ2d1y84nhKvN1db+x7jOhb3N0NaNeMqn/sOd58MudSpobVmGKZYFiw2gt1jDsgTMq8fZYLVQZjSDBzqhSdFNdfEQeLS21aaZNp4b4yTDM82HifV/COHMQCf1Ug8rpwlwnyq99p3bEZxzI3lBoPQVIfJtWa58HKavW/Ve/m5R312xgmLjYA0G/O4HxInmkuLAe/u1vmKty1P7lcp9vXHCU8GEZZSWBa0A29yb+flcmn4DuvDmJbv4DkWyy2fJNNc6tTwXJubyy2yPGcQpviOxZdeXzhwjuy3zo9SnUUQBEEQBEEQ3kycSwFjoe7xyo0ut9f7bI1imoHDV9wyBst+T9tn8R2LQZgyjFOiNEdjjPhWzT2y8Tqb5DNwba4u1njUC/fs13GVeD2IxbrH/Y0haWZjWwoLRdt3WKy7k7CU8kl1yWG8Rar92B7FvHp3k4bvslj3CJOcu/0xF9KM5Vbt0OJSOSZLzelSuS86R8DGIEJr2BzuGpINz5EyqsdIea+vLO4a7bZl0RtGxEXZ3Wouk1mWmj4fCzdRSqG0BqVoBy5eQ5nSv4E7Vwy4vd4n0yaZ7WLDhF+VHkbzkvy2A4eP3t3ibautiVBacyzee32RYZSSpDlxBp26x43lOm9dbu7RY8N+6xwQ4UwQBEEQBEEQDuBcChhgRIz331h66vtnMTIbvsNnH+3Q8F0C1+L1zRGjOOPqYr1IuHlwSMks8ypb2JY1iY2fx7ynv8963sP1zeZdlzp86uEOO5sJ7ZrLe68t0Axcbq40nwpL2ctbZD9ur/exbYtBlLI5MslN655NlOrd/B2HEJcOE/7xItgZJ5OqETXXJs01TwYRnZrLlcUXeuo3JeV9Xkoy3rAVnmNP5t48A74UJixLkeQZj3oxrcBmudsgz3MCz2Gl5fPpBz2udhsTMWBjEFH3XK4suCi1uzZLD6PZdRsmGbefDPEcRS+MiVPbrJPVFraloAWPe2OUUqy2/EnoyH7st87N5xf/GyAIgiAIgiAI55lzK2AcB8Mo5WqRTDJMcyyluNatMU4yOsU+z1pq9TA5IWY5rhKvh2EnTHjnhfYkr8ROmNAMTG6K4xANNocJcZISuC6BY5Hl0B/HeK7zzIbYaeQIGCUpVpHDBIp7WFQ4EV4chxHxqh4MVxZrtGsun8p6+I6NUorFhs9q2ydJc/RMWV6A7fGYpu/MDWWqrtssz7m/NWYYJrxluYFj2cRZxmLDw3dMVZ+bK7u5WA7LQev8pH4DBEEQBEEQBOG88qYWMKI0pxWYigYAnm2R53qq+sG8EIr9YtWPIgLM89o4aqLPfdGaQZhyf3NEWJQ0Xah7JgNqwfOKBlmek2uFU+QWcWzIY/VUJZazSt1z6Y2iqeShuc5peVLe8kVyGBGvKnIsNnyiVHN1sYFtwYV2jTjLuNipcX9rRMN/uq266xCn2eRzVVysrts3eiG+Y3F9uYFj2xMxa2toyvqW67L6OwCYdaTU5Deh7HP5O4HW+67zE/kNEARBEARBEIRzzJtawNgvB4YujI1Z74nD5Kt4VhHgKF4bR2EnTNgeJeQUYg2wPUrYCZNjO8fFdsDttSHjJMO3FVFmSrpe6zaO7Rwvknbg4Fhq3+ShwvFzGBGvKnIErs3FTgDk3FkfstT0udAOsJRCAU3fnWo/yTTtmstS058SF8vPVTGyPE+U5jzqhQDYFvSjlFZqPImqvwOWgvtbI0BxdbFGruHOWh9d5OYofyfGaU6YZLRq3tx1fhK/AYIgCIIgCIJwnnlTCxizOTDCJCfONE3X3tN74kUkeTypfA+PdkIa/q7HCZicD492wmdqZz8PlJVWgGtbPOyF9MKUpu/wrkutSZWWs85S02ft4Q4PeyOiJMN3bS516lzriiH5IjmMiDcrOPqOxVIjYKUZ4LtGcHAVvOdyh41BNDeXy3Qp4mkR4sH2mM897uO5FqvNgFbN5WInYHsUMwhTbGXKCr96d5ONQcxCw+Nat872KKHhuaCgN0642KkxTDLQsFx4YniOETOSLN8zF8xp5HwRBEEQBEEQhPPECxMwlFI/DfxZYE1r/cXFd13gfwfeArwG/Hmt9daL6sP2KOb2en9SzvPWyrQhPZsDw3Msbq00qXt7e1C8qCSPJ5HvwbYsMpWSZhrbgiwHS2ls6/BG0kEeKEtNnzDJeOfF9olWD6n273lKUYZJxlpvjM4VvuOgc1jrjXnrckOMyRfIYUS8WcFxZ5zyucc7XOs2cIoQEd+xJvNwdu3P3r8yJCXXmsc7IZ5t0665jOOMe5tDrnUbNAOHbsPHtYw30cYwou465Gg2BxFaa5RSdApRcJyYEJU818xi1sPeiYZPI+eLIAiCIAiCIJwnXmSA9f8CfMPMd98P/IbW+u3AbxSfXwhlOc8sM+VDswxevbvJ9iie7FPmwLi0UOPGUoNLCzVagTOVA2OWapJHVbxbSp2LJI/dhkur5qEUhGmOUtCqeXQb7sEHF1TzEJhKLRaeY08qKZRGWPmU2VKc2JPkUlzJtUmImGvjlh8mh0+EeHu9z2LD58Zyg+tLDW4sN1hsGGNYeLGUc+fmSnPunCkFR8+x2AlTtscxC3WP9Z2QLDPeD+M44/b6gAdbI1ZbNd55sc1qq8bGIHpqHkSFh8bWMMazbVzHwrUtXMfiardBL4wnczjwHNIsp+G5eK6pSOK5NuM4Z5wYUTDNd0NeLEthVaqdgOS0EARBEARBEITn5YX9N621/mfA5szXfw74meLvnwG++UWd//Z6n4bvUvcdLMui7js0fHfKEC3j7qscZGTUPZdc50WlA02S5uQ6p+4dXgQ4LW6ttMiynKbvcLkT0PQdsizn1krr0G2URl8V11ZTos9Bhijsig131gfPLDLsxUHiymEYhCmBO33/A9eELginSyk4LjY8wiRDYxJrxrmm7jv4rs0wThlFKcMkO3AelOs/zvJJ0tlShGgFDot1fzKHAXKtJ/t1ai55bryLAttiGCcMo5ROzSVOcxquTd13iIvfiTjNT9QTSRAEQRAEQRBeRk76ceAFrfVDgOJ99agNHWQAH8YQXWr6xGn2TEZGO3BYagYoZdzFlYKlZkA7OPvpRBbqHq/c6GLbsDWKsW149+UOwyg9tJBwFNFnluPwlJjHYcSVg2gGDmEyvX+Y5DTPwf192SlzYDzqhURJTtOzGUUZvVHM/a0Rj3pj7m+NCZPsqRCOefOgXP8KSNKcJMuJ05yaa3Nva8Tj3ngyL33HeFqlxdz3HZtu08OyFY5tcXmhzuVOQK7BUnBztcWtleapeCIJgiAIgiAIwsvKmbXKlFLfDXw3wPXr16e2HaYSSGmI1n2rcty0IXqU5JlLTZ9wa8RS0z+VHA/Py0Ld4/03loDDjeMsx1ExpeopAUwqTzxPIlQ4nnK0t1ZavHrXOA6ViV2HUcIrN7pH7tdZY7+1dZZZavq8encT27KoFVVCNBBnmt44Zqnhk2nNk0HMSnt6Pc6bB+X6V0rx+saQRuCwUHNY60eA5upifSKuLTV96r7D1jCirh1QkGaat3Tr3Fx9Or9GieS0EARBEARBEITj46Q9MB4rpS4BFO9re+2otf4prfUHtNYfWFlZmdp2mFCBWysthlHCKErJ89y4lUfJU+EShwl3mLf/y/Bk9SghF8dx/cfhKTGPo3jUzDLPS+WVG91zU0XlMOy3ts4ygWuz0DDCoedYpHlOu+YQ2IowMve9E7i0aw5pkh9qHgSuzc2VJl95a5nLnRpbowTfsbjWbVDznMmaGEYpt1aaXF6oExVz7HIn2Fe8EARBEARBEATheDlpD4xfAv4d4IeL9188SiNRmlP3po0G11aM4t0QhNIQvb3eZ2sU0wycYzNEz3O1gGqVjse9MZcWalR1rNlxnMdRrr963q1RRJZ7U+VcjyPB4XGVo616qQhni3bgmBwujkWYZHzyjR45xhuiHTgErs3FTsA42btc6TzKubMTpoRxWlQlsaj7NsMwZSdMALi8UOPmSvOErlYQBEEQBEEQhCovsozqzwMfApaVUveBH8QIF/9AKfVdwOvAtx6l7cOGCoghOs1syIjjWNzfGnGtu1sidN44Hkdp0up589zj3uaQq90GrcA5UhjKXpxncUk4mGoIk+9YrLZ9osSZmsNxmtMOrCOJbNvDaBKiYnLD9FluBSZpZyWcZBilR14PgiAIgiAIgiAcjRcmYGitv32PTV/zvG0fRx6G5+F5DfrjauNZmc09sdoKuLc5Ym0n5Fq3Pnccj5InY/baoiSbOm+r5nKtKFNpW+rInhKnMYbC6TLrZbNU9xinOZZSpirQc/wWbAwi2jWX1zaG5BrCOCXT8NqTITdXGigV4ViKTz3oca3bmKyH2+sDao4FSk3NQ5mfgiAIgiAIgnC8nNkknvsRuDZLTZ/b630GYUozcLi1cjKx6Ecx6F9EG0dhNvQmcG2uLtZ41Av3dLV/1oSbYZJxe31gco9ojaUUW8OYd1xsUQ1VaQYOlqWO7I6/1xjK0/GXn6qXTZhkPNga8cbWCK01Fzq1I6+jnXFCP0xZavqMooz7WyPGccaVhRqdmscwTvncox0cW1H3HOqezdY45vUnQxqBy3sutae8NMq1c5JrXBAEQRAEQRBeZk46ieexUD7ZXG3VeOfFNqutGhuD6LnLcB6GoyS+fBFtHIV5JVBty+Jad+8kps+acPPB9pitYYRjWdQ9B8eyGMUpD7bGU/s9b86LeWOoNXzqQe/Yy7MKZ5NSxHIdm7csN7jabaC1PvjAPRglKZZSNH2X1XbActOnW/ewlCLOcraGCXFqRLky/8ZaL2Sh5pHlmsc7EbnWeI7N7fX+qaxxQRAEQRAEQXiZOZcCxmkJAHA8FTReVBWOgzhKlY55osd+4sPj3pi66+AW98Z1LFbbAQ974+eqDjLLvDEcRAkaxGh8k3DcvwN1zyXXOUkxT22lyPIMy1b0RjEKM7dcx2YUZ9Q9h36YoSxFwzcVS7ZHMa6tGITpqaxxQRAEQRAEQXiZOZcCxmkJAPDsBv2LauMolKE3a/0xn3m0w1p/fGCIxbOKHkopmL41BK7Ncis41tKz88ZwFGXU3aer04jR+HJy3L8D7cBhqRmgFIyTjFbgcmO5STtw2AkTNJqGb7M9TLi/NQJykixjHGd0ai6OZc6dZJpmkZy2ykmscUEQBEEQBEF4mTmXOTAOW4XkKEn0DjrmOBKIzmvjySBinKR8fq0/yelxHCVf513baqvGlQVz3o1BRODae47Ls5YmXW35POiFKKVwLEWaa0ZxxrXF2rEmWZ03hkpBM3Cn9hOj8eXm3ubIhy6MEgAAFDZJREFUeN3YFosNE+7hFyVWNwYRO2HKKE6ouw7tmvvUeq6ud7QmznKWmr7xoqink2o5m8PIhKvYNu+8VOPexojXngy5uFBjoeZgoUiyHKUgTjNurbQmniCnkWhYEARBEARBEF5GzqVldxivgDI+/lnyIRzmmNKgfx5vgtk2BlHCWm+MoywW6x5ZBq/e3WR7FB9tgPbgRYXelON2Z30AStHwLNI8ZxSnpHlOt+5y+ZgNt3n34d2XO1iKYw1VEc4mYZIRxiZZq2Mp8lxzb3PITpjQ8B3e2BoxijN6o4gsg944YRxnU+t5dr27jo3SmiTLGcUZNc/mlRtd6p5NGGdYymKl7dMOXC4v1gCLLNN4rs32MOQL60NGYYpS6lh+JwRBEARBEARBmOZcemAcxivgWatnPMsx1SoIz3sNAB+9u8Fiw6fum9tR9835b6/3ef+Npec6T5XZKiRgng6P4oNFnb2qKczb7rkOnTllJY+befchcO1De4sI55eNQUSr5tEIXLZHsfGYcm1qjsUwSifCnO+YfCxJljOMU7oNf7Ke5633Vs2biA0lC3WPKM25sWyEkN44Zmec8O5LLfpRyijO2BjFvOtSh+WmP7VGxONCEARBEARBEI6PcylgwMEiwlGM9aMccxwMwpTFmXCRwLXYOmYPjMOG3lQ5SNSZt70duE8ZgSfFcYhLwtmnXKtKWVzs1ADQ2oQrldviLKdWiFeOpRgn2dR6fpb17jsWuYaLnRpaQ8NzQcFCw6zbhueQZrrwbDpYLBUEQRAEQRAE4dk5lyEkh+EoiTJPK7lmM3AIk+nEg2GS0wyOV186ShWSeYkSszzn9Y0hd9YHvL4xJMun+y6JM8831ZCgs1qGdr+1OhHqbIu02CfN9eT7cj0/y3qvrp0ozdCY9VN6ZwSuRZztznlZA4IgCIIgCIJw/Ly0AsZRjPWjHHMc3FppMYwSRlFKnueMopRhlHBrpXWs5zlKXP6skRcmGfe3RjiORd2zcRyL+zNGriTOPL8cJXfMabDfWi23NXyHKE0ZRSlRktHwnKn1/Czrvbp28lyTac3FTkDg2kXS0BzP3p3zsgYEQRAEQRAE4fh5af/DPoqxflqJ9xbqHq/c6GLbsDWKsW145Ub32KuQwO413lxpHuraZo28tZ0QUKy2ApQy76BY2wklceZLwItK9Hrc7LdWy211z6ZT97Ft6NRcap49Neefdb2X+79yo0u3biqeaK1peA7DyCQPlTUgCIIgCIIgCC+Oc5sD4zAcJR/CaeVQWKh7x5qw87iYTZia5Zqri7UpI/DqYo1HvXCSOHOp6T9z+VrhbHBaeWCOwn5rtdx25ZBtlOVUH2yPD5yzs2uirFYyLBJ6SvJYQRAEQRAEQXgxvNQChnA8VA3FMplhFduyuNatTwzB/aqWCGeboyR6Pe8cZc7OE09ehMeUIAiCIAiCIAi7vLxWifBCOChvwHkJQRDmc1p5YE4TmbOCIAiCIAiCcD4QD4xjoHQ/fzOETMy6z8+6y7/IEIQ30zifFgfd37PKvLkBHGq+nKewGUEQBEEQBEF4MyMCxnPyZgyZ2C/3wIsKQXgzjvNpcVp5YI7KvLlxZ62PVop24B44X96MYTOCIAiCIAiCcB6R/9CfE3E/n+ZFhSDIOAt7MW9uDJOMUZQear68GcNmBEEQBEEQBOE8IgLGcxKlOa6tpr5zbUWU5qfUo9PlRZWilXEW9mLe3MhzTa6ns83uNV9Oq3yyIAiCIAiCIAjPhoSQPCfifv40LyIEQcZZ2It5c8OyFMxUy9lvvpy3sBlBEARBEARBeDMi1t9zIu7nJ4OMs7AX8+ZGw7Wp+47MF0EQBEEQBEF4iRAB4zkR9/OTQcZZ2It5c+PmaotbK02ZL4IgCIIgCILwEiEhJMeAuJ+fDDLOwl7sNTdkvgiCIAiCIAjCy4N4YAiCIAiCIAiCIAiCcOYRAUMQBEEQBEEQBEEQhDOPCBiCIAiCIAiCIAiCIJx5RMAQBEEQBEEQBEEQBOHMIwKGIAiCIAiCIAiCIAhnHqW1Pu0+HIhSah24u8fmZeDJAd8d9PmkjpHznt1jDtNGlRta65U9tp0bDlhb+7Hf2JwVpI/Hx0n286VYW4IgCIIgCMLxcy4EjP1QSn1Ea/2B/b476PNJHSPnPbvHHKYNYZfzMDbSx+PjvPRTEARBEARBeLmREBJBEARBEARBEARBEM48ImAIgiAIgiAIgiAIgnDmeRkEjJ86xHcHfT6pY+S8Z/eYw7Qh7HIexkb6eHycl34KgiAIgiAILzHnPgeGIAiCIAiCIAiCIAgvPy+DB4YgCIIgCIIgCIIgCC85L0zAUEotKaU+XrweKaXeqHz25uyfFdv+UCn1CaXU9yqlrD32+aRS6h8qpX6v+C5TSm0ppSKl1BeUUlop9enK/j+klPr3K+38fvH6M0qpXvHd+5RSf6ZynodKqZFSKlVKrRdtjorX60qpteL1u0qpb5np52DO9emij59QSn1MKfVVRVtaKdVTSv214nOmlPqZos/fp5T6HqXU362086HiGF3smyulQqVUXPw9rmzLKuM+LvYrx+SblVKvKaU+p5TaVEr9TaXUH1NKbSulbhdtxEXfYqXUXaVUopT6SNGPtxTfLyulvqXY/4eVUr+slPqoUqpffLeulHqslLpf9G9bKTUs2vodpdQ3KaV+rBjTO8Wxrxdtxkqpry3O97jo1/WZ+TAsridWSv3jYp9PKaV+RSn1DrXHvCrvUXEdnyzf59y3dyqlPly08Wml1JvGlV4p9Q1Kqc8opT6vlPr+OduVUurHi+1/oJT6slPo4zWl1G8W9+YPlVL/8Zx9PlTM4/L356+fQj9fU0r9i+L8H5mz/VTHspjnH6+8dpRS3zOzz6mPoyAIgiAIgvDmxnlRDWutN4D3ASilfggYaK1/ZJ9Dxlrr9ymlHKAL/BzQAX6wug/wAa11qpT6WeAfAF8M1IC/CnwB+AHgAvDdwK8Wbd4Efgn4u0Xf/phS6sOADdwr2n4f8AHgV4AQWAB6gAbqwKg4x38CPAD+XrH/3wK+qeygUkoV747WOi3+tovNrwF/Avhq4O8APpADKfCfYQSlPwL+BdAsjvk24K+UbRbfZUUfPwL8H8W1rgKbxXjsAB8DtoF/BvxO5Xw3gK8Fvh24BPx7wHcBfx74emAIfFFxvRnw08D3A98J/EdAwNN8O/DPgYvF53dg7pVbXM8bwAeL6+wV+2jgLvB/F+P6w8D/ACigD1wDYq31ryulvgYzJ/5VrfXrlfOOtdbNYszHwK9prb+hGKv3Ff2pzplVdufVLPbsF8V4//fA39Za/2Lx3XvnHPvSUczZvwP8y8B94PeVUr+ktf5UZbd/BXh78foKzP37ihPuagr8p1rrjymlWsBHlVK/NtNPgN/WWv/ZE+7bLH9aa/1kj22nOpZa68+w+3ttY9bsL8zZ9SyMoyAIgiAIgvAm5URyYJQCBvCbwI9ijPMnwHdqrR8WYsKfAH4XIzR8I3AH+LeBz2OEiu8CrmCM3i/GGO/vwBjCCmOo1zCiggXEgIcxYGtFVzSwhTGGwRg/NhAx3zCfZQMjbOTFcVbRpsYY3XWM0V6eKy9euuiLBj4J3Cr23Yu8aDurvM+KTXGxX9WbxcKMywdm9l0Dlnna4+YeRiz5INCofP+LwJ8r+ltSCgseRggpx73s7zqwMucczOz7rKwV7c4en7A71msYAadKjhFhmjPfx0UfbXbvIxiDbQcj6qjiuAeYufINwM9g5l8CvIoRut6JmatdjKC0ATzG3KsacLP47neLY74ReDfwccw4LgDfpbX+baXUFwH/c/G9BfxrWuvPHWJ8XghKqT8O/JDW+uuLz38VQGv9Nyv7/I/Ah7XWP198/gzwIa31w1PoctmnXwR+Qmv9a5XvPgR832ka3kqp1zBC2lwB4yyNpVLq64Af1Fr/yZnvP8Qpj6MgCIIgCILw5uYkc2AozNPsf11r/X7Mk/2/Ud2utf6g1vq/LT6vY0SPn8U8+bcwBqkDtIDbGGNUFa+vwngOvFEcX4ZxvA78vxjD8yHTQsVPFu+9YvsfYLwkStLivV+8dzEGb1Kcc73YP8Y81bfZNfo/z66h/HuVMXgvu6JDXjlXhvEOWK98V7Y1LK4nq2z3imuxild5vWVfx5gxynhaWEiLNi8BX1f08TFGyMmBP8206PCZ4t2p9L0cm62i7VIUiirXVl6frryHlX5ElW1ln8rPP1q8l8JEjhERyjbLewdm7LPK5/+t6FPZxxx4P0agcGf6E2PmzFax3yeBj2JEkRT4D4F/jBnDv44R2r6yeF/CCD9/ESNUNICR1vp9RVsPME/Rh8C3Al+OEZguAd8HfA+7HkZ/CfjvimM/gPF6OE2usOudBKY/V46wz4mhlHoL8Apmvc/yx4sQol8txKKTRgP/tAiR+u4528/SWH4b8PN7bDvtcRQEQRAEQRDexJykgOFjPCd+TSn1ceA/B65Wticz+/8SxoD+NMbA/CcYg30B+DAmxMCt7P/PMWEdK5XzgfF0+ECx70WmPR/+jeIcC8X2d2FCLEoDtxyf1kzfSo+OFeCtlXNpdo3mS8U1JRjDu7zGmGlju/TUsDBGbtVTwsGINi7GI8CuXB9FO+OijfKYr6r08VZxjMKEk5SUHgJOsd3GCAV+0c6s18LbKm2WokbpudAo+q8wISxVj5DS+6T0VFFMC0ilJwfFtnql/b9cvEeV/b+t8vd3VP7OiuPKtkrX+0fFu4URJdrFfm7x7hTbltkVfm5iRCYfcw9/FfgRjMfQXwN+vzj27RjRJ9Za/zRGyPowcLMIVbmJ8a64i7lH78B4YXygaPvtRZ/eUpz3d4EfUEr9FeCG1nrM6TLPY2bWXesw+5wISqkm8H8C36O13pnZ/DHMmH4pRkT9RyfcPYA/qbX+MkyoyH+glPrqme1nYiyVyU/0TcA/nLP5LIyjIAiCIAiC8CbmpD0w/lBr/b7i9V6t9dfts/8yxjDdYPfp/BjzBPvnMcLGmF0DN8UY927xdxkDX8O4+48x/5SX4sEYk3shwzxtLymfvFOcO8EY5rryyjAG78eLv0tDYxOT8wGMh0ApEJRERdtlOEh1/BVGrPgjpskxhv1rGO+L0huiFAQ+W7yXokp5/GeB/7I4Z4bxPiiP+0czbZRjptnN+1Fuf8LuGJffZzPXbRXX1GHXQ6L0DGHm2H7lc1zpV9XbRWPud3n9qmjrw5X9Pszuvfy+4v1xcexvVo6l6P8vY55wR+x6eowwXi+fx3hALBRj8ZOYOfYYI7i8o9h3udg3Yv+187cx+Tl+vfisgMeFd8VHgG/WWv99KqFBWuufwxiOY+CfKKX+pX3aPwnuY0TCkqsYj5Jn3eeFo5RyMeLFz2qt/6/Z7VrrHa31oPj7VwBXKbV8kn3UWj8o3tcwuSW+fGaXMzGWGIHlY1rrx7MbzsI4CoIgCIIgCG9uTlLAiICVIrYepZS7jwuyixEXfmKP7U2mRQeAyxjD1GLaoAcjdljAN7Pr6eFjwh4U5sl8hjF4L7ArOnSK40rPgNLgTzGeB6vsejiU/Vos/v4Eu/kWSs+BoHiVfcgrx2ZFmxd5+smrLq6vza43BJVrpdLndvH+VuBLiutMK9sVRugZFn+XRtJDjPHcZjdERrEr1pTHlv1xis+/VXxOiuPTyj6qckw518oQElX0qcy94VX2rXpqbFfG4yNMe35Ylb/Ld4XJnQK73ioeJuzjJ4vx+FixX47xlAATpmSzm1vkCsYb54MYT45VzD24VJzn9eI7Vyn1HZV9x0Xf7yqlSm8Yv9iv9GxZKbw0JhSJZu9orX8c4330JZwuvw+8XSn11uKp/Ldh+lXll4DvKCpofCXQO+mcDUUC178PfFpr/aN77HOxklz3yzHzZuME+9goEoyilGpgwrZmK96c+lgWfDt7hI+c9jgKgiAIgiAIwkkn8fx14McxwoAD/JjW+u8VSTy/CpNQ0sUYg/8T8L2Yih0/hgkR+U6MEftfAf815ilmaSSn7IZiOOydOLLqAVHuH7MbVrAfpXFeFS3AiAENdkMZqiETOUa8qSYSrYZ8VMMsZs+fY8SDGJNvYVZwmneNDzFGdpVecf4yvCNiV4B4hLkfjUp7+yXdTDDjEFT2Wa/0sRQe9mpj9vsh06Ejs324V1yPPfN9ee/AeKW8jV1xo5zUn6CorFChzE1xhV0BSWE8NN7OrhBW5vb4HeBDwHXMmG0X5/lbxTm/ESNalUk868W7xjxF38LM2d8D/gJGWLoDfAvmvnxEa/2WIknmv4UZ30fAv6m13pwzfieGMmWFfwxzvT+ttf4bSqm/BKC1/snCmP0JTJLTEfDvaq2fKhH6gvv4p4Dfxvx2lB43P4C5X2U//zKm2k6KEZi+V2v9/5xgH2+yW9HDAX7ujI5lHbPebmqty/LS1T6e6jgKgiAIgiAIwokIGGcJpdQSxkX6ximc28I8/f/W46wwoZT6ZUypz984pva+D+horf+LZzyuqbUeFOVHfwGTqPV/1Vo3Z/b7QNHfryo+7zkuRV+6wH+jte4ppb4e87T6htb6ETPMG4vjGJ/KtdUxFW++uyjdOff7o55HEARBEARBEARBmM9sac6XGqXUZUzuhB85hXO/B/OU/xeOS7xQSi0A/x/wiWMUL34Bk/zzKDkYfkgp9bUYL4x/ypwkf0qp78c8xf0Lxec9x6XSl78I3C+EEYAfnhUv5o3FMY/PTxV9DYCfqYgUe30vCIIgCIIgCIIgHCNvOg8MQRAEQRAEQRAEQRDOHyeZxFMQBEEQBEEQBEEQBOFIiIAhCIIgCIIgCIIgCMKZRwQMQRAEQRAEQRAEQRDOPCJgCIIgCIIgCIIgCIJw5hEBQxAEQRAEQRAEQRCEM48IGIIgCIIgCIIgCIIgnHn+fzB+7K+p6a/6AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_y_vs_X(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATrandom_num1random_num2random_catgenuine_num
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.980.4967141Terminator4.577098
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.14-0.1382640Dracula4.654383
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.030.6476892Platist5.338755
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.941.5230300Bejita7.066230
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.33-0.2341530Excel6.775308
\n", + "
" + ], + "text/plain": [ + " CRIM ZN INDUS CHAS NOX RM AGE DIS RAD TAX PTRATIO \\\n", + "0 0.00632 18.0 2.31 0.0 0.538 6.575 65.2 4.0900 1.0 296.0 15.3 \n", + "1 0.02731 0.0 7.07 0.0 0.469 6.421 78.9 4.9671 2.0 242.0 17.8 \n", + "2 0.02729 0.0 7.07 0.0 0.469 7.185 61.1 4.9671 2.0 242.0 17.8 \n", + "3 0.03237 0.0 2.18 0.0 0.458 6.998 45.8 6.0622 3.0 222.0 18.7 \n", + "4 0.06905 0.0 2.18 0.0 0.458 7.147 54.2 6.0622 3.0 222.0 18.7 \n", + "\n", + " B LSTAT random_num1 random_num2 random_cat genuine_num \n", + "0 396.90 4.98 0.496714 1 Terminator 4.577098 \n", + "1 396.90 9.14 -0.138264 0 Dracula 4.654383 \n", + "2 392.83 4.03 0.647689 2 Platist 5.338755 \n", + "3 394.63 2.94 1.523030 0 Bejita 7.066230 \n", + "4 396.90 5.33 -0.234153 0 Excel 6.775308 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchamarking against classical permutation importance" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = XGBRegressor(random_state=42, n_estimators=20, eval_metric='logloss')\n", + "\n", + "obj_feat = list(set(list(X.columns)) - set(list(X.select_dtypes(include=[np.number]))))\n", + "X[obj_feat] = X[obj_feat].astype('str').astype('category')\n", + "for col in obj_feat:\n", + " X[col] = X[col].cat.codes\n", + "\n", + "model.fit(X, y, verbose=0)\n", + "\n", + "result = permutation_importance(model, X, y, n_repeats=10, random_state=42, n_jobs=2)\n", + "sorted_idx = result.importances_mean.argsort()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.boxplot(result.importances[sorted_idx].T, vert=False, labels=X.columns[sorted_idx])\n", + "ax.set_title(\"Permutation Importances (test set)\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# XGBoost \n", + "\n", + "Let's use the same model for all the examples" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "model = XGBRegressor(random_state=42, n_estimators=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boruta (vanilla)\n", + "\n", + "the original form, with gini/impurity feature importance " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 90%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 9/10 [00:01<00:00, 8.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using native var. imp.\n", + "\n", + "Iteration: \t10 / 10\n", + "Confirmed: \t10\n", + "Tentative: \t2\n", + "Rejected: \t1\n", + "All relevant predictors selected in 00:00:01.06\n", + "['CRIM', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'genuine_num']\n", + "Wall time: 1.2 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "feat_selector = BorutaPy(model, verbose= 1, n_estimators=50, max_iter= 10, random_state=42, importance='native')\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + "
predictorBorutaBoruta_weak_incl
0CRIM11
1ZN00
2INDUS01
3CHAS01
4NOX11
5RM11
6AGE11
7DIS11
8RAD00
9TAX11
10PTRATIO11
11B11
12LSTAT11
13random_num100
14random_num200
15random_cat00
16genuine_num11
\n", + "
" + ], + "text/plain": [ + " predictor Boruta Boruta_weak_incl\n", + "0 CRIM 1 1\n", + "1 ZN 0 0\n", + "2 INDUS 0 1\n", + "3 CHAS 0 1\n", + "4 NOX 1 1\n", + "5 RM 1 1\n", + "6 AGE 1 1\n", + "7 DIS 1 1\n", + "8 RAD 0 0\n", + "9 TAX 1 1\n", + "10 PTRATIO 1 1\n", + "11 B 1 1\n", + "12 LSTAT 1 1\n", + "13 random_num1 0 0\n", + "14 random_num2 0 0\n", + "15 random_cat 0 0\n", + "16 genuine_num 1 1" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat_selector.tag_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boruta with permutation importance\n", + "\n", + "Not the original form, same process but using permutation importance instead of the gini/impurity one. IQR is small." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 90%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 9/10 [00:06<00:00, 1.35it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using pimp var. imp.\n", + "\n", + "Iteration: \t10 / 10\n", + "Confirmed: \t10\n", + "Tentative: \t1\n", + "Rejected: \t3\n", + "All relevant predictors selected in 00:00:06.67\n", + "['CRIM', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'genuine_num']\n", + "Wall time: 6.81 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "model = XGBRegressor(random_state=42, n_estimators=100)\n", + "\n", + "feat_selector = BorutaPy(model, verbose= 1, max_iter= 10, n_estimators=50, random_state=42, importance='pimp')\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boruta with SHAP\n", + "\n", + "Not the original form, same process but using SHAP importance instead of the gini/impurity one. Using CatBoost `get_feature_importance` to compute SHAP importance seems much slower than using `shap.TreeExplainer`, as in [the ARFS package](https://github.com/ThomasBury/arfs/blob/main/examples/Regression.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Boruta iteration: 90%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 9/10 [00:01<00:00, 6.08it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Boruta finished running using shap var. imp.\n", + "\n", + "Iteration: \t10 / 10\n", + "Confirmed: \t9\n", + "Tentative: \t3\n", + "Rejected: \t4\n", + "All relevant predictors selected in 00:00:01.49\n", + "['CRIM', 'NOX', 'RM', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'genuine_num']\n", + "Wall time: 1.63 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "\n", + "model = XGBRegressor(random_state=42, n_estimators=100)\n", + "\n", + "feat_selector = BorutaPy(model, verbose= 1, max_iter= 10, n_estimators=50, random_state=42, importance='shap', TreeExplainer=TreeExplainer)\n", + "feat_selector.fit(X, y, sample_weight=None)\n", + "print(feat_selector.support_names_)\n", + "fig = feat_selector.plot_importance(n_feat_per_inch=5)\n", + "\n", + "# highlight synthetic random and genuine variables\n", + "fig = highlight_tick(figure=fig, str_match='random')\n", + "fig = highlight_tick(figure=fig, str_match='genuine', color='green')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "boruta", + "language": "python", + "name": "boruta" + }, + "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.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/boruta/examples/catboost_info/catboost_training.json b/boruta/examples/catboost_info/catboost_training.json new file mode 100644 index 0000000..9050030 --- /dev/null +++ b/boruta/examples/catboost_info/catboost_training.json @@ -0,0 +1,1004 @@ +{ +"meta":{"test_sets":[],"test_metrics":[],"learn_metrics":[{"best_value":"Min","name":"RMSE"}],"launch_mode":"Train","parameters":"","iteration_count":1000,"learn_sets":["learn"],"name":"experiment"}, +"iterations":[ +{"learn":[9.306297515],"iteration":0,"passed_time":0.02175441189,"remaining_time":21.73265748}, +{"learn":[9.21580425],"iteration":1,"passed_time":0.03670976468,"remaining_time":18.31817257}, +{"learn":[9.12533741],"iteration":2,"passed_time":0.0640321481,"remaining_time":21.28001722}, +{"learn":[9.046805853],"iteration":3,"passed_time":0.09688891967,"remaining_time":24.125341}, +{"learn":[8.96821819],"iteration":4,"passed_time":0.1319625882,"remaining_time":26.26055504}, +{"learn":[8.898438591],"iteration":5,"passed_time":0.1575553113,"remaining_time":26.10166324}, +{"learn":[8.81479703],"iteration":6,"passed_time":0.1903686406,"remaining_time":27.00515145}, +{"learn":[8.762090798],"iteration":7,"passed_time":0.2167618535,"remaining_time":26.87846983}, +{"learn":[8.683687727],"iteration":8,"passed_time":0.2526381522,"remaining_time":27.81826765}, +{"learn":[8.618491334],"iteration":9,"passed_time":0.2796298236,"remaining_time":27.68335253}, +{"learn":[8.539419964],"iteration":10,"passed_time":0.3206890021,"remaining_time":28.83285664}, +{"learn":[8.486822402],"iteration":11,"passed_time":0.3481923493,"remaining_time":28.66783676}, +{"learn":[8.428148864],"iteration":12,"passed_time":0.3733007413,"remaining_time":28.3421409}, +{"learn":[8.384020819],"iteration":13,"passed_time":0.418767993,"remaining_time":29.4932315}, +{"learn":[8.342972216],"iteration":14,"passed_time":0.4447023947,"remaining_time":29.20212392}, +{"learn":[8.289024716],"iteration":15,"passed_time":0.4724289495,"remaining_time":29.0543804}, +{"learn":[8.235986159],"iteration":16,"passed_time":0.4978356387,"remaining_time":28.7866137}, +{"learn":[8.180603523],"iteration":17,"passed_time":0.5255050563,"remaining_time":28.66922029}, +{"learn":[8.131127119],"iteration":18,"passed_time":0.5517508663,"remaining_time":28.48776841}, +{"learn":[8.093087148],"iteration":19,"passed_time":0.5808219509,"remaining_time":28.46027559}, +{"learn":[8.052593873],"iteration":20,"passed_time":0.6074585601,"remaining_time":28.31913954}, +{"learn":[8.006721596],"iteration":21,"passed_time":0.6344271643,"remaining_time":28.20317121}, +{"learn":[7.971430834],"iteration":22,"passed_time":0.6616080929,"remaining_time":28.10396117}, +{"learn":[7.929157099],"iteration":23,"passed_time":0.6959497745,"remaining_time":28.3019575}, +{"learn":[7.900634096],"iteration":24,"passed_time":0.7108917502,"remaining_time":27.72477826}, +{"learn":[7.861003776],"iteration":25,"passed_time":0.7377625325,"remaining_time":27.63771949}, +{"learn":[7.826563928],"iteration":26,"passed_time":0.7649025327,"remaining_time":27.5648209}, +{"learn":[7.789488461],"iteration":27,"passed_time":0.7915779762,"remaining_time":27.47906403}, +{"learn":[7.749706084],"iteration":28,"passed_time":0.8183203227,"remaining_time":27.39962184}, +{"learn":[7.719616281],"iteration":29,"passed_time":0.8438109889,"remaining_time":27.28322198}, +{"learn":[7.674626622],"iteration":30,"passed_time":0.8729625098,"remaining_time":27.28711845}, +{"learn":[7.651647678],"iteration":31,"passed_time":0.9039938029,"remaining_time":27.34581254}, +{"learn":[7.617526004],"iteration":32,"passed_time":0.9319976677,"remaining_time":27.3103559}, +{"learn":[7.574388178],"iteration":33,"passed_time":0.9599734258,"remaining_time":27.2745391}, +{"learn":[7.538184566],"iteration":34,"passed_time":0.9917395646,"remaining_time":27.34367657}, +{"learn":[7.510672056],"iteration":35,"passed_time":1.02239661,"remaining_time":27.37750922}, +{"learn":[7.484848616],"iteration":36,"passed_time":1.065086416,"remaining_time":27.72103292}, +{"learn":[7.443014706],"iteration":37,"passed_time":1.095127531,"remaining_time":27.72401803}, +{"learn":[7.418462339],"iteration":38,"passed_time":1.140084141,"remaining_time":28.09284255}, +{"learn":[7.376998707],"iteration":39,"passed_time":1.165610012,"remaining_time":27.9746403}, +{"learn":[7.353447121],"iteration":40,"passed_time":1.192782591,"remaining_time":27.89947573}, +{"learn":[7.321153483],"iteration":41,"passed_time":1.223854348,"remaining_time":27.91553489}, +{"learn":[7.287449358],"iteration":42,"passed_time":1.250112815,"remaining_time":27.82227824}, +{"learn":[7.251488693],"iteration":43,"passed_time":1.27890457,"remaining_time":27.78710839}, +{"learn":[7.2383362],"iteration":44,"passed_time":1.308905199,"remaining_time":27.77787701}, +{"learn":[7.216234343],"iteration":45,"passed_time":1.336205317,"remaining_time":27.71173636}, +{"learn":[7.198404554],"iteration":46,"passed_time":1.364208267,"remaining_time":27.66149954}, +{"learn":[7.177252198],"iteration":47,"passed_time":1.391118813,"remaining_time":27.59052313}, +{"learn":[7.164703518],"iteration":48,"passed_time":1.418654792,"remaining_time":27.53348382}, +{"learn":[7.1521049],"iteration":49,"passed_time":1.445170422,"remaining_time":27.45823802}, +{"learn":[7.127862402],"iteration":50,"passed_time":1.471139186,"remaining_time":27.37472721}, +{"learn":[7.107018264],"iteration":51,"passed_time":1.496985407,"remaining_time":27.29119549}, +{"learn":[7.094865795],"iteration":52,"passed_time":1.518199014,"remaining_time":27.12706541}, +{"learn":[7.075006396],"iteration":53,"passed_time":1.54575155,"remaining_time":27.07927715}, +{"learn":[7.051048719],"iteration":54,"passed_time":1.575695041,"remaining_time":27.0733057}, +{"learn":[7.038764118],"iteration":55,"passed_time":1.602609406,"remaining_time":27.0154157}, +{"learn":[7.009651127],"iteration":56,"passed_time":1.628213114,"remaining_time":26.93692924}, +{"learn":[6.996694598],"iteration":57,"passed_time":1.656772449,"remaining_time":26.90826978}, +{"learn":[6.978654187],"iteration":58,"passed_time":1.68202693,"remaining_time":26.82690409}, +{"learn":[6.969776604],"iteration":59,"passed_time":1.70810592,"remaining_time":26.76032608}, +{"learn":[6.954441817],"iteration":60,"passed_time":1.734291858,"remaining_time":26.69672221}, +{"learn":[6.932883026],"iteration":61,"passed_time":1.760389155,"remaining_time":26.63298431}, +{"learn":[6.917175292],"iteration":62,"passed_time":1.787279971,"remaining_time":26.58224337}, +{"learn":[6.902595892],"iteration":63,"passed_time":1.828707926,"remaining_time":26.74485342}, +{"learn":[6.887459389],"iteration":64,"passed_time":1.853964358,"remaining_time":26.66856423}, +{"learn":[6.875213925],"iteration":65,"passed_time":1.880738486,"remaining_time":26.61529918}, +{"learn":[6.852972446],"iteration":66,"passed_time":1.907723,"remaining_time":26.56575461}, +{"learn":[6.828957383],"iteration":67,"passed_time":1.934606965,"remaining_time":26.51549546}, +{"learn":[6.817855354],"iteration":68,"passed_time":1.961597831,"remaining_time":26.46735625}, +{"learn":[6.80595976],"iteration":69,"passed_time":1.987156781,"remaining_time":26.40079723}, +{"learn":[6.791965865],"iteration":70,"passed_time":2.014556557,"remaining_time":26.35947946}, +{"learn":[6.777822093],"iteration":71,"passed_time":2.0399498,"remaining_time":26.29268631}, +{"learn":[6.766576643],"iteration":72,"passed_time":2.065779386,"remaining_time":26.23256837}, +{"learn":[6.752653775],"iteration":73,"passed_time":2.107534887,"remaining_time":26.37266629}, +{"learn":[6.743335111],"iteration":74,"passed_time":2.135820398,"remaining_time":26.34178491}, +{"learn":[6.728182951],"iteration":75,"passed_time":2.161017412,"remaining_time":26.27342222}, +{"learn":[6.716220956],"iteration":76,"passed_time":2.188452545,"remaining_time":26.23300908}, +{"learn":[6.698745275],"iteration":77,"passed_time":2.214776915,"remaining_time":26.17979892}, +{"learn":[6.687924223],"iteration":78,"passed_time":2.244261177,"remaining_time":26.16410815}, +{"learn":[6.671577812],"iteration":79,"passed_time":2.269082542,"remaining_time":26.09444923}, +{"learn":[6.651217],"iteration":80,"passed_time":2.299462718,"remaining_time":26.0889659}, +{"learn":[6.649087833],"iteration":81,"passed_time":2.326847206,"remaining_time":26.04933823}, +{"learn":[6.630157908],"iteration":82,"passed_time":2.370466058,"remaining_time":26.18936597}, +{"learn":[6.616275305],"iteration":83,"passed_time":2.395907395,"remaining_time":26.12679969}, +{"learn":[6.607533031],"iteration":84,"passed_time":2.435619358,"remaining_time":26.21872603}, +{"learn":[6.599297789],"iteration":85,"passed_time":2.463143871,"remaining_time":26.17806394}, +{"learn":[6.586425764],"iteration":86,"passed_time":2.489685204,"remaining_time":26.12738611}, +{"learn":[6.569831007],"iteration":87,"passed_time":2.517112634,"remaining_time":26.08644002}, +{"learn":[6.565380784],"iteration":88,"passed_time":2.543001577,"remaining_time":26.03004985}, +{"learn":[6.549139075],"iteration":89,"passed_time":2.592767189,"remaining_time":26.21575713}, +{"learn":[6.537012133],"iteration":90,"passed_time":2.618555877,"remaining_time":26.15678343}, +{"learn":[6.531194539],"iteration":91,"passed_time":2.644743569,"remaining_time":26.10246913}, +{"learn":[6.510934582],"iteration":92,"passed_time":2.670660217,"remaining_time":26.04611631}, +{"learn":[6.506204288],"iteration":93,"passed_time":2.711601776,"remaining_time":26.13522563}, +{"learn":[6.491867296],"iteration":94,"passed_time":2.736124791,"remaining_time":26.0651888}, +{"learn":[6.473723898],"iteration":95,"passed_time":2.762181822,"remaining_time":26.01054549}, +{"learn":[6.464631348],"iteration":96,"passed_time":2.782167039,"remaining_time":25.89996739}, +{"learn":[6.450326755],"iteration":97,"passed_time":2.808129058,"remaining_time":25.84624909}, +{"learn":[6.443832888],"iteration":98,"passed_time":2.834412285,"remaining_time":25.79601484}, +{"learn":[6.431655464],"iteration":99,"passed_time":2.860850064,"remaining_time":25.74765058}, +{"learn":[6.420913004],"iteration":100,"passed_time":2.887167967,"remaining_time":25.69865349}, +{"learn":[6.413341173],"iteration":101,"passed_time":2.915212198,"remaining_time":25.66529955}, +{"learn":[6.409779361],"iteration":102,"passed_time":2.950575858,"remaining_time":25.6957917}, +{"learn":[6.395028109],"iteration":103,"passed_time":2.975938962,"remaining_time":25.63885875}, +{"learn":[6.388814686],"iteration":104,"passed_time":3.002951493,"remaining_time":25.59658653}, +{"learn":[6.370728269],"iteration":105,"passed_time":3.028193135,"remaining_time":25.53966663}, +{"learn":[6.361275485],"iteration":106,"passed_time":3.068974314,"remaining_time":25.61302862}, +{"learn":[6.344403735],"iteration":107,"passed_time":3.10524159,"remaining_time":25.64699536}, +{"learn":[6.337169293],"iteration":108,"passed_time":3.146484229,"remaining_time":25.72034356}, +{"learn":[6.33059718],"iteration":109,"passed_time":3.172898483,"remaining_time":25.67163318}, +{"learn":[6.31547966],"iteration":110,"passed_time":3.215364052,"remaining_time":25.75187966}, +{"learn":[6.308599042],"iteration":111,"passed_time":3.244707313,"remaining_time":25.7258937}, +{"learn":[6.296427708],"iteration":112,"passed_time":3.269247164,"remaining_time":25.66214367}, +{"learn":[6.287715725],"iteration":113,"passed_time":3.310173191,"remaining_time":25.72643375}, +{"learn":[6.281914794],"iteration":114,"passed_time":3.335867506,"remaining_time":25.67167602}, +{"learn":[6.27414496],"iteration":115,"passed_time":3.371021154,"remaining_time":25.68950604}, +{"learn":[6.273972211],"iteration":116,"passed_time":3.38583013,"remaining_time":25.55288893}, +{"learn":[6.26641996],"iteration":117,"passed_time":3.412810546,"remaining_time":25.50931273}, +{"learn":[6.254857409],"iteration":118,"passed_time":3.440854778,"remaining_time":25.47389125}, +{"learn":[6.247723264],"iteration":119,"passed_time":3.468115343,"remaining_time":25.43284585}, +{"learn":[6.238526451],"iteration":120,"passed_time":3.494791266,"remaining_time":25.38778118}, +{"learn":[6.235189859],"iteration":121,"passed_time":3.52056623,"remaining_time":25.33653402}, +{"learn":[6.220870429],"iteration":122,"passed_time":3.547035064,"remaining_time":25.29064839}, +{"learn":[6.212054644],"iteration":123,"passed_time":3.573990899,"remaining_time":25.24851635}, +{"learn":[6.209153611],"iteration":124,"passed_time":3.583587957,"remaining_time":25.0851157}, +{"learn":[6.200536449],"iteration":125,"passed_time":3.609632545,"remaining_time":25.03824479}, +{"learn":[6.197102468],"iteration":126,"passed_time":3.636918114,"remaining_time":25.00023239}, +{"learn":[6.191672907],"iteration":127,"passed_time":3.662161755,"remaining_time":24.94847696}, +{"learn":[6.175650415],"iteration":128,"passed_time":3.690157365,"remaining_time":24.91571368}, +{"learn":[6.163677768],"iteration":129,"passed_time":3.717104635,"remaining_time":24.87600794}, +{"learn":[6.154094013],"iteration":130,"passed_time":3.743611926,"remaining_time":24.83357835}, +{"learn":[6.151734128],"iteration":131,"passed_time":3.769703161,"remaining_time":24.78865412}, +{"learn":[6.145210682],"iteration":132,"passed_time":3.797103711,"remaining_time":24.75254825}, +{"learn":[6.132945405],"iteration":133,"passed_time":3.823363064,"remaining_time":24.70919712}, +{"learn":[6.131330087],"iteration":134,"passed_time":3.849647658,"remaining_time":24.66626092}, +{"learn":[6.122165088],"iteration":135,"passed_time":3.876349839,"remaining_time":24.62622251}, +{"learn":[6.11819553],"iteration":136,"passed_time":3.90333195,"remaining_time":24.58814214}, +{"learn":[6.116812798],"iteration":137,"passed_time":3.932051818,"remaining_time":24.5610773}, +{"learn":[6.116802748],"iteration":138,"passed_time":3.942435937,"remaining_time":24.42041253}, +{"learn":[6.111216141],"iteration":139,"passed_time":3.968326775,"remaining_time":24.37686447}, +{"learn":[6.101604882],"iteration":140,"passed_time":4.010409625,"remaining_time":24.43221183}, +{"learn":[6.094570532],"iteration":141,"passed_time":4.045194875,"remaining_time":24.44209298}, +{"learn":[6.086099332],"iteration":142,"passed_time":4.071181881,"remaining_time":24.39862148}, +{"learn":[6.077564797],"iteration":143,"passed_time":4.098984808,"remaining_time":24.36618747}, +{"learn":[6.071976957],"iteration":144,"passed_time":4.125191975,"remaining_time":24.32440785}, +{"learn":[6.068463513],"iteration":145,"passed_time":4.15341215,"remaining_time":24.29461627}, +{"learn":[6.056773675],"iteration":146,"passed_time":4.185550638,"remaining_time":24.28758296}, +{"learn":[6.048002516],"iteration":147,"passed_time":4.212103498,"remaining_time":24.24805527}, +{"learn":[6.039974132],"iteration":148,"passed_time":4.237603971,"remaining_time":24.20269113}, +{"learn":[6.036905216],"iteration":149,"passed_time":4.262492016,"remaining_time":24.15412142}, +{"learn":[6.030600038],"iteration":150,"passed_time":4.290886529,"remaining_time":24.12558055}, +{"learn":[6.025473281],"iteration":151,"passed_time":4.317907074,"remaining_time":24.08937631}, +{"learn":[6.023958932],"iteration":152,"passed_time":4.344449007,"remaining_time":24.05064254}, +{"learn":[6.018452312],"iteration":153,"passed_time":4.371686501,"remaining_time":24.01588818}, +{"learn":[6.015954732],"iteration":154,"passed_time":4.386104067,"remaining_time":23.91134153}, +{"learn":[6.011714814],"iteration":155,"passed_time":4.412377407,"remaining_time":23.87209315}, +{"learn":[5.996632322],"iteration":156,"passed_time":4.437920231,"remaining_time":23.82908761}, +{"learn":[5.99326434],"iteration":157,"passed_time":4.466589451,"remaining_time":23.80296404}, +{"learn":[5.990077105],"iteration":158,"passed_time":4.508456402,"remaining_time":23.84661531}, +{"learn":[5.983547432],"iteration":159,"passed_time":4.533457165,"remaining_time":23.80065012}, +{"learn":[5.980644516],"iteration":160,"passed_time":4.560945303,"remaining_time":23.76790751}, +{"learn":[5.977468288],"iteration":161,"passed_time":4.594801847,"remaining_time":23.76817252}, +{"learn":[5.96567149],"iteration":162,"passed_time":4.625208843,"remaining_time":23.75030553}, +{"learn":[5.964824081],"iteration":163,"passed_time":4.669539966,"remaining_time":23.8032647}, +{"learn":[5.959363378],"iteration":164,"passed_time":4.698806914,"remaining_time":23.77881074}, +{"learn":[5.952631589],"iteration":165,"passed_time":4.729931299,"remaining_time":23.76363074}, +{"learn":[5.951932566],"iteration":166,"passed_time":4.742297577,"remaining_time":23.6546939}, +{"learn":[5.939750375],"iteration":167,"passed_time":4.775186423,"remaining_time":23.64854228}, +{"learn":[5.932763585],"iteration":168,"passed_time":4.804194095,"remaining_time":23.6229899}, +{"learn":[5.930592479],"iteration":169,"passed_time":4.830866605,"remaining_time":23.58599578}, +{"learn":[5.91904232],"iteration":170,"passed_time":4.856648335,"remaining_time":23.54480391}, +{"learn":[5.911315574],"iteration":171,"passed_time":4.886692937,"remaining_time":23.52431251}, +{"learn":[5.904578813],"iteration":172,"passed_time":4.930538523,"remaining_time":23.56968415}, +{"learn":[5.89700148],"iteration":173,"passed_time":4.974960403,"remaining_time":23.61676605}, +{"learn":[5.889260982],"iteration":174,"passed_time":5.010879555,"remaining_time":23.6227179}, +{"learn":[5.877596953],"iteration":175,"passed_time":5.041202108,"remaining_time":23.60199169}, +{"learn":[5.871508542],"iteration":176,"passed_time":5.08331722,"remaining_time":23.63598911}, +{"learn":[5.863873424],"iteration":177,"passed_time":5.114715131,"remaining_time":23.61963954}, +{"learn":[5.855137593],"iteration":178,"passed_time":5.139988263,"remaining_time":23.57502996}, +{"learn":[5.846758951],"iteration":179,"passed_time":5.167854431,"remaining_time":23.54244796}, +{"learn":[5.845148336],"iteration":180,"passed_time":5.194785096,"remaining_time":23.50568505}, +{"learn":[5.844477677],"iteration":181,"passed_time":5.220856372,"remaining_time":23.46516765}, +{"learn":[5.841182047],"iteration":182,"passed_time":5.247608842,"remaining_time":23.42784931}, +{"learn":[5.839715088],"iteration":183,"passed_time":5.274036424,"remaining_time":23.38920501}, +{"learn":[5.835804128],"iteration":184,"passed_time":5.302708221,"remaining_time":23.36057946}, +{"learn":[5.829678437],"iteration":185,"passed_time":5.329510395,"remaining_time":23.3237713}, +{"learn":[5.824781701],"iteration":186,"passed_time":5.358425183,"remaining_time":23.29625494}, +{"learn":[5.819806294],"iteration":187,"passed_time":5.386050785,"remaining_time":23.26315552}, +{"learn":[5.807032107],"iteration":188,"passed_time":5.412612816,"remaining_time":23.22555023}, +{"learn":[5.805007583],"iteration":189,"passed_time":5.438990432,"remaining_time":23.187275}, +{"learn":[5.799966878],"iteration":190,"passed_time":5.467308868,"remaining_time":23.15734489}, +{"learn":[5.794310032],"iteration":191,"passed_time":5.498110893,"remaining_time":23.13788334}, +{"learn":[5.786388304],"iteration":192,"passed_time":5.536718016,"remaining_time":23.1509401}, +{"learn":[5.785116104],"iteration":193,"passed_time":5.563334161,"remaining_time":23.11364605}, +{"learn":[5.774030991],"iteration":194,"passed_time":5.590116958,"remaining_time":23.07714949}, +{"learn":[5.768576166],"iteration":195,"passed_time":5.616855393,"remaining_time":23.04057008}, +{"learn":[5.763424597],"iteration":196,"passed_time":5.643383856,"remaining_time":23.0032347}, +{"learn":[5.757592676],"iteration":197,"passed_time":5.669268835,"remaining_time":22.96340205}, +{"learn":[5.757375326],"iteration":198,"passed_time":5.685820827,"remaining_time":22.88614313}, +{"learn":[5.753843902],"iteration":199,"passed_time":5.712071071,"remaining_time":22.84828428}, +{"learn":[5.746157049],"iteration":200,"passed_time":5.739759602,"remaining_time":22.81625832}, +{"learn":[5.745978742],"iteration":201,"passed_time":5.768727267,"remaining_time":22.78932851}, +{"learn":[5.732782027],"iteration":202,"passed_time":5.796261992,"remaining_time":22.75675275}, +{"learn":[5.728649678],"iteration":203,"passed_time":5.824313096,"remaining_time":22.7262413}, +{"learn":[5.727949924],"iteration":204,"passed_time":5.852236481,"remaining_time":22.69525855}, +{"learn":[5.721397052],"iteration":205,"passed_time":5.881655807,"remaining_time":22.67007141}, +{"learn":[5.713048232],"iteration":206,"passed_time":5.911359528,"remaining_time":22.64593288}, +{"learn":[5.707233267],"iteration":207,"passed_time":5.939691503,"remaining_time":22.61651764}, +{"learn":[5.699670245],"iteration":208,"passed_time":5.969652292,"remaining_time":22.59327733}, +{"learn":[5.691272338],"iteration":209,"passed_time":6.002435304,"remaining_time":22.58058995}, +{"learn":[5.691098011],"iteration":210,"passed_time":6.037512384,"remaining_time":22.57629038}, +{"learn":[5.68827298],"iteration":211,"passed_time":6.066651034,"remaining_time":22.54962743}, +{"learn":[5.685451133],"iteration":212,"passed_time":6.096743293,"remaining_time":22.52646466}, +{"learn":[5.683989338],"iteration":213,"passed_time":6.124353124,"remaining_time":22.49411942}, +{"learn":[5.680232986],"iteration":214,"passed_time":6.152112412,"remaining_time":22.46236392}, +{"learn":[5.674510741],"iteration":215,"passed_time":6.179828518,"remaining_time":22.43048869}, +{"learn":[5.674339162],"iteration":216,"passed_time":6.201472166,"remaining_time":22.37674058}, +{"learn":[5.673261428],"iteration":217,"passed_time":6.231800353,"remaining_time":22.3544398}, +{"learn":[5.666761068],"iteration":218,"passed_time":6.258099208,"remaining_time":22.31769626}, +{"learn":[5.658970524],"iteration":219,"passed_time":6.286160263,"remaining_time":22.28729548}, +{"learn":[5.653131084],"iteration":220,"passed_time":6.325348093,"remaining_time":22.29613649}, +{"learn":[5.650958719],"iteration":221,"passed_time":6.369026459,"remaining_time":22.32028191}, +{"learn":[5.643169486],"iteration":222,"passed_time":6.407943513,"remaining_time":22.32722919}, +{"learn":[5.634112254],"iteration":223,"passed_time":6.435805977,"remaining_time":22.2954707}, +{"learn":[5.630876573],"iteration":224,"passed_time":6.463561807,"remaining_time":22.26337956}, +{"learn":[5.629595639],"iteration":225,"passed_time":6.49231656,"remaining_time":22.23474787}, +{"learn":[5.626804751],"iteration":226,"passed_time":6.520100991,"remaining_time":22.20281086}, +{"learn":[5.624914942],"iteration":227,"passed_time":6.546593752,"remaining_time":22.16653674}, +{"learn":[5.62209936],"iteration":228,"passed_time":6.57578336,"remaining_time":22.13942782}, +{"learn":[5.619281932],"iteration":229,"passed_time":6.604981849,"remaining_time":22.11233054}, +{"learn":[5.616540954],"iteration":230,"passed_time":6.640507312,"remaining_time":22.10627759}, +{"learn":[5.610927866],"iteration":231,"passed_time":6.680835322,"remaining_time":22.11586865}, +{"learn":[5.604278957],"iteration":232,"passed_time":6.71030173,"remaining_time":22.08927651}, +{"learn":[5.602544514],"iteration":233,"passed_time":6.725625712,"remaining_time":22.01636451}, +{"learn":[5.59788989],"iteration":234,"passed_time":6.753177561,"remaining_time":21.98374823}, +{"learn":[5.595738611],"iteration":235,"passed_time":6.788904255,"remaining_time":21.9776392}, +{"learn":[5.585270962],"iteration":236,"passed_time":6.819350654,"remaining_time":21.9542808}, +{"learn":[5.581115882],"iteration":237,"passed_time":6.856431379,"remaining_time":21.95210383}, +{"learn":[5.577791906],"iteration":238,"passed_time":6.884845853,"remaining_time":21.92204056}, +{"learn":[5.574409273],"iteration":239,"passed_time":6.911845727,"remaining_time":21.88751147}, +{"learn":[5.570908772],"iteration":240,"passed_time":6.953765025,"remaining_time":21.90003176}, +{"learn":[5.565394991],"iteration":241,"passed_time":6.980304846,"remaining_time":21.86393006}, +{"learn":[5.559976052],"iteration":242,"passed_time":7.009357485,"remaining_time":21.83573505}, +{"learn":[5.55483665],"iteration":243,"passed_time":7.036268125,"remaining_time":21.80089632}, +{"learn":[5.552674644],"iteration":244,"passed_time":7.063344764,"remaining_time":21.76663387}, +{"learn":[5.552031971],"iteration":245,"passed_time":7.089959444,"remaining_time":21.73101391}, +{"learn":[5.55187056],"iteration":246,"passed_time":7.105753555,"remaining_time":21.66247946}, +{"learn":[5.551213706],"iteration":247,"passed_time":7.133094738,"remaining_time":21.62938405}, +{"learn":[5.549666242],"iteration":248,"passed_time":7.159270714,"remaining_time":21.59282051}, +{"learn":[5.548115994],"iteration":249,"passed_time":7.187635238,"remaining_time":21.56290571}, +{"learn":[5.544295921],"iteration":250,"passed_time":7.216927491,"remaining_time":21.53577168}, +{"learn":[5.537733631],"iteration":251,"passed_time":7.265992449,"remaining_time":21.56731092}, +{"learn":[5.536140612],"iteration":252,"passed_time":7.295482477,"remaining_time":21.54041664}, +{"learn":[5.527248619],"iteration":253,"passed_time":7.337059702,"remaining_time":21.54900212}, +{"learn":[5.522729377],"iteration":254,"passed_time":7.380874322,"remaining_time":21.56373086}, +{"learn":[5.520965137],"iteration":255,"passed_time":7.417439823,"remaining_time":21.55693449}, +{"learn":[5.520463001],"iteration":256,"passed_time":7.459693591,"remaining_time":21.56635151}, +{"learn":[5.509022048],"iteration":257,"passed_time":7.506682213,"remaining_time":21.58898528}, +{"learn":[5.504591918],"iteration":258,"passed_time":7.537229683,"remaining_time":21.56404322}, +{"learn":[5.498471855],"iteration":259,"passed_time":7.580831364,"remaining_time":21.57621234}, +{"learn":[5.496409469],"iteration":260,"passed_time":7.609737109,"remaining_time":21.54634377}, +{"learn":[5.490889618],"iteration":261,"passed_time":7.637486643,"remaining_time":21.51322574}, +{"learn":[5.488373132],"iteration":262,"passed_time":7.667110503,"remaining_time":21.48540092}, +{"learn":[5.480369352],"iteration":263,"passed_time":7.727767604,"remaining_time":21.54407938}, +{"learn":[5.479180537],"iteration":264,"passed_time":7.794668236,"remaining_time":21.61917416}, +{"learn":[5.475534605],"iteration":265,"passed_time":7.832153103,"remaining_time":21.6120315}, +{"learn":[5.468400809],"iteration":266,"passed_time":7.861801843,"remaining_time":21.58314888}, +{"learn":[5.458346782],"iteration":267,"passed_time":7.921360362,"remaining_time":21.63595442}, +{"learn":[5.453291742],"iteration":268,"passed_time":7.95988357,"remaining_time":21.63076167}, +{"learn":[5.449961225],"iteration":269,"passed_time":7.996338545,"remaining_time":21.61973014}, +{"learn":[5.445974412],"iteration":270,"passed_time":8.025584552,"remaining_time":21.58911859}, +{"learn":[5.441847935],"iteration":271,"passed_time":8.05166492,"remaining_time":21.55004435}, +{"learn":[5.436979277],"iteration":272,"passed_time":8.08642197,"remaining_time":21.53417133}, +{"learn":[5.435541558],"iteration":273,"passed_time":8.113095031,"remaining_time":21.49674085}, +{"learn":[5.435089808],"iteration":274,"passed_time":8.140995191,"remaining_time":21.46262368}, +{"learn":[5.428992797],"iteration":275,"passed_time":8.168824819,"remaining_time":21.42836655}, +{"learn":[5.427042701],"iteration":276,"passed_time":8.197448291,"remaining_time":21.39622785}, +{"learn":[5.423559135],"iteration":277,"passed_time":8.227734372,"remaining_time":21.36843243}, +{"learn":[5.422965732],"iteration":278,"passed_time":8.254523453,"remaining_time":21.33158211}, +{"learn":[5.414410675],"iteration":279,"passed_time":8.281844791,"remaining_time":21.29617232}, +{"learn":[5.410915981],"iteration":280,"passed_time":8.3100771,"remaining_time":21.26315101}, +{"learn":[5.409658109],"iteration":281,"passed_time":8.339654495,"remaining_time":21.2335884}, +{"learn":[5.406195492],"iteration":282,"passed_time":8.382766697,"remaining_time":21.23831704}, +{"learn":[5.404200538],"iteration":283,"passed_time":8.40791739,"remaining_time":21.19742553}, +{"learn":[5.400063404],"iteration":284,"passed_time":8.449934253,"remaining_time":21.19895786}, +{"learn":[5.399152148],"iteration":285,"passed_time":8.477272348,"remaining_time":21.16354006}, +{"learn":[5.393798614],"iteration":286,"passed_time":8.503875023,"remaining_time":21.12635154}, +{"learn":[5.393422472],"iteration":287,"passed_time":8.534871252,"remaining_time":21.10009837}, +{"learn":[5.389275826],"iteration":288,"passed_time":8.565439134,"remaining_time":21.07275856}, +{"learn":[5.383474018],"iteration":289,"passed_time":8.593366817,"remaining_time":21.03893255}, +{"learn":[5.373957786],"iteration":290,"passed_time":8.622295889,"remaining_time":21.00758689}, +{"learn":[5.365248295],"iteration":291,"passed_time":8.649333973,"remaining_time":20.97167278}, +{"learn":[5.361896159],"iteration":292,"passed_time":8.676099011,"remaining_time":20.93516041}, +{"learn":[5.352794364],"iteration":293,"passed_time":8.702680188,"remaining_time":20.89827283}, +{"learn":[5.348089397],"iteration":294,"passed_time":8.730760379,"remaining_time":20.86503752}, +{"learn":[5.341953259],"iteration":295,"passed_time":8.757187794,"remaining_time":20.82790611}, +{"learn":[5.337808733],"iteration":296,"passed_time":8.78448897,"remaining_time":20.79291497}, +{"learn":[5.337560165],"iteration":297,"passed_time":8.822470731,"remaining_time":20.78313575}, +{"learn":[5.335720017],"iteration":298,"passed_time":8.851983444,"remaining_time":20.75331236}, +{"learn":[5.330115528],"iteration":299,"passed_time":8.89384012,"remaining_time":20.75229361}, +{"learn":[5.326790004],"iteration":300,"passed_time":8.92979675,"remaining_time":20.73730209}, +{"learn":[5.324865482],"iteration":301,"passed_time":8.957506678,"remaining_time":20.70311146}, +{"learn":[5.323039153],"iteration":302,"passed_time":8.98461249,"remaining_time":20.66757395}, +{"learn":[5.322134431],"iteration":303,"passed_time":9.010973098,"remaining_time":20.63038578}, +{"learn":[5.307985551],"iteration":304,"passed_time":9.037459465,"remaining_time":20.59355517}, +{"learn":[5.299105282],"iteration":305,"passed_time":9.062889835,"remaining_time":20.55439721}, +{"learn":[5.291757675],"iteration":306,"passed_time":9.090674212,"remaining_time":20.52064244}, +{"learn":[5.283694383],"iteration":307,"passed_time":9.117006612,"remaining_time":20.48366421}, +{"learn":[5.283278167],"iteration":308,"passed_time":9.142498398,"remaining_time":20.44487506}, +{"learn":[5.282608192],"iteration":309,"passed_time":9.178494819,"remaining_time":20.42955298}, +{"learn":[5.281079582],"iteration":310,"passed_time":9.203874844,"remaining_time":20.39057803}, +{"learn":[5.279476583],"iteration":311,"passed_time":9.241607481,"remaining_time":20.37892932}, +{"learn":[5.275666464],"iteration":312,"passed_time":9.269355214,"remaining_time":20.34519818}, +{"learn":[5.27523769],"iteration":313,"passed_time":9.296776006,"remaining_time":20.31079089}, +{"learn":[5.273863576],"iteration":314,"passed_time":9.324617159,"remaining_time":20.27734208}, +{"learn":[5.268063011],"iteration":315,"passed_time":9.353722634,"remaining_time":20.24666545}, +{"learn":[5.266887189],"iteration":316,"passed_time":9.380577573,"remaining_time":20.21114979}, +{"learn":[5.261823558],"iteration":317,"passed_time":9.408738671,"remaining_time":20.17848985}, +{"learn":[5.257471241],"iteration":318,"passed_time":9.435063811,"remaining_time":20.14193873}, +{"learn":[5.253391392],"iteration":319,"passed_time":9.461422568,"remaining_time":20.10552296}, +{"learn":[5.248636576],"iteration":320,"passed_time":9.488951058,"remaining_time":20.07164414}, +{"learn":[5.248104218],"iteration":321,"passed_time":9.514623721,"remaining_time":20.03389715}, +{"learn":[5.238003344],"iteration":322,"passed_time":9.566497374,"remaining_time":20.05114156}, +{"learn":[5.234250311],"iteration":323,"passed_time":9.593150554,"remaining_time":20.01533881}, +{"learn":[5.231629095],"iteration":324,"passed_time":9.619938746,"remaining_time":19.97987278}, +{"learn":[5.228882929],"iteration":325,"passed_time":9.659895212,"remaining_time":19.97168519}, +{"learn":[5.223447947],"iteration":326,"passed_time":9.685683393,"remaining_time":19.9341435}, +{"learn":[5.222639852],"iteration":327,"passed_time":9.710828521,"remaining_time":19.89535599}, +{"learn":[5.217785155],"iteration":328,"passed_time":9.737127931,"remaining_time":19.8590056}, +{"learn":[5.211000043],"iteration":329,"passed_time":9.76358742,"remaining_time":19.82304113}, +{"learn":[5.197835086],"iteration":330,"passed_time":9.791272834,"remaining_time":19.78961186}, +{"learn":[5.195956359],"iteration":331,"passed_time":9.817680258,"remaining_time":19.75364582}, +{"learn":[5.194227857],"iteration":332,"passed_time":9.84515705,"remaining_time":19.71987914}, +{"learn":[5.193656032],"iteration":333,"passed_time":9.870661639,"remaining_time":19.68221752}, +{"learn":[5.193234917],"iteration":334,"passed_time":9.89913936,"remaining_time":19.65053037}, +{"learn":[5.19132427],"iteration":335,"passed_time":9.935880283,"remaining_time":19.63519199}, +{"learn":[5.190458072],"iteration":336,"passed_time":9.963665858,"remaining_time":19.6021082}, +{"learn":[5.189763508],"iteration":337,"passed_time":9.998958897,"remaining_time":19.58375973}, +{"learn":[5.176690114],"iteration":338,"passed_time":10.02449623,"remaining_time":19.54628912}, +{"learn":[5.176225337],"iteration":339,"passed_time":10.06706593,"remaining_time":19.54195151}, +{"learn":[5.173572331],"iteration":340,"passed_time":10.09355695,"remaining_time":19.50631681}, +{"learn":[5.165146202],"iteration":341,"passed_time":10.12225631,"remaining_time":19.47498436}, +{"learn":[5.160527906],"iteration":342,"passed_time":10.14775798,"remaining_time":19.43754226}, +{"learn":[5.154822109],"iteration":343,"passed_time":10.17514333,"remaining_time":19.40376171}, +{"learn":[5.14798121],"iteration":344,"passed_time":10.20192595,"remaining_time":19.36887391}, +{"learn":[5.141607911],"iteration":345,"passed_time":10.22742121,"remaining_time":19.33159964}, +{"learn":[5.131449509],"iteration":346,"passed_time":10.26817737,"remaining_time":19.32311187}, +{"learn":[5.130054899],"iteration":347,"passed_time":10.30982762,"remaining_time":19.31611381}, +{"learn":[5.119946204],"iteration":348,"passed_time":10.33825025,"remaining_time":19.28424331}, +{"learn":[5.112369317],"iteration":349,"passed_time":10.37725626,"remaining_time":19.27204735}, +{"learn":[5.110293151],"iteration":350,"passed_time":10.40330179,"remaining_time":19.23573465}, +{"learn":[5.100965209],"iteration":351,"passed_time":10.4304914,"remaining_time":19.20158645}, +{"learn":[5.100495606],"iteration":352,"passed_time":10.45684458,"remaining_time":19.16594461}, +{"learn":[5.099706493],"iteration":353,"passed_time":10.48332417,"remaining_time":19.13058592}, +{"learn":[5.087433987],"iteration":354,"passed_time":10.5091037,"remaining_time":19.09400531}, +{"learn":[5.080084168],"iteration":355,"passed_time":10.53526511,"remaining_time":19.05817621}, +{"learn":[5.076425088],"iteration":356,"passed_time":10.56680977,"remaining_time":19.03209715}, +{"learn":[5.072249926],"iteration":357,"passed_time":10.60905845,"remaining_time":19.02518304}, +{"learn":[5.064093237],"iteration":358,"passed_time":10.63520286,"remaining_time":18.98931765}, +{"learn":[5.062475398],"iteration":359,"passed_time":10.66060309,"remaining_time":18.95218326}, +{"learn":[5.062361702],"iteration":360,"passed_time":10.70071916,"remaining_time":18.94116216}, +{"learn":[5.057242931],"iteration":361,"passed_time":10.72688861,"remaining_time":18.90540036}, +{"learn":[5.055591118],"iteration":362,"passed_time":10.75321115,"remaining_time":18.86996007}, +{"learn":[5.047764746],"iteration":363,"passed_time":10.78080611,"remaining_time":18.83679309}, +{"learn":[5.047064223],"iteration":364,"passed_time":10.82312941,"remaining_time":18.82927993}, +{"learn":[5.0445546],"iteration":365,"passed_time":10.84997728,"remaining_time":18.79476939}, +{"learn":[5.041126001],"iteration":366,"passed_time":10.90711313,"remaining_time":18.81254118}, +{"learn":[5.038059824],"iteration":367,"passed_time":10.93347514,"remaining_time":18.77705513}, +{"learn":[5.037267399],"iteration":368,"passed_time":10.96733417,"remaining_time":18.75443865}, +{"learn":[5.035548576],"iteration":369,"passed_time":10.99328022,"remaining_time":18.71828795}, +{"learn":[5.030392894],"iteration":370,"passed_time":11.02073765,"remaining_time":18.68475467}, +{"learn":[5.029642673],"iteration":371,"passed_time":11.04682484,"remaining_time":18.64894086}, +{"learn":[5.027271244],"iteration":372,"passed_time":11.07434816,"remaining_time":18.61559329}, +{"learn":[5.024773873],"iteration":373,"passed_time":11.09992428,"remaining_time":18.57901765}, +{"learn":[5.016410001],"iteration":374,"passed_time":11.12737319,"remaining_time":18.54562199}, +{"learn":[5.008028182],"iteration":375,"passed_time":11.15730132,"remaining_time":18.51637241}, +{"learn":[5.004436453],"iteration":376,"passed_time":11.18454409,"remaining_time":18.48268161}, +{"learn":[5.004155567],"iteration":377,"passed_time":11.21212248,"remaining_time":18.44957721}, +{"learn":[4.998066017],"iteration":378,"passed_time":11.23923209,"remaining_time":18.41573385}, +{"learn":[4.996871469],"iteration":379,"passed_time":11.26663249,"remaining_time":18.38240038}, +{"learn":[4.988367262],"iteration":380,"passed_time":11.29390441,"remaining_time":18.34888932}, +{"learn":[4.983654187],"iteration":381,"passed_time":11.32141556,"remaining_time":18.31579795}, +{"learn":[4.982372718],"iteration":382,"passed_time":11.34808382,"remaining_time":18.28137785}, +{"learn":[4.97834342],"iteration":383,"passed_time":11.37780474,"remaining_time":18.2518951}, +{"learn":[4.974104901],"iteration":384,"passed_time":11.40367959,"remaining_time":18.2162674}, +{"learn":[4.964633435],"iteration":385,"passed_time":11.4301425,"remaining_time":18.18162564}, +{"learn":[4.963053945],"iteration":386,"passed_time":11.46695831,"remaining_time":18.16342492}, +{"learn":[4.95718563],"iteration":387,"passed_time":11.49647651,"remaining_time":18.13361759}, +{"learn":[4.956531594],"iteration":388,"passed_time":11.54064768,"remaining_time":18.12682707}, +{"learn":[4.956438109],"iteration":389,"passed_time":11.56928736,"remaining_time":18.09555203}, +{"learn":[4.953071368],"iteration":390,"passed_time":11.59624069,"remaining_time":18.06166389}, +{"learn":[4.947372064],"iteration":391,"passed_time":11.6359267,"remaining_time":18.04755978}, +{"learn":[4.945999404],"iteration":392,"passed_time":11.66448336,"remaining_time":18.01613588}, +{"learn":[4.938835395],"iteration":393,"passed_time":11.69063806,"remaining_time":17.98103214}, +{"learn":[4.937852727],"iteration":394,"passed_time":11.73995361,"remaining_time":17.98144793}, +{"learn":[4.934619338],"iteration":395,"passed_time":11.78468618,"remaining_time":17.97462236}, +{"learn":[4.933658837],"iteration":396,"passed_time":11.82155515,"remaining_time":17.95566186}, +{"learn":[4.928963356],"iteration":397,"passed_time":11.85374145,"remaining_time":17.92952852}, +{"learn":[4.925288065],"iteration":398,"passed_time":11.88132018,"remaining_time":17.89642463}, +{"learn":[4.923243053],"iteration":399,"passed_time":11.90749575,"remaining_time":17.86124362}, +{"learn":[4.918170037],"iteration":400,"passed_time":11.93427697,"remaining_time":17.82701224}, +{"learn":[4.917171729],"iteration":401,"passed_time":11.97621783,"remaining_time":17.8153688}, +{"learn":[4.909951118],"iteration":402,"passed_time":12.0040119,"remaining_time":17.78261813}, +{"learn":[4.905013948],"iteration":403,"passed_time":12.03288303,"remaining_time":17.75148091}, +{"learn":[4.904694938],"iteration":404,"passed_time":12.07470126,"remaining_time":17.73937592}, +{"learn":[4.900543075],"iteration":405,"passed_time":12.11692521,"remaining_time":17.72771816}, +{"learn":[4.895223316],"iteration":406,"passed_time":12.14432447,"remaining_time":17.6943106}, +{"learn":[4.89135731],"iteration":407,"passed_time":12.18368904,"remaining_time":17.6782939}, +{"learn":[4.884327946],"iteration":408,"passed_time":12.22605609,"remaining_time":17.66650158}, +{"learn":[4.883030848],"iteration":409,"passed_time":12.25739838,"remaining_time":17.63869523}, +{"learn":[4.880893252],"iteration":410,"passed_time":12.29133707,"remaining_time":17.61459253}, +{"learn":[4.880801262],"iteration":411,"passed_time":12.3240819,"remaining_time":17.58873825}, +{"learn":[4.870751028],"iteration":412,"passed_time":12.35468347,"remaining_time":17.55980435}, +{"learn":[4.868467907],"iteration":413,"passed_time":12.39549553,"remaining_time":17.54531493}, +{"learn":[4.860514297],"iteration":414,"passed_time":12.43830759,"remaining_time":17.53351793}, +{"learn":[4.860422305],"iteration":415,"passed_time":12.46526827,"remaining_time":17.49931892}, +{"learn":[4.855418447],"iteration":416,"passed_time":12.49237659,"remaining_time":17.46536104}, +{"learn":[4.851916444],"iteration":417,"passed_time":12.53143256,"remaining_time":17.44807117}, +{"learn":[4.849504783],"iteration":418,"passed_time":12.57385084,"remaining_time":17.43533971}, +{"learn":[4.846850505],"iteration":419,"passed_time":12.60074447,"remaining_time":17.40102808}, +{"learn":[4.8463838],"iteration":420,"passed_time":12.62727043,"remaining_time":17.36624603}, +{"learn":[4.833032034],"iteration":421,"passed_time":12.6533252,"remaining_time":17.33085773}, +{"learn":[4.83139662],"iteration":422,"passed_time":12.6817155,"remaining_time":17.29869939}, +{"learn":[4.83109765],"iteration":423,"passed_time":12.70841972,"remaining_time":17.26426829}, +{"learn":[4.829716852],"iteration":424,"passed_time":12.74472227,"remaining_time":17.24285954}, +{"learn":[4.825015227],"iteration":425,"passed_time":12.77307419,"remaining_time":17.21066804}, +{"learn":[4.823351034],"iteration":426,"passed_time":12.79972979,"remaining_time":17.17621819}, +{"learn":[4.817559026],"iteration":427,"passed_time":12.82579179,"remaining_time":17.14101146}, +{"learn":[4.813421647],"iteration":428,"passed_time":12.85228257,"remaining_time":17.10641806}, +{"learn":[4.803560893],"iteration":429,"passed_time":12.87819059,"remaining_time":17.07108985}, +{"learn":[4.803253062],"iteration":430,"passed_time":12.90434115,"remaining_time":17.03612556}, +{"learn":[4.801843861],"iteration":431,"passed_time":12.93096182,"remaining_time":17.00182016}, +{"learn":[4.799063783],"iteration":432,"passed_time":12.95773362,"remaining_time":16.96774818}, +{"learn":[4.796621518],"iteration":433,"passed_time":12.98487533,"remaining_time":16.93419225}, +{"learn":[4.791081182],"iteration":434,"passed_time":13.01508598,"remaining_time":16.90465191}, +{"learn":[4.790805067],"iteration":435,"passed_time":13.0400888,"remaining_time":16.86837175}, +{"learn":[4.787655069],"iteration":436,"passed_time":13.06695766,"remaining_time":16.83454728}, +{"learn":[4.783852468],"iteration":437,"passed_time":13.09444089,"remaining_time":16.80154287}, +{"learn":[4.779159432],"iteration":438,"passed_time":13.11974139,"remaining_time":16.7657743}, +{"learn":[4.778886619],"iteration":439,"passed_time":13.15226124,"remaining_time":16.73924158}, +{"learn":[4.775664898],"iteration":440,"passed_time":13.17866551,"remaining_time":16.70492975}, +{"learn":[4.771376172],"iteration":441,"passed_time":13.20647071,"remaining_time":16.6724223}, +{"learn":[4.764875837],"iteration":442,"passed_time":13.2374623,"remaining_time":16.64394244}, +{"learn":[4.763716858],"iteration":443,"passed_time":13.26468694,"remaining_time":16.61073409}, +{"learn":[4.759339438],"iteration":444,"passed_time":13.29215863,"remaining_time":16.57786076}, +{"learn":[4.757997517],"iteration":445,"passed_time":13.33725112,"remaining_time":16.56689937}, +{"learn":[4.75594894],"iteration":446,"passed_time":13.38076752,"remaining_time":16.55383544}, +{"learn":[4.752371509],"iteration":447,"passed_time":13.40786928,"remaining_time":16.52041037}, +{"learn":[4.750610217],"iteration":448,"passed_time":13.438155,"remaining_time":16.49092072}, +{"learn":[4.749695429],"iteration":449,"passed_time":13.46293437,"remaining_time":16.45469756}, +{"learn":[4.745288316],"iteration":450,"passed_time":13.49120424,"remaining_time":16.42277412}, +{"learn":[4.745158807],"iteration":451,"passed_time":13.51798537,"remaining_time":16.38906191}, +{"learn":[4.736325135],"iteration":452,"passed_time":13.54476519,"remaining_time":16.35537872}, +{"learn":[4.735711638],"iteration":453,"passed_time":13.57096791,"remaining_time":16.32103189}, +{"learn":[4.732150655],"iteration":454,"passed_time":13.59950063,"remaining_time":16.28951175}, +{"learn":[4.730025501],"iteration":455,"passed_time":13.62808151,"remaining_time":16.25806215}, +{"learn":[4.728772563],"iteration":456,"passed_time":13.65372831,"remaining_time":16.22313889}, +{"learn":[4.725847827],"iteration":457,"passed_time":13.68079671,"remaining_time":16.18993846}, +{"learn":[4.718615738],"iteration":458,"passed_time":13.70674115,"remaining_time":16.15544001}, +{"learn":[4.717367483],"iteration":459,"passed_time":13.73447093,"remaining_time":16.12307457}, +{"learn":[4.714338934],"iteration":460,"passed_time":13.7588492,"remaining_time":16.08681067}, +{"learn":[4.713140169],"iteration":461,"passed_time":13.78662846,"remaining_time":16.05455868}, +{"learn":[4.711807757],"iteration":462,"passed_time":13.8131103,"remaining_time":16.02082124}, +{"learn":[4.707974665],"iteration":463,"passed_time":13.83840317,"remaining_time":15.9857416}, +{"learn":[4.704359765],"iteration":464,"passed_time":13.86557988,"remaining_time":15.95287148}, +{"learn":[4.700946192],"iteration":465,"passed_time":13.89156983,"remaining_time":15.91866586}, +{"learn":[4.700708352],"iteration":466,"passed_time":13.93295798,"remaining_time":15.90206981}, +{"learn":[4.696698443],"iteration":467,"passed_time":13.9592233,"remaining_time":15.86817691}, +{"learn":[4.690153753],"iteration":468,"passed_time":13.98644728,"remaining_time":15.83540193}, +{"learn":[4.684763998],"iteration":469,"passed_time":14.01151161,"remaining_time":15.80021522}, +{"learn":[4.682898224],"iteration":470,"passed_time":14.04022592,"remaining_time":15.76917094}, +{"learn":[4.678749408],"iteration":471,"passed_time":14.06569106,"remaining_time":15.73450186}, +{"learn":[4.671459419],"iteration":472,"passed_time":14.09428914,"remaining_time":15.70336232}, +{"learn":[4.666429971],"iteration":473,"passed_time":14.1194851,"remaining_time":15.66845815}, +{"learn":[4.664630169],"iteration":474,"passed_time":14.14782156,"remaining_time":15.63706594}, +{"learn":[4.662199704],"iteration":475,"passed_time":14.17415936,"remaining_time":15.60348636}, +{"learn":[4.655992647],"iteration":476,"passed_time":14.2011085,"remaining_time":15.57060744}, +{"learn":[4.652068465],"iteration":477,"passed_time":14.2269914,"remaining_time":15.53658893}, +{"learn":[4.650420351],"iteration":478,"passed_time":14.25327887,"remaining_time":15.50304444}, +{"learn":[4.643418993],"iteration":479,"passed_time":14.29670135,"remaining_time":15.48809313}, +{"learn":[4.636460035],"iteration":480,"passed_time":14.32315867,"remaining_time":15.45471798}, +{"learn":[4.632968064],"iteration":481,"passed_time":14.35056274,"remaining_time":15.422389}, +{"learn":[4.631112578],"iteration":482,"passed_time":14.37724671,"remaining_time":15.38930963}, +{"learn":[4.6293636],"iteration":483,"passed_time":14.40437234,"remaining_time":15.35672754}, +{"learn":[4.628456212],"iteration":484,"passed_time":14.43381276,"remaining_time":15.32662592}, +{"learn":[4.626240139],"iteration":485,"passed_time":14.45999969,"remaining_time":15.29308609}, +{"learn":[4.620625778],"iteration":486,"passed_time":14.48782637,"remaining_time":15.26130375}, +{"learn":[4.61969543],"iteration":487,"passed_time":14.5134709,"remaining_time":15.22724815}, +{"learn":[4.616396959],"iteration":488,"passed_time":14.54034383,"remaining_time":15.19451063}, +{"learn":[4.611743573],"iteration":489,"passed_time":14.56674299,"remaining_time":15.16130393}, +{"learn":[4.605125583],"iteration":490,"passed_time":14.61071288,"remaining_time":15.14633983}, +{"learn":[4.599340081],"iteration":491,"passed_time":14.63891276,"remaining_time":15.11497496}, +{"learn":[4.595985806],"iteration":492,"passed_time":14.66656139,"remaining_time":15.08305603}, +{"learn":[4.595169345],"iteration":493,"passed_time":14.69269635,"remaining_time":15.04960395}, +{"learn":[4.593957744],"iteration":494,"passed_time":14.71994015,"remaining_time":15.01731267}, +{"learn":[4.586480218],"iteration":495,"passed_time":14.74733627,"remaining_time":14.98519653}, +{"learn":[4.585228769],"iteration":496,"passed_time":14.77272977,"remaining_time":14.95107259}, +{"learn":[4.582154705],"iteration":497,"passed_time":14.79917932,"remaining_time":14.91804823}, +{"learn":[4.577741412],"iteration":498,"passed_time":14.82591413,"remaining_time":14.88533663}, +{"learn":[4.569967684],"iteration":499,"passed_time":14.85211193,"remaining_time":14.85211193}, +{"learn":[4.565214419],"iteration":500,"passed_time":14.87831199,"remaining_time":14.81891753}, +{"learn":[4.559741129],"iteration":501,"passed_time":14.90659881,"remaining_time":14.78782113}, +{"learn":[4.554412282],"iteration":502,"passed_time":14.93152043,"remaining_time":14.75341085}, +{"learn":[4.552067677],"iteration":503,"passed_time":14.95676529,"remaining_time":14.71935632}, +{"learn":[4.550391882],"iteration":504,"passed_time":14.98409131,"remaining_time":14.68737663}, +{"learn":[4.543945396],"iteration":505,"passed_time":15.02599536,"remaining_time":14.66964764}, +{"learn":[4.539138209],"iteration":506,"passed_time":15.06263504,"remaining_time":14.64670429}, +{"learn":[4.534808114],"iteration":507,"passed_time":15.0878605,"remaining_time":14.61265229}, +{"learn":[4.534007757],"iteration":508,"passed_time":15.11347539,"remaining_time":14.57901064}, +{"learn":[4.529902812],"iteration":509,"passed_time":15.15385716,"remaining_time":14.55958825}, +{"learn":[4.529726299],"iteration":510,"passed_time":15.18249995,"remaining_time":14.52885025}, +{"learn":[4.527095406],"iteration":511,"passed_time":15.21074988,"remaining_time":14.49774598}, +{"learn":[4.522285697],"iteration":512,"passed_time":15.23893699,"remaining_time":14.4665932}, +{"learn":[4.51698853],"iteration":513,"passed_time":15.26499564,"remaining_time":14.43343946}, +{"learn":[4.51096004],"iteration":514,"passed_time":15.29265535,"remaining_time":14.40182105}, +{"learn":[4.503553965],"iteration":515,"passed_time":15.31926613,"remaining_time":14.36923412}, +{"learn":[4.49733747],"iteration":516,"passed_time":15.34812588,"remaining_time":14.33877138}, +{"learn":[4.496504532],"iteration":517,"passed_time":15.37396357,"remaining_time":14.30550278}, +{"learn":[4.495742877],"iteration":518,"passed_time":15.41600297,"remaining_time":14.28727829}, +{"learn":[4.494791653],"iteration":519,"passed_time":15.44175253,"remaining_time":14.25392541}, +{"learn":[4.494089839],"iteration":520,"passed_time":15.4795649,"remaining_time":14.23169211}, +{"learn":[4.489743028],"iteration":521,"passed_time":15.50441915,"remaining_time":14.19753324}, +{"learn":[4.488833907],"iteration":522,"passed_time":15.53216488,"remaining_time":14.16604713}, +{"learn":[4.485718458],"iteration":523,"passed_time":15.55801715,"remaining_time":14.13285527}, +{"learn":[4.482639287],"iteration":524,"passed_time":15.58461733,"remaining_time":14.10036806}, +{"learn":[4.478967464],"iteration":525,"passed_time":15.61445263,"remaining_time":14.07081853}, +{"learn":[4.47301574],"iteration":526,"passed_time":15.6416966,"remaining_time":14.03894211}, +{"learn":[4.47228902],"iteration":527,"passed_time":15.66842871,"remaining_time":14.00662566}, +{"learn":[4.46992917],"iteration":528,"passed_time":15.69586796,"remaining_time":13.97495994}, +{"learn":[4.467743559],"iteration":529,"passed_time":15.73364467,"remaining_time":13.95247735}, +{"learn":[4.466739542],"iteration":530,"passed_time":15.77284581,"remaining_time":13.93119526}, +{"learn":[4.465962742],"iteration":531,"passed_time":15.79867385,"remaining_time":13.89808151}, +{"learn":[4.459746787],"iteration":532,"passed_time":15.82644633,"remaining_time":13.86669876}, +{"learn":[4.457368533],"iteration":533,"passed_time":15.85163217,"remaining_time":13.83307227}, +{"learn":[4.453478498],"iteration":534,"passed_time":15.87801199,"remaining_time":13.8005151}, +{"learn":[4.448082313],"iteration":535,"passed_time":15.90320483,"remaining_time":13.76695344}, +{"learn":[4.446245205],"iteration":536,"passed_time":15.92955387,"remaining_time":13.73441982}, +{"learn":[4.44605768],"iteration":537,"passed_time":15.95484117,"remaining_time":13.70099744}, +{"learn":[4.443683655],"iteration":538,"passed_time":15.98325028,"remaining_time":13.67027529}, +{"learn":[4.440201548],"iteration":539,"passed_time":16.01062255,"remaining_time":13.63867847}, +{"learn":[4.43952352],"iteration":540,"passed_time":16.03755414,"remaining_time":13.60672338}, +{"learn":[4.433705805],"iteration":541,"passed_time":16.06357113,"remaining_time":13.57401398}, +{"learn":[4.433056866],"iteration":542,"passed_time":16.08929172,"remaining_time":13.54107977}, +{"learn":[4.432131333],"iteration":543,"passed_time":16.11511395,"remaining_time":13.50825728}, +{"learn":[4.429760282],"iteration":544,"passed_time":16.1402856,"remaining_time":13.47491733}, +{"learn":[4.424853426],"iteration":545,"passed_time":16.16672203,"remaining_time":13.44265898}, +{"learn":[4.420597851],"iteration":546,"passed_time":16.19462725,"remaining_time":13.41163829}, +{"learn":[4.419715603],"iteration":547,"passed_time":16.23678068,"remaining_time":13.39238114}, +{"learn":[4.416857931],"iteration":548,"passed_time":16.26278473,"remaining_time":13.35977397}, +{"learn":[4.416751803],"iteration":549,"passed_time":16.29077409,"remaining_time":13.32881517}, +{"learn":[4.413781681],"iteration":550,"passed_time":16.31693144,"remaining_time":13.29637426}, +{"learn":[4.412353329],"iteration":551,"passed_time":16.34573354,"remaining_time":13.26610258}, +{"learn":[4.408311774],"iteration":552,"passed_time":16.37156103,"remaining_time":13.23343179}, +{"learn":[4.405806977],"iteration":553,"passed_time":16.40115533,"remaining_time":13.20381819}, +{"learn":[4.400871654],"iteration":554,"passed_time":16.42876485,"remaining_time":13.17261325}, +{"learn":[4.389815979],"iteration":555,"passed_time":16.4556103,"remaining_time":13.1408111}, +{"learn":[4.386545456],"iteration":556,"passed_time":16.48381034,"remaining_time":13.1101041}, +{"learn":[4.383411269],"iteration":557,"passed_time":16.50946476,"remaining_time":13.07738965}, +{"learn":[4.382759626],"iteration":558,"passed_time":16.53677037,"remaining_time":13.0460031}, +{"learn":[4.382133476],"iteration":559,"passed_time":16.56286396,"remaining_time":13.01367883}, +{"learn":[4.382029015],"iteration":560,"passed_time":16.58978417,"remaining_time":12.98202362}, +{"learn":[4.381773197],"iteration":561,"passed_time":16.61900779,"remaining_time":12.95218045}, +{"learn":[4.376556147],"iteration":562,"passed_time":16.64679051,"remaining_time":12.92122106}, +{"learn":[4.369684655],"iteration":563,"passed_time":16.67168641,"remaining_time":12.88804127}, +{"learn":[4.365271614],"iteration":564,"passed_time":16.69982087,"remaining_time":12.85738421}, +{"learn":[4.361005243],"iteration":565,"passed_time":16.72527692,"remaining_time":12.8246823}, +{"learn":[4.359810417],"iteration":566,"passed_time":16.75788508,"remaining_time":12.7974678}, +{"learn":[4.35431967],"iteration":567,"passed_time":16.78490106,"remaining_time":12.76598109}, +{"learn":[4.350078041],"iteration":568,"passed_time":16.81181636,"remaining_time":12.73443383}, +{"learn":[4.347685906],"iteration":569,"passed_time":16.83843322,"remaining_time":12.70267769}, +{"learn":[4.343337767],"iteration":570,"passed_time":16.8648866,"remaining_time":12.67081673}, +{"learn":[4.342712275],"iteration":571,"passed_time":16.89152536,"remaining_time":12.63911338}, +{"learn":[4.342277694],"iteration":572,"passed_time":16.91590036,"remaining_time":12.60574076}, +{"learn":[4.332624195],"iteration":573,"passed_time":16.95816822,"remaining_time":12.58567886}, +{"learn":[4.329167588],"iteration":574,"passed_time":16.98557532,"remaining_time":12.55455567}, +{"learn":[4.325424555],"iteration":575,"passed_time":17.01056844,"remaining_time":12.52166843}, +{"learn":[4.323798455],"iteration":576,"passed_time":17.05295585,"remaining_time":12.50156036}, +{"learn":[4.322874075],"iteration":577,"passed_time":17.07799656,"remaining_time":12.46871029}, +{"learn":[4.312675925],"iteration":578,"passed_time":17.10949596,"remaining_time":12.44058342}, +{"learn":[4.312066378],"iteration":579,"passed_time":17.13505021,"remaining_time":12.40813981}, +{"learn":[4.311644336],"iteration":580,"passed_time":17.17681594,"remaining_time":12.38741115}, +{"learn":[4.309866209],"iteration":581,"passed_time":17.20115416,"remaining_time":12.35409354}, +{"learn":[4.303820966],"iteration":582,"passed_time":17.2283789,"remaining_time":12.32287136}, +{"learn":[4.301719897],"iteration":583,"passed_time":17.25374952,"remaining_time":12.29034212}, +{"learn":[4.301116937],"iteration":584,"passed_time":17.28175632,"remaining_time":12.25970747}, +{"learn":[4.296892323],"iteration":585,"passed_time":17.30903795,"remaining_time":12.22856947}, +{"learn":[4.296798657],"iteration":586,"passed_time":17.35155846,"remaining_time":12.20816634}, +{"learn":[4.295802374],"iteration":587,"passed_time":17.37709703,"remaining_time":12.17578907}, +{"learn":[4.295568374],"iteration":588,"passed_time":17.40942638,"remaining_time":12.14817359}, +{"learn":[4.289932713],"iteration":589,"passed_time":17.43588236,"remaining_time":12.11646062}, +{"learn":[4.289110276],"iteration":590,"passed_time":17.46398459,"remaining_time":12.08590473}, +{"learn":[4.284767629],"iteration":591,"passed_time":17.49042596,"remaining_time":12.05421249}, +{"learn":[4.284588826],"iteration":592,"passed_time":17.51817457,"remaining_time":12.02343516}, +{"learn":[4.279402731],"iteration":593,"passed_time":17.54312688,"remaining_time":11.99075676}, +{"learn":[4.277190701],"iteration":594,"passed_time":17.57058666,"remaining_time":11.95981109}, +{"learn":[4.272370955],"iteration":595,"passed_time":17.59982372,"remaining_time":11.93008185}, +{"learn":[4.270297853],"iteration":596,"passed_time":17.62883214,"remaining_time":11.90019992}, +{"learn":[4.268776171],"iteration":597,"passed_time":17.65494582,"remaining_time":11.86837495}, +{"learn":[4.265613012],"iteration":598,"passed_time":17.68100854,"remaining_time":11.83653493}, +{"learn":[4.265604058],"iteration":599,"passed_time":17.70869112,"remaining_time":11.80579408}, +{"learn":[4.265512073],"iteration":600,"passed_time":17.73519574,"remaining_time":11.77428137}, +{"learn":[4.257606792],"iteration":601,"passed_time":17.76290063,"remaining_time":11.74357882}, +{"learn":[4.255100218],"iteration":602,"passed_time":17.79058278,"remaining_time":11.71287125}, +{"learn":[4.251343472],"iteration":603,"passed_time":17.82027711,"remaining_time":11.68349294}, +{"learn":[4.248730627],"iteration":604,"passed_time":17.856914,"remaining_time":11.65864633}, +{"learn":[4.24535366],"iteration":605,"passed_time":17.88351887,"remaining_time":11.62723834}, +{"learn":[4.23980014],"iteration":606,"passed_time":17.91062837,"remaining_time":11.5961729}, +{"learn":[4.230214392],"iteration":607,"passed_time":17.93722655,"remaining_time":11.5647908}, +{"learn":[4.228698521],"iteration":608,"passed_time":17.96359727,"remaining_time":11.53327838}, +{"learn":[4.226493066],"iteration":609,"passed_time":17.99151869,"remaining_time":11.50277424}, +{"learn":[4.225908823],"iteration":610,"passed_time":18.01818026,"remaining_time":11.47147647}, +{"learn":[4.217229516],"iteration":611,"passed_time":18.04412092,"remaining_time":11.43973679}, +{"learn":[4.215123825],"iteration":612,"passed_time":18.0705656,"remaining_time":11.40833424}, +{"learn":[4.213042615],"iteration":613,"passed_time":18.10862089,"remaining_time":11.38424701}, +{"learn":[4.205833243],"iteration":614,"passed_time":18.13493436,"remaining_time":11.35276379}, +{"learn":[4.204781921],"iteration":615,"passed_time":18.16124174,"remaining_time":11.32129355}, +{"learn":[4.197797069],"iteration":616,"passed_time":18.1892989,"remaining_time":11.29092622}, +{"learn":[4.191870868],"iteration":617,"passed_time":18.21743663,"remaining_time":11.26061617}, +{"learn":[4.189100979],"iteration":618,"passed_time":18.24277612,"remaining_time":11.22859079}, +{"learn":[4.188331058],"iteration":619,"passed_time":18.26985034,"remaining_time":11.19765021}, +{"learn":[4.187494733],"iteration":620,"passed_time":18.29702262,"remaining_time":11.16678192}, +{"learn":[4.178993585],"iteration":621,"passed_time":18.32484278,"remaining_time":11.13631924}, +{"learn":[4.178263596],"iteration":622,"passed_time":18.35629133,"remaining_time":11.10806072}, +{"learn":[4.172446931],"iteration":623,"passed_time":18.39931036,"remaining_time":11.08676394}, +{"learn":[4.165931178],"iteration":624,"passed_time":18.42476465,"remaining_time":11.05485879}, +{"learn":[4.165125986],"iteration":625,"passed_time":18.45323918,"remaining_time":11.02477868}, +{"learn":[4.161355207],"iteration":626,"passed_time":18.48279329,"remaining_time":10.99534593}, +{"learn":[4.159123482],"iteration":627,"passed_time":18.50953368,"remaining_time":10.96424606}, +{"learn":[4.157733657],"iteration":628,"passed_time":18.53550754,"remaining_time":10.93270794}, +{"learn":[4.157523496],"iteration":629,"passed_time":18.56196538,"remaining_time":10.90147173}, +{"learn":[4.156921403],"iteration":630,"passed_time":18.58833273,"remaining_time":10.87019775}, +{"learn":[4.15567469],"iteration":631,"passed_time":18.61432675,"remaining_time":10.83872191}, +{"learn":[4.154874737],"iteration":632,"passed_time":18.64207657,"remaining_time":10.80828136}, +{"learn":[4.153824149],"iteration":633,"passed_time":18.70126023,"remaining_time":10.79599565}, +{"learn":[4.153513209],"iteration":634,"passed_time":18.72830372,"remaining_time":10.76508796}, +{"learn":[4.150174445],"iteration":635,"passed_time":18.75354906,"remaining_time":10.7331633}, +{"learn":[4.143543617],"iteration":636,"passed_time":18.79378114,"remaining_time":10.70979993}, +{"learn":[4.142518496],"iteration":637,"passed_time":18.82045465,"remaining_time":10.67869057}, +{"learn":[4.140609976],"iteration":638,"passed_time":18.84742728,"remaining_time":10.64776408}, +{"learn":[4.140600597],"iteration":639,"passed_time":18.87599723,"remaining_time":10.61774844}, +{"learn":[4.133577581],"iteration":640,"passed_time":18.90325836,"remaining_time":10.58700429}, +{"learn":[4.130973197],"iteration":641,"passed_time":18.93071569,"remaining_time":10.5563804}, +{"learn":[4.126592036],"iteration":642,"passed_time":18.95706569,"remaining_time":10.52515156}, +{"learn":[4.12533841],"iteration":643,"passed_time":18.98477482,"remaining_time":10.49468918}, +{"learn":[4.125005984],"iteration":644,"passed_time":19.01340764,"remaining_time":10.46474374}, +{"learn":[4.121664479],"iteration":645,"passed_time":19.03986173,"remaining_time":10.43360844}, +{"learn":[4.118756341],"iteration":646,"passed_time":19.06764708,"remaining_time":10.40321394}, +{"learn":[4.116685314],"iteration":647,"passed_time":19.093489,"remaining_time":10.3717718}, +{"learn":[4.116484168],"iteration":648,"passed_time":19.13658681,"remaining_time":10.34967946}, +{"learn":[4.114730813],"iteration":649,"passed_time":19.16410685,"remaining_time":10.31913446}, +{"learn":[4.1121717],"iteration":650,"passed_time":19.19256993,"remaining_time":10.28910431}, +{"learn":[4.108903332],"iteration":651,"passed_time":19.2211914,"remaining_time":10.25916351}, +{"learn":[4.106063639],"iteration":652,"passed_time":19.25147889,"remaining_time":10.23011206}, +{"learn":[4.103386538],"iteration":653,"passed_time":19.3005961,"remaining_time":10.21101873}, +{"learn":[4.099811948],"iteration":654,"passed_time":19.32880808,"remaining_time":10.18082258}, +{"learn":[4.097520622],"iteration":655,"passed_time":19.3684544,"remaining_time":10.15662853}, +{"learn":[4.095728877],"iteration":656,"passed_time":19.39435907,"remaining_time":10.12521334}, +{"learn":[4.091648173],"iteration":657,"passed_time":19.42181618,"remaining_time":10.09462179}, +{"learn":[4.090300946],"iteration":658,"passed_time":19.44952346,"remaining_time":10.06416919}, +{"learn":[4.090293168],"iteration":659,"passed_time":19.47600167,"remaining_time":10.03309177}, +{"learn":[4.083458536],"iteration":660,"passed_time":19.50301997,"remaining_time":10.00230525}, +{"learn":[4.078376128],"iteration":661,"passed_time":19.52903171,"remaining_time":9.971016192}, +{"learn":[4.075150531],"iteration":662,"passed_time":19.56030421,"remaining_time":9.942417073}, +{"learn":[4.069712197],"iteration":663,"passed_time":19.59138017,"remaining_time":9.913710449}, +{"learn":[4.068562429],"iteration":664,"passed_time":19.61842707,"remaining_time":9.882967018}, +{"learn":[4.064921332],"iteration":665,"passed_time":19.64505457,"remaining_time":9.852024362}, +{"learn":[4.060630454],"iteration":666,"passed_time":19.67478645,"remaining_time":9.822644511}, +{"learn":[4.059920051],"iteration":667,"passed_time":19.70023773,"remaining_time":9.791136116}, +{"learn":[4.05606486],"iteration":668,"passed_time":19.72683564,"remaining_time":9.76021315}, +{"learn":[4.053790151],"iteration":669,"passed_time":19.75234745,"remaining_time":9.728768148}, +{"learn":[4.048848082],"iteration":670,"passed_time":19.78070507,"remaining_time":9.698736168}, +{"learn":[4.043894151],"iteration":671,"passed_time":19.80549484,"remaining_time":9.666967718}, +{"learn":[4.04068757],"iteration":672,"passed_time":19.83199754,"remaining_time":9.636052296}, +{"learn":[4.037988102],"iteration":673,"passed_time":19.85817836,"remaining_time":9.60499428}, +{"learn":[4.03217302],"iteration":674,"passed_time":19.88355534,"remaining_time":9.57356368}, +{"learn":[4.028015257],"iteration":675,"passed_time":19.91022679,"remaining_time":9.542771421}, +{"learn":[4.021675829],"iteration":676,"passed_time":19.95414012,"remaining_time":9.520217515}, +{"learn":[4.019266437],"iteration":677,"passed_time":19.98173126,"remaining_time":9.489848769}, +{"learn":[4.016197857],"iteration":678,"passed_time":20.00883637,"remaining_time":9.459258433}, +{"learn":[4.015106549],"iteration":679,"passed_time":20.03486356,"remaining_time":9.428171089}, +{"learn":[4.01152552],"iteration":680,"passed_time":20.07028482,"remaining_time":9.401499057}, +{"learn":[4.008793892],"iteration":681,"passed_time":20.09713604,"remaining_time":9.370805367}, +{"learn":[4.006987211],"iteration":682,"passed_time":20.12281529,"remaining_time":9.339578987}, +{"learn":[4.001370378],"iteration":683,"passed_time":20.14823304,"remaining_time":9.308248012}, +{"learn":[3.999785673],"iteration":684,"passed_time":20.17599492,"remaining_time":9.278012262}, +{"learn":[3.995391756],"iteration":685,"passed_time":20.20178059,"remaining_time":9.246879163}, +{"learn":[3.992859418],"iteration":686,"passed_time":20.22748604,"remaining_time":9.215725082}, +{"learn":[3.990590638],"iteration":687,"passed_time":20.25352371,"remaining_time":9.184737494}, +{"learn":[3.987421019],"iteration":688,"passed_time":20.27969562,"remaining_time":9.153824871}, +{"learn":[3.984875426],"iteration":689,"passed_time":20.30708324,"remaining_time":9.123472181}, +{"learn":[3.983259512],"iteration":690,"passed_time":20.33320261,"remaining_time":9.092560936}, +{"learn":[3.977451854],"iteration":691,"passed_time":20.372584,"remaining_time":9.067566289}, +{"learn":[3.975760211],"iteration":692,"passed_time":20.39766241,"remaining_time":9.036193883}, +{"learn":[3.972342593],"iteration":693,"passed_time":20.42387609,"remaining_time":9.005340176}, +{"learn":[3.967600289],"iteration":694,"passed_time":20.44994042,"remaining_time":8.974434287}, +{"learn":[3.961251142],"iteration":695,"passed_time":20.47878925,"remaining_time":8.944758522}, +{"learn":[3.959542542],"iteration":696,"passed_time":20.50640916,"remaining_time":8.914550897}, +{"learn":[3.956680484],"iteration":697,"passed_time":20.53238167,"remaining_time":8.883637915}, +{"learn":[3.952320243],"iteration":698,"passed_time":20.55723476,"remaining_time":8.852257029}, +{"learn":[3.949781359],"iteration":699,"passed_time":20.58435276,"remaining_time":8.821865467}, +{"learn":[3.943998991],"iteration":700,"passed_time":20.61114756,"remaining_time":8.791345392}, +{"learn":[3.943797999],"iteration":701,"passed_time":20.63713804,"remaining_time":8.760494496}, +{"learn":[3.939884026],"iteration":702,"passed_time":20.66384698,"remaining_time":8.729960955}, +{"learn":[3.936069773],"iteration":703,"passed_time":20.69369222,"remaining_time":8.700756956}, +{"learn":[3.934062424],"iteration":704,"passed_time":20.7213637,"remaining_time":8.670641548}, +{"learn":[3.933561732],"iteration":705,"passed_time":20.74734297,"remaining_time":8.639828377}, +{"learn":[3.932784425],"iteration":706,"passed_time":20.78083736,"remaining_time":8.612143347}, +{"learn":[3.932783625],"iteration":707,"passed_time":20.80718069,"remaining_time":8.581492599}, +{"learn":[3.925873007],"iteration":708,"passed_time":20.83498258,"remaining_time":8.551452653}, +{"learn":[3.919731912],"iteration":709,"passed_time":20.86175283,"remaining_time":8.520997634}, +{"learn":[3.919104987],"iteration":710,"passed_time":20.88937219,"remaining_time":8.490898119}, +{"learn":[3.916761538],"iteration":711,"passed_time":20.91515402,"remaining_time":8.4600623}, +{"learn":[3.914897185],"iteration":712,"passed_time":20.942294,"remaining_time":8.429787347}, +{"learn":[3.914184042],"iteration":713,"passed_time":20.96748706,"remaining_time":8.398741317}, +{"learn":[3.910854434],"iteration":714,"passed_time":20.99656545,"remaining_time":8.369260354}, +{"learn":[3.904997748],"iteration":715,"passed_time":21.02221004,"remaining_time":8.338418507}, +{"learn":[3.899231733],"iteration":716,"passed_time":21.06373228,"remaining_time":8.313858067}, +{"learn":[3.894304024],"iteration":717,"passed_time":21.08806638,"remaining_time":8.28249961}, +{"learn":[3.89254508],"iteration":718,"passed_time":21.11516443,"remaining_time":8.252240898}, +{"learn":[3.890636951],"iteration":719,"passed_time":21.14148496,"remaining_time":8.221688594}, +{"learn":[3.88964335],"iteration":720,"passed_time":21.17051602,"remaining_time":8.192196908}, +{"learn":[3.886600386],"iteration":721,"passed_time":21.1959558,"remaining_time":8.161323702}, +{"learn":[3.886314445],"iteration":722,"passed_time":21.22365784,"remaining_time":8.131332255}, +{"learn":[3.8851498],"iteration":723,"passed_time":21.25107062,"remaining_time":8.101236865}, +{"learn":[3.883414876],"iteration":724,"passed_time":21.27888488,"remaining_time":8.071301161}, +{"learn":[3.878088684],"iteration":725,"passed_time":21.30556125,"remaining_time":8.040941849}, +{"learn":[3.876567021],"iteration":726,"passed_time":21.33319809,"remaining_time":8.010953341}, +{"learn":[3.871736757],"iteration":727,"passed_time":21.36126031,"remaining_time":7.981130226}, +{"learn":[3.871244031],"iteration":728,"passed_time":21.38710264,"remaining_time":7.950486715}, +{"learn":[3.867953534],"iteration":729,"passed_time":21.41425299,"remaining_time":7.920340145}, +{"learn":[3.86702534],"iteration":730,"passed_time":21.44085318,"remaining_time":7.889999324}, +{"learn":[3.867014463],"iteration":731,"passed_time":21.46791395,"remaining_time":7.859837347}, +{"learn":[3.86106331],"iteration":732,"passed_time":21.5053248,"remaining_time":7.833453918}, +{"learn":[3.859242171],"iteration":733,"passed_time":21.54488441,"remaining_time":7.807819146}, +{"learn":[3.854114093],"iteration":734,"passed_time":21.57100343,"remaining_time":7.777300556}, +{"learn":[3.848413555],"iteration":735,"passed_time":21.59883553,"remaining_time":7.747408398}, +{"learn":[3.842989506],"iteration":736,"passed_time":21.62611135,"remaining_time":7.717323317}, +{"learn":[3.838695475],"iteration":737,"passed_time":21.65273189,"remaining_time":7.687013219}, +{"learn":[3.837889031],"iteration":738,"passed_time":21.67916668,"remaining_time":7.656647503}, +{"learn":[3.834531862],"iteration":739,"passed_time":21.70550654,"remaining_time":7.626259054}, +{"learn":[3.830419349],"iteration":740,"passed_time":21.74648593,"remaining_time":7.600998454}, +{"learn":[3.8301816],"iteration":741,"passed_time":21.77409527,"remaining_time":7.571046603}, +{"learn":[3.830180861],"iteration":742,"passed_time":21.80061368,"remaining_time":7.54072371}, +{"learn":[3.825330234],"iteration":743,"passed_time":21.82804029,"remaining_time":7.510723542}, +{"learn":[3.825116385],"iteration":744,"passed_time":21.85449166,"remaining_time":7.480396474}, +{"learn":[3.823593569],"iteration":745,"passed_time":21.88165386,"remaining_time":7.450321824}, +{"learn":[3.8196481],"iteration":746,"passed_time":21.90911263,"remaining_time":7.420355417}, +{"learn":[3.813765217],"iteration":747,"passed_time":21.93576908,"remaining_time":7.390125413}, +{"learn":[3.809458841],"iteration":748,"passed_time":21.96328246,"remaining_time":7.36019212}, +{"learn":[3.808672277],"iteration":749,"passed_time":21.99095035,"remaining_time":7.330316782}, +{"learn":[3.805836512],"iteration":750,"passed_time":22.01834227,"remaining_time":7.300355826}, +{"learn":[3.803780095],"iteration":751,"passed_time":22.04577773,"remaining_time":7.270416061}, +{"learn":[3.799304159],"iteration":752,"passed_time":22.07386897,"remaining_time":7.240698056}, +{"learn":[3.793935942],"iteration":753,"passed_time":22.10135261,"remaining_time":7.210786129}, +{"learn":[3.788916483],"iteration":754,"passed_time":22.12886245,"remaining_time":7.180889139}, +{"learn":[3.780373664],"iteration":755,"passed_time":22.15579486,"remaining_time":7.150812097}, +{"learn":[3.779398732],"iteration":756,"passed_time":22.18381405,"remaining_time":7.121092226}, +{"learn":[3.779197226],"iteration":757,"passed_time":22.2106515,"remaining_time":7.090999556}, +{"learn":[3.773122662],"iteration":758,"passed_time":22.25096568,"remaining_time":7.065194636}, +{"learn":[3.769846671],"iteration":759,"passed_time":22.2770325,"remaining_time":7.03485237}, +{"learn":[3.768002629],"iteration":760,"passed_time":22.3052573,"remaining_time":7.005199072}, +{"learn":[3.764894455],"iteration":761,"passed_time":22.33253333,"remaining_time":6.975253193}, +{"learn":[3.762056151],"iteration":762,"passed_time":22.3605163,"remaining_time":6.945533896}, +{"learn":[3.760824597],"iteration":763,"passed_time":22.38569796,"remaining_time":6.914953821}, +{"learn":[3.759107224],"iteration":764,"passed_time":22.41269504,"remaining_time":6.884945535}, +{"learn":[3.756007267],"iteration":765,"passed_time":22.44033569,"remaining_time":6.855141713}, +{"learn":[3.753671874],"iteration":766,"passed_time":22.46755731,"remaining_time":6.825216235}, +{"learn":[3.750400326],"iteration":767,"passed_time":22.49727945,"remaining_time":6.796053168}, +{"learn":[3.749297448],"iteration":768,"passed_time":22.52272791,"remaining_time":6.765604873}, +{"learn":[3.746556366],"iteration":769,"passed_time":22.54842234,"remaining_time":6.735243036}, +{"learn":[3.743254753],"iteration":770,"passed_time":22.5751576,"remaining_time":6.705202451}, +{"learn":[3.742330736],"iteration":771,"passed_time":22.60265075,"remaining_time":6.675394263}, +{"learn":[3.739497017],"iteration":772,"passed_time":22.62871352,"remaining_time":6.645172018}, +{"learn":[3.737241733],"iteration":773,"passed_time":22.65555578,"remaining_time":6.615188122}, +{"learn":[3.733163137],"iteration":774,"passed_time":22.68744799,"remaining_time":6.586678448}, +{"learn":[3.729663848],"iteration":775,"passed_time":22.72991863,"remaining_time":6.561213625}, +{"learn":[3.728730992],"iteration":776,"passed_time":22.75825329,"remaining_time":6.531647983}, +{"learn":[3.723038552],"iteration":777,"passed_time":22.78435861,"remaining_time":6.501449373}, +{"learn":[3.717513382],"iteration":778,"passed_time":22.81201062,"remaining_time":6.471700059}, +{"learn":[3.717327004],"iteration":779,"passed_time":22.839328,"remaining_time":6.441861745}, +{"learn":[3.717326204],"iteration":780,"passed_time":22.86531037,"remaining_time":6.411655531}, +{"learn":[3.716935992],"iteration":781,"passed_time":22.92065955,"remaining_time":6.389646781}, +{"learn":[3.715934678],"iteration":782,"passed_time":22.94832016,"remaining_time":6.359879279}, +{"learn":[3.711815421],"iteration":783,"passed_time":22.97591352,"remaining_time":6.330098623}, +{"learn":[3.710086253],"iteration":784,"passed_time":23.00408241,"remaining_time":6.30048117}, +{"learn":[3.708230952],"iteration":785,"passed_time":23.03128225,"remaining_time":6.270603563}, +{"learn":[3.705644544],"iteration":786,"passed_time":23.05712984,"remaining_time":6.240366779}, +{"learn":[3.704862455],"iteration":787,"passed_time":23.08358253,"remaining_time":6.210303929}, +{"learn":[3.70415444],"iteration":788,"passed_time":23.12823464,"remaining_time":6.18511725}, +{"learn":[3.701407918],"iteration":789,"passed_time":23.15567543,"remaining_time":6.155306127}, +{"learn":[3.69957917],"iteration":790,"passed_time":23.18434508,"remaining_time":6.12582569}, +{"learn":[3.698570077],"iteration":791,"passed_time":23.21162097,"remaining_time":6.095981265}, +{"learn":[3.696587263],"iteration":792,"passed_time":23.23821804,"remaining_time":6.065966121}, +{"learn":[3.693585307],"iteration":793,"passed_time":23.26589852,"remaining_time":6.036240673}, +{"learn":[3.693343596],"iteration":794,"passed_time":23.30832364,"remaining_time":6.010322449}, +{"learn":[3.68884961],"iteration":795,"passed_time":23.33564513,"remaining_time":5.980491969}, +{"learn":[3.687765069],"iteration":796,"passed_time":23.37802461,"remaining_time":5.95450313}, +{"learn":[3.684139554],"iteration":797,"passed_time":23.41589284,"remaining_time":5.92733127}, +{"learn":[3.682973227],"iteration":798,"passed_time":23.44129881,"remaining_time":5.896997573}, +{"learn":[3.679813455],"iteration":799,"passed_time":23.46991492,"remaining_time":5.867478729}, +{"learn":[3.676862111],"iteration":800,"passed_time":23.49706061,"remaining_time":5.837596832}, +{"learn":[3.676860986],"iteration":801,"passed_time":23.53968303,"remaining_time":5.811542694}, +{"learn":[3.670214102],"iteration":802,"passed_time":23.56562754,"remaining_time":5.781355699}, +{"learn":[3.668143742],"iteration":803,"passed_time":23.59246,"remaining_time":5.751395722}, +{"learn":[3.662024558],"iteration":804,"passed_time":23.61862879,"remaining_time":5.721282751}, +{"learn":[3.661849831],"iteration":805,"passed_time":23.64521643,"remaining_time":5.691280381}, +{"learn":[3.65672535],"iteration":806,"passed_time":23.68940019,"remaining_time":5.665494717}, +{"learn":[3.650817304],"iteration":807,"passed_time":23.72102379,"remaining_time":5.636678921}, +{"learn":[3.648015458],"iteration":808,"passed_time":23.746723,"remaining_time":5.60645747}, +{"learn":[3.645562403],"iteration":809,"passed_time":23.77268764,"remaining_time":5.576309447}, +{"learn":[3.642641794],"iteration":810,"passed_time":23.80704866,"remaining_time":5.548128479}, +{"learn":[3.640010725],"iteration":811,"passed_time":23.83962232,"remaining_time":5.519518469}, +{"learn":[3.638098571],"iteration":812,"passed_time":23.8694384,"remaining_time":5.490264429}, +{"learn":[3.634369651],"iteration":813,"passed_time":23.9056016,"remaining_time":5.462459334}, +{"learn":[3.632357423],"iteration":814,"passed_time":23.93182391,"remaining_time":5.432377208}, +{"learn":[3.630719581],"iteration":815,"passed_time":23.95795776,"remaining_time":5.402284592}, +{"learn":[3.6282957],"iteration":816,"passed_time":23.98347498,"remaining_time":5.372063552}, +{"learn":[3.624702515],"iteration":817,"passed_time":24.01062404,"remaining_time":5.342217084}, +{"learn":[3.62121705],"iteration":818,"passed_time":24.03706192,"remaining_time":5.312220033}, +{"learn":[3.618614636],"iteration":819,"passed_time":24.06289572,"remaining_time":5.28209906}, +{"learn":[3.609915518],"iteration":820,"passed_time":24.09060305,"remaining_time":5.25239701}, +{"learn":[3.60547361],"iteration":821,"passed_time":24.11652687,"remaining_time":5.222313604}, +{"learn":[3.605232121],"iteration":822,"passed_time":24.14508342,"remaining_time":5.192806519}, +{"learn":[3.604026256],"iteration":823,"passed_time":24.17344191,"remaining_time":5.163259438}, +{"learn":[3.60223655],"iteration":824,"passed_time":24.20063488,"remaining_time":5.133468005}, +{"learn":[3.597290223],"iteration":825,"passed_time":24.22634932,"remaining_time":5.103371405}, +{"learn":[3.594862734],"iteration":826,"passed_time":24.25371492,"remaining_time":5.073630812}, +{"learn":[3.592061768],"iteration":827,"passed_time":24.27928606,"remaining_time":5.04352319}, +{"learn":[3.587447029],"iteration":828,"passed_time":24.30618896,"remaining_time":5.01370122}, +{"learn":[3.58743466],"iteration":829,"passed_time":24.33528272,"remaining_time":4.984335014}, +{"learn":[3.586440433],"iteration":830,"passed_time":24.36189959,"remaining_time":4.954465741}, +{"learn":[3.583533931],"iteration":831,"passed_time":24.38876558,"remaining_time":4.924654589}, +{"learn":[3.58312837],"iteration":832,"passed_time":24.41536234,"remaining_time":4.894796532}, +{"learn":[3.581414251],"iteration":833,"passed_time":24.4738189,"remaining_time":4.871287694}, +{"learn":[3.57935402],"iteration":834,"passed_time":24.50302039,"remaining_time":4.841914209}, +{"learn":[3.575183325],"iteration":835,"passed_time":24.54690998,"remaining_time":4.815422532}, +{"learn":[3.570305144],"iteration":836,"passed_time":24.5724064,"remaining_time":4.78530734}, +{"learn":[3.56817989],"iteration":837,"passed_time":24.5987458,"remaining_time":4.755366134}, +{"learn":[3.564980762],"iteration":838,"passed_time":24.62514237,"remaining_time":4.725444483}, +{"learn":[3.561248045],"iteration":839,"passed_time":24.65160634,"remaining_time":4.695544064}, +{"learn":[3.560676841],"iteration":840,"passed_time":24.67841989,"remaining_time":4.66571791}, +{"learn":[3.557303682],"iteration":841,"passed_time":24.70639945,"remaining_time":4.636117711}, +{"learn":[3.551800692],"iteration":842,"passed_time":24.73829047,"remaining_time":4.607249826}, +{"learn":[3.548281689],"iteration":843,"passed_time":24.76351628,"remaining_time":4.57714282}, +{"learn":[3.546813403],"iteration":844,"passed_time":24.79056254,"remaining_time":4.547381294}, +{"learn":[3.542273534],"iteration":845,"passed_time":24.81680081,"remaining_time":4.517479106}, +{"learn":[3.541420393],"iteration":846,"passed_time":24.84481576,"remaining_time":4.487906507}, +{"learn":[3.540819093],"iteration":847,"passed_time":24.87115835,"remaining_time":4.458037818}, +{"learn":[3.536771861],"iteration":848,"passed_time":24.89813961,"remaining_time":4.428291025}, +{"learn":[3.531581189],"iteration":849,"passed_time":24.92478621,"remaining_time":4.398491684}, +{"learn":[3.528630759],"iteration":850,"passed_time":24.96746842,"remaining_time":4.371507397}, +{"learn":[3.524574299],"iteration":851,"passed_time":24.99283852,"remaining_time":4.341478991}, +{"learn":[3.520611084],"iteration":852,"passed_time":25.01961705,"remaining_time":4.311704228}, +{"learn":[3.51941272],"iteration":853,"passed_time":25.04753264,"remaining_time":4.282130872}, +{"learn":[3.517256478],"iteration":854,"passed_time":25.07294922,"remaining_time":4.252137586}, +{"learn":[3.517126089],"iteration":855,"passed_time":25.10084548,"remaining_time":4.222572137}, +{"learn":[3.516527637],"iteration":856,"passed_time":25.13134577,"remaining_time":4.193445093}, +{"learn":[3.516382259],"iteration":857,"passed_time":25.16669316,"remaining_time":4.165117049}, +{"learn":[3.513012499],"iteration":858,"passed_time":25.19249339,"remaining_time":4.135205551}, +{"learn":[3.512084026],"iteration":859,"passed_time":25.22869098,"remaining_time":4.106996206}, +{"learn":[3.507025209],"iteration":860,"passed_time":25.25722369,"remaining_time":4.077530886}, +{"learn":[3.50364826],"iteration":861,"passed_time":25.28390697,"remaining_time":4.047771649}, +{"learn":[3.50050135],"iteration":862,"passed_time":25.31104077,"remaining_time":4.018091061}, +{"learn":[3.50004915],"iteration":863,"passed_time":25.3390484,"remaining_time":3.988553915}, +{"learn":[3.497942827],"iteration":864,"passed_time":25.36446406,"remaining_time":3.958615779}, +{"learn":[3.496333618],"iteration":865,"passed_time":25.39177522,"remaining_time":3.928981385}, +{"learn":[3.491419841],"iteration":866,"passed_time":25.41946278,"remaining_time":3.899410093}, +{"learn":[3.488233694],"iteration":867,"passed_time":25.44649365,"remaining_time":3.869743273}, +{"learn":[3.485575107],"iteration":868,"passed_time":25.47314423,"remaining_time":3.840025195}, +{"learn":[3.483879021],"iteration":869,"passed_time":25.51616598,"remaining_time":3.812760434}, +{"learn":[3.483429571],"iteration":870,"passed_time":25.54417408,"remaining_time":3.783235886}, +{"learn":[3.479844265],"iteration":871,"passed_time":25.57116766,"remaining_time":3.753565896}, +{"learn":[3.477559243],"iteration":872,"passed_time":25.59741177,"remaining_time":3.723793007}, +{"learn":[3.47377196],"iteration":873,"passed_time":25.62489269,"remaining_time":3.694206497}, +{"learn":[3.468124821],"iteration":874,"passed_time":25.65125659,"remaining_time":3.664465227}, +{"learn":[3.466921718],"iteration":875,"passed_time":25.67593275,"remaining_time":3.634492764}, +{"learn":[3.461149048],"iteration":876,"passed_time":25.70530585,"remaining_time":3.605191128}, +{"learn":[3.459516828],"iteration":877,"passed_time":25.73140046,"remaining_time":3.575433777}, +{"learn":[3.456806927],"iteration":878,"passed_time":25.76161653,"remaining_time":3.546252105}, +{"learn":[3.456149562],"iteration":879,"passed_time":25.78685248,"remaining_time":3.516388975}, +{"learn":[3.453164846],"iteration":880,"passed_time":25.81510461,"remaining_time":3.486943756}, +{"learn":[3.451453582],"iteration":881,"passed_time":25.85824682,"remaining_time":3.459493338}, +{"learn":[3.449654043],"iteration":882,"passed_time":25.88702781,"remaining_time":3.430104478}, +{"learn":[3.445730537],"iteration":883,"passed_time":25.91306665,"remaining_time":3.400357162}, +{"learn":[3.440188788],"iteration":884,"passed_time":25.94948116,"remaining_time":3.371966479}, +{"learn":[3.439295289],"iteration":885,"passed_time":25.97610953,"remaining_time":3.342298518}, +{"learn":[3.436022852],"iteration":886,"passed_time":26.00419764,"remaining_time":3.312823374}, +{"learn":[3.435005804],"iteration":887,"passed_time":26.04010231,"remaining_time":3.284337228}, +{"learn":[3.430079068],"iteration":888,"passed_time":26.06693494,"remaining_time":3.254701662}, +{"learn":[3.429272827],"iteration":889,"passed_time":26.09498884,"remaining_time":3.22522334}, +{"learn":[3.428004187],"iteration":890,"passed_time":26.13753596,"remaining_time":3.197521235}, +{"learn":[3.42664981],"iteration":891,"passed_time":26.16714076,"remaining_time":3.168218836}, +{"learn":[3.424154056],"iteration":892,"passed_time":26.19331551,"remaining_time":3.13850477}, +{"learn":[3.42147428],"iteration":893,"passed_time":26.24123581,"remaining_time":3.111376953}, +{"learn":[3.419797236],"iteration":894,"passed_time":26.26675567,"remaining_time":3.081574688}, +{"learn":[3.418220387],"iteration":895,"passed_time":26.2967117,"remaining_time":3.052296893}, +{"learn":[3.414847191],"iteration":896,"passed_time":26.32472974,"remaining_time":3.022795054}, +{"learn":[3.413591164],"iteration":897,"passed_time":26.35226037,"remaining_time":2.993241155}, +{"learn":[3.411829725],"iteration":898,"passed_time":26.37728528,"remaining_time":2.963410248}, +{"learn":[3.407247368],"iteration":899,"passed_time":26.41794146,"remaining_time":2.935326829}, +{"learn":[3.405464242],"iteration":900,"passed_time":26.44723606,"remaining_time":2.905967114}, +{"learn":[3.402054531],"iteration":901,"passed_time":26.47231673,"remaining_time":2.876149712}, +{"learn":[3.40181483],"iteration":902,"passed_time":26.50067824,"remaining_time":2.846695226}, +{"learn":[3.400273555],"iteration":903,"passed_time":26.52686155,"remaining_time":2.817011846}, +{"learn":[3.397921518],"iteration":904,"passed_time":26.55276508,"remaining_time":2.787306832}, +{"learn":[3.396431072],"iteration":905,"passed_time":26.57953256,"remaining_time":2.757699847}, +{"learn":[3.393732841],"iteration":906,"passed_time":26.60542761,"remaining_time":2.728009667}, +{"learn":[3.392920628],"iteration":907,"passed_time":26.63225991,"remaining_time":2.69842281}, +{"learn":[3.390110114],"iteration":908,"passed_time":26.65839809,"remaining_time":2.668772526}, +{"learn":[3.388595441],"iteration":909,"passed_time":26.68566217,"remaining_time":2.639241314}, +{"learn":[3.386985252],"iteration":910,"passed_time":26.71069343,"remaining_time":2.609496943}, +{"learn":[3.382015717],"iteration":911,"passed_time":26.73747312,"remaining_time":2.579931617}, +{"learn":[3.380551574],"iteration":912,"passed_time":26.7629588,"remaining_time":2.550249087}, +{"learn":[3.378788438],"iteration":913,"passed_time":26.78971855,"remaining_time":2.520695619}, +{"learn":[3.377721223],"iteration":914,"passed_time":26.81761569,"remaining_time":2.491253916}, +{"learn":[3.376911249],"iteration":915,"passed_time":26.84385794,"remaining_time":2.461663829}, +{"learn":[3.373417759],"iteration":916,"passed_time":26.88647604,"remaining_time":2.433563262}, +{"learn":[3.372732742],"iteration":917,"passed_time":26.91387947,"remaining_time":2.404072023}, +{"learn":[3.372600298],"iteration":918,"passed_time":26.95246749,"remaining_time":2.375571128}, +{"learn":[3.368659706],"iteration":919,"passed_time":26.98072654,"remaining_time":2.346150134}, +{"learn":[3.364562474],"iteration":920,"passed_time":27.00569165,"remaining_time":2.316449121}, +{"learn":[3.362472241],"iteration":921,"passed_time":27.03282209,"remaining_time":2.286941565}, +{"learn":[3.361646962],"iteration":922,"passed_time":27.0581361,"remaining_time":2.257287627}, +{"learn":[3.358861489],"iteration":923,"passed_time":27.08494707,"remaining_time":2.227766209}, +{"learn":[3.356955858],"iteration":924,"passed_time":27.12909497,"remaining_time":2.199656349}, +{"learn":[3.353174551],"iteration":925,"passed_time":27.15804689,"remaining_time":2.170297484}, +{"learn":[3.352182825],"iteration":926,"passed_time":27.18463863,"remaining_time":2.140753636}, +{"learn":[3.351101708],"iteration":927,"passed_time":27.21238174,"remaining_time":2.11130548}, +{"learn":[3.34898966],"iteration":928,"passed_time":27.23835979,"remaining_time":2.081726098}, +{"learn":[3.348630558],"iteration":929,"passed_time":27.2665018,"remaining_time":2.05231734}, +{"learn":[3.343254485],"iteration":930,"passed_time":27.29292536,"remaining_time":2.022783942}, +{"learn":[3.342033926],"iteration":931,"passed_time":27.3217955,"remaining_time":1.993435723}, +{"learn":[3.340737433],"iteration":932,"passed_time":27.34996193,"remaining_time":1.964037995}, +{"learn":[3.339144168],"iteration":933,"passed_time":27.37678396,"remaining_time":1.934547903}, +{"learn":[3.333577461],"iteration":934,"passed_time":27.40346125,"remaining_time":1.905053456}, +{"learn":[3.332448295],"iteration":935,"passed_time":27.4312071,"remaining_time":1.875638092}, +{"learn":[3.331198626],"iteration":936,"passed_time":27.47209839,"remaining_time":1.847110137}, +{"learn":[3.327927888],"iteration":937,"passed_time":27.50100228,"remaining_time":1.817763477}, +{"learn":[3.324592275],"iteration":938,"passed_time":27.52714728,"remaining_time":1.788238534}, +{"learn":[3.32381222],"iteration":939,"passed_time":27.55597675,"remaining_time":1.758892133}, +{"learn":[3.322602574],"iteration":940,"passed_time":27.58134648,"remaining_time":1.729329907}, +{"learn":[3.31850546],"iteration":941,"passed_time":27.61055007,"remaining_time":1.700012637}, +{"learn":[3.317361352],"iteration":942,"passed_time":27.63860446,"remaining_time":1.670626145}, +{"learn":[3.31531718],"iteration":943,"passed_time":27.67416888,"remaining_time":1.641687984}, +{"learn":[3.313649176],"iteration":944,"passed_time":27.70241063,"remaining_time":1.612309613}, +{"learn":[3.311511541],"iteration":945,"passed_time":27.73038328,"remaining_time":1.582918284}, +{"learn":[3.308772142],"iteration":946,"passed_time":27.76067808,"remaining_time":1.553659914}, +{"learn":[3.307302565],"iteration":947,"passed_time":27.78986537,"remaining_time":1.524338607}, +{"learn":[3.305675371],"iteration":948,"passed_time":27.81519355,"remaining_time":1.494810191}, +{"learn":[3.304642431],"iteration":949,"passed_time":27.84271694,"remaining_time":1.465406155}, +{"learn":[3.303324494],"iteration":950,"passed_time":27.87075929,"remaining_time":1.436032813}, +{"learn":[3.301779618],"iteration":951,"passed_time":27.89826838,"remaining_time":1.406635381}, +{"learn":[3.298413116],"iteration":952,"passed_time":27.92575273,"remaining_time":1.377240691}, +{"learn":[3.296544406],"iteration":953,"passed_time":27.95310539,"remaining_time":1.347843656}, +{"learn":[3.295659859],"iteration":954,"passed_time":27.99247943,"remaining_time":1.319017356}, +{"learn":[3.295427314],"iteration":955,"passed_time":28.03391416,"remaining_time":1.290263832}, +{"learn":[3.294632872],"iteration":956,"passed_time":28.06122985,"remaining_time":1.260849408}, +{"learn":[3.294075719],"iteration":957,"passed_time":28.08790655,"remaining_time":1.231411352}, +{"learn":[3.293454663],"iteration":958,"passed_time":28.1142764,"remaining_time":1.201965936}, +{"learn":[3.292261473],"iteration":959,"passed_time":28.14962717,"remaining_time":1.172901132}, +{"learn":[3.290276795],"iteration":960,"passed_time":28.17663051,"remaining_time":1.143484485}, +{"learn":[3.289025886],"iteration":961,"passed_time":28.21477293,"remaining_time":1.11451286}, +{"learn":[3.285308319],"iteration":962,"passed_time":28.24160967,"remaining_time":1.085087807}, +{"learn":[3.282777049],"iteration":963,"passed_time":28.26833506,"remaining_time":1.055663965}, +{"learn":[3.279650799],"iteration":964,"passed_time":28.30131253,"remaining_time":1.026472475}, +{"learn":[3.278910906],"iteration":965,"passed_time":28.33373784,"remaining_time":0.9972537127}, +{"learn":[3.276885194],"iteration":966,"passed_time":28.35985461,"remaining_time":0.9678130324}, +{"learn":[3.276139154],"iteration":967,"passed_time":28.38645661,"remaining_time":0.9383952598}, +{"learn":[3.273550145],"iteration":968,"passed_time":28.41528719,"remaining_time":0.9090545954}, +{"learn":[3.269697382],"iteration":969,"passed_time":28.45743901,"remaining_time":0.8801269796}, +{"learn":[3.267733388],"iteration":970,"passed_time":28.48338932,"remaining_time":0.8506882495}, +{"learn":[3.263122871],"iteration":971,"passed_time":28.5199477,"remaining_time":0.8215622793}, +{"learn":[3.26144263],"iteration":972,"passed_time":28.54596052,"remaining_time":0.7921284008}, +{"learn":[3.258592836],"iteration":973,"passed_time":28.57411162,"remaining_time":0.7627586265}, +{"learn":[3.25603903],"iteration":974,"passed_time":28.60010512,"remaining_time":0.7333360286}, +{"learn":[3.254617725],"iteration":975,"passed_time":28.62875616,"remaining_time":0.7039858072}, +{"learn":[3.252926053],"iteration":976,"passed_time":28.65479423,"remaining_time":0.6745755039}, +{"learn":[3.251200809],"iteration":977,"passed_time":28.68161865,"remaining_time":0.6451897855}, +{"learn":[3.250229087],"iteration":978,"passed_time":28.70741169,"remaining_time":0.6157871761}, +{"learn":[3.248580362],"iteration":979,"passed_time":28.73376849,"remaining_time":0.5864034385}, +{"learn":[3.245873806],"iteration":980,"passed_time":28.75919634,"remaining_time":0.5570078802}, +{"learn":[3.243447442],"iteration":981,"passed_time":28.79134261,"remaining_time":0.5277435509}, +{"learn":[3.242799048],"iteration":982,"passed_time":28.83351952,"remaining_time":0.4986468279}, +{"learn":[3.242540875],"iteration":983,"passed_time":28.86027657,"remaining_time":0.4692727898}, +{"learn":[3.238884783],"iteration":984,"passed_time":28.88533601,"remaining_time":0.4398782133}, +{"learn":[3.237129627],"iteration":985,"passed_time":28.91341113,"remaining_time":0.4105352494}, +{"learn":[3.234918061],"iteration":986,"passed_time":28.94077054,"remaining_time":0.3811854276}, +{"learn":[3.232608492],"iteration":987,"passed_time":28.96963269,"remaining_time":0.3518578869}, +{"learn":[3.229573155],"iteration":988,"passed_time":28.99472517,"remaining_time":0.3224893599}, +{"learn":[3.226056975],"iteration":989,"passed_time":29.02268136,"remaining_time":0.2931583976}, +{"learn":[3.225471932],"iteration":990,"passed_time":29.04877447,"remaining_time":0.2638132899}, +{"learn":[3.224036703],"iteration":991,"passed_time":29.07417768,"remaining_time":0.2344691749}, +{"learn":[3.219677231],"iteration":992,"passed_time":29.11861951,"remaining_time":0.205267207}, +{"learn":[3.217445788],"iteration":993,"passed_time":29.16087856,"remaining_time":0.1760213998}, +{"learn":[3.215003381],"iteration":994,"passed_time":29.18877468,"remaining_time":0.1466772597}, +{"learn":[3.211103611],"iteration":995,"passed_time":29.22037363,"remaining_time":0.1173508981}, +{"learn":[3.210005671],"iteration":996,"passed_time":29.27461812,"remaining_time":0.08808811871}, +{"learn":[3.208173478],"iteration":997,"passed_time":29.31678224,"remaining_time":0.05875106661}, +{"learn":[3.20596231],"iteration":998,"passed_time":29.34502797,"remaining_time":0.02937440237}, +{"learn":[3.204588605],"iteration":999,"passed_time":29.36980261,"remaining_time":0} +]} \ No newline at end of file diff --git a/boruta/examples/catboost_info/learn/events.out.tfevents b/boruta/examples/catboost_info/learn/events.out.tfevents new file mode 100644 index 0000000..1dae7c2 Binary files /dev/null and b/boruta/examples/catboost_info/learn/events.out.tfevents differ diff --git a/boruta/examples/catboost_info/learn_error.tsv b/boruta/examples/catboost_info/learn_error.tsv new file mode 100644 index 0000000..fc49359 --- /dev/null +++ b/boruta/examples/catboost_info/learn_error.tsv @@ -0,0 +1,1001 @@ +iter RMSE +0 9.306297515 +1 9.21580425 +2 9.12533741 +3 9.046805853 +4 8.96821819 +5 8.898438591 +6 8.81479703 +7 8.762090798 +8 8.683687727 +9 8.618491334 +10 8.539419964 +11 8.486822402 +12 8.428148864 +13 8.384020819 +14 8.342972216 +15 8.289024716 +16 8.235986159 +17 8.180603523 +18 8.131127119 +19 8.093087148 +20 8.052593873 +21 8.006721596 +22 7.971430834 +23 7.929157099 +24 7.900634096 +25 7.861003776 +26 7.826563928 +27 7.789488461 +28 7.749706084 +29 7.719616281 +30 7.674626622 +31 7.651647678 +32 7.617526004 +33 7.574388178 +34 7.538184566 +35 7.510672056 +36 7.484848616 +37 7.443014706 +38 7.418462339 +39 7.376998707 +40 7.353447121 +41 7.321153483 +42 7.287449358 +43 7.251488693 +44 7.2383362 +45 7.216234343 +46 7.198404554 +47 7.177252198 +48 7.164703518 +49 7.1521049 +50 7.127862402 +51 7.107018264 +52 7.094865795 +53 7.075006396 +54 7.051048719 +55 7.038764118 +56 7.009651127 +57 6.996694598 +58 6.978654187 +59 6.969776604 +60 6.954441817 +61 6.932883026 +62 6.917175292 +63 6.902595892 +64 6.887459389 +65 6.875213925 +66 6.852972446 +67 6.828957383 +68 6.817855354 +69 6.80595976 +70 6.791965865 +71 6.777822093 +72 6.766576643 +73 6.752653775 +74 6.743335111 +75 6.728182951 +76 6.716220956 +77 6.698745275 +78 6.687924223 +79 6.671577812 +80 6.651217 +81 6.649087833 +82 6.630157908 +83 6.616275305 +84 6.607533031 +85 6.599297789 +86 6.586425764 +87 6.569831007 +88 6.565380784 +89 6.549139075 +90 6.537012133 +91 6.531194539 +92 6.510934582 +93 6.506204288 +94 6.491867296 +95 6.473723898 +96 6.464631348 +97 6.450326755 +98 6.443832888 +99 6.431655464 +100 6.420913004 +101 6.413341173 +102 6.409779361 +103 6.395028109 +104 6.388814686 +105 6.370728269 +106 6.361275485 +107 6.344403735 +108 6.337169293 +109 6.33059718 +110 6.31547966 +111 6.308599042 +112 6.296427708 +113 6.287715725 +114 6.281914794 +115 6.27414496 +116 6.273972211 +117 6.26641996 +118 6.254857409 +119 6.247723264 +120 6.238526451 +121 6.235189859 +122 6.220870429 +123 6.212054644 +124 6.209153611 +125 6.200536449 +126 6.197102468 +127 6.191672907 +128 6.175650415 +129 6.163677768 +130 6.154094013 +131 6.151734128 +132 6.145210682 +133 6.132945405 +134 6.131330087 +135 6.122165088 +136 6.11819553 +137 6.116812798 +138 6.116802748 +139 6.111216141 +140 6.101604882 +141 6.094570532 +142 6.086099332 +143 6.077564797 +144 6.071976957 +145 6.068463513 +146 6.056773675 +147 6.048002516 +148 6.039974132 +149 6.036905216 +150 6.030600038 +151 6.025473281 +152 6.023958932 +153 6.018452312 +154 6.015954732 +155 6.011714814 +156 5.996632322 +157 5.99326434 +158 5.990077105 +159 5.983547432 +160 5.980644516 +161 5.977468288 +162 5.96567149 +163 5.964824081 +164 5.959363378 +165 5.952631589 +166 5.951932566 +167 5.939750375 +168 5.932763585 +169 5.930592479 +170 5.91904232 +171 5.911315574 +172 5.904578813 +173 5.89700148 +174 5.889260982 +175 5.877596953 +176 5.871508542 +177 5.863873424 +178 5.855137593 +179 5.846758951 +180 5.845148336 +181 5.844477677 +182 5.841182047 +183 5.839715088 +184 5.835804128 +185 5.829678437 +186 5.824781701 +187 5.819806294 +188 5.807032107 +189 5.805007583 +190 5.799966878 +191 5.794310032 +192 5.786388304 +193 5.785116104 +194 5.774030991 +195 5.768576166 +196 5.763424597 +197 5.757592676 +198 5.757375326 +199 5.753843902 +200 5.746157049 +201 5.745978742 +202 5.732782027 +203 5.728649678 +204 5.727949924 +205 5.721397052 +206 5.713048232 +207 5.707233267 +208 5.699670245 +209 5.691272338 +210 5.691098011 +211 5.68827298 +212 5.685451133 +213 5.683989338 +214 5.680232986 +215 5.674510741 +216 5.674339162 +217 5.673261428 +218 5.666761068 +219 5.658970524 +220 5.653131084 +221 5.650958719 +222 5.643169486 +223 5.634112254 +224 5.630876573 +225 5.629595639 +226 5.626804751 +227 5.624914942 +228 5.62209936 +229 5.619281932 +230 5.616540954 +231 5.610927866 +232 5.604278957 +233 5.602544514 +234 5.59788989 +235 5.595738611 +236 5.585270962 +237 5.581115882 +238 5.577791906 +239 5.574409273 +240 5.570908772 +241 5.565394991 +242 5.559976052 +243 5.55483665 +244 5.552674644 +245 5.552031971 +246 5.55187056 +247 5.551213706 +248 5.549666242 +249 5.548115994 +250 5.544295921 +251 5.537733631 +252 5.536140612 +253 5.527248619 +254 5.522729377 +255 5.520965137 +256 5.520463001 +257 5.509022048 +258 5.504591918 +259 5.498471855 +260 5.496409469 +261 5.490889618 +262 5.488373132 +263 5.480369352 +264 5.479180537 +265 5.475534605 +266 5.468400809 +267 5.458346782 +268 5.453291742 +269 5.449961225 +270 5.445974412 +271 5.441847935 +272 5.436979277 +273 5.435541558 +274 5.435089808 +275 5.428992797 +276 5.427042701 +277 5.423559135 +278 5.422965732 +279 5.414410675 +280 5.410915981 +281 5.409658109 +282 5.406195492 +283 5.404200538 +284 5.400063404 +285 5.399152148 +286 5.393798614 +287 5.393422472 +288 5.389275826 +289 5.383474018 +290 5.373957786 +291 5.365248295 +292 5.361896159 +293 5.352794364 +294 5.348089397 +295 5.341953259 +296 5.337808733 +297 5.337560165 +298 5.335720017 +299 5.330115528 +300 5.326790004 +301 5.324865482 +302 5.323039153 +303 5.322134431 +304 5.307985551 +305 5.299105282 +306 5.291757675 +307 5.283694383 +308 5.283278167 +309 5.282608192 +310 5.281079582 +311 5.279476583 +312 5.275666464 +313 5.27523769 +314 5.273863576 +315 5.268063011 +316 5.266887189 +317 5.261823558 +318 5.257471241 +319 5.253391392 +320 5.248636576 +321 5.248104218 +322 5.238003344 +323 5.234250311 +324 5.231629095 +325 5.228882929 +326 5.223447947 +327 5.222639852 +328 5.217785155 +329 5.211000043 +330 5.197835086 +331 5.195956359 +332 5.194227857 +333 5.193656032 +334 5.193234917 +335 5.19132427 +336 5.190458072 +337 5.189763508 +338 5.176690114 +339 5.176225337 +340 5.173572331 +341 5.165146202 +342 5.160527906 +343 5.154822109 +344 5.14798121 +345 5.141607911 +346 5.131449509 +347 5.130054899 +348 5.119946204 +349 5.112369317 +350 5.110293151 +351 5.100965209 +352 5.100495606 +353 5.099706493 +354 5.087433987 +355 5.080084168 +356 5.076425088 +357 5.072249926 +358 5.064093237 +359 5.062475398 +360 5.062361702 +361 5.057242931 +362 5.055591118 +363 5.047764746 +364 5.047064223 +365 5.0445546 +366 5.041126001 +367 5.038059824 +368 5.037267399 +369 5.035548576 +370 5.030392894 +371 5.029642673 +372 5.027271244 +373 5.024773873 +374 5.016410001 +375 5.008028182 +376 5.004436453 +377 5.004155567 +378 4.998066017 +379 4.996871469 +380 4.988367262 +381 4.983654187 +382 4.982372718 +383 4.97834342 +384 4.974104901 +385 4.964633435 +386 4.963053945 +387 4.95718563 +388 4.956531594 +389 4.956438109 +390 4.953071368 +391 4.947372064 +392 4.945999404 +393 4.938835395 +394 4.937852727 +395 4.934619338 +396 4.933658837 +397 4.928963356 +398 4.925288065 +399 4.923243053 +400 4.918170037 +401 4.917171729 +402 4.909951118 +403 4.905013948 +404 4.904694938 +405 4.900543075 +406 4.895223316 +407 4.89135731 +408 4.884327946 +409 4.883030848 +410 4.880893252 +411 4.880801262 +412 4.870751028 +413 4.868467907 +414 4.860514297 +415 4.860422305 +416 4.855418447 +417 4.851916444 +418 4.849504783 +419 4.846850505 +420 4.8463838 +421 4.833032034 +422 4.83139662 +423 4.83109765 +424 4.829716852 +425 4.825015227 +426 4.823351034 +427 4.817559026 +428 4.813421647 +429 4.803560893 +430 4.803253062 +431 4.801843861 +432 4.799063783 +433 4.796621518 +434 4.791081182 +435 4.790805067 +436 4.787655069 +437 4.783852468 +438 4.779159432 +439 4.778886619 +440 4.775664898 +441 4.771376172 +442 4.764875837 +443 4.763716858 +444 4.759339438 +445 4.757997517 +446 4.75594894 +447 4.752371509 +448 4.750610217 +449 4.749695429 +450 4.745288316 +451 4.745158807 +452 4.736325135 +453 4.735711638 +454 4.732150655 +455 4.730025501 +456 4.728772563 +457 4.725847827 +458 4.718615738 +459 4.717367483 +460 4.714338934 +461 4.713140169 +462 4.711807757 +463 4.707974665 +464 4.704359765 +465 4.700946192 +466 4.700708352 +467 4.696698443 +468 4.690153753 +469 4.684763998 +470 4.682898224 +471 4.678749408 +472 4.671459419 +473 4.666429971 +474 4.664630169 +475 4.662199704 +476 4.655992647 +477 4.652068465 +478 4.650420351 +479 4.643418993 +480 4.636460035 +481 4.632968064 +482 4.631112578 +483 4.6293636 +484 4.628456212 +485 4.626240139 +486 4.620625778 +487 4.61969543 +488 4.616396959 +489 4.611743573 +490 4.605125583 +491 4.599340081 +492 4.595985806 +493 4.595169345 +494 4.593957744 +495 4.586480218 +496 4.585228769 +497 4.582154705 +498 4.577741412 +499 4.569967684 +500 4.565214419 +501 4.559741129 +502 4.554412282 +503 4.552067677 +504 4.550391882 +505 4.543945396 +506 4.539138209 +507 4.534808114 +508 4.534007757 +509 4.529902812 +510 4.529726299 +511 4.527095406 +512 4.522285697 +513 4.51698853 +514 4.51096004 +515 4.503553965 +516 4.49733747 +517 4.496504532 +518 4.495742877 +519 4.494791653 +520 4.494089839 +521 4.489743028 +522 4.488833907 +523 4.485718458 +524 4.482639287 +525 4.478967464 +526 4.47301574 +527 4.47228902 +528 4.46992917 +529 4.467743559 +530 4.466739542 +531 4.465962742 +532 4.459746787 +533 4.457368533 +534 4.453478498 +535 4.448082313 +536 4.446245205 +537 4.44605768 +538 4.443683655 +539 4.440201548 +540 4.43952352 +541 4.433705805 +542 4.433056866 +543 4.432131333 +544 4.429760282 +545 4.424853426 +546 4.420597851 +547 4.419715603 +548 4.416857931 +549 4.416751803 +550 4.413781681 +551 4.412353329 +552 4.408311774 +553 4.405806977 +554 4.400871654 +555 4.389815979 +556 4.386545456 +557 4.383411269 +558 4.382759626 +559 4.382133476 +560 4.382029015 +561 4.381773197 +562 4.376556147 +563 4.369684655 +564 4.365271614 +565 4.361005243 +566 4.359810417 +567 4.35431967 +568 4.350078041 +569 4.347685906 +570 4.343337767 +571 4.342712275 +572 4.342277694 +573 4.332624195 +574 4.329167588 +575 4.325424555 +576 4.323798455 +577 4.322874075 +578 4.312675925 +579 4.312066378 +580 4.311644336 +581 4.309866209 +582 4.303820966 +583 4.301719897 +584 4.301116937 +585 4.296892323 +586 4.296798657 +587 4.295802374 +588 4.295568374 +589 4.289932713 +590 4.289110276 +591 4.284767629 +592 4.284588826 +593 4.279402731 +594 4.277190701 +595 4.272370955 +596 4.270297853 +597 4.268776171 +598 4.265613012 +599 4.265604058 +600 4.265512073 +601 4.257606792 +602 4.255100218 +603 4.251343472 +604 4.248730627 +605 4.24535366 +606 4.23980014 +607 4.230214392 +608 4.228698521 +609 4.226493066 +610 4.225908823 +611 4.217229516 +612 4.215123825 +613 4.213042615 +614 4.205833243 +615 4.204781921 +616 4.197797069 +617 4.191870868 +618 4.189100979 +619 4.188331058 +620 4.187494733 +621 4.178993585 +622 4.178263596 +623 4.172446931 +624 4.165931178 +625 4.165125986 +626 4.161355207 +627 4.159123482 +628 4.157733657 +629 4.157523496 +630 4.156921403 +631 4.15567469 +632 4.154874737 +633 4.153824149 +634 4.153513209 +635 4.150174445 +636 4.143543617 +637 4.142518496 +638 4.140609976 +639 4.140600597 +640 4.133577581 +641 4.130973197 +642 4.126592036 +643 4.12533841 +644 4.125005984 +645 4.121664479 +646 4.118756341 +647 4.116685314 +648 4.116484168 +649 4.114730813 +650 4.1121717 +651 4.108903332 +652 4.106063639 +653 4.103386538 +654 4.099811948 +655 4.097520622 +656 4.095728877 +657 4.091648173 +658 4.090300946 +659 4.090293168 +660 4.083458536 +661 4.078376128 +662 4.075150531 +663 4.069712197 +664 4.068562429 +665 4.064921332 +666 4.060630454 +667 4.059920051 +668 4.05606486 +669 4.053790151 +670 4.048848082 +671 4.043894151 +672 4.04068757 +673 4.037988102 +674 4.03217302 +675 4.028015257 +676 4.021675829 +677 4.019266437 +678 4.016197857 +679 4.015106549 +680 4.01152552 +681 4.008793892 +682 4.006987211 +683 4.001370378 +684 3.999785673 +685 3.995391756 +686 3.992859418 +687 3.990590638 +688 3.987421019 +689 3.984875426 +690 3.983259512 +691 3.977451854 +692 3.975760211 +693 3.972342593 +694 3.967600289 +695 3.961251142 +696 3.959542542 +697 3.956680484 +698 3.952320243 +699 3.949781359 +700 3.943998991 +701 3.943797999 +702 3.939884026 +703 3.936069773 +704 3.934062424 +705 3.933561732 +706 3.932784425 +707 3.932783625 +708 3.925873007 +709 3.919731912 +710 3.919104987 +711 3.916761538 +712 3.914897185 +713 3.914184042 +714 3.910854434 +715 3.904997748 +716 3.899231733 +717 3.894304024 +718 3.89254508 +719 3.890636951 +720 3.88964335 +721 3.886600386 +722 3.886314445 +723 3.8851498 +724 3.883414876 +725 3.878088684 +726 3.876567021 +727 3.871736757 +728 3.871244031 +729 3.867953534 +730 3.86702534 +731 3.867014463 +732 3.86106331 +733 3.859242171 +734 3.854114093 +735 3.848413555 +736 3.842989506 +737 3.838695475 +738 3.837889031 +739 3.834531862 +740 3.830419349 +741 3.8301816 +742 3.830180861 +743 3.825330234 +744 3.825116385 +745 3.823593569 +746 3.8196481 +747 3.813765217 +748 3.809458841 +749 3.808672277 +750 3.805836512 +751 3.803780095 +752 3.799304159 +753 3.793935942 +754 3.788916483 +755 3.780373664 +756 3.779398732 +757 3.779197226 +758 3.773122662 +759 3.769846671 +760 3.768002629 +761 3.764894455 +762 3.762056151 +763 3.760824597 +764 3.759107224 +765 3.756007267 +766 3.753671874 +767 3.750400326 +768 3.749297448 +769 3.746556366 +770 3.743254753 +771 3.742330736 +772 3.739497017 +773 3.737241733 +774 3.733163137 +775 3.729663848 +776 3.728730992 +777 3.723038552 +778 3.717513382 +779 3.717327004 +780 3.717326204 +781 3.716935992 +782 3.715934678 +783 3.711815421 +784 3.710086253 +785 3.708230952 +786 3.705644544 +787 3.704862455 +788 3.70415444 +789 3.701407918 +790 3.69957917 +791 3.698570077 +792 3.696587263 +793 3.693585307 +794 3.693343596 +795 3.68884961 +796 3.687765069 +797 3.684139554 +798 3.682973227 +799 3.679813455 +800 3.676862111 +801 3.676860986 +802 3.670214102 +803 3.668143742 +804 3.662024558 +805 3.661849831 +806 3.65672535 +807 3.650817304 +808 3.648015458 +809 3.645562403 +810 3.642641794 +811 3.640010725 +812 3.638098571 +813 3.634369651 +814 3.632357423 +815 3.630719581 +816 3.6282957 +817 3.624702515 +818 3.62121705 +819 3.618614636 +820 3.609915518 +821 3.60547361 +822 3.605232121 +823 3.604026256 +824 3.60223655 +825 3.597290223 +826 3.594862734 +827 3.592061768 +828 3.587447029 +829 3.58743466 +830 3.586440433 +831 3.583533931 +832 3.58312837 +833 3.581414251 +834 3.57935402 +835 3.575183325 +836 3.570305144 +837 3.56817989 +838 3.564980762 +839 3.561248045 +840 3.560676841 +841 3.557303682 +842 3.551800692 +843 3.548281689 +844 3.546813403 +845 3.542273534 +846 3.541420393 +847 3.540819093 +848 3.536771861 +849 3.531581189 +850 3.528630759 +851 3.524574299 +852 3.520611084 +853 3.51941272 +854 3.517256478 +855 3.517126089 +856 3.516527637 +857 3.516382259 +858 3.513012499 +859 3.512084026 +860 3.507025209 +861 3.50364826 +862 3.50050135 +863 3.50004915 +864 3.497942827 +865 3.496333618 +866 3.491419841 +867 3.488233694 +868 3.485575107 +869 3.483879021 +870 3.483429571 +871 3.479844265 +872 3.477559243 +873 3.47377196 +874 3.468124821 +875 3.466921718 +876 3.461149048 +877 3.459516828 +878 3.456806927 +879 3.456149562 +880 3.453164846 +881 3.451453582 +882 3.449654043 +883 3.445730537 +884 3.440188788 +885 3.439295289 +886 3.436022852 +887 3.435005804 +888 3.430079068 +889 3.429272827 +890 3.428004187 +891 3.42664981 +892 3.424154056 +893 3.42147428 +894 3.419797236 +895 3.418220387 +896 3.414847191 +897 3.413591164 +898 3.411829725 +899 3.407247368 +900 3.405464242 +901 3.402054531 +902 3.40181483 +903 3.400273555 +904 3.397921518 +905 3.396431072 +906 3.393732841 +907 3.392920628 +908 3.390110114 +909 3.388595441 +910 3.386985252 +911 3.382015717 +912 3.380551574 +913 3.378788438 +914 3.377721223 +915 3.376911249 +916 3.373417759 +917 3.372732742 +918 3.372600298 +919 3.368659706 +920 3.364562474 +921 3.362472241 +922 3.361646962 +923 3.358861489 +924 3.356955858 +925 3.353174551 +926 3.352182825 +927 3.351101708 +928 3.34898966 +929 3.348630558 +930 3.343254485 +931 3.342033926 +932 3.340737433 +933 3.339144168 +934 3.333577461 +935 3.332448295 +936 3.331198626 +937 3.327927888 +938 3.324592275 +939 3.32381222 +940 3.322602574 +941 3.31850546 +942 3.317361352 +943 3.31531718 +944 3.313649176 +945 3.311511541 +946 3.308772142 +947 3.307302565 +948 3.305675371 +949 3.304642431 +950 3.303324494 +951 3.301779618 +952 3.298413116 +953 3.296544406 +954 3.295659859 +955 3.295427314 +956 3.294632872 +957 3.294075719 +958 3.293454663 +959 3.292261473 +960 3.290276795 +961 3.289025886 +962 3.285308319 +963 3.282777049 +964 3.279650799 +965 3.278910906 +966 3.276885194 +967 3.276139154 +968 3.273550145 +969 3.269697382 +970 3.267733388 +971 3.263122871 +972 3.26144263 +973 3.258592836 +974 3.25603903 +975 3.254617725 +976 3.252926053 +977 3.251200809 +978 3.250229087 +979 3.248580362 +980 3.245873806 +981 3.243447442 +982 3.242799048 +983 3.242540875 +984 3.238884783 +985 3.237129627 +986 3.234918061 +987 3.232608492 +988 3.229573155 +989 3.226056975 +990 3.225471932 +991 3.224036703 +992 3.219677231 +993 3.217445788 +994 3.215003381 +995 3.211103611 +996 3.210005671 +997 3.208173478 +998 3.20596231 +999 3.204588605 diff --git a/boruta/examples/catboost_info/time_left.tsv b/boruta/examples/catboost_info/time_left.tsv new file mode 100644 index 0000000..9e5775f --- /dev/null +++ b/boruta/examples/catboost_info/time_left.tsv @@ -0,0 +1,1001 @@ +iter Passed Remaining +0 21 21732 +1 36 18318 +2 64 21280 +3 96 24125 +4 131 26260 +5 157 26101 +6 190 27005 +7 216 26878 +8 252 27818 +9 279 27683 +10 320 28832 +11 348 28667 +12 373 28342 +13 418 29493 +14 444 29202 +15 472 29054 +16 497 28786 +17 525 28669 +18 551 28487 +19 580 28460 +20 607 28319 +21 634 28203 +22 661 28103 +23 695 28301 +24 710 27724 +25 737 27637 +26 764 27564 +27 791 27479 +28 818 27399 +29 843 27283 +30 872 27287 +31 903 27345 +32 931 27310 +33 959 27274 +34 991 27343 +35 1022 27377 +36 1065 27721 +37 1095 27724 +38 1140 28092 +39 1165 27974 +40 1192 27899 +41 1223 27915 +42 1250 27822 +43 1278 27787 +44 1308 27777 +45 1336 27711 +46 1364 27661 +47 1391 27590 +48 1418 27533 +49 1445 27458 +50 1471 27374 +51 1496 27291 +52 1518 27127 +53 1545 27079 +54 1575 27073 +55 1602 27015 +56 1628 26936 +57 1656 26908 +58 1682 26826 +59 1708 26760 +60 1734 26696 +61 1760 26632 +62 1787 26582 +63 1828 26744 +64 1853 26668 +65 1880 26615 +66 1907 26565 +67 1934 26515 +68 1961 26467 +69 1987 26400 +70 2014 26359 +71 2039 26292 +72 2065 26232 +73 2107 26372 +74 2135 26341 +75 2161 26273 +76 2188 26233 +77 2214 26179 +78 2244 26164 +79 2269 26094 +80 2299 26088 +81 2326 26049 +82 2370 26189 +83 2395 26126 +84 2435 26218 +85 2463 26178 +86 2489 26127 +87 2517 26086 +88 2543 26030 +89 2592 26215 +90 2618 26156 +91 2644 26102 +92 2670 26046 +93 2711 26135 +94 2736 26065 +95 2762 26010 +96 2782 25899 +97 2808 25846 +98 2834 25796 +99 2860 25747 +100 2887 25698 +101 2915 25665 +102 2950 25695 +103 2975 25638 +104 3002 25596 +105 3028 25539 +106 3068 25613 +107 3105 25646 +108 3146 25720 +109 3172 25671 +110 3215 25751 +111 3244 25725 +112 3269 25662 +113 3310 25726 +114 3335 25671 +115 3371 25689 +116 3385 25552 +117 3412 25509 +118 3440 25473 +119 3468 25432 +120 3494 25387 +121 3520 25336 +122 3547 25290 +123 3573 25248 +124 3583 25085 +125 3609 25038 +126 3636 25000 +127 3662 24948 +128 3690 24915 +129 3717 24876 +130 3743 24833 +131 3769 24788 +132 3797 24752 +133 3823 24709 +134 3849 24666 +135 3876 24626 +136 3903 24588 +137 3932 24561 +138 3942 24420 +139 3968 24376 +140 4010 24432 +141 4045 24442 +142 4071 24398 +143 4098 24366 +144 4125 24324 +145 4153 24294 +146 4185 24287 +147 4212 24248 +148 4237 24202 +149 4262 24154 +150 4290 24125 +151 4317 24089 +152 4344 24050 +153 4371 24015 +154 4386 23911 +155 4412 23872 +156 4437 23829 +157 4466 23802 +158 4508 23846 +159 4533 23800 +160 4560 23767 +161 4594 23768 +162 4625 23750 +163 4669 23803 +164 4698 23778 +165 4729 23763 +166 4742 23654 +167 4775 23648 +168 4804 23622 +169 4830 23585 +170 4856 23544 +171 4886 23524 +172 4930 23569 +173 4974 23616 +174 5010 23622 +175 5041 23601 +176 5083 23635 +177 5114 23619 +178 5139 23575 +179 5167 23542 +180 5194 23505 +181 5220 23465 +182 5247 23427 +183 5274 23389 +184 5302 23360 +185 5329 23323 +186 5358 23296 +187 5386 23263 +188 5412 23225 +189 5438 23187 +190 5467 23157 +191 5498 23137 +192 5536 23150 +193 5563 23113 +194 5590 23077 +195 5616 23040 +196 5643 23003 +197 5669 22963 +198 5685 22886 +199 5712 22848 +200 5739 22816 +201 5768 22789 +202 5796 22756 +203 5824 22726 +204 5852 22695 +205 5881 22670 +206 5911 22645 +207 5939 22616 +208 5969 22593 +209 6002 22580 +210 6037 22576 +211 6066 22549 +212 6096 22526 +213 6124 22494 +214 6152 22462 +215 6179 22430 +216 6201 22376 +217 6231 22354 +218 6258 22317 +219 6286 22287 +220 6325 22296 +221 6369 22320 +222 6407 22327 +223 6435 22295 +224 6463 22263 +225 6492 22234 +226 6520 22202 +227 6546 22166 +228 6575 22139 +229 6604 22112 +230 6640 22106 +231 6680 22115 +232 6710 22089 +233 6725 22016 +234 6753 21983 +235 6788 21977 +236 6819 21954 +237 6856 21952 +238 6884 21922 +239 6911 21887 +240 6953 21900 +241 6980 21863 +242 7009 21835 +243 7036 21800 +244 7063 21766 +245 7089 21731 +246 7105 21662 +247 7133 21629 +248 7159 21592 +249 7187 21562 +250 7216 21535 +251 7265 21567 +252 7295 21540 +253 7337 21549 +254 7380 21563 +255 7417 21556 +256 7459 21566 +257 7506 21588 +258 7537 21564 +259 7580 21576 +260 7609 21546 +261 7637 21513 +262 7667 21485 +263 7727 21544 +264 7794 21619 +265 7832 21612 +266 7861 21583 +267 7921 21635 +268 7959 21630 +269 7996 21619 +270 8025 21589 +271 8051 21550 +272 8086 21534 +273 8113 21496 +274 8140 21462 +275 8168 21428 +276 8197 21396 +277 8227 21368 +278 8254 21331 +279 8281 21296 +280 8310 21263 +281 8339 21233 +282 8382 21238 +283 8407 21197 +284 8449 21198 +285 8477 21163 +286 8503 21126 +287 8534 21100 +288 8565 21072 +289 8593 21038 +290 8622 21007 +291 8649 20971 +292 8676 20935 +293 8702 20898 +294 8730 20865 +295 8757 20827 +296 8784 20792 +297 8822 20783 +298 8851 20753 +299 8893 20752 +300 8929 20737 +301 8957 20703 +302 8984 20667 +303 9010 20630 +304 9037 20593 +305 9062 20554 +306 9090 20520 +307 9117 20483 +308 9142 20444 +309 9178 20429 +310 9203 20390 +311 9241 20378 +312 9269 20345 +313 9296 20310 +314 9324 20277 +315 9353 20246 +316 9380 20211 +317 9408 20178 +318 9435 20141 +319 9461 20105 +320 9488 20071 +321 9514 20033 +322 9566 20051 +323 9593 20015 +324 9619 19979 +325 9659 19971 +326 9685 19934 +327 9710 19895 +328 9737 19859 +329 9763 19823 +330 9791 19789 +331 9817 19753 +332 9845 19719 +333 9870 19682 +334 9899 19650 +335 9935 19635 +336 9963 19602 +337 9998 19583 +338 10024 19546 +339 10067 19541 +340 10093 19506 +341 10122 19474 +342 10147 19437 +343 10175 19403 +344 10201 19368 +345 10227 19331 +346 10268 19323 +347 10309 19316 +348 10338 19284 +349 10377 19272 +350 10403 19235 +351 10430 19201 +352 10456 19165 +353 10483 19130 +354 10509 19094 +355 10535 19058 +356 10566 19032 +357 10609 19025 +358 10635 18989 +359 10660 18952 +360 10700 18941 +361 10726 18905 +362 10753 18869 +363 10780 18836 +364 10823 18829 +365 10849 18794 +366 10907 18812 +367 10933 18777 +368 10967 18754 +369 10993 18718 +370 11020 18684 +371 11046 18648 +372 11074 18615 +373 11099 18579 +374 11127 18545 +375 11157 18516 +376 11184 18482 +377 11212 18449 +378 11239 18415 +379 11266 18382 +380 11293 18348 +381 11321 18315 +382 11348 18281 +383 11377 18251 +384 11403 18216 +385 11430 18181 +386 11466 18163 +387 11496 18133 +388 11540 18126 +389 11569 18095 +390 11596 18061 +391 11635 18047 +392 11664 18016 +393 11690 17981 +394 11739 17981 +395 11784 17974 +396 11821 17955 +397 11853 17929 +398 11881 17896 +399 11907 17861 +400 11934 17827 +401 11976 17815 +402 12004 17782 +403 12032 17751 +404 12074 17739 +405 12116 17727 +406 12144 17694 +407 12183 17678 +408 12226 17666 +409 12257 17638 +410 12291 17614 +411 12324 17588 +412 12354 17559 +413 12395 17545 +414 12438 17533 +415 12465 17499 +416 12492 17465 +417 12531 17448 +418 12573 17435 +419 12600 17401 +420 12627 17366 +421 12653 17330 +422 12681 17298 +423 12708 17264 +424 12744 17242 +425 12773 17210 +426 12799 17176 +427 12825 17141 +428 12852 17106 +429 12878 17071 +430 12904 17036 +431 12930 17001 +432 12957 16967 +433 12984 16934 +434 13015 16904 +435 13040 16868 +436 13066 16834 +437 13094 16801 +438 13119 16765 +439 13152 16739 +440 13178 16704 +441 13206 16672 +442 13237 16643 +443 13264 16610 +444 13292 16577 +445 13337 16566 +446 13380 16553 +447 13407 16520 +448 13438 16490 +449 13462 16454 +450 13491 16422 +451 13517 16389 +452 13544 16355 +453 13570 16321 +454 13599 16289 +455 13628 16258 +456 13653 16223 +457 13680 16189 +458 13706 16155 +459 13734 16123 +460 13758 16086 +461 13786 16054 +462 13813 16020 +463 13838 15985 +464 13865 15952 +465 13891 15918 +466 13932 15902 +467 13959 15868 +468 13986 15835 +469 14011 15800 +470 14040 15769 +471 14065 15734 +472 14094 15703 +473 14119 15668 +474 14147 15637 +475 14174 15603 +476 14201 15570 +477 14226 15536 +478 14253 15503 +479 14296 15488 +480 14323 15454 +481 14350 15422 +482 14377 15389 +483 14404 15356 +484 14433 15326 +485 14459 15293 +486 14487 15261 +487 14513 15227 +488 14540 15194 +489 14566 15161 +490 14610 15146 +491 14638 15114 +492 14666 15083 +493 14692 15049 +494 14719 15017 +495 14747 14985 +496 14772 14951 +497 14799 14918 +498 14825 14885 +499 14852 14852 +500 14878 14818 +501 14906 14787 +502 14931 14753 +503 14956 14719 +504 14984 14687 +505 15025 14669 +506 15062 14646 +507 15087 14612 +508 15113 14579 +509 15153 14559 +510 15182 14528 +511 15210 14497 +512 15238 14466 +513 15264 14433 +514 15292 14401 +515 15319 14369 +516 15348 14338 +517 15373 14305 +518 15416 14287 +519 15441 14253 +520 15479 14231 +521 15504 14197 +522 15532 14166 +523 15558 14132 +524 15584 14100 +525 15614 14070 +526 15641 14038 +527 15668 14006 +528 15695 13974 +529 15733 13952 +530 15772 13931 +531 15798 13898 +532 15826 13866 +533 15851 13833 +534 15878 13800 +535 15903 13766 +536 15929 13734 +537 15954 13700 +538 15983 13670 +539 16010 13638 +540 16037 13606 +541 16063 13574 +542 16089 13541 +543 16115 13508 +544 16140 13474 +545 16166 13442 +546 16194 13411 +547 16236 13392 +548 16262 13359 +549 16290 13328 +550 16316 13296 +551 16345 13266 +552 16371 13233 +553 16401 13203 +554 16428 13172 +555 16455 13140 +556 16483 13110 +557 16509 13077 +558 16536 13046 +559 16562 13013 +560 16589 12982 +561 16619 12952 +562 16646 12921 +563 16671 12888 +564 16699 12857 +565 16725 12824 +566 16757 12797 +567 16784 12765 +568 16811 12734 +569 16838 12702 +570 16864 12670 +571 16891 12639 +572 16915 12605 +573 16958 12585 +574 16985 12554 +575 17010 12521 +576 17052 12501 +577 17077 12468 +578 17109 12440 +579 17135 12408 +580 17176 12387 +581 17201 12354 +582 17228 12322 +583 17253 12290 +584 17281 12259 +585 17309 12228 +586 17351 12208 +587 17377 12175 +588 17409 12148 +589 17435 12116 +590 17463 12085 +591 17490 12054 +592 17518 12023 +593 17543 11990 +594 17570 11959 +595 17599 11930 +596 17628 11900 +597 17654 11868 +598 17681 11836 +599 17708 11805 +600 17735 11774 +601 17762 11743 +602 17790 11712 +603 17820 11683 +604 17856 11658 +605 17883 11627 +606 17910 11596 +607 17937 11564 +608 17963 11533 +609 17991 11502 +610 18018 11471 +611 18044 11439 +612 18070 11408 +613 18108 11384 +614 18134 11352 +615 18161 11321 +616 18189 11290 +617 18217 11260 +618 18242 11228 +619 18269 11197 +620 18297 11166 +621 18324 11136 +622 18356 11108 +623 18399 11086 +624 18424 11054 +625 18453 11024 +626 18482 10995 +627 18509 10964 +628 18535 10932 +629 18561 10901 +630 18588 10870 +631 18614 10838 +632 18642 10808 +633 18701 10795 +634 18728 10765 +635 18753 10733 +636 18793 10709 +637 18820 10678 +638 18847 10647 +639 18875 10617 +640 18903 10587 +641 18930 10556 +642 18957 10525 +643 18984 10494 +644 19013 10464 +645 19039 10433 +646 19067 10403 +647 19093 10371 +648 19136 10349 +649 19164 10319 +650 19192 10289 +651 19221 10259 +652 19251 10230 +653 19300 10211 +654 19328 10180 +655 19368 10156 +656 19394 10125 +657 19421 10094 +658 19449 10064 +659 19476 10033 +660 19503 10002 +661 19529 9971 +662 19560 9942 +663 19591 9913 +664 19618 9882 +665 19645 9852 +666 19674 9822 +667 19700 9791 +668 19726 9760 +669 19752 9728 +670 19780 9698 +671 19805 9666 +672 19831 9636 +673 19858 9604 +674 19883 9573 +675 19910 9542 +676 19954 9520 +677 19981 9489 +678 20008 9459 +679 20034 9428 +680 20070 9401 +681 20097 9370 +682 20122 9339 +683 20148 9308 +684 20175 9278 +685 20201 9246 +686 20227 9215 +687 20253 9184 +688 20279 9153 +689 20307 9123 +690 20333 9092 +691 20372 9067 +692 20397 9036 +693 20423 9005 +694 20449 8974 +695 20478 8944 +696 20506 8914 +697 20532 8883 +698 20557 8852 +699 20584 8821 +700 20611 8791 +701 20637 8760 +702 20663 8729 +703 20693 8700 +704 20721 8670 +705 20747 8639 +706 20780 8612 +707 20807 8581 +708 20834 8551 +709 20861 8520 +710 20889 8490 +711 20915 8460 +712 20942 8429 +713 20967 8398 +714 20996 8369 +715 21022 8338 +716 21063 8313 +717 21088 8282 +718 21115 8252 +719 21141 8221 +720 21170 8192 +721 21195 8161 +722 21223 8131 +723 21251 8101 +724 21278 8071 +725 21305 8040 +726 21333 8010 +727 21361 7981 +728 21387 7950 +729 21414 7920 +730 21440 7889 +731 21467 7859 +732 21505 7833 +733 21544 7807 +734 21571 7777 +735 21598 7747 +736 21626 7717 +737 21652 7687 +738 21679 7656 +739 21705 7626 +740 21746 7600 +741 21774 7571 +742 21800 7540 +743 21828 7510 +744 21854 7480 +745 21881 7450 +746 21909 7420 +747 21935 7390 +748 21963 7360 +749 21990 7330 +750 22018 7300 +751 22045 7270 +752 22073 7240 +753 22101 7210 +754 22128 7180 +755 22155 7150 +756 22183 7121 +757 22210 7090 +758 22250 7065 +759 22277 7034 +760 22305 7005 +761 22332 6975 +762 22360 6945 +763 22385 6914 +764 22412 6884 +765 22440 6855 +766 22467 6825 +767 22497 6796 +768 22522 6765 +769 22548 6735 +770 22575 6705 +771 22602 6675 +772 22628 6645 +773 22655 6615 +774 22687 6586 +775 22729 6561 +776 22758 6531 +777 22784 6501 +778 22812 6471 +779 22839 6441 +780 22865 6411 +781 22920 6389 +782 22948 6359 +783 22975 6330 +784 23004 6300 +785 23031 6270 +786 23057 6240 +787 23083 6210 +788 23128 6185 +789 23155 6155 +790 23184 6125 +791 23211 6095 +792 23238 6065 +793 23265 6036 +794 23308 6010 +795 23335 5980 +796 23378 5954 +797 23415 5927 +798 23441 5896 +799 23469 5867 +800 23497 5837 +801 23539 5811 +802 23565 5781 +803 23592 5751 +804 23618 5721 +805 23645 5691 +806 23689 5665 +807 23721 5636 +808 23746 5606 +809 23772 5576 +810 23807 5548 +811 23839 5519 +812 23869 5490 +813 23905 5462 +814 23931 5432 +815 23957 5402 +816 23983 5372 +817 24010 5342 +818 24037 5312 +819 24062 5282 +820 24090 5252 +821 24116 5222 +822 24145 5192 +823 24173 5163 +824 24200 5133 +825 24226 5103 +826 24253 5073 +827 24279 5043 +828 24306 5013 +829 24335 4984 +830 24361 4954 +831 24388 4924 +832 24415 4894 +833 24473 4871 +834 24503 4841 +835 24546 4815 +836 24572 4785 +837 24598 4755 +838 24625 4725 +839 24651 4695 +840 24678 4665 +841 24706 4636 +842 24738 4607 +843 24763 4577 +844 24790 4547 +845 24816 4517 +846 24844 4487 +847 24871 4458 +848 24898 4428 +849 24924 4398 +850 24967 4371 +851 24992 4341 +852 25019 4311 +853 25047 4282 +854 25072 4252 +855 25100 4222 +856 25131 4193 +857 25166 4165 +858 25192 4135 +859 25228 4106 +860 25257 4077 +861 25283 4047 +862 25311 4018 +863 25339 3988 +864 25364 3958 +865 25391 3928 +866 25419 3899 +867 25446 3869 +868 25473 3840 +869 25516 3812 +870 25544 3783 +871 25571 3753 +872 25597 3723 +873 25624 3694 +874 25651 3664 +875 25675 3634 +876 25705 3605 +877 25731 3575 +878 25761 3546 +879 25786 3516 +880 25815 3486 +881 25858 3459 +882 25887 3430 +883 25913 3400 +884 25949 3371 +885 25976 3342 +886 26004 3312 +887 26040 3284 +888 26066 3254 +889 26094 3225 +890 26137 3197 +891 26167 3168 +892 26193 3138 +893 26241 3111 +894 26266 3081 +895 26296 3052 +896 26324 3022 +897 26352 2993 +898 26377 2963 +899 26417 2935 +900 26447 2905 +901 26472 2876 +902 26500 2846 +903 26526 2817 +904 26552 2787 +905 26579 2757 +906 26605 2728 +907 26632 2698 +908 26658 2668 +909 26685 2639 +910 26710 2609 +911 26737 2579 +912 26762 2550 +913 26789 2520 +914 26817 2491 +915 26843 2461 +916 26886 2433 +917 26913 2404 +918 26952 2375 +919 26980 2346 +920 27005 2316 +921 27032 2286 +922 27058 2257 +923 27084 2227 +924 27129 2199 +925 27158 2170 +926 27184 2140 +927 27212 2111 +928 27238 2081 +929 27266 2052 +930 27292 2022 +931 27321 1993 +932 27349 1964 +933 27376 1934 +934 27403 1905 +935 27431 1875 +936 27472 1847 +937 27501 1817 +938 27527 1788 +939 27555 1758 +940 27581 1729 +941 27610 1700 +942 27638 1670 +943 27674 1641 +944 27702 1612 +945 27730 1582 +946 27760 1553 +947 27789 1524 +948 27815 1494 +949 27842 1465 +950 27870 1436 +951 27898 1406 +952 27925 1377 +953 27953 1347 +954 27992 1319 +955 28033 1290 +956 28061 1260 +957 28087 1231 +958 28114 1201 +959 28149 1172 +960 28176 1143 +961 28214 1114 +962 28241 1085 +963 28268 1055 +964 28301 1026 +965 28333 997 +966 28359 967 +967 28386 938 +968 28415 909 +969 28457 880 +970 28483 850 +971 28519 821 +972 28545 792 +973 28574 762 +974 28600 733 +975 28628 703 +976 28654 674 +977 28681 645 +978 28707 615 +979 28733 586 +980 28759 557 +981 28791 527 +982 28833 498 +983 28860 469 +984 28885 439 +985 28913 410 +986 28940 381 +987 28969 351 +988 28994 322 +989 29022 293 +990 29048 263 +991 29074 234 +992 29118 205 +993 29160 176 +994 29188 146 +995 29220 117 +996 29274 88 +997 29316 58 +998 29345 29 +999 29369 0 diff --git a/boruta/test/.ipynb_checkpoints/__init__-checkpoint.py b/boruta/test/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000..e69de29 diff --git a/boruta/test/.ipynb_checkpoints/modif_tests-checkpoint.py b/boruta/test/.ipynb_checkpoints/modif_tests-checkpoint.py new file mode 100644 index 0000000..507db6f --- /dev/null +++ b/boruta/test/.ipynb_checkpoints/modif_tests-checkpoint.py @@ -0,0 +1,154 @@ +%matplotlib inline +from sklearn.datasets import fetch_openml +from sklearn.ensemble import RandomForestClassifier +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.compose import ColumnTransformer +from sklearn.model_selection import train_test_split +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import OneHotEncoder +from sklearn.datasets import fetch_openml +from sklearn.inspection import permutation_importance +import catboost +from boruta import BorutaPy as bp +from sklearn.datasets import load_boston, load_diabetes +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +import gc +import shap +# lightgbm and catboost +import lightgbm as lgb +from lightgbm import LGBMRegressor, LGBMClassifier +from xgboost import XGBRegressor, XGBClassifier +from catboost import CatBoostRegressor, CatBoostClassifier +from sys import getsizeof, path +plt.style.use('fivethirtyeight') +rng = np.random.RandomState(seed=42) + + + +# Convert the cat. pred. for boosting +def cat_var(df, col_excl=None, return_cat=True): + """Identify categorical features. + + Parameters + ---------- + df: original df after missing operations + + Returns + ------- + cat_var_df: summary df with col index and col name for all categorical vars + :param return_cat: Boolean, return encoded cols as type 'category' + :param df: pd.DF, the encoded data-frame + :param col_excl: list, colums not to be encoded + """ + + if col_excl is None: + non_num_cols = list(set(list(df.columns)) - set(list(df.select_dtypes(include=[np.number])))) + else: + non_num_cols = list( + set(list(df.columns)) - set(list(df.select_dtypes(include=[np.number]))) - set(col_excl)) + + # cat_var_index = [i for i, x in enumerate(df[col_names].dtypes.tolist()) if isinstance(x, pd.CategoricalDtype) or x == 'object'] + # cat_var_name = [x for i, x in enumerate(col_names) if i in cat_var_index] + + cat_var_index = [df.columns.get_loc(c) for c in non_num_cols if c in df] + + cat_var_df = pd.DataFrame({'cat_ind': cat_var_index, + 'cat_name': non_num_cols}) + + cols_need_mapped = cat_var_df.cat_name.to_list() + inv_mapper = {col: dict(enumerate(df[col].astype('category').cat.categories)) for col in df[cols_need_mapped]} + mapper = {col: {v: k for k, v in inv_mapper[col].items()} for col in df[cols_need_mapped]} + + for c in cols_need_mapped: + df.loc[:, c] = df.loc[:, c].map(mapper[c]).fillna(0).astype(int) + + if return_cat: + df[non_num_cols] = df[non_num_cols].astype('category') + return df, cat_var_df, inv_mapper + + +def get_titanic_data(): + # Fetch Titanic data and add random cat and numbers + # Example taken from https://scikit-learn.org/stable/auto_examples/inspection/ + # plot_permutation_importance.html#sphx-glr-auto-examples-inspection-plot-permutation-importance-py + X, y = fetch_openml("titanic", version=1, as_frame=True, return_X_y=True) + rng = np.random.RandomState(seed=42) + X['random_cat'] = rng.randint(3, size=X.shape[0]) + X['random_cat'] = X['random_cat'].astype('str') + X['random_num'] = rng.randn(X.shape[0]) + + categorical_columns = ['pclass', 'sex', 'embarked', 'random_cat'] + numerical_columns = ['age', 'sibsp', 'parch', 'fare', 'random_num'] + X = X[categorical_columns + numerical_columns] + # Impute + categorical_pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing'))]) + numerical_pipe = Pipeline([('imputer', SimpleImputer(strategy='mean'))]) + preprocessing = ColumnTransformer([('cat', categorical_pipe, categorical_columns), ('num', numerical_pipe, numerical_columns)]) + X_trans = preprocessing.fit_transform(X) + X = pd.DataFrame(X_trans, columns = X.columns) + # encode + X, cat_var_df, inv_mapper = cat_var(X) + return X, y + +def get_boston_data(): + boston = load_boston() + X = pd.DataFrame(boston.data) + X['random_num1'] = rng.randn(X.shape[0]) + X['random_num2'] = np.random.poisson(1, X.shape[0]) + y = pd.Series(boston.target) + return X, y + +# Testing the changes with rnd cat. and num. predictors added to the set of genuine predictors +def testing_estimators(varimp, models, X, y): + for model in models: + print('testing ' + str(type(model)) + ' for var.imp: ' + varimp) + feat_selector = bp(model, n_estimators = 100, verbose= 1, max_iter= 10, random_state=42, weight=None, importance=varimp) + feat_selector.fit(X, y) + print(feat_selector.support_names_) + feat_selector.plot_importance() + gc.enable() + del(feat_selector, model) + gc.collect() + +def testing_clf_all_varimp(X, y): + for varimp in ['shap', 'pimp', 'native']: + models = [catboost.CatBoostClassifier(random_state=42, verbose=0), XGBClassifier(random_state=42, verbose=0), LGBMClassifier(random_state=42, verbose=0)] + testing_estimators(varimp=varimp, models=models, X=X, y=y) + gc.enable() + del(models) + gc.collect() + +def testing_regr_all_varimp(X, y): + for varimp in ['shap', 'pimp', 'native']: + models = [catboost.CatBoostRegressor(random_state=42, verbose=0), XGBRegressor(random_state=42, verbose=0), LGBMRegressor(random_state=42, verbose=0)] + testing_estimators(varimp=varimp, models=models, X=X, y=y) + gc.enable() + del(models) + gc.collect() + + +X, y = get_titanic_data() +X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42) +# lightgbm faster and better than RF +lgb_model = LGBMClassifier(n_jobs= 4) +lgb_model.fit(X_train, y_train) +result = permutation_importance(lgb_model, X_test, y_test, n_repeats=10, random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() +# Plot +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, vert=False, labels=X_test.columns[sorted_idx]) +ax.set_title("Permutation Importances (test set)") +fig.tight_layout() +plt.show() + +if __name__ == '__main__': + # classification and cat. pred + X, y = get_titanic_data() + testing_clf_all_varimp(X=X, y=y) + # regression + X, y = get_boston_data() + testing_regr_all_varimp(X=X, y=y) \ No newline at end of file diff --git a/boruta/test/.ipynb_checkpoints/unit_tests-checkpoint.py b/boruta/test/.ipynb_checkpoints/unit_tests-checkpoint.py new file mode 100644 index 0000000..5d5ce9f --- /dev/null +++ b/boruta/test/.ipynb_checkpoints/unit_tests-checkpoint.py @@ -0,0 +1,57 @@ +import unittest +from boruta import BorutaPy +import pandas as pd +from sklearn.ensemble import RandomForestClassifier +import numpy as np + + +class BorutaTestCases(unittest.TestCase): + + def test_get_tree_num(self): + rfc = RandomForestClassifier(max_depth=10) + bt = BorutaPy(rfc) + self.assertEqual(bt._get_tree_num(10), 44, "Tree Est. Math Fail") + self.assertEqual(bt._get_tree_num(100), 141, "Tree Est. Math Fail") + + def test_if_boruta_extracts_relevant_features(self): + np.random.seed(42) + y = np.random.binomial(1, 0.5, 1000) + X = np.zeros((1000, 10)) + + z = y - np.random.binomial(1, 0.1, 1000) + np.random.binomial(1, 0.1, 1000) + z[z == -1] = 0 + z[z == 2] = 1 + + # 5 relevant features + X[:, 0] = z + X[:, 1] = y * np.abs(np.random.normal(0, 1, 1000)) + np.random.normal(0, 0.1, 1000) + X[:, 2] = y + np.random.normal(0, 1, 1000) + X[:, 3] = y ** 2 + np.random.normal(0, 1, 1000) + X[:, 4] = np.sqrt(y) + np.random.binomial(2, 0.1, 1000) + + # 5 irrelevant features + X[:, 5] = np.random.normal(0, 1, 1000) + X[:, 6] = np.random.poisson(1, 1000) + X[:, 7] = np.random.binomial(1, 0.3, 1000) + X[:, 8] = np.random.normal(0, 1, 1000) + X[:, 9] = np.random.poisson(1, 1000) + + rfc = RandomForestClassifier() + bt = BorutaPy(rfc) + bt.fit(X, y) + + # make sure that only all the relevant features are returned + self.assertListEqual(list(range(5)), list(np.where(bt.support_)[0])) + + # test if this works as expected for dataframe input + X_df, y_df = pd.DataFrame(X), pd.Series(y) + bt.fit(X_df, y_df) + self.assertListEqual(list(range(5)), list(np.where(bt.support_)[0])) + + # check it dataframe is returned when return_df=True + self.assertIsInstance(bt.transform(X_df, return_df=True), pd.DataFrame) + +if __name__ == '__main__': + unittest.main() + + diff --git a/boruta/test/modif_tests.py b/boruta/test/modif_tests.py new file mode 100644 index 0000000..3bc4a5d --- /dev/null +++ b/boruta/test/modif_tests.py @@ -0,0 +1,157 @@ +%matplotlib inline +from sklearn.datasets import fetch_openml +from sklearn.ensemble import RandomForestClassifier +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.compose import ColumnTransformer +from sklearn.model_selection import train_test_split +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import OneHotEncoder +from sklearn.datasets import fetch_openml +from sklearn.inspection import permutation_importance +import catboost +from boruta import BorutaPy as bp +from sklearn.datasets import load_boston, load_diabetes +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +import gc +import shap +# lightgbm and catboost +import lightgbm as lgb +from lightgbm import LGBMRegressor, LGBMClassifier +from xgboost import XGBRegressor, XGBClassifier +from catboost import CatBoostRegressor, CatBoostClassifier +from sys import getsizeof, path +plt.style.use('fivethirtyeight') +rng = np.random.RandomState(seed=42) + + + +# Convert the cat. pred. for boosting +def cat_var(df, col_excl=None, return_cat=True): + """Identify categorical features. + + Parameters + ---------- + df: original df after missing operations + + Returns + ------- + cat_var_df: summary df with col index and col name for all categorical vars + :param return_cat: Boolean, return encoded cols as type 'category' + :param df: pd.DF, the encoded data-frame + :param col_excl: list, colums not to be encoded + """ + + if col_excl is None: + non_num_cols = list(set(list(df.columns)) - set(list(df.select_dtypes(include=[np.number])))) + else: + non_num_cols = list( + set(list(df.columns)) - set(list(df.select_dtypes(include=[np.number]))) - set(col_excl)) + + # cat_var_index = [i for i, x in enumerate(df[col_names].dtypes.tolist()) if isinstance(x, pd.CategoricalDtype) or x == 'object'] + # cat_var_name = [x for i, x in enumerate(col_names) if i in cat_var_index] + + cat_var_index = [df.columns.get_loc(c) for c in non_num_cols if c in df] + + cat_var_df = pd.DataFrame({'cat_ind': cat_var_index, + 'cat_name': non_num_cols}) + + cols_need_mapped = cat_var_df.cat_name.to_list() + inv_mapper = {col: dict(enumerate(df[col].astype('category').cat.categories)) for col in df[cols_need_mapped]} + mapper = {col: {v: k for k, v in inv_mapper[col].items()} for col in df[cols_need_mapped]} + + for c in cols_need_mapped: + df.loc[:, c] = df.loc[:, c].map(mapper[c]).fillna(0).astype(int) + + if return_cat: + df[non_num_cols] = df[non_num_cols].astype('category') + return df, cat_var_df, inv_mapper + + +def get_titanic_data(): + # Fetch Titanic data and add random cat and numbers + # Example taken from https://scikit-learn.org/stable/auto_examples/inspection/ + # plot_permutation_importance.html#sphx-glr-auto-examples-inspection-plot-permutation-importance-py + X, y = fetch_openml("titanic", version=1, as_frame=True, return_X_y=True) + rng = np.random.RandomState(seed=42) + X['random_cat'] = rng.randint(3, size=X.shape[0]) + X['random_cat'] = X['random_cat'].astype('str') + X['random_num'] = rng.randn(X.shape[0]) + + categorical_columns = ['pclass', 'sex', 'embarked', 'random_cat'] + numerical_columns = ['age', 'sibsp', 'parch', 'fare', 'random_num'] + X = X[categorical_columns + numerical_columns] + # Impute + categorical_pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing'))]) + numerical_pipe = Pipeline([('imputer', SimpleImputer(strategy='mean'))]) + preprocessing = ColumnTransformer([('cat', categorical_pipe, categorical_columns), ('num', numerical_pipe, numerical_columns)]) + X_trans = preprocessing.fit_transform(X) + X = pd.DataFrame(X_trans, columns = X.columns) + # encode + X, cat_var_df, inv_mapper = cat_var(X) + # sample weight is just a dummy random vector for testing purpose + sample_weight = np.random.uniform(0,1, len(y)) + return X, y, sample_weight + +def get_boston_data(): + boston = load_boston() + X = pd.DataFrame(boston.data) + X['random_num1'] = rng.randn(X.shape[0]) + X['random_num2'] = np.random.poisson(1, X.shape[0]) + y = pd.Series(boston.target) + return X, y + +# Testing the changes with rnd cat. and num. predictors added to the set of genuine predictors +def testing_estimators(varimp, models, X, y, sample_weight=None): + for model in models: + print('='*20 +' testing: {mod:>55} for var.imp: {vimp:<15} '.format(mod=str(model), vimp=varimp)+'='*20 ) + feat_selector = noglmgroot.BorutaPy(model, n_estimators = 100, verbose= 1, max_iter= 10, random_state=42, weight=None, importance=varimp) + feat_selector.fit(X, y, sample_weight) + print(feat_selector.support_names_) + feat_selector.plot_importance(n_feat_per_inch=3) + gc.enable() + del(feat_selector, model) + gc.collect() + +def testing_clf_all_varimp(X, y, sample_weight=None): + for varimp in ['shap', 'pimp', 'native']: + models = [RandomForestClassifier(n_jobs= 4, oob_score= True), catboost.CatBoostClassifier(random_state=42, verbose=0), XGBClassifier(random_state=42, verbose=0), LGBMClassifier(random_state=42, verbose=0)] + testing_estimators(varimp=varimp, models=models, X=X, y=y, sample_weight=sample_weight) + gc.enable() + del models + gc.collect() + +def testing_regr_all_varimp(X, y): + for varimp in ['shap', 'pimp', 'native']: + models = [catboost.CatBoostRegressor(random_state=42, verbose=0), XGBRegressor(random_state=42, verbose=0), LGBMRegressor(random_state=42, verbose=0)] + testing_estimators(varimp=varimp, models=models, X=X, y=y) + gc.enable() + del(models) + gc.collect() + +print('='*20 + ' Benchmarking using sklearn permutation importance ' + '='*20 ) +X, y, sample_weight = get_titanic_data() +X_train, X_test, y_train, y_test, w_train, w_test = train_test_split(X, y, sample_weight, stratify=y, random_state=42) +# lightgbm faster and better than RF +lgb_model = LGBMClassifier(n_jobs= 4) +lgb_model.fit(X_train, y_train, sample_weight=w_train) +result = permutation_importance(lgb_model, X_test, y_test, n_repeats=10, random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() +# Plot +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, vert=False, labels=X_test.columns[sorted_idx]) +ax.set_title("Permutation Importances (test set)") +fig.tight_layout() +plt.show() + +if __name__ == '__main__': + # classification and cat. pred, sample weight is just a dummy random vector for testing purpose + X, y, sample_weight = get_titanic_data() #get_titanic_data() + testing_clf_all_varimp(X=X, y=y, sample_weight=sample_weight) + + # regression + X, y = get_boston_data() + testing_regr_all_varimp(X=X, y=y) \ No newline at end of file diff --git a/setup.py b/setup.py index 5848b5b..1708abf 100644 --- a/setup.py +++ b/setup.py @@ -15,5 +15,8 @@ keywords=['feature selection', 'machine learning', 'random forest'], install_requires=['numpy>=1.10.4', 'scikit-learn>=0.17.1', - 'scipy>=0.17.0' + 'scipy>=0.17.0', + 'pandas', + 'matplotlib', + 'tqdm' ])