From 4b3c9226a2e715e8e51b4bd8530c7eea8147ca64 Mon Sep 17 00:00:00 2001 From: Yujie Wang <30487251+yuji3w@users.noreply.github.com> Date: Mon, 18 Apr 2022 20:30:18 -0700 Subject: [PATCH 1/4] Add change detection benchmarker prototype --- lib/__init__.py | 0 lib/data_aug_utils.py | 49 +++++ lib/data_clean_utils.py | 24 +++ lib/data_load_utils.py | 230 +++++++++++++++++++++ lib/model.py | 154 ++++++++++++++ model.ipynb | 433 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 890 insertions(+) create mode 100644 lib/__init__.py create mode 100644 lib/data_aug_utils.py create mode 100644 lib/data_clean_utils.py create mode 100644 lib/data_load_utils.py create mode 100644 lib/model.py create mode 100644 model.ipynb diff --git a/lib/__init__.py b/lib/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/data_aug_utils.py b/lib/data_aug_utils.py new file mode 100644 index 0000000..019a545 --- /dev/null +++ b/lib/data_aug_utils.py @@ -0,0 +1,49 @@ +import typing + +import pandas as pd + + +""" + Returns df column with tip percentages. If the total amount + of a trip is 0, the tip percent is calculated as 0 by default. +""" +def tip_percent_column(total_amount_series: pd.Series, + tip_amount_series: pd.Series): + zero_total_indices = total_amount_series == 0 + tip_percents_including_nans = tip_amount_series / total_amount_series + tip_percents_including_nans[zero_total_indices] = 0 + return tip_percents_including_nans + + +def dollars_per_mile(total_amount_series: pd.Series, + trip_distance_series: pd.Series): + zero_distance_indices = trip_distance_series == 0 + dollars_per_mile = total_amount_series / trip_distance_series + dollars_per_mile[zero_distance_indices] = 0 + return dollars_per_mile + + +""" + Returns df column with day picked up in month. +""" +def pickup_day_in_month(pickup_date_series: pd.Series): + return pickup_date_series.dt.day + +""" + Returns pickup time in mins since midnight of the day. +""" +def pickup_time_sice_midnight(pickup_date_series: pd.Series): + return pickup_date_series.dt.hour * 60 + pickup_date_series.dt.minute + +""" + Returns pickup day of week from 0-6. +""" +def pickup_day_in_week(pickup_date_series: pd.Series): + return pickup_date_series.dt.weekday + +""" + Returns month from 0 BC to make it easier for plotting across months across years. +""" +def pickup_month_inc_year(pickup_date_series: pd.Series): + return pickup_date_series.dt.year * 12 + pickup_date_series.dt.month + diff --git a/lib/data_clean_utils.py b/lib/data_clean_utils.py new file mode 100644 index 0000000..a54e0a9 --- /dev/null +++ b/lib/data_clean_utils.py @@ -0,0 +1,24 @@ +import typing + +import pandas as pd + +""" + Cleans up all strings from each column of the NYC Taxi dataset. +""" +def hard_coded_cleaning_steps_mutation(df: pd.DataFrame): + # Correct string type confusion in vendorid. + df.loc[df['vendorid'] == '1', 'vendorid'] = 1 + df.loc[df['vendorid'] == '1.0', 'vendorid'] = 1 + df.loc[df['vendorid'] == '2', 'vendorid'] = 2 + df.loc[df['vendorid'] == '2.0', 'vendorid'] = 2 + + # Y/N more useful as 0/1 for graphing and analysis + df.loc[df['store_and_fwd_flag'] == 'N', 'store_and_fwd_flag'] = 0 + df.loc[df['store_and_fwd_flag'] == 'Y', 'store_and_fwd_flag'] = 1 + + + df.loc[df['payment_type'] == '1.0', 'payment_type'] = 1 + df.loc[df['payment_type'] == '2.0', 'payment_type'] = 2 + df.loc[df['payment_type'] == '3.0', 'payment_type'] = 3 + df.loc[df['payment_type'] == '4.0', 'payment_type'] = 4 + df.loc[df['payment_type'] == '5.0', 'payment_type'] = 5 \ No newline at end of file diff --git a/lib/data_load_utils.py b/lib/data_load_utils.py new file mode 100644 index 0000000..50b8c96 --- /dev/null +++ b/lib/data_load_utils.py @@ -0,0 +1,230 @@ +import typing + +import numpy as np +import pandas as pd + +from collections.abc import Iterable +from dataclasses import dataclass +from datetime import datetime, timedelta +from enum import Enum +from ttb import Dataset +from typing import Optional +from tqdm.auto import tqdm + + +class TrainTestDataFrameAccessor: + ''' + Supports querying for dataframes corresponding to the training label + and nonlabel features of the original df. + ''' + def __init__(self, df_data: pd.DataFrame, + time_index_col: pd.Series, + x_labels: tuple[str, ...], + y_label: str, + date_slice_fit: tuple[datetime, datetime], + date_slices_infer: tuple[tuple[datetime, datetime], ...]): + + self.x_accessor = SingleDataFrameAccessor( + df_data[list(x_labels)], time_index_col, + date_slice_fit, date_slices_infer) + self.y_accessor = SingleDataFrameAccessor( + df_data[[y_label]], time_index_col, + date_slice_fit, date_slices_infer) + + def get_fit_dates(self) -> tuple[datetime, datetime]: + return self.x_accessor.get_fit_dates() + + def get_x_fit(self) -> pd.DataFrame: + return self.x_accessor.get_df_fit() + + def get_x_infer_iterable(self) -> Iterable[pd.DataFrame]: + yield from self.x_accessor.get_df_infer_iterable() + + def get_y_fit(self) -> pd.DataFrame: + return self.y_accessor.get_df_fit() + + def get_y_infer_iterable(self) -> Iterable[pd.DataFrame]: + yield from self.y_accessor.get_df_infer_iterable() + + def get_xy_fit_np(self) -> tuple[np.array, np.array]: + return (self.get_x_fit().values.astype(np.float32), + self.get_y_fit().values.astype(np.float32)) + + def get_xy_infer_iterable_np(self) -> Iterable[np.array, np.array]: + for x_df, y_df in zip(self.get_x_infer_iterable(), + self.get_y_infer_iterable()): + yield (x_df.values.astype(np.float32), + y_df.values.astype(np.float32)) + + +class AnnotatedTrainTestDataFrameAccessor(TrainTestDataFrameAccessor): + def __init__(self, df_data: pd.DataFrame, + time_index_col: pd.Series, + x_labels: tuple[str, ...], + y_label: str, + date_slice_fit: tuple[datetime, datetime], + date_slices_infer: tuple[tuple[datetime, datetime], ...], + is_continuous_annotations: dict): + TrainTestDataFrameAccessor.__init__( + self, df_data, time_index_col, x_labels, y_label, + date_slice_fit, date_slices_infer) + self.x_accessor.is_continuous_annotations = is_continuous_annotations + self.y_accessor.is_continuous_annotations = is_continuous_annotations + + def get_xy_fit_np(self) -> tuple[ + tuple[np.array, np.array], tuple[np.array, np.array]]: + x_np, y_np = super().get_xy_fit_np() + return ((x_np, self.x_accessor.get_annotations()), + (y_np, self.y_accessor.get_annotations())) + + def get_xy_infer_iterable_np(self) -> Iterable[ + tuple[np.array, np.array], tuple[np.array, np.array]]: + ''' + TODO: properly propogate the logic of annotations into the inner class + because clearly the annotations are tied to each of x and y values + and can be set as an attribute during init + ''' + for xy_tup in super().get_xy_infer_iterable_np(): + x_np, y_np = xy_tup + yield ((x_np, self.x_accessor.get_annotations()), + (y_np, self.y_accessor.get_annotations())) + +@dataclass +class SingleDataFrameAccessor: + ''' + Supports iterating through a df by date_slices. + ''' + df_data: pd.DataFrame + time_index_col: pd.Series + date_slice_fit: tuple[datetime, datetime] + date_slices_infer: tuple[tuple[datetime, datetime], ...] + is_continuous_annotations: Optional[dict] = None + + def get_fit_dates(self) -> tuple[datetime, datetime]: + return self.date_slice_fit + + def get_annotations(self) -> np.array: + return np.array(list( + map(self.is_continuous_annotations.get, + list(self.df_data.columns)))) + ''' + Unpacks date_slice into inclusive, exclusive start_date, end_date + for slicing df_data. + ''' + def get_date_indices_(self, date_slice: tuple[datetime, datetime]): + start_date, end_date = date_slice + return (self.time_index_col >= start_date) & \ + (self.time_index_col < end_date) + + def get_df_fit(self) -> pd.DataFrame: + return self.df_data[self.get_date_indices_(self.date_slice_fit)] + + def get_df_infer_iterable(self) -> Iterable[pd.DataFrame]: + for date_slice in self.date_slices_infer: + yield self.df_data[self.get_date_indices_(date_slice)] + + ''' + Yields the inclusive start date for each df slice for display + purposes. Yield datetime instead of Tuple[datetime, datetime] + for ease of display. + ''' + def get_curr_date_iterable(self) -> Iterable[datetime]: + for date_slice in self.date_slices_infer: + yield date_slice[0] + + def get_future_date_iterable(self) -> Iterable[datetime]: + for date_slice in self.date_slices_infer: + yield date_slice[1] + +@dataclass +class AccessorFactory: + ''' + Dependent on whether is_continuous_annotations + is set or not, returns TrainTestDataFrameAccessor + or AnnotatedTrainTestDataFrameAccessor + ''' + df_data: pd.DataFrame + time_index_col: pd.Series + date_slice_fit: tuple[datetime, datetime] + date_slices_infer: tuple[tuple[datetime, datetime], ...] + is_continuous_annotations: Optional[dict] = None + + def get(self, x_labels: tuple[str, ...], y_label: str): + if self.is_continuous_annotations is None: + return TrainTestDataFrameAccessor( + self.df_data, + self.time_index_col, + x_labels, + y_label, + self.date_slice_fit, + self.date_slices_infer) + else: + return AnnotatedTrainTestDataFrameAccessor( + self.df_data, + self.time_index_col, + x_labels, + y_label, + self.date_slice_fit, + self.date_slices_infer, + self.is_continuous_annotations) + +''' + Batches and appends pandas dataframes. Useful for loading + large datasets because memory swaps kill performance. + Args: + progress_format: either 'print' or 'tqdm' +''' +def batch_load_df(dataset: Dataset, load_start: datetime, + load_end: datetime, no_batches: int, + progress_format: str) -> pd.DataFrame: + + date_iter = date_iter_step_no(load_start, load_end, + step_no = no_batches) + if progress_format == 'tqdm': + date_iter = tqdm(date_iter, total=no_batches) + + df_list = [] + for curr_date, future_date in date_iter: + start_time = datetime.now() + df_list.append(dataset.load(curr_date, future_date)) + if progress_format == 'print': + print(f"Loaded { curr_date } to { future_date } in "\ + f"{ datetime.now() - start_time }", end="\r") + + df_intermonth = pd.concat(df_list) + del df_list[:] # free space since loading is so expensive + return df_intermonth + + +''' + Iterate between start_date (inc) and end_date(inc) for chunking + data for loading and graphing. + + args: + step_no: subdivisions of delta to advance by for memory + management in batch loading + + yields: + (curr_date, future_date), inclusive exclusive tuple whose + union covers entire date range. +''' +def date_iter_step_no( + start_date: typing.Union[str, datetime], + end_date: typing.Union[str, datetime], + step_no: int = 100, + ): + delta = (end_date - start_date) / step_no + curr_date = start_date + while curr_date < end_date: + yield (curr_date, curr_date + delta) + curr_date += delta + +def date_iter_step_size( + start_date: typing.Union[str, datetime], + end_date: typing.Union[str, datetime], + step_size: timedelta = timedelta(days=7), + ): + curr_date = start_date + while curr_date < end_date: + yield (curr_date, curr_date + step_size) + curr_date += step_size \ No newline at end of file diff --git a/lib/model.py b/lib/model.py new file mode 100644 index 0000000..fb01ca8 --- /dev/null +++ b/lib/model.py @@ -0,0 +1,154 @@ +import abc + +import numpy as np +import torch +from alibi_detect.cd import (ChiSquareDrift, ClassifierDrift, + ClassifierUncertaintyDrift, CVMDrift, FETDrift, + KSDrift, LearnedKernelDrift, LSDDDrift, MMDDrift, + SpotTheDiffDrift, TabularDrift) +from alibi_detect.utils.pytorch.kernels import DeepKernel +from sklearn.ensemble import RandomForestClassifier +from torch import nn + +# TODO: implement preprocessing for feature reduction in all models +class ModelWrapperInterface(abc.ABC): + ''' + Drift detector wrapper. + ''' + @abc.abstractmethod + def fit(self, x_fit, y_fit): + ''' + Initializes a drift detector with some combination of + x_fit, y_fit. x_fit, y_fit can be of any type, depending + on the data loader implementation. + ''' + pass + @abc.abstractmethod + def infer(self, x_infer, y_infer) -> float: + ''' + Returns p-value corresponding to drift for the drift + detector initialized in fit method. + ''' + pass + +@ModelWrapperInterface.register +class CVMModel: + def fit(self, x_fit, y_fit): + self.model = CVMDrift(x_fit) + def infer(self, x_infer, y_infer) -> float: + return self.model.predict(x_infer)['data']['p_val'][0] + +@ModelWrapperInterface.register +class MMDModel: + def fit(self, x_fit, y_fit): + self.model = MMDDrift(x_fit) + def infer(self, x_infer, y_infer) -> float: + return self.model.predict(x_infer)['data']['p_val'] + +@ModelWrapperInterface.register +class TabularModel: + def fit(self, x_fit_annotated, y_fit_annotated): + ''' + Because TabularModel chooses between KS and Chi-Squared + feature-wise drift detection depending on user labels, + each argument should be composed of a numpy array of features + and a boolean numpy array of whether each feature is continuous. + ''' + x_fit, x_is_continuous_annotations = x_fit_annotated + tabular_continuous_annotation = {} + for i in range(x_is_continuous_annotations.shape[0]): + if not x_is_continuous_annotations[i]: + tabular_continuous_annotation[i] = None + self.model = TabularDrift(x_fit, + categories_per_feature = tabular_continuous_annotation) + def infer(self, x_infer_annotated, y_infer_annotated) -> float: + x_infer, _ = x_infer_annotated + return self.model.predict(x_infer)['data']['p_val'][0] + +@ModelWrapperInterface.register +class FETModel: + def __init__(self, classifier_model = None, train_drift_frac = .7): + if classifier_model is None: + classifier_model = RandomForestClassifier() + self.classifier_model = classifier_model + self.train_drift_frac = train_drift_frac + def fit(self, x_fit, y_fit) -> float: + shuffled_indices = np.random.permutation(x_fit.shape[0]) + split_index = round(x_fit.shape[0] * self.train_drift_frac) + x_fit_class, x_fit_fet = np.split(x_fit, [split_index,]) + y_fit_class, y_fit_fet = np.split(y_fit.reshape(-1), [split_index,]) + self.classifier_model.fit(x_fit_class, y_fit_class) + x_fit_classifier_output = np.array( + self.classifier_model.predict(x_fit_fet), dtype='bool') + self.model = FETDrift(x_fit_classifier_output, alternative='two-sided') + def infer(self, x_infer, y_infer) -> float: + x_infer_classified = self.classifier_model.predict(x_infer) + return self.model.predict(x_infer_classified)['data']['p_val'][0] + +@ModelWrapperInterface.register +class LearnedKernelModel: + def __init__(self, kernel:DeepKernel): + self.kernel = kernel + def fit(self, x_fit, y_fit): + # pytorch models accept float32 by default. + x_fit = x_fit.astype(np.float32) + self.model = LearnedKernelDrift(x_fit, self.kernel, backend='pytorch') + def infer(self, x_infer, y_infer) -> float: + x_infer = x_infer.astype(np.float32) + return self.model.predict(x_infer)['data']['p_val'] + +@ModelWrapperInterface.register +class ClassifierDriftModel: + def __init__(self, classifier_model:nn.Module): + self.classifier_model = classifier_model + def fit(self, x_fit, y_fit): + # pytorch models accept float32 by default. + x_fit = x_fit.astype(np.float32) + self.model = ClassifierDrift( + x_fit, self.classifier_model, backend='pytorch') + def infer(self, x_infer, y_infer) -> float: + x_infer = x_infer.astype(np.float32) + return self.model.predict(x_infer)['data']['p_val'] + +@ModelWrapperInterface.register +class SpotTheDiffModel: + def fit(self, x_fit, y_fit): + x_fit = x_fit.astype(np.float32) + self.model = SpotTheDiffDrift(x_fit, backend='pytorch') + def infer(self, x_infer, y_infer) -> float: + x_infer = x_infer.astype(np.float32) + return self.model.predict(x_infer)['data']['p_val'] + +# TODO: come up with good scheme to pass in params to classifieruncertainty +# model +@ModelWrapperInterface.register +class ClassifierUncertaintyModel: + def __init__(self, classifier_model = None, train_drift_frac = .7): + if classifier_model is None: + classifier_model = nn.Sequential( + nn.Linear(18,10), + nn.ReLU(), + nn.Linear(10,2)) + self.classifier_model = classifier_model + self.train_drift_frac = train_drift_frac + def fit(self, x_fit, y_fit): + # TODO(wangyujie): must train model, but too complicated for + # prototype + shuffled_indices = np.random.permutation(x_fit.shape[0]) + split_index = round(x_fit.shape[0] * self.train_drift_frac) + x_fit_class, x_fit_uncertainty = np.split(x_fit, [split_index,]) + y_fit_class, y_fit_uncertainty = np.split(y_fit.reshape(-1), [split_index,]) + x_fit_uncertainty = x_fit_uncertainty.astype(np.float32) + self.model = ClassifierUncertaintyDrift( + x_fit_uncertainty, self.classifier_model, preds_type='logits', backend='pytorch') + def infer(self, x_infer, y_infer) -> float: + x_infer = x_infer.astype(np.float32) + return self.model.predict(x_infer)['data']['p_val'] + +# TODO: track the runtime +@ModelWrapperInterface.register +class CVMModel: + def fit(self, x_fit, y_fit): + self.model = CVMDrift(x_fit) + def infer(self, x_infer, y_infer) -> float: + return self.model.predict(x_infer)['data']['p_val'][0] diff --git a/model.ipynb b/model.ipynb new file mode 100644 index 0000000..7b94348 --- /dev/null +++ b/model.ipynb @@ -0,0 +1,433 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + "\n", + "import abc\n", + "import matplotlib as mpl\n", + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import torch\n", + "import typing\n", + "\n", + "from datetime import datetime, timedelta\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator\n", + "from operator import itemgetter\n", + "from scipy.stats import entropy\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from torch import nn\n", + "from ttb import Dataset\n", + "\n", + "from lib.model import (\n", + " ClassifierDriftModel,\n", + " ClassifierUncertaintyModel,\n", + " CVMModel,\n", + " FETModel,\n", + " LearnedKernelModel,\n", + " MMDModel,\n", + " ModelWrapperInterface,\n", + " SpotTheDiffModel,\n", + " TabularModel,\n", + ")\n", + "from alibi_detect.utils.pytorch.kernels import DeepKernel\n", + "from lib.data_aug_utils import (\n", + " dollars_per_mile,\n", + " pickup_day_in_month,\n", + " pickup_day_in_week,\n", + " pickup_month_inc_year,\n", + " pickup_time_sice_midnight,\n", + " tip_percent_column,\n", + ")\n", + "from lib.data_clean_utils import hard_coded_cleaning_steps_mutation\n", + "from lib.data_load_utils import (\n", + " AccessorFactory,\n", + " AnnotatedTrainTestDataFrameAccessor,\n", + " batch_load_df,\n", + " date_iter_step_size,\n", + " TrainTestDataFrameAccessor,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1 [00:00 .15)\n", + "df.insert(21, 'total_amount_per_mile', dollars_per_mile(df['total_amount'], df['trip_distance']))\n", + "\n", + "df_sample = df.sample(frac=.0005)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + " Some drift detection methods benefit from the knowledge of\n", + " what features are categorical.\n", + "'''\n", + "is_continuous_annotations = {\n", + " 'congestion_surcharge': False,\n", + " 'dolocationid': False,\n", + " 'extra': False,\n", + " 'fare_amount': True,\n", + " 'id': False,\n", + " 'improvement_surcharge': False,\n", + " 'mta_tax': False,\n", + " 'passenger_count': False,\n", + " 'payment_type': False,\n", + " 'pickup_day_in_month': True,\n", + " 'pickup_mins_since_midnight': True,\n", + " 'pickup_month_inc_year': False,\n", + " 'pulocationid': False,\n", + " 'ratecodeid': False,\n", + " 'store_and_fwd_flag': False,\n", + " 'tip_amount': True,\n", + " 'tip_percent_greater_15': False,\n", + " 'tip_percent': True,\n", + " 'tolls_amount': True,\n", + " 'total_amount_per_mile': True,\n", + " 'total_amount': True,\n", + " 'trip_distance': True,\n", + " 'vendorid': False,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Column tip_amount has importance 0.5213913757556793\n", + "Column payment_type has importance 0.16735546844410745\n", + "Column total_amount has importance 0.07468124741277538\n", + "Column total_amount_per_mile has importance 0.07033652833437838\n", + "Column fare_amount has importance 0.0414589015389518\n", + "Column trip_distance has importance 0.03847645981805085\n", + "Column pickup_mins_since_midnight has importance 0.0260308345871801\n", + "Column dolocationid has importance 0.01866331273059336\n", + "Column pulocationid has importance 0.01752183077028386\n", + "Column extra has importance 0.007315181902508898\n" + ] + } + ], + "source": [ + "x_labels = [\n", + " 'congestion_surcharge',\n", + " 'dolocationid',\n", + " 'extra',\n", + " 'fare_amount',\n", + " 'improvement_surcharge',\n", + " 'mta_tax',\n", + " 'passenger_count',\n", + " 'payment_type',\n", + " 'pickup_mins_since_midnight',\n", + " 'pulocationid',\n", + " 'ratecodeid',\n", + " 'store_and_fwd_flag',\n", + " 'tip_amount',\n", + " 'tolls_amount',\n", + " 'total_amount_per_mile',\n", + " 'total_amount',\n", + " 'trip_distance',\n", + " 'vendorid',\n", + "]\n", + "y_label = 'tip_percent_greater_15'\n", + "\n", + "classifier_model = RandomForestClassifier()\n", + "classifier_model.fit(df_sample[x_labels], df_sample[y_label])\n", + "\n", + "name_and_importance = list(zip(x_labels, classifier_model.feature_importances_))\n", + "name_and_importance.sort(key = itemgetter(1), reverse=True)\n", + "for col_name, importance in name_and_importance[:10]:\n", + " print(f\"Column {col_name} has importance {importance}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + " Returns performance list when fitted on Accessor\n", + " fit method and inferred on Accessor iterable.\n", + "\"\"\"\n", + "def get_periodic_model_performance(\n", + " df_accessor: TrainTestDataFrameAccessor, \n", + " model: ModelWrapperInterface) -> np.array:\n", + " model.fit(*df_accessor.get_xy_fit_np())\n", + " \n", + " perf_list = []\n", + " for args in df_accessor.get_xy_infer_iterable_np():\n", + " perf_list.append(model.infer(*args))\n", + " return np.array(perf_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_interweek_performance(\n", + " accessor_factory: AccessorFactory,\n", + " model: ModelWrapperInterface,\n", + " y_label: str):\n", + " fig, axs = plt.subplots(5, 5, figsize=(25,17))\n", + " strftime_rep = '%Y-%m-%d'\n", + "\n", + " for ax, col_name in zip(axs.reshape(-1), df_data.columns):\n", + " '''\n", + " TODO(wangyujie): accelerate this using pd group by\n", + " df['ts'] = pd.to_datetime(df['tpep_pickup_datetime'])\n", + " df.set_index('ts')\n", + " df.groupby(pd.Grouper('1D')).apply(…)\n", + " '''\n", + " df_accessor = accessor_factory.get((col_name,), y_label)\n", + " drifts_arr = get_periodic_model_performance(df_accessor, model)\n", + " \n", + " ax.set_ylim((-.1, 1.1)) # Can't see 0 or 1 on graph if (0,1)\n", + " ax.title.set_text(f'Feature Drift for {col_name}')\n", + " ax.set_ylabel('P-val for No Drift')\n", + " ax.set_xlabel(f'Weeks since {df_accessor.get_fit_dates()[0].strftime(strftime_rep)}')\n", + " ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n", + " ax.plot(range(1, drifts_arr.size + 1), drifts_arr)\n", + " fig.tight_layout()\n", + "\n", + "def get_drift_perf(\n", + " accessor_factory: AccessorFactory,\n", + " model: ModelWrapperInterface,\n", + " x_labels: tuple[str, ...],\n", + " y_label: str) -> np.array:\n", + "\n", + " df_accessor = accessor_factory.get(x_labels, y_label)\n", + " return get_periodic_model_performance(df_accessor, model)\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_cols = [\n", + " 'vendorid',\n", + " 'pickup_mins_since_midnight',\n", + " 'passenger_count',\n", + " 'trip_distance',\n", + " 'ratecodeid',\n", + " 'store_and_fwd_flag',\n", + " 'pulocationid',\n", + " 'dolocationid',\n", + " 'payment_type',\n", + " 'fare_amount',\n", + " 'extra',\n", + " 'mta_tax',\n", + " 'tip_amount',\n", + " 'tolls_amount',\n", + " 'improvement_surcharge',\n", + " 'total_amount_per_mile',\n", + " 'total_amount',\n", + " 'congestion_surcharge',\n", + " 'tip_percent_greater_15']\n", + "df_data = df_sample[data_cols]\n", + "time_index_col = df_sample['tpep_pickup_datetime']\n", + "date_slices = tuple(\n", + " date_iter_step_size(global_start_date, global_end_date))\n", + "accessor_factory_annotated = AccessorFactory(\n", + " df_data, time_index_col, date_slices[0], date_slices[1:],\n", + " is_continuous_annotations)\n", + "\n", + "plot_interweek_performance(\n", + " accessor_factory_annotated,\n", + " TabularModel(),\n", + " 'tip_percent_greater_15')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n", + "No GPU detected, fall back on CPU.\n", + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "x_labels = (\n", + " 'vendorid',\n", + " 'pickup_mins_since_midnight',\n", + " 'passenger_count',\n", + " 'trip_distance',\n", + " 'ratecodeid',\n", + " 'store_and_fwd_flag',\n", + " 'pulocationid',\n", + " 'dolocationid',\n", + " 'payment_type',\n", + " 'fare_amount',\n", + " 'extra',\n", + " 'mta_tax',\n", + " 'tip_amount',\n", + " 'tolls_amount',\n", + " 'improvement_surcharge',\n", + " 'total_amount_per_mile',\n", + " 'total_amount',\n", + " 'congestion_surcharge')\n", + "y_label = 'tip_percent_greater_15'\n", + "df_data = df_sample[list(x_labels + (y_label,))]\n", + "time_index_col = df_sample['tpep_pickup_datetime']\n", + "date_slices = tuple(\n", + " date_iter_step_size(global_start_date, global_end_date))\n", + "accessor_factory_default = AccessorFactory(\n", + " df_data, time_index_col, date_slices[0], date_slices[1:])\n", + "accessor_factory_annotated = AccessorFactory(\n", + " df_data, time_index_col, date_slices[0], date_slices[1:],\n", + " is_continuous_annotations)\n", + "\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_annotated, TabularModel(), x_labels, y_label)\n", + "np.savetxt('TabularModel.csv', drift_perf, delimiter=',')\n", + "\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, CVMModel(), x_labels, y_label)\n", + "np.savetxt('CVMModel.csv', drift_perf, delimiter=',')\n", + "\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, FETModel(), x_labels, y_label)\n", + "np.savetxt('FETModel.csv', drift_perf, delimiter=',')\n", + "\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, MMDModel(), x_labels, y_label)\n", + "np.savetxt('MMDModel.csv', drift_perf, delimiter=',')\n", + "\n", + "proj = nn.Sequential(\n", + " nn.Linear(len(x_labels), 10),\n", + " nn.Linear(10, 10),\n", + ")\n", + "kernel = DeepKernel(proj, eps=0.01)\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, LearnedKernelModel(kernel), x_labels, y_label)\n", + "np.savetxt('LearnedKernelModel.csv', drift_perf, delimiter=',')\n", + "\n", + "model = nn.Sequential(\n", + " nn.Linear(len(x_labels), 10),\n", + " nn.ReLU(),\n", + " nn.Linear(10, 2),\n", + ")\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, ClassifierDriftModel(model), x_labels, y_label)\n", + "np.savetxt('ClassifierDriftModel.csv', drift_perf, delimiter=',')\n", + "\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, SpotTheDiffModel(), x_labels, y_label)\n", + "np.savetxt('SpotTheDiffModel.csv', drift_perf, delimiter=',')\n", + "\n", + "model = nn.Sequential(\n", + " nn.Linear(len(x_labels), 10),\n", + " nn.ReLU(),\n", + " nn.Linear(10, 2),\n", + ")\n", + "drift_perf = get_drift_perf(\n", + " accessor_factory_default, ClassifierUncertaintyModel(model), x_labels, y_label)\n", + "np.savetxt('SpotTheDiffModel.csv', drift_perf, delimiter=',')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: get the f1 score of some model and also export csv" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "16005896cb84f99e64a5e3de5f8f72988fbd89dfc36078e24fdce82fe5ee90e7" + }, + "kernelspec": { + "display_name": "Python 3.9.7 ('ttb')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 9674a6dbf6e3317a332f29d6927c0eb082696136 Mon Sep 17 00:00:00 2001 From: Yujie Wang <30487251+yuji3w@users.noreply.github.com> Date: Mon, 25 Apr 2022 14:25:06 -0700 Subject: [PATCH 2/4] Add interpretability features + all models fully functional 1. Add f1, accuracy scores to CSV 2. Aggregate CSVs 3. Track runtimes for each method 4. All methods now ready for use --- .gitignore | 4 +- lib/data_clean_utils.py | 17 +--- lib/data_load_utils.py | 6 ++ lib/model.py | 36 ++++++-- model.ipynb | 193 ++++++++++++++++++++++++++++------------ 5 files changed, 178 insertions(+), 78 deletions(-) diff --git a/.gitignore b/.gitignore index 9f28f47..e239121 100644 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,6 @@ data/* *.temporary* *data.txt *.DS_Store* -*.ipynb_checkpoints* \ No newline at end of file +*.ipynb_checkpoints* +*.png +*.csv \ No newline at end of file diff --git a/lib/data_clean_utils.py b/lib/data_clean_utils.py index a54e0a9..278f248 100644 --- a/lib/data_clean_utils.py +++ b/lib/data_clean_utils.py @@ -6,19 +6,10 @@ Cleans up all strings from each column of the NYC Taxi dataset. """ def hard_coded_cleaning_steps_mutation(df: pd.DataFrame): - # Correct string type confusion in vendorid. - df.loc[df['vendorid'] == '1', 'vendorid'] = 1 - df.loc[df['vendorid'] == '1.0', 'vendorid'] = 1 - df.loc[df['vendorid'] == '2', 'vendorid'] = 2 - df.loc[df['vendorid'] == '2.0', 'vendorid'] = 2 + # Correct string type confusion in vendorid, payment_type + df['vendorid'] = df['vendorid'].astype(float).astype(int) + df['payment_type'] = df['payment_type'].astype(float).astype(int) # Y/N more useful as 0/1 for graphing and analysis df.loc[df['store_and_fwd_flag'] == 'N', 'store_and_fwd_flag'] = 0 - df.loc[df['store_and_fwd_flag'] == 'Y', 'store_and_fwd_flag'] = 1 - - - df.loc[df['payment_type'] == '1.0', 'payment_type'] = 1 - df.loc[df['payment_type'] == '2.0', 'payment_type'] = 2 - df.loc[df['payment_type'] == '3.0', 'payment_type'] = 3 - df.loc[df['payment_type'] == '4.0', 'payment_type'] = 4 - df.loc[df['payment_type'] == '5.0', 'payment_type'] = 5 \ No newline at end of file + df.loc[df['store_and_fwd_flag'] == 'Y', 'store_and_fwd_flag'] = 1 \ No newline at end of file diff --git a/lib/data_load_utils.py b/lib/data_load_utils.py index 50b8c96..400638e 100644 --- a/lib/data_load_utils.py +++ b/lib/data_load_utils.py @@ -34,6 +34,9 @@ def __init__(self, df_data: pd.DataFrame, def get_fit_dates(self) -> tuple[datetime, datetime]: return self.x_accessor.get_fit_dates() + def get_dates_infer(self) -> tuple[tuple[datetime, datetime], ...]: + return self.x_accessor.get_dates_infer() + def get_x_fit(self) -> pd.DataFrame: return self.x_accessor.get_df_fit() @@ -118,6 +121,9 @@ def get_date_indices_(self, date_slice: tuple[datetime, datetime]): def get_df_fit(self) -> pd.DataFrame: return self.df_data[self.get_date_indices_(self.date_slice_fit)] + + def get_dates_infer(self) -> tuple[tuple[datetime, datetime], ...]: + return self.date_slices_infer def get_df_infer_iterable(self) -> Iterable[pd.DataFrame]: for date_slice in self.date_slices_infer: diff --git a/lib/model.py b/lib/model.py index fb01ca8..a6d4738 100644 --- a/lib/model.py +++ b/lib/model.py @@ -8,6 +8,7 @@ SpotTheDiffDrift, TabularDrift) from alibi_detect.utils.pytorch.kernels import DeepKernel from sklearn.ensemble import RandomForestClassifier +from sklearn.metrics import f1_score from torch import nn # TODO: implement preprocessing for feature reduction in all models @@ -119,25 +120,25 @@ def infer(self, x_infer, y_infer) -> float: x_infer = x_infer.astype(np.float32) return self.model.predict(x_infer)['data']['p_val'] -# TODO: come up with good scheme to pass in params to classifieruncertainty -# model @ModelWrapperInterface.register class ClassifierUncertaintyModel: - def __init__(self, classifier_model = None, train_drift_frac = .7): + def __init__(self, classifier_model = None, train_fxn = None, train_drift_frac = .7): if classifier_model is None: classifier_model = nn.Sequential( nn.Linear(18,10), nn.ReLU(), nn.Linear(10,2)) + if train_fxn is None: + train_fxn = lambda *args: None + self.train_fxn = train_fxn self.classifier_model = classifier_model self.train_drift_frac = train_drift_frac def fit(self, x_fit, y_fit): - # TODO(wangyujie): must train model, but too complicated for - # prototype shuffled_indices = np.random.permutation(x_fit.shape[0]) split_index = round(x_fit.shape[0] * self.train_drift_frac) x_fit_class, x_fit_uncertainty = np.split(x_fit, [split_index,]) y_fit_class, y_fit_uncertainty = np.split(y_fit.reshape(-1), [split_index,]) + self.train_fxn(self.classifier_model, x_fit_class, y_fit_class) x_fit_uncertainty = x_fit_uncertainty.astype(np.float32) self.model = ClassifierUncertaintyDrift( x_fit_uncertainty, self.classifier_model, preds_type='logits', backend='pytorch') @@ -152,3 +153,28 @@ def fit(self, x_fit, y_fit): self.model = CVMDrift(x_fit) def infer(self, x_infer, y_infer) -> float: return self.model.predict(x_infer)['data']['p_val'][0] + +@ModelWrapperInterface.register +class OutputClassifierAccuracyBaselineModel: + ''' + Wrapper for sklearn classifier model. + ''' + def __init__(self, model): + self.model = model + def fit(self, x_fit, y_fit): + self.model.fit(x_fit, y_fit.reshape(-1)) + def infer(self, x_infer, y_infer) -> float: + return self.model.score(x_infer, y_infer.reshape(-1)) + +@ModelWrapperInterface.register +class OutputClassifierF1ScoreBaselineModel: + ''' + Wrapper for sklearn classifier model. + ''' + def __init__(self, model): + self.model = model + def fit(self, x_fit, y_fit): + self.model.fit(x_fit, y_fit.reshape(-1)) + def infer(self, x_infer, y_infer) -> float: + y_pred = self.model.predict(x_infer) + return f1_score(y_infer.reshape(-1), y_pred, average='micro') \ No newline at end of file diff --git a/model.ipynb b/model.ipynb index 7b94348..cd6150e 100644 --- a/model.ipynb +++ b/model.ipynb @@ -11,11 +11,13 @@ "%matplotlib inline\n", "\n", "import abc\n", + "import joypy\n", "import matplotlib as mpl\n", "import numpy as np\n", "import os\n", "import pandas as pd\n", "import seaborn as sns\n", + "import time\n", "import torch\n", "import typing\n", "\n", @@ -37,6 +39,8 @@ " LearnedKernelModel,\n", " MMDModel,\n", " ModelWrapperInterface,\n", + " OutputClassifierAccuracyBaselineModel,\n", + " OutputClassifierF1ScoreBaselineModel,\n", " SpotTheDiffModel,\n", " TabularModel,\n", ")\n", @@ -61,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -70,7 +74,7 @@ "text": [ " 0%| | 0/1 [00:00 np.array:\n", + " '''\n", + " Returns performance list when fitted on Accessor\n", + " fit method and inferred on Accessor iterable.\n", + " '''\n", + " perf_list, _ = get_periodic_model_performance_with_time(\n", + " df_accessor, model)\n", + " return perf_list\n", + "\n", + "def get_periodic_model_performance_with_time(\n", + " df_accessor: TrainTestDataFrameAccessor, \n", + " model: ModelWrapperInterface) -> tuple[np.array, np.array]:\n", + " '''\n", + " Returns performance list when fitted on Accessor\n", + " fit method and inferred on Accessor iterable.\n", + " '''\n", " model.fit(*df_accessor.get_xy_fit_np())\n", " \n", " perf_list = []\n", + " time_list = []\n", + "\n", " for args in df_accessor.get_xy_infer_iterable_np():\n", + " start = time.time()\n", " perf_list.append(model.infer(*args))\n", - " return np.array(perf_list)" + " time_list.append(time.time() - start)\n", + " return np.array(perf_list), np.array(time_list)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "def plot_interweek_performance(\n", + "def plot_feature_wise_interweek_performance(\n", " accessor_factory: AccessorFactory,\n", " model: ModelWrapperInterface,\n", " y_label: str):\n", @@ -220,16 +236,11 @@ " strftime_rep = '%Y-%m-%d'\n", "\n", " for ax, col_name in zip(axs.reshape(-1), df_data.columns):\n", - " '''\n", - " TODO(wangyujie): accelerate this using pd group by\n", - " df['ts'] = pd.to_datetime(df['tpep_pickup_datetime'])\n", - " df.set_index('ts')\n", - " df.groupby(pd.Grouper('1D')).apply(…)\n", - " '''\n", " df_accessor = accessor_factory.get((col_name,), y_label)\n", " drifts_arr = get_periodic_model_performance(df_accessor, model)\n", " \n", - " ax.set_ylim((-.1, 1.1)) # Can't see 0 or 1 on graph if (0,1)\n", + " # Can't see 0 or 1 on graph if (0,1)\n", + " ax.set_ylim((-.1, 1.1))\n", " ax.title.set_text(f'Feature Drift for {col_name}')\n", " ax.set_ylabel('P-val for No Drift')\n", " ax.set_xlabel(f'Weeks since {df_accessor.get_fit_dates()[0].strftime(strftime_rep)}')\n", @@ -245,17 +256,39 @@ "\n", " df_accessor = accessor_factory.get(x_labels, y_label)\n", " return get_periodic_model_performance(df_accessor, model)\n", + "\n", + "def get_drift_perf_with_runtimes(\n", + " accessor_factory: AccessorFactory,\n", + " model: ModelWrapperInterface,\n", + " x_labels: tuple[str, ...],\n", + " y_label: str) -> np.array:\n", + "\n", + " df_accessor = accessor_factory.get(x_labels, y_label)\n", + " return get_periodic_model_performance_with_time(\n", + " df_accessor, model)\n", + "\n", + "\n", + "def create_df_model_performance(\n", + " model_name: str,\n", + " model_perf: np.array,\n", + " date_slices: tuple[datetime, datetime]) -> pd.DataFrame:\n", + "\n", + " strftime_rep = '%Y-%m-%d'\n", + " start_dates = (start_date for start_date, _ in date_slices)\n", + "\n", + " date_dict = {start_date.strftime(strftime_rep): perf for start_date, perf in zip(start_dates, model_perf)}\n", + " return pd.DataFrame(date_dict, index=[model_name])\n", " \n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABwAAAATACAYAAAD3F1M2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3QUVRvH8e9NJ52QUFIghQ4JLfQuiIAogoAg9gqKYu/1tXewYheVooCiCAgWpPcWekkIKfSEBEgv9/1jFwyYRshmtjyfc3JIdmdnnsyG38zOnXuv0lojhBBCCCGEEEIIIYQQQgghhLAPTkYXIIQQQgghhBBCCCGEEEIIIYSoPtIAKIQQQgghhBBCCCGEEEIIIYQdkQZAIYQQQgghhBBCCCGEEEIIIeyINAAKIYQQQgghhBBCCCGEEEIIYUekAVAIIYQQQgghhBBCCCGEEEIIOyINgEIIIYQQQgghhBBCCCGEEELYEWkAFA5BKdVTKbWnxM/NlFJblFKnlVL3V3Id45VSR5VSZ5RSdSxXbfVSSr2glPr+El6/QynVp4zn+iilUqq6biGEia1l1IX1lrPcLUqpFZas5VIopRYqpW42YLtnlFKRNb3di6WUGquUWlzO8/8ope6o5Loqva8vZr1C2DNbOzYIIYQwsdX8Vko1NG/PuZrXm6iU6m/+/iml1BfVuX4hhKgKW81qa3Ax14Mryv2SxwhhGdIA6EDM/6FyzKF09iu4GtZZY/9JzY1ZBeYwPq2U2quU+lAp1aC812mtl2utm5V46DFgidbaR2v9fkW/h1LKFXgXGKC19tZap1XPb2T9tNattNb/GF2HsH+SUbaTUaXUa5O01oO01lMN2K631jqhprd7sbTW07TWA6ppXdWyr5VS4UoprZRyqY66hPWTY4PtHBtEzTHnYGOj6xCiPJLf1pXfldl3Wusk8/aKLnV75WzjVa11hTd6yQ1hQtQMyWrryuqLpaz8pmuofO4Ly5EGQMdzlTmUzn4dMrKYKl7A+0Fr7QMEAMOA+sDGsoK9jG00AnZcxDbrAR4X+Zqz21dKKZv7vyYXV4VBJKNMJKOEEOJfcmwwkWODAeScWIhLIvltYvX5LVknhEOTrDaxqqyWXBbVRT7UCZRSfkqpL5VSh5VSqUqpl5V5yAelVJRS6m+lVJpS6oRSappSyt/83HdAQ2Ce+Q6Rx1QpXYDV+cM9vKCUmq2U+l4pdQq4pbztl0drXaC13gFcBxwHHjZvo49SKkUp9bhS6gjwdcm6lFJ/A32BD811z7jw97ig/qbA2S7hGebXo5TqppRar5TKNP/brcRr/lFKvaKUWglkA5EXrPNxpdTsCx6brJR6vxLvyS1KqRVKqbeVUieVUgeUUoNKrCdCKbXUfNfLH0DgBdu5WpmG9cww19nigvfqcaVUHJCllHK54P2rpZT6xrzdnUDHit4nIS6VZFTNZ1SJ/fKkUmqn+f/810opj5K/Q4llw5RSPymljpvfiw/LeC/fMueXn7rgbjpVYrhi9W8vr7uUUofM+/6Riva5eR2zzO/faaXUNqVUU/PvcUwplayUGlBi+XN3FlciW29RSiWY13tAKTW2gloam7M40/y3+UOJ58713DBn6kdKqfnmda9VSkWVWLaVUuoPpVS6Mg0t8pT5cSel1BNKqXjzPv9RKRVQQU1n9+ut5n1xUik1TinVUSkVp0zHhQ9LLH/e3YRKqcuVUrvNv9OHgLpw2XL2X8l97ayUese8Xw4opSao//bqa6SUWmneJ4uVUmePZcvM/2aY/z90Le93FvZLybHBGo8NtZVSvynTseCk+fvQEq8tNUdV+XnZvEQG7lFKjSrxXEX5OcD8mkyl1MfmbdxR4vnblFK7zLUuUko1KvGcVkrdq5TaB+wr7z1VZee0u1JqkjIdxw6Zv3cvsS9WXLCeSh0blFJnc3Cr+b2/rrz6hLA2kt+GXH8obd+dPS+8XSmVBPytLhhpwbze15RS65RSp5RSv6gKzjfNr7tRKXXQ/D4+fcFzJc/5PczvTZoynYeuV0rVU0q9AvQssc8+NC8/WZnOYU8ppTYqpXpesN4flVLfmnNzh1IqtsTzZX5eUeUcD4RwVJLVhp5rX3hd9uzn/tPKdA4+zLxsC2AK0NVcY4b5cXdl+lyepEznplOUUrVKbGOoMg11esq83oHmx4OVUr8q0zntfqXUnSVeU+71YPNr55gz9oAqMYSqumBqqvKOEcJCtNby5SBfQCLQv5THfwY+BbyAusA64G7zc42BywF3IAjThbdJZa0T6AOklLVd4AWgALgGUwN0rfK2X0qtLwDfl/L4/4C1JWooBN4w113rwrqAf4A7Kto3JZ4PBzTgYv45ADgJ3Ai4AGPMP9cpsf4koJX5edcL1tcIU9j7mH92Bg4DXSrxntxi3od3ml83HjgEKPPzqzF1QXcHegGnz+4zoCmQZX5PXTF1b98PuJXYD1uAMKBWKe/f68By8+8fBmy/8P2WL/mq6ldZ/w8r+P8gGaWrP6NKbHO7+f96ALASePnC/Ygph7YC75n3kQfQw/zcLcAK8778HFgEeJbx3pzbdyV+nxnmdUZjOnkvcx+UWEcucIX59/oWOAA8jSnz7gQOlLafKSdbzTWcApqZl20AtKqglhnm7TqV3Cfm5zTQ2Pz9N0Aa0Mlc8zRgpvk5H0zHhofN6/ABOpufmwisAUIx/R19CsyooKaz+3WKeX0DzPtrLqa/7RDgGNC75Ptn/j4Q0/FkhHlfPojp77jC/VfKvh4H7DTXXhv4k/P/fv8B4jEds2qZf369tL91+bL/L+TYYEvHhjrAtYAnpryaBcw1P1dmjlJGXppfkwzcaq6nHXACaGl+/hvKzs9A8/aGm5+baH4Pz+bQUEznwC3Mzz8DrCrxe2rgD/PvWKucfVxeTv8PU07XxfR3uAp4yfzcLZjz9YJtVnhsuHBZ+ZIva/0qK6OQ/C5z35R4PhzL5Hf/UrbxrXlf1Cplu/8AqUBr8zJzStsfF2ynJXAG07UId0zXJgoveE/OnvPfDczDdNxwBjoAvqXtM/NjN2A61rhgyt0jgEeJ9eYCg83reg1YY36uvM8r5R4P5Eu+7P2rrDxCsrrMfVPi+XAsk9VbOP+67Egg2LxvrsN0XbeB+blb+O855XvAr+Z6fDDl7Gvm5zoBmeb3zwnTNYDm5ueWAR9jysi2mK7BXGZ+rszrweb1bASeA9wwNWwmAFdc+P5QwTFCvizzJT0AHc9c851VGUqpuUqpephOkB7QWmdprY9hCorRAFrr/VrrP7TWeVrr45j+Y/a+xBpWa63naq2LAd/ytn8RDmEKobOKgefNdedcYr2luRLYp7X+TmtdqLWeAewGriqxzDda6x3m5wtKvlhrfRDYhKlbOsBlQLbWek1F74nZQa3159o0Nv9UTBdR6imlGmK6C+NZ8+++DFPQn3UdMN/8nhYAb2M66HUrscz7WuvkMvbbKOAVrXW61joZeL+yO0yISpKMqh6XlFElfGjOg3TgFUwnsBfqhOlk9FHzPsrVWpfs1eCK6eJuAKahRbIv4vd40bzObcDXZWz/Qsu11ou01oWYLj4HYWo8KgBmAuFn704sRanZan6uGGitlKqltT6sTXcVlqcA080ewaXskwv9rLVeZ655GqaTbYAhwBGt9TvmdZzWWq81PzcOeFprnaK1zsN0Uj1CVW6YkJfM61uM6cPDDK31Ma11KqaT+nalvGYwsENrPdu8LydhuuhSUnn7r6RRwGRz7ScxfZi40Nda673m/x8/ltgnwjHJsaF6WPTYoLVO01rP0Vpna61Pm58rud/LytGy8nIIkKi1/tpcz2ZMF59HllhnWfl5NrN+Mj/3Pudn1jhMF0J2mZ9/FWh7Qa+P18znvOW9F+Xl9Fjgf+Z8PQ68iOmCUGWV9bsJYUskv6tHdeV3aV4w74uy6v5Oa71da50FPAuMqqAXzgjgN631MvM56rOY9k9pCjA16DXWWhdprTdqrU+VtWKt9ffmY02h1vodTBePS87ftUJrvcB8Lvod0Mb8eHmfVypzPBDC3klWV4/qyurzrstqrWdprQ9prYu11j9gGp2iU2kvVEop4C7gQfN57GlMuXZ2390OfGV+/4q11qla691KqTCgO/C4OSO3AF8AN5lfV9714I5AkNb6f1rrfK11AqYbwEt7vy7mGCGqiYwl63iu0Vr/efYHpVQnTBdnD5syAjC13Cebn68HTMY0/IKP+bmTl1hDconvG5W3/YsQAqSX+Pm41jq3yhVWLBg4eMFjB811nFXR7zAd0wWTb4HrzT9D5fbJuQsYWuts83LemO52Pmk+OS9ZV1hpdWuti5VSyRdRd/AFz1+4D4S4VJJR1aM6MurCZQ6a13uhMEwNP4VlrKMxpg/fnbTW+ZXYZnnbj67Ea46W+D4HOGG+CHD2ZzDlZUYpry01W7XWR5RpiLVHgC/NQ3Y8rLXeXU4djwEvAeuUUieBd7TWX5WxbMmL0tnm+sC0b+PLeE0j4GelVMmT5SJMDW6p5dQF/91HF/7szX+dl/9aa20+fpRU1rGp3HVR+t9iWftEOCY5NlQPix4blFKemC7ODMTUuxfARynlrLXOKidHy8rLRkDns8MZmblguqh7VllZUVpmlRx6qhEwWSn1TonHFKZ9cXYfVWZflJfTF+7vso6jZZEcFPZA8rt6VFd+l6ai112Y+a6YrjscLX3x/+RvllIqrYxlv8OUozPNN+h9j+kGt1IviivTlAC3m7ehMTUSlJzy5MLc9DDfHFfe55XKHA+EsHeS1dXDEufaKKVuAh7C1OMQ/r3+W5ogTL2qN5bYdwpTT2gw5eGCUl4XDJxtMCxZe2yJ58u6HtwICL7gnN0Z083FpW2nsscIUU2kB6BIBvKAQK21v/nLV2vdyvz8q5hOrKK11r6YhlxQJV6vL1hfFqagAUzz/GAKn5JKvqai7VdImSZNvYrzg+XCuipyscsfwhRwJTXk/IuuFa1zFtBHmeZGGca/DYCXsk8OA7WVUl4X1FVq3eY7Q8Iuou7D/NuYeOG6hbAEyaiqLV8dGQX//f9e2mTgyUDDcnqe7cI0fNtCpVTJO3TPey8wTdJdle3XCG3qVXg5pl5tuzHd0Vbe8ke01ndqrYMxDW/0sTLP7XQRkillXoASzw0q8Xfpr7X20KZefJZwXv6XOH5UdV2hJX6+mPVc7P8FYZ/k2FC15S19bHgYU0+Mzub93sv8uIKyc7ScvEwGll6Qc95a6/GVqPG8nDFnVsncScY0jFTJddfSWq+6yH1RXk5fuL9L7qsL/+ZKOwYKYY8kv6u2fHXkd1nPV/S6CzO/ANNwzGW58JzRE1Mvv/9u2DRX14ta65aYRiUawr+9Tc6rS5nm+3sMUy+U2lprf0zD2JX8+yhLeZ9XKnM8EMLRSFZXbfnqOtc+t4y5N/LnwARMQ4n6Yxp+U124rNkJTDf1tiqx7/y01mdvJEsGosqoPUAp5VNG7eVdD07GNNVKyRz10VoPLmU7lT5GiOojDYAOTmt9GFgMvKOU8lVKOSnTZK5nu277YBqbN1MpFQI8esEqjnL+h969mO6yulIp5Ypp/HT3S9h+mZRpItQWmIaWq4+py3lVXfh7VGQB0FQpdb25juswjWP8W2VXoE3d5P/BNKzdAa31LvPjVd4n2jS06AbgRaWUm1KqB+d3Nf8RuFIp1c/8/jyM6aBa2ZPbH4EnlVK1zQ2X91XydUJUiWRUmb9HRS45o8zuVUqFKqUCMM3P9EMpy6zDdBL3ulLKSynloZTqXnIBbRr64ingT6XU2ZPNLcBopZSrUioW01AQF3pWKeWplGqFqRGxtO1bnFKqnjJNlO2FKTPPUMEwFUqpkeacBNPdkLqi15TiN6CBUuoBZZrI20cp1dn83BTgFfMHApRSQUqpoRe5/osxH2illBpuvnhyP6U32lbGj8BEpVSI+W7vxy/itccx7ceL+f8g7IwcG8r8PSpi6WODD6YLDhnm554/+4LycrScvPzNXO+N5mOFq1Kqo3n/VWQ+EK2UusacWfdyfmZNwXRO28pcg59SamQp66lIeTk9A3jGnM+BmOZF+d783FZMmdpWKeWBaRjni3Gx770QVkHyu8zfoyLVkd9VzY0blFItleki7f+A2frf0TVKMxsYopTqoZRyM7+m1GuPSqm+SqloZWoMOIWpcfHs+fKF9fpgmifqOOCilHoOUw/Ayijv80p1HQ+EsBuS1WX+HhWprnPtkrwwnRsfB1BK3YppXtaSNYaa8xZtGkL1c+A9pVRd82tClFJXmJf/ErhVma4LO5mfa65Nw3quAl4zZ2QMph7XZ89dy7sevA44rZR6XClVSynlrJRqrZTqWMrvU+ljhKg+soMFmO6wcgN2YvrQPRvTnblgmquiPaY7q+YDP13w2tcwfbDNUEo9orXOBO7BNE5wKqa7PFIoX3nbL811Sqkz5pp+BdKADlrrS+kZct7vUdHCWus0THenPWze/mPAEK11eXfClWY60J9/e/+ddbH7pKTrgc6Yurk/j2mI0bN178F0Z84HmO4KuQrTnFyVHZbvRUzdvA9gOhh/V/7iQlQLyShjM2oxpgmc44GXS9lWEaYsaYxpQusUTPONXrjcVEwnd38rpcIxjfUehWmfvsh/cxBgKbAf+At4W5vmrDOCE6YhNw5hytbeQEU9UDoCa81/C78CE7VpLPxK06bhNy7HtH+PYBrrv6/56cnm9S5WSp0G1mDKfosw/+2MxDRfXxrQBFhZxdV9junvKg7YjOmDUiGmIUwrqiMb07xiK83/H7pUsQZh++TYYH3HhkmY5pY+gSmTfi/xmvJytNS8NGfgAEzzhxzClINvUM4FoxK/69nMetP8u7bEdJNcnvn5n83rmqmUOoXpTupBF7cbKszpl83bjAO2YZr/+2Xz6/ZiOib+aX5NefPEluYFYKr5vR91sXULYTDJb2Py+6K2WcJ3wDeYMs4D001g5dW6A9NNF9MxNbqdpOz3pD6m/X8K06ghS/n3GsNkTPNbn1RKvQ8swnRc2YvpmkQulRwOsLzPK9V1PBDCDklWG3euXXKdO4F3gNWYGvuiOf9z+N/ADuCIUursdh7HdB1ljTnX/sQ8X6rWeh2mm6vfw7SvlvJvr8UxmIYZPQT8jGm+xLNDw5Z5PdicsUMwzVd9ANNngS8Av1J+n4s5RohqorSWkZSEEEIIcT6lVCJwR4kTvprcdjimE0dXXfbcgsJOKKUGAVO01hcOlyKEsDJGHhsuhTINA5UCjNVaLzG6HiGEsAVKqX+A77XWXxhdixBCCCGqRnoACiGEEEKIGmMeFmSweViUEEy91X82ui4hhH1RSl2hlPJXSrljGoZaYeqZKIQQQgghhBAOQRoAhRBCCGEzlFILlVJnSvl6yoBappRRy5SarqVETWPLqGmHUTWVQmEaQuQkpiFAd2GaG0sIIapTV0xDlJ4d9v4arXXOxa5EKdWzjFw9U90FCyGELbCR800hhBBCIEOACiGEEEIIIYQQQgghhBBCCGFXpAegEEIIIYQQQgghhBBCCCGEEHbExegCLlZgYKAODw83ugwhhKgWGzduPKG1DjK6jqqQPBZC2BNbzmOQTBZC2A/JYyGEsA6Sx0IIYT2qmsk21wAYHh7Ohg0bjC5DCCGqhVLqoNE1VJXksRDCnthyHoNkshDCfkgeCyGEdZA8FkII61HVTJYhQIUQQgghhBBCCCGEEEIIIYSwI9IAKIQQQgghhBBCCCGEEEIIIYQdkQZAIYQQQgghhBBCCCGEEEIIIeyINAAKIYQQQgghhBBCCCGEEEIIYUekAVAIIYQQQgghhBBCCCGEEEIIOyINgEIIIYQQQgghhBBCCCGEEELYEWkAFEIIIYQQQgghhBBCCCGEEMKOSAOgEEIIIYQQQgghhBBCCCGEEHZEGgCFEEIIIYQQQgghhBBCCCGEsCPSACiEEEIIIYQQQgghhBBCCCGEHZEGQCGEEEIIIYQQQgghhBBCCCHsiMUaAJVSXymljimltpfxvFJKva+U2q+UilNKtbdULUII4egkk4UQwjpIHgshhHWQPBZCCOsgeSyEEJZjyR6A3wADy3l+ENDE/HUX8IkFaxFCCEf3DZLJQghhDb5B8lgIIazBN0geCyGENfgGyWMhhLAIizUAaq2XAenlLDIU+FabrAH8lVINLFWPsF27j5ziyZ+2cTgzx+hShLBZkslCCGEdJI+FEMI6SB4LIYR1kDwWQgjLMXIOwBAgucTPKebH/kMpdZdSaoNSasPx48drpDhhPd5dvJcZ65IYOGk5v28/bHQ5QtirSmWy5LEQQlicnCMLIYR1kDwWQgjrIHkshBBV5GJ0AZWhtf4M+AwgNjZWG1yOqEHHTuXy1+5jDG0bzIETWYz7fhNjOjXk2SEt8HSziT9fIeyK5LEQQlgPyWQhhLAOkseObfraJOZuTsXDzZlark54urng4eqMp5sztVydqWX+19Pt3+9ruZl+Ni3nYnrM/Lirs0IpZfSvJYRNkjwWQojzGdmCkgqElfg51PyYEOfM2phCUbFmYr8mhNb25N0/9vLpsnjWHkjj/dHtaB3iZ3SJQtgLyWQhhLAOksdCCGEdJI9FhbLzC3l94S58PFwJ9HHnaGYR2QWF5OQXk1tQRHZ+IcUX2QTh7KTwdHXGw630RsSSjYsebs54urpQy82JWuaGxHJf4+aMh4szTk7GNTBqrSko0hQUFZNfWEz+hf+W9Vhhsek15sfySj5WwXoKSr6mqMRrzF/eHi5c2z6U6zs3JLS2p2H7RpRJ8lgIIarIyAbAX4EJSqmZQGcgU2st4zuKc4qLNT+sT6ZzRACRQd4APDGoOT2bBPLQj1sY/vEqHhvYjNu6Rxh68iqEnZBMFkII6yB5LIQQ1kHyWFTo582pnMot5KtbOhIbHvCf57XW5BcVk5NfRE5BEdn5Ree+z8k3/Zx79vGCInLyC83/FpNTUHhumbPLZ+YUnL+ugiLyC4svum4PVydz46ALHuZei/9pNHRzxtP8mIuTE/lFRebGNH2u8S2/qJiCCxrd8kp57FwDnLnxTVdjvywXJ4Wbi5Ppy/mCf83fuzo74enpcv5yJZY5mJbFlKXxfLI0nsua1eWGro3o3SRIrjVZD8ljIYSoIos1ACqlZgB9gEClVArwPOAKoLWeAiwABgP7gWzgVkvVImzTqvg0ktKzeXhA0/Me7944kIUTe/H4nDhenr+LpXuP886oNtT18TCoUiGsn2SyEEJYB8ljIYSwDpLH4lJprZm6KpFWwb50aFS71GWUUri7OOPu4oy/heooLComt7CY7PxCcvOLzY2DhecaDc82FuaW2wBpWj4jp4DDmTn/vja/iOyCIrQ29Uw822jm6uyE+wWNbq7OpoY4PzdX82PqvEY2V/P37qU8VlbD3X+2deFrnJ2qrZEuNSOHmeuSmLEumb++Xk/DAE+u79yQUbFhBHi5Vcs2ROkkj4UQwnIs1gCotR5TwfMauNdS2xe2b8b6JPw9XbmiVf3/PBfg5cZnN3Zg2tokXvptJ4MmLeetkTFc1ryeAZUKYf0kk4UQwjpIHgshhHWQPBaXanV8GnuPnuGtETGGztnn4uyEt7MT3u6WucSntabY3ABoz0L8a/HwgGbcd1kTFu88wnerD/L6wt28+8deroxuwA1dGtG+ob/Mz2gBksdCCGE5Rg4BKkSZ0s7ksXjHEW7o0ggPV+dSl1FKcUOXRnSOCOC+GZu57ZsN3NItnCcGNS/zNUIIIYQQQgghhBCX6ptViQR4uXFVm2CjS7EopRTODtTm5ebixJCYYIbEBLP36GmmrTnInE2p/Lw5lZYNfLmhSyOGtg3Gy0INrkIIIUR1cjK6ACFKM2dTCgVFmjGdGla4bJN6Psy9tzu3dY/gm1WJXPPRSvYcOV0DVQohhBBCCCGEEMLRJKdn8+euo4zuGCY3INuxpvV8eHFoa9Y+1Y9Xh0VTrDVP/byNLq/+xQu/7mD/Mbn2JIQQwrpJA6CwOlprZq5PpkOj2jSt51Op13i4OvPcVS35+taOnDiTx9UfruC71Yno6pxZWgghhBBCCCGEEA7v+zUHz41KJOyfl7sL13duyMKJPZkzviv9W9Zj+tok+r+7jNGfrea3uEPkFxYbXaYQQgjxH9IAKKzOugPpJBzPYnTHsIt+bd9mdVk4sRddIuvw7C87uPPbDaRn5VugSiGEEEIIIYQQQjianPwiZq5P5opW9Qj2r2V0OaIGKaXo0CiA965ry+onL+Pxgc1JOZnDhOmb6f7G37y7eA+HM3OMLlMIIYQ4RxoAhdWZuT4ZH3cXroxpUKXXB/m48/UtHXluSEuW7T3BwEnLWLHvRDVXKYQQjicjO5+HfthCcnq20aUIIYQQQghhiLlbUsnMKeCWbhFGlyIMVMfbnfF9olj6aF++vqUj0SF+fLBkP91f/5u7vt3Asr3HKS6WUamEEEIYS2asFVYlIzuf+dsOc11sGJ5uVf/zdHJS3NYjgi6Rdbh/5mZu+HItd/WK5JEBzXBzkXZvIYSoikl/7uOnzam4OCveHNHG6HKEEEIIIYSoUVprpq5KpEUDXzqG1za6HGEFnJ0UfZvXpW/zuiSnZzN9XRI/rk9m8c6jhNfx5IYujRjRIRR/TzejSxVCCOGApCVEWJWfN6eSX1jM6E4XP/xnaVoG+zJvQg/Gdm7IZ8sSGP7JShKOn6mWdQshhCM5cCKL79ccxNvdhZ83p8rQNkIIIYQQwuGsSUhn95HT3NKtEUopo8sRViYswJPHBzZn1ZOXMXl0WwK93Xl5/i46v/oXj8zaytbkDKNLFEII4WCkAVBYDa01M9clExPqR6tgv2pbby03Z14ZFs2nN3Yg5WQOV76/gh/WJ6G1DMUghBCV9cbC3bi7OPHt7Z0o1vDVigNGlySEEEIIIUSNmroqEX9PV4a2DTG6FGHF3F2cGdo2hNnju7FwYk9GdAhlwbbDDP1oJVd9sIIf1yeTk19kdJlCCCEcgDQACquxKSmDPUdPM7pjQ4us/4pW9fl9Yi/ahvnz+Jxt3Dt9E5nZBRbZlhBC2JP1ien8vuMI43pH0b5hbYbENGD62iTJUCGEEEII4TBSM3JYvPMIozs2xMPV2ehyhI1o0cCXV4ZFs/apfrw0tBV5hUU8NieOzq/+yf/m7SReRqkSQghhQdIAKKzGzHVJeLo5c3XbYItto76fB9/f0ZnHBzZn8Y6jDJq8jLUJaRbbnhBC2DqtNS/P30U9X3fu6BkJwN29osjKL+K7NYnGFieEEEIIIUQN+W71QQBu7NrI4EqELfLxcOXGruEseqAXP9zVhd7N6vLdmkT6vbOUsV+s4ffthyksKja6TCGEEHZGGgCFVTidW8BvcYe5uk0w3u4uFt2Ws5NifJ8o5ozvhpuLE2M+X8M7i/dQICdaQgjxH7/FHWZrcgaPDGhGLTfTnc4tg33p0yyIr1cmklsgQ9cIIYQQQgj7lltQxMz1SQxoWZ8Q/1pGlyNsmFKKzpF1+GBMO1Y+cRmPDGjKgeNZjPt+Ez3eWMKkP/dy9FSu0WUKIYSwE9IAKKzCL1sOkVNQxOhOlhn+szRtwvyZf39Prm0fygd/72fUp6tJSsuuse0LIYS1yyss4o3fd9OigS/D24ee99y43lGkZeUza0OyQdUJIYQQQghRM37ZkkpGdgE3dws3uhRhR+r6eDDhsiYsf/wyPr8plmb1fZj05z66vf4390zbyKr9J9BaG12mEEIIGyYNgMIqzFiXRIsGvrQJ9avR7Xq5u/DWyDZ8MKYd+4+dYfD7y5m7ObVGaxBCCGv17aqDpJzM4enBLXB2Uuc91zkigHYN/flseYIMVSOEEEIIIeyW1ppvVh2keX0fukQGGF2OsEPOTorLW9Zj6m2d+OeRPtzeI4JV8Wlc/8Va+r+7lK9XHiAzR+ZfF0IIcfGkAVAYbltKJjsOnWJMpzCUUhW/wAKuahPMwok9aV7fhwd+2MKDP2zhdK6cXAkhHNfJrHw++HsffZoF0aNJ4H+eV0oxrncUyek5zN922IAKhRBCCCGEsLx1B9LZdfgUN3cLN+yahXAc4YFePDW4BWue7Mc7I9vgW8uVF+ftpMurf/HEnDi2p2YaXaIQQggbIg2AwnAz1ifh4erE0LYhhtYRWtuTmXd14cH+TfllSyqD31/OpqSThtYkhBBGef/vfZzJK+TJQS3KXObyFvWICvJiytIEGZpGCCGEEELYpamrE/Gr5co1Bl+zEI7Fw9WZazuE8vM93fntvh4MbRvM3C2pDPlgBdd8tJI5G1NkPnYhhBAVkgZAYaisvEJ+2ZzK4OgG+NVyNbocXJydmNi/CT/e3ZXiYhg5ZTUf/LWPomK5sC2EcBwHTmTx3eqDXNcxjGb1fcpczslJcXfvKHYdPsWyfSdqsEIhhBBCCCEs71BGDot2HGV0xzBquTkbXY5wUK1D/Hj92hjWPtWf569qyancAh6etZUur/3Fqwt2cTAty+gShRBCWClpABSG+i3uEFn5RVzfqaHRpZwnNjyAhQ/0ZHB0A975Yy9jPl9DakaO0WUJIUSNePP33bi5OPHg5U0rXPaatiHU9/Xgk3/210BlQgghhBBC1Jzv1xxEa80NXRoZXYoQ+NVy5dbuEfz1UG+m39mZblF1+HLFAXq/9Q83fbWOP3YelRvYhRBCnEcaAIWhZqxLpnFdbzo0qm10Kf/h6+HK+6Pb8s7INuxIzWTQpGUskHmuhBB2bkNiOgu3H2Fc7yjq+nhUuLybixN39IxgTUI6m2XYZCGEEEIIYSdyC4qYsS6J/i3qERbgaXQ5QpyjlKJbVCAfj+3Aqicu48H+Tdlz5BR3fruBnm/8zYd/7+PY6VyjyxRCCGEFpAFQGGbX4VNsSc5gdMcwq51IWynFtR1CWTCxJxFB3twzbROPz44jO7/Q6NKEEKLaaa15ef4u6vm6c0fPiEq/bnSnhvh6uDBlabwFqxNCCCGEEKLm/Lr1ECezC7ilW7jRpQhRpnq+Hkzs34SVj1/GlBs6EBnkzduL99Lttb+ZMH0TaxPSZL52IYRwYNIAKAwzc10Sbs5OXNs+1OhSKtSojhezx3Xl3r5R/LgxmSHvr2BbSqbRZQlhc46eyuWDv/bJBxArNX/bYbYkZ/DwgGZ4urlU+nXe7i7c1DWcxTuPEn/8jAUrFEIIIYQQwvK01kxdlUjTet50japjdDlCVMjF2YmBrevz/R2d+evh3tzUNZxle49z3WdruGLSMvmcJoQQDkoaAIUhcguK+HlzKgNb16e2l5vR5VSKq7MTj17RnOl3dCE7v4jhn6zks2XxFMv46kJU2uKdR3nnj73M3phidCniAnmFRbzx+26a1/ep0o0Zt3QPx83Zic+WJligOiGEEEIIIWrOxoMn2XHoFDd3C7faEYuEKEtUkDfPXdWStU/1581rY6jr40GIfy2jyxJCCGEAaQAUhliw7TCncgsZ3SnM6FIuWteoOvz+QE/6Na/Hqwt2c9NX6zh2SsZWF6IyxnZqSKfwAF76baf8v7Ey360+SHJ6Dk9f2QJnp4u/yBHo7c6o2DB+2pzCkUx5b4UQQgghhO36elUivh4uDGsXYnQpQlRZLTdnRnUM4/s7OuPh6mx0OUIIIQxg0QZApdRApdQepdR+pdQTpTzfUCm1RCm1WSkVp5QabMl6hPWYuS6Z8DqedI20zaE0/D3d+OSG9rw2PJoNB9MZOHk5f+48anRZQpTJWvLYyUnx+rXR5BUW88zc7TIUqJXIyM7n/b/20btpED2bBFV5PXf1iqRYw1crD1RjdULYF2vJYyGEEJLJonSHM3P4ffsRrusYdlHD4gshqk7yWAghLMNiDYBKKWfgI2AQ0BIYo5RqecFizwA/aq3bAaOBjy1Vj7Ae+4+dZl1iOqM7NbTpoTSUUozp1JDf7utJfV8P7vh2A8/O3U5uQZHRpQlxHmvL48ggbx66vCmLdx5l/rbDltqMuAgf/L2fM3mFPDW4xSWtJyzAkyujGzBtzUEyswuqqToh7Ie15bEQQliC1pqF2w4z+c99RpdSLslkUZZpa5Io1pobu4QbXYoQDkHyWAghLMeSPQA7Afu11gla63xgJjD0gmU04Gv+3g84ZMF6hJWYuS4ZFydVpTmmrFHjut78fG837uwZwXdrDnL1hyvYfeSU0WUJUZLV5fHtPSKICfXj+V92kJ6Vb8lNiQocTMvi29WJjIoNo1l9n0te3929I8nKL+L7tQeroToh7I7V5bEQQlSnFftOMPSjlYyftomF2w+TV2jVN0dKJov/yC0oYsa6JPo1r0fDOp5GlyOEo5A8FkIIC7FkA2AIkFzi5xTzYyW9ANyglEoBFgD3lbYipdRdSqkNSqkNx48ft0StoobkFRYxZ1MKl7esR5CPu9HlVBt3F2eevrIlU2/rRHpWAVd/uJJvVh6Q4Q2FtbC6PHZxduLNETGcyi3gxXk7qrwecene/H0PLk5OPHR502pZX6tgP3o3DeLrlQekR7QQ/1VteQxyjiyEsB5bkzMY+8UabvhyLWln8nlrRAzz7++Ju4tVzzlldefIwnjz4w6TlpXPLd3CjS5FCEcieSyEEBZi0TkAK2EM8I3WOhQYDHynlPpPTVrrz7TWsVrr2KCgqs9NJIy3aMdRTmYXMKZTQ6NLsYjeTYP4/YGe9GgcyAvzdnLbN+s5cSbP6LKEqIwaz+Pm9X25t29jftlySObQNMjGg+nM33aYu3tHUtfXo9rWO653FCfO5DNrY0q1rVMIB1KpPAY5RxZCGG//sdOM+24jQz9aye7Dp3luSEv+fqQ3I2PDcHay3ekeSpBrFg5Ea803qxJpXNeb7o3rGF2OEOJ8ksdCCFEFlmwATAXCSvwcan6spNuBHwG01qsBDyDQgjUJg81cl0Ro7Vr0aGy/b3Ogtztf3hzLi1e3YmV8GgMnLWfpXrnrSBjKavP4nj6NaV7fh6fnbiMzR+aMq0laa16ev4u6Pu7c1SuyWtfdJTKAtmH+fL4sgcKi4mpdtxA2zmrzWAghLkZqRg6PztrKgPeWsWL/CR7s35Slj/Xlth4R1t7rryTJZHGeTUkZbEvN5OZu4ShlFw3YQtgKyWMhhLAQSzYArgeaKKUilFJumCZo/fWCZZKAfgBKqRaYwltaSuzUwbQsVsWncV1sGE72cTdomZRS3NwtnF8ndCfAy5Wbv1rHy7/ttPY5MIT9sto8dnMxDQV6/HQery3YZenNiRIWbDvC5qQMHh7QFE83l2pdt1KKcb2jSErPZsH2I9W6biFsnNXmsRBCVEbamTz+N28nfd/6h1+2HuK27hEse6wvE/s3wdu9es8naoBksjjPN6sS8fFwYXi7C0ceFEJYmOSxEEJYiMUaALXWhcAEYBGwC/hRa71DKfU/pdTV5sUeBu5USm0FZgC3aJk0zW7NXJ+Mk4KRsWEVL2wnmtf35dcJPbipayO+WHGAYR+tYv+xM0aXJRyMtedxTKg/d/aKZOb6ZFbsO1ETm3R4eYVFvPH7bprX92FEB8tk8oCW9YgM8mLKP/EyH6oQZtaex0IIUZYzeYVM+nMvvd5cwjerDnBNu2CWPNKHZ4a0JMDLzejyqkQyWZR09FQuC7cdZlRsGF6215gthE2TPBZCCMux6FmN1noBpolZSz72XInvdwLdLVmDsA4FRcXM2pDCZc3rUd+v+uaZsgUers78b2hrejUJ4tHZWxnywXKev6oVozuGybAiosZYex4/2L8pf+w4yhM/xbHogV7yodvCvlt9kKT0bL69rZPF5udxclKM6xXFY3PiWLbvBL2byvwLQoD157EQQpSUW1DEtLVJfLRkP+lZ+QxqXZ+HBzSlcV0fo0urFpLJ4qxpa5Mo0pqbujYyuhQhHJLksRBCWIYlhwAV4py/dh3lxJk8xnRynN5/F+rfsh6/P9CL2EYBPPnTNsZ/v4mM7HyjyxLCKni4OvPGiBhSM3J4a9Eeo8uxaxnZ+Xzw9356NQ2il4Ub5Ya2C6aerztT/om36HaEEEIIUb0Ki4r5cUMyl739Dy/9tpOWDXz55d7ufHJDB7tp/BPirLzCIqavPchlzerSqI6X0eUIIYQQQlSbChsAlVITK/OYEOWZsS6Z+r4eDt8DpJ6vB9/e1omnBjfnr91HGThpOavj04wuS9gIe8/jjuEB3Nw1nKmrE9mQmG50OXbrw7/3czq3gKcGN7f4ttxdnLmjRySrE9LYkpxh8e0JUZPsPZOFEI5Ja83v2w8zcPJyHpsdR5CPO9Pu6Mz3d3SmTZi/0eWVSvJYXKoF2w5z4kw+N3cLN7oUIWya5LEQ4lJsPJjOZW//w4x1SUaXYlcq0wPw5lIeu6Wa6xB2LDk9m2X7jjOqYxguztLp1MlJcVevKH6+pzuebs5c/8Ua3lq0m+JiGbpcVMju8/jRK5oR4l+Lx+bEkVtQZHQ5dicpLZupqxMZ2SGM5vV9a2SbYzo3xNfDRXoBCntk95kshHAsK/ef4JqPVzHu+01orZlyQ3vm3tud7o0DjS6tIpLH4pJ8szKRqCAvejax+r91Iayd5LEQokpSTmZz17cbST6ZzZM/beOJOXHkFcp1wepQ5iRLSqkxwPVApFLq1xJP+QDSNUNU2qwNyQCMig01uBLr0jrEj9/u78ELv+7goyXx+Hi4Mq53lNFlCSvkSHns5e7C68NjuOHLtUz+ax+PD7R8LzVH8sai3bg4OfHQgKY1tk1vdxdu6hrOR//sJ/74GaKCvGts20JYgiNlshDCMWxNzuCtRXtYsf8EwX4evDkihuHtQqz+5k3JY1EdNiedZGtKJv8b2gqlLDM3thD2TvJYCHEpzuQVcsfUDeQXFbPg/p78suUQHy7Zz67Dp/jkhg4E+9cyukSbVmYDILAGOAwEAu+UePw0EGfJooT9MM0dkUKvJkGE1vY0uhyr4+nmwhvXxnAmr5C3F+2hc0QA7RrWNrosYX0cKo97NAnkutgwPluWwODWDYgO9TO6JLuw8eBJ5scdZmK/JtTz9ajRbd/SPZzPlyfw2dIE3hgRU6PbFsICHCqThRD2a/+xM7yzeA8Ltx8hwMuNZ65swQ1dGuHh6mx0aZUleSwu2TerEvF2d2F4e7lhWYhLIHkshKiSomLNAzM3s+/YGb65tSNN6vnwyBXNiA714+Eft3LVByv44Pp2dIuSXvpVVV4D4GytdQelVLbWemmNVSTsytK9xzlyKpcXrm5pdClWSynFa8Nj2Jq8nPtmbGbBxJ74ergaXZawLg6Xx09d2YJ/9h7j0dlb+XVCD9xcrPsOdGuntebVBbsI8nHnrl6RNb79QG93RsaG8uP6FB4a0LTGGyCFqGYOl8lCCPtyKCOHyX/uY9bGZGq5OjOxXxPu6BmBj+19BpE8Fpfk2OlcFmw7zA1dGuHtXt7lMSFEBSSPhRBV8uai3fy56xj/G9qKnk2Czj1+Rav6NJ7gzd3fbeSGL9byxKDm3NkzUnrrV0F5ZzhOSqmngKZKqYcufFJr/a7lyhL2Ysa6JAK93enXop7RpVg1v1quvD+mHaM+Xc2TP23jwzHtJNBESQ6Xx361XHn5mmju/HYDn/wTz8T+TYwuyab9vv0IGw+e5PXh0XgZdHHjrp5RTF+bxFcrDvDk4BaG1CBENXG4TBZC2If0rHw+XrKfb9ccBA23dIvg3r5R1PF2N7q0qpI8Fpdk+tokCoo0N3UNN7oUIWyd5LEQ4qLN2pDMp0sTuLFLo1KPxVFB3sy9tzuPztrKqwt2szUlkzevjTHsupatKq9LxWigCFMjoU8pX0KU60hmLn/vPsbI2FBcrXz+CGvQoVFtHh7QlPlxh/lhfbLR5Qjr4pB5fHnLelzdJpgPl+xjz5HTRpdjs/ILi3n99900q+fDyNgww+poWMeTK2OCmbY2icycAsPqEKIaOGQmCyFs15m8Qib/uY9eby7hq5UHGNommL8f6c1zV7W05cY/kDwWlyC/sJhpa5Po2yyIiEAvo8sRwtZJHgshLsr6xHSe+nkbPRoH8txVZY8c6O3uwsdj2/PEoOYs3HaYYR+vJOH4mRqs1PaV2Vyqtd4DvKGUitNaL6zBmoSdmLUhmWINozsad8HZ1ozrFcWq/Wm8MG8HHRrVpkk9OU8Sjp3HL1zdipX7T/DY7K3MGd8NF7mZ4KJ9v+YgB9Oy+ebWjjg7GduzeFzvSOZtPcT3aw5yb9/GhtYiRFU5ciYLIWxLXmER09Yk8dGS/aRl5XNFq3o8MqCZ3XzGkDwWl2Lh9sMcP53Hzd3CjS5FCJsneSyEuBjJ6dnc/d1Gwmp78tH17SvsOKSUYlzvKKJD/JgwfRNDP1zJu9e15fKWMuJgZZTZAKiUukFr/T3QUin1n7G6pPu2KE9xsWbm+mS6N65DozpyN11lOTkp3r2uDYMnL2fC9M38MqE7Hq7ORpclDObIeRzg5cYLV7fivhmb+WrlAe7qFWV0STYlM7uA9//eR88mgfRuGlTxCyysVbAfvZoG8fXKA9zeI0LyTdgkR85kIYRtKCrW/LQphUl/7iM1I4eukXV4bGAz2jWsbXRp1cqe8jg9Kx8nBf6ebkaX4jC+XplIRKAXvZoYf44shK2zpzwWQljW6dwCbp+6nqJizZe3dMTPs/JzUHdvHMi8+3ow/vtN3PntBu67rDEP9G9q+M3u1q685tWzrTbeSPdtcZGW7z9BakYOozs2NLoUm1PXx4N3RrVlz9HTvDx/p9HlCOvg0Hk8JKYBl7esxzuL93LgRJbR5diUD5fsIzOngCcHtbCaeUXH9Y7kxJl8Zm9MMboUIarKoTNZCGG9tNb8vv0IAyct49HZcQR4ufHd7Z2Yfmdnu2v8M7OLPM7JL2Lw5OW8OE8++9WUrckZbEnO4OaujXCSi4ZCVAe7yGMhhGUVFWvun7GZhONZfDK2fZWG4A6t7cmscV0Z2SGUD/7ez23frCcjO98C1dqP8oYA/VQp5Qyc0lq/V4M1CTswc10StT1dGdBKuuJWRe+mQdzdK5JPlyXQPSqQQdENjC5JGMjR81gpxcvXtObyd5fy+Ow4Zt7VRT6oV0JSWjZTVx1kZIdQWgb7Gl3OOV0j69AmzJ/PliUwumOYDOsqbI6jZ7IQwjqtij/BG7/vYWtyBpFBXnwytj0DW9e3mhuALMFe8riWmzPXdQxj8l/7GBLTgH4t5DO0pU1dlYiXmzPXdgg1uhQh7IK95LEQwrJeW7CLJXuO88qw1nRrHFjl9Xi4OvPmiBjaNvTnhV93cNWHK/j0hliruvZlTcq96qa1LgLG1FAtwk4cP53HHzuPcm37UNxdZHi3qnp4QDPahPrx+Jw4Uk5mG12OMJij53E9Xw+eGdKSdYnpTFt70OhybMKbi3bj7KR46PJmRpdyHqUU43tHkpSezcLtR4wuR4gqcfRMFkJYj20pmdz45Vqu/3wtx07l8sa10Sx+oBeDohvYdePfWfaSx/f2bUyzej489fM2MnMKjC7Hrh0/nce8uEOMjA3Dx6Pyw44JIcpnL3kshLCMH9Yn8cWKA9zSLZyxnRtd8vqUUozt3Igf7u5KQaFm+Ccr+XmzjDRVmsrcdr9SKfWhUqqnUqr92S+LVyZs1uyNKRQWa0Z3kuE/L4WbixMfjGmP1nD/jM0UFBUbXZIwnkPn8cgOofRsEsjrC3dLo3gFNiWd5Le4w9zZK5L6fh5Gl/MfA1rWJzLIiylL49FaG12OEFXl0JkshDBW/PEz3DttE1d9uILtqZk8c2ULljzSh+s6NnTE3vU2n8duLk68NTKG46fzeG3BLqPLsWsz1iVRUKS5qeulX3wUQvyHzeexEKL6rUlI45m52+nVNIhnrvzPNKGXpH3D2sy7rwdtQv158IetvPDrDrmGfoEyhwAtoa353/+VeEwDl1V7NcLmaa35YX0SncIDaFzX2+hybF7DOp68Mjya+2dsZtKfe3n0iuZGlySM1db8r0PmsVKK14ZHc8V7y3jyp218e1snh7iz/WJprXl1/i4Cvd25u1ek0eWUyslJcXevSB6fs43l+07Qq2mQ0SUJURVtzf86ZCYLIYxxODOHyX/uY9bGFNxdnLi/XxPu7Bnh6D2Z2pr/tek8jgn1565eUUxZGs+VMQ3o2UTOj6pbfmEx3685SO+mQUQGyfUKISygrflfm85jIUT1OZiWxfjvN9IwwJMPxrSzyI1qQT7ufH9HZ15fuJsvVxxgx6FMPhrbnro+1ndDvBEqbADUWvetiUKEfVidkEZiWjb392tidCl24+o2wazcd4KP/4mnW1Qg3S9hjGRh2ySPTZP9Pj6oOc/9soPZG1MYGRtmdElWZ9GOI2w4eJLXhkfj5V6Z+3yMcU27EN79Yy9TlsZLA6CwSZLJQoiadDIrn4//2c/U1QdBw01dG3Fv38YEersbXZrh7CmPH+jfhMU7j/DEnG0sfrCXVZ/L2aLfdxzh2Ok83rg23OhShLBL9pTHQohLdyq3gNunbkADX97cEb9alrthzdXZiWeHtCQm1I8n5mxjyPsr+OSG9nRoFGCxbdqKcptclVLNlFLvKKXmm7/eVko1ranihO2ZuS4ZXw8XBkc3MLoUu/L81S2JCvLmgR+2cOJMntHlCANIHv/rhs6N6BQewEu/7eTYqVyjy7Eq+YXFvL5wN03reTOyQ6jR5ZTL3cWZ23tEsCo+ja3JGUaXI8RFkUwWQtSUrLxC3v9rH73eXMKXKw5wVUwwfz3cm+evaiWNf9hfHnu4OvPmtTEcyszhzd93G12O3Zm6KpHwOp70lpvPhKh29pbHQohLU1hUzITpm0k8kcUnYzsQHuhVI9sd2jaEn+/tRi03Z0Z/tobvVic6/NQzZTYAKqW6Av8AZ4DPgM+BLOAfpVSXGqlO2JT0rHx+336E4e1D8XB1Nrocu+Lp5sKH17cjM6eAR2ZtpbjYsYPL0Ugen8/JSfHGiBjyCot5Zu52hz+QlzRt7UES07J5cnALm5j/Z0ynhvh4uDBlabzRpQhRaZLJQoiakFdYxDcrD9D7rSW8+8deukbV4fcHevHOqDaEBXgaXZ5VsNc8jg0P4Oau4UxdfZB1B9KNLsdubEvJZOPBk9zUNRwnJ5lGQIjqZK95LISoulcW7GLZ3uO8fE1rukbVqdFtN6/vy68TetCzSRDP/rKDR2bFkVtQVKM1WJPyxpN4Dhijtf6nxGNzlVJ/A88DgyxZmLA9P21KIb+omNGdZEg+S2he35dnh7Tk2bnb+XLFAe600rm9hEVIHl8gItCLhwc05dUFu5m/7TBDYoKNLslwmTkFTP5rHz0aB9LHRu5q9vFw5aaujfj4n3gSjp+RuViErZBMFkJYTFGxZu7mVN79Yy+pGTl0iQzgs5ua075hbaNLs0Z2m8ePDWzGX7uP8vicOBZO7Ck32FaDb1Yl4unmzIhY6x4lQwgbZbd5LIS4eNPWHuTrlYnc3iOC0Z0aGlKDXy1Xvrgplvf/3sekP/ex+8gpptzQwSFvpCuve0DUBcENgNZ6KSAtD+I8Wmtmrk+mbZg/zev7Gl2O3bqhc0OuaFWPNxftliHzHIvkcSlu6x5Bm1A/nv9lB+lZ+UaXY7iPl+wnM6eAJwc3Rynbuav5lm4RuDo78dmyBKNLEaKyJJOFENVOa83iHUcYNHkZD8/aSm0vV769rRMz7uwijX9ls9s89nRz4fXhMRw4kcV7f+w1uhybd+JMHvO2HmJEh1B8PSw3/5AQDsxu81gIcXFW7T/B87/soG+zIJ4a3MLQWpycFA/0b8qXN8eSlJ7NVR+uYNne44bWZITyGgBPl/NcVnUXImzbhoMn2X/sDNcb1KrvKJRSvHltG+r6eHDfjM2czi0wuiRRMySPS+Hi7MSbI9pwKreAF+ftMLocQyWnZ/P1ykSubR9Kq2A/o8u5KEE+7oyKDeWnTakyp6OwFZLJQohqtTo+jeGfrOKu7zZSWKT56Pr2/HpvD3o1DbKpm3oMYNd53L1xIGM6NeTz5QlskZs/L8nMdUnkFxVzU9dwo0sRwl7ZdR4LISrnwIksxk/bRESgF++PaYezlQy53a9FPeZN6EF9Xw9u/nodHy3Z71DTCZU3BGiYUur9Uh5XQIiF6hE2asa6JLzdXRjSpoHRpdg9P09XJo9uy3WfreHpn7czeXRbuTBg/ySPy9Csvg8T+jbhvT/3clVMMP1b1jO6JEO8tWgPTk7w8ADbnGP9rp5RTF+bxJcrD/DkIGPvEBOiEiSThRDVYntqJm8u2sOyvcep7+vB68OjGdEh1Cbm8bUSdp/HTw5uzj97jvHY7K3Mu68H7i4yFOjFKigq5vs1SfRsEkjjujLcvBAWYvd5LIQoX2ZOAbdPXY+zk+LLmzviY2U97sMDvfjpnm48Pmcbby3aQ1xKBm+PbGN1dVpCeQ2Aj5bz3IbKrFwpNRCYDDgDX2itXy9lmVHAC4AGtmqtr6/MuoX1yMwpYMG2wwxvH4qnW3l/UqK6xIYH8GD/Jry9eC89mgQyKlbmXbRzksflGN8nioXbD/P03G10jAjAr5b9H7xL2pKcwa9bD3HfZY1p4FfL6HKqpGEdTwZHN2DamiTu6dPY4d5DYXMuKZPtOY+FEOXLyS9ic/JJ1h1IZ21COqsT0vD3dOWpwc25qWu4zPN28ez+HNnXw5VXh0Vz6zfr+ejv/Tw0oFlNbdpuLNpxhCOncnllWGujSxHCntl9HgshylZYVMyE6ZtITs9m2h1daFjHOufZ83Rz4f3RbWkb5s+rC3Yx9KOVfHZjBxrX9TG6NIsqs7VGaz31UlaslHIGPgIuB1KA9UqpX7XWO0ss0wR4EuiutT6plKp7KdsUxvhlSyq5BcUy/GcNG9+nMSv3p/H8Lzto39Df7sPKkUkel8/NxYm3RrThmo9X8tqCXbx+bYzRJdUYrTWvzN9JoLc7d/eOMrqcSzKudxS/xR1m2tqD3NOnsdHlCFGmS8lke89jIcT5MnMK2HgwnbUH0ll/IJ1tqZkUFGmUgub1fZnYrwm394yQOcmqyFHOkfs2r8vwdiF8/E88A1s3oGWwb02XYNOmrkqkYYAnfZrJ4VQIS3GUPBZClO6l33ayfN8J3rw2hk4RAUaXUy6lFLf3iKBVsC8Tpm9i6IcreXtkGwZF2++ohpYcW6QTsF9rnaC1zgdmAkMvWOZO4COt9UkArfUxC9YjLEBrzfS1SbQO8aV1iG3NO2XrnJ0Uk0a3pZabMxOmbya3oMjokoT1svs8jg71486ekcxcn8yKfSeMLqfGLNpxlPWJJ3no8qZ4u9t2D+zWIX70bBLIVysSJc+EPbP7PBbCkR07lctvcYd4/pftDJy0jLb/W8xt32zgqxUHzBcbIvnqlli2PDeAhRN78uDlTaXxz1g2k8nPXdUSf083Hp29lYKiYiNKsEnbUzNZn3iSm7o2spp5iIQQpbKZPBZCnO+71YlMXX2Qu3pFMqqj7YxQ1yWyDvPu60HT+j6Mn7aJ1xfuptBOz7Es2QAYAiSX+DmF/4773BRoqpRaqZRaY+7uLWzI1pRMdh85zeiO0vvPCPV8PXhnZBt2HznNqwt2GV2OsF4OkccP9G9CZKAXT/wUR1ZeodHlWFx+YTGvL9xFk7rejIoNNbqcajG+TxQnzuQxZ1OK0aUIYSkOkcdCOAKtNQfTspi1IZnHZm+lz1tL6PTqX0yYvpkfN6QQ6O3OA/2aMuPOLsQ9fwVzxnfjiUHNuax5PRnq2nrYTCb7e7rx8jWt2HHoFJ8tSzCiBJs0dVUitVydGSlTZghh7Wwmj4UQ/1qx7wQvzNtJv+Z1eXxgc6PLuWgN/Gox864ujO3ckClL47nl6/WkZ+UbXVa1M7q7gAvQBOgDhALLlFLRWuuMkgsppe4C7gJo2FAamqzJzHVJ1HJ1ZmjbYKNLcVh9m9fljh4RfLHiAN0bB3JFq/pGlyRsk83nsYerM2+OiGHkp6t5a9EeXri6ldElWdT0tQdJTMvm61s64uJsyft5ak7XyDq0CfXjs2UJjO7YUO7UFo6qUnkM1p3JQtib4mLN3mOnWX/APKRnYjpHT+UB4O/pSmyjAMZ2bkTHiABaBfviaifHZmE958gDWzfgyugGTP5zH1e0qidTQFQg7Uwev2w9xKjYUGl0F8I+WE0eCyEg/vgZ7pm2kcZB3kwe085mr9+4uzjzyrBo2oT688wv27nqgxVMuaED0aH2M9JhhZ9KlFKhSqmflVLHlVLHlFJzlFKV6WqQCpS8zSrU/FhJKcCvWusCrfUBYC+mMD+P1vozrXWs1jo2KCioEpsWNeFMXiG/bj3EVW0a4CND1xjqsYHNiQ7x47HZcaRm5BhdjrAQyeOKxYYHcHPXcKauTmR9YrrR5VhMZk4Bk//aR/fGdejTzPreh6pSSjGudxQH07JZuP2w0eUIUa4qZnK15TFYfyYLYcsKiorZnHSST5fGc8fU9bR76Q8GTlrOs7/sYEPiSTpF1OGla1qz6IFebHrmcr64OZY7e0XSNsxfGv9qmCOdI79wdSu83J15dHYcRcXaYtuxBzPXJ5NfWMzNXcONLkUIh+FIeSyEI8vIzueOqRtwdXbii5tjbX5KGoBRHcOYPa4rANdOWcWPG5IreIXtqMwnk6+BX4EGQDAwz/xYRdYDTZRSEUopN2C0eT0lzcV05wZKqUBM3bllPAsb8euWQ2TnFzG6k9xRYzQ3Fyc+GNOOwqJiHpi52W7HLBaSx5Xx6BXNCPGvxeOz4+x2LrmP/9lPRk4BTw1ugVK2eZdVWQa0qk9koBdTlsajtVzYElatKpnsUHkshC3JyS9iVfwJJv25l7FfrCHmhcUM+3gVry3cTfzxLAa2qs/bI9uw/LG+rH7yMj4Y044buzSiWX0fnGz0jmc74jDnyEE+7rxwdSs2J2Xw9coDRpVh9QqLivl+zUG6N65Dk3rSU1KIGuQweSyEoyooKuaeaZtIPZnDpzd2ICzA0+iSqk1MqD/z7utBx/DaPDY7jqd/3kZ+oe1fY69MA2CQ1vprrXWh+esboMJbKLTWhcAEYBGwC/hRa71DKfU/pdTV5sUWAWlKqZ3AEuBRrXValX6TcqRm5LBi34nqXq3Dm7k+iWb1fGgX5m90KQIID/Ti1eHRrE88yft/7TO6HGEZNp/HNcHL3YXXh8eQcCKLSX/a3/+F5PRsvl6ZyPB2obQKtp8hCc5ydlLc1SuS7amnWLFfjt3Cql10JjtaHgthzTKzC/hr11FeW7iL4R+vJObFRVz/+Vom/7WPk1kFXNcxjI/Htmfd0/1Y8kgf3hgRw4gOoYQFeNrdzTd2wKHOka9uE0z/FnV5e/EeEk9kGVmK1Vq88yiHM3O5pVuE0aUI4WgcKo+FcDRaa174dQer4tN4bXg0seEBRpdU7QK83Jh6ayfG9Y5i2tokrvtsNUcyc40u65JUpn9mmlLqBmCG+ecxQKUCVmu9AFhwwWPPlfheAw+ZvyzmmZ+3sT7xJL/d14PwQC9LbsphbE/NJC4lk+evaikfgK3I0LYhLN93gg+W7KdLVB26RQUaXZKoXjafxzWlR5NArosN4/PlCQyOrk9MqL/RJVWbtxfvQQGPXNHU6FIsZlj7EN79Yy9TlsbTs4kM2yKsVpUy2dHyWAhrcexULusS08/N4bfn6Gm0BldnRUyoP7f3iKRzRADtG9WW+cJsj0OdIyulePmaaC5/dylP/BTH9Du6SC/UC3yzKpHQ2rW4rHldo0sRwtE4VB4L4Wi+XX2QaWuTGNc7ims7VGZ0X9vk4uzEE4OaExPqx6OztjLkg+V8dH17OkfWMbq0KqlMD8DbgFHAEeAwMAK41ZJFVbeXrmmNs5Pinmmb7HY4uJo2c30S7i5ODGsXYnQp4gIvXt2KiEAvHvxhC+lZ+UaXI6qXzedxTXrqyhYEervx2Ow4u+iyD7A1OYNfthzizp6RNPCrZXQ5FuPu4sztPSJYuT+NuJQMo8sRoiySyUJYKa01B9OymLUhmUdnbaXPW0vo9OpfTJi+mVkbUwj0dufB/k2ZcWcXtr1wBXPGd+OJQc3p27yuNP7ZJofL4/p+HjwzpAVrEtKZvi7J6HKsys5Dp1h3IJ2bu4bjLA2jQtQ0h8tjIRzFsr3HeXHeDi5vWY/HrmhmdDk1YnB0A+be2x1fD1eu/2ItX644YJNT1VTYA1BrfRC4uqLlrFlobU/eHdWG26du4KXfdvLKsGijS7Jp2fmF/LL5EIOjG+Dv6WZ0OeICXu4ufDCmHcM+WsUjs7by5c2x0kvTTthDHtckv1quvHJNNHd8u4FP/olnYv//zA9uU7TWvLJgF4HebozrE2V0ORZ3feeGfLhkP1OWxvPx2A5GlyNswKncAuZtPUQ9Hw/6t6xn8e1JJgthPYqLNXuPnT7Xu299YjpHT+UB4O/pSsfwAMZ2bkTHiABaBfvi6lyZ+2CFrXDUPB4VG8a8rYd5bcEu+javS4i//d4cdjGmrkqklqszo2LDjC5FCIfjqHkshL3bf+w0907fRLP6vky6rq1DjTzQpJ4Pv0zozsM/buWl33YSl5LBa8Oj8XSrzMCa1qHMSpVSz5X1HKae1y9ZoB6L6deiHnf3iuTTZQl0ighgaFvpuVZV8+MOczqvkNEd5YTaWrUK9uPpK1vw/K87+GplIrf3kLkPbJm95XFN6t+yHkPbBvPhkn0MbF2fZvV9jC6pyv7YeZR1B9J5+ZrWeLvbzolGVfl4uHJjl0Z8sjSeAyeyiJAhvEUpios1qxPSmLUhmYXbj5BXWMzwdiEWbQCUTBbCeAVFxWxPzWSdubFvfeJJMnMKAKjv60HniDp0jAigc0QAjYO8HeoihSNx9DxWSvHa8GiumLSMJ3/axtRbOzr8jZ8ns/KZuyWV4e1D8fOU3rxC1BRHz2Mh7NnJrHxun7oBdxcnvrg5Fi8HuB51IR8PV6bc0IFPlsbz9uI97Dlymk9v7ECjOrZxnaq8d6y02aS9gNuBOoDNhfcjVzRjw8GTPPXTNlqH+BEV5G10STZpxrokIoO86BRhfxN92pObujZixf4TvL5wF53CA4gO9TO6JFF1dpfHNen5q1qxYt8JHpu9lTnju+Fig3f9FxQV8/rC3TSu6+1QN1/c2j2CL1Yc4LNl8bw2PMbocoQVSU7PZvbGFGZvTCE1IwdfDxdGxYYxMjaU6BCLH+8kk4WoYTn5RWxOOmmawy8xnU0HM8gxT+0QGejFwFb16RQRQKeIAEJr13L4RhAH4vB5HBbgyRODmvPcLzuYvTGFkQ7e623m+mTyCou5pVu40aUI4WgcPo+FsEf5hcWM+34jhzNzmXFnF4cebcDJSXFv38a0DvFj4szNXPXBCiaPbkdfG5hvuMwGQK31O2e/V0r5ABMxjds8E3inrNdZM1dnJz68vh2DJy/n3mmbmHtvdzxcnY0uy6bsPXqaTUkZPD24hXywtnJKKd68NobB7y/nvhmb+O3+ng7Ra8ge2WMe16QALzdeuLoV983YzFcrD3BXL9sbPnP62iQSTmTx1S2xNtmAWVVBPu6M7BDKrA0pPNi/KXV9PYwuSRgoJ7+IRTuO8OOGZFbFp6EU9GgcyOODmjOgZb0aO6eTTBaiZmxPzWRe3CHWHUhne2omBUUapaBFfV+u6xhGp4gAOoYHEOTjbnSpwiCSxyY3dG7Eb1sP89JvO+ndNMhhz5cKi4r5fs1BukbWselRP4SwRZLHQtgfrTXP/7qdtQfSmXRdWzo0qm10SVahd9Mg5k3owd3fbeS2qeuZ2K8J91/WxKpHHCn3KqJSKkAp9TIQh6mxsL3W+nGt9bEaqc4CGvjV4t3r2rL7yGle+HWH0eXYnBnrknB1VgxvL0Oo2oLaXm5MHt2OpPRsnp273ehyxCWwxzyuSUNiGjCgZT3eWbyXhONnjC7nopzKLWDSn3vpFlWHvs2s/86i6nZXr0gKi4v5amWi0aUIA2it2Zx0kid/2kanV/7kgR+2kHIyh4cub8qKxy/ju9s7c3Wb4Bq/oUsyWQjL2nf0NCOnrOarFQdwVoo7ekby9a0d2fr8ABZM7MkLV7dicHQDafwTkseY7kh/Y0QMeYXFPD13O1pro0syxJ+7jpKakcMt3cONLkUIhyR5LIR9+WplIjPWJTOhb2OuaSftACWFBXjy0z3dGNYuhEl/7uPObzecm47AGpU3B+BbwHDgMyBaa21bV0zL0bdZXe7pE8XH/8TTOTKAYe1CjS7JJuQWFPHTplQGtKpPHW/5sG0rOkUEMLFfU977cy89GgdybQf5e7c19pzHNUUpxcvXtKb/u0t5Ys42Zt7Vxarvzinp4yXxZOQU8JSD9rxuVMeLQdENmLbmIPf0jcLXQ+ZzcQTHTucyd3MqP25IYf+xM9RydWZQdH1GxYbRKTzA0P+/kslCWFZWXiHjp23Cy92Z3+7rQ30/x+zNJComefyviEAvHh7QlFcX7Oa3uMNc1SbY6JJq3DerEgnxr0X/FpabB1gIUTrJYyHsy5I9x3hl/k4GtqrPQ5c3Nbocq+Th6sw7I9vQLsyfF+ftZOiHK5hyYwea1/c1urT/KK8H4MNAMPAMcEgpdcr8dVopdapmyrOchy5vSqeIAJ76aTv7j502uhyb8Pv2I2TmFHB9p4ZGlyIu0oTLGtM5IoBnf9luc72fBGDneVxT6vp68OyQlqxLTOf7tQeNLqdSUk5m89XKAwxrF0Jry89rZrXG947idF4h09YkGV2KsKCComIW7TjCHVM30PW1v3l1wW78arny+vBo1j3dj3dHtaVLZB1raLyXTBbCQrTWPP3zNuKPn+H90e2k8U9URPK4hNt7RNImzJ/nf91B2pk8o8upUbuPnGJNQjo3dm2Es/HnCUI4IsljIezE3qOnuW/6Zlo08OXd69pYw+dvq6WU4sau4cy8qwvZ+UUM+2gVv249ZHRZ/1FmA6DW2klrXUtr7aO19i3x5aO1tr6mzIvk4uzEB2Pa4enmzD3TNpGdX2h0SVZvxrokGgZ40jWyjtGliIvk7KSYPLod7i5OTJi+mbzCIqNLEhfB3vO4Jo3oEEqvpkG8sXA3KSezjS6nQm8v2oMCHhnQzOhSDNU6xI+eTQL5csUBcgskv+zNniOnefm3nXR59S/u/m4jcSkZ3Nkzkj8f6s2c8d0Y3akhPlbU81MyWQjLmbEumblbDvFg/6Z0axxodDnCykken8/ZSfHWiBhO5xbwwrydRpdTo6auSsTD1YnRHcOMLkUIhyR5LIR9SM/K5/ap66nl5sznN8Xi6Vbm4JGihNjwAH67rwetQ3y5f8ZmXvptJwVFxUaXdU65cwDau3q+Hkwa3ZZ9x87w3C8yH2B5Eo6fYe2BdK7rGCYt/zaqvp8Hb49sw87Dp3htwW6jyxHCEEopXh3WGoAnf9pm1XOkxKVkMHfLIe7oGUGwfy2jyzHc+N5RnDiTx0+bUo0uRVSDzJwCvltzkKEfruCKScuYujqRThEBfHVLLKueuIwnBjWncV1vo8sUQtSg7amZvDBvB72aBjGhb2OjyxHCJjWt58P9lzVh3tZDLNpxxOhyakRGdj4/b07lmrYh+Hu6GV2OEEIIYZPyC4sZ991Gjp3K4/ObYuU61EWq6+vBtDu6cEu3cL5ccYAbvljL8dPWMSKDQzcAAvRsEsR9fRsze2MKszYkG12O1fphfTIuToqRsTJ/nC3r16Iet3YP55tVifyx86jR5QhhiNDanjwxqDnL951g1sYUo8spldaaV+bvoo6XG+N6RxldjlXoGlWHmFA/PlsWT1Gx9TbcirIVF2uW7zvO/TM20/GVP3l27nbyCot5bkhL1j7Vn09u6MBlzevh4uzwp6dCOJzMnALumbaJAE83Jl3XVm44FOISjOsTRcsGvjwzdzuZ2QVGl2NxP6xPJregmJu7hRtdihBCCGGTzg7Dvy4xnbdGtqFtmL/RJdkkNxcnXri6Fe9d14atKRlc9cEKNiedNLosaQAEmNi/KV0j6/DsL9vZc0TmA7xQfmExszem0K9FXer6yDwctu6JQc1pFezLo7O3cjgzx+hyhDDE2M6N6BQRwMu/7eToqVyjy/mPP3cdY+2BdB64vKlVDX1oJKUU43tHkZiWze/bHeOOdnuRlJbNu4v30PPNJdz45TqW7j3OmI5h/HZfDxZO7MltPSII8JI79oVwVFprHpu9lUMZOXw0tp3kgRCXyNXZiTdHxJCelc/L8+17KNCiYs23qw/SOSKAFg1klEEhhBCiKr5YfoBZG1O4v18Trm4TbHQ5Nm9Yu1DmjO+Gq4viuk/XMH1tkqEjkJXbAKiUclZKLampYozi7KSYPKYt3u6u3DNtI1l5Mh9gSX/sPEpaVj6jOzU0uhRRDdxdnPlgTDvyC4uZOHOL9KSxEY6SxzXFyUnxxrUx5BUW88zc7VY1FGhBUTGvLdxFVJCXzGNygQGt6hMR6MWUpfFW9Z6J/8rOL2TOxhRGf7aaXm8t4YMl+4mq682H17dj7VP9eHFoa1qH+KGUbfbykUwWovp8ueIAi3Yc5YlBzenQKMDocoSNkTwuXesQP8b1jmTWxhSW7j1udDkW8+euo6Rm5HBr93CjSxHC4UkeC2Gb/tp1lFcX7uLK6AY80K+J0eXYjVbBfsyb0IOuUXV46udtPDFnG7kFRYbUUm4DoNa6CChWSvnVUD2Gqevjwfuj23LgRJbVXQw22sz1SYT416JXkyCjSxHVJDLIm5evac26A+l88Pc+o8sRleBIeVxTIgK9eHhAU/7YeZTf4g4bXc45M9clkXA8iycHtcBVhkI8j7OT4q5ekWxLzWTl/jSjyxEX0Fqz8eBJnpgTR6dX/uLhWVs5nJnLo1c0Y9UTl/HtbZ0YEhOMh6uz0aVeMslkIarHxoPpvL5wNwNa1uP2HhFGlyNskORx2e67rAmN63rz5Jw4Tufa51CgU1clEuznQf8W9YwuRQiHJ3kshO3ZfeQU98/YTOtgP94e2UaG4a9m/p5ufHVLR+67rDE/bEhm1KerSc2o+dH4XCqxzBlgm1LqDyDr7INa6/stVpVBujUOZGK/prz35146RwRIjzdMw3Yt33eCB/s3xVlCwK4Mbx/Kin0neP+vfXSJrEOXyDpGlyQq5jB5XFNu6x7B/LjDvPDrDrpF1aGOt7uh9ZzKLeC9P/fRJTKAfi3qGlqLtRrePoT3/tjLlKXx9GgSaHQ5Ajh2KpefNqfy44ZkEo5n4enmzODoBoyKDaNjeG2b7eVXCZLJQlyC9Kx8JkzfTLB/Ld4a2caes0JYnuRxKTxcnXlzRAzXfrKKN37fzcvXRBtdUrXae/Q0q+LTeGxgM5k/WAjrIXkshI04cSaPO6ZuwNvDhc9viqWWm+3fqGuNnJ0UDw9oRnSIHw//uJWrPljBh9e3o1tUzV3PqkwD4E/mL4cw4bLGrE9M5/lfd9AmzN/hx5H/YUMSTgpGdQw1uhRhAf+7pjWbkzN4YOYWFk7sSW2Zc8XaOVQe1wQXZyfeHNGGIR8s58V5O3l/TDtD65nyTzzpWfk8PbilXAgtg7uLM7f1iOD1hbvZlpJJdKjcYGqE/MJi/t59lB83mIYWKyrWdAyvzbheUQyOaYC3e2VOMW2eZLIQVVRcrHnghy2kZeXz0/hu+NWS+W7FJZE8LkP7hrW5vXsEX6w4wJXRwXSNsp+bPr9ZlYi7ixOjO8qN20JYEcljIWxAXmER477byIkzefx4d1fq+3kYXZLdG9CqPr9M8Obe6ZtxruHrfRVendFaT1VKuQFNzQ/t0Vrb5/gRmFplJ41uy+DJy7l32iZ+va+Ho1zE+o/ComJmbUihT7O6NPCrZXQ5wgK83V34YEw7hn28kkdnb+Xzm2Kl0cGKOVoe15Rm9X2Y0LcJ7/25l6vaBHN5S2OGEErNyOHLFQcY3i5EGrUqMLZzQz5asp8pS+P5aGx7o8txKLsOn2LWhhTmbkklPSufer7u3N0rkhEdQokM8ja6vBolmSxE1X20ZD/L9h7nlWGm+UCFuBSSx+V7eEAz/th1lMfnxPH7Az3xdLP96xuZ2QX8vCmVoW2DCZCbWIWwGpLHQlg/rTVP/rSNDQdP8tH17YkJ9Te6JIcRGeTN/Pt61PhQqxWOk6CU6gPsAz4CPgb2KqV6WbYsYwV6u/P+mHYkpmXx5E/bHHY+wL93H+PY6TzGyFCodq11iB9PDmrBn7uOMXVVotHliHI4Yh7XlPF9omhe34enf95GZo4xn0/eWbQHgIevaGbI9m2Jj4crN3RpxMLthzlwIqviF4hLkpGdz7erExnywXIGTV7O92sO0jWyDl/f2pFVT/TjsYHNHa7xDySThaiqVftP8N6fexnaNpjr5XOGqAaSx+Wr5ebMG9fGkJSezTuL9xpdTrX4cUMyOQVF3Nwt3OhShBAlSB4LYf0+XZbAT5tSebB/U66MaWB0OQ7HiHkWKzNQ+jvAAK11b611L+AK4D3LlmW8LpF1eHhAM+ZtPcS0tUlGl2OIGeuSqOfrTt9mQUaXIizs1u7h9Gtel1cX7GZ7aqbR5YiyOWQe1wQ3FyfeGtGGtKx8Xp2/q8a3vy0lk582p3J7jwhC/KXHdWXc2j0cF2cnPluWYHQpdqmoWLN073EmTN9Ep1f+4rlfdqA1vHBVS9Y+1Y+Pxranb7O6jj4/sGSyEBfp2Klc7p+5hcggb14dFi0jT4jqInlcgS6RdbihS0O+WnmATUknjS7nkhQVa75dk0in8ABaBUsPYiGsjOSxEFZs8Y4jvPH7bq5qE8z9/RobXY6oIZVpAHTVWu85+4PWei/gEJM0jO8dRe+mQfzvt50O1yhyKCOHpXuPM7JDmEyo7QCUUrw1sg21vVy5f8ZmsvIKjS5JlM5h87gmRIf6cWfPSH7YkMzyfcdrbLtaa15ZsJM6Xm6M7xNVY9u1dXV9PBjRIZQ5G1M4dirX6HLsRuKJLN5etIceb/zNzV+tY8X+E1zfuSHz7+/B/Pt7ckv3CJkv9l+SyUJchMKiYiaYzzM/GdseLwedZkFYhORxJTwxqAXBfrV4bHYcuQVFRpdTZUt2HyM5PUd6/wlhnSSPhbBSOw+d4oEfthAT4sdbI2LkRjwHUplPXRuUUl8A35t/HgtssFxJ1sPJSfHedeb5AKdvYt59PfD1cIzj1o8bkinWcF3HMKNLETUkwMuNyaPbcf3na3julx28M6qN0SWJ/3LYPK4pD/RvwuKdR3hizjYWP9irRi5O/rXrGGsS0nlpaCt8HOQYU13u6hnJzHVJfLUykScGNTe6HJuVlVfIgm2HmbUxhXUH0nFS0KtpEM8OaUm/FnVxd3E2ukRrJZksxEV494+9rDuQzruj2tCkno/R5Qj7InlcCd7uLrw6PJqbv1rHB3/v49ErbPPc6ZtViTTw82BAK2Pm7RZClEvyuIYUFhVzOreQM3mFnMot4HRuofmrgDN5pu9LPn6mxPc+Hi7c2LURV0Y3kE4fDuLY6VzumLoeXw9XPr8pFg9X+YzvSCpzZXM8cC9wv/nn5ZjGcXYIAV5ufHh9O677bA1PzInjo+vb230LeVGx5sf1yfRsEkhYgKfR5Yga1CWyDhMua8L7f+2jR5M6DGsXanRJ4nwOncc1wcPVmTevjWHkp6t5a9EeXri6lUW3V1BUzKsLdxEZ5MVomQfpooUHejEougHT1hzknr5RDnOTTnXQWrPx4El+3JDM/LjDZOUXERHoxWMDmzG8XSj1/TyMLtEWSCYLUUl/7z7Kx//EM6ZTGMPby/mlqHaSx5XUu2kQIzuEMmVpAoNaN6B1iG0Nobnv6GlW7D/Bo1c0w1UuWgthjSSPK6C1Jq+w+Fxj3bkGurwCTpVoxDM12hVyOq/A3JhnbtwzL5NTiZ7cbi5O+Hq44O3ugo+HKz4eLoQHerLv2BkmztzCW4v2cEePCEZ1DMPTTUZmsFe5BUXc/d1GTmYXMGtcV+r6ymd9R1Pm/26l1F9a637A/7TWjwPv1lxZ1iU2PIBHr2jG6wt3M3VVIrd0jzC6JItatvc4hzJzeWZIS6NLEQa4/7LGrIlP45mft9M2rDYRgV5Gl+TwJI9rVmx4ADd3DeebVYlcGdOAjuEBFtvWzPXJJBzP4vObYuUiRhWN7x3F/LjDTF+bxLjeMoRqRY6eymXOphRmb0gh4UQWXm7OXBnTgFGxYXRoVNvub3KqDpLJQlyclJPZPPjDVlo28OX5qyx7Y41wLJLHVfPMlS1Zuvc4j8zayq8TeuDmYjvnoFNXJ+Lm4sRoGalICKviKHmstSYrv+i8hrsLG/HOfn+qlEa8s8sXFOkKt+Xp5oyPx78Nd74eLoT61zI/Znrc1LBn+t737GPnnncpcySX4mLNX7uP8enSeF6Yt5NJf+3jpq7h3Ny1EXW83at7twkDaa158qdtbE7KYMoN7W3uxh9RPcpr3m+glOoGXK2Umgmcd0VIa72popUrpQYCkwFn4Aut9etlLHctMBvoqLW2yq7hd/WMZN2BdF5ZsIt2DWvTJszf6JIsZsa6JOp4udG/hQyp4YhcnJ2YNLotgyYv574Zm5gzvpsM/2Y8yeMa9ugVzfhz11Eenx3Hgok9LTI8wuncAib9sZfOEQH0b1G32tfvKFqH+NGjcSBfrjjALd3CZSiLMmit+X7NQV6ev4u8wmI6RQQwvk8Ug6MbyDxcF++SMlnyWDiS/MJi7p2+meJizcdj20tGi+om58hV4OfpysvXtOau7zYyZWk89/drYnRJlXIqt4CfNqVydZtguUAthPWxmzyevjaJtQfS/tO4d3ZozeIK2u6cFOf1uPPxcKGujwdRQabvvd3/bdA7u0zJ5X09XPFyd7bo0JxOTorLW9bj8pb12JCYzqfLEnj/r318ujSeUbFh3NEzgkZ1pDOAPfj4n3h+3pzKo1c0Y2DrBkaXIwxS3hWf54BngVD+e+eGBi4rb8VKKWfgI+ByIAVYr5T6VWu984LlfICJwNqLK71mOTkp3hnZhivfN80HOP++nvh52t9QY8dO5fLX7mPc0TPCpu4EFNUr2L8Wb42I4a7vNvLm73t4VnqDGk3yuIZ5ubvwxrUxjP1iLZP+3GeR+eWmLI0nLSufr69sIb2uLtH4PlGM/WItP29OZYwMpfofx0/n8ficOP7efYxeTYN48epW0rv70lQ5kyWPhaN5dcEutiab7jgOl9wR1U/OkatoQKv6XNUmmA/+3sfA1vVpagPzcs7akEJ2fhG3dAs3uhQhxH/ZTR7vO3aaLckZpsY7d1caBnjibW6Yq0zvOy83Z5v6fB8bHkBseAD7j53h82UJ/LA+mWlrDzIougHjekURHSo9xmzV79sP89aiPVzTNph7+shoSY6szAZArfVsYLZS6lmt9UtVWHcnYL/WOgHAfAfIUGDnBcu9BLwBPFqFbdSo2l5ufDi2PaOmrOaR2Vv57MYONhXqlTFrYwpFxZrRHeUCqqMb0Ko+N3dtxJcrDtC9cR0uay49Qo0ieWyM7o0DGd0xjM+WxTM4uj4xof7Vtu5DGTl8sfwA17QNrtb1OqpuUXWIDvE7d8eis5N9HZsvxd+7j/LorDhO5xXy/FUtublrOE6yfy7JJWay5LFwGPPjDvPNqkRu6x4hdxwLi5Bz5EvzwlUtWbn/BI/O2sqc8d0s2tvkUhUXa75dnUhso9oyfJkQVsie8vj5q1o55JDljet688aIGB4a0JSvVyYybc1B5scdpltUHe7uHUWvJoF2dw3cnm1PzeTBH7bSNsyf16+NkffOwVV4hlfF4AYIAZJL/JxifuwcpVR7IExrPb+8FSml7lJKbVBKbTh+/HgVy6ke7RvW5olBzflj51G+XHHA0FqqW3GxZub6JLpEBkjPAAHAk4Nb0KKBL4/MiuNIZq7R5Tg8yeOa99SVLQjyceex2XHkFxZX23rfXrwHDTxyRbNqW6cjU0oxvk8UiWnZLNpxxOhyrEJOfhHPzt3Obd9sIMjHnXkTenBr9whp/KtGVczkastj87IOlcnCdhw4kcXjc+Jo19DfIr3ohShJzpGrpo63Oy9e3YqtKZl8tdK6r238s/cYB9OyuVl6/wlh1SSPbV89Xw+eGNScVU9exlODmxN//Aw3f7WOQZOXM3dzKgVF1XddRFjGsVO53PntBmp7uvLZTR1kCH5RcQOgpSilnDB1C3+4omW11p9prWO11rFBQUGWL64Ct/eI4PKW9Xh94W42JZ00upxqsyo+jeT0HBk+TZzj4erMh9e3Iye/iAd+2ExRRYOdC5tky3lsab4errw6LJrdR07z8T/7q2Wd21Mz+XlzKrd1jyC0tme1rFPAFa3qExHoxZSl8Wjt2Fm1PTWTIR8s57s1B7mjRwS/TOhOs/rWP7SXuLg8BsfLZGEbcguKGP/9RlycFR9e316mFRA2yxHOkYfENGBAy3q8s3gvCcfPGF1Omb5emUg9X3cGtq5vdClCCAM4Qh5bGx8PV+7qFcXyxy7jrRExFBVrHvhhC33e+oevVhwgK6/Q6BJFKXILirjzu41k5hTwxc0dqevjYXRJwgpY8tNYKhBW4udQ82Nn+QCtgX+UUolAF+BXpVSsBWuqFkop3h7Rhvp+Htw3fTMZ2flGl1QtZqxLwt/TlStayUm1+FdUkDf/G9qKNQnpfLykehpARI2z2zyuCf1a1GNo22A+WrKfPUdOX9K6tNa8Mn8XtT3duKevjMFenZydFHf2jCQuJZNV8WlGl2OIomLNlKXxDPt4JWfyCvn+9s48M6Ql7i5yx58VkTwWdu/5X3aw+8hp3ruuLSH+tYwuR4jyOHwmK6V4+ZrWuLs48ficOIqt8IbP+ONnWL7vBDd0boSrFQ9TKoS4JA6fx9bKzcWJkbFhLHqgF1/eHEuIfy3+99tOur3+N+8s3sOJM3lGlyjMtNY8OjuOuJQM3ruuLS2DfY0uSViJMs+elFIB5X1VYt3rgSZKqQillBswGvj17JNa60ytdaDWOlxrHQ6sAa7WWm+4xN+pRvh5uvLR9e05djqXh3/capUnyhcj7Uwei3ceYXi7UOkaLP5jRIdQrmkbzHt/7mV9YrrR5TgcyWPjPX9VK3w9XHls9lYKL2HIiyV7jrE6IY0H+jfB18O1GisUAMPbhxDk486UpfFGl1LjDmXkMPaLNby+cDf9mtfj94m96NEk0Oiy7NIlZrLksbBrszem8MOGZO7tG0XfZnWNLkfYOTlHrh51fT14dkhL1iee5Ls1B40u5z++XZWIm7MTYzrLSEVCWCvJY/vn5KTo16IeP47rypzx3egSGcCHS/bT/fW/efrnbSSeyDK6RIf3wd/7mbf1EI9d0Vw694jzuJTz3EZAA6VNFqOByPJWrLUuVEpNABYBzsBXWusdSqn/ARu01r+W93pb0CbMn6cGt+DFeTv5fHkCd/e23d4cczalUFCkGdMprOKFhcNRSvHysGg2J2cwccZmFkzsib+nm9FlORLJY4MFeLnx4tBWTJi+mS9XHKhS3hcWFfPqgt1EBnrJUMsW4uHqzG3dI3jj991sS8kkOtTP6JJqxLyth3j6520UFmvevDaGkbGhMsm3ZVU5kyWPhT3bc+Q0z8zdRpfIAB7s39TocoRjkHPkajKiQyjz4g7zxu+7uax5XcICrGOY+tO5BczemMKQNg0I9HY3uhwhRNkkjx1Ih0a1+fTGWOKPn+GL5QnM2pDC9HVJDGpdn7t7RdEmzN/oEh3Ogm2HefePvQxvH8K43uX+dxMOSNnaPDmxsbF6wwbrucFDa8090zaxeOdRfrirC7Hhlbmxxbporen3zlICvNyYPb6b0eUIKxaXksG1n6yib7O6fHpjB7nAXA2UUhu11jY5bIW15bGlaa25+7uNLN17nIUTexIZ5H1Rr/9+zUGembudz27swAC5G8tiTuUW0P21v+nVLIiPrm9vdDkWdTq3gOd/2cFPm1NpG+bPpOvaEh7oZXRZNsuW8xgcL5OFdTmTV8jVH67gVE4hCyb2kPlGxCWRPDZGakYOA95dSruGtfnu9k5W8Vnv65UHeHHeTn6d0J2YUH+jyxHC4Ugei8o4diqXb1Yl8t2ag5zOLaRLZAB3946iT9MgqziW2LttKZmM/HQVrYP9mHZnZ5kCxI5VNZMrNYC6Uqq2UqqTUqrX2a+LL9E+KaV4Y0QMIf61mDB9M+lZtjcf4NoD6SScyGK09EgRFYgJ9efxgc1ZvPMo31vh8DCOQPLYOJcyR8rp3AIm/bmXThEBXN6yngWrFL4erozt0oiF2w7b9TAkGxLTGfz+cuZuSeX+fk2YNa6rNP4ZQDJZCNMNMk/+ZBr66YMx7aTxTxhC8vjShfjX4snBLVix/wQ/bkg2uhyKizVTVyXSvqG/NP4JYUMkjx1PXV8PHhvYnNVP9uOZK1twMC2bW79ez6DJy/lpUwoFlzCNiijf0VO53PHteup4uTPlxg7S+CdKVWEDoFLqDmAZpm7YL5r/fcGyZdkWXw9XPh7bnvSsfB78YYvNzQc4c10SPh4uXBndwOhShA24rXsEfZsF8dL8Xew8dMrochyK5LHxSs6R8v3ayjeCf7o0gRNn8nl6cAu5A64G3NY9HBcnJz5bnmB0KdWuoKiYdxfvYdSnqwGYNa4rD13eFFfnSt3TJaqRZLIQJt+vTWLe1kM8PKAZXaPqGF2OcECSx9Xn+k4N6RIZwMu/7eJIZq6htSzdd5zEtGxu7hZuaB1CiMqTPHZs3u4u3NEzkqWP9uWdkW0o1pqHftxK7zeX8MXyBM7kFRpdol3JyS/izm83cCa3kC9viZWhskWZKnO1aCLQETiote4LtAMyLFmULWod4sezV7Vk6d7jfLI03uhyKi0jO58F249wTdsQarnJXQKiYk5OirdHtsG/lisTZmwiO18O4DVI8tgKjOgQSq+mQby+cDfJ6dkVLn84M4fPlycwtG2wjIVfQ+r6enBth1Bmb0zh2GljL15Vp8QTWYyYspr3/97PNe1CWHB/Tzo0sr2hx+2IZLJweHEpGbw0byd9mgUx3obnQxc2T/K4mjg5Kd64NoaC4mKe/nkbRk4Z883KROr6uDOotdyoLIQNkTwWuLk4cW2HUBY90Iuvb+lIWIAnL8/fRbfX/uKtRbs5fjrP6BJtXnGx5pFZW9mWmsnk0e1oXt/X6JKEFatMA2Cu1joXQCnlrrXeDTSzbFm26YbODRkS04B3Fu9hbUKa0eVUyk+bUskvLGaMDP8pLkIdb3cmXdeWAyeyeOHXHUaX40gkj62AUorXhkejgKcqcWHk7UV70cAjA+Stqkl39YqkoKiYr1cmGl3KJdNa88P6JAa/v5wDx8/w4fXteHdUW3w8XI0uzdFJJguHlpldwD3TNhHo7cZ7o9ri5CQ93IVhJI+rUaM6XjwyoBl/7T7GL1sOGVJDwvEzLN17nLGdG+HmIqMcCGFDJI/FOUop+javyw93d+Xne7rRvXEgH/8TT/c3/ubJn7aRcPyM0SXarMl/7WP+tsM8Oag5/WWaGVGBypxJpSil/IG5wB9KqV8AmfyrFGcvCjeq48V9MzZz4ox139GgtWbm+iTahPrRMljuFBAXp1vjQO7t05gfN6Twy5ZUo8sxTNqZPJbsOVZTQ+RIHluJEP9aPDGoOcv3nWDWxpQyl9uemslPm1O4tXs4YQGeNVihiAj0YnDrBny/5iCncwuMLqfKTmblM/77TTw+ZxttQv35/YFeDIkJNrosYSKZLByW1ppHZm/l6KlcPhzbntpebkaXJByb5HE1u7V7BO0a+vPCvB2G9NT4dvVBXJ0V13eWG5WFsDGSx6JU7RrW5pMbOvD3w30Y0SGUOZtS6PfuUsZ9t5HNSSeNLs+m/Lr1EJP/2sfIDqHc2TPS6HKEDXCpaAGt9TDzty8opZYAfsDvFq3Khvl4uPLR9e0Z9vFKHvxhC9/c2glnK70bdlNSBnuPnuG14dFGlyJs1AP9m7AmIY2nf95O2zB/GtXxMroki8rMLmBbaiZxqRlsS8kkLiWT1IwcAF4dFm3xD6iSx9ZlbOdGzIs7zEu/7aR30yDq+Xqc97zWmlcX7MK/liv39GlsUJWObVzvKOZvO8z0tUncbYND0y3fd5xHZm0lPSufJwc1586ekdLDxopIJgtH9vnyBP7YeZTnhrSkfcPaRpcjHJzkcfVzdlK8NSKGwZNX8MKvO/hobPsa2/aZvEJmb0xhSEwwQT4yn5EQtkTyWFQkItCLV4dF82D/pkxdlci3qxP5fccROkUEMK53JH2a1pXPvCXk5BeRcOIM8ceziD92hvjjZ/hj51E6hQfw8rDWKCX7SlSswgZApdT7wEyt9Sqt9dIaqMnmtQz25YWrW/HkT9v4aMl+7u/XxOiSSjVzXRJebs5c1UZ6EoiqcXF2YtLotgyevJz7Zmxm9rhudjNEy5m8QnakZrItNZOtKZlsS8kgMe3f+d4a1fGkfaPa3NItnOhQP6JD/Cxek+SxdTk7R8rASct4Zu52Pruxw3knX//sOc6q+DReuKolfrVkqEYjRIf60aNxIF+uOMAt3cNxd7GNuW5zC4p4a9EevlxxgMZ1vfny5o60roGMERdHMlk4qg2J6bzx+x4Gta7Prd3DjS5HCMljC2lc14eJ/Zvw1qI9DNl2mEHRNTMX35yNKZzJK+TmbuE1sj0hRPWRPBaVFeTjziNXNGNcnyh+WJ/Ml8sTuO2bDTSt581dvaK4uk2w3VxfrIjWmhNn8ok/bmrg23/s3wa/s50OAJwUhAV40r9FPf43tJXNXN8QxquwARDYCDyjlGoG/IwpyDdYtizbN7pjGGsT0pj0515iw2vTLSrQ6JLOcyq3gHlxhxjWLgRv98r8GQhRutDanrw5IoZx32/i7cV7eGpwC6NLumi5BUXsPHyKuOQM4lIz2ZaSyf7jZzg7tVuIfy2iQ/wYGRtGm1B/Wof44u9pyFBXksdWJiLQNEfKKwt28Vvc4XM3VBQWFfPqgl1EBHpxfedGBlfp2Mb1juKGL9fy86ZURtvAfLd7jpxm4szN7D5ympu6NuLJQS2o5SYn9lZKMlk4nLQzeUyYvpmw2rV4Y0SM3HUsrIXksYXc1SuShdsP8+wvO+gSWcfiw/0WF2umrkqkbZg/bcP8LbotIYRFSB6Li+Lt7sLtPSK4qWsjfos7xKdLE3hk1lbeXrSH23tEMLpTGD4e9nFDdUFRMUnp2eaefFnnGvzij53hVG7hueVquToTVdeL2PDaXBcURlSQN1F1vQiv44WHq1wbEBevMkOATgWmKqUCgGuBN5RSDbXW1tmtzUoopXhlWDTbUjO5f8YWFkzsQV0fj4pfWEN+2XKI3IJiRne0/ouhwvoNbN2AG7s04rNlCXSNqkPfZnWNLqlM+YXF7Dly+twwnltTMtl79DRFxabWvkBvd9qE+jEkJpiYUD9ah/hZzdAzksfW6bYeEfy27TDP/7qDblF1qOPtzo8bUth37Ayf3tjBYe5as1bdG9ehdYgvny5LYGRsmNUOy11crPlmVSKv/74bXw8Xvrollsuay2Te1kwyWTiaomLNAz9sIT07n5/v6YavnVyMEbZP8thyXJ2dePPaNlz94Qpe+m0n717X1qLbW77/BAknsphk4e0IISxD8lhUlauzE8PahXJN2xCW7j3Op0sTeGXBLt7/ex83dGnErd3CqetrPdfVy3Mqt4CEEkN2mr6yOJiWRUGRPrdcXR93ooK8ubptMFFB3jSu601UkDf1fT1kGFRRrS6m61djoDnQCNhlmXLsi5e7Cx+P7cDQj1YwccYWvr+js9VceJy5LokWDXyJCZUhxUT1ePrKFqxPTOeRH7eycGJPqzgwFxYVs//4GeJSMs1z9mWw6/Bp8ouKAfD3dCU6xI9+zaOIDvUjJtSP+r4etnA3u+SxFTk7R8qV7y/nxXk7eXV4NO/+sZdO4QEMaCkNOEZTSjG+d2Punb6JxTuO1NjwVRfj2KlcHpkdx7K9x7mseV3eHBFDoLd13HggKkUyWTiED//ez/J9J3h9eDStguUzhLBKkscW0DLYl3v6RPH+3/sZ0qaBRW9QmroqkSAfdwZb4fmaEOKiSB6LKlFK0adZXfo0q8vW5Aw+W5bAp0vj+XL5AYa3D+HOXpFEBXkbXSZaaw5n5p7rwbf/+Bnij5l69R07nXduORcnRaM6nkQFeTOgZT1zbz5vIoO85GY6UWMqMwfgm8AwIB74AXhJa51h4brsRrP6PvxvaGsemx3H5L/28dDlTY0uiW0pmew4dIqXhrayhYYOYSM8XJ358Pp2XPXBSh78cQvf3da5Ru9YKS7WHEjLMvfqyzj3d55TUASYhhWIDvHj1u6mOfvahPoTWruWTf0fkDy2Xk3r+XDfZU1494+9HD+dx4kzeXxxc6xN/X3Zs4Gt6xNex5MpS+MZ2Lq+Vb0vi3Yc4Yk5ceQUFPHSNa25oXNDq6pPlE0yWTiSFftOMOmvvQxvF8J1HcOMLkeI80geW969lzXm9x1HeOqn7Sx+KMAiFy0TT2SxZM8x7r+siYygIYSNkjwW1alNmD8fjW1P4oksvliRwKwNKfywIZnLW9Tj7t5RdGhU2+I15BYUkZiWda5x7+xXwvEssvOLzi3n4+FC47re9GoaZGrkC/Iiqq43DQM8cXWWY5owVmV6AMYDXbXWJyxdjL0aFRvG2oR0Pvh7Hx3Da9OzSZCh9Uxfl4SHqxND24UYWoewP43r+vDC1S15fM42Plkaz719G1tkO1prUk7mnGvoi0vJZHtqJqfzTGNme7g60TrYj9GdTHP2RYf6EVHHyx660EseW7HxfaJYsO0wqxPSuLpNsMxbYkWcnRR39YriqZ+3sTo+jW6NjZ+XNzu/kJd+28mMdcm0DvFl0nXtaFzX+DsZxUWRTBYO4UhmLhNnbqZJXW9eHtZablIQ1kjy2MLcXZx5c0Qbhn+8ktcW7OK14THVvo1vVx/EWSnGdpZpSoSwYZLHotqFB3rx8jXRPNC/Kd+uSmTq6oMs3nmUjuG1ubtXFJc1r3vJ1/vSs/LP9eY7O2Rn/PEzJKdnU/zvqJ2E+Nciqq43HcMDzA19pvn5grzd5RxZWK3KzAH46dnvlVK/aa2HWLYk+/TSNa2IS8nggZlbWDCxJ/UMGh4xK6+QX7ekcmV0sHQ1FhYxKjaMFfvTePePvXSJDKBDo4BLWp/WmqOn8v5t7EvNZFtKBiezCwBwc3aiRQMfhrYLJibUn5hQPxoHeeNih3fYSB5bN1dnJ94d1ZY3ft/NYwObGV2OuMDw9iG8+8dePlkab3gD4NbkDB74YQuJaVmM6x3FQ5c3lTvdbZBksnAEhUXF3DdjEzkFRXw8tj2ebhczg4QQNUPyuGa0DfPnzp6RfLosgSExwXSvxvOprLxCZm1I5sqYBlYxlYQQomokj4UlBXq789CAZtzdO4ofNyTzxfID3PHtBhrX9eauXpEMbRuMu4tzma8vKtaknMw2N/Rlsb/EHH1nrzECuLk4ERnoResQP4a2DSEqyIvGdb2JCPSSc2Fhky72r1a6jFWRp5sLH49tz9UfruS+GZuZfkdnQxoofos7RFZ+Edd3lqF7hGUopXhlWGu2JJ/k/hlbWHB/T/w8K9/YfOJM3rlefXEpGcSlZnLcPH62s5OiaT0frmhV3zRnX4g/zer7OOqFc8ljK9Qy2Jept3UyugxRCg9XZ27rEc6bv+9he2omrUNqfv6qomLNJ//sZ9Kf+wjycWf6HV3oGlWnxusQFiGZLOzSW4v3sD7xJJNHt6VxXR+jyxGiMiSPLejBy5uyeOdRnvgpjt8n9sLLvXouhP60KYXTeYXc3C28WtYnhLAKksfCIrzcXbi1ewQ3dGnEgm2HmbI0gcdmx/HO4j3c1j2CYe1COHY677wGvvhjWRw4kUV+UfG59dTxciMqyJuBreufm5uvcZA3wf61cLb9EcSEOOdiz9Y2W6QKB9Gkng+vDGvNQz9u5b0/9/LoFc1rvIbp65JpUteb9g0tP06ycFy+Hq58MKY9Iz5ZxRM/xfHx2PaldoXPzC5gW+q/c/ZtS80kNSMHAKUgKsibnk0CiQnxIzrUn1bBvni4ln03j4ORPBbiIt3QpRGfLIlnytJ4Pry+fY1uOzk9m4d+3ML6xJMMiWnAK9dEX9TNEcLqSSYLu/PHzqN8ujSBsZ0bMrStXMMTNkPy2II8XJ15c0QMoz5dzVuL9vDC1a0ueZ1aa75ZlUibUD/ayRD6QtgTyWNhUa7OTgxtG8LVbYJZvu8Eny6L57WFu3lt4e5zyzgpaFTHi6ggL/o0Czo3ZGdkoDe1vdwMrF6ImlNmA6BSygMYBzQGtgFfaq1vq6nC7NXw9qGsTUjnoyXxdAwPoE+zujW27V2HT7E1OYNnh7SUcYmFxbUN8+fRK5rx2sLdTFubxDXtQtiRau7ZZx7GMzEt+9zy4XU8ad+oNrd0Cycm1I9WIX54V9MdpbZO8liI6uHr4cr1XRry+bIEDqZl0aiOV41sd+7mVJ6dux0NvDuqDcPahchx2IZJJgtHkJyezcM/bqF1iC/PDmlpdDlClEry2BgdwwO4qUsjpq5O5MqYBnQMv7QpH1bsP0H88SzeHdVGzo+EsFGSx8JISil6NQ2iV9MgtqVksjrhBGG1PYmq602jOp7lDgsqhCMo7+r6VKAAWA4MAloCE2uiKHv34tBWbE3J4MEftjD//p4E+9eqke3OXJeEm7MTw9vJHbyiZtzZM5KV8Wk8/+sOnv1lO9o8cW6Ify2iQ/wY1TGMmBB/okP8pCdM+SSPhagmt3eP4OsViXy2LIFXhkVbdFuZOQU8O3c7v249RGyj2rx3XVvCAjwtuk1RIySThV3LKyzi3umb0MDH13eQ0ReENZM8NshjA5vz565jPD47jgUTe15STkxdlUigtxtXxjSoxgqFEDVM8lhYhehQP6JDa366DyGsWXkNgC211tEASqkvgXU1U5L983B15qOx7bn6gxXcN2MzM+/qgquF5wPMyS/i582pDIquL12cRY1xclK8O6oNb/6+mxB/T2JC/Wgd4keQj7vRpdkayWMhqkldXw+u7RDCrI0pPNC/qcXyaG1CGg/9uJUjp3J5+PKmjO8TZcjcv8IiJJOFXXtl/i7iUjL59MYONKwjNy0IqyZ5bBAvdxfeuDaGG75cy3t/7uXJQS2qtJ6ktGz+2n2M+/o2lh4aQtg2yWMhhLBS5V2JKjj7jda6sAZqcShRQd68OjyajQdP8vaiPRbf3oJthzmVW8jojg0tvi0hSgr0dufNEW2Y2L8JfZvXlca/qpE8FqIa3dkzkoKiYr5eeaDa151fWMwbv+9m9OdrcHVWzBnfjfv6NZHGP/simSzs1ryth/h29UHu7BnBFa3qG12OEBWRPDZQjyaBjO4YxufLEtianFGldXy7OhFnpRjbpVH1FieEqGmSx0IIYaXK6wHYRil1yvy9AmqZf1aA1lr7Wrw6Oze0bQhrD6Tz6bIEOkUE0K9FPYtta+b6JCICvegSeWnj8wshDCF5LEQ1igzyZlDr+ny35iDj+0Th41E9QxDHHz/DAzO3sC01k+tiw3juqpZ4yVym9kgyWdil+ONneGJOHB0a1eaxgc2NLkeIypA8NthTV7bgnz3HeWx2HPPu64GbS+VveMrKK+SHDckMim5APV8PC1YphKgBksdCCGGlyjw701o7a619zV8+WmuXEt9LcFeT54a0pGUDXx76cSspJ7Mtso39x06zPvEk13UMk0m1hbBBksdCVL9xvaM4nVvIjHVJl7wurTXfrznIle8vJ/lkNlNu6MAbI2Kk8c9OSSYLe5STX8Q932/C3dWZD69vZ/HpCYSoDpLHxvP1cOWVYa3Zc/Q0Hy3Zf1Gv/XlzKqdzC7mlm/T+E8LWSR4LIYT1kk92BvNwdebjse0pKtZMmL6Z/MLiat/GjHXJuDorRnQIrfZ1CyGEELYoJtSf7o3r8MXyA+QVFlV5PWln8rjz2w08M3c7HcMDWPRALwa2lmHzhBC25blftrP32GkmXdeWBn61jC5HCGFD+rWox7B2IXy0ZD+7Dp+q+AWYbp6auiqR6BA/2jesbeEKhRBCCCEcl0UbAJVSA5VSe5RS+5VST5Ty/ENKqZ1KqTil1F9KKYe89Ss80Is3ro1hS3IGb/y+u1rXnVdYxE+bUri8ZT0CvWXuNSEcleSxEP81rncUx07nMXdzapVev2TPMa6YtJxl+07w7JCWTL21kwxhJSokeSyszY8bkpm1MYX7+jamV9Mgo8sRokZJJleP54a0xN/TlUdnb6WwqOKbmlfFp7Hv2Blu7hYuoxQJIQDJYyGEsBSLNQAqpZyBj4BBQEtgjFKq5QWLbQZitdYxwGzgTUvVY+2ujGnATV0b8eWKAyzacaTa1rtox1FOZhcwumPDalunEMK2SB4LUboejQNpFezLp0sTKCrWlX5dbkERz/+ynVu/Xk8dLzd+ndCd23tE4OQkF7BE+SSPhbXZdfgUz87dTvfGdZjYv6nR5QhRoySTq09tLzf+N7Q121NP8dnyhAqX/2ZVIgFebgyJaVAD1Qkh/s/eXYdHca9tHP8+8YSE4E6CuztV6tRdaKmf0/bU3+rpqdupnbq7QKGlTkvdBYq7e4J70EDk9/6xk3aBJATIZnY39+e69kqyMzvzzCa5M5mfTLhTHouIhE4oRwD2AuY55xY453YA7wEnB6/gnPvJOVd047s/gUo9R+Xtx7elY8N0bvpgMtnryud+gO+NyaJR9WQOalGrXLYnIhFJeSxSDDPjX/2as2DNFr6bUbbON9OX5XDis7/z9qjFXHJgUz67+kDa1NNtLaTMlMcSNjbl5nHluxNIT47nqbO7EqtODFL5KJPL0XEd63Nsh3o89f1c5q3aXOJ62eu28v3MlZzbK4Ok+NgKrFBEwpjyWEQkRELZANgQyA76eon3XEkuBb4qboGZXWZm48xs3OrVq8uxxPCSGBfL8+d2A+CqIRP2655EAIvWbGHk/LWc07OxRiWIVG7KY5ESHNuhPpk1U3jxlwU4V/IowMJCxyu/zufU50eyYVse71zSi7tObKcLV7K3yi2PQZks+845x78/nkrWuq08O6ArtdN0qwCplHSOXM7uPbk9KQmx3PLh5BJnVxj052JizDivj2YpEpG/KI9FREIkpPcALCszGwj0AB4rbrlz7hXnXA/nXI/ataP7vhQZNVN47IzOTFmSw0Nf7t/9AN8bm01sjHFmj8blVJ2IRDvlsVQ2sTHGZYc0Y3L2BkYtWFvsOstztjHw9dH898tZ9Gtdm2+uP0T3yZKQ21MegzJZ9t07oxYzYspybjq6Nb2b1fS7HJGwp3PksqmTlsTdJ7ZjQtYG3h65aLflW3fk896YLPp3qEf99OSKL1BEIp7yWERk74SyAXApENzy1Mh7bidmdiRwO3CSc257COuJGP071OPiA5vw1shFfDl1+T5tY0d+IR+Oz+aw1nWoWzWpnCsUkQijPBYpxendGlErNZGXftn9njVfTl1O/6d+Y2LWBh4+rSMvn9+dGlUSfKhSooTyWHw3OXsDD4yYwRFt6nD5Ic38LkfET8rkEDilS0MOb1OHR7+ZxeK1W3Za9unEZWzMzeeiA5r4U5yIhCvlsYhIiISyAXAs0NLMmppZAnAOMDx4BTPrCrxMILhXhbCWiHPbsW3p3Lgat344ZbeT5rL4YeZK1mzewbm9NfpPRJTHIqVJio/lkoOa8Ouc1UxbmgPA5u353PTBZK58dwJNaqbw5XUHc06vDMw0pbbsF+Wx+GrD1h1c+e4E6qQl8fhZnXWbAKnslMkhYGY8eGoH4mNi+PdHUyn0pgJ1zvH2yEW0q1+VHpnVfa5SRMKM8lhEJERC1gDonMsHrga+AWYCw5xz083sPjM7yVvtMSAV+MDMJpnZ8BI2V+kkxMXw3ICumMGV704gN2/v7gc4dGw29dOTOLRVnRBVKCKRQnkssmfn9c4kNTGOl39dwPjF6znu6d/4eMISrjm8BR/+6wCa1qrid4kSBZTH4qfCQseNwyazalMuz5/XjWopGs0slZsyOXTqpyfzn+PbMmrBWoaOzQJg1IK1zF65iYsObKIOVSKyE+WxiEjoxIVy4865L4Evd3nurqDPjwzl/iNd4xopPH5WF/75zjgeGDGDB07pWKbXZa/bym9zV3PN4S2JVa9eEUF5LLIn6cnxnNc7g1d/W8CXU5dTPz2J9y/vS88mNfwuTaKM8lj88spvC/hh1iruPak9XRpX87sckbCgTA6dc3o25ospy3joy1kc1roOb49cRPWUeE7q3MDv0kQkDCmPRURCI5RTgEo5OKpdXf55cFMG/5nF55OXlek1H4zLBuDsnpr+U0REpKwuOagpNaokcHLnBnx53cFq/BORqDF6wVoe+2Y2x3eszwV9M/0uR0QqATPj4dM6UVDouHrIBL6bsZIBvTJIio/1uzQRERGRSkMNgBHglv5t6JZRjX9/NIUFqzeXum5+QSHvj8vm0Fa1aVgtuYIqFBERiXx1qyYx9vYjeeLsLlRNive7HJGQyi8oJGvt1r2eZl4iz+pN27lm6EQyaqTw8OkdNfWeiFSYxjVSuLV/ayZkbcDMGNhHHRBEREREKlJIpwCV8hEfG8Nz53bjuGd+48p3J/DpVQeW2Gvu59mrWblxO/eelFHBVYqIiEQ+XRiXymLphm0c+tjPAFRPiadu1STqpSdRr2pSsZ9XT4nX70cEKih0XP/+RHK25fH2Jb1IU+cGEalgF/Rtwsj5a6mfnkQDdVIWERERqVBqAIwQDaol8+RZXbj4rbHc+/l0HjqtU7HrvTc2i1qpiRzRtk4FVygiIiIikaJacgKPntGJlTm5rNiYy8qNgY/Tlm5k7ZbtOLfz+glxMdStmvh3o6DXMFjUQFg3LYk6VRM1tVuYefqHufwxby2Pnt6JtvWr+l2OiFRCMTHGKxf08LsMERERkUpJDYAR5LA2dfhXv+a8+PN8ejetySldG+60fEVOLj/OWsUVhzYnPlazu4qIiIhI8dJT4jmrR/H3i84rKGTVpu2syPEaBnP+biBckZPLtKU5fD9zJbl5hbu9VqMJw8evc1bz7I9zOaN7I87SvcFFREREREQqHTUARpgbj2rF+EXr+c8nU+nQMJ0WdVL/WjZsXDaFDs7WP/giIiIiso/iY2NoWC251PtJO+fYuC0/0CjojSAsr9GE9aoGRhMmxmk04b5anrON69+fRKs6adx/cge/yxEREREREREfqAEwwsTFxvDMgK4c/8xvXOXdDzA5IZbCQsf7Y7M5sEVNMmtW8btMEREREYliZkZ6SjzpKfG0rpdW4nr7M5qwRpUEr4EwkboaTVhmeQWFXD1kItvzCnhhYDeSE9SQKiIiIiIiUhmpATAC1UtP4smzu3Dhm2O467NpPHZmZ36bt4alG7Zx23Ft/C5PRERERATYx9GE3kjCFRtzWeV9nLqPowkbVU+mbloSMTGVp5Hw0a9nMX7xep4d0JXmtVP3/AIRERERERGJSmoAjFCHtKrN1Ye14Nkf59G7WU2+n7GSGlUSOKpdXb9LExEREREps1CPJkyMi6FxjRQya6QEPtYMPDJqVKFR9WSS4qNnhNy301fw6m8LuaBvJid2buB3OSIiIiIiIuIjNQBGsOuPbMXYReu449Op5Bc4Lj6wie6VIiIiIiJRaW9HEy7P2caS9dvIWreVxWu3sHjtVkYtWMvWHQV/rW8G9aomkVGjqFEwhYyaVcisEfi8WgRNMZq1dis3fjCZTo3Suf34tn6XIyIiIiIiIj5TA2AEi40xnjmnK8c98ztrNm/n7J4ZfpckIiIiIuKbPY0mdM6xdssOFq/dSta6LWSt3cbidVvIWruVn2evZtWm7Tutn5YUFxgxWKPK36MHa6SQUTOF+unJxIbJ1KK5eQVcOWQ8Bjx/bjd1ChQRERERERE1AEa6OlWTePuSnkxfupEWdXSPDxERERGRkpgZtVITqZWaSPfM6rst37ojn+x121i8dgtZ67Z6owe3MmP5Rr6dsYK8gr9vQhgfazSqnrLz6MEaKWTWrELjGsmkJFTcv1oPjJjBtKUbefWCHjSukVJh+xUREREREZHwpQbAKNC+QTrtG6T7XYaIiIiISERLSYijdb20YkcPFhQ6ludsI2ut1zC4bitZa7eyeN0WJmStZ1Nu/k7r105L/Gu04N+NhFXIrJlCzSoJ5Ta16GeTljL4zywuP6SZ7gcuIiIiIiIif1EDoIiIiIiIyB7ExgRG/DWqnsIBxSzfsDUwtejidVvJDrrv4J/z1/LJxKW4vwcPUiUh9q8pRYPvO5hZM4UG1ZKJj40pU03zVm3ito+n0rNJdW46pnX5HKiIiIiIiIhEBTUAioiIiIiI7KdqKQlUS0mgc+Nquy3LzStgyfpt3n0H/x49OH/1Fn6avZod+YV/rRsbYzSolkRmjSp/jx70RhJm1qxCamLgX7itO/K58t0JJMfH8uyAbmVuNBQREREREZHKQQ2AIiIiIiIiIZQUH0uLOqnF3rO7sNCxatP23e47uHjdVr6etoJ1W3bstH6NKglk1EihoNAxd9VmBl3Sm3rpSRV1KCIiIiIiIhIh1AAoIiIiIiLik5gYo156EvXSk+jdrOZuyzfm5v1138GixsGsdVtYviGXu05ox0Eta/lQtYiIiIiIiIQ7NQCKiIiIiIiEqapJ8XRomE6Hhul+lyIiIiIiIiIRRDeKEBEREREREREREREREYkiagAUERERERERERERERERiSJqABQRERERERERERERERGJImoAFBEREREREREREREREYkiIW0ANLP+ZjbbzOaZ2b+LWZ5oZu97y0ebWZNQ1iMiUlkpj0VEwoPyWEQkfCiTRUTCg/JYRCQ0QtYAaGaxwPPAsUA7YICZtdtltUuB9c65FsCTwCOhqkdEpLJSHouIhAflsYhI+FAmi4iEB+WxiEjohHIEYC9gnnNugXNuB/AecPIu65wMvO19/iFwhJlZCGsSEamMlMciIuFBeSwiEj6UySIi4UF5LCISIqFsAGwIZAd9vcR7rth1nHP5QA5Qc9cNmdllZjbOzMatXr06ROWKiEQt5bGISHgotzwGZbKIyH7SObKISHhQHouIhEhI7wFYXpxzrzjnejjnetSuXdvvckREKi3lsYhI+FAmi4iEB+WxiEh4UB6LiOwslA2AS4HGQV838p4rdh0ziwPSgbUhrElEpDJSHouIhAflsYhI+FAmi4iEB+WxiEiIhLIBcCzQ0syamlkCcA4wfJd1hgMXep+fAfzonHMhrElEpDJSHouIhAflsYhI+FAmi4iEB+WxiEiIxIVqw865fDO7GvgGiAXecM5NN7P7gHHOueHA68AgM5sHrCMQ8CIiUo6UxyIi4UF5LCISPpTJIiLhQXksIhI6IWsABHDOfQl8uctzdwV9ngucGcoaREREeSwiEi6UxyIi4UOZLCISHpTHIiKhEcopQEVERERERERERERERESkgqkBUERERERERERERERERCSKqAFQREREREREREREREREJIqoAVBEREREREREREREREQkiqgBUERERERERERERERERCSKqAFQREREREREREREREREJIqoAVBEREREREREREREREQkiqgBUERERERERERERERERCSKqAFQREREREREREREREREJIqoAVBEREREREREREREREQkiphzzu8a9oqZrQYW78NLawFryrmccKLji2zRfnwQ/ce4r8eX6ZyrXd7FVATlcYmi/fgg+o9RxxfZKl0egzK5FDq+yKbji2zK472jn4fIpuOLbDq+4imPo5OOL7JF+/FB9B9jhWZyxDUA7iszG+ec6+F3HaGi44ts0X58EP3HGO3HV56i/b2K9uOD6D9GHV9ki/bjK2/R/n7p+CKbji+yRfvxlbdof790fJFNxxfZov34ylu0v186vsgW7ccH0X+MFX18mgJUREREREREREREREREJIqoAVBEREREREREREREREQkilSmBsBX/C4gxHR8kS3ajw+i/xij/fjKU7S/V9F+fBD9x6jji2zRfnzlLdrfLx1fZNPxRbZoP77yFu3vl44vsun4Ilu0H195i/b3S8cX2aL9+CD6j7FCj6/S3ANQREREREREREREREREpDKoTCMARURERERERERERERERKKeGgBFREREREREREREREREokjUNwCa2RtmtsrMpvldSyiYWWMz+8nMZpjZdDO7zu+aypOZJZnZGDOb7B3fvX7XFApmFmtmE83sC79rKW9mtsjMpprZJDMb53c95c3MqpnZh2Y2y8xmmllfv2sKV8rjyKY8jnzKYwkWzZmsPI4O0ZzHoEyWv0VzHoMyORoojyOb8rjslMeRrTLkMUR3JiuPQ7TfaL8HoJkdAmwG3nHOdfC7nvJmZvWB+s65CWaWBowHTnHOzfC5tHJhZgZUcc5tNrN44HfgOufcnz6XVq7M7AagB1DVOXeC3/WUJzNbBPRwzq3xu5ZQMLO3gd+cc6+ZWQKQ4pzb4HNZYUl5HNmUx5FPeSzBojmTlcfRIZrzGJTJ8rdozmNQJkcD5XFkUx6XnfI4slWGPIbozmTlcWhE/QhA59yvwDq/6wgV59xy59wE7/NNwEygob9VlR8XsNn7Mt57RFWrtZk1Ao4HXvO7Ftk7ZpYOHAK8DuCc26ET6ZIpjyOb8ljCmfJ470VzJiuPI5/yOLIpk/dONOcxKJMjnfI4simP947yOLJFex6DMjmS+ZnHUd8AWJmYWROgKzDa51LKlTe0eRKwCvjOORdVxwc8BdwCFPpcR6g44FszG29ml/ldTDlrCqwG3vSG379mZlX8Lkr8pzyOWE+hPI5UymMplvI4Yj1FdOcxKJOlElImR6SnUB5HMuWxFEt5HLGeIrozWXkcAmoAjBJmlgp8BFzvnNvodz3lyTlX4JzrAjQCeplZ1AzDN7MTgFXOufF+1xJCBznnugHHAld5UypEizigG/Cic64rsAX4t78lid+Ux5FJeRzxlMeyG+VxZKokeQzKZKlklMmRR3kcFZTHshvlcWSqJJmsPA4BNQBGAW9e44+Ad51zH/tdT6h4w2J/Avr7XEp5OhA4yZvj+D3gcDMb7G9J5cs5t9T7uAr4BOjlb0XlagmwJKhH0YcEwlwqKeVxRFMeRzblsexEeRzRoj6PQZkslYsyOWIpjyOf8lh2ojyOaFGfycrj0FADYITzbnD6OjDTOfeE3/WUNzOrbWbVvM+TgaOAWb4WVY6cc7c55xo555oA5wA/OucG+lxWuTGzKt6NhfGGNR8NTPO3qvLjnFsBZJtZa++pI4CouHmy7D3lcWRTHkc25bEEUx5HtmjPY1AmS+WiTI5cyuPIpzyWYMrjyBbtmaw8Dp24itiJn8xsKNAPqGVmS4C7nXOv+1tVuToQOB+Y6s1xDPAf59yX/pVUruoDb5tZLIEG62HOuS98rknKri7wSeAcgzhgiHPua39LKnfXAO+aWQKwALjY53rClvI44imPI5vyWHYS5ZmsPJZwp0yWv0R5HoMyWcKb8lj+ojyOeMrjyKY8DhFzzlXEfkRERERERERERERERESkAmgKUBEREREREREREREREZEoogZAERERERERERERERERkSiiBkARERERERERERERERGRKKIGQBEREREREREREREREZEoogZAERERERERERERERERkSiiBkDZIzN70syuD/r6GzN7Lejrx83shn3Y7ltmdkY51djAzD4sj22VsP0uZjbKzKab2RQzOztoWVMzG21m88zsfTNL8J6/wcxmeOv/YGaZQa+50Mzmeo8LS9hnTTP7ycw2m9lzuyx70MyyzWzzHuoudj0zu8jMVpvZJO/xj315X0SkYimPlcciEh6Ux8pjEQkfymRlsoiEB+Wx8ljCjxoApSz+AA4AMLMYoBbQPmj5AcBIH+r6i3NumXOuXP4QlGArcIFzrj3QH3jKzKp5yx4BnnTOtQDWA5d6z08EejjnOgEfAo8CmFkN4G6gN9ALuNvMqhezz1zgTuCmYpZ97r12T0pb733nXBfv8VoJ64hIeFEeK49FJDwoj5XHIhI+lMnKZBEJD8pj5bGEGTUASlmMBPp6n7cHpgGbzKy6mSUCbYEJZtbdzH4xs/FeD4/6AGbW3My+9p7/zcza7LoDM7vf680Ra2YPB/V6+F8x6x4a1OtgopmlmVkTM5vmLb/IzD729jnXzB4Nem1/M5tgZpPN7AfvuSpm9oaZjfG2d/Ku+3TOzXHOzfU+XwasAmqbmQGHEwhngLeBU7z1fnLObfWe/xNo5H1+DPCdc26dc2498B2BPwi77nOLc+53AiG+67I/nXPLd31+X9cTkYihPFYei0h4UB4rj0UkfCiTlckiEh6Ux8pjCTNxfhcg4c85t8zM8s0sg0BPjVFAQwKBngNMBRzwLHCyc261BYY3PwhcArwCXOGcm2tmvYEXCAQeAGb2GJAGXAzUAE4F2jjnnP3dQyLYTcBVzrk/zCyVYsIN6AJ0BbYDs83sWW+9V4FDnHMLLdCLAuB24Efn3CXe/saY2ffOuS3FvR9m1gtIAOYDNYENzrl8b/ES773Z1aXAV97nDYHsoGUlvSbUTjezQ4A5wP8557L39AIR8ZfyeGfKYxHxi/J4Z8pjEfGTMnlnymQR8YvyeGfKYwkHagCUshpJILgPAJ4gEDYHEAjvP4DWQAfgu0CHBmKB5V64HgB84D0PkBi03TuB0c65ywDMLIdAyL5uZl8AXxRTyx/AE2b2LvCxc25J0LaL/OCcy/G2OQPIBKoDvzrnFgI459Z56x4NnGRmRcOkk4AMYOauG/V6pAwCLnTOFRaz392Y2UCgB3DoHleuOJ8DQ51z283scgK9Tg7fw2tEJDwoj1Eei0hYUB6jPBaRsKFMRpksImFBeYzyWMKHpgCVsiqaw7kjgeHbfxLovVE0d7MB093f8wF3dM4dTeBnbEPQ812cc22DtjsW6F7Uk8LrBdGLwHDoE4Cvdy3EOfcw8A8gGfjDihkOTqDXRpECSm/sNuD0oPoynHPFBXdVYARwu3PuT+/ptUA1MyvafiNgadBrjiTQO+Qk51xRTUuBxkGbbgQsNbNT7e9h6T1Kqbf4gwgMfS96/X2lreucWxtUz2tA973dn4j4RnmsPBaR8KA8Vh6LSPhQJiuTRSQ8KI+VxxJG1AAoZTWSQJiuc84VeD0fqhEI8JHAbALzGfcFMLN4M2vvnNsILDSzM73nzcw6B233a+BhYIQF5mFOBdKdc18C/wcEr4u3jebOuanOuUcIhH9x4V2cP4FDzKypt52i4dvfANeY1xXDzLoWs88E4BPgHedc0VzNOOcc8BNQdPPYC4HPgrbzMoHgXhW0uW+Aoy0w/3V1Ar1HvnHOfRL0B2RcGY/pL973pej1d5W2rtcLpchJFNNTRUTClvJYeSwi4UF5rDwWkfChTFYmi0h4UB4rjyWMqAFQymoqUItAAAY/l+OcW+Oc20EgwB4xs8nAJAI9OwDOAy71np8O7HSDVOfcBwTmVR5OYB7nL8xsCvA7cEMxtVxvZtO8dfL4e17kUjnnVgOXAR97tbzvLbofiAemmNl07+tdnQUcAlwU1EOii7fsVuAGM5tHYD7n173nHwNSCQxdn2Rmw7061nn7GOs97nN/DyXfiZktIjBc/iIzW2Jm7bznHzWzJUCK9/w9Jby+pPWuNbPp3vtwLXBRiW+ciIQb5bHyWETCg/JYeSwi4UOZrEwWkfCgPFYeSxixQOOziIiIiIiIiIiIiIiIiEQDjQAUERERERERERERERERiSJqABQRERERERERERERERGJImoAFBEREREREREREREREYkiagAUERERERERERERERERiSJqABQRERERERERERERERGJImoAFBEREREREREREREREYkiagAUERERERERERERERERiSJqABQRERERERERERERERGJImoAFBEREREREREREREREYkiagAUERERERERERERERERiSJqABQRERERERERERERERGJImoAFBEREREREREREREREYkiagCUCmNmB5vZ7KCvW5vZJDPbZGbXlnEb/zKzlWa22cxqhq7a6GBmzsxa7GGdZDP73MxyzOyD/djXPWY2uAzrnWpm2d73sKuZLTKzI/d1vyISHqIt483sLTN7oIL3udN7uJ/b2mxmzUpYdpGZ/V4e+xGR8BMJebw3GVuW89nyZmYvmdmd5bCd88zs21KW/2xm/9jf/YiIvyIhd0VERKRyUgNgBfMaO7Z5J3VFjwblsM0Ka0DxGnryvJPZTWY2x8yeM7P6pb3OOfebc6510FO3AD8559Kcc8/s6TjMLB54AjjaOZfqnFtbPkdU7L7K1JgVJc4A6gI1nXNnVsD+/gdc7X0PJ1bA/kQqjDI+MjI+XOx6UbuY93Cfee/hgvLYlkgkUh4rj8uquE4RzrkrnHP37++2nXPvOueO3t/tiEQC5a5yt7yV9ftvZk288+q4iqhLRCJLOHbS2JcaRPaVGgD9caJ3Ulf0WOZnMft4kvS+cy4NqAGcCtQDxpd0YlzCPjKB6Xuxz7pA0l6+pmj/ZmYV9vMeYSeemcAc51x+Be5vr7+HIhFEGR8QtRkvIhFDeRygPBaRiqLcDVDuikhYUSeNsOuksVMN5bC9qGFm/cxsid91RBOdJIQJM0s3s9fNbLmZLTWzB8ws1lvW3Mx+NLO1ZrbGzN41s2reskFABvC5F963FPeLEhxmXmB+aGaDzWwjcFFp+y+Ncy7POTcdOBtYDdzo7aOfmS0xs1vNbAXwZnBdZvYjcBjwnFf30F2PY5f6WwFFvTU2eK/HzA4ws7EWmL5yrJkdEPSan83sQTP7A9gK7DYVmlffUu8Px2wzO8LM+gP/Ac72apnsrdvAzIab2Tozm2dm/wzaTrm8p6V9r73li8zsJjOb4h3z+2aWFLT8Zm9/y8zsktL25a1/L3BX0LFeamYbiv6BMLNXzWxV0PqDzOx67/OmZvaL9959B9Taw74SzWwzEAtMNrP5xazTy8xGeTUs9/6QJwQtP9r7PuWY2Qve/jVtkoQ9ZbxvGb/IzG4zsxlmtt7M3izKTCtmxIeVMs2cmf3Ty/513t+CBkHL2pvZd96ylWb2H+/5EjPNzH71Xj7Ze0/O3vV7a2ZtvePcYGbTzeykoGVvmdnzZjbCy+HRZta8uGMxs5pezRvNbAzw13oilY3y2Lc87mpmE7y8ep/Ahe7g5SVm7C7rpZvZO2a22swWm9kdFnTh29vOTG8/M8ysm/f8v81sftDzp3rPtwVeAvp678cG7/m3LGiK0j38DXBmdoWZzfXy+nkzM2/ZTn9rzOwoM5vlvY/PAVbccYpEE+VuWJ4HVzezL7wsXe993shbdqaZjd9lWzeY2Wfe529Z4H/xr7zj+cPM6pnZU962ZplZ16DXNjCzj7x9LbSgkS7e92uYl+ubLHC+26Ok738p366i8+oN3rqHenndMWhfdcxsq5nVDvoe/sf7uVtkZucFrZtoZv8zsywLnNu/ZGbJpexfJFKok0ZAOHTS2OfBEfv4vkll5pzTowIfwCLgyGKe/wR4GagC1AHGAJd7y1oARwGJQG0CJzdPlbRNoB+wpKT9AvcAecApBBqBk0vbfzG13gMMLub5+4DRQTXkA494dSfvWhfwM/CPPb03QcubAA6I876uAawHzgfigAHe1zWDtp8FtPeWx++yvdZANtAgaPvNSzpG731/gUDodyHwT8Dh5fGeBu2jLN/rMUAD7/hnAld4y/oDK4EO3j6HeO9Xiz3sc6dj9d6z7t7ns4EFQNugZV29z0cR6AGTCBwCbCru56KY/e1UEzv/bHYH+njfrybe8V3vLasFbARO85Zf573n/9jTPvXQo6IeJeVYaXlQxt97ZfxeZnzQPqcBjb3t/QE84C27CPh9l/X/yifgraB1DwfWAN28430W+NVblgYsJ3BRKMn7ure3rMRM23V/u35vgXhgHoEOKQleDZuA1kH1rQV6edt/F3ivhGN5Dxjmff87AEt3PXY99Ii2R0mZg/K4xPcmaHkTyvecOwFYDPyfl21neO/LHjPWWx6cZ+8AnxHI2ibAHOBSb9mZXr71JNCw1gLIDFrWwPs+nA1sAep7yy5i978Hb+1lfV8A1QhcrF4N9N912wTOZTd5xx/vvR/56FxWjyh5lJQtKHdLfG+CljehYs+DawKnAykE8vQD4FNvWSKwDu8agPfcROB07/O3CGRidwLnvj8CC4ELCHT2fYDAqBa878F4Ap2OEwg0VC4Ajgl6v3OB47zXPgT8Wdb3raT3z3vuBeCRoK+vAz7f5XtYdD3jUAJ/F4rOs58EhnvvWxrwOfCQ379jeuixP4+Sfp+AdOB1Av/TLvV+h2O9Zc293/G13u/9u0A1b9kgoBDYBmwmMKKtH3vO6A+BwQSu7/2jtP0XU+s97H6tNhaYDPzP+7ofsAS4FVjh1flXXd7xFHjZsxkYuutx7LL9Vl4+OG/5j97zBwBjgRzv4wFBr/kZeJBA7m5jl+uyxdTQCjieQNZuJHCt+p6g9Zt4+7+UQPYXXYu4hMA1hvXAN3jnvXv4OXja2/5GAvl88C7v7wfe92cTMNWr7TZglfe6o4PWb0AgK9cRuHbxz6Blb+H9zQn+vuzyc3ETMMV7D4s6CFbx3rNC773ZjHfdXo99f2gEoD8+tUDv0A1m9qmZ1SVwwnO9c26Lc24VgROOcwCcc/Occ98557Y751YTOEk5dD9rGOWc+9Q5VwhULW3/e2EZgROkIoXA3V7d2/az3uIcD8x1zg1yzuU754YCs4ATg9Z5yzk33Vuet8vrCwic7LUzs3jn3CLn3G6j0gDMrDFwIHCrcy7XOTcJeI3ASW6R/X5Py/i9fsY5t8w5t47AiWgX7/mzgDedc9Occ1sIBPe++AU41MzqeV9/6H3d1DuuyWaWQeDiyp1erb96tewX59x459yf3vdrEYF/1IqO/zhgunPuYxeYrvQZAn/MRcKNMr587G/GF3nOOZftZeaDBC6g7K3zgDeccxOcc9sJnAD3NbMmwAnACufc497fh03OudGwx0zbkz5AKvCwc26Hc+5HAheYg+v/xDk3xsvEd/n778FfvB7upwN3ed//acDbe/0OiEQm5XH52N887kOgwespFxhR8yGBCyVFSsvYv3h5dg5wm5e1i4DHCVwgh8BFpEedc2NdwDzn3GIA59wH3vlzoXPufWAugQ4UZVGW+h52zm1wzmUBP1FMHvP3ueyH3nv0FDqXleij3C0fIT0Pds6tdc595Jzb6pzb5C071Fu2ncCF2IEQmOmCwMXnL4K2+4l3nptLoIE11zn3jnOuwHtt0QjAnkBt59x93vnsAuBVdn7/f3fOfem9dhDQee/frmK9DQwws6KR1ud72w9WdD3jF2AEcJa3/mXA/znn1nnvz3/Z+58ZkUjxFoEG8RYEfnePJnBOBYEOVQ8RaOhpS6BDwT0AzrnzCTRGFY0qfLSM+zuZwHXGagT+hy1t/3vkZcdnwMFBT9cjkNmZBH6fg9c/HPgNuNqre0Bpx+Gcm0OgswUEGj8PN7MaBDLjGQIdKp4ARtjO9wY839t3GoGOcKXVMIdAI+MF3vtyPPAvMztll8M9lMD34RgzO5lAZ+HTCHSg+Y1AY+aejCVwnlqDwMCRDyxoZjkCf2cGAdUJNEh+Q6AzR0MCnWFeDlr3PQKNrQ0IdHD7r5kdXoYaipxFYDBLU6ATcJELXM8+FljmwmSkajTQkFF/nOKc+77oCzPrReCf4uV/n5sQQ6BlHe+k+WkCYZbmLVu/nzVkB32eWdr+90JDAq3+RVZ7J4Sh0oBdQtT7umHQ1yUeg3NungWms7wHaG9m3wA3lBAsDYCik7/gffUoYV/79J6W8XsdfKFgq1dbUY3BU3Xs+t6U1S/ASQRC/FcCPVfOJ9Az5TfnXKEFpj1a7wVz8P4a7+M+gb+mP3mCwPuaQiCjio6pAUHvn3POmeaElvCkjC8f+5XxJayzmL8zc29rmVD0hXNus5mt9WppDJTUeaS0TCvLPrO9i1dFdj3+Xf8epBazndrefnd9H0QqA+Vx+djfPG4ALHUu0N036PXBy0vK2EVB69Ui8P4Fvza4jtLy+ALgBgIXsSGQl6VOX7+X9ZUlj4s7l93b771IuFPulo+QngebWQqBhtD+BC7yAqSZWax3Mf1tYKiZ3UHgWsAwr2GwyMqgz7cV83VRBmYCDcybXtkTS+BCdZFd8zPJzOJcoIPbPnPOjTazrUA/M1tOoHFheNAqxV3PaEDg3DmFwJSCRcvMq1sk0n1qZkW/Wz8DlxPoJFHN68ywxcyeJNBw9bJzbh6BkV0Aq83sCeDu/axhlHPuUwAzK+qkUez+92KbJXbS8PaznyXv5q9OGt7XQ73pjU8k0KAJXieNsm7QOfdz0JdTLDB99KHAp0HP31OUW2Z2BYGRyTO9r/8L/MfMMos6wJWwn8FBXz7u5XxrAqMoIXDd9xtvmx8QaGB82DlXYGbvAa9YYKruNAIDZY73/h5OMrOigTI/lvGwnym6Bm9mwQNcpJxpBGB4yAa2A7Wcc9W8R1XnXFEPg/8SGOrb0TlXlUBPrOD0cjtvji0ETliAv3rL1t5lneDX7Gn/e+TNZ3wiO5/I7VrXnuzt+ssInFAGyyAwZLxM23TODXHOHeRtxxGYxqO41y0DaphZWhn3ta/v6Z6+16VZzs4NcBllfN2ufiHwD1g/7/PfCYT6od7XRfuqbmZVymF/wV4k0LOxpXf8/+Hv418ONCpa0euZ12i3LYiEH2X8vq2/3xnv2TUXizp57Po+1qNkO9XiZV9Nr5Zsirnviqe0TNuTZUDjXe4XsOvxl8VqAj0qy+Pvg0ikUx7v2/r7m8fLgYa289WX4BwqLWODrSEwtV9wLcF1ZFPMPU7NLJPAiJOrCUyfV43AtHhF9ezp/ShrfXuy07m6937sV+c5kQig3N239UN9HnwjgQu+vb33/RDveQNwzv0J7CBwXeBcdh85V1bZwMKg976acy7NOXdcGV9f1vetpPXeJvAzdT7w4S6NtsVdz1hG4G/NNqB9UM3pzrniOnaIRJpTgn6uT2HnThIbvMb6lwlMl4yZ1TWz9yxw/9SNBKaGLGsHqpKU1Eljt/3vhUjtpPEXM+ttZj9Z4H6pOcAV7P5e7/rePR30vq0jkOENKYWZ3WSB+2XneK9L32U/u3boWON1DCn6GgKdPEoaKFPq/ndRlg50Ug7UABgGnHPLgW8JtLxXNbMYC9wMu2jqizQCc97mmFlD4OZdNrGSnS8+ziHQa+p4M4sH7iAw1eW+7r9EZhZnZm0JDDOuR2Ckw77a9Tj25EuglZmd69VxNtCOnaemKJGZtTazw80skcDotqI5hotqaVJ04dU5lw2MBB4ysyQz60Rg7uXBxWx6f97TPX2vSzOMwE3O23k9+vapV45zbi6B92Ig8ItzbiOB9+N0vAZArzfJOOBeM0sws4PYeTqSfZVGYB7qzWbWBvhX0LIRQEczO8UCN7y9isDPnEhYU8aXeBx7sl8ZH+QqM2tkgWk6bicwLREEeri1N7MuFpjy4p5StjEUuNhbN5HAxarRLjD93BdAfTO73swSzSzNzHp7ryst06D092Q0gZPgW8ws3sz6EcjZ98p64PDXlCgfA/eYWYqZtQMu3JttiEQL5XGJx7En+5vHowh0RLjWy7PT2Hn6zdIy9i9eng0DHvSyNpPAqL6i8/HXgJvMrLsFtPDWqULg4vBqADO7mMD9UIusBBqZWUIJ9ZepvjIYQeDvzmneuey16FxWopxyt8Tj2JNQnwenEfiff4O3rLhrB+8AzwF5zrnf93K/RcYAm8zsVjNLNrNYM+tgZj3L+Pqyvm+rCVzL2XXdwcCpBK5tvFPM64quZxxMYFr/D7zZN14FnjSzokaQhmZ2TBlrFokk6qSxb+uXVyeNYEMIjFJu7JxLB15i987Du753l+/SwSLZOTeypB14WXcLgak3q3ud4nKK2U9Z7GmgzE4/C+zdOe/evneyB2oADB8XELgp8gwCU158CNT3lt1L4KbzOQT+cfx4l9c+BNxhgVb/m5xzOcCVBP4JXkrgl25PUyWWtv/inG1mm72ahhO4IWx3t3/z8u50HHta2Tm3lsBJ2o3e/m8BTnDOrSnj/hKBhwn08FpBoIfJbd6yD7yPa82saMqfAQSmDVpGYJ77u13Q9CbF2Nv3FPb8vS6Rc+4rAvcS+ZHAEP2yDrkuzi/AWq/hs+hrI2j6IwI9AXsT6GVyN8WfUO+tm7ztbiJw0l30Dwre9/VM4FEC3+92BBoht+++GZGwo4yv+IwvMoTAhZ8FBKaGe8Db/hwCc9h/T+BeUCVe2PCy/k7gIwIjOJrz971rNgFHEfinY4W3rcO8l5aYaZ57gLe99+SsXfa5w9vmsQT+Tr0AXOCcm7WXxw+BUS+pXn1vAW/uwzZEooXyuILz2Muz04CLCJw3nk3Qe1taxhbjGgLv8wICuT0EeMPbzgcE7mM1hEDufgrUcM7NIHCvwFEELiZ3BP4I2uaPwHRghZntdkx7WV+Jgs5lHybwPrbcpQ6RaKXcDbPzYALXDZIJnGP+CXxdzGsHEegsUWyn57LwOm6cQGBat4Xe/l4jMOKkLMr0vjnnthLI/z+8dft4z2cTuIbh2LlxAALnxesJXN95F7gi6Dz7VgLXVP60wKin7wmMmBSJKuqkUeJx7El5ddIIlkZgRF2uBabPPncP678E3GaB+7RiZulmdmYZ9pFPoNNEnJndReBeuXutDANlJgHHmVkNC8y2dP1ebH4lUNPMyvq3QvbAnFOjqohEHq+XzxLgPOfcT37XIyLhx8wWAf/YQ2cNEREREZGosr/nwWaWDKwCunmzBEUkM3sDWOacuyPouX7AYOecbikilUZJmeA1sjxMoPNpGoEOA484597zGpfeIdAAPo9Ax4D/K/rdMbOTgWcJNCI94Jz7n5ldRKDxPpZAB/6ri/ZrZvcALZxzA8uy/2KO4R4Co5m3ExiksAz4DnjQObfUW6cfu/x+7/qcmf3sff1aScexy36bEOjEEO+8+5NaYCa0pwncX3QecF3RaOldt1+cYmo4g0CHtRoEBmEsInBvxIHF7d97zfkEOohkEui08p1z7pJS9hlLoGPyGQQ60DxJoFNNsd8fMzsSeM0518T7Oo7AdPyNnXNLzKwRgYbIAwh0qHjMOfeSt24SgWmYj/WO5U3gxqDvwSKCfh6L2fcbwMkEfo7a7WcnnEpPDYAiEjG8aTdGE5iu5GYC04A2c4GbBYuI7EQNgCIiIiJSGZVDA+ANBEYdHl6uhVUg76L5JKCrc25h0PP9UAOgiIhUEpoCVKSCmdlLZra5mMdLIdzn9BL2eV4I9nVeCfuaXg6b70tg6pI1BHoHnaLGPxEREREREZHy4TUeXkdgCtKwsLfXGczsfmAagREpC4tbR0REpDLQCEAREREREREREREREZEIZWYHA18Vt8w5l1rB5UiYUAOgiIiIiIiIiIiIiIiISBSJ87uAvVWrVi3XpEkTv8sQESkX48ePX+Ocq+13HftCeSwi0SSS8xiUySISPZTHIiLhQXksIhI+9jWTI64BsEmTJowbN87vMkREyoWZLfa7hn2lPBaRaBLJeQzKZBGJHspjEZHwoDwWEQkf+5rJMeVdiIiIiIiIiIiIiIiIiIj4Rw2AIiIiIiIiIiIiIiIiIlFEDYAiIiIiIiIiIiIiIiIiUUQNgCIiIiIiIiIiIiIiIiJRRA2AIiIiIiIiIiIiIiIiIlFEDYAiIiIiIiIiIiIiIiIiUUQNgCIiIiIiIiIiIiIiIiJRRA2AIiIiIiIiIiIiIiIiIlFEDYAiIiIiIiIiIiIiIiIiUUQNgCIiIiIiIiIiIiIiIiJRJGQNgGb2hpmtMrNpJSw3M3vGzOaZ2RQz6xaqWkREKjtlsohIeFAei4iEB+WxiEh4UB6LiIROKEcAvgX0L2X5sUBL73EZ8GIIaxERqezeQpksIhIO3kJ5LCISDt5CeSwiEg7eQnksIhIScaHasHPuVzNrUsoqJwPvOOcc8KeZVTOz+s655eVdy8zlG1m9aXt5b1YqUP30JFrWTfO7DNkHzjlmLN9I67ppxMVq1mG/hFMmi4hUZspjEZHwoDwWEQkPymMpLwWFjoVrNgNGfKwRHxtDXKyREBvz1+fxMTHExJjfpYpUmJA1AJZBQyA76Osl3nO7hbeZXUaghwcZGRl7vaMXf57P8MnL9q1KCRuvX9iDI9rW9bsM2Uuv/LqAh76aRYs6qdzavw1Htq2Dmf7QhqEyZfL+5rGIiOxRhZ0ji4hIqZTHIiLhQXksZfLmHwt5YMTMPa4XG+M1EMbEEB8XQ3ysERcTQ0JcDHExgYbD4AbE+NgYEoI+L1oe5z1f9Hl8bAzxMUa8t53A9gLLgz+PD26Q3G3bOzdcxhU9V0zDpXOOgkJHgXMUFkKB93XhX8+5oOeKlhdSUBhoLC3c6fW7b6uw0JHvPV+07l+v+etzdn79TvvctQ52e31+4c77TkuM47ojW1GjSkKofkwqHT8bAMvMOfcK8ApAjx493N6+/vojW3LhAZnlXpdUDOfg7uHTuf79SXx+9UE0qVXF75KkjP6Yt4ZHvp7FAc1rsiInl3++M45eTWpw23Ft6JpR3e/yZB/sbx6LiEj5USaLiIQH5bGISHhQHldehYWOd0YtplOjdP55cDPyCgq9hyOvoJD8AscO77l877m8vz4GrVdYyI78vz/Py3dszs8PrJPvyCvceRs78gvJL/x7e6EUG2PExthfDX+FEfQTHhtjxJoREwNxMTHE2N/HE2N/f1yxMZft+YU8fHonv0uOGn42AC4FGgd93ch7rtw1q50ais1KBXppYHdOeu53Lh80no+vPIAqiRHRdl2pLVm/lauHTKB57VReuaAHiXExvD82m6e+n8upL4zkuI71uPmYNjRVg264qLBMFhGRUimPRUTCg/JYRCQ8KI9lj/6Yv4asdVu58egunNi5gS81OG9EW/GNjbs3OOYXFHrr/f15cevnFzp25AeeKyh0mBlxMUaM16gWG0PQ50ENajGB9QINb9563rK/njMjNnb31wavG2NGXOwurwnaf0wMfz23a6Ne0WvK6v4vZvDGHwu5oG8T2jWoGsLvVuXhZyvKcOBqM3sP6A3kaO5mKUnjGik8M6ArF74xhls/msKzA7pqGskwlptXwBWDx5Nf4Hj5/O6keg22A/tkcmrXhrz62wJe+XUB305fybm9M7j2iJbUSk30uepKT5ksIhIelMciIuFBeSwiEh6Ux7JH7/6ZRfWUePp3qOdbDWZF9x6EZGJ9qyOSXXt4Sz6asIT/fjmTQZf20vX/chCyBkAzGwr0A2qZ2RLgbiAewDn3EvAlcBwwD9gKXByqWiQ6HNyyNjcf04ZHvp5F50bV+OchzfwuSYrhnOOOT6cxbelGXr2gx24jcKskxnH9ka04t3cGz/wwl3dHZ/HR+CVcdkhz/nFwU43uDBFlsohIeFAei4iEB+WxiEh4UB7L/lq1MZfvZq7k0oOakhinhrdIlp4Sz3VHtOTez2fw8+zVHNamjt8lRbyQXWl3zg3Yw3IHXBWq/Ut0uuLQZkxZsoGHvppJ+wZVOaBFLb9Lkl0MHp3Fh+OXcO0RLTmqXd0S16uTlsQDp3Tk4gOb8tjXs3ny+zkMHr2Y649sydk9GhMXG1OBVUc/ZbKISHhQHouIhAflsYhIeAinPH711wXMW7WZR87Q/cciybBx2RQUOgb0yvC7FCkHA/tkMmjUYh4YMYODWtYiXteI94vePYkoZsZjZ3amee1Urh46kaUbtvldkgQZv3gd930+ncNa1+b6I1qW6TXNa6fy0vnd+ehffcmskcLtn0zjmKd+5ZvpKwic44mIiIiIiIhIRSosdGzKzWPphm1s2Z7vdzkiFWJjbh7DxmeTvW6r36VIGRUUOoaOyeaA5jVpWquK3+VIOYiPjeG249oyf/UW3huT5Xc5EU9z7UnESU2M46Xzu3PKc3/wr8HjGXZ5X5LiNbzbb6s25vKvwRNoUC2Zp87uulc3eAXonlmDD67oy3czVvLw17O4fNB4emRW57bj2tI9s3qIqhYRERERERGJPs45tuwoYOO2PDbm5rFxW37Q53lszA18nRO8PPfvzzfl5lHo9cmtnZbIV9cdTK3URH8PSiTEzu2dwQs/z2fw6MXcdmxbv8uRMvh1zmqWbtjGf47T9yuaHNm2Dn2a1eDJ7+dyUpeGpCfH+11SxFIDoESk5rVTefyszlw2aDx3fTaNR07vpJuC+mhHfiFXvjuBTbn5vHNpL9JT9i2UzYyj29fj8DZ1GDZuCU9+P4fTXxxJ//b1uLl/a5rvcj9BERERERERkWjknGNbXsHfDXO7NNTlbC2+4S64ga+gsPRZdaokxFI1OZ6qSfFUTY6jXtUkWtVNIz05nqpJcVRNjicuxnjwy5nc/8UMnj6nawUdvYg/6qcnc3S7ugwbm83/HdlKAw4iwLujs6iVmlDqbYgk8pgZdxzfjhOf+50XfprHbWrg3WdqAJSIdXT7elxzeAue/XEenRtX47zemX6XVGk9OGIG4xav55kBXWlTr+p+by8uNoZze2dwStcGvPbbQl7+ZT7fzVzJOT0bc92RLamTllQOVYuIiIiIiIiEhnOO7fmFfzXc5QQ3zgWNwCuu4S7HWyd/Dw14yfGxVE2O8xrw4qmVmkDz2lV2atQrWhb8dXpyPKlJcWW+r9KGbXk89f1cTunSkMPa1CmPt0ckbJ3fN5Ovpq3g88nLOLNHY7/LkVIsz9nGj7NWcvmhzUmI053Ook2Hhumc3q0Rb/6xiIF9MmlcI8XvkiKSGgAlol1/ZCumLs3hnuHTaVOvqqaK9MFH45fw9qjF/OOgppzUuUG5bjslIY5rj2jJub0zePaHubw7OotPJi7lnwc345+HNCM1UREmIiIiIiIi/vlq6nJGTF3+d4NeUKPejoLCUl+bGBfjNc4FRttVS0kgs2aVEhvuqibH/zU6Ly0pvsIueP+rX3NGTFnO7Z9M5dsbDtX/4hLV+jarScs6qbwzajFndG+kGcfC2HtjsnHAgJ4ZfpciIXLT0a0ZMWU5D389i+fP7eZ3ORFJf7ElosXGGE+f3ZUTn/udK98dz+fXHKTRYRVo2tIc/vPJVPo0q8G/j20Tsv3USk3k3pM7cNGBTfnfN7N5+oe5vDt6Mdcd2YpzejYuc69FERERERERkfLyzqhF3PXZdOpVTaJuehJVk+JoVD25hBF4cUENePGkJcVFzPSCiXGxPHx6J854aST/+2Y295zU3u+SRELGzLigbyZ3fjadSdkb6JqhwQbhKL+gkPfHZnNwy9pk1NTIsGhVLz2Jyw9txlPfz+WSA9fRPbOG3yVFHDUASsRLT4nn5fO7c+oLf3D1uxN595+91SBUAdZv2cHlg8ZTo0oCz53bjbgKeM+b1qrC8+d14x9Z63noq1nc+ek03vx9Ibf0b80x7eupV5aIiIiIiIhUiFd+nc9/v5zFkW3r8vx5XUmMi4zGvH3VPbM6F/ZtwtujFnFSlwZ0U6OIRLFTuzXika9nM2jUYjUAhqmfZq9mxcZcdUioBC47pBlDx2Rx3xcz+eRfBxATo+u/e0OtJBIV2tavyiOnd2LMonU8OGKm3+VEvYJCx7XvTWT1pu28NLA7tVITK3T/XTOq8/5lfXjtgh7ExhhXDJ7A6S+OZOyidRVah4iIiIiIiFQuzjme/n4u//1yFsd3qs+LA7tFfeNfkZuOaU39qkn8+6Mp7MgvfXpTkUiWmhjH6d0a8sWU5azZvN3vcqQYQ0Yvpk5aIke01X1Jo11KQhw3Hd2aydkb+HzKMr/LiThqAJSocXKXhlx6UFPeGrmITyYu8bucqPa/b2fz29w13H9Kezo3ruZLDWbGke3q8tV1B/PI6R1ZumEbZ740in++M455qzb5UpOIiIiIiIhEL+ccj3w9mye/n8Pp3RrxzDldK9UMRKmJcTxwagfmrNzMS7/M97sckZA6v28TdnjTTEp4yV63lZ/nrNZtgSqR07s1on2Dqjz69Wxy8wr8Liei6DdEosq/j21D76Y1uO3jqUxfluN3OVHpq6nLefHn+ZzbO4Ozw+Amu3GxMZzdM4OfbzqMm49pzaj5azn6yV+57eOprNqY63d5IiIiIiIiEgUKCx33fj6Dl36Zz3m9M3jsjE7EVsJpyA5vU5eTOjfguR/nqfOtRLUWdVI5sEVN3v1zMfkFGvEaTt4fm40BZ/fy/7qkVIyYGOP249uydMM23vhjod/lRBQ1AEpUiY+N4fnzulEtOYHLB41nw9YdfpcUVeau3MRNH0yma0Y17j6xnd/l7CQ5IZarDmvBLzf344K+TfhwfDaHPvYzT3w7m83b8/0uT0RERERERCJUQaHjP59M5a2Ri7j0oKY8cEqHSn0PortObEdKYiz//mgqhYXO73JEQuaCvk1YlpPL9zNX+V2KePIKCnl/XDb9WtehYbVkv8uRCnRA81oc1a4uL/w0n9WbNDVvWakBUKJOrdREXjq/O6s2bueaoRMp0MloudiYm8flg8aTnBDLi+d1D9t7HNRMTeSek9rz/Q2HckTbOjzz4zwOffQn3h65SPcoEBERERERkb2SX1DIjcMm8d7YbK45vAV3HN8Ws8rb+AeB6y53Ht+OcYvX8+6YLL/LEQmZI9rUoUF6EoP+XOR3KeL5fsZKVm/aznm9NfqvMrrt2Dbk5hXw5Pdz/C4lYqgBUKJSl8bVuO/k9vw2dw1PfDfb73IiXmGh48Zhk8lat5Xnz+1GvfQkv0vao8yaVXju3G58dtWBtKybyt3Dp3P0k78wYspynFOjsIiIiIiIiJRuR34h1wydyKeTlnHzMa258ejWlb7xr8hp3RpycMtaPPLVLJbnbPO7HJGQiIuN4bw+mfwxb62mvA0TQ8Zk0SA9iX6t6/hdivigWe1UBvbJ5L0xWcxeod/JslADoEStc3plMKBXY57/aT5fT1vhdzkR7fmf5vHdjJXcfnxbejer6Xc5e6Vz42oM/Wcf3ryoJwlxMVw1ZAKnvjCS0QvW+l2aiIiIiIiIhKncvAIuHzSOr6at4M4T2nHVYS38LimsmBn/PbUjBYWOOz+dpo62ErXO6dmYhNgYBo1a7Hcpld7itVv4be4azu6ZUSnvwSoB1x3RktTEOB78cqbfpUQENQBKVLvnpPZ0blyNG4dNYt6qzX6XE5F+mr2KJ76fwyldGnDRAU38LmefmBmHtanDV9cdwqNndGJFTi5nv/In/3h7LHNXqreIiIiIiIiI/G3rjnwufXssP89ZzX9P7cilBzX1u6Sw1LhGCjce3YrvZ65ixNTlfpcjEhI1UxM5oVN9PpqwlM3b8/0up1IbOiab2Bjj7J6N/S5FfFS9SgLXHtGSX+es5ufZuj/nnqgBUKJaYlwsLw3sRnJCLJcNGsem3Dy/S4ooi9du4bqhE2lTryoPndYp4qc6iY0xzurRmJ9v7sct/VszesE6jnnqV279cAorcnL9Lk9ERERERER8tik3jwteH8Oo+Wt5/MzOnKv7TJXqogOa0KlROvcMn86GrTv8LkckJC44oAmbt+fzyYQlfpdSae3IL+SDcdkc0aZORNyaSELrgr5NaFIzhf9+OZP8gkK/ywlragCUqFc/PZnnzu3G4rVbuXHYZAoLNS1FWWzdkc/lg8ZjZrw8sDvJCbF+l1RukuJjubJfC3695TAuPrApH09cQr///cRj38xioxqJRUREREREKqUNW3dw3mujmZS9gWcHdOO0bo38LinsxcXG8PBpnVi/NY8HR2g6NolOXRpXo1OjdN4etVjT3frkm+krWLtlhzplCAAJcTH8+9i2zFm5mffHZftdTlhTA6BUCn2a1eQ/x7Xl2xkrefGX+X6XE/acc/z7o6nMXrmJZwZ0JaNmit8lhUT1KgnceUI7fryxH8e0r8fzP83n0Ed/4s0/FrIjX71HREREREREKos1m7dzzit/Mmv5Jl4a2J3jO9X3u6SI0a5BVS4/pBkfjF/C73PX+F2OSEhc0LcJ81ZtZtSCtX6XUikNGZ1Fo+rJHNKytt+lSJg4pn1dejWpwRPfztGsf6VQA6BUGpcc2ISTuzTgf9/O5pc5q/0uJ6y98ccihk9exk1Ht+bQVtH/h7VxjRSePqcrn199EG3rV+Xez2dw5BO/8PnkZRoxKiIiIiIiEuVW5ORy9sujWLR2C69f1IMj29X1u6SIc+0RLWlaqwr/+WQq23YU+F2OSLk7oVN9qqfE887IxX6XUunMXx1oeB3QK4OYmMi+PZGUHzPjjhPasnbLDl74WQN+SqIGQKk0zIyHT+tE67ppXDt0Illrt/pdUlj6c8Fa/vvlTI5pX5cr+zX3u5wK1bFROu/+ozdvXdyTlIRYrhk6kVNe+IOR89WDUUREREREJBotWb+Vs14exYqcXN6+uBcHa3TJPkmKj+Wh0zqStW4rT30/x+9yRMpdUnwsZ/fM4LuZK1m2YZvf5VQqQ0dnERdjnNlD0zLLzjo1qsZpXRvy+u8LWbJe1/qLowZAqVSSE2J55fweOOe4fPB49UrbxfKcbVw9ZAJNaqbwvzM7Y1b5etWYGf1a12HEtQfzvzM7s2bTds59dTQXvzmGWSs2+l2eiIiIiIiIlJOFa7Zw1kuj2LB1B4P/0ZvezWr6XVJE69OsJgN6NebV3xYwbWmO3+WIlLvzemdQ6BxDRmf5XUqlkZtXwIcTlnB0+7rUSUvyuxwJQzcd05oYg0e/nu13KWFJDYBS6WTUTOGZAV2ZtWIjt308RTfv9WzPL+CKwRPIzSvk5fN7kJYU73dJvoqNMc7o3ogfb+rHbce2Ydzi9Rz79G/c/MFklueop5eIiIiIiEgkm7tyE2e9PIrc/EKGXtaHrhnV/S4pKvz72LbUSk3klg+nkFdQ6Hc5IuWqcY0UjmhTl/fGZrE9X4MKKsLX01awYWse5/XO9LsUCVMNqiVz2cHNGD55GROy1vtdTthRA6BUSv1a1+HGo1rx6aRlvDVykd/lhIV7hk9ncvYG/ndmZ1rUSfW7nLCRFB/L5Yc257dbDuMfBzXls0nL6PfYzzzy9SxytukGsyIiIiIiIpFm+rIczn7lTwDev6wP7Ruk+1xR9EhPjue+kzswY/lGXv99od/liJS7C/pmsmbzDr6ausLvUiqFd0cvpknNFPpqhLaU4vJDm1M7LZEHvpihwT67CGkDoJn1N7PZZjbPzP5dzPIMM/vJzCaa2RQzOy6U9YgEu7JfC45qV5cHRsxk9IK1fpfjq6Fjshg6JpurDmtO/w71/C4nLFVLSeD249vxw42HclzH+rz483wOfewnXv99YUT0+lIei4iEB+WxiEj4UCZXThOz1jPglT9Jioth2OV9aVk3ze+Sok7/DvXo374eT343h0VrtvhdjkSASMrjg1rUolmtKrwzapFfJVQac1ZuYuyi9QzolUFMTOW7TZGUXZXEOG46uhUTsjYwYupyv8sJKyFrADSzWOB54FigHTDAzNrtstodwDDnXFfgHOCFUNUjsquYGOOJszqTWSOFq4ZMYEVOrt8l+WJi1nru/mw6h7SqzQ1Htfa7nLDXuEYKT57dhS+uOYiODdO5/4sZHPH4L/w2d7XfpZVIeSwiEh6UxyIi4UOZXDmNXrCWga+NplpKAsOu6EvTWlX8Lilq3XtyexLiYrjt46kajSGlirQ8jokxBvbJZELWBt3rMsSGjM4iITaGM7o38rsUiQBndG9Mm3ppPPL1LHLzwn+wRkUJ5QjAXsA859wC59wO4D3g5F3WcUBV7/N0YFkI6xHZTVpSPK9c0J1tOwq4YvD4iBjJVZ5Wb9rOvwZPoG56Is+c04VY9aYpsw4N0xl0aW/euaQXVZPiSUmI9buk0iiPRUTCg/JYRCR8KJMrmd/mrubCN8dQLz2JYZf3pVH1FL9Limp1qybxn+PaMmrBWj4Yt8TvciS8RVwen969ESkJsRoFGELbdhTw0YQl9O9Qj5qpiX6XIxEgNsa44/h2ZK/bxtu65ddfQtkA2BDIDvp6ifdcsHuAgWa2BPgSuKa4DZnZZWY2zszGrV4dvqNsJDK1qJPG42d1ZlL2Bu79fIbf5VSYvIJCrh4ygQ3bdvDSwO5US0nwu6SIdEir2oy49iC6Z9bwu5TSKI9FRMJDueUxKJNFRPaTzpErke9nrOTSt8bRpGYV3r+8L/XSk/wuqVI4u0djejetwQMjZrBqU+WcdUnKJOLyOD05nlO6NuSzSctYv2VHyPZTmX0xZRmbcvM5t3eG36VIBDmoZS2OaFOH536cx9rN2/0uJyyE9B6AZTAAeMs51wg4DhhkZrvV5Jx7xTnXwznXo3bt2hVepES//h3q869+zRkyOov3x2b5XU6FePirWYxeuI6HTuuoG57vJ7OoGDmpPBYRCQ9lymNQJouIVACdI0eBEVOWc8Xg8bStn8Z7l/WhlkaSVJiYGOOh0zqSm1/IvcMrT4drCYmwy+ML+mayPb+QYeOy97yy7LUhY7JoXrsKvZuGdYd7CUO3HdeWrXkFPPX9XL9LCQuhbABcCjQO+rqR91ywS4FhAM65UUASUCuENYmU6KajW3Nwy1rc+el0JmVv8LuckPps0lJe/30hFx3QhFO7ah7tSkB5LCISHpTHIiLhQ5lcCXw8YQnXDJ1A14xqDP5Hb81844NmtVO57oiWjJi6nG+nr/C7HAlPEZnHbepVpVfTGgwevZiCQt3nsjzNWLaRiVkbOLd3ZrR0upcK1KJOKuf1zmDImCzmrdrkdzm+C2UD4FigpZk1NbMEAjdoHb7LOlnAEQBm1pZAeGu+DPFFbIzxzDldqZ2WyL8Gj2dNlA4Tnrl8I7d+NIVeTWpw+/Ft/S5HKobyWEQkPCiPRUTChzI5yg0ZncWNH0ymb/OavH1JL9KS4v0uqdK67JBmtKmXxp2fTWNjbp7f5Uj4idg8vrBvE7LXbePn2av8LiWqDBmzmIS4GE7vtutMsCJlc90RLUlJiOW/X87yuxTfhawB0DmXD1wNfAPMBIY556ab2X1mdpK32o3AP81sMjAUuMg5py4T4pvqVRJ4+fzurNuyg6uHTCC/oNDvksrVhq07uHzQeNKT43nuvK7Ex/o9C7BUBOWxiEh4UB6LiIQPZXJ0e/33hfznk6kc1roOr1/Yk5SEOL9LqtTiY2N45PROrN60nUe+0sVY2Vkk5/HR7etSt2oi74xa7HcpUWPL9nw+nbiMEzrW16ht2Wc1UxO55vAW/DhrFb/N9b2vgK9CegbknPuSwI1Zg5+7K+jzGcCBoaxBZG91aJjOQ6d15IZhk3n4q1nccUI7v0sqFwWFjuvem8TynG28f3lf6qTppueVifJYRCQ8KI9FRMKHMjk6Pf/TPB77ZjbHdqjH0+d0JSFOHV/DQefG1bjkwKa89vtCTu7SkF66r5cEidQ8jo+N4dxemTz5/RwWrtlC01pV/C4p4n0+eRmbt+dzXp8Mv0uRCHfhAU0Y9OdiHhwxkxHX1iI2pnJOJ6uzIJFinNatERf2zeS13xcyfPIyv8spF099P4df5qzmnpPa0y2jut/liIiIiIiIiJQb5xz/+2Y2j30zm1O6NODZAWr8Czc3HN2KRtWT+ffHU8jNK/C7HJFyMaBXY+JijMF/ahRgeXh3dBat66bp2qXst8S4WG47ti2zVmzig3HZfpfjmz2eCZnZdWV5TiTa3H58O3o2qc6tH05h5vKNfpezX76dvoJnf5zH2T0ac24v9aCJVMpjEZHwoUwWEQkPymOBQOPfAyNm8txP8zinZ2MeP6sLcbrlRdhJSYjjv6d2ZMHqLTz/0zy/y5FyVlnzuE7VJI7tWJ9h47LZuiPf73Ii2tQlOUxdmsO5vTMwq5yjtaR8HduhHj0yq/O/b+eweXvl/P0sy9nQhcU8d1E51yESdhLiYnj+vG6kJcVxxeDx5GyNzBtVz1+9mRuGTaZzo3TuPbm9/oBGNuWxiEj4UCaLiIQH5XElV1jouOPTabz++0IuOqAJD53WsdJO8xUJDmlVm9O6NeTFn+cza0Vkd7aW3VTaPL6gbyabcvP5bFJ0zCLmlyFjFpMUH8MpXRv6XYpECTPj9uPbsmbzdl7+Zb7f5fiixAZAMxtgZp8DzcxseNDjJ2BdxZUo4p86aUm8OLA7yzZs4/r3J1JY6Pv9hffK5u35XD5oPIlxMbw4sDtJ8bF+lyT7QHksIhI+lMkiIuFBeSwA+QWF3PzhFN4dncUVhzbn7hPbqdNrBLjz+HakJ8dz60dTKYiw6yyyO+Ux9MisTtv6VXl75CKc08/0vtiUm8dnk5ZxUucGpCfH+12ORJGuGdU5uUsDXvl1Acs2bPO7nAoXV8qyP4HlQC3g8aDnNwFTQlmUSDjpnlmdu05sz52fTuOpH+Zyw1Gt/C6pTJxz3PzBZBau2cKgS3vRoFqy3yXJvlMei4iED2WyiEh4UB5XcnkFhVz//iRGTFnODUe14prDW6jxL0JUr5LA3Se159qhE3l75CIuOaip3yXJ/qn0eWxmXNA3k9s+nsq4xevp2aSG3yVFnE8nLWPrjgLO7Z3pdykShW7p34avp63gsW9m8+TZXfwup0KV1gD4oXOuu5ltdc79UmEViYShgb0zmJK9gWd+mEvHhukc1a6u3yXt0Uu/LOCraSu44/i2HNC8lt/lyP5RHouIhA9lsohIeFAeV2K5eQVcPWQi389cyX+Oa8NlhzT3uyTZSyd2qs+nE5fyv29nc1S7ujSukeJ3SbLvlMfAyV0a8NCXM3l75CI1AO4l5xxDRmfRrn5VOjdK97sciUINqyXzj4Ob8vxP87nogCZ0blzN75IqTGkNgDFm9h+glZndsOtC59wToStLJLyYGfef0oFZKzZxw/uT+OzqA2lWO9Xvskr029zVPPbNLE7s3IBL1ZMuGiiPRUTChzJZRCQ8KI8rqW07Crhs0Dh+m7uG+09uz/l9m/hdkuyDoussRz/xC7d/Oo23L+6pEZyRS3kMpCTEcVaPxrw1chGrNuZSp2qS3yVFjEnZG5i5fCMPntpBOSAh869+LXh/bDYPjJjBsMv7VpqftRLvAQicAxQQaCRMK+YhUqkkxcfy0vndiY+L4fJB49m8Pd/vkoqVvW4r1wydSMs6aTxyesdKE2ZRTnksIhI+lMkiIuFBeVwJbd6ez4VvjuH3eWt49IxOavyLcA2rJXNL/zb8Omc1n01a5nc5su+Ux56BfTLJL3QMGZPldykR5d3RWVRJiOXkLg39LkWiWGpiHDcc1Zqxi9bzzfQVfpdTYUocAeicmw08YmZTnHNfVWBNImGrYbVknhvQlYGvj+aWDyfz/LndwqqBLTevgCsGj6ew0PHy+d1JSShtkK9ECuWxiEj4UCaLiOzZj7NWsnjtVs7vk0lcbGn9jved8rjyydmWx4VvjGHq0hyeOruLLhRHiYF9Mvls0lLu/Xw6B7esRc3URL9Lkr2kPP5bk1pV6Ne6NkNGZ3HVYS2ID9HfwGiSsy2PL6Ys49SujUhN1HVMCa2zejTi7ZGLeOirWRzWpg6JcbF+lxRyJf5WmdlA59xgoJ2Ztd11eWUZvi2yqwNa1OLfx7bhv1/O4uVfF3DFoeFxrwHnHP/5ZCozlm/kjQt70qRWFb9LknKiPBYRCR/KZBGR0uXmFXDXZ9OpkhDH+X0yQ7Yf5XHlsm7LDs5/fTRzVm7ihfO6cUz7en6XJOUkNsZ4+PROHP/MbzwwYiZPnt3F75JkLymPd3ZB30wueWsc30xfwQmdGvhdTtj7ZMIScvMKOa93ht+lSCUQFxvD7ce35YI3xjBo1GL+cXAzv0sKudK6IRS1HqRSyYdvi+zqnwc34/hO9Xn061n8PneN3+UAMOjPxXw8YSnXH9GKw9rU8bscKV/KYxGR8KFMFhEpxau/LmDJ+m3cfWK7kI3+8yiPK4lVG3M5++VRzFu1mVcv6KHGvyjUqm4aV/ZrwScTl/Lz7FV+lyN7T3kc5NBWdciokcI7oxb7XUrYcy4wXWrnRul0aJjudzlSSRzSqjb9Wtfm6R/msm7LDr/LCbnSpgB92cxigY3OuScrsCaRsGdmPHp6J+au3MQ1Qycw/OqDaFwjxbd6xi5ax32fz+DItnW45vAWvtUhoaE8FhEJH8pkEZGSLc/Zxgs/z6d/+3oc0KJWSPelPK4clm3YxnmvjWblxlzevLgnBzQP7c+V+OfKw5ozYupybv9kGt/+3yFU0VSAEUN5vLPYGGNgnwz+++UsZq3YSJt6Vf0uKWyNW7yeOSs388jpHf0uRSqZ249rS/+nf+OZH+Zyz0nt/S4npErtjuecKwAGVFAtIhGlSmIcL5/fg/xCx7/eHU9uXoEvdazcmMuV706gcY0Unji7CzEx4XNPQik/ymMRkfChTBYRKd5DX86i0DluP363GeBCQnkc3bLWbuXMl0axZtN2Bl3aS41/US4xLpZHTu/IspxtPP7tHL/Lkb2kPN7ZWT0akxgXo1GAezBkdBZpiXGc2FlTpUrFalk3jXN6Nmbwn4uZv3qz3+WEVFnm4/jDzJ4zs4PNrFvRI+SViUSAprWq8NTZXZi2dCO3fzIN51yF7n9HfiFXvjuBLdvzefn87lRNiq/Q/UuFUx6LiIQPZbKISJCxi9YxfPIyLj+kWUXPjqI8jkLzVm3mzJdHsmVHPkP+2YfumTX8LkkqQPfMGpzfJ5M3Ry5kYtZ6v8uRvac89lRLSeDkLg34ZMJScrbl+V1OWFq/ZQcjpi7n1G4NSUnQiF+peP93VCuS4mN56MtZfpcSUmX57erifbwv6DkHHF7u1YhEoCPa1uW6I1ry9A9z6dI4nfP7Nqmwfd//xQzGL17P8+d2o1XdSjetemXUxfuoPBYR8V8X76MyWUQqvYJCxz3Dp1M/PYkr+jWv6N138T4qj6PEzOUbOf/10YDx3mV9NH1eJXPzMa35bsZK/v3RVD6/5iAS4kJ6L1EpX128j8pj4IK+TRg2bgkfjl/CpQc19bucsPPRhCXsyC/k3N4ZfpcilVSt1ESuOqwFj3w9i5Hz1oR8+nq/7LEB0Dl3WEUUIhLJrjuiJdOW5nDv5zNoW78qPZqEvnfiB+OyGfTnYi4/pBnHd6of8v2J/5THIiLhQ5ksIvK3YeOymb5sI88M6FrhvfiVx9FlypINXPDGGJLiYnn3n71pXjvV75KkgqUlxfPAKR249O1xvPzLfK45oqXfJUkZKY931qFhOt0yqjH4z8VcfEAT3bIniHOOIWOy6JZRTZ08xFcXH9iEwX8u5oERM/n8moOIjcLf01K70ZhZazN73MxGeI//mVmriipOJFLExBhPnN2FRtWT+de7E1i1MTek+5u6JIfbP53GgS1qcvMxrUO6LwkPymOR0HPO8dmkpazdvN3vUiTMKZNFRP6Wsy2Px76ZTa8mNTixgjsmKo+jy7hF6zjv1dGkJsbxwRV91fhXiR3Rti4ndKrPsz/OY96q6L43U7RQHhfvwgOasHDNFn6bt8bvUsLKnwvWsWD1Fs7rnel3KVLJJcXH8u9j2zBj+UY+mrDE73JCosQGQDPrC/wMbAZeAV4FtgA/m1mfCqlOJIKkJ8fz8vk92Jybz7/encCO/MKQ7Gft5u1cMXg8tVMTeXZAN+JiNR1GtFMei1SMN/5YxHXvTeKaoRMpLKzYe7pK5FAmi4js7Knv57B+6w7uOrEdZhXXazqa8vj+L2bwyNez+HD8EiZlb2BTbuW7X9TIeWs4//Ux1E5L5IMr+lb0fSQlDN19YnuSE2K57eMpOjcPc9GUx+Wtf4d61EpNYNCoRX6XElaGjMkiPTleM5pJWDihU326ZlTjf9/MZsv2fL/LKXelzc1xFzDAOfdz0HOfmtmPwN3AsaEsTCQSta6XxmNnduLqIRN5YMQM7ju5Q7luP7+gkGvfm8jqzdv56IoDqFEloVy3L2FLeSwSYtOW5vDwVzPJqJHCyPlrGfTnYi48oInfZUl4UiaLiHjmrtzEO6MWc07PDDo0TK/o3UdNHo9dtI4ZyzaSH9TIUbdqIi3qpNK8dupOH+ukJVZoQ2tF+Gn2Kq4YNJ4mNasw6B+9qJOW5HdJEgZqpyVyx/FtufnDKQwZk8XAPhopFMaiJo/LW2JcLAN6ZfDcT/PIXrdVnRuANZu38/W05Qzsk0lSfKzf5YhgZtxxfDtOf3Ekr/y6gP87KroGL5fWANh8l+AGwDn3i5m9ErqSRCLbCZ0aMGVJDq/8uoBOjapxRvdG5bbtx76ZzR/z1vLYGZ3o2KjC/8EW/yiPRUJoy/Z8rhk6kZpVEvn0qgO5YdgkHvpqJoe0qk3TWlX8Lk/CjzJZRITA1Nn3fTGDKgmx3HS0LxdKoiaPh199EHkFhWSt28q8VZuZv3qz93ELH09Yyuag3uhpiXE0q5NK89pVdmoYzKyREpGzw3w9bQXXDJ1A63ppvHNJb3VylZ2c0b0Rn01axsNfzeLItnWpl67G4TAVNXkcCuf2zuCFn+czePRibju2rd/l+O7D8UvIK3Cc1zvD71JE/tI9szondKrPy7/OZ0CvjKj6e1NaA+CmUpZtKe9CRKLJLce0ZtrSHG7/ZCpt6qWVS2/YEVOW8/KvCzi/TyZn9mhcDlVKBFEei4TQ3cOns2jtFob+sw81qiTwyOmdOPrJX7lx2CQ+uOKAqLwJtOwXZbKICPDdjJX8NncNd5/YjpqpiX6UEFV5HB8bQ/Paqbvd9845x8qN24MaBQMf/5i3ho8nLA16vZFZswotaqfSvM7fjYPNa6dSJbG0Sz/++WzSUm4YNpnOjdJ58+JepCfH+12ShBkz47+nduTop37hjk+n8eoF3aNuBGyUiKo8Lm/105M5ul1d3h+bzf8d2apSj3orLHQMHZNFr6Y1aFEnze9yRHZya/82fDtjJY99M5vHz+rsdznlprSzwMZm9kwxzxvQMET1iESFuNgYnh3QlROf/Z3LB43n82sO2q+ejLNXbOLmDyfTPbM6d57QrhwrlQihPBYJkc8mLeXD8Uu49vAW9GlWE4C6VZO47+T2XPfeJF79bQFXHNrc5yolzCiTRaTSy80r4IERM2lZJ9XPafkqRR6bGfXSk6iXnsSBLWrttGxjbh4LVm/ZqWFwzqpNfDdzJQVB04k2SE+ieVGDYJ3UvxoJa6f6N53osLHZ3PrxFHo3rcHrF/YM20ZK8V9GzRRuPKo1D345k6+mreC4jrpnWBiqFHm8P87vm8lX01bw+eRllbpT/x/z17B47VZuiLIpFiU6NK6RwiUHNuWlX+Zz0QFNomb2vdLOsG4uZdm4smzczPoDTwOxwGvOuYeLWecs4B7AAZOdc+eWZdsi4a5maiIvnd+dM14axbVDJ/LWxT33aUqWnG15XDF4PFUS43jhvG4kxEXetC6y35THIiGweO0Wbv9kGj0yq3PtES13WnZS5wZ8PW0FT3w7h8Na16F1PfVOlL/sVyYrj0UkGrz++0Ky1m1l8KW9ifdv2slKf45cNSmeLo2r0aVxtZ2e35FfyOK1W3aaSnTeqs0MG5fN1h0FQa+PK/Y+g41rpIR0BoS3Ry7i7uHTOaRVbV4e2J3khMo7GkbK5uIDmzB88jLu+mw6BzavRXqKRouGmUqfx3vSt1lNWtZJ5Z1Rizmje6NKO5J1yOgsqqfE079DPb9LESnWlYc154Nx2TwwYgbvXdYnKn5XS2wAdM69vT8bNrNY4HngKGAJMNbMhjvnZgSt0xK4DTjQObfezOrszz5Fwk2nRtV44JQO3PLhFP737Rz+fWybvXp9YaHjhvcnkb1uK0Mv60PdqtEz/7CUnfJYpPztyC/k2qETiTF46pwuu3XQMDMeOKUDYxf9yg3DJvHJlQeqA4YA+5fJymMRiQYrcnJ5/qd5HN2uLge1rLXnF4SIzpFLlhAXQ8u6abSsu3MHJuccy3Ny/2oYLBo5+NPs1Xwwfsnfr4+NoWmtKoGpRL1Rg0XTie5vY93Lv8znoa9mcVS7ujx3blcS49T4J3sWFxvDw6d35KTn/uC/X87kkTM6+V2SBFEe75mZcUHfTO78bDqTsjfQNaO63yVVuFUbc/luxkouOaipsl/CVtWkeK4/qhV3fjqN72as5Oj2kd9YHco5FnoB85xzCwDM7D3gZGBG0Dr/BJ53zq0HcM6tCmE9Ir44q0djJmdv4KVf5tOpUfpeTVfx7I/z+GHWKu47uT09m9QIYZUS5ZTHIrt44rs5TF6Sw4vndaNR9ZRi16mZmsiDp3bk8kHjee6neZqmRMqD8lhEIt7DX80kv9Bxx/ERf2uCSpfJZkaDask0qJbMwS1r77QsZ2se81YHGgTnew2DM5Zt5OtpKwiaTZSG1ZJ3Gi0Y+LzKHu8D6Zzj6R/m8tT3czmxcwOeOKuzn6NHJQK1b5DOZYc048Wf53NylwYc0MK/DghS7ipFHp/arRGPfD2bd0YtrpQNgMPGZZNf6BjQK8PvUkRKNaBnY94euYiHvppFv9Z1Ir4zeCgbABsC2UFfLwF677JOKwAz+4PAEO97nHNf77ohM7sMuAwgI0MhIZHnrhPbMWP5Rm76YDIt66Tu1hOzOD/OWslTP8zhtG4NOd+/+2pIdFAeiwT5be5qXvplPuf2zuDYPXTKOKZ9PU7r1pDnf5rHkW3r0KlRtYopUqJVueWxt44yWUQq1PjF6/h00jKuOqw5GTWL70ATQXSOHCQ9JZ7umdXpnrnzRent+QUsWrN1p/sMzl+9mdEL15KbV/jXetVT4nebSrR57VQaVk8mxuDhr2fx8i8LOKN7Ix45vVNIpxiV6HXdES35aupybvtkKt9cfwhJ8RpFFCUqRR6nJsZxereGDB2Tze3Ht6XWHjpORJOCQsfQMdkc0LwmTWtV8bsckVLFxcZw+/FtufjNsQz+czGXHNTU75L2i993WY4DWgL9gEbAr2bW0Tm3IXgl59wrwCsAPXr0cIhEmMS4WF48rzsnPPs7lw0az2dXH0jVpJLnrF+0ZgvXvTeJdvWr8t9TO0bFfMMS9pTHUims2bydG4YFOmPcWcaRC3ef2J6R89Zyw7DJfHHNQbrQIKFWpjwGZbKIVKzCQsc9w2dQr2oSV/Zr4Xc5FaXSnyMnxsXSul7abvdDLix0LMvZttM9Buev2sx3M1by3pbsoNfHUC89icVrt3J+n0zuPak9MWr8k32UFB/Lf0/ryLmvjuap7+fu9W1WJKJFRR6f37cJb49azPtjs7nqsErzt5Rf565m6YZt3HacfmclMvRrVZuDW9bi6R/mclq3hlRLSfC7pH22x/GLZtbIzD4xs9VmtsrMPjKzRmXY9lKgcdDXjbzngi0Bhjvn8pxzC4E5BMJcJOrUS0/ihfO6kb1uKze8P5nCwuLPQ7buyOfyQeOJizFeGthdF5rlL8pjkf1TWOi4cdhkcrbl8ey5Xct8D5v05HgePaMT81Zt5vFvZ4e4SokU+5jJymMRiVgfjM9m6tIcbjuuDVUS/e5L/DedI/sjJsZoVD2Ffq3rcOlBTXnotI4Mu6Iv4+88iol3HsWHV/Tl4dM6ckHfTJrXTuXmY1pz38lq/JP9d0DzWpzTszGv/raAaUtz/C5HgiiP96xFnVQObFGTd/9cTH5B4Z5fECWGjM6iVmoCR7eL/PupSeVgZtx+fFs25ebxzA/z/C5nv5RlAtM3geFAfaAB8Ln33J6MBVqaWVMzSwDO8bYT7FMCPTcws1oEhnMvKEvhIpGoV9Ma3HF8W76fuZLnfto9PJxz3PLhFOau2sQzA7rSuEbET6sj5Ut5LLIf3vhjIb/MWc2dx7elTb2qe/XaQ1rV5rzeGbz2+0LGLFwXogolwuxLJiuPRSQibczN47FvZtMjszondW7gdzm70jlymKleJYEeTWpwTq8Mbj++HW9c1JOrDmuhmW2k3Nx2bFtqVEng3x9PqVSNKBFAeVwGF/RtwrKcXL6fGXG3Mdwny3O28cPMlZzZo3HE30tNKpc29apyds/GDPpzEQvXbPG7nH1Wlt+62s65N51z+d7jLaD2nl7knMsHrga+AWYCw5xz083sPjM7yVvtG2Ctmc0AfgJuds6t3acjEYkQFx7QhFO7NuTJ7+fw06yd/9i//vtCvpiynJuPabPbTdlFUB6L7LOpS3J45OtZHN2uLgP38b6q/zmuLY2rp3DTB5PZsj2/nCuUCLTXmaw8FpFI9cz3c1m7ZQf3nNQ+HBtxdI4sUsmkp8Rz30ntmbZ0I6//vtDvcuRvyuMyOKJNHRpWS2bQn4v8LqVCvD82m0IHA3qG1z0ZRcri/45qRUJsDA9/NdPvUvZZWRoA15rZQDOL9R4DgTIFrHPuS+dcK+dcc+fcg95zdznnhnufO+fcDc65ds65js659/b9UEQig5nx31M70rZeVa57byKLvB4EI+ev4aGvZnFsh3pccWgzn6uUMKU8FtkHm7fnc83QCdRKTeTRMzrt84XLKolx/O/MzmSv38pDEXzyJ+VmnzJZeSwikWbeqk28NXIRZ/doTIeG6X6XUxydI4tUQv071OPodnV54rs5f11XEd8pj8sgLjaGc3tn8Me8tcxbtcnvckIqv6CQ98dmc0ir2mTU1CxnEnnqpCVx5WEt+Gb6Sv5cEJF9DsrUAHgJcBawAlgOnAFcHMqiRKJdckIsL5/fnZgY44rB45m3ajNXD5lIs1pVeOzMzuHYq1bCg/JYZB/c/dl0stZt5amzu+z3jZt7Na3BPw5qyuA/s/h1zupyqlAilDJZRKKec477vphJckIsNx3T2u9ySqI8FqmEzIz7Tu5AQmwM//lkKs45v0sS5XGZndOzMQmxMbwzarHfpYTUT7NXszwnl3N7afSfRK5LD2pKg/QkHhgxg8LCyPtbs8cGQOfcYufcSc652s65Os65U5xzWRVRnEg0a1wjhWfO6crslZs47pnfyMsv5KXzu5OaGOd3aRKmlMcie+/TiUv5aMISrjm8Jb2b1SyXbd54dGta1Enllg+nkLMtr1y2KZFHmSwSWtOX5bBk/Va/y6j0fpi5il/nrOb6I1tRKzXR73KKpTwWqbzqpSfx7+PaMHL+Wj4Yv8Tvcio95XHZ1UxN5IRO9flo/BI25Ubv/5RDRi+mTloiR7St43cpIvssKT6WW49tw7SlG/lk4lK/y9lrJbY0mNldpbzOOefuD0E9IpXKIa1qc8sxbfjft7N5fEBnmtdO9bskCUPKY5F9s3jtFm7/ZCo9m1TnmsNblNt2k+JjeeKszpz6wkju/Xw6T5zVpdy2LeFPmSwSeu+MWsS9n8+gTloiX1xzEDXDtOEp2m3PL+D+ETNoUSeVC/ru2/1zQ0l5LCIQuK/YZ5OW8eCImfRrXZs6aUl+l1TpKI/3zQUHNOHjiUv5ZOJSLujbxO9yyt2S9Vv5ec5qrjmsBfGxZZmEUCR8ndipAW/8vpDHvpnNcR3rk5wQ63dJZVbab9+WYh4AlwK3hrgukUrjX/2aM+muozi6fT2/S5HwpTwW2Us78gu5duhE4mJjeOqcrsSV8z8cnRpV46rDWvDxhKV8M31FuW5bwp4yWSRE8gsKueuzadz12XR6N63Bui07uPa9iRRE4FQ70eCN3xexeO1W7jqhXbheuFMeiwgxMcZDp3VkW14B934+w+9yKivl8T7o0rganRql886oxVE5he37Y7Mx4GxN/ylRICbGuOOEdqzYmMurvy3wu5y9UuJZvHPu8aIH8AqQTGDe5veAZhVUn0ilkJYU73cJEsaUxyJ77/FvZzN5SQ6PnN6RhtWSQ7KPqw9rQfsGVbn9k6ms3bw9JPuQ8KNMFgmNnG15XPzWWN4ZtZh/HtyUQZf25v5TOvDHvLU8/u1sv8urdFZuzOW5H+dyZNu6HNKqtt/lFEt5LCJFmtdO5bojWjJiynK+m7HS73IqHeXxvrugbxPmrdrMqPlr/S6lXOUVFPLe2Gz6ta4Tsv/HRSpazyY1OK5jPV78eT4rN+b6XU6ZldqNz8xqmNkDwBQC04V2c87d6pxbVSHViYgIoDwW2Ru/zlnNy78u4LzeGfTvUD9k+0mIi+HxszqzcVs+d3w6LSp7bUrxlMki5Wvx2i2c9sIfjJq/lkdO78jtx7cjNsY4q0djBvRqzAs/z+dbjbauUI98NYu8AsedJ7T1u5RSKY9FpMhlhzSjTb007vx0WlTfUy1cKY/3zQmd6lM9JZ53Ri32u5Ry9cPMlazetJ1zNfpPosyt/dtQUOgiqoNiiQ2AZvYYMBbYBHR0zt3jnFtfYZWJiAigPBbZG6s3beeGYZNpVTeVO09oF/L9talXlf87qhVfTVvB8MnLQr4/8Z8yWaR8jV6wllOe/4O1W3Yw6NLenN1z5wtFd5/Yno4N07lx2GQWrdlSwlakPE3IWs/HE5dy6cFNyaxZxe9ySqQ8FpFg8bExPHx6J1ZtyuXRryPnwmw0UB7vu6T4WM7umcG3M1awbMM2v8spN++OzqJBehKHtanjdyki5SqzZhUuOrAJH4xfwvRlOX6XUyaljQC8EWgA3AEsM7ON3mOTmW2smPJERATlsUiZFBY6bvpgMpty83h2QDeS4ivmpsyXHdKMbhnVuPPTaRE1DYTsM2WySDkZNi6bga+PpnqVBD698kD6Nq+52zpJ8bG8OLAbsbHGFYPHs21HgQ+VVh6FhY57h0+nTloiVx3Wwu9y9kR5LCI76dK4Ghcf2JRBfy5m3KJ1fpdTmSiP98N5vTNwwJDRWX6XUi4Wr93Cb3PXcHbPDGJjzO9yRMrdVYe1oFpyPA+OmBkRM0GVdg/AGOdcsnMuzTlXNeiR5pyrWpFFiohUZspjkbJ5/feF/DJnNXee0I7W9dIqbL+xMcbjZ3VhR0Eht340JSJOAGXfKZNF9l9BoeOhL2dyy4dT6N20Jp/860Ca1Cp5pFmj6ik8fU5XZq/cxO2fTFXOhtCHE5YweUkOtx3XhtTEOL/LKZXyWESKc+PRrWhUPZlbP5rC9nx1GqkIyuP907hGCke0qcvQMVlR8TM7dEw2sTHG2T0b+12KSEikJ8dz/ZGtGDl/LT/OCv9Zjku9B6CIiIhIJJiyZAOPfjOLY9rX5bzeFX+fgaa1qnDbsW35efZq3hubXeH7FxGJFFu253P5oPG8/OsCzu+TyZsX9yQ9JX6Przu0VW3+78hWfDxxKYOjpId8uNmUm8ejX8+mW0Y1TunS0O9yRET2SUpCHA+e2pH5q7fw/E/z/S5HpEwu6JvJ2i07+GpqZN/zeEd+IR+Oz+aINnWol57kdzkiIXNu7wya1a7Cg1/OJK+g0O9ySqUGQBEREYlom7fnc+3QidROTeSR0zth5s80I+f3yeSA5jV54IsZZK/b6ksNIiLhbOmGbZzx0ih+nLWSe09qz/2ndCA+tuz/kl59WAsOb1OH+z6fzsQs3VqovD374zzWbtnOPSe19+1vqYhIeTi0VW1O69qQF3+ex+wVm/wuR2SPDmpRi2a1qvD2qEV+l7Jfvp2xgjWbd3CuD51yRSpSfGwMtx/XlgWrt4T99L1qABQREZGIdten08hat5WnzulKtZQE3+qIiTEeO7MzZsZNH0ymsFBT1ImIFJmYtZ6Tn/uDJeu28ubFvbjwgCZ7vY2YGOPJs7pQLz2JK9+dwNrN28u/0Epq/urNvPnHQs7s3ohOjar5XY6IyH6744R2pCXFc+tHUyjQebmEuZgYY2CfTCZmbWDqkhy/y9ln7/6ZRaPqyRzSsrbfpYiE3OFt6nBgi5o89f0ccrbl+V1OiUptADSzWDP7qaKKERGR4imPRYr38YQlfDxxKdce0ZJeTWv4XQ4NqyVz14ntGL1wHW+NXOR3ORIiymSRvTN88jLOfuVPkhNi+PjKAzi01b5fFEpPiefF87qzbssOrn1voi7qlpP7v5hBUlwsNx/Txu9S9oryWERKUqNKAnef2I5J2RsYFOGjqiKB8nj/nd69ESkJsbwToT+vC1ZvZtSCtQzolUFMjGYSkOhnZtx+XDs2bMvj+Z/m+V1OiUptAHTOFQCFZpZeQfWIiEgxlMciu1u0Zgt3fjqNXk1qcPVhLfwu5y9ndm/EEW3q8MjXs5i3arPf5UgIKJNFysY5xxPfzeHaoRPp3CidT688kJZ10/Z7ux0apnP/KR34Y95aHv92djlUWrn9OGslP89ezbVHtKR2WqLf5ewV5bGIlOakzg3o17o2j34zm6UbtvldTlRTHu+/9OR4TunakOGTl7F+yw6/y9lrQ8dkERdjnNmjkd+liFSYdg2qcmb3Rrz1xyIWr93idznFKssUoJuBqWb2upk9U/QIdWEiIrIb5bGIZ0d+Ide+N5G42BieOqcLcXtxD6lQMzMeOq0jyQmx3PjBZPLD/IbQss+UySKlyM0r4OqhE3nmh7mc3q0Rg//Rm5qp5de4dFaPxgzo1ZgXfp7Pt9NXlNt2K5sd+YXc/8VMmtWusk/TsoYJ5bGIFMvMeOCUDgDc/slUnNOo8RBTHu+nC/pmsj2/kGHjsv0uZa/k5hXwwfglHN2+LnXSkvwuR6RC3Xh0a+JijUe+nuV3KcWKK8M6H3sPERHxl/JYxPO/b2czZUkOLw3sToNqyX6Xs5s6VZN44JQOXD1kIi//uoCrwmiEopQbZbJICVZtzOWfg8YzZckG/n1sGy4/pBlm5T8V1N0ntmfa0o3cOGwyn1+TRpNaVcp9H9HuzT8WsnDNFt66uCcJceHTmWYvKY9FpESNqqdw8zGtuffzGQyfvIyTuzT0u6RopjzeT23qVaVX0xoMHr2YfxzcjNgImUrz62kr2LA1j3N7ZfpdikiFq1s1iSsObc4T381h7KJ19Gzi/+1pgu2xAdA597aZJQCtvKdmO+fC966GIiJRSnksEvDLnNW88usCBvbJoH+Hen6XU6ITOjXg62kreOr7ORzWug7tGlT1uyQpR8pkkeJNX5bDP94ex4atebw0sDvHtA9dTifFx/LiwG6c8OzvXDF4PJ9ceSDJCbEh21+0WbUpl2d/nMcRberQr3Udv8vZZ8pjEdmTC/o24bNJy7j38xkc3LI2Naok+F1SVFIel48L+zbhqiET+Hn2Ko5oW9fvcspkyOgsmtRM4YDmNf0uRcQX/zy4GUNGZ/HAFzP45MoDw+o+mHvs4mdm/YC5wPPAC8AcMzsktGWJiMiulMcigYuVNw6bROu6adxxfDu/y9mj+0/uQHpyAjcMm8SOfE0FGk2UySK7+3b6Cs58aRQAH/6rb0gb/4o0qp7C0+d0ZfbKTZrebS89+vVstucXcMcJ4f/3tDTKYxHZk9gY45HTO7EpN48HvpjhdzlRS3lcPo5uX5e6VRN5Z9Riv0spk7krNzFm0ToG9MoIq0YPkYqUnBDLLf1bM3lJDsMnL/O7nJ2UZY6Px4GjnXOHOucOAY4BngxtWSIiUgzlsVRqhYWOG4dNZlNuPs+e25Wk+PAf5VG9SgIPn9aRWSs28fQPc/wuR8qXMlnE45zjpV/mc/ng8bSsm8ZnVx1I+wbpFbb/Q1vV5vojWvHxxKUMHp1VYfuNZBOz1vPh+CVcclBTmkb+1KnKYxHZo9b10vhXvxZ8PHEpv8xZ7Xc50Up5XA7iY2M4t1cmv8xZzcI1W/wuZ4/eHZ1FQmwMZ3Rv5HcpIr46pUtDOjZM59GvZ5GbV+B3OX8pSwNgvHNudtEXzrk5QHzoShIRkRIoj6VSe+33Bfw2dw13ndiOVnXT/C6nzI5sV5czuzfixZ/nMzFrvd/lSPlRJosA2/MLuPnDKTz81SyO71if9y/rQ52qSRVexzWHt+Cw1rW5AI7BngABAABJREFU7/Ppyto9KCx03PP5DGqnJXLN4S39Lqc8KI9FpEyuOqw5zWtX4T8fT2XL9ny/y4lGyuNyMqB3Y+JjjUFhPgowN6+AjycsoX+HetRMTfS7HBFfxcQYtx/flmU5ubz++0K/y/lLWRoAx5nZa2bWz3u8CowLdWEiIrIb5bFUWpOzN/Do17M5tkM9zu2V4Xc5e+2uE9tRPz2ZG4dNZtuO8OkJJvtFmSyV3rotOzj/tTF8OH4J1x3RkmcH+Dc6OybGePLsLtStmsSV705g7ebtvtQRCT6euJTJ2Ru4tX8bUhPj/C6nPCiPRaRMEuNieeT0TizdsI0nvtPsHCGgPC4nddKS6N+hPh+Mz2brjvBtrP5iynI25uZzbu/I+x9dJBT6NKvJMe3r8sJP81i1KdfvcoCyNQD+C5gBXOs9ZnjPiYhIxVIeS6W0KTePa9+bSJ20RB4+rRNmkXdfgbSkeB49oxML1mzhsW9m7/kFEgmUyVKpzV25iZOf/53JSzbwzICu/N9RrXzP52opCbw0sDtrt+zguvcmUVCo+wHuavP2fB75ehZdGlfjtK4N/S6nvCiPRaTMejSpwfl9Mnnzj4VMyt7gdzn7xTnHptw8stdtZeqSHH6bu5rhk5fxzqhFPPPDXO79fDo3vD+Ji98cw7otOyqiJOVxObqwbyabcvP5dGJ43U8s2LujF9O8dhV6N63hdykiYePfx7ZlR0EhT4ZJR5MSu/uZ2Q/OuSOA+5xztwJP7O3Gzaw/8DQQC7zmnHu4hPVOBz4Eejrn1DNERCSI8lgqu7s+m072uq28f3lf0lMidwaZA1vU4sK+mbzxx0KOaleXvs1r+l1S1CkodBiE9Obz+5vJymOJBj/PXsU1QyaSGB/Le5f1oWtGdb9L+kuHhuk8cEoHbvlwCk98N5ubj2njd0lh5dkf57J603ZevaBHSLOyIugcWUT21S39W/PdjJX8+6MpfH7NQcTHlmV8RGjl5hWwfusONmzNY/3WHeRszWN90efb8li/ZQcbtuWxYesO1m/NY8PWPHK27SCvoOTOLqmJcVRLiadaSjxbd+RTo0pCSGpXHodG98zqtK1flXdGLWJAr8a+d7Ta1czlG5mYtYE7jm8bdrWJ+KlprSpc0LcJb/6xkAsPaEKbelV9rae0+T7qm9kBwElm9h6w02+yc25CaRs2s1jgeeAoYAkw1syGO+dm7LJeGnAdMHof6hcRqQyUx1JpfTxhCZ9MXMr/HdmKnk0iv1fhrce24Zc5q7npg8l883+HRMvUa2EhZ2tgpGj3zOpce0RI72m1z5msPJZo8PbIRdz7+XRa16vKaxf2oGG1ZL9L2s1ZPRozMWs9z/80ny6Nq3NUu7p+lxQWFq7Zwhu/L+SM7o3o0ria3+WUB50ji8g+SUuK5/5TOvDPd8bxyq8LuOqwFuW27byCQjZsDTTUbSih4W5DUEPfhq15bNi2g9y8whK3mRQfQ7XkBKqlxFM9JYGWdVKpllL0dXzg8+R4qlcJfCxaVoENm8rjEDAzLuybyb8/nsrYRevpFWaj7IaMziIhLoYzujfyuxSRsHPt4S35aMISHhwxk3cu6eVrI3lpV53uAu4EGrF7zw0HHL6HbfcC5jnnFgB4fwBOJjD8O9j9wCPAzWWsWUSkslEeS6W0cM0W7vh0Gr2a1uDqw8vvn3I/pSTE8fhZnTnzpVE8OGIGD53Wye+SosLsFZu4bNA4lm3YxtHtQ36hf38yWXksESuvoJD7Pp/BoD8Xc2Tbujx9TheqhHEnhrtPbM+0pRu54f1JfH7NQTSpVcXvknx3/xczSIyL5Zb+rf0upbzoHFlE9tlR7epyfKf6PP3DXPp3qEfz2qk7LS8oDEyvuX6nEXk7/mrAW781L6hhr+j5PDZvL/l+bXExtlPDXeMaKXRsGGi4S08ONO5VT4knPaXo88C6ft1fdy8oj0Pk5C4N+e+XM3ln1KKwagDcsj2fTyYu5YSO9amWEpqRpSKRLD0lnmsPb8l9X8zg5zmrOax1Hd9qKfE/Nufch8CHZnanc+7+fdh2QyA76OslQO/gFcysG9DYOTfCzEoMbzO7DLgMICNDNxUVkcpFeSyV0Y78Qq4ZOoGEuBiePqcLsRE+TVmw7pk1uOyQ5rz0y3yObl/P1xPBaDBiynJu/nAyVRLjeO+yPnTPDO0/xvuZyeWWx966ymSpEDnb8rjq3Qn8Pm8Nlx/SjFv6twn7XE6Kj+XFgd044dnfuWLweD658kCSE8L+AmrI/DR7FT/OWsVtx7ahTlqS3+WUC50ji8j+uufE9vw+dw3/fHscmTVTvBF6gRF7OdvycCXMrmnGXw126cnx1E5NpFWdtKCGu3jSvY9/jdyrkkCVhNionCpReRw6yQmxnNWjMW+NXMSqjbnUqRoef8M/n7yMzdvzObd35L/HIqEysE8mg/5czIMjZnJwi1rE+TTd9B67bO5jcO+RmcUQ6BVyURlqeAV4BaBHjx66k7uIVErKY6lMHvtmFtOWbuSV87tTPz38ppfbX/93VEt+nLWSWz+cwrf/d4h6Te6DgkLHY9/M5qVf5tMtoxovDuxO3Qr8hzgUmbw3eezVoEyWkFu0ZguXvD2W7HVbefSMTpzVo7HfJZVZo+opPH1OVy56cwy3fzKVx8/qHJUXXvdkR34h938+g6a1qnDxgU39Lqfc6RxZRPZV7bREHjm9E499M4s1m3dQzRuVF2i4C0ylWb3K34141bxGvapJ8RF/H9VQUB6HxsA+mbz2+0KGjMni+iNb+V0OAEPGZNG6bhrdM8PnPtAi4SYhLobbjm3DZYPGM3RsNuf3yfSljlDO2bIUCP7vsJH3XJE0oAPws/dPWD1guJmdFO03cRURqWDKY4koP81exau/LeSCvpkc3b6e3+WERGJcLE+c1YVTnv+Du4dP5+lzuvpdUkTZsHUH1wydyG9z13Bu7wzuObE9CXH+9KbbS8pjiSij5q/lX++Ox4DBl/amd7Oafpe01w5tVZvrj2jFk9/PoWtmdd/+8fbT2yMXsWDNFt68qGekZGVFUSaLCP071KN/h+j8nyOCKI9L0aRWFfq1rs2Q0VlcdViLiry3Y7GmLslhypIc7j2pfaXsWCWyN45qV5c+zWrw5HdzOLlLA6omxVd4DaFMjLFASzNramYJwDnA8KKFzrkc51wt51wT51wT4E+gUgS3iEgFUx5XkB35hcxbtRlX0lwxskerNuVy07DJtKmXxn+Oa+t3OSHVoWE61xzeks8mLePLqcv9LidizFi2kROf+53RC9bx0Gkd+e+pHSPpgrbyWCLG+2OzOP/10dRKTeTTqw6MyMa/Itcc3oLDWtfmvs+nMzFrvd/lVKjVm7bzzA9zOax1bQ5roymnd6FMFhEJD8rjPbigbyarNm3nm+kr/C6FIWMWkxQfwyldG/pdikjYMzPuOL4d67fu4IWf5vtSQ4kjAM2s1BuoOOfW7WF5vpldDXwDxAJvOOemm9l9wDjn3PDSXi8iIgHK4/BWWOgYs2gdn01aypdTV5CzLY8DmtfkvpPb06JOmt/lRZTCQseNwyazZUc+7w3oEwk3u99vVx7WnB9mreSOT6fRs0kNaqcl+l1SWBs+eRm3fDiZ9OR43ru8D90yKn7Kmf3J5HDL48JCp+mrZDcFhY6Hv5rJq78t5OCWtXj+vG6+9FQtTzExxpNnd+GEZ3/nyncn8MU1B1EztXLk7WPfzCI3v4A7T2jndynlTufIIiLhQXkceoe2qkNGjRTeGbmYEzo18K2OTbl5fDZpGSd2akB6cmSfH4pUlA4N0zmtayPe+H0h5/XOoHGNlArdf2lTgI4HHFDcVQEHNNvTxp1zXwJf7vLcXSWs229P2xMRqaSUx2HGOcfM5Zv4bNJShk9exvKcXJLjYzm6fV1a1knllV8X0P+p37j04KZce3hLqiSGcsbt6PHqbwv4be4a/ntqR1rWrRyNp/GxMTx+ZmeOf/Z3bv9kKi+f313TqBQjv6CQR7+ZzSu/LqBHZnVeGNiNOmkVd7+/XexXJodLHq/amEu///1M+wZV6diwGh0bVaVjw3Sa1kolVo2Cldbm7flcN3QiP8xaxYV9M7nzhHa+3ay+vFVLSeClgd057cWRXPfeJN6+pFfU/6xPzt7AB+P/n737Do+iasM4/HvTCZDQQg+99xJQQLALNrAh2LFjxd79xN4Ve++oiKgUwV4B6b33FkB6byHJ+f7YRQMmIcBuZnfz3Ne1F8nu7Mw7s+HZ3Tlzzknn6o61qJVSwutygkGfkUVEQoPyOMiio4yLj67GEyPmMmf1VhpWSvKkjiFTV7EzI4uLiuCQ6iJH4s7O9Rk+YxVPfz+XVy9sVajbzvOMpHMu8mYHFxEJQ8rj0LFi406GTlvF4CkrWbB2OzFRRqd6KdxzagNOblSBxDjf22rPttV4+ru5vPXHYoZOXcWDZzTi1CYV1bCTj6krNvPsD/M4rWlFLmibevAnRJC6FUpy5yn1eXzEHL6evJJzW1f1uqSQsmmHb76/UQvXc8nRvgYJL4f8jJRMznZwfloqM1Zu4bPxy9g9OhuA4nHRNK6cTNOqyTStkkyTKsnUKldcPQWLgPRNO7nqo4ksWLudR7s15pJ2NbwuKeCaVEnmsW5NuOur6bzw0zzu7NzA65KCJjvb0XfYLMoWj+emE+p4XU5QREoei4iEO+Vx4Tg/LZXnf5zPx2OW8eQ5TQt9+845Ph23nEaVkmheNbnQty8SziomJ3Btp9q89MsCLu+widbVC280owJ1STCz0kBd4J9LrZ1zfwarKBERyZ3yuPBt2L6H4TNWM2TqKiYt880blFa9NI+e1YTTm1aiTPG4/zynXIl4nu3enB5tUnlwyCyu/3QyHeuW4+GujSP1Cvwjsm33Xm7+fAoVkhJ48uxmRbKh9IpjavLT7DX0HTaLdrXLUrlUMa9LCgmzVm3h2k8msXbrHp45txnntwmtxuFwzuSKyQn07doY8PWwXLRuBzNWbmFG+mZmrNzCp+OWsXuvr1GwRHwMjSr7egg2q+prFKxZVo2CkWTy8k1c8/FE9mRm8+HlbehYN8XrkoLm/DapTF6+idd+W0SL1NKc3KiC1yUFxeCpK5myfDPPnNeMkmE+hGtBhHMei4hEEuVx8JRKjKNbi8oMnrKSe05tUOhDcE5dsZk5q7fy2FlNiuR3dpEjde2xtfh9/jq27d5bqNs9aAOgmV0F9AGqAlOBo4ExwAlBrUxERPajPC48O/Zk8tPsNQyeupKRC9aTle2oV6EEd3auT9fmlQs8XndajTIMu7ED/ccu4/kf59O5359c06kWNx5fl2JxkT+/XUE453hg8ExWbt7FF9ccTXJi5J+kzE10lPFs92ac+tJI7v5qOh9f0bbIf6kaMnUld381nVLF4hjYux0tUkt5XdJ+IimTY6KjqF+xJPUrluQ8fw/UzKxsFq7bzoz0LcxcuYXpK7fQf+wy9mT+2yjY2N8ouK+3YA01CoalIVNXcueg6VRKTmDANWlFYv7avl0bM2vVVm4bOJVhNx5DjXLFvS4poLbvyeSp7+bSvGoy57WK/F7lkZTHIiLhTHkcfJe2q8HAiekMmpTOlccUbsfLz8Ytp3hcNGe1rFKo2xWJFIlxMQy+vn2hn+spSA/APkAbYKxz7ngzawA8EdyyREQkF8rjIMrIzGbkgnUMnrqKn2b/ze692VROTuDqjrXo1qLyYY+xHxMdRa8ONTmtWSWeGjGX135bxOApq/jfmY04pVGFIt/I89XklQyZuorbT65HWo18546PeNXLFue+0xrywOCZfDpuORcX0XkVMrOyefK7ubw3aglta5bhtQtbkVIy3uuychPRmRwTHUWDikk0qJhE9zRfz8vMrGwWrN3OjJX+RsH0LXySo1GwZHwMjask/TN0qBoFQ1t2tqPfz/N5+deFtK1Zhrcubk3pXHq1R6KE2Ghev6gVZ746it79J/HN9R0i6sKc135byNpte3jzktZF5f9fROexiEgYUR4HWZMqybSqVor+Y5dxefsahfY+v2XXXoZNX8XZLatSIr5AAwqKSC68OAdYkP+xu51zu80MM4t3zs01s/pBr0xERA6kPA6w7GzHxGWbGDJ1JSNmrGbTzr2USozl3FZV6daiCmnVSwfsA3X5kgm80KMFPdqk8r8hs7j2k0kcXz+Fvl0bU71sZPU8KKjF67bzvyEzOapmGa4/PjLnJzpUFx1VjR9m/c0TI+bQsW65Ive3sWH7Hm78bApjFm+gV/sa3H96Q2KjvZvv7yCKXCbHREfRsFISDSslcb6/UXBvVjYL1/p6Cs5Y6bt9NGYZGQc0CjarWuqfRsHqZRKLSqNEyNqVkcUdX05j+IzVnJ9WlcfOaurp3JpeSC2TSL8eLbj8wwnc/80Mnj+/eURclLN0/Q7eG7mEc1pVoVW1wptbxGNFLo9FREKU8rgQXNa+Bn0GTGXkwvUcW69whm3/ZnI6u/dmc9FR1QpleyISOAVpAEw3s1LAYOAnM9sELAtmUSIikivlcYDM/XsrQ6auYujUVazcvIuE2ChOblSRs1pUpmPdlKCeBD2qVlm+vfkYPvprKS/+NJ+TX/yT3sfW5vrjapMQGzm9Dw5mT2YWN30+hbiYKPr1bEG0GgMA39Vgz5zXjFNe/JM7vpzGgGvaFZljM3Olb76/ddv38Fz35v8MRRnClMlAbM5GwTb/NgouWLOdGSs3+xsFt/LhX0v/bRRMiKFJ5X+HDm1aJZnqZRMjovElHKzZupurP57IjJVbuO+0BlzdsVaRPfbH1S/PLSfW48Wf59OyemkuiYCe148Nn0NstHFPlwZel1KYlMciIqFBeVwIujSpSLkScXwyZmmhNAA65/hs/HKa++cCF5HwctAGQOfc2f4f+5rZb0Ay8H1QqxIRkf9QHh+Z9E07GTrN1+g39+9tREcZHeuW447O9TilUUWKF+IwFrHRUVzVsRZnNq/M48Pn8PIvC/hmSjp9z2zMiQ0rFFodXnrm+3nMWrWVdy5No1JyMa/LCSmVkovxcNfG3DZwGu+PWsLVnWp5XVLQfT05nXu/nkHZ4nF81bs9TauG/hdLZXLeYqOjaFQ5iUaVk+jRxnff3qxs5q/Z9k9PwZkrt/Dh6KVkZP3bKLivMXBfw2C1MmoUDLSZK7dw1UcT2bp7L29fksbJjYrGe05+bjqhDlNXbOKRYbNoUjmJlmHca+6P+ev4ec4a7u7SgPJJCV6XU2iUxyIioUF5XDjiY6K5oG01Xv1tISs27iS1TGJQtzdp2Sbmr9nO0+c2Dep2RCQ4Dnq208xeBgY45/5yzv1RCDWJiEgulMeHbuOODIbPWM3QqSuZsHQTAK2qleKRbo05rWklypXwdl6xCkkJvHxBS3q2SeV/Q2dx5UcTOalheR46s3HQP8R76be5a3lv1BIua1ddJ5/zcHbLKnw/82+e/XEex9VPoW6Fkl6XFBR7s7J5fPgcPvxrKUfX8s33V9bj/5cFpUw+NLHRUTSunEzjysn09N+XkelrFJy5cgvT/Y2CH+RoFExKiKFp1X/nE2xWpRSpZYqpUfAwfT/zb279YiqlE2MZ1Ls9jSof3ty2kSYqynixRwvOeGUU1386mW9vOiZsciinvVnZPDJsFjXKJnLFMTW8LqdQKY9FREKD8rjwXHhUNV7/fRH9xy7j3tMaBnVbn41bTsn4GM5sXjmo2xGR4ChId4dJwAP+MZu/wRfkE4NbloiI5EJ5XAA7MzL5afYahkxdxZ/z15GZ7ahTvgR3nFKPrs2rUK1s6DWsta9TjhE3d+T90Ut4+ZcFnPTCH9xwfB2u6VQr4oYFXbt1N3d8OY0GFUsG/YtKODMzHj+7KZ37/cntX07jq+vah/JceIdl/fY9XP/pZMYv2ciVx9Tk3lMbEBNe+6hMPkJxMVE0qeJr4DuwUXDffIIz0rfw/qgl7M1yACQXi6VJlSSaVin1T49BNQrmzznHG38s4pnv59GyWineuqQ15UsWnd5hBVEqMY43L27NOW/8RZ8BU/noirZhN/zyR38tZdG6Hbx7aRrxMZH12aEAlMciIqFBeVxIKiUX45RGFfhi4gpuPble0M4bbNqRwbczVtMjLZXEuMIbNUlEAqcgQ4B+BHxkZmWAc4Gnzayac65u0KsTEZF/KI/ztjcrm1EL1jNk6kp+nL2GnRlZVEpO4MpjatK1RWUaVUoK+ZPDcTFR9D62Nl39w4K+8NN8vp6cTt+ujTmufnmvywuI7GzHbQOnsSMjky8uPDriGjcDLaVkPI+d1YTrP53M678tos9JkfNffdqKzfTuP4mNOzLo16MFZ7Ws4nVJh0yZHBw5GwUv8N+3JzOL+X9v/7dRcOVm3hu1eL9GwZxDhzatkkzV0moUBN+xu/frGXw9eSVdm1fmmfOaKXvz0KRKMo91a8JdX03nhZ/mcWfn8JlDb/32Pbz08wI61UvhxIaR8ZnhUCiPRURCg/K4cF3SrjrfzfybodNWcX5aalC28dXkdDIys7nwqGpBWb+IBN+hNN3XARoA1YE5wSlHREQKQHmMr0fD5OWbGDxlFcNnrGbjjgySEmLo1qIy3VpUoW2NMkSF2dX7AJVLFeO1i1rRY/46+g6dRa8PJtClcUUePLMRVUqF91x5b/25mFEL1/PUOU2pUz4yh7QMtNOaVqJbi8q88usCTmxYPiImXf9y4gruHzyTlBLxfHVd+0jYJ2VykMXHRPsa93LMDbmvUXD6ys3M9DcMvjvy30bBUom+RsHaKSVILZNIauliVCubSGrpxEKd89VLG7bv4dpPJjFx2SZuO7keN51QR42iB3F+m1QmL9/Ea78tokVq6bAZpvq5H+axa28W/zujUVF/jZXHIiKhQXlcCNrVKkvd8iX4eMxSureuGvDPAM45Phu/nFbVStGwkoaOFwlXBZkD8BngbGAR8AXwqHNuc5DrEhGRAyiPfRas2cbgqSsZMnUV6Zt2ER8TxUmNKtCteWWOrZ8SMcNedaqXwne3dOTdkUt45dcF/P78Wm46oS5Xd6xFXExYDZMIwJTlm3j+x3mc3rQSPdoE5+rESPVI1yaMXbyB2wZOZdhNx4Tt33hGZjaPDZ/Nx2OW0aFOWV65oBVlisd5XdZhUyZ7K69GwXl/b2N6um8+wZmrtjBoUjrb92Tu99xyJeL8jYKJVCvju6WWSSS1TDEqJRcLu6EfczN/zTau+HAC67bt4dULW3JGM83ZUlB9uzZm1qqtvsy98RhqlCvudUn5mpG+hS8mruDKDjWpU76E1+V4QnksIhIalMeFy8y4tH0NHhw8kykrNtOqWumArn/s4o0sXreD57o3D+h6RaRwFeTy10VAO+fc+mAXIyIi+Sqyebxq8y6GTVvF4KmrmLN6K1EGx9RN4daT6nFK4wqUTIj1usSgiI+J5obj69CtRWUe/XY2z/4wj68mp/NI1yYcU7ec1+UV2Nbde7l5wBQqJCXwxDlNi3rvhEOWnBjLU+c24/IPJvDiTwu459TwGZZun7XbdnPDp5OZsHQT13SqxV2d64fbfH+5KbKZHKriY6JpVrUUzaqW+uc+5xybd+5l+cadLN+4kxWbdrLC//OUFZsYPmM1Wdnun+Vjo40qpYqRmqNhMGcjYXKx0H+/+W3eWm76bArF4qL54tp2tEgt5XVJYSUhNprXL2rFma+Oonf/SXxzfQeKxYXmhRfOOfoOm0XZ4nHcHEHDRB8G5bGISGhQHheys1tW4env5vLJmGUBbwD8bPxykhJiOKNZpYCuV0QKV0HmAHxr389m9q1z7ozgliQiIrkpanm8eWcGI2b8zZCpKxm/dCPOQYvUUvQ9sxGnN6tMSsl4r0ssNFVLJ/LWJWn8Nm8tfYfO4uL3xnF6s0o8cHpDKiWH9rCgzjke+GYmqzbvZuC1R4fFyfNQdHz98lzQNpW3/1zEyY3K07p6Ga9LKrApyzfRu/8ktuzay8sXtKRr88joiVTUMjlcmRmli8dRungczXNpCMvMymb1lt3/NBDuu6Vv3MmIGavZtHPvfssnJcRQrez+jYP7ehJWLlXM0x7azjk+GL2Ux4bPpkHFJN7rlRby7xGhKrVMIv16tODyDydw/+AZPN+9eUhevDJk6iomLdvE0+c2JSlCL4YqCOWxiEhoUB4XvhLxMZzXuiqfjVvO/ac3pFyJwJwn2bB9D9/PXM3FR1fX/NEiYe5QJ8CoEpQqRETkUEVkHu/KyOLnOWsYMnUVf8xfy94sR62U4tx6Uj26tahM9bKhPQxXsB1fvzztbinL238u5rXfFvLb3LX0ObEuVxxTk9gQ7U01aFI6Q6et4o5T6oVVo1Uouv/0RoxcsJ7bB05jRJ+OJMaF/jxmX0xYzoODZ1EhOZ6vr+tAo8oRO3dERGZyURATHeUf/jORDrk8vnX3XlZs3MmKjbv+6Tm4fONO5q7exs+z15KRlf3PslEGlZKLkVqm2AFDi/p+Lls8LmiNSHuzsnlo6Cw+G7ecUxpVoF/PFmGREaHsuPrl6XNiXfr9vIBW1Upz8dHVvS5pPzv2ZPLkd3NoWiWZ7q01tHYOymMRkdCgPC4kFx9dnQ//WsoXE1Zww/F1ArLOQZPS2ZvluOioagFZn4h451C/FU4JShUiInKoIiaPM7OyGb1oA0OmrOSHWX+zIyOLCknx9Gpfg24tqtC4clJIXnXvlYTYaG4+sS5ntajCw8Nm8eR3cxk0KZ2HuzWmfe3QGhZ00brtPDR0FkfXKsN1xwXmi0hRViI+hue6N6fn22N5+ru5PNytidcl5SkjM5uHh83i03HL6Vi3HC/3bEnpMJ7vrwAiJpNlf0kJsTSunEzjysn/eSw727Fm226Wb9g3vOi/jYS/zVvHum179ls+MS7630bB0olUK1Psn96EVUsnHvbV1Vt27uX6zyYxeuEGrjuuNneeUp+oCJjHMBTcfEJdpq7YzMPDZtG4chItAzy01pF4/feFrNm6h9cvaqXXe3/KYxGR0KA8LiR1ypfgmDrl6D92Gdd2qnXEUy1kZzs+G7+ctjXLUKd8yQBVKSJeybMB0MwSgN5AHWAG8J5z7orCKkxERHwiMY+dc0xZsZmhU1fx7fRVrN+eQcmEGM5oVpluLStzVM2yROtkVr6qlU3kvV5t+Hn2GvoOm8WF74yja/PKPHB6Q8onJXhdHnsys7j58ynEx0TRr0dLvZ4BcnStslzRoSbvj17CKY0r0qFOaDX6AqzdupvrPp3MpGWb6H1sbe7sXD+iXv9IzGQ5PFFRRqXkYlRKLsZRtcr+5/FdGVmkb9p/aNEVG3exfMNORi1Yz669WfstX75kfK49B6uVSaR8yfhcG3mWrN/BlR9OYMWmnTzXvTnnta4atP0tiqKijH49WnDGK6O4/tPJfHvTMZQN0NBaR2L5hp28M3IJZ7esUqR71yuPRURCg/LYe5e0q861n0zi5zlr6dKk4hGt669FG1i2YSe3nVwvQNWJiJfy6wH4EbAXGAmcCjQC+hRGUSIisp+IyeNlG3YwaFI6Q6auYvnGncTFRHFSw/J0bV6F4xukEB+jseUP1UmNKnBM3XK8/ttC3vxjMb/OXcstJ9WlV/saR3zl35F4+rt5zFq1lXcvTaNisvcNkpHkri71+X3+Wu78chrf39oppOZ9mrRsE9f1n8S23Zm8emFLzmgWGfP9HSBiMlmCq1hcNHUrlKRuhf9eOe2cY/32DN98g5t2/tOLcPnGnYxdvIFvpq7EuX+Xj4uJomrpf4cWrVYmkcS4GJ7+fi7RUcZnVx9NmxpFtyEomEolxvHmxa05542/6DNgKh9d0dbzixoeGz6bmCjjnlMbeFpHCFAei4iEBuWxx05sUJ4qpYrx8ZilR9wA+Nn4ZZROjD3i9YhIaMivAbCRc64pgJm9B4wvnJJEROQAEZPHYxdv4LXfFtK+djluOqEOnZtUDKnGi3CVEBvNbafU55xWVXlo6CweGz6HQZPSeaRbE9rWLPwTwr/OXcP7o5fQq30NTmpUodC3H+kSYqN5vntzzn3jLx4dNptnuzf3uiQAPhu3nIeGzqRScjE+vrItDSpG7Hx/EZPJ4h0zI6VkPCkl42ld/b/DSu7JzGLV5t3/NAqm5+hFOGnpJrbtyQSgbvkSvHdZG6qVTSzsXShSmlRJ5rFuTbjrq+m88NM87uzsXcPbyAXr+HH2Gu7sXJ8KIdDj32PKYxGR0KA89lhMdBQXHlWNZ3+Yx8K12w576M6123bz46w1XN6hhi7QFokQ+TUA7t33g3MuU/MviYh4JmLy+IxmlTm+fvmQGKIyEtUoV5wPL2/DD7PW8Oi3szn/rTGc06oK957akJSShTNk2Zqtu7njy+k0rJSknglB1LJaaa47rjav/baIzo0retrQuiczi75DZ/H5+BV0qpfCyz1bUCoxouf7i5hMltAVHxNNzXLFqVmu+H8ec86xZddeVm3eTa2U4oc9d6AcmvPbpDJ5+SZe+20RLVJLc7IHubs3K5uHh82mWplErjymZqFvPwQpj0VEQoPyOAT0bJPKSz8v4OMxy3jkMOeL/3JiOpnZjgvaVgtwdSLilfzGBmtuZlv9t21As30/m9nWwipQREQiJ4+Lx8eo8S/IzIwuTSry022duOH42gybtooTnv+dj/5aSmZWdlC3nZXtuPWLqezKyOKVC1rqpHSQ9TmxHg0qluSer2ewaUeGJzWs2bqbnm+P5fPxK7j+uNp80KtNpDf+QQRlsoQnM6NUYhyNKicpZwtZ366NaVolmdsGTmXp+h2Fvv1Pxixj4drtPHB6Q732PspjEZHQoDwOAWVLxHNGs0p8NSmdbbv3HvwJB8jKdnw+fjnta5elVkqJIFQoIl7IswHQORftnEvy30o652Jy/ByxYzqJiIQa5bEcjsS4GO7s3IDvb+lE86qleGjoLLq+OppJyzYFbZtv/bmIvxZtoG/XRtQpry8MwRYXE8UL57dgy64MHhwys9C3P3HpRs54ZRTz/t7G6xe14q4uDTyfF6swKJNFiq6E2Ghev6gV0VFG7/6T2JWRVWjb3rB9Dy/+PJ+Odct50vswFCmPRURCg/I4dFzavgY7MrL4ZsrKQ37unwvWkb5pFxcepd5/IpEkvx6AR8zMupjZPDNbaGb35PL4bWY228ymm9kvZlY9mPWIiBRVyuOiq3ZKCT65si2vXdiKjTsyOPeNv7hr0DQ2bN8T0O1MXr6J53+cz+nNKnF+WmpA1y15a1Q5iVtOqse301czbNqqQtmmc45Pxi6j59tjKR4XzeAbOnBa00qFsu1IoDwWCW+pZRLp16MF89Zs4/7BM3DOFcp2n/txPjszsvjfGY3Q0GqBo0wWEQkNyuPAaJFaimZVk/l4zLJD/ozy2bjllCsRxymNKgapOhHxQtAaAM0sGngNOBVoBFxgZo0OWGwKkOacawYMAp4JVj0iIkWV8ljMjNObVeKX24/l2k61+HrySo5/7nc+GbuMrOwjP3G5dfdebv58CpWSE3ji7KY6MVnIru1UixappXhwyEzWbt0d1G3t3pvF3V9N58HBM+lYtxxDbjyGehUOb4L5okh5LBIZjqtfnj4n1uXrySv5dNzyoG9v5sotDJiwnMva1aCuMjdglMkiIqFBeRxYl7arwcK12xmzaEOBn/P3lt38Onct3dNSiYsJan8hESlkwfwf3RZY6Jxb7JzLAAYA3XIu4Jz7zTm30//rWKBqEOsRESmqlMcC+OZgvPe0hnzXpyONKifx4OCZnPXaaKau2HzY63TOcd/XM1i9ZTcv9WxJcrHYwBUsBRITHcXz5zdnV0YW934dvN4oq7fsosdbYxg4MZ2bT6jDe5e10et96JTHIhHi5hPqclz9FB4ZNvuI3kcPxjnHw8NmUSYxjj4n1Q3adoooZbKISGhQHgfQGc0qUToxlo/GLC3wc76YsIKsbMcFbTT8p0ikCWYDYBVgRY7f0/335eVK4Lsg1iMiUlQpj2U/dSuU5POrj+alni1Ys3U3Z78+mnu/ns6mHRmHvK4vJ6Xz7fTV3HZyPVpXLx2EaqUgaqeU4O4uDfhl7lq+nJQe8PWPW7yBM18ZxcK123nz4tbcdkp9oorAfH9BoDwWiRBRUUa/Hi0onxTP9f0nBXxo7X2GTV/NhKWbuKNzfV10EXjKZBGR0KA8DqCE2Gh6tKnGT7PXsHLzroMun5mVzYAJy+lYtxzVyiYWQoUiUphCok+vmV0MpAHP5vH4NWY20cwmrlu3rnCLExEpQpTHRYeZ0a1FFX65/Viu6FCTgRPTOf753/l8/HKyCzgs6MK123loyCza1y5L72NrB7liOZhe7WtwVM0yPDJsNumbdh78CQXgnOOjv5Zy0bvjSEqIZciNHejSRHNCFIaD5bF/GWWyiIdKJcbx5sWtWb8jgz4DpgZkWO2cdmZk8sTwOTSunKT5dT2mz8giIqFBeVwwFx1VDQd8Nm7ZQZf9fd46Vm/ZzUVHaVpFkUgUzAbAlUDObylV/fftx8xOAu4Hujrncr1s0jn3tnMuzTmXlpKSEpRiRUQimPJY8lQyIZYHz2jE8JuPoV75ktz79QzOfuMvZqRvyfd5u/dmcdPnU0iIjeLFHi2IVm8wz0VFGc91b45zjrsGTS9wQ25edu/N4o4vp/PQ0FkcVz+FwTd2oE55zT11hAKWx6BMFgkFTaok82i3xoxauJ4XfpoX0HW/8fsi/t66m75dG+t9Njj0GVlEJDQojwMstUwiJzaowIDxK9iTmZXvsp+NX075kvGc2LB8IVUnIoUpmA2AE4C6ZlbTzOKAnsDQnAuYWUvgLXzBvTaItYiIFGXKYzmoBhWT+OLao3nh/Oas3LSTrq+N4sHBM9myc2+uyz/9/VzmrN7Kc92bUyEpoZCrlbyklknkgTMa8deiDXwy9uBXe+Zl5eZddH9zDF9NTueWk+ry9iVpJCVo6LkAUB6LRKAebarRIy2V135bxE+z1wRknSs27uStPxfTtXll2tQoE5B1yn8ok0VEQoPyOAgubVedDTsyGDFjdZ7LpG/ayW/z1tKjTSqx0SExUKCIBFjQ/mc75zKBG4EfgDnAQOfcLDN7xMy6+hd7FigBfGlmU81saB6rExGRw6Q8loIyM85pVZVfbj+Oy9rV4NNxyzjh+d/5cuKK/XqT/TJnDR+MXsrlHWpwYsMKHlYsuenZJpXj6qfw5HdzWLJ+xyE/f8wi33x/S9fv4J1L07jlpHqa7y9AlMcikevhbo1pUiWJ2wZOZelhZO+BHh8+h2gz7j2tQQCqk9wok0VEQoPyODiOqVOOWuWK8/GYvC8M/WLCCgzo2bZa4RUmIoXKnAvsPAXBlpaW5iZOnOh1GSIiAWFmk5xzaV7XcTiUx5Fv1qotPDh4JpOXb6Z19dI80q0x5UrE06Xfn1RKLsY3N7QnPiba6zIlF2u27uaUF/+kdkpxvuzdvkBDxznn+GD0Uh4fMYcaZRN5+9I0aqeUKIRqQ0M45zEok0VCwYqNOznjlVFUSk7gm+s7UCzu8N4j/1q4ngvfHccdp9TjxhPqBrjK0Kc8FhEJDcrj8Pf+qCU88u1sht14DE2rJu/32N6sbDo89StNqiTzfq82HlUoIgV1uJmsvr0iIiKSq8aVkxnUuz3PnNeMJet3cOYrozj3jb/YvTebly9oqca/EFYhKYFHujVm8vLNvP3n4oMuvysji9sGTuORb2dzYoPyDL6hQ5Fq/BMRCYTUMon069mCeWu2cf/gGRzOxbaZWdn0HTaL1DLFuKpjrSBUKSIiIkXFua2rkhgXzcdjlv7nsV/mrGXttj1cqN5/IhFNDYAiIiKSp6go4/y0VH69/VguOqo6q7fs5pFujalTXo1Doa5r88qc2qQiL/40n7l/b81zuRUbd3Lem38xeOpKbj+5Hm9e3JqSmu9PROSwHF+/PH1OrMvXk1fy6bjlh/z8/mOXMX/Ndu4/rREJsbrQRkRERA5fcrFYzm5ZhaHTVrFpR8Z+j306bhmVkxM4vkF5j6oTkcKgBkARERE5qFKJcTx6VhNmP9KZ7mmpXpcjBWBmPHZWE5KKxXD7wGlkZGb/Z5nRC9fT9dVRLN+4k/cuS+OmE+tqvj8RkSN08wl1Oa5+Co8Mm83UFZsL/LyNOzJ44af5dKhTls6NNceuiIiIHLlL29VgT2Y2Ayeu+Oe+5Rt2MnLBenq0qVag6SJEJHypAVBEREQKTMN+hpeyJeJ5/OymzFq1lVd/W/jP/c453h25mEveG0e5EvEMvfEYTmigk80iIoEQFWX069GC8knxXN9/EhsPuOI+L8//OI8dGVk8dGZjzHQyTkRERI5c/YolOapmGT4Zu4ysbN/w5J9PWE50lNGjjS7uFYl0agAUERERiWCdG1fknFZVeO23hUxbsZldGVn0GTCVx4bPoXPjinxzQwdqlivudZkiIhGlVGIcb17cmvU7Mrj58yn/nHDLy+xVW/l8/HIuObo69SqULKQqRUREpCi4tF0N0jft4vd5a8nIzObLiSs4oUF5KiYneF2aiARZjNcFiIiIiEhwPXRmY8Ys2sCtA6cSHxPN3L+3cmfn+lx/XG31MhERCZImVZJ5tFtj7v5qBi/+NJ87OtfPdTnnHH2HzSK5WCy3nlSvkKsUERGRSHdK4wpUSIrnozHL2LU3i/XbM7joqGpelyUihUA9AEVEREQiXHKxWJ4+txmL1+1g5aadvN+rDTccX0eNfyIiQdajTTV6pKXy6m8L+Wn2mlyXGT5jNeOXbOSOzvVJTowt5ApFREQk0sVGR3Fh2+r8OX8dL/28gKqli9GpborXZYlIIVADoIiIiEgR0KleCh9d0ZbhN3fk+PrlvS5HRKTIeLhbY5pUSeK2gVNZun7Hfo/tysjiieFzaFQpiZ5tdCW+iIiIBMcFR6USG20sWLudC9pWIypKF4OKFAVqABQREREpIo6tl0JqmUSvyxARKVISYqN546LWRJnRu/8kdmVk/fPYG38sYtWW3fTt2phonYgTERGRIClfMoFTm1QiNtronlbV63JEpJCoAVBEREREREQkiFLLJNKvZwvmrdnG/YNn4JwjfdNO3vpjEWc0q0TbmmW8LlFEREQi3MNdGzOod3vKl0zwuhQRKSQxXhcgIiIiIiIiEumOr1+em0+oy0u/LKBVtdL8tWg9ZnDfaQ29Lk1ERESKgNLF4yhdPM7rMkSkEKkBUERERERERKQQ9DmxLlNXbKbv0FlkZjtuPakelUsV87osERERERGJQBoCVERERERERKQQREUZL/VsQcXkBKqWLsa1x9byuiQREREREYlQ6gEoIiIiIiIiUkhKJcYx/OaOZGU7EmKjvS5HREREREQilBoARURERERERApRcrFYr0sQEREREZEIpyFARURERERERERERERERCKIGgBFREREREREREREREREIogaAEVEREREREREREREREQiiBoARURERERERERERERERCKIGgBFREREREREREREREREIogaAEVEREREREREREREREQiiBoARURERERERERERERERCKIGgBFREREREREREREREREIkhQGwDNrIuZzTOzhWZ2Ty6Px5vZF/7Hx5lZjWDWIyJSVCmPRURCg/JYRCR0KJNFREKD8lhEJDiC1gBoZtHAa8CpQCPgAjNrdMBiVwKbnHN1gBeBp4NVj4hIUaU8FhEJDcpjEZHQoUwWEQkNymMRkeAJZg/AtsBC59xi51wGMADodsAy3YCP/D8PAk40MwtiTSIiRZHyWEQkNCiPRURChzJZRCQ0KI9FRIIkmA2AVYAVOX5P99+X6zLOuUxgC1D2wBWZ2TVmNtHMJq5bty5I5YqIRCzlsYhIaAhYHoMyWUTkCOkzsohIaFAei4gESVDnAAwU59zbzrk051xaSkqK1+WIiBRZymMRkdChTBYRCQ3KYxGR0KA8FhHZXzAbAFcCqTl+r+q/L9dlzCwGSAY2BLEmEZGiSHksIhIalMciIqFDmSwiEhqUxyIiQRLMBsAJQF0zq2lmcUBPYOgBywwFLvP/fB7wq3POBbEmEZGiSHksIhIalMciIqFDmSwiEhqUxyIiQRITrBU75zLN7EbgByAaeN85N8vMHgEmOueGAu8Bn5jZQmAjvoAXEZEAUh6LiIQG5bGISOhQJouIhAblsYhI8AStARDAOTcCGHHAff/L8fNuoHswaxAREeWxiEioUB6LiIQOZbKISGhQHouIBEcwhwAVERERERERERERERERkUKmBkARERERERERERERERGRCKIGQBEREREREREREREREZEIogZAERERERERERERERERkQiiBkARERERERERERERERGRCKIGQBEREREREREREREREZEIogZAERERERERERERERERkQiiBkARERERERERERERERGRCKIGQBEREREREREREREREZEIYs45r2s4JGa2Dlh2GE8tB6wPcDmhRPsX3iJ9/yDy9/Fw96+6cy4l0MUUBuVxniJ9/yDy91H7F96KXB6DMjkf2r/wpv0Lb8rjQ6O/h/Cm/Qtv2r/cKY8jk/YvvEX6/kHk72OhZnLYNQAeLjOb6JxL87qOYNH+hbdI3z+I/H2M9P0LpEg/VpG+fxD5+6j9C2+Rvn+BFunHS/sX3rR/4S3S9y/QIv14af/Cm/YvvEX6/gVapB8v7V94i/T9g8jfx8LePw0BKiIiIiIiIiIiIiIiIhJB1AAoIiIiIiIiIiIiIiIiEkGKUgPg214XEGTav/AW6fsHkb+Pkb5/gRTpxyrS9w8ifx+1f+Et0vcv0CL9eGn/wpv2L7xF+v4FWqQfL+1feNP+hbdI379Ai/Tjpf0Lb5G+fxD5+1io+1dk5gAUERERERERERERERERKQqKUg9AERERERERERERERERkYinBkARERERERERERERERGRCBLxDYBm9r6ZrTWzmV7XEgxmlmpmv5nZbDObZWZ9vK4pkMwswczGm9k0//497HVNwWBm0WY2xcy+9bqWQDOzpWY2w8ymmtlEr+sJNDMrZWaDzGyumc0xs3Ze1xSqlMfhTXkc/pTHklMkZ7LyODJEch6DMln+Fcl5DMrkSKA8Dm/K44JTHoe3opDHENmZrDwO0nYjfQ5AM+sEbAc+ds418bqeQDOzSkAl59xkMysJTALOcs7N9ri0gDAzA4o757abWSwwCujjnBvrcWkBZWa3AWlAknPuDK/rCSQzWwqkOefWe11LMJjZR8BI59y7ZhYHJDrnNntcVkhSHoc35XH4Ux5LTpGcycrjyBDJeQzKZPlXJOcxKJMjgfI4vCmPC055HN6KQh5DZGey8jg4Ir4HoHPuT2Cj13UEi3NutXNusv/nbcAcoIq3VQWO89nu/zXWf4uoVmszqwqcDrzrdS1yaMwsGegEvAfgnMvQB+m8KY/Dm/JYQpny+NBFciYrj8Of8ji8KZMPTSTnMSiTw53yOLwpjw+N8ji8RXoegzI5nHmZxxHfAFiUmFkNoCUwzuNSAsrftXkqsBb4yTkXUfsH9APuArI9riNYHPCjmU0ys2u8LibAagLrgA/83e/fNbPiXhcl3lMeh61+KI/DlfJYcqU8Dlv9iOw8BmWyFEHK5LDUD+VxOFMeS66Ux2GrH5GdycrjIFADYIQwsxLAV8AtzrmtXtcTSM65LOdcC6Aq0NbMIqYbvpmdAax1zk3yupYgOsY51wo4FbjBP6RCpIgBWgFvOOdaAjuAe7wtSbymPA5PyuOwpzyW/1Aeh6ciksegTJYiRpkcfpTHEUF5LP+hPA5PRSSTlcdBoAbACOAf1/gr4FPn3Nde1xMs/m6xvwFdPC4lkDoAXf1jHA8ATjCz/t6WFFjOuZX+f9cC3wBtva0ooNKB9BxXFA3CF+ZSRCmPw5ryOLwpj2U/yuOwFvF5DMpkKVqUyWFLeRz+lMeyH+VxWIv4TFYeB4caAMOcf4LT94A5zrkXvK4n0MwsxcxK+X8uBpwMzPW0qAByzt3rnKvqnKsB9AR+dc5d7HFZAWNmxf0TC+Pv1nwKMNPbqgLHOfc3sMLM6vvvOhGIiMmT5dApj8Ob8ji8KY8lJ+VxeIv0PAZlshQtyuTwpTwOf8pjyUl5HN4iPZOVx8ETUxgb8ZKZfQ4cB5Qzs3TgIefce95WFVAdgEuAGf4xjgHuc86N8K6kgKoEfGRm0fgarAc65771uCYpuArAN77PGMQAnznnvve2pIC7CfjUzOKAxcDlHtcTspTHYU95HN6Ux7KfCM9k5bGEOmWy/CPC8xiUyRLalMfyD+Vx2FMehzflcZCYc64wtiMiIiIiIiIiIiIiIiIihUBDgIqIiIiIiIiIiIiIiIhEEDUAioiIiIiIiIiIiIiIiEQQNQCKiIiIiIiIiIiIiIiIRBA1AIqIiIiIiIiIiIiIiIhEEDUAioiIiIiIiIiIiIiIiEQQNQDKQZnZi2Z2S47ffzCzd3P8/ryZ3XYY6/3QzM4LUI2VzWxQINaVx/pbmNkYM5tlZtPNrEeOx2qa2TgzW2hmX5hZnP/+28xstn/5X8yseo7nXGZmC/y3y/LYZlkz+83MtpvZqwc89riZrTCz7QepO9flzKyXma0zs6n+21WHc1xEpHApj5XHIhIalMfKYxEJHcpkZbKIhAblsfJYQo8aAKUgRgPtAcwsCigHNM7xeHvgLw/q+odzbpVzLiBvBHnYCVzqnGsMdAH6mVkp/2NPAy865+oAm4Ar/fdPAdKcc82AQcAzAGZWBngIOApoCzxkZqVz2eZu4EHgjlweG+Z/7sHkt9wXzrkW/tu7eSwjIqFFeaw8FpHQoDxWHotI6FAmK5NFJDQoj5XHEmLUACgF8RfQzv9zY2AmsM3MSptZPNAQmGxmrc3sDzOb5L/CoxKAmdU2s+/99480swYHbsDMHvVfzRFtZk/luOrhuVyWPTbHVQdTzKykmdUws5n+x3uZ2df+bS4ws2dyPLeLmU02s2lm9ov/vuJm9r6Zjfevr9uB23TOzXfOLfD/vApYC6SYmQEn4AtngI+As/zL/eac2+m/fyxQ1f9zZ+An59xG59wm4Cd8bwgHbnOHc24UvhA/8LGxzrnVB95/uMuJSNhQHiuPRSQ0KI+VxyISOpTJymQRCQ3KY+WxhJgYrwuQ0OecW2VmmWZWDd+VGmOAKvgCfQswA3DAK0A359w683Vvfhy4Angb6O2cW2BmRwGv4ws8AMzsWaAkcDlQBjgbaOCcc/bvFRI53QHc4JwbbWYlyCXcgBZAS2APMM/MXvEv9w7QyTm3xHxXUQDcD/zqnLvCv73xZvazc25HbsfDzNoCccAioCyw2TmX6X843X9sDnQl8J3/5yrAihyP5fWcYDvXzDoB84FbnXMrDvYEEfGW8nh/ymMR8YryeH/KYxHxkjJ5f8pkEfGK8nh/ymMJBWoAlIL6C19wtwdewBc27fGF92igPtAE+Ml3QQPRwGp/uLYHvvTfDxCfY70PAuOcc9cAmNkWfCH7npl9C3ybSy2jgRfM7FPga+dceo517/OLc26Lf52zgepAaeBP59wSAOfcRv+ypwBdzWxfN+kEoBow58CV+q9I+QS4zDmXnct2/8PMLgbSgGMPunDhGQZ87pzbY2bX4rvq5ISDPEdEQoPyGOWxiIQE5THKYxEJGcpklMkiEhKUxyiPJXRoCFApqH1jODfF1317LL6rN/aN3WzALPfveMBNnXOn4Psb25zj/hbOuYY51jsBaL3vSgr/VRBt8XWHPgP4/sBCnHNPAVcBxYDRlkt3cHxXbeyTRf6N3Qacm6O+as653II7CRgO3O+cG+u/ewNQysz2rb8qsDLHc07Cd3VIV+fcvppWAqk5Vl0VWGlmZ9u/3dLT8qk3953wdX3f9/xH8lvWObchRz3vAq0PdXsi4hnlsfJYREKD8lh5LCKhQ5msTBaR0KA8Vh5LCFEDoBTUX/jCdKNzLst/5UMpfAH+FzAP33jG7QDMLNbMGjvntgJLzKy7/34zs+Y51vs98BQw3HzjMJcAkp1zI4BbgZzL4l9HbefcDOfc0/jCP7fwzs1YoJOZ1fSvZ1/37R+Am8x/KYaZtcxlm3HAN8DHzrl9YzXjnHPAb8C+yWMvA4bkWM9b+IJ7bY7V/QCcYr7xr0vju3rkB+fcNzneQCYWcJ/+4X9d9j3/f/kt678KZZ+u5HKlioiELOWx8lhEQoPyWHksIqFDmaxMFpHQoDxWHksIUQOgFNQMoBy+AMx53xbn3HrnXAa+AHvazKYBU/Fd2QFwEXCl//5ZwH4TpDrnvsQ3rvJQfOM4f2tm04FRwG251HKLmc30L7OXf8dFzpdzbh1wDfC1v5Yv/A89CsQC081slv/3A50PdAJ65bhCooX/sbuB28xsIb7xnN/z3/8sUAJf1/WpZjbUX8dG/zYm+G+PuH+7ku/HzJbi6y7fy8zSzayR//5nzCwdSPTf3zeP5+e13M1mNst/HG4GeuV54EQk1CiPlcciEhqUx8pjEQkdymRlsoiEBuWx8lhCiPkan0VEREREREREREREREQkEqgHoIiIiIiIiIiIiIiIiEgEUQOgiIiIiIiIiIiIiIiISARRA6CIiIiIiIiIiIiIiIhIBFEDoIiIiIiIiIiIiIiIiEgEUQOgiIiIiIiIiIiIiIiISARRA6CIiIiIiIiIiIiIiIhIBFEDoIiIiIiIiIiIiIiIiEgEUQOgiIiIiIiIiIiIiIiISARRA6CIiIiIiIiIiIiIiIhIBFEDoIiIiIiIiIiIiIiIiEgEUQOgiIiIiIiIiIiIiIiISARRA6CIiIiIiIiIiIiIiIhIBFEDoMgBzKyjmc3L8Xt9M5tqZtvM7OYCruM6M1tjZtvNrGzwqhURERERERGRUPwub2azzOy4I12PeMPMlprZSV7XIRLuQjGfg83MPjSzx7yuQ3z8fze1/D8XqddGDYCSK/+HnF3+/xz7bpUDsM5C++BkZn3NbK//zWSbmc03s1fNrFJ+z3POjXTO1c9x113Ab865ks65lw+2H2YWC7wAnOKcK+Gc2xCYPTp0RS3QRCR8FMUvACIiwRQJuZrzc7b/s3z/wq5BJNzpu3xofZd3zjV2zv1+pOspKtTgJpFM+Rxa+Xyox64o51MkfC73/90s9roOL6gBUPJzpv8/x77bKi+LMbOYw3jaF865kkAZ4GygIjAprzemPLZRHZh1CNusACQc4nP2bd/MrND+Xx7mMRWRANEXgND6AnAozKyGmblA5GhR/iIhEmjK1dDKVeXbwfnfS+p4XYdEHH2X94nY7/K5bF/f7Q9DYR03r/8+JKQon32KTD7L4dHrFjg6iHJIzCzZzN4zs9VmttLMHjOzaP9jtc3sVzPbYGbrzexTMyvlf+wToBowzH8i5i4zO87M0g9Y/4FX/Q4ys/5mthXold/28+Oc2+ucmwX0ANYBt/u3cZyZpZvZ3Wb2N/BBzrrM7FfgeOBVf92fH7gfB9RfD9h35fVm//Mxs/ZmNsHMtvj/bZ/jOb+b2eNmNhrYCdTK5bhXNrOvzGydmS0x/1XcZlbGX/+Z/t9LmNlCM7vUzK4BLgLu8tc6LMcxvtvMpgM7zCzGzO4xs0X+k0yzzezsgx1TEQkYfQHw0RcAEQkU5aqPclVE/qHv8p59lz/wuHzpPy7bzGyGmdUzs3vNbK2ZrTCzUw5Y/5NmNt7MtprZEDMr439s38VoV5rZcuBXM4syswfMbJl/fR+bWbJ/+e/M7MYDaptmZuf4f25gZj+Z2UYzm2dm5+dY7kMze92/ju1mNtrMKppZPzPbZGZzzaxljuVzPX+R4xgM9Ne2zXxDpKb5H/vP31pefxdmluA/jhvMbLP/talw4DHPsc3+eR03//1Xm9kc+/ecSKscm2thZtP9fwNfmFmC/zmlzexb/35u8v9cNb+/DzM7xX98t/iP6R9mdlWO51zhr2OTmf1gZtXzOgYSOUz5XOj5nFfemFlXfy5t9q+j4UGW/9LM/vbX8KeZNT7YcTugjoLkyGNm9pd/u8PMrKz/72Crf79r5Fg+v2NSkGy8zMyW+//W7vc/1gW4D+jhr2HaQfYpz/cu/+NH+/dns/neh4474Ln5vq8ewbHJ86I7MzvDfCOnbPavr1l++xh2nHO66fafG7AUOCmX+78B3gKKA+WB8cC1/sfqACcD8UAK8CfQL691AscB6XltF+gL7AXOwtdYXSy/7edSa1+gfy73PwKMy1FDJvC0v+5iB9YF/A5cdbBjk+PxGoADYvy/lwE2AZcAMcAF/t/L5lj/cqCx//HYA9YXBUwC/gfE4Qu/xUBn/+OnAH/7j8c7wKAcz/0QeCyXYzwVSAWK+e/rDlT2b6sHsAOo5PXfoW66Rfotn6xNBt4DVgMrgceAaP9jtfF9Ud0ArAc+BUr5H/sEyAZ2Advx9f4oSNYOAvoDW4Gr8tt+LrX+J2uBaGAa8Jz/9+OAdOBuf159krMu//5kAbv9dX9+4H4csP56/pxy/sd/9d/fHpgAbPH/2z7Hc34HHgdG+9dbJ4/X405gun/97+E7If4dsA34GSjtX3Z5ju1vB9rl99rk8zfwn9fMf/+X/mO1Bd/7aWP//XH4MvymHMd6NPA/r/+eddMtFG4oV0MmV/PJt674Ghk3+9fRMJ/j2N//c4L/eG7wP28CUOEgfwuXA3Pw5fdicnxnyHH87gLW+l+Xs4DTgPnARuC+HMvHA/2AVf5bPyDe/1gvYNQB23b7jge+z+OvAcP9tYwDavsf+9O/7A7/Merh9f8h3cL/hr7Lh8x3+TyOy26gs3/5j4ElwP1ALHA1sOSA+lcCTfzH7Sv+zcV9tX7sf6wYcAWwEN85gxLA18An/uUvBUbnWHcjfHka73/+Cny5GQO0xPd+2Mi/7If+31vjy+Nf/XVfiu/96TF8Pc7h4Ocv9h2D0/zPfRIYW9DXKMdy1wLDgET/eloDSXn8vfY9yHHr7j/ObQDD9/+heo51jcd3vqQMvveV3v7HygLn+msoie/z++ADXr+cfx8p+D4XnOP/vQ++/ydX+Zfv5n/9GvoffwD4y+tM0S1wt7z+vlE+53lscjy+7/9uUPLZ//u+z8Mn48vku/z/J+PyqhFf7pbk38+KU3M89iEHnJPNpYaC5MhCfN9XkoHZ+D6rnsS/7yMfFPCYHLi//7yWOY7vO/7XqzmwB//n9Lxe9zz26Xfyfu+qgu/z/Gn4/v5O9v+eUtDX7XCOjX/5Az+fP+b/uSW+7wNH4Xs/ucx/rOK9zoxA3XSVpuRnsL/le7OZDTbf1VSnAbc453Y459YCLwI9AZxzC51zPznn9jjn1uEbQujYI6xhjHNusHMuG0jKb/uHYBW+UNwnG3jIX/euI6w3N6cDC5xznzjnMp1znwNzgTNzLPOhc26W//G9Bzy/Db4gfMQ5l+F84xW/w7/H/Ud8bxC/4Ds+1xagppedcyv27a9z7kvn3CrnXLZz7gtgAdD2CPZZRI7Mh/g+MNfB92HkFHwnkMH3pfRJfF9CG+JrzO8L4Jy7BN+HpX29X54p4Pa64TtZXQrfie/8tn9QzrksYAjQMcfdFfFlb3XgmgOWPwEYCdzor/uC/PbDOTcf3wdC8J2kP8F/Rdlw4GV8H6JfAIbb/nNYXeLfdklgWR7ln4vvQ2g9fDn9Hb6r3VLwfUDddwVzpxzbL+GcG0M+r01e8nnNvgPq4vsCNhnf64JzLgO4GHjEfzXiPfg+pD6e33ZERLma334EI1dzO3b+K7g/B27Bl6sj8F1JHXeQQ3AZvi/2qf5aeuNrWMzPWuAMfN8hLgdetP17dFTEdyK7Cr4T1e/gy9fW+I7zg2ZW07/s/cDRQAt8J0Ta4jsxW1A9gYeB0vhOVDwO4Jzb917S3H+MvjiEdYrkR9/lA+NIv8vnZqRz7gfnXCa+7/EpwFP+5w4Aapi/d4/fJ865mc65HcCDwPkH9Mzp6z+mu/CNAPSCc26xc247cC/Q03y9xL/B15Otuv95FwFfO+f24MvKpc65D/z7MQXfCdvuObbzjXNuknNut39du51zH/vfn77A994GBzl/4TfKOTfC/9xP8OXqodqL7/2gjnMuy1/b1kN4fs7jdhXwjHNugvNZ6JzL+Z72sv98yUZ8jY4tAJxzG5xzXznndjrntuHL9gP/3/zz9wGcCsxyzn3t//1lfBfx7NMbeNI5N8f/+BPs/5pJZFA+B0Yw8rkHMNx/vPcCz+FrDGuf1xOcc+8757b5s7Qv0Nz8Pa8LooA58oFzbpFzbgu+8wSLnHM/53gf2Ze/BTkmB/Owc26Xc24avosPDyefIe/3rouBEf73gGzn3E/ARHx/g/scyutW0GOTn2uAt5xz4/zvJx/ha/w8+tB2OXRpjHDJz1nOuZ/3/WJmbfFdAbHazPbdHYXvSjH8b1ov4fvCXNL/2KYjrGFFjp+r57f9Q1AF31W9+6zzf4gNlsr890TzMn8d++S3D9WByma2Ocd90fhO6uzzNnAj8IQr2Hwt+23PzC4FbsN3xQf4rhYsV4D1iMiRG2xmmf6ff8fXiH8avhOwu/AN1fsi/34oWYjv5CHAOjN7AXjoCGsY45wbDGBm+74A5Lr9Q1hnnl8A/Ns5wpL/458Pu/7fPzffcENn4jvxDv4PkgdZzyvOuTX+GkcCa/0nQTCzb4AT83piIF8b59z7+342s77AJjNLds5tcc7NNLPHgMH4Ggjb+k+giIiPcjUwApWrOf1zYgXAzJ7D1wOiPb7XKi85T/ROx9e7JF/OueE5fv3DzH7E9z1lco51Pu6cyzKzAfg+T7/kP/kyy8xm4zvpsQTfifKb/CfFMLOH8b12DxZor30nzsf7n/spvpN3IsGk7/KBcaTf5XOzJsfPu4D1OT7H7TtJXgJf77wD178M33HM+V095+MH1rsM33m/Cs65lWY2HN9J/afx9Qy52r9cdeCoA845xOBrnMur7gN/L5FjXQc7f5Gz0WsnkGBmMf4TtgX1Cb6LQgb4G0z7A/cX8CQ/7H/cUoFF+Sx7YL2VAcwsEV9DSRd8F3gAlDSz6Byv6YGvzz+/O+ec7T9UY3XgJTN7Psd9hu/vLa+LFyX8KJ8DIxj5vN86nXPZZrbigHX+w9+g9Ti+iyVS8H02B19GbynIBguYIwXN34Ick4M5MO9K5LXgQeT13lUd6G7+qaz8YoHf8njuwRT02OSnOnCZmd2U4744/FkfCdQAKIdiBb4W8HJ5fDB7Al932qbOuY1mdhbwao7H3QHL78DXxRn4JzhTDlgm53MOtv2DMt/cJGfiG8Ytr7oO5lCXX4UvTHKqBnxfwHWuwDcMSN3cHvQft7fxdW2+3sw+8J/Iym+9/9zvv5rsHXwntcf4T4JMxfdBU0SCT18AAiNQXwAO+wNkoF6bAn6R+Mi/zFfOuQWHug2RCKdcDQzPT6zkcMgnes3sVHwNufXwHe9EYEaORTbkctK9oCdUlnFoJwUCdTJF5HDpu/zhLX+k3+UDIfWAbe/FNxznvvtzbv/Aeqvh632+L9s+Bx4ysz/x9YDed8J1BfCHc+7kANSb7/mLAijQ8fTn/8PAw/45nkbgmyPsPQ74+8TX4zu/7azAN4TcobodqA8c5Zz728xaAFPY/1xKzu2sBnLO7WU5f/fX8bhz7tPDqEXCl/L58JYPRD4f+PgqoOm+X/z/R1PxDWeZ2/IX4hv14yR8Q0Ym4/sOcSjnUwuSIwV1sGNSkGzMy6G+Pnm9d63A1zvw6lyfdXjbOlL7sjdiR1XSEKBSYM651cCPwPNmlmS+CaZrm9m+rskl8c1dscXMquCbRymnNew/eed8fFd6nW5msfiG0Yk/gu3nycxi/EOlfY4v4I7kqtsD9+NgRgD1zOxCfx098I23/20Bnz8e2Ga+yXOLmVm0mTUxszb+x+/DF45XAM8CH+cYEqQgtRb3P38dgJldjm+cZhHxRs4P4KX8tyTn3L6h2XJ+AUjCN4RCXl8y4ci+AOS2/YPK8QUg55W+Xn0BWJnj90B+kMxtXQd7bQq6rpxfJJL5t3d2znW9ju99pLOZHVPwskWKJOXq4S0fiFzN7cTKP+vM5cRK7itxbq9z7mHnXCN8vQXPwDf3VK7MLB7f8HXP4ev5UgrfZ/LDvcAtt5Pqq/w/H/j3cCgnU0QKhb7L57kfB3Ok3+UD4WIza+TvJfIIMCifkR8+B241s5pmVgLf+9sXOU7qj8CXZY/47993kdm3+PbzEjOL9d/a+I/7oTrY+YuDKdBrZGbHm1lT/3vwVnwnl/ftz1R8Q5/GmlkacN5BVvcucIeZtTafOlawYTdL4rtYZLP5hs0+2OgBw4GmZnaW+YZlvYH9T8C/CdxrZo39+5hsZt1zWY9EEOVznvtxMIHI5wO3ORA43cxO9B+72/F9hv8rj+VL+h/fgO+z4BOHsO2c6ziUHMnPwY7JVA4tG3Nag2+I6oK2JeX13tUfONPMOvvfHxLM7Dgzq5r/6oLqHaC3mR3lfw8o7v//U9LDmgJKDYByqC7F1w12Nr6rGgYBlfyPPQy0wtc7YTi+CadzehJ4wHzjXN/hH5/3enwftlbi+/KcTv7y235uepjZdn9NQ/GFcmvn3Kp8nnMw++3HwRb2D8l5Br43jg34JpE9wzm3viAb8wfkGfjGmV+C74qJd4FkM2uNb+jOS/3LPY3vRMs9/qe/BzTy1zo4j/XPBp4HxuAL9KbA6ILUJiKBpy8Aee7HwRT2CZp1+E4yHPgFIL/XJi+H9EXCzC7BN0dVL3xzEn7kP8kjIrlQrua5HwfjxYmVXB3kRG9u4vC9JuuATPP1BjzlEOo+0Of4Pv+nmFk5fHMG9vc/Ng1obGYtzCyBg8z9motDfV1EDpe+yxfyd/kA+QTfsMt/4+u1d3M+y77vX/5PfOcOdgP/DGnmHzL6a3wXmX2W4/5t+DKyJ76LG/7Gd24hz/e2vOR3/qKAqyjoa1QR39/QVmAO8Af/Dln6IL4efZvw/W1/ltsKctT8Jb6RNT4DtuEbZr9Mfs/x64dvfrD1wFj273mU23bW4xvh4xl8f0+N8M19tcf/+Df4jvsAM9sKzMQ3b6BEPuWzN/l84LGbh+9CwFfw/b8+E99c1hl51PgxvlEhVuI7dmMPYdv79OMQciQ/BTgmh5SNB/jS/+8GM5uc75I+ub53OedW4LvY+T58n9NX4Pvu5VkblXNuIr4hsV/Fd2wW4jvXEjmcc7rppptuuummmwc3fMNEnJTL/cnAG/g+qG/BNwRET/9jjfHNfbQd3xVctwPpOZ7bDViOb96QO/z39cI35Mxa4I6c28V3orJ/QbefS6198Z2I3Y7vy8UCfL3TquRY5ricNeZ2H765n67Kbz8OeH4NfBc8xOS47xj/sdni//eYvNZfkNcD38ndvjl+vwr4Ocfvj+D70LoZ3wTR+b42+Wx3v33FNzTcEHwnIJbh+0LmgDr4ep1sADrkeP4XwDte/z3rplso3A78f5zjfuWqN7ma27E7G99Jki34Ttg2zu31y3kc8c1VNc9/PNYAL+esM49t3+BfdjO+kxADgMfyOFYx/n2vkeO+UcDF/p8T/Ntc7b+9DCTkWPZ+/h3W6GL/uur4H/tw33bz2HZv/zo3A+d7/X9IN910C51bQXJWt/C94TvhvQo43utadNNNN90CddN7V+jdzP/CiIiIiIiIiIiISAgws9/xXQjxrte1SGCYWWdgHL4h/+7Ed7FKLefcrnyfKCISJvTeFXo0BKiIiIiIiIiIiIiEDDO7yMy253Kb5XVtR6AdsIh/hxc8S41/IpHNzO7LI8u+87q2w5XH/mw3s47huJ1Ipx6AIiIiIkFkZtXwDXeXm0bOueWFWY+ISKTwzz+Tm1OdcyMLtRgREREREZEQowZAERERERERERERERERkQgS43UBh6pcuXKuRo0aXpchIhIQkyZNWu+cS/G6jsOhPBaRSBLOeQzKZBGJHMpjEZHQoDwWEQkdh5vJYdcAWKNGDSZOnOh1GSIiAWFmy7yu4XApj0UkkoRzHoMyWUQih/JYRCQ0KI9FRELH4WZyVKALERERERERERERERERERHvqAFQREREREREREREREREJIKoAVBEREREREREREREREQkgqgBUERERERERERERERERCSCqAFQREREREREREREREREJIKoAVBEREREREREREREREQkgqgBUERERERERERERERERCSCqAFQREREREREREREREREJIKoAVBEREREREREREREREQkgqgBUERERERERERERERERCSCqAFQREREREREREREREREJIIErQHQzN43s7VmNjOPx83MXjazhWY23cxaBasWEZGiTpksIhIalMciIqFBeSwiEhqUxyIiwRPMHoAfAl3yefxUoK7/dg3wRhBrEREp6j5EmSwiEgo+RHksIhIKPkR5LCISCj5EeSwiEhQxwVqxc+5PM6uRzyLdgI+dcw4Ya2alzKySc251sGoSESmqlMkiIqEhVPI4fdNOLv9gQsDWZxawVWEEcGUB4nCBW1fgViUS0lJKxvPZ1Ud7XUaeQiWPAR4eNovZq7YGerUiIgA0qpzEQ2c29rqMPIVSHouIRJqgNQAWQBVgRY7f0/33/Se8zewafFd4UK1atUIpTkSkiClQJiuPRUSCrlA+I8dFR1G3QonDrzKHQDZoBXRduIA2Jga0kTP02jhFAq50YpzXJRwpnbMQEQkNymMRkcPkZQNggTnn3gbeBkhLS9M1syIiHlEei4iEjiPJ5PJJCbx+Ueug1CUiUtQc6WfkUO6ZIyISTnTOQkRkf8GcA/BgVgKpOX6v6r9PREQKnzJZRCQ0KI9FREKD8lhEJDQoj0VEDpOXDYBDgUvN52hgi8ZuFhHxjDJZRCQ0KI9FREKD8lhEJDQoj6VAfpmzhjNfGcXYxRu8LkUkZARtCFAz+xw4DihnZunAQ0AsgHPuTWAEcBqwENgJXB6sWkREijplsohIaFAei4iEBuWxiEhoUB5LIOzMyOSBwTNZvWU3F74zlhuPr8PNJ9YlJtrL/k8i3gtaA6Bz7oKDPO6AG4K1fRER+ZcyWUQkNCiPRURCg/JYRCQ0KI8lEN78YzGrt+zmoyvaMmzaKl7+dSGjF22gX48WpJZJ9Lo8Ec+oCVxERERERERERERERMJO+qadvPXHIro2r8yx9VJ4rntzXurZgvl/b+O0l0cybNoqr0sU8YwaAEVEREREREREREREJOw8+d1czOCeUxv8c1+3FlUY0acjdcqX4KbPp3DXoGnszMj0sEoRb6gBUELeD7P+5sJ3xrJl516vSxERERERERERERGREDBu8QaGT1/NdcfWoXKpYvs9llomkYHXtuPG4+vw5aR0znh5FDNXbvGoUhFvqAFQQtrKzbu448tp/LVoA0//MNfrckTkCO3JzOL7mX97XYaIiIiIiIiIiISxrGxH32GzqVKqGNd0qpXrMrHRUdzRuT6fXnUUOzIyOfv10bw7cjHZ2a6QqxXxhhoAJWRlZzvuGDiN7GzHGc0q8dm45UxattHrskTkCHw4eim9+0/iz/nrvC5FRERERERERETC1BcTVjBn9VbuPa0BxeKi8122fe1yfN+nE8fVL89jw+dw+YcTWLdtTyFVKuIdNQBKyHp/9BLGLN7A/85sxNPnNqNycgL3fT2TvVnZXpcmIofpsvY1qJVSnHu/nsG23RrWV0REREREREREDs2WXXt57sd5tK1RhtObVirQc0oXj+PtS1rzaLfGjFm8gVNfGskfukBdIpwaACUkzft7G8/8MI+TGlbg/LRUisfH8HC3Jsxbs413Ry7xujwROUwJsdE81705q7fs4okRGtZXREREREREREQOzcu/LGDTzgz+d2YjzKzAzzMzLmlXg6E3dqBM8Vgue388jw+fTUamOpxIZFIDoIScPZlZ3PLFVErGx/DUuU3/CfGTG1XglEYVeOmX+azYuNPjKkXkcLWqVpqrOtbi8/HLGbVgvdfliIiIiIiIiIhImFi4djsf/bWUnm1SaVIl+bDW0aBiEkNvPIaLj67GOyOXcM4bo1m8bnuAKxXZnxfDzqoBUEJOv58XMGf1Vp46txnlSsTv91jfro2JNuOBwTNxTpO1ioSr206uR62U4tz91XQNBSohJVPDTIuIiIiIiIiErMeGz6ZYbDS3n1L/iNaTEBvNY2c15a1LWpO+aRdnvDKKLyeu0DlnCYo5q7dy/HO/88WE5YW63ZhC3ZrIQUxYupE3/1hEzzapnNyown8er1yqGLedUp9Hv53N8BmrOaNZZQ+qFJEjlRAbzbPnNee8N//iye/m8sTZTb0uSYqIrbv3kr5xF+mbdrJy8y7SN+1i5aZdpG/eSfqmXWzfncl9pzXkimNqel2qiIiIiIiIiOTw29y1/D5vHQ+c3vA/HUcOV+fGFWlWNZlbBkzlzkHT+XPBeh4/uwlJCbEBWb/I2m27ufLDCZSIj+G4+uULddtqAJSQsW33Xm79YiqppRN54IxGeS53WbvqfDMlnYeHzaZTvRSFsUiYal29NFcdU5N3Ri7htCaVOKZuOa9LkjDnnGPLrr2kb/I18Pn+3fVPQ1/6pp1s252533MSYqOoWjqRqqWL0bxqKRav28HjI+bQPDWZ1tXLeLQnIiIiIiIiIpJTRmY2j347m1rlinNpuxoBXXel5GJ8dvXRvPH7Ql78eQFTlm/i5Qta0qpa6YBuR4qe3XuzuPrjSWzauZcve7ejQlJCoW5fDYASMh79djarNu9i4LXtKBGf959mTHQUT5zdlLNeG82z38/j0bOaFGKVIhJIt59Sn1/mrOXur6bzw62d8v2/L+KcY+OOjBwNezka+fwNfDsysvZ7TvG46H8a+NrUKE3V0sWoWjqRKqWKUbV0McoUj9tvwvCtu/dyxsujuOmzKYzo05FSiXGFvZsiIiIiIiIicoCPxyxl8fodfNCrDXExgZ/ZLDrKuPGEurSrXY4+A6bQ/c0x3HpSXa47rg7RUXbwFYgcIDvbcfvAaUxP38zbl6Qd9pyVR0JnWiUk/DDrbwZOTOeG42uTVuPgPS6aVS3Fpe1q8NGYpZzTqgotdTWGSFhKiI3m2e7NOO/NMTw5Yg6PayjQIi0727F++x7SN+/fqPdvL76d7N67/xx9SQkxVCmdSLWyibSrXfafBj7fv8VILha7XwPfwSQlxPLqhS05942/uOPL6bxzaetDer6IiIiIiIiIBNb67Xt46ecFHFc/heMbBHcIxdbVSzOiT0fu/2Ymz/04n1EL19OvR0sqJhduzy0Jfy/8NJ/hM1Zz/2kNc53urDCoAVA8t27bHu79egaNKyfR58R6BX7e7afU47uZq7nvm5kMu7EDMdGBv/JDRIKvdfUyXNmhJu+OWsJpTSvRoY6GAo1U2dmOtdv2/KdR7995+HaRkbl/A1/pxFiqlC5GnZQSHFcvhSo5evBV8TfwBVqzqqW499SGPPLtbN4fvZQrNR+giIiIiIiIiGee/3Eeu/Zm8WA+00YFUlJCLC/3bEGnuuV4aOgsurz0J8+c24xTGlcslO1L+PtqUjqv/raQC9qmclVH784rqQFQPOWc456vprN9Tyb9erQ4pO7bJRNiebhrY3r3n8wHo5dydadaQaxURILpjs71+XXuWu4apKFAw1lmVjZ/b93t77l3QAPf5l2s2ryLvVluv+eUKxFHlVLFaFgpiZMbVfA38BWjSqlEqpQu5tnfwuUdajBm8Qae+m4OadVL0zy1lCd1iIiIiIiIiBRlM1duYcCEFVzZoSa1U0oU2nbNjO5pqbSuXpqbB0zhmk8mccnR1bn/9IYkxEYXWh0SfsYv2cg9X0+nQ52yPNKtiacjS+kMq3hqwIQV/DJ3Lf87oxF1K5Q85Od3blyRExuU54Wf5nNq04pULZ0YhCpFJNgSYqN55rxmdH9rDE99N4fHztJQoKFq7dbdLFy3PccQnb5GvpWbd7F6y26ysvdv4CtfMp6qpYvRrGopTmta6Z+59/b14isWF5ofms2MZ89rxukvj+KGzyYz/OaOQeltKCIiIiIiIiK5c87xyLDZlEmM46YT63pSQ62UEnx1XXue+2Ee74xcwvglG3n5gpbUr3jo57Il8i1dv4NrP5lIaplEXr+wNbEej1qoBkDxzNL1O3j029l0qFOWXu1rHNY6zIyHuzXm5Bf+5KEhs3j3sjTN1SQSptJq5BgKtEkl2mso0JDz8+w1XNt/0j+NfGZQMSmBqqWLkVa99D9z7+0bprNSckJYXxVXKjGOVy5syflvjuGer6bz+kWt9B4jIiIiIiIiUkiGz1jN+KUbefKcpp5elBsfE839pzfimLop3D5wGl1fHcUDpzfk4qOr6zyB/GPLzr1c8dEEAD7o1YbkRO8vJFcDoHgiMyubWwdOJSbKeK57c6KiDj8oq5ZO5NaT6/LEiLn8MOtvujSpFMBKRaQw3X5KfX6Zu5Y7NRRoyFm6fge3DpxKw0olue/UhlQtnUjF5IRDGro5HLWqVpq7utTniRFz+WTsMi5tV8PrkkREREREREQi3q6MLJ4cMZdGlZI4Py3V63IAOLZeCt/16cgdX07jwSGz+HPBep45txmli8d5XZp4bG9WNtd9OokVG3fy6VVHU71sca9LAiCyz9pJyHrj90VMWb6ZR89qQqXkYke8vss71KRhpST6Dp3Ntt17A1ChiHihWFw0z57XjFVbdvHUd3O8Lkf8dmVk0bv/JKKjjDcuak37OuWoVjYx4hv/9rnqmFocXz+Fx76dw8yVW7wuR0RERERERCTivfXnIlZu3sVDZzYi+gg6jwRaSsl4PujVhgdOb8jv89Zy6ksjGbNog9dliYecc/xvyEz+WrSBp85pRtuaZbwu6R9F48ydhJTp6Zt56ZcFnNm8Mt1aVAnIOmOjo3ji7Cas2bab53+cH5B1iog30mqU4YoONek/djl/LVzvdTlFnnOO+wfPYN6abfTr0YLUMkVvrtWoKOP581tQpngcN342WReaiIiIiIiIiATRys27ePOPRZzerBJH1SrrdTn/ERVlXNWxFt9c34HEuGgufHcsz/4wl71Z2V6XJh54d+QSPh+/ghuOr825rat6Xc5+1AAohWpXRha3fjGVciXiebRb44Cuu2W10lx8VHU+HrOU6embA7puESlcd5xSn5rlinPXV9PZsSfT63KKtE/HLefrySvpc2Jdjqtf3utyPFOmeBwvX9CSFZt2cd83M3HOeV2SiIiIiIiISER66ru5OAf3ntrA61Ly1aRKMsNuOoburavy2m+LOP+tMazYuNPrsqQQ/Tjrb574bg6nNa3I7SfX97qc/1ADoBSqp7+fy6J1O3iue3NKJQZ+bOQ7u9SnbIl47vtmBpm64kIkbBWLi+aZ85qxcvMunvpurtflFFlTV2zmkWGzOa5+CjefUNfrcjzXtmYZbju5HsOmrWLAhBVelyMiIiIiIiISccYv2ciwaau49tjaVC0d+qMQFY+P4ZnzmvPKBS1ZuGY7p700kiFTV3pdlhSCmSu30GfAVJpVSeb57i2ICqGhavcJagOgmXUxs3lmttDM7snl8Wpm9puZTTGz6WZ2WjDrEW/9OX8dH/61lMs71OCYuuWCso2khFgeOrMRM1du5eMxy4KyDZFwFI553KZGGS5vX5NPxi7jr0UaCrSwbdyRwfX9J1E+KZ5+PULzQ4wXrju2Nh3rlqPv0FnMWb3V63IkDIVjHouIRCplsohIaFAeyz5Z2Y6Hh82iUnICvY+t5XU5h+TM5pUZ0acjdSuUoM+Aqdzx5TSNahXB1mzdzVUfTaR0YizvXJZGsbhor0vKVdAaAM0sGngNOBVoBFxgZo0OWOwBYKBzriXQE3g9WPWItzbvzODOQdOoU74Ed3cJbtft05tW4th6KTz/4zxWb9kV1G2JhINwzuM7O9enRtlE7tZQoIUqK9tx8+dTWL8jgzcvbh2UHtvhKirKeOH8FiQVi+XGzybr71IOSTjnsYhIpFEmi4iEBuWx5DRo0gpmrdrKPac2IDEuxutyDllqmUQGXtuOm0+ow1eT0znjlVHMSN/idVkSYDszMrnqo4ls272X93q1oXzJBK9LylMwewC2BRY65xY75zKAAUC3A5ZxQJL/52RgVRDrEY8457h/8Ew2bM+gX48WJMQGtzXczHjsrCZkOUffobOCui2RMBG2eewbCrQ56Zt28fT3Ggq0sLz403xGLVzPo90a06RKstflhJyUkvG81LMFi9fv4MEhM70uR8JL2OaxiEgEUiaLiIQG5bEAsHX3Xp79YR5p1UvTtXllr8s5bDHRUdx2Sn0+v/podu/N4pw3RvPOn4vJznZelyYBkJ3tuO2LacxatYVXLmxJw0pJB3+Sh4LZAFgFyDlBTrr/vpz6AhebWTowArgptxWZ2TVmNtHMJq5bty4YtUoQDZ22iuHTV3PryfUK7URyaplEbj6xLj/MWsNPs9cUyjZFQlhY53HbmmXo1b4GH49ZxphFGwplm0XZz7PX8OpvC+mRlkqPNtW8Lidkta9djptPqMvXk1fy5UTNBygFFrA8Bn1GFhE5QmH9GVlEJIIojwWAV39dyIYdGTx0ZmPMwn8akqNrleW7Ph05oUF5Hh8xh8s+GM/abbu9LkuO0DM/zOP7WX/zwOmNOKFBBa/LOaigzgFYABcAHzrnqgKnAZ+Y2X9qcs697ZxLc86lpaSkFHqRcvhWbd7FA4Nn0rp6aa7tVLjjNl/dsRb1K5TkoSEzNUSbyMGFdB7f1bkB1csmctdXGj89mJZt2MGtA6fSpEoSD3dr7HU5Ie/mE+vSrlZZ/jdkFgvWbPO6HIkcBcpj0GdkEZFCENKfkUVEihDlcYRbvG47H4xeQvfWVWlaNXJGIiqVGMebF7fm8bObMH7JRk57aSS/zVvrdVlymAZOXMGbfyzi4qOrcXmHGl6XUyDBbABcCaTm+L2q/76crgQGAjjnxgAJQLkg1iSFKDvbcceX08jKdrxwfnNiogu3vTk2OoonzmnCqi27efGn+YW6bZEQE/Z5XCwummf9Q4E+o6FAg2JXRha9+08myow3Lmod9OGaI0F0lPFSzxYkxkVzw2eT2ZWR5XVJEvrCPo9FRCKIMllEJDQoj4XHh88hPiaaOzrX97qUgDMzLjqqOsNuOoZyJeK5/IMJPPrtbPZk6hxCOBmzaAP3fT2DjnXL0TeMeqkGs0VmAlDXzGqaWRy+CVqHHrDMcuBEADNriC+81T87Qnzw11L+WrSB/53RiOpli3tSQ+vqZbigbTU++GspM1dqwlUpsiIij9vWLMNl7Wrw0ZhljF2soUADyTnHA4NnMvfvrfTr2YLUMolelxQ2yicl8GKPFixYu52Hh2neWTmoiMhjEZEIoUwWEQkNyuMi7vd5a/ll7lpuOqEO5UsmeF1O0NSrUJLBN3TgsnbVeW/UEs55/S8WrdvudVlSAIvXbad3/0nULFec1y5qVegdnY5E0Cp1zmUCNwI/AHOAgc65WWb2iJl19S92O3C1mU0DPgd6Oec0G2YEmL9mG09/P5eTGpanR5vUgz8hiO7p0oDSibHc/80MsjTZqhRBkZTHd3Wp7xsKdNB0dmZoKNBA+Wz8cr6anE6fE+tyfP3yXpcTdjrVS+H642ozYMIKhkw98EJVkX9FUh6LiIQ7ZbKISGhQHhdte7OyefTb2dQom0ivMBlS8UgkxEbzcLcmvHNpGqs27+KMl0cxcMIK9OccujbvzODKjyYSE2W836sNSQmxXpd0SCzc/rjS0tLcxIkTvS5D8pGRmc1Zr41mzdbdfH9LJ1JKxntdEkOmrqTPgKk80q0xl7ar4XU5Iv8ws0nOuTSv6zgcXuXxuMUb6PH2WHq1r0Hfrpqn7khNW7GZ7m+OoX2dsrx/WRuiosJjCINQk5mVzQXvjGX2qq0Mu+kYaqWU8LokOUThnMegz8giEjmUxyIioUF5LIXh/VFLeOTb2bx7aRonNargdTmF6u8tu7n1i6mMWbyB05tV4omzm5JcLLwalyJdRmY2l7w3jikrNvP51UfRunoZz2o53EwOn76KEjb6/Tyf2au38uQ5TUOi8Q+ga/PKHFOnHM98P481W3d7XY6IHIGjapWlV/safPjXUg0FeoQ27sjguv6TKJ8UT78eLdT4dwRioqN4+YKWxMVEccNnU9i9V2P5i4iIiIiIiORlw/Y9vPjzfDrWLceJDYveaEQVkxPof9VR3Nm5Pt/P/JvTXhrJpGUbvS5L/Jxz3P/NDMYt2ciz5zXztPHvSBy0AdDM+hTkPhGACUs38uYfi+iRlsopjSt6Xc4/zIzHzmpCRlY2jwyb7XU5IodFefyvu7rUp1oZDQV6JLKyHX0GTGH9jgzevLg1pRLjvC4p7FVKLsbz5zdnzuqtPDZc7zWRTpksIhIalMciIqFBeSyH6oWf5rMzI4uHzmyEWdG8IDk6yrjh+DoM6t2OqCg4/62xvPzLAk1jFQLe/GMxX07yTZfTrUUVr8s5bAXpAXhZLvf1CnAdEgG278nktoFTqVK6GA+e2cjrcv6jRrni3HR8HYbPWM1vc9d6XY7I4VAe+yXGxfDMec1YvnEnz3w/z+tywlK/n+czcsF6Hu3WmCZVkr0uJ2Kc0KAC13SqRf+xyxk+fbXX5UhwKZNFREKD8lhEJDQoj6XAZq/ayufjl3Npu+rUKV/S63I817JaaUbc3JEzmlXihZ/mc+E7Y1m1eZfXZRVZ389czdPfz6Vr88rcclJdr8s5IjF5PWBmFwAXArXMbGiOh0oC6osq//HosNms3LSLgde2o0R8nn9anrrm2FoMmbaKBwbP5KfbOpEYF5p1iuSkPM7d0TmGAj21SUWOqlXW65LCxi9z1vDKrwvpkZZKjzbVvC4n4tzZuT4Tlm7knq+m06RKEtXLFve6JAkgZbKISGhQHouIhAblsRwq5xwPD5tFcrFYbjmxntflhIySCbH069GCTnVT+N+QmZz60kiePrcZXZqEzih7RcH09M3c8sVUWlUrxTPnNQv73qn5tX6MBVYD5YDnc9y/DZgezKIk/Pw462++mLiC64+rTVqN0B0PNz4mmsfPakKPt8fy0i8LuPfUhl6XJFIQyuM83NWlPr/OXctdX03nuz4d1ahfAMs27ODWL6bSpEoSD3dr7HU5ESk2OoqXe7bk9JdHcuNnUxh0XTviY6K9LksCR5ksIhIalMciIqFBeSyH5LuZfzNuyUYeO6sJyYmxXpcTUsyMc1tXpXX10tw8YAq9+0/iwqOq8eDpjSgWp/MKwbZ6yy6u+mgi5UrE8/alaSTEhv8xz28I0EHOud+Bnc65P3LcJjvnNOGS/GPdtj3c+/UMGlVK4paTQv+qjaNqleX8tKq8N3IJc//e6nU5IgWhPM5DYlwMT5/bjGUbNBRoQezKyKJ3/8mYGW9c1DoiPsiEqtQyiTzbvTkzVm7hqe/mel2OBJYyWUQkNCiPRURCg/JYCmz33iweHz6HBhVLckFbjUiUlxrlijOod3uuPbYWn41bTtdXR+k8dpDt2JPJlR9OZFdGFu/3akO5EvFelxQQ+XWViDKz+4B6ZnbbgQ86514IXlkSLpxz3Pv1dLbtyeTzni2IiynItJLeu/fUhvw8Zy33fj2Dr3q3JyoqvLvySsRTHuejXe2yXNauuoYCPQjnHA8Mnsncv7fyfq82pJZJ9LqkiNe5cUV6ta/BB6OXcnStsnRurGE7IoQyWUQkNCiPRURCg/JYCuydPxezcvMuPrv6KKJ1PjZfcTFR3HtqQ46pU47bBk6j66ujuf+0hlzarnrYD0sZarKyHX0GTGHemm2836sN9SpEzryU+bXW9ASy8DUSlszlJsIXE1bw85y13N2lQVj9xyhdPI77T2vIlOWb+XzCcq/LETkY5fFB3NWlAallinHXV9PZlZHldTkh6bPxy/lqcjo3n1CX4+uX97qcIuPe0xrQtEoyd345jfRNO70uRwJDmSwiEhqUxyIioUF5LAWyessuXv99Eac2qUj72uW8LidsdKybwnd9OtKhdlkeGjqLC98Zx7INO7wuK6I8OWIOP89ZS98zG3FsvRSvywmoPHsAOufmAU+b2XTn3HeFWJOEiWUbdvDIt7NpX7ssl7ev4XU5h+ycVlUYNCmdp76by8mNKlC+ZILXJYnkSnl8cMXjY3jm3OZc8M5YnvlhLg+dqbntcpq2YjMPD53NsfVS6HNiXa/LKVLiY6J59cKWnPHyKG76fAoDr21HbHR49JaX3CmTRURCg/JYRCQ0KI+loJ7+bi5ZznHfaQ29LiXslCsRz/u92jBgwgqeGD6Hzv3+5I5T6nN5h5rqSXmEPhu3nHdHLaFX+xpc0q6G1+UEXJ4NgGZ2sXOuP9DIzP7zv1Ldt4u2zKxsbv1iKtFRxnPdm4flEJpmxmNnN+HUfiN57Ns5vHxBS69LEsmV8rhg2tUuy6X/DAVaibY1y3hdUkjYuCOD6/pPIqVkPP16tAjLvA531csW56lzm3HDZ5N59od5+rIT5pTJIiKhQXksIhIalMdSEJOWbWTw1FXceHwdTUlymMyMC9pW47j6KTzwzUweGz6Hb6ev5pnzmoXVyHyhZNSC9Tw4ZCbH10/hwTMaeV1OUOR3CXpx/78lUPdtOcBbfy5m8vLNPHZWEyqXKuZ1OYetdkoJrjuuNkOnreLP+eu8LkckL8rjArq7SwOqli7GXYOmaShQ/h3DfP2ODN68uDWli8d5XVKRdXqzSlx8dDXe/nMxv85d43U5cmSUySIioUF5LCISGiImj3+c9Tev/LIA55zXpUSU7GzHw8NmUyEpnuuOq+11OWGvUnIx3r0sjZd6tmD5xp2c/vJIXv5lARmZ2V6XFlYWrt3GdZ9Ook5KCV6+oGXE9qTMbwjQt8wsGtjqnHuxEGuSEDdz5RZe/Gk+ZzSrRNfmlb0u54hdd1xthk1bxQODZ/LjrZ1IiI32uiSR/SiPC654fAxPn9uMC98Zx7M/zON/Z0bm1TsF1e/n+YxcsJ6nzmlK06rJXpdT5D1weiMmLdvM7QOnMaJPRyolh+8FNEWZMllEJDQoj0VEQkMk5fFv89bx+fjlbNm1l/tPb4hZZDYIFLavJqczPX0LL/ZoTvH4PJsj5BCYGd1aVOGYOuXoO2w2L/w0nxEzfL0Bm1Ut5XV5IW/jjgyu+HAi8THRvNcrjZIJsV6XFDT5TkLjnMsCLiikWiQM7N6bxS1fTKVsiTgeO6tJRLwRJsRG89jZTVi+cSev/LrA63JEcqU8Lrj2tctxydHV+eCvJUxYutHrcjzzy5w1vPLrQs5Pq0rPttW8Lkfwvd+8dmFLMjKzufnzKWRm6eq8cKVMFhEJDcpjEZHQECl5/PhZTejVvgbvjlrCPV/NICtbPQGP1Lbde3n6+3m0rFaKbs2reF1OxClbIp5XLmjJO5emsWlnBme9NponR8xh916NipWXPZlZXPvJRNZs3c07l7amaunIHpI23wZAv9Fm9qqZdTSzVvtuQa9MQtLT389l4drtPNe9OaUSI2coufa1y3FOqyq8/edi5q/Z5nU5InlRHhfQPac2oEqpYtz5ZdEcCnT5hp3c+sVUGldO4pFuTbwuR3KolVKCJ85pyoSlm3jx5/lelyNHRpksIhIalMciIqEh7PM4Ksp46MxG3HxCHb6YuIKbP5+iYRWP0Gu/LWL99j08dGZjoiJ0iMVQcHKjCvx467H0aJPKW38u5tSXRjJu8Qavywo5zjnu+WoGE5Zu4vnzm9OyWmmvSwq6gvS5beH/95Ec9znghIBXIyFt1IL1fDB6Kb3a16Bj3RSvywm4+09ryK9z13L/NzP44pp2elOSUNTC/6/y+CCKx8fwzLnNuPDdcTz347yIncg3N7v3ZtG7/yTMjDcvbq1hjUNQtxZV+GvhBl7/fRFH1SxLp3qR955aRLTw/6tMFhHxVgv/v8pjERFvtfD/G9Z5bGbcdkp9SibE8viIOWzfk8mbF7emWJy+Wx+qpet38P6oJZzbqiotUkt5XU7ESy4Wy5PnNOPMZpW5++vp9Hh7LBcfXY27uzSI6CEuD8Wrvy7kmykruf3kepzRLPynNiuIgzYAOueOL4xCJLRt3pnBHV9Oo3ZKce7u0sDrcoKibIl47ju1IXd9NZ0vJ62gRxsNmSehRXl8aNrXKcfFR1fj/dFLOLVJRdJqlPG6pKBzzvHA4JnM+Xsr71/WhtQykT2MQTjr27UxU1Zs4tYvpvJdn46UT0rwuiQ5RMpkEZHQoDwWEQkNkZbHV3eqRcmEGO79ZgaXvj+O93q1IUmNKIfk8RFziI027u5S3+tSipT2dcrxwy2deP7H+bw/egm/zlnL4+c05fj65b0uzVPfTl/F8z/N55yWVbjxhDpel1No8h0C1Mzqm9nzZjbcf3vOzOoVVnESOh4cMov12/fwYo8WEX3FS/e0qrStUYYnRsxl/fY9Xpcj8g/l8eG599SGvqFAB00vEkOBfj5+BYMmpXPTCXU5vkHR/mAX6orFRfPaha3YmZFFnwFTNbdEmFEmi4iEBuWxiEhoiNQ87tm2Gi/3bMmU5Zu58J2xbNC5wgIbuWAdP81eww0n1NEFrx5IjIvhwTMa8dV17SkeH8PlH0zgti+msmlHhteleWLK8k3cPnAabWqU5slzm2JWdEb+y7MB0MzaAb8D24G3gXeAHcDvZnZ0oVQnIWHI1JUMm7aKPifWpVnVUl6XE1RmxuNnN2FnRiZPDJ/jdTkigPL4SOwbCnTJ+h08/+M8r8sJqmkrNtN36Cw61Uuhz4l1vS5HCqBuhZI80q0xYxZv4JVfF3hdjhSQMllEJDQoj0VEQkOk5/GZzSvzzqVpLFiznfPfGsPqLbu8LinkZWZl88iw2VQrk8gVHWp6XU6R1qpaab69+RhuPqEOQ6et4uQX/2D49NU4V3QuQk7ftJOrP55IhaQE3rokjfiYyO3clJv8hgD9H3CBc+73HPcNNrNfgYeAU4NZmISGVZt38eDgmbSsVorrjqvtdTmFom6FkvQ+tjav/LqQc1tXpUOdcl6XJKI8PgL7hgJ9b/QSukToUKAbd2Rw/aeTSSkZz0s9WhCtOUzDRve0VMYs3sBLvyygbc0ytK+t95wwoEwWEQkNymMRkdAQ8Xl8fIPyfHxFW678aCLnvTGGT686ihrlintdVsjqP3YZC9Zu561LWpMQW7QaW0JRfEw0t51Sny5NKnH3V9O54bPJdG5cgUe7NYn43pnbdu/lyg8nsiczmwHXtKFM8TivSyp0+Q0BWvuA4AbAOfcHUCtoFUnIyM523DloGpnZjhfPb0FMdL4jxkaUG46vQ/WyiTwweCa790b+sIES8pTHR+ieUxtSOdk3FGik/Z/Oynb0GTCFddv28MbFrShdBD/MhLtHuzWhVrni9BkwlXXbNKRMGFAmi4iEBuWxiEhoKBJ5fFStsnx+9dHszMik+1tjmPv3Vq9LCkkbd2Twwk/zOaZOOU5pVMHrciSHRpWT+Ob69txzagN+n7eOk174g4ETV0Rsb8DMrGxu/nwKC9dt542LWlOnfAmvS/JEfi062/J5bEegC5HQ8+FfSxm9cAMPntGoyF3VkhAbzWNnNWHJ+h28/vsir8sRUR4foRLxMTxzXmQOBfrSz/MZuWA9D3drHPHDNEeq4vExvHphK7bu2sttA6eSrfkAQ50yWUQkNCiPRURCQ5HJ46ZVkxl4bTuiDHq8NZYpyzd5XVLIefGn+ezIyOLBMxoVqXnWwkVMdBS9j63Nd3060qBiEncNms6l749nxcadXpcWcI8Nn8Nv89bxaLcmHFO36I62lN8QoKlm9nIu9xtQJUj1SIhYsGYbT30/lxMblKdnm1Svy/FEx7opdGtRmTd/X0TX5pWL7FUCEhKUxwHQoU45LjqqGu+O8g0F2rp6+A8F+uvcNbz860LOT6taZLM6UjSslMRDZzbmvm9m8MYfi7jh+DpelyR5UyaLiIQG5bGISGgoUnlct0JJBvVuz0XvjuOid8fx7mVpmsrBb+7fW/l03DIuObo69SuW9LocyUetlBIMuOZoPh2/nKdGzKFzvz+5q3N9Lm1Xg6gImFbmkzFL+fCvpVx1TE0uPKqa1+V4Kr8egHcCk3K5TQTuKsjKzayLmc0zs4Vmdk8ey5xvZrPNbJaZfXZo5UswZGRmc8sXUykRH8NT5zYr0ldrPHB6IxJio7j/mxkR2x1awoLyOEDuPc0/FOiX4T8U6PINO7llwFQaV07ikW5NinRWR4oL2qZyZvPKPP/jPMYv2eh1OZK3I8pk5bGISMDoM7KISGgocnmcWiaRQb3bUbV0MXp9MIGfZq/xspyQ4Jzj4aGzSSoWy60n1/O6HCmAqCjjkqOr8+Ntx9KmRhn6DptN97fGsHDtdq9LOyJ/zF9H32GzOalhBe49raHX5Xguzx6AzrmPjmTFZhYNvAacDKQDE8xsqHNudo5l6gL3Ah2cc5vMrPyRbFMC46Vf5jNr1VbeuqQ1KSXjvS7HUykl47nn1Ibc980Mvpq8kvNaV/W6JCmClMeBs28o0IveHcfzP87j/tMbeV3SYdm9N4ve/SdhZrx5sSbVjhRmxhNnN2FG+mZu/nwKI/p0LJITVIe6I8lk5bGISODoM7KISGgoqnlcPimBL65pR68PJ9C7/ySe796cs1pGXIfHAvth1hrGLN7AI90aUypR32PDSZVSxfjw8jZ8M2Ulj3w7m9NeHkmfE+tyTadaxEbn138s9Mxfs40bP51M/QolealnC6IjoDfjkQrmK9gWWOicW+ycywAGAN0OWOZq4DXn3CYA59zaINYjBTBx6Ube+H0R56dVpXPjil6XExJ6tkmldfXSPD58Nht3ZHhdjsjhUB7n0KFOOS70DwU6aVn49bJyzvHg4JnM+Xsr/Xq0ILVMotclSQCVTIjl1QtbsXFHBrdrPsBIpDwWEQkdymQRkdAQtnlcungcn151FG1qlObWgVP5ZOwyr0vyxO69WTw+Yjb1KpTgwrZFe7jFcGVmnNOqKj/deiwnNSzPsz/M46zXRjNz5RavSyuw9dv3cMWHEygWF817vdIoHp/f7HdFRzAbAKsAK3L8ns5/x32uB9Qzs9FmNtbMuuS2IjO7xswmmtnEdevWBalc2b4nk9sGTqNK6WL878zGXpcTMqKijCfObsq23Zk8OWKO1+WIHA7l8QHuPbWBbyjQQeE3FOiACSv4clI6N51Ql+MbeH7RowRBkyrJPHBGQ36bt453Ry32uhwJrIDlMUROJouIeESfkUVEQkNY53GJ+Bg+vLwtJzYoz4ODZ/L67wsLZbuh5L1RS1ixcRcPndmYmDDrMSb7SykZz+sXtebNi1uxdtseur02mme+nxvy5852783imo8nsn77Ht67rA2Vkot5XVLI8Pp/ZAxQFzgOuAB4x8xKHbiQc+5t51yacy4tJSWlcCssQh77djYrNu3khfNbUEIt5PupX7EkV3eqxZeT0hm7eIPX5YgEQ5HK45IJsTx9bjMWr9vBCz/N97qcApuevpmHhsyiU70U+pxY1+tyJIguObo6XRpX5Jnv5zF5+Savy5HCVaA8hsjJZBGREFakPiOLiISwkM7jhNho3ri4Nd1aVOaZ7+fx1Hdzca5ojOayZutuXvttIac0qkCHOuW8LkcCpEuTSvx867Gc07IKr/++iNNeHsnEpaE5ipZzjrsGTWfy8s3069GCplWTvS4ppBy0AdDMqprZN2a2zszWmtlXZlaQidBWAqk5fq/qvy+ndGCoc26vc24JMB9fmAfU+u17Qr6V2ms/zV7DgAkr6H1sbdrUKON1OSHp5hPqklqmGPd/M4M9mfp7ksIXCXkcSo6pW44L2lbj3ZGLmbQs9BtYNu7I4Lr+k0kpGc9LPTSOeaQzM54+rxmVSiVw02dT2LJzr9clyQEOM5OVxyIiAabPyCIioaGo53FsdBQvnt+Ci46qxpt/LOKBwTOLxJQOT38/l8wsx/2nN/S6FAmw5MRYnu3enI+vaMuevdl0f2sMfYfOYseeTK9L20+/nxcwdNoq7u7SgC5NKnldTsgpSA/AD4ChQCWgMjDMf9/BTADqmllNM4sDevrXk9NgfFduYGbl8HXnDvhYV08Mn0P7p37lme/nsmrzrkCvPuyt376He76aTsNKSdx6Uj2vywlZxeKieaRbExat28Fbf2hINvFE2OdxqLnvtAZUSi7GnYOmhfSFIlnZjj4DprBu2x7euLgVpYtrQu2iILlYLK9e0Iq123Zzx6BpReYK0jByOJmsPBYRCTx9RhYRCQ1FPo+joozHzmpC72Nr8+m45dw6cCp7s7K9LitopizfxNeTV3Jlx5pUL1vc63IkSDrVS+HHWztxWbsafDRmKae8+CcjF4TGkOdDpq7kpV8WcH5aVXofW8vrckJSQRoAU5xzHzjnMv23D4GD9qF2zmUCNwI/AHOAgc65WWb2iJl19S/2A7DBzGYDvwF3OucCPr5i97RU2tQozZt/LOKYp3+l9yeTGLNog06k4esie89XM9i2J5N+PVoQF+P1qLCh7fj65Tm9WSVe/W0hS9bv8LocKXrCPo9DTcmEWJ46tymL1+3gxRAeCvSln+czcsF6Hu7WmGZVS3ldjhSi5qmluLtLA36avYYPRi/1uhzZ3yFnsvJYRCQo9BlZRCQ0KI/xjeZyz6kNuKtLfYZMXcV1/SeF9AXHhys72/HwsNmklIznhuPreF2OBFnx+Bj6dm3MwGvbER8bxSXvjefOL6d5OlrRpGUbufPL6RxdqwyPndUUM42UlZuCTPS2wcwuBj73/34BUKCAdc6NAEYccN//cvzsgNv8t6BpV7ss7WqXJX3TTvqPXc6ACcv5ftbfNKhYkkvb1eCslpVJjCuac94NnLiCn+es4YHTG1K/YkmvywkLD53RiD/nreOBwTPof+VRChcpTGGfx6GoY90ULmibyjsjF9O5SUVaVSvtdUn7+XXuGl7+dSHdW1elZ5vUgz9BIs6Vx9Rk7OKNPPndHNJqlFYjcOg4rExWHouIBJw+I4uIhAblcQ7XH1eHkgmx/G/ITC7/YALvXJZGifjIOf88eOpKpq7YzHPdm0fUfkn+2tQow4ibO/LyLwt468/F/D5/HY92a0KXJhULtY4VG3dyzceTqFK6GG9e3FqdmvJRkCNzBXA+8DewGjgPuDyYRQVL1dKJ3HNqA8beeyLPnNeM6Cjjvm9mcPQTv/DYt7NZvmGn1yUWqmUbdvDwsNm0q1WWKzrU9LqcsFE+KYG7utRn9MINDJm6yutypGiJmDwONfed1pCKSQnc+WVoDQW6fMNObhkwlcaVk3j0rCa64KCIMjOe696MlBLx3PjZFLbu1nyAIUKZLCISGpTHIiKhQXl8gEuOrs4L5zdn/NKNXPTuODbvzPC6pIDYsSeTp76bS/OqyZzTsorX5UghS4iN5q4uDRhyQwdSSsTTu/8kbvh0Muu27SmU7W/dvZcrPpxAZrbj/V5tKJWoaXLyc9AGQOfcMudcV+dcinOuvHPuLOfc8sIoLlgSYqM5Py2Vb286hkG929GpXgof/rWUY5/7jSs+nMAf89dF/CStWdmO2wZOIzrKeO785kRF6aTyobjwqOq0SC3Fo9/Ojpg3bwl9kZjHocI3FGgzFq3bwYs/h8ZQoLv3ZtG7/yQA3rioNQmx0R5XJF4qlRjHKxe2ZOXmXdzz1XQNYx4ClMkiIqFBeSwiEhqUx7k7u2VV3ry4NXNWb6XHW2NZu3W31yUdsdd/X8jabXv435mNdU65CGtSJZkhN3bgzs71+Wn2Gk5+8Q++npwe1PMVmVnZ3PDpZJZu2MGbF7emZjnNPXkwefbPNbP/5fUYvp7XjwahnkJlZqTVKENajTKs2bqbT8ct57Nxy7ns/fHUKlecS9tV59zWVSmZEOt1qQH35h+LmLRsE/16tKBKqWJelxN2oqOMJ85uypmvjuLp7+fy5DnNvC5JIlhRyONQ0KleCj3bpPLOn4vp0rgiLT0cCtQ5x4ODZzJ79Vbe75VGtbKJntUioaN19TLccUp9nv5+Lv3HLeeSo6t7XVKRpEwWEQkNymMRkdCgPD64kxtV4MNebbjq44mc9+YYPr3qKFLLhOf3/OUbdvLOyCWc3bIKrauH1hQqUvhio6O44fg6dG5ckbu/ms5tA6cxdNoqHj+7acDbHJxz9B02i5EL1vPMec1oV7tsQNcfqfLrAbgjlxvAlcDdQa6r0FVISuC2k+sx+p7j6dejBUnFYuk7bDZHP/EL/xsyk4Vrt3tdYsDMXLmFF3+az+nNKtGtRWWvywlbjSonceUxNfl8/AomLN3odTkS2YpUHnvp/tN9Q4He4fFQoAMmrODLSencfEIdTmhQwbM6JPRc26kWx9VP4dFvZzNr1RavyymqlMkiIqFBeSwiEhqUxwXQvk45Pr3qKLbs2kv3N8ewcO02r0s6LI+PmE20GXd3aeB1KRJC6pQvwcBr29H3zEaMX7KRU174g0/GLgvoKIsfjF5K/7HLufbYWpyflhqw9Ua6PBsAnXPP77sBbwPF8I3bPACoVUj1Fbr4mGjOalmFwTd0YMgNHejcpCIDxq/gpBf+4JL3xvHz7DVkhfHwoLv3ZnHrF1MpUzyOxzWf1BG75aS6VClVjPu/mUFGZrbX5UiEKqp57IWSCbE86R8KtN/PCzypYXr6Zh4aMouOdcvR56R6ntQgoSsqyni+e3NKJ8Zy42dT2L4n0+uSihxlsohIaFAei4iEBuVxwbWsVpovrj2azGxH9zfHMCM9vC7qHL1wPT/MWsMNx9emYnKC1+VIiImOMnp1qMkPt3SiZbXSPDh4Jj3fGcuS9TsO/uSD+HXuGh4bPpvOjStwd2c1Ph+KfOcANLMyZvYYMB3fcKGtnHN3O+fWFkp1HmueWooXzm/BX/eewB2n1GPBmu1c9fFEjnvuN97+c1FYzv32zPfzWLB2O892b64JMgMgMS6GR7o1Zv6a7bwzcrHX5UgEK+p5XJiO9Q8F+vafi5iyfFOhbnvTjgyu6z+ZlJLxvNyzJdEaS19yUbaE7+9j2YYd3P/NDM0H6AFlsohIaFAei4iEBuVxwTWomMSg3u1IjIvhgnfGMm7xBq9LKpDMrGweGTabqqWLcVVHtetK3lLLJPLJlW155txmzFm9lS79/uStPxaRmXV4nWfmrN7KTZ9NoVHlJF7s0ULzTh6iPBsAzexZYAKwDWjqnOvrnCvcM6EholyJeG48oS4j7z6e1y9qRaXkYjwxYi5HP/kL9349nTmrt3pdYoGMXrie90cv4bJ21Tm2XorX5USMExtWoEvjirz8ywKWb9jpdTkSgZTHhe++0xtSISmBOwdNL7ShQLOyHX2+mMq6bXt4/aJWlC6uizQkb0fVKsutJ9VjyNRVDJy4wutyihRlsohIaFAei4iEBuXxoatRrjiDrmtHhaR4Ln1/PL/NC/120s/HL2femm3cf1pDEmKjvS5HQpyZcX6bVH6+7ViOrZfCk9/N5Zw3/jrkdpS1W3dz5YcTKJkQy3uXtSExLiZIFUeu/HoA3g5UBh4AVpnZVv9tm5mFR4tXgMVGR3Fa00oMvLYdI27uyFktqvDNlJWc+tJIzn9rDCNmrD7sluxg27JzL3d8OY1aKcW559SGXpcTcfp2bUxsdBQPDJmpnhjyf/buOzyKcn3j+PdJhySEktASAgRC70SqoFixYlfsHhX12Nvx6M9jO/Z2jr0cewXBhr2g0lV67zWAQOgdUt7fH7tgQAgBspnZzf25rlzszs7OPLMJdzb7zPtOKCiPy1mVhFgePbMNc1du4pkh5TMV6DND5jBsdh73ndqStvWqlss+Jbz9vVdjujeuwb2DpzFreXhePyJMKZNFRPxBeSwi4g/K44NQJ6USH13VlcY1k7jy7bF8OXmZ1yXt07otO3jqh9l0zapB71a1vS5HwkitKgm8clFHXji/A8vWbeWU50bw9Pez2F6w/5Ptt+4o5Mp3xrJ2Sz6vXZJDrSqadvZglHQNwCjnXCXnXLJzrkqxr2TnXJXyLNKPWtStwqNntuHXO4/mrhObsWzdVv7+/nh6PP4zz/80h9Wbtntd4m7uGTyVvI3b+e+57agUp7M0ylrtlARuPa4Jw2bn8eXkP7wuRyKM8tgbRzRJ49ycerwydB4Tc9eFdF8/z1zJs0PmcFbHDPp20oWMpXSio4z/ntuepPhYrv1gPFt26HqA5UGZLCLiD8pjERF/UB4fvBpJ8XzYrwvtM6ty/YcT6P/7Yq9L2qv//jiHDVvzueeUFphp+kU5MGbGSW3q8MPNR3BK27o8+9NcTn52BONLuOxOUZHj1oETmbx0Pc/2bU+r9JRyrDiylHgNQNm/qpXj6NezEUNv78X/Ls6hUVoST34/m66P/MQtH01k8pJ1XpfI4EnL+HziMm44Ops2GVW9LidiXdy1Aa3TU7j/i+ms35rvdTkiUgb+7+TgVKADJ4VsKtDcNVu4acBEWtSpwoOntdKbaTkgacnxPHNeO+blbeKez6d5XY6IiIiIiIgcgCoJsbzzt870zE7jn59M4bXh870uaTezV2zk3V8XcX7nTJrXUT9XDl61xDj+c2473rz0MDZtL+DMl0bx7y+n7/Vk5qd+mMXXU5Zz1wnNObZFLQ+qjRxqAJaR6Cjj2Ba1eO+Kzvx4S0/O61SP76Yu59TnR3LaCyP5bMJSdhSU//Sgy9dv4+5Pp9CuXlX+fmSjct9/RRIdZTxyRmvWbN7OE9/N9LocESkDVRJieeSM1swJ0VSg2/ILufq9cTjnePnCjppHXw5K98apXN+rMYPGLeHjcUu8LkdEREREREQOQKW4aP53cQ4nta7Dg1/N4OnvZ/niEkPOOf795XQS46K55dimXpcjEaJXs5p8f3NPLuicyesjFtD7v8MZNXfVrscHjVvCCz/Po2+nelzRo6GHlUYGNQBDoHHNZB7o04pf7zqae09pwfqt+dw0YCLdHv2Jp3+YzYoN28qljqIix+2DJpFf6PjPue2Iida3O9RapadwabeGvP/b4hKHMYtI+DiyaU3OycnglaHzmFTGU4He8/lUpi3bwH/ObUdmjcplum2pWG48pgmdG1bn7s+mMnflJq/LERERERERkQMQFxPFs33bc05OBs/+NJf7v5hOUZG3TcAfZ6xk+JxV3HxsE6onxnlai0SW5IRYHjytNf37dSHK4PzXfuPOTyYzZMYK7vxkMt0b1+CBPpolqyyU2BEys2gz+7m8iok0yQmxXNa9IUNuOYK3/9aJNhkpPPfTHLo/+hPXfTCesQvXhPRsjndGL2T4nFXcfXJzGqYmhmw/srtbjmtC7SoJ3PXJFPILy3/Up0Qm5bG3/u+kFtRMTuC2gZNKdaHi0uj/+2I+GruE649qzNHNNZ2BHJroKOOZ89pTKS6a6z4YH7IpayVAmSwi4g/KYxERf1Ael43oKOOxM9tw+eENeWvUQm4fNJkCjz5b3F5QyINfTadxzSQu7FLfkxok8nXJqsG3N/Xkqp5ZDBiTy+Vvj6Ve9cq8eH5HYjWYqUyU+Co65wqBIjPTVRYPQVSUcUSTNN649DB+ue1ILunWgKGz8zjr5dGc/NwIPhqbW+Yf1M1ZsZFHvplJr6ZpnN8ps0y3LSVLio/hvlNbMnP5Rt4YscDrciRCKI+9lVIplkfODE4F+uOhTwU6Zcl67hk8jR7Zqdx0TJMyqFAEaqck8PQ5bZm5fCP3f1ExrwdYVOT2ev2AsqZMFhHxB+WxiIg/KI/Ljplx90nNufmYJnw8fgnXfTChzE5EPhBvjlzIotVb+NfJLdSIkZBKiI3mzhOb89m13TmzQwZvXnoYKZVjvS4rYsSUYp1NwBQz+wHYvHOhc+6GkFUVwerXSORfJ7fg1uOa8OmEpbw9aiH/GDSZR76ewbmHZXJhl0wyqh3aNHA7Coq4+aOJJMbH8NhZbTRU1gPHt6zNMc1r8d8f53Bi6zrUq66p/aRMKI891KtpTc7umMHLQ+dxfMvatK1X9aC2s3bzDq5+bxxpSfE8e157oqOU0VJ2jmxak2uObMRLv8yjS1YN+rRL97qkMuecY+2WfBas2sSCVVuC/25mft5mFq7ezOnt03nkjDblUYoyWUTEH5THIiL+oDwuI2bGjcdkk5wQwwNfTueKt8fyykUdqRxXmo/yD93Kjdt4bsgcjmlekyOapJXLPkXaZFTlqXOqel1GxClNanwS/JIyVDkuhgs61+f8TpmMnr+ad0Yt4tVh83h12DyObVGLS7o2oGujGgfVvHt2yBymLt3Ayxd2pGZyQgiql9K4v09Ljn16KPcOnsbrl+SoEStlQXnssbtPbsHwOau4fdAkvrj+cOJjog/o+YVFjpsGTCRv43YGXt2VappDX0LglmOb8PuCNdz1yRTaZFQN22nAt+woYMGqzYGvvMC/84P312/N37VeTJSRWb0yDVMTObxxKl2yapRXicpkERF/UB6LiPiD8riM/e3whiQnxHDHx5O56PXfeePSw0ipFPqRUU98O4sdhUX830ktQr4vEQmt/TYAnXNvm1kcsHOOslnOufySniOlZ2Z0a5RKt0apLF23lfd+XUT/3xfz3bQVNKmVxMVdG3B6+3QS40t3hse4RWt48Ze5nN0xg96taoe4eilJetVK3HJsEx78agbfTl3OCa3reF2ShDnlsfdSKsXyyBmtueytMTw7ZA63H9/sgJ7/7JA5DJ2dx8Ontz7oEYQi+xMbHcVzfdtz4rPDufb98Xzy924kxB5Ys7q87CgoInftll0NvgWr/2z2Ld+wbbd166Qk0DA1kZPb1KFhaiJZaYk0TE0io1olT6akUSaLiPiD8lhExB+Ux6Fxdk49kuJjuKH/BM579VfevbwTqUnxIdvfpNx1DBy3hKt6ZoXtyaQi8qf9dpXM7EjgbWAhYEA9M7vEOTcspJVVQOlVK3FH72bceHQ2X0xaxtujF3L3Z1N57NuZnN2xHhd3rU+DEoJ38/YCbh4wibpVK3HPKTpDww8u7daAT8Yv5b4vpnF4dirJCZq/WA6e8tgfejWryVkdM3h56HyOb1mbNhlVS/W8n2et5Nmf5nBWxwz6dqoX2iKlwqtbtRJPntWWK94Zy8Nfz+CBPq08q6WoyLF8w7Y/R/Dlbd41bWfu2q0UFrld61arHEvD1ES6N04NNvgCXw1qJFIpzl9NTGWyiIg/KI9FRPxBeRw6J7Suw2vxMVz17ljOeXk0717RmfSqlcp8P8457v9iGqlJcVx3VOMy376IlL/SDCt7CjjOOTcLwMyaAB8CHUNZWEWWEBvN2Tn1OKtjBuMXr+WtUYt4Z/RC3hy1gCObpHFJtwb0zE4jao/rRj341XRy125hQL+uajT5REx0FA+f0ZrTXxzJU9/P5r5TW3pdkoQ35bFP/OvkFgyfk8dtA0s3FWjumi3c1H8izWtX4cHTWmlKYCkXx7SoxRWHN+S1EQvoklWDE0M4Er34dfnmB0fwLVz953X5tuUX7Vq3Umw0DVITaVk3hZPb1A00+dISaVgjMdymxVUmi4j4g/JYRMQflMchdESTNN67vDOXvTWGs18axXtXdCYrLalM9/H5xGWMX7yOx89so8+WRSJEaRqAsTuDG8A5N9vMlADlwMzoWL86HetXZ8VJzfngt8W8/9tiLn1zDA1TE7moS33OysmgSkIsP05fwYe/53L1EY3o1LC616VLMe3qVeXiLvV5e/RCTm+frmn/5FAoj31i51Sgf3trLM8Nmcttxzfd57rb8gu55v1xOOd4+cKOvp2KUSLTP3o3Y8yitdwxaDKt6qaQWaPyIW3vYK/L1zA4mi8rNYlaVeIjpQmuTBYR8QflsYiIPyiPQyynQXU+vLILl7zxO+e8Mpp3/taZFnWrlMm2N28v4JFvZtA6PYWzOmaUyTZFxHulaQCONbPXgPeC9y8AxoauJNmbWlUSuPnYJlzbqzHfTP2Dt0Yt5IEvp/Pk97M4o0M6305dTvM6Vbj52GyvS5W9uPX4pnwzdTl3fTqFz6/tTowH1yqSiKA89pGjmtXizA4ZvDR0Hse3rE3rjJS9rnfP51OZunQDr1+Sc8jNF5EDFRcTxfPB6wFe/+F4Bl7djbiYkn8H7XldvvmrNrNwVXhcl6+cKZNFRPxBeSwi4g/K43LQKj2Fj67uyoWv/cZ5r47mzcsOo2P9Qx8M8vLQeazYsJ0Xzu/wl1nnRCR8laYBeA1wLXBD8P5w4MWQVSQliouJok+7dPq0S2fyknW8PWoRH41ZAsD7V7Tb7zR04o0qCbHcd2pL/v7+eN4atZAremR5XZKEJ+Wxz9xzcgtGzA1MBTr4+u5/yeD+vy/mo7FLuP6oxhzdvJZHVUpFV696ZZ44qw1Xvzeex76dyb9ObhGx1+UrZ8pkERF/UB6LiPiD8ricNEpLYuDVXbno9d+58LXfefXijvTITjvo7eWu2cIrw+Zzatu65DTQzHIikWSfDUAzG+KcOxp4wDl3B/B0+ZUlpdEmoypPnVOVu05sxvqt+WU+77OUrRNa1aZX0zSe/mE2J7auQ90QXKxXIpPy2L9SKv85FejzP83l1uP+nAp0ypL13DN4Gj2yU7npmCYeVikCvVvV4ZKu9Xl9xAKGz8lj8ZotkXpdvpBTJouI+IPyWETEH5TH3sioVpmPrurKRa//xuVvjeXZvu3p3ar2QW3rkW9mEGXwzxOalXGVIuK1kkYA1jGzbsCpZtYf2G3sr3Nu/P42bma9gWeAaOA159yj+1jvTGAQcJhzTkPDD1CNpHhqJMV7XYbsh5nxQJ9WHPufodw7eBr/uzjH65IkfCiPfWznVKAv/jKP41oEpgJdu3kHV783jrSkeJ45rz3Rmj5DfOCuk5qzZUchazbvoGd2WqRel688HFImK49FRMqM3iOLiPiD8tgjacnxDOjXlUvf+p1rPxjP42e24cwDvH7f6Hmr+XrKcm4+pokGK4hEoJIagPcA/wIy+OuZGw44qqQNm1k08AJwLLAEGGNmg51z0/dYLxm4EfjtwEoXCT/1qlfmpmOa8Og3M/lu2nKOb3lwZ+ZIhaM89rl7Tm7B8DmBqUA/v647Nw2YSN7G7Qy8uivVNXpKfCI+Jponzm7rdRmR4KAzWXksIlKm9B5ZRMQflMceSqkcy3uXd6bfu2O5deAkNm7L59LuDUv13MIix/1fTCO9aiX69dTlikQiUdS+HnDODXLOnQA87pzrtcdXicEd1AmY65yb75zbAfQH+uxlvX8DjwHbDuYARMLN5Yc3pFntZO4bPI1N2wu8LkfCgPLY/3ZOBTprxUb6PD+SobPzuPfUFrStV9Xr0kSkjB1iJiuPRUTKiN4ji4j4g/LYe4nxMbx+yWEc16IW930xneeGzME5t9/n9R+zmJnLN3LXic0r+vXdRSLWPhuAOznn/n2Q204HcovdXxJctouZdQDqOee+KmlDZtbPzMaa2di8vLyDLEfEH2Kjo3jo9NYs37CN//ww2+tyJIwoj/3t6Oa1OKNDOrNWbOTMDhmc3ynT65JEJIQOMpPLLI+D6yqTRaTC03tkERF/UB57KyE2mhcv6MAZ7dN56ofZPPLNzBKbgOu35PPkd7Po1LA6J7bWDGUikWq/DcBQMbMoAsPCb93fus65V51zOc65nLS0tNAXJxJiHetX4/xOmbw5cgFTl673uhyp4JTHZef+U1vy0OmteOj0VrqemogcsAPJY1Ami4iEkt4ji4j4g/K49GKio3jy7LZc0rU+rw6bz52fTKGwaO9NwGeGzGHd1nzuPaWFPr8QiWChbAAuBeoVu58RXLZTMtAK+MXMFgJdgMFmlhPCmkR84x+9m1E9MZ67Pt33L2ORMqI8LifJCbFc0Lk+CbGaOkNE9kp5LCLiH8pkERF/UB6Xoago475TW3Jdr8b0H5PLjf0nsKOgaLd15q7cyDujF3LeYZm0rJviUaUiUh5i9vWAmVUv6YnOuTX72fYYINvMGhII7fOA84s9fz2QWmx/vwC3OefG7r9skfCXUimWe05pwQ0fTuDd0QtLfYFeqXiUxyIi/nGImaw8FhEpI3qPLCLiD8pj/zEzbju+KckJMTzyzUw2by/gxQs6UikuGuccD3w5g0px0dx2XBOvSxWRENtnAxAYBzhgb2OAHZBV0oadcwVmdh3wHRANvOGcm2ZmDwBjnXODD7JmkYhxSps6DBq3hCe/n03NKgmc0Kq2ht3L3iiPRUT846AzWXksIlKm9B5ZRMQflMc+ddURjahSKZa7Pp3CJW/+zuuX5DBm4RqGzc7j7pOaUyMp3usSRSTErKSLgfpRTk6OGztWJ3hI5Fi6bitXvD2WGX9soHvjGtx3SkuyayV7XZaUEzMb55wLy2krlMciEknCOY9BmSwikUN5LCLiD8rjyDF40jJuGTCR5nWqsGl7AWbw7Y09iYsJ5dXBRKQsHWwmlzQCsPjGqwHZQMLOZc65YQe6MxH5q/Sqlfjiuu58+PtinvhuFic8M5xLuzXgxmOySU6I9bo88RnlsYiIfyiTRUT8QXksIuIPymN/OrVtXZLio7nmvfFsLyjizcsOU/NPpILYbwPQzK4AbiRwAdaJBC60Oho4KqSViVQgMdFRXNS1ASe2rsOT38/i9ZEL+GziMu48oRmnt08nKkrTgoryWETET5TJIiL+oDwWEfEH5bG/HdWsFh/268K0pevp1bSm1+WISDkpTav/RuAwYJFzrhfQHlgXyqJEKqoaSfE8ckYbPr+2OxnVKnHrwEmc/cpopi5d73Vp4g/KYxER/1Ami4j4g/JYRMQflMc+1yGzGhd1beB1GSJSjkrTANzmnNsGYGbxzrmZQNPQliVSsbXJqMon13TjibPasGj1Zk55fgT/9+kU1m7e4XVp4i3lsYiIfyiTRUT8QXksIuIPymMREZ8pzTUAl5hZVeAz4AczWwssCmVRIgJRUcbZOfU4rmVt/vvjbN4ZvYivpvzBbcc1pW+nTKI1LWhFpDwWEfEPZbKIiD8oj0VE/EF5LCLiM/ttADrnTg/evM/MfgZSgG9DWpWI7JJSKZZ7T2nJeYdlcu/gqdz92VQ+/H0xD/RpScf61b0uT8qR8lhExD+UySIi/qA8FhHxB+WxiIj/7HcKUDN71sy6ATjnhjrnBjvnNA+hSDlrWjuZD6/swnN927N60w7OfGk0t3w0kZUbt3ldmpQT5bGIiH8ok0VE/EF5LCLiD8pjERH/Kc01AMcBd5vZPDN70sxyQl2UiOydmXFK27oMufUI/n5kI76YtIyjnhzKa8Pnk19Y5HV5EnrKYxER/1Ami4j4g/JYRMQflMciIj6z3wagc+5t59yJwGHALOAxM5sT8spEZJ8S42P4R+9mfHdTT3IaVOPBr2Zw4jPDGTl3ldelSQgpj0VE/EOZLCLiD8pjERF/UB6LiPhPaUYA7tQYaAbUB2aGphwRORBZaUm8eelhvHZxDtsLirjgtd+49v3xLF231evSKoSiIsfIuau4/sMJTF26vjx3rTwWEfEPZbKIiD8oj0VE/EF5LCLiEzH7W8HMHgdOB+YBA4B/O+fWhbguESklM+OYFrU4PDuV/w2bzwu/zOWnmSu5tlcjruiRRUJstNclRpwVG7YxaNwSBozJZfGaLaRUiqV3y9q0Sk8J6X6VxyIi/qFMFhHxB+WxiIg/KI9FRPxnvw1AAqHd1TmnuQVFfCwhNprrj87m9A7pPPTVDJ78fjYDxy3hnpNbcHTzWl6XF/YKCosYOjuPD3/P5edZKykscnTNqsGtxzXh+Ja1y6vRqjwWEfEPZbKIiD8oj0VE/EF5LCLiM/ttADrnXtl528y+dM6dHNqSRORQZFSrzEsXdmTEnFXcO3gql789lqOa1eSek1vQIDXR6/LCTu6aLXw0NpeBY5ewfMM2UpPi6dczi3Ny6tGwnF9P5bGIiH8ok0VE/EF5LCLiD8pjERH/Kc0IwOLSQ1KFiJS5w7NT+ebGnrw9aiHPDJnDcf8ZxpU9G3Jtr8ZUjjvQ//oVy/aCQn6YvoIBY3IZMXcVBhzRJI37+7TkqGY1iY0+kMunhozyWETEP5TJIiL+oDwWEfEH5bGIiA8caBdgQkiqEJGQiIuJ4sqeWfRpV5dHv5nJCz/P45PxS7n7pBac2Lo2ZuZ1ib4yd+VG+v+eyycTlrJm8w7Sq1bipqObcHZOBnWrVvK6vD0pj0VE/EOZLCLiD8pjERF/UB6LiPjAPhuAZpYAXA00BqYArzvn/lZehYlI2alZJYGnz23H+Z0zuefzaVz7wXi6ZtXg/j4taVIr2evyPLV1RyFfTfmDAWMWM2bhWmKijONa1uLcwzI5vHEq0VHeN0mVxyIi/qFMFhHxB+WxiIg/KI9FRPyrpBGAbwP5wHDgBKAFcGN5FCUioZHToDpfXH84H/y+mCe/m8UJzwzn0m4NuPGYbKokxHpdXrmaunQ9/ccs5vMJy9i4vYCs1ETuPKEZZ3bMIDUp3uvy9qQ8FhHxD2WyiIg/KI9FRPxBeSwi4lMlNQBbOOdaA5jZ68Dv5VOSiIRSdJRxUZf6nNS6Dk9+P4s3Ri7g84nL+OcJzTijfTpRPhjxFiobtuUzeOIy+o9ZzNSlG4iPieKk1nU497B6dGpY3c9ToiqPRUT8Q5ksIuIPymMREX9QHouI+FRJDcD8nTeccwU+/mBcRA5C9cQ4Hj69NX0Py+SewVO5beAkPvhtEQ/0aUWr9BSvyyszzjnGL17Lh7/n8tXkP9iaX0jzOlV4oE9L+rRNJ6VyWIx8VB6LiPiHMllExB+UxyIi/qA8FhHxqZIagG3NbEPwtgGVgvcNcM65KiGvTkRCrnVGCh9f3Y1PJizl0W9mcMrzI+jbKZPbj2tKtcQ4r8s7aGs27+CT8UsYMCaXOSs3kRgXzWnt0+nbqR6t01P8PNpvb5THIiL+oUwWEfEH5bGIiD8oj0VEfGqfDUDnXHR5FiIi3omKMs7qmMFxLWvxzI9zeGvUQr6a/Ae3Hd+U8ztlEh0m04IWFTlGzVtN/zGL+X7aCnYUFtEhsyqPn9mGk9rUITG+pHMe/Et5LCLiH8pkERF/UB6LiPiD8lhExL/C89NwEQmJKgmx/OvkFpx7WD3u/Xwa//psKh/+tpgH+rQkp0F1r8vbpxUbtjFoXGC03+I1W6haOZYLu9Tn3MPq0bR2stfliYiIiIiIiIiIiIiUq6hQbtzMepvZLDOba2b/3Mvjt5jZdDObbGZDzKx+KOsRkdJpUiuZD67szPPnt2ftlh2c9fJobhkwkZUbtnld2i4FhUX8OH0FV7w9lm6P/sQT380io1olnjmvHb/eeTT3nNJCzb9ilMciIv6gPBYR8Q9lsoiIPyiPRURCI2QjAM0sGngBOBZYAowxs8HOuenFVpsA5DjntpjZNcDjwLmhqklESs/MOLlNXY5qVpMXfp7L/4Yt4PvpK7jpmGwu6daA2OiQnj+wT7lrtjBgTC4Dx+WyYsN20pLjuapnFufk1KNBaqInNfmd8lhExB+UxyIi/qFMFhHxB+WxiEjohHIK0E7AXOfcfAAz6w/0AXaFt3Pu52Lr/wpcGMJ6ROQgVI6L4fbjm3F2x3rc/8U0HvxqBv3H5HLfKS05PDu1XGrYXlDID9NX0P/3XEbMXUWUwZFNa/LvPvXo1aymZ83IMKI8FhHxB+WxiIh/KJNFRPxBeSwiEiKhbACmA7nF7i8BOpew/uXAN3t7wMz6Af0AMjMzy6o+ETkADVITefOyTgyZsYL7v5jOha//xomta/N/J7UgvWqlkOxz7sqN9P89l08mLGXN5h2kV63ELcc24eycDOqkhGafEUp5LCLiD2WWx6BMFhE5RHqPLCLiD8pjEZEQCWUDsNTM7EIgBzhib487514FXgXIyclx5ViaiOzh6Oa16N44ldeGz+f5n+fy08yVXHtkY67smUVCbPQhb3/rjkK+mvIH/X9fzNhFa4mNNo5tUYvzDsvk8MapREVZGRyF7IvyWETEH/aXx6BMFhEpL3qPLCLiD8pjEZEDE8oG4FKgXrH7GcFluzGzY4D/A45wzm0PYT0iUkYSYqO57qhsTu+QwcNfzeCpH2YzcNwS7jm5BUc3r4nZgTfppi5dT/8xi/l8wjI2bi8gKy2Ru05sxhkdMkhNig/BUVQoymMREX9QHouI+IcyWUTEH5THIiIhEsoG4Bgg28waEgjt84Dzi69gZu2BV4DezrmVIaxFREIgvWolXrigA+fPXcW9g6dxxTtj6dU0jXtOaUnD1MT9Pn/Dtnw+n7iMAWMWM3XpBuJjojipdR3O65TJYQ2qHVQjUfZKeSwi4g/KYxER/1Ami4j4g/JYRCREQtYAdM4VmNl1wHdANPCGc26amT0AjHXODQaeAJKAgcEP+hc7504NVU0iEhrdG6fyzY09eHvUQv774xyO/88wrujRkOuOakzluN1jxjnHuEVr+fD3XL6asoxt+UU0r1OFB/q0pE+7dFIqxXp0FJFLeSwi4g/KYxER/1Ami4j4g/JYRCR0zLnwmg45JyfHjR071usyRGQfVm7cxqPfzOST8Uupk5LAXSc25+Q2dVi7JZ9Pxi+h/5hc5q7cRFJ8DKe2q8t5h9WjdXpKhR3tZ2bjnHM5XtdxMJTHIhJJwjmPQZksIpFDeSwi4g/KYxER/zjYTA7lFKAiUgHVTE7g6XPacUHnTO75fBrXfziB536aw4JVm8kvdHTIrMrjZ7XhpNZ1SIxXBImIiIiIiIiIiIiIlDV9+i4iIdGxfnUGX3c4H/6+mP5jFnNRlwac16keTWole12aiIiIiIiIiIiIiEhEUwNQREImOsq4sEt9LuxS3+tSREREREREREREREQqjCivCxARERERERERERERERGRsqMGoIiIiIiIiIiIiIiIiEgEUQNQREREREREREREREREJIKoASgiIiIiIiIiIiIiIiISQdQAFBEREREREREREREREYkgagCKiIiIiIiIiIiIiIiIRBA1AEVEREREREREREREREQiiBqAIiIiIiIiIiIiIiIiIhFEDUARERERERERERERERGRCKIGoIiIiIiIiIiIiIiIiEgEUQNQREREREREREREREREJIKoASgiIiIiIiIiIiIiIiISQdQAFBEREREREREREREREYkgagCKiIiIiIiIiIiIiIiIRBA1AEVEREREREREREREREQiiBqAIiIiIiIiIiIiIiIiIhFEDUARERERERERERERERGRCKIGoIiIiIiIiIiIiIiIiEgEUQNQREREREREREREREREJIKEtAFoZr3NbJaZzTWzf+7l8XgzGxB8/DczaxDKekREKirlsYiIPyiPRUT8Q5ksIuIPymMRkdAIWQPQzKKBF4ATgBZAXzNrscdqlwNrnXONgf8Aj4WqHhGRikp5LCLiD8pjERH/UCaLiPiD8lhEJHRCOQKwEzDXOTffObcD6A/02WOdPsDbwduDgKPNzEJYk4hIRaQ8FhHxB+WxiIh/KJNFRPxBeSwiEiKhbACmA7nF7i8JLtvrOs65AmA9UGPPDZlZPzMba2Zj8/LyQlSuiEjEUh6LiPhDmeUxKJNFRA6R3iOLiPiD8lhEJERCeg3AsuKce9U5l+Ocy0lLS/O6HBGRCkt5LCLiH8pkERF/UB6LiPiD8lhEZHehbAAuBeoVu58RXLbXdcwsBkgBVoewJhGRikh5LCLiD8pjERH/UCaLiPiD8lhEJERC2QAcA2SbWUMziwPOAwbvsc5g4JLg7bOAn5xzLoQ1iYhURMpjERF/UB6LiPiHMllExB+UxyIiIRITqg075wrM7DrgOyAaeMM5N83MHgDGOucGA68D75rZXGANgYAXEZEypDwWEfEH5bGIiH8ok0VE/EF5LCISOiFrAAI4574Gvt5j2T3Fbm8Dzg5lDSIiojwWEfEL5bGIiH8ok0VE/EF5LCISGqGcAlREREREREREREREREREypkagCIiIiIiIiIiIiIiIiIRRA1AERERERERERERERERkQiiBqCIiIiIiIiIiIiIiIhIBFEDUERERERERERERERERCSCqAEoIiIiIiIiIiIiIiIiEkHUABQRERERERERERERERGJIGoAioiIiIiIiIiIiIiIiEQQNQBFREREREREREREREREIogagCIiIiIiIiIiIiIiIiIRxJxzXtdwQMwsD1h0EE9NBVaVcTl+ouMLb5F+fBD5x3iwx1ffOZdW1sWUB+XxPkX68UHkH6OOL7xVuDwGZXIJdHzhTccX3pTHB0Y/D+FNxxfedHx7pzyOTDq+8BbpxweRf4zlmslh1wA8WGY21jmX43UdoaLjC2+RfnwQ+ccY6cdXliL9tYr044PIP0YdX3iL9OMra5H+eun4wpuOL7xF+vGVtUh/vXR84U3HF94i/fjKWqS/Xjq+8BbpxweRf4zlfXyaAlREREREREREREREREQkgqgBKCIiIiIiIiIiIiIiIhJBKlID8FWvCwgxHV94i/Tjg8g/xkg/vrIU6a9VpB8fRP4x6vjCW6QfX1mL9NdLxxfedHzhLdKPr6xF+uul4wtvOr7wFunHV9Yi/fXS8YW3SD8+iPxjLNfjqzDXABQRERERERERERERERGpCCrSCEARERERERERERERERGRiKcGoIiIiIiIiIiIiIiIiEgEifgGoJm9YWYrzWyq17WEgpnVM7OfzWy6mU0zsxu9rqksmVmCmf1uZpOCx3e/1zWFgplFm9kEM/vS61rKmpktNLMpZjbRzMZ6XU9ZM7OqZjbIzGaa2Qwz6+p1TX6lPA5vyuPwpzyW4iI5k5XHkSGS8xiUyfKnSM5jUCZHAuVxeFMel57yOLxVhDyGyM5k5XGI9hvp1wA0s57AJuAd51wrr+spa2ZWB6jjnBtvZsnAOOA059x0j0srE2ZmQKJzbpOZxQIjgBudc796XFqZMrNbgByginPuZK/rKUtmthDIcc6t8rqWUDCzt4HhzrnXzCwOqOycW+dxWb6kPA5vyuPwpzyW4iI5k5XHkSGS8xiUyfKnSM5jUCZHAuVxeFMel57yOLxVhDyGyM5k5XFoRPwIQOfcMGCN13WEinPuD+fc+ODtjcAMIN3bqsqOC9gUvBsb/IqorrWZZQAnAa95XYscGDNLAXoCrwM453bojfS+KY/Dm/JY/Ex5fOAiOZOVx+FPeRzelMkHJpLzGJTJ4U55HN6UxwdGeRzeIj2PQZkczrzM44hvAFYkZtYAaA/85nEpZSo4tHkisBL4wTkXUccH/Bf4B1DkcR2h4oDvzWycmfXzupgy1hDIA94MDr9/zcwSvS5KvKc8Dlv/RXkcrpTHslfK47D1XyI7j0GZLBWQMjks/RflcThTHsteKY/D1n+J7ExWHoeAGoARwsySgI+Bm5xzG7yupyw55wqdc+2ADKCTmUXMMHwzOxlY6Zwb53UtIXS4c64DcAJwbXBKhUgRA3QAXnLOtQc2A//0tiTxmvI4PCmPw57yWP5CeRyeKkgegzJZKhhlcvhRHkcE5bH8hfI4PFWQTFYeh4AagBEgOK/xx8D7zrlPvK4nVILDYn8GentcSlnqDpwanOO4P3CUmb3nbUllyzm3NPjvSuBToJO3FZWpJcCSYmcUDSIQ5lJBKY/DmvI4vCmPZTfK47AW8XkMymSpWJTJYUt5HP6Ux7Ib5XFYi/hMVh6HhhqAYS54gdPXgRnOuae9rqesmVmamVUN3q4EHAvM9LSoMuScu9M5l+GcawCcB/zknLvQ47LKjJklBi8sTHBY83HAVG+rKjvOueVArpk1DS46GoiIiyfLgVMehzflcXhTHktxyuPwFul5DMpkqViUyeFLeRz+lMdSnPI4vEV6JiuPQyemPHbiJTP7EDgSSDWzJcC9zrnXva2qTHUHLgKmBOc4BrjLOfe1dyWVqTrA22YWTaBh/ZFz7kuPa5LSqwV8GniPQQzwgXPuW29LKnPXA++bWRwwH7jM43p8S3kc9pTH4U15LLuJ8ExWHovfKZNllwjPY1Ami78pj2UX5XHYUx6HN+VxiJhzrjz2IyIiIiIiIiIiIiIiIiLlQFOAioiIiIiIiIiIiIiIiEQQNQBFREREREREREREREREIogagCIiIiIiIiIiIiIiIiIRRA1AERERERERERERERERkQiiBqCIiIiIiIiIiIiIiIhIBFEDUPbLzP5jZjcVu/+dmb1W7P5TZnbLQWz3LTM7q4xqrGtmg8piW/vYfjszG21m08xsspmdW+yxhmb2m5nNNbMBZhYXXH6LmU0Prj/EzOoXe84lZjYn+HXJPvZZw8x+NrNNZvb8Ho89ZGa5ZrZpP3XvdT0zu9TM8sxsYvDrioN5XUSkfCmPlcci4g/KY+WxiPiHMlmZLCL+oDxWHov/qAEopTES6AZgZlFAKtCy2OPdgFEe1LWLc26Zc65MfhHswxbgYudcS6A38F8zqxp87DHgP865xsBa4PLg8glAjnOuDTAIeBzAzKoD9wKdgU7AvWZWbS/73Ab8C7htL499EXzu/pS03gDnXLvg12v7WEdE/EV5rDwWEX9QHiuPRcQ/lMnKZBHxB+Wx8lh8Rg1AKY1RQNfg7ZbAVGCjmVUzs3igOTDezDqa2VAzGxc8w6MOgJk1MrNvg8uHm1mzPXdgZv8Ons0RbWaPFjvr4cm9rHtEsbMOJphZspk1MLOpwccvNbNPgvucY2aPF3tubzMbb2aTzGxIcFmimb1hZr8Ht9dnz30652Y75+YEby8DVgJpZmbAUQTCGeBt4LTgej8757YEl/8KZARvHw/84Jxb45xbC/xA4BfCnvvc7JwbQSDE93zsV+fcH3suP9j1RCRsKI+VxyLiD8pj5bGI+IcyWZksIv6gPFYei8/EeF2A+J9zbpmZFZhZJoEzNUYD6QQCfT0wBXDAc0Af51yeBYY3PwT8DXgVuNo5N8fMOgMvEgg8AMzsCSAZuAyoDpwONHPOOfvzDInibgOudc6NNLMk9hJuQDugPbAdmGVmzwXX+x/Q0zm3wAJnUQD8H/CTc+5vwf39bmY/Ouc27+31MLNOQBwwD6gBrHPOFQQfXhJ8bfZ0OfBN8HY6kFvssX09J9TONLOewGzgZudc7v6eICLeUh7vTnksIl5RHu9OeSwiXlIm706ZLCJeUR7vTnksfqAGoJTWKALB3Q14mkDYdCMQ3iOBpkAr4IfACQ1EA38Ew7UbMDC4HCC+2Hb/BfzmnOsHYGbrCYTs62b2JfDlXmoZCTxtZu8DnzjnlhTb9k5DnHPrg9ucDtQHqgHDnHMLAJxza4LrHgecamY7h0knAJnAjD03Gjwj5V3gEudc0V72+xdmdiGQAxyx35XLzxfAh8657WZ2FYGzTo7az3NExB+UxyiPRcQXlMcoj0XEN5TJKJNFxBeUxyiPxT80BaiU1s45nFsTGL79K4GzN3bO3WzANPfnfMCtnXPHEfgZW1dseTvnXPNi2x0DdNx5JkXwLIhOBIZDnwx8u2chzrlHgSuASsBI28twcAJnbexUSMnNbgPOLFZfpnNub8FdBfgK+D/n3K/BxauBqma2c/sZwNJizzmGwNkhpzrndta0FKhXbNMZwFIzO93+HJaeU0K9ez+IwND3nc9/oKR1nXOri9XzGtDxQPcnIp5RHiuPRcQflMfKYxHxD2WyMllE/EF5rDwWH1EDUEprFIEwXeOcKwye+VCVQICPAmYRmM+4K4CZxZpZS+fcBmCBmZ0dXG5m1rbYdr8FHgW+ssA8zElAinPua+BmoPi6BLfRyDk3xTn3GIHw31t4782vQE8zaxjczs7h298B11vwVAwza7+XfcYBnwLvOOd2ztWMc84BPwM7Lx57CfB5se28QiC4Vxbb3HfAcRaY/7oagbNHvnPOfVrsF8jYUh7TLsHvy87n31PSusGzUHY6lb2cqSIivqU8Vh6LiD8oj5XHIuIfymRlsoj4g/JYeSw+ogaglNYUIJVAABZftt45t8o5t4NAgD1mZpOAiQTO7AC4ALg8uHwasNsFUp1zAwnMqzyYwDzOX5rZZGAEcMtearnJzKYG18nnz3mRS+ScywP6AZ8EaxkQfOjfQCww2cymBe/v6RygJ3BpsTMk2gUfuwO4xczmEpjP+fXg8ieAJAJD1yea2eBgHWuC+xgT/HrA/TmUfDdmtpDAcPlLzWyJmbUILn/czJYAlYPL79vH8/e13g1mNi34OtwAXLrPF05E/EZ5rDwWEX9QHiuPRcQ/lMnKZBHxB+Wx8lh8xALNZxERERERERERERERERGJBBoBKCIiIiIiIiIiIiIiIhJB1AAUERERERERERERERERiSBqAIqIiIiIiIiIiIiIiIhEEDUARURERERERERERERERCKIGoAiIiIiIiIiIiIiIiIiEUQNQBEREREREREREREREZEIogagiIiIiIiIiIiIiIiISARRA1BEREREREREREREREQkgqgBKCIiIiIiIiIiIiIiIhJB1AAUERERERERERERERERiSBqAIqIiIiIiIiIiIiIiIhEEDUARURERERERERERERERCKIGoASVsysh5nNKna/qZlNNLONZnZDKbdxjZmtMLNNZlYjdNWWDTN7y8we9LoOEQkfFTErQ8nMLjCz772u41CZ2UIzO8brOkQiWTjkr5llBrcdXdbbFhEREREREf9QAzAMBT/A2xr8w33nV90y2Ga5fShoZveZWX7ww5CNZjbbzJ43szolPc85N9w517TYon8APzvnkp1zz+7vOMwsFngaOM45l+ScW10Gx3JAr11F/gA2+H1/z+s6pGJQVvorK8OFmTUwM2dmMTuXOefed84d52VdIuFE+euv/N1zn865xcFtFx7qtv3Or++7Q1mXmZ1jZqPMbIuZ/bKXx52ZbS72f/O1UNQhIiIiIiLeUwMwfJ0S/MN959cyL4sp/kHpARjgnEsGqgOnA7WBcfv6YGUf+6gPTDuAfdYCEg7wOTv3b2am/zMi4UVZGaCsrAAO8ufrYPaj77GUhvI3QPm7H+WVXWXJy5pL8X1eA/wXeLSEddoW+795RZkWKCIiIiIivhF2fyDKvplZipm9bmZ/mNlSM3tw59Q+ZtbIzH4ys9VmtsrM3jezqsHH3gUygS+CZ4H+w8yONLMle2x/15mqwbOiB5nZe2a2Abi0pP2XxDmX75ybBpwL5AG3BvdxpJktMbM7zGw58GbxuszsJ6AX8Hyw7g/3PI496m8C7JySaV3w+ZhZNzMbY2brg/92K/acX8zsITMbCWwBsvbY5l9eu+DyU81smpmtC26j+X7WH2hmy4M1DDOzlvt73faoo5qZfWlmeWa2Nng7Y4/jeDB4NvAmM/vCzGoEfw42BI+7QbH1S3pNdjtj2YqN6rM/R85cYmaLgz9r/xd8rDdwF3BusIZJB3KMImVFWVn+WRlcp56ZfRLMqdVm9nxweZSZ3W1mi8xspZm9Y2Ypwcf2mSnBxyuZ2dvB3JsR/J4sKfZ4XTP7OLjPBVZs+j0z62RmY4MZuMLMng4+NKzYsW8ys65mdqmZjSj23P29Fv82s5EWGDX0vZmllvS9NbOE4M/Iagv83hhjZrWCj5Umcy83s8XAzu/VlcHXY6OZTTezDsV2187MJgdrH2BmCcHnVLP9/x7Z7XtsZseZ2azgtl40s6FmdkWx5/wtWMdaM/vOzOqX9DpI5Csp/0z5W27vVW2Pkc7BbTxiZr8HM/FzM6u+n+/lzm30M7Nlwdf0tmKPR5nZP81sXvB7+tHObR5odlnJWX5fcNvvBJ83zcxy9nXs+zmmiy3wu2i1mf3rUH6eDvTnObi8iwXeq68zs0lmdmRpv8/FOed+dM59BHjadBcREREREe+pARhZ3gIKgMZAe+A4YOcHcQY8AtQFmgP1gPsAnHMXAYv580ztx0u5vz7AIKAq8P5+9r9fwWmIPgd6FFtcm8BZ1/WBfnusfxQwHLguWHffko7DOTcb2NlYq+qcOyr4QcRXwLNADQJTLn1lu19v5aLgvpOBRXts8y+vXfDDmw+Bm4A04GsCf+DHlfBafwNkAzWB8QRezwMRBbwZfJ0yga3A83usc17wWNKBRsDo4HOqAzOAewFK+Zrsz+FAU+Bo4B4za+6c+xZ4mMDZ9EnOubYHeIwiZeUtlJXlmpXBD0S/DC5vQCCH+gcfvjT41YvAB5pJ/DW//pIpweX3BreXBRwLXFhsn1HAF8Ck4P6OBm4ys+ODqzwDPOOcq0IgEz8KLu9Z7NiTnHOj9ziW0rwW5wOXEcj0OOA2SnYJkELg560GcDWBHC+tIwj8vB5vZmcT+Jm9GKgCnAoUn0LwHKA30BBoQ+C1h9L9Hin+PV5P4Of6zmDNs4DiTYk+BE76OIPA78LhBH43SsX2Fspfz9+r7uPwLgb+BtQh8Bo9u7/XI6gXgfewxwF32J8nLFwPnEYgn+oCa4EX9njufrOrFFlOcN3+BL7Pgwlm14H83JhZC+BF4ILga5AS3F9xB/LzdEA/z2aWTuD7/CCBn6fbgI/NLK3Y/vf5fT4Iwyxw8uEnVuwkQBERERERiSxqAIavz4Jnh64zs88sMFLgROAm59xm59xK4D8Emj445+Y6535wzm13zuUR+PDgiEOsYbRz7jPnXBGBP9T3uf8DsIzAH707FQH3Bus+kA9DS+skYI5z7l3nXIFz7kNgJnBKsXXecs5NCz6eX4ptngt8FXy984EngUoU+2B0T865N5xzG51z2wl8ONDWgiNgSsM5t9o597FzbotzbiPwEH/9/r7pnJvnnFtPoOE4L3iGcAEwkMAHF1C612R/7nfObXXOTSLwgY2afeIVZWXZONSs7ETgQ9Dbg8e9zTm3c0TdBcDTzrn5zrlNBBpK59nu06vtK1POAR52zq11zi1h9w+sDwPSnHMPOOd2OOfmA//jz9c6H2hsZqnOuU3OuV/L8LV40zk3O/i9+Ahot59t5hP4YL+xc67QOTfOObehlPUA3Bd8XbcS+PD5cefcGBcw1zlX/IPiZ51zy5xzawh8qN4OSv17ZNf3GDgBmOac+yR4/1lgebF1rwYecc7NCD7+MIHRhxoFWHEof8tGKN6r7s27zrmpzrnNwL+Ac6wUoyMJ5PNm59wUAicR9A0uvxr4P+fckmLvb8/aI9tLk137y3KAEc65r12gQfsuB/e+8yzgC+fcCOfcDuAewO2xTql/ng7i5/lC4OvgcRQ5534Axgb3sVNZfJ8J1tEAaEbg5/lLC8NpWEVEREREZP/0Rj98neac+3HnHTPrBMQCf5jZzsVRQG7w8VoERjv0IHDWaBSBM3EPRW6x2/VL2v8BSCdw3Yqd8pxz2w66wv2ry1/PoF3E7mf8Hugx7LZN51yRmeXy17OIgV0jYx4CziYwSqIo+FAqgREW+2VmlQl86NAbqBZcnGxm0cEPQwBWFHvK1r3cT9pb/UF7vib7U/xD4C3Fti1S3pSVZeNQs7IesCjYCNrfthcReH9Sq9iyfWVK3T32u+drXdfM1hVbFk1gNA7A5cADwEwzW0DgQ+wvSziGfdW7s+bir8WBZuC7BF6j/sEp4t4j8MF5aT/gLX7c9YB5Jay7Z211odS/R4rvZ7fX3jnnbPfpGOsDz5jZU8WWGYHX6VBHrkh4UP6WjVC8V92b4ttYROC1SmX394uleV7r4O36wKdmVlTs8UJ2z/bSZNf+shz+mmsJZhazj985+7Jnpm0xs9V7rFPqn6eD+HmuD5xtZsUbu7HAz/vY/0Fzzu2c6nqHmd0IbCAwSnFKWWxfRERERET8Qw3AyJELbAdS9/HH7sMEzmJt7ZxbY2ansfvUXnue4boZqLzzTrBJlbbHOsWfs7/971dwip9TgB+LLd6zrv050PWXEfiDu7hM4NsD2Oaejy/jzw8/sMCnAvWApftY/3wCUwodAywkMOXQWgIflJbWrQSmx+vsnFtuZu2ACQe4jZ3295rs9rNBYOqr0jrQ749IWVNWHtz6h5qVuUDmPj6Q3XPbmQSmVFsBZFCyP4LrTA/er7fHPhc457L39kTn3Bygb/D1PAMYFJxSb3+vTWleiwMSbPTdD9wfnIrtawJTar5O6TJ3z5+xRgdRRml+jxTfz87XHtj1u6749ysXeMg5d6BTWkvkUv4e3PqheK+6N8XzM5PAyORVpXzezGLP23nduVzgb865kXs+odiUk6XJrhKzvBRK+3r/QSADgcA1ZgmMzN7Xtsr65zmXwCjMK0uoMVTvox0H9zeDiIiIiIj4nKYAjRDOuT+A74GnzKyKmUUFLz6/c6qZZGATsD54jYnb99jECna/mPxsAmfPnmRmscDdQPwh7H+fzCwmeD2nDwl8sPl0qQ567/Y8jv35GmhiZucH6zgXaEHgWlUHu8+PgJPM7Ojga3crgQ8IRu1j/eTg46sJfJD18AHsu/g2tgLrgteKufcgtrHT/l6TiQSm54s1sxwCUyaV1gqgQfADNJFyp6zc53Hsz6Fm5e8EPlx91MwSzSzBzLoHH/sQuNnMGppZEn9eK7Q0H9B/BNxpZtWC36/r9tjnRjO7w8wqmVm0mbUys8MAzOxCM0sLTuW2LvicIiAv+O++Xp+y+L2xGzPrZWatgw2MDQQ+eN85amYiB5a5rwG3mVlHC2hspZt280B/j3wFtDaz0ywwddy17N6cfJnA96Zl8BhTLHCNL6mglL/7PI79CcV71b250MxaWGA08APAoGKjf0vyLzOrHPy/fhkwILj8ZeChnfljZmkWuDbovuwru0rM8lIo7es9CDjFzLqZWRyBKUv32RQLwc/ze8H9Hx88xgQzO9LM9ncizF/sfD6Bk32jgtuKDT7W0szaBddJAp4icJLijAPdj4iIiIiI+J8+hI8sFwNxBEZCrCXwh2yd4GP3Ax0ITCn5FfDJHs99BLjbAtdpuc0FrhP3dwJ/jC8lcJb1EkpW0v735lwz2xSsaTCBBlhH59yyEp6zP7sdx/5Wds6tBk4m0KRbDfwDONk5V5oznve6T+fcLALX8XiOwJnTpwCnBK8nsrca3yEwZdJSAq9daa9DVdx/CVxncFXw+YcyEmV/r8m/CJyhvZbAz9UHB7D5gcF/V5vZ+IOtUeQQKSvLOSuDHyKfAjQGFhN4jc4NPvwGgSkwhwELgG3A9aU8jgeC21pAYETOIAInVOzc58kErnG3gEA+vkZglDUEprqcFnxtnwHOc4HrDG4hMC3zyODr06UsX4t9qB2sfQOBD2GHEnhN4AAz1zk3MFj/B8BG4DN2v17ZvvyXA/g9Ejzes4HHCbwOLQhcr2rn6/8p8BiBaU03AFMJXDdQKjblrw/eq+5jnXeBtwhMp5kA3FDKbQ8F5gJDgCedc98Hlz9D4DX73sw2EsiVzvvayL6yqxRZvj+ler2dc9MI/O7pT+CElU3ASoKZtg9l+fOcS2BGkLsInIiSS6BpeDB/r19E4ISOlwhMQbqVwHUTITAF6wACv2/mE7gW4MmHeE1BERERERHxKXNOM/KJiIhI+DOzawg08vY7okfKlgVGdi8BLnDO/by/9UXEP8zsF+A959xrB/CcBgQacrEHO6WqnwVHx60Dsp1zCzwuR0RERERE5KBoBKCIiIiEJTOrY2bdg1OvNSUwQuZTr+uqKIJT1VU1s3gCo1aMgxvFLiLiOTM7JTidaSLwJDCFwPW5RUREREREwpIagCJhwszuMrNNe/n6xuvaREQ8Ege8QmC6uJ+Az4EXPa1oH8zsgn1k+DSvazsEXYF5/Dnd9WnOua3eliQiZSXScqsUx9MHWBb8yiYwotyX0+Xs4zg2mVkPr2sLJ2b2hpmtNLOp+3jczOxZM5trZpPNrEN51ygiUhEoj0VEQkdTgIqIiIiIiIhIhWJmPQlc7/Ed51yrvTx+IoFrQ55I4BqWzzjn9nktSxEROTjKYxGR0NEIQBERERERERGpUJxzw4A1JazSh8CH0c459ytQ1czqlE91IiIVh/JYRCR0Yrwu4EClpqa6Bg0aeF2GiEiZGDdu3CrnXJrXdRwM5bGIRJJwzmNQJotI5PBRHqcDucXuLwku+2PPFc2sH9APIDExsWOzZs3KpUARkVBSHouI+MfBZnLYNQAbNGjA2LFjvS5DRKRMmNkir2s4WMpjEYkk4ZzHoEwWkcgRjnnsnHsVeBUgJyfHKY9FJBIoj0VE/ONgM1lTgIqIiIiIiIiI7G4pUK/Y/YzgMhERKV/KYxGRg6QGoIiIiIiIiIjI7gYDF1tAF2C9c+4v082JiEjIKY9FRA5S2E0BKiIiIiIiIiJyKMzsQ+BIINXMlgD3ArEAzrmXga+BE4G5wBbgMm8qFRGJbMpjEZHQUQNQRERERERERCoU51zf/TzugGvLqRwRkQpLeSwiEjqaAlREREREREREREREREQkgqgBKCIiIiIiIiIiIiIiIhJB1AAUERERERERERERERERiSBqAIqIiIiIiIiIiIiIiIhEEDUARURERERERERERERERCKIGoAiIiIiIiIiIiIiIiIiESRkDUAze8PMVprZ1H08bmb2rJnNNbPJZtYhVLWIiFR0ymQREX9QHouIiIiIiIhIeQjlCMC3gN4lPH4CkB386ge8FMJaREQqurdQJouI+MFbKI9FREREREREJMRC1gB0zg0D1pSwSh/gHRfwK1DVzOqEqh4RkYpMmSwi4g/KYxEREREREREpD15eAzAdyC12f0lw2V+YWT8zG2tmY/Py8sqlOBGRCqZUmaw8FhEJOb1HFhEREREREZFD5mUDsNScc68653KcczlpaWlelyMiUmEpj0VE/EOZLCIiIiIiIiL74mUDcClQr9j9jOAyEREpf8pkERF/UB6LiIiIiIiIyCHzsgE4GLjYAroA651zf3hYj4hIRaZMLgNFRY7l67fhnPO6FBEJX8pjERERERERETlkMaHasJl9CBwJpJrZEuBeIBbAOfcy8DVwIjAX2AJcFqpaRMRbzjnMzOsyKjRlcugsX7+N4XPyGD5nFSPmrmLN5h3UTI6nR3YaPZuk0r1xKqlJ8V6XKSI+oTwWERERERERkfIQsgagc67vfh53wLWh2r+IhJZzjnVb8snbtJ28jdtZuXEbeRt33t6+2+0i53iub3uObFrT67IrLGVy2dm6o5DfF65h+OxA02/Wio0ApCbFcUSTNFrWrcKE3HUMmbmCj8cvAaBl3SqBhmB2Kh0bVCM+JtrLQxARDymPRURERERERKQ8hKwBKCLhaVt+Ias2/bWJl7frK9jo27Sd/MK/TnMYHxNFzSrxpCXF0ygtiS5ZNRg9fzU3D5jI1zf2oE5KJQ+OSuTgOeeYuXwjw4INv98XrmFHQRFxMVF0alCdMzqk0yM7jWa1k4mK+nOka2GRY+rS9Qyfk8ewOat4bfh8Xh46j0qx0XTOqr6rIdi4ZpJGyIqIiIiIiIiIiEiZUgNQpAJwzrF2S36xht5eRutt2s7KDdvYsK3gL883gxqJcaQmxZOWHE/jmsmkJQdu1wz+u/MrOT7mL82MeXmbOOW5Edz44UQ+uLIzMdFeXn5UZP/yNm5nxNw8hs9exfC5q8jbuB2AJrWSuKhLfXpkp9K5YQ0qxe17JF90lNG2XlXa1qvKdUdls2l7Ab/OW71rutB/z5oOQJ2UBHpkp9IjO43ujVOpnhhXLscoIiIiIiIiIiIikUsNQPG9lRu38en4pURHGfGx0cTHRBEfE0XCrtvRxMdG7bqdELv7srjoqIgdXbMtv/AvTby8DduKTcsZ+HfVPkbrJcRGUTM5gZrJ8WTXTKJboxq7NfRqJieQlhxP9cQ4Yg+hadcoLYmHT2/NTQMm8t8f53Db8U0P5bBFyty2/ELGLVrLsDmBpt/0PzYAUK1yLIdnp9EjO5We2WnUTkk46H0kxcdwTItaHNOiFgC5a7YwYu4qhs/J49upy/lo7BLMoHV6yq6GYIfMasTFqGEuIiIiIiIiIiIiB0YNQPG9R7+eyScTlh7SNnZrGO5sEO7WRNy9abhbc7HYcxJi/7qspGZkfEzUblMClkZRkWPtlh1/NvE2bN+jobdt1+2N+xyt9+fovCa1kncfqZcUT80qgcZeYlx0uTVHT2ufzqh5q3jhl7m7pj8U8YpzjrkrNzFsziqGzc7jtwWr2ZZfRGy00bF+NW4/vik9swPX8zvQ/8OlVa96Zfp2yqRvp0wKCouYvHR9YMThnDxeHjqfF36eR+W4aLpm1Qg0BJukkZWaGLEnNIiIiIiIiIiIiEjZUQNQfC13zRY+n7SMS7s14JbjmrAtv5Dt+UVsLyhie0Fh4N/8IrYV7FweXFZQxPb8wt3/3fmc3dYPLNu0vWCv29mWX0jRXwfOHZC46Ki/NAyLj2SMj40mymD1ph27RusV7GWnleOidzXxmtZOpkd22q6GXlrwmns1g6P1/DrF5v2ntmJi7rrA9QBv6EHNKgc/mkrkQK3ZvCMw4i54Lb/lG7YBkJWWyHmHZQam9cyqQVJ8+f9qjImOokNmNTpkVuPGY7LZsC2f0cWmCx0ycyUA6VUr0bNJYHRgt0Y1qFpZ04WWlaIix/IN21i0eguFRY7oKCMm2oiOMmKjona7HxNlxERHERP15/3Av1HERAfuq1ErIiIiIiIiIiJeUgNQfO1/w+cTZXDVEVlUSYilSkJsuddQUFjEtn01EveybGfjcM8mZfGmYvEm5Yat+RQWOWokxdGsdjI1g828tOSEYrfjSfSgKVHWKsVF88L5HTjl+RHc2H8i713RmegQja4S2VFQxPjFa3c10aYsXY9zUCUhhsODU2we3jiVetUre13qX1RJiOX4lrU5vmVtABat3szwOYHRgV9O+oMPf88lyqBNRlV6BkcHtqtX9ZCm6q0oNm7LZ37eZuav2sSCvM3MW7WZ+XmbWbhqM1vzC8tsP1EGMcUah4Em4Z9Nw9joP5uGxdeJ2VuzMSqK6GjbreH41wZkVLFt7m1fgftxMVH0alqTlMrl//tURERERERERETKT/h3FCRi5W3czoAxuZzRPoM6KZU8qyMmOoqk6ChPRgVFouxayTzQpxX/GDSZ536aw03HNPG6JIkQzjkWrPqzUTZ63mo27ygkOspoX68qNx/ThB7ZqbTJqBp2jef6NRKpXyORC7vUp6CwiElL1jEsOF3o8z/P5dmf5pIUH0PXRjUCDcHsNOrXqFxhR6HlFxaRu2YL8/M2s2BVoNk3L3g7b+P2XetFGWRUq0xWWiJdsqqTlZZEwxqJxMVEUVBURGGRo6DIUVDoKCwqoqDIBZYVuj8fKyra7f7O9QoKd7//57Z2v19Y+Od2im97e0EhhUWO/F3bLiq2j53L99hW8Gt/WqVXYeBV3agUFx3Kb4OIiIiIiIiIiHhIHQ3xrTdGLmBHYRFXHZHldSlSxs7umMGv81bzzJA5dGpYnW6NUr0uScLU+i35jJq3imFz8hg2exVL120FILN6ZU7vkE6P7DS6NqrhyejhUImJjqJj/ep0rF+dm49twvot+Yyev2rX9Qx/mL4CgHrVK9EjO42e2al0bZRKSqXIeQ0g0PBdtWkH8/M2BZt8m5mft4n5qzazePWW3aZSrlY5lqy0JI5skkbDtESyUpNolJZIZo3KxMdEVhOsqMhR6PZsMAabkkWO8YvWckP/Cdw2aBLP921fYZvEIuFu0/YCXhs+n+Z1quwaLS4iIiIiIiJSnBqA4ksbtuXz3uhFnNiqDllpSV6XI2XMzPj3aa2YuGQdN/WfyNc39iA1Kd7rsiQMFBQWMTF3HcOCo/wm5a6jyEFSfAzdGtXg6iMb0TM7lfo1Er0utdykVI6ld6s69G5VB+ccC1dvYXiwIfr5hKV88NtioqOMdvWq0iM4OrBtRopvrxW6p607CneN4luQt3ujb+O2gl3rxUVH0SC1Mk1qJtO7ZW0apiaSlZZEVmoi1RIrzrUSo6KMKIzYffQ106tWYum6rTz6zUya1krmhqOzy7dAETlk301bzn2Dp/HH+sC1bE9sXZv7T21FWrLeS4mIiIiIiMif1AAUX3p39CI2bi/gmiMbeV2KhEhifAwvnN+B014Yyc0DJvL2ZZ2ICrNpGaV8LF69hWFz8hg+J49Rc1ezcXvBruvfXderMT2bpNFW178DAs31hqmJNExN5OKuDcgvLGLC4nWBhuCcVTwzZA7//XEOyQkxdG+USo8mqfTMTvP8OohFRY6l67Yyf9VmFgSbezun79w5qnOnOikJZKUlclq79GCTL5FGaUnUrVop7KZ29cpVPbOYvXwjT/8wmya1kujdqo7XJYlIKSxbt5V7B0/jh+kraFY7mWf7tmfMwjX898c5jJo3lHtPacFp7dI1sldEREREREQANQDFh7buKOSNEQs4okkardJTvC5HQqh5nSrce0pL7vp0Ci8Nnce1vRp7XZL4wMZt+YyetzrY9FvFotVbgMDIpZPb1qFHdhrdGtWgauWKM6rrYMVGR9GpYXU6NazOrcc1Zd2WHYycuzo4QjCPb6ctB6BBjcr0yE6jR3YqXRvVIDlEU6au35LPvFWbgs29wL/z8zazcPVmthcU7VovKT6GrLREDmtQjXPT6u1q9DVMTaRynN66HCoz4+EzWrNg9WZuHjCJetUr07Kuft+K+FVhkePtUQt56vtZFDrHnSc042+HNyQ2OorDGlTnuBa1+cegSdw8YBJfTPqDh05v5en1s0VERERERMQf9Cma+M5HY3NZvXkHf9fovwqhb6d6jJ6/mqd/mE2nhtU5rEF1r0uSclZY5Ji8ZB3Dg9N6jl+8jsIiR+W4aLpm1eCybg3o0SSNrNREjWo4RFUrx3FSmzqc1CYwXej8VZsZPjvQaP14/BLe/XUR0VFGh8yqgesHNkmjdXrKAY2s21FQxOI1m5kXHME3P2/TrtF8qzfv2LVedJSRWb0yWamJ9GySSsPUJLLSAo2+tKR4fa9DLCE2mlcu6kif50dy5dtj+fy6wzV9oIgPTVmynrs+ncKUpes5smka/+7T6i+jthvXTGLg1d14e9RCnvhuFsc9PYy7TmrOeYfVU5aKiIiIiIhUYGoAiq/kFxbx6rD5dKxfjU4N1QiqCMyMh09vxZQl67j+gwl8fWMPqleg63VVVEvXbd3VeBoxdxXrt+YD0Do9hat6ZtEjO42O9asRF6NpPUPFzGiUlkSjtCQu7d6QHQVFjFu0luHBkZf/+XE2T/8wm5RKsRzeODVw/cAmaaRXrYRzjpUbtzMvb1Owyffndfly12yhyP25n9SkeLJSEzm2Ra3gKL5Aoy+zemVN2+qxmskJ/O/iHM56eRRXvzeOD67sTHzMPi4eKCLlavP2Ap76fjZvjVpAjaR4Xji/Aye2rr3Phl50lPG3wxtyTPNa3PHxZO78ZApfTl7Go2e08XyaZxEREREREfGGGoDiK4MnLmPpuq38+7SWOmO5AklOiOX58ztwxoujuG3gJF67OEfXA4xQ305dzhPfzWRe3mYAalWJ59gWtejZJI3ujWpQI0kjkLwSFxNF10Y16NqoBv/oDas3bWfkvNW7GrVfTfkDCEzFum7LDjbvKNz13ITYKBqmJtGqbgqntq27q9HXMDWRlEqhmU5Uykar9BSeOrsd134wnrs/ncrjZ7XR718Rj30/bTn3DZ7GHxu2cUHnTG4/vlmpszSzRmU+uLIzH/6ey8Nfz+C4/wzjH72bcknXBnpvJbIXZtYbeAaIBl5zzj26x+OZwNtA1eA6/3TOfV3edYqIRDrlsYhIaKgBKL5RVOR4aeg8mtVOplfTml6XI+WsVXoKd5/cnHs+n8ZrI+bTr6emgI1ESfExZFSrTN9OmfRskkZ2zSQ1G3yqRlI8p7aty6lt6+KcY+7KTQybs4rxi9eSlhS/65p8WWlJ1KmSoA+Ww9hJbeowa0U2zw6ZQ9PayVzRI8vrkkQqpD/Wb+Xez6fx/fQVNKudzHPnd6Bj/WoHvB0z4/zOmRzZNI3/+3QK938xna8m/8FjZ7WhUVpSCCoXCU9mFg28ABwLLAHGmNlg59z0YqvdDXzknHvJzFoAXwMNyr1YEZEIpjwWEQmdCtEAXL1pO/PyNmtKSZ/7fvoK5q7cxDPntVNDoIK6qEt9Rs1dzePfziKnQXU6ZB74h17ib4dnp3J4dqrXZcgBMjOyayWTXSuZy2nodTkSAjcdnc2cFRt5+OsZNKqZpBNxRMpRYZHjndELefK7WRQ6xz9PaMblhzc85GmS61atxBuXHsanE5Zy/xfTOeGZ4dx8TBOu7NGQGE3BLALQCZjrnJsPYGb9gT5A8Q+cHVAleDsFWFauFYqIVAzKYxGREKkQf/ndOnASf39/PJu3F3hdiuyDc46XfplLZvXKnNS6jtfliEfMjMfOakOdqglc/8EE1m/J97okEZEKISrKeOqctjSrXYUbPpjA3JWbvC5JpEKYunQ9p784kvu/mE5Og+r8cPMRXH1EozK7RqqZcUaHDH64pSdHN6vJY9/O5PQXRzHjjw1lsn2RMJcO5Ba7vyS4rLj7gAvNbAmB0SbX721DZtbPzMaa2di8vLxQ1CoiEsmUxyIiIVIhGoDXH5XNqk3beXPkAq9LkX0YNW81k5as5+ojGumM5AoupVIsz/ftwMqN27ht0CScc16XJCJSIVSOi+F/l+QQHxvFFW+PYd2WHV6XJBKxNm8v4N9fTufU50ewbN02nuvbnrcuO4x61SuHZH81kxN46cKOvHhBB/5Yv5VTnhvBf36YzY6CopDsTySC9AXecs5lACcC75rZX/5gdc696pzLcc7lpKWllXuRIiIVgPJYROQgVIhOS8f61Ti2RS1eGTqftZv1YZYfvfDzXGomx3Nmxz1P8JGKqG29qtzRuxk/TF/BmyMXel2OiEiFkV61Eq9c1JFl67Zx7QfjyS9Uc0CkrP0wfQXHPj2U10csoG+nTIbcegSntK1bLlPgn9i6Dj/cHNjfM0PmcMpzI5iUuy7k+xXxqaVAvWL3M4LLirsc+AjAOTcaSAA0n72ISNlSHouIhEiFaAAC3H58UzbvKODFX+Z6XYrsYWLuOkbNW80VPRoSHxPtdTniE5cf3pBjmtfikW9mMHnJOq/LERGpMDrWr85Dp7di5NzVPPjl9P0/QURKZfn6bVz97jiufGcsyQmxfHxNVx46vTUplWLLtY5qiXH859x2vHFpDuu35nP6iyN55OsZbMsvLNc6RHxgDJBtZg3NLA44Dxi8xzqLgaMBzKw5gQ+cNaeciEjZUh6LiIRIhWkANqmVzBkdMnh79CKWrtvqdTlSzIs/zyWlUiznd67vdSniI2bGk2e3IS0pnus+mMCGbboeoIhIeTk7px5X9mjI26MX8f5vi7wuRySsFRY53hq5gGOeHsovs1dyR+9mfHnD4XSsX93Tuo5qVovvb+nJuYfV45Vh8znhmeGMWbjG05pEypNzrgC4DvgOmAF85JybZmYPmNmpwdVuBa40s0nAh8ClTtcoEBEpU8pjEZHQqTANQICbjskGB//9YbbXpUjQnBUb+X76Ci7p1oCk+BivyxGfqVo5jufOb8/SdVv558eTdT1AEZFy9M8TmnNk0zTu/Xwao+et9rockbA0del6Tn9xJPd9MZ0O9avx/U1HcM2RjYj1yTWvqyTE8sgZbXj/is4UFBVxziujuffzqWzeXuB1aSLlwjn3tXOuiXOukXPuoeCye5xzg4O3pzvnujvn2jrn2jnnvve2YhGRyKQ8FhEJjZD+5Wlmvc1slpnNNbN/7uXxTDP72cwmmNlkMzsxlPVkVKvMRV3r8/H4JcxZsTGUu5JSeumXeVSKjeaybg28LkV8qmP96tx+fFO+nrKc935b7HU5YctveSwi/hcdZTzbtz0NUhP5+/vjWLx6i9clRQTlccWweXsBD345nVOfH8Gyddt4tm973r7sMDJrVPa6tL3q3jiV727qyaXdGvDOr4s4/r/DGDFnlddlRbRt+YWs3LCNLTsKdJKbiIiIiIiERMiGXJlZNPACcCywBBhjZoOdc8UvJnM3gWHdL5lZC+BroEGoagK4tldjBozJ5YnvZvHqxTmh3JXsR+6aLXw+aRmXdG1AtcQ4r8sRH+vXI4tf56/m319Op0NmVVrWTfG6pLDi1zwWEf+rkhDLaxfn0OeFkVzxzhg+vqYbyQnle72ySKI8rhiGzFjBPZ9PY+m6rZzfOZM7jm9GSmX//7+pHBfDvae05KTWdfjHx5O58PXfODenHned1Lzcr1MYqZxzTMhdx8CxS/hy0jI2BkdaRhkkxseQFPxKjI8hOeHP2zuXJyUEH9vL8p23E2KjMDOPj1RERERERPwglHMudgLmOufmA5hZf6APUPwDDgdUCd5OAZaFsB4AqifG0a9nFk//MJvxi9fSIbNaqHcp+/C/4fOJMriyZ0OvSxGfi4oynjq7LSc+O5zrPpjAF9cfriljD4wv81hEwkOD1ERevKADF7/xOzf1n8irF+cQHaUPlw+S8jiCLV+/jfu/mMY3U5fTpFYSH1/T1fPr/B2MnAbV+fqGHjwzZA6vDpvPL7NX8tBprTmmRS2vSwtbKzds45MJSxk4Npd5eZtJiI3ixFZ1aJ9Zlc07Ctm0rYBN2wNfm7f/eXv5+m1s3l7AxuDyolIMFIyOMhLjoklOiCUxPnq3hmJi3O7NwuK399ZQjI9RM1FEREREJJyF8hP0dCC32P0lQOc91rkP+N7MrgcSgWNCWM8ulx/ekHdGL+Sxb2bSv18X/VHjgbyN2xkwJpcz2mdQJ6WS1+VIGKiRFM+z57Wn7/9+5a5PpvDMee30f7f0fJvHIhIeujdO5d5TWnDP59N44rtZ/POEZl6XFK6UxxGosMjx3q+LeOK7WeQXFvGP3k254vAs4mL8cZ2/g5EQG80dvZtxYqs63D5oEle8M5Y+7epy7yktqa6ZO0ple0EhQ2asZODYXIbOzqPIQcf61Xj0jCxOalPngEdTO+fYml8YaA5uK2Dz9kI2bs8P3N5REGwiFrJpe37gsW1/NhM3bivgj2AzcdO2AjbtKKA0s47GRNmuxmBywh5Nwp1Nw4QYkuKjSYoPNBwDIxcDt6skxFKvuj+nvRURERERqQi8HkLTF3jLOfeUmXUF3jWzVs65ouIrmVk/oB9AZmbmIe80MT6G64/K5t7B0xg6O48jm9Y85G3KgXlj5AJ2FBZx1RFZXpciYaRzVg1uObYJT34/m26NanBep0PPA9nFkzwWkfBxUZf6zFq+kZeHzqNp7SROb5/hdUmRqlR5DMpkP5i2bD13fTKFSUvW0yM7lQdPa0X9Golel1VmWmekMPi6w3npl3k8//McRsxZxf19AtOE6kSsvZu6dD2Dxi3hs4lLWbcln1pV4rnqiEac1TGDRmlJB71dM6NyXAyV42KomXxoNRYVBZqJO0cXbgo2CzfuMQJxb8vXbc1nydotbN4eaEZuLqGZWCclgdF3Hn1oxYqIiIiIyEELZQNwKVCv2P2M4LLiLgd6AzjnRptZApAKrCy+knPuVeBVgJycnDK5QnrfTpm8NmI+j307i57ZaURpKqtys2FbPu+NXsSJreqQdQh/BEvFdM2Rjfl1/hruHTyNdplVaVa7yv6fJL7OYxEJD2bGfae2ZF7eJu74eAoNaiTSXlOpH6gyy+Pg48pkj2zZUcB/fpjNGyMXUq1yLM+c145T29aNyKZYXEwUNx6TTe9WtfnHoEmB6dhbLuPffVpRs0qC1+X5wupN2/l84jIGjlvCjD82EBcdxbEta3F2xwx6ZKf5btrkqODIvsT4GA71VNiiIseW/L9OY7pxWwER+N9BRERERCSshHJemjFAtpk1NLM44Dxg8B7rLAaOBjCz5kACkBfCmnaJi4ni1mObMuOPDXwxWZdWKU/vjl7Exu0FXHNkI69LkTAUHWX859x2VKkUy7Xvj2fLjgKvSwoHvs5jEQkfsdFRvHRBR2pXSaDfu+P4Y/1Wr0sKN8rjCPDTzBUc+/Qw/jd8Aefk1GPILUfSp116RDb/imtaO5mPr+nGnSc045dZeRzz9FAGjVuCK81ckhGooLCIH6ev4Kp3x9LlkSE88OV0YqKMB/q05Pf/O5oXzu/AkU1r+q75V9aiooyk+BhqpyTQuGYS7epVpXvjVHq3qs3xLWt7XZ6IiIiISIUWsgagc64AuA74DpgBfOScm2ZmD5jZqcHVbgWuNLNJwIfApa4c/4I8tW1dmtVO5qnvZ7Oj4C+zKkkIbN1RyBsjFnBEkzRapad4XY6EqbTkeJ45tx3zV23mX59N87oc3wuHPBaR8FEtMY7XLslh645CrnxnLFt3FHpdUthQHoe3FRu28ff3x/G3t8ZSOS6aQVd35ZEzWpNS+cCu5RbOYqKjuOqIRnxzYw+a1k7mtoGTuPTNMSxdV3FOBpizYiMPfz2DLo/8xBXvjGXswrVc0rUB397Ugy+uP5yLuzagamVdJ1FERERERLwX0msAOue+Br7eY9k9xW5PB7qHsoaSREUZd/RuxmVvjWHAmMVc1LWBV6VUGB+NzWX15h38XaP/5BB1a5zK9Udl8+yQOXRtVIOzOupaVCXxex6LSHhpUiuZZ85rxxXvjOX2QZN4rm/7iB/9VFaUx+GnsMjx/m+LeOLbWewoLOL245tyZY8s4mJCOZmKv2WlJTGgX1fe/XURj307k+OeHsqdJzbn/E6ZEXlphfVb8xk8aRmDxi1hUu46YqKMXs1qcnbHDHo1q0lsdMX9WRAREREREf8KaQMwHBzZNI1ODavzzJC5nNEhg8T4Cv+ShEx+YRGvDptPx/rV6NSwutflSAS48ehsfl+wmn99NpV29VJoXDPZ65JERCqMo5vX4o7ezXj0m5k0rZXM9Udne12SSJmbvmwDd346hUm56+iRncq/+7SiQWqi12X5QlSUcUm3BhzVrCZ3fjKFuz+byheTlvHYmW0i4jUqLHKMnLuKgeOW8N205ewoKKJprWTuPqk5p7VPJzUp3usSRURERERESlThT1U0C4wCXLVpO2+OXOB1ORFt8MRlLF23lWt7NdIoASkT0VHGM+e1p3JcNNe+P0HT0ImIlLOremZxRvt0nvphNt9O/cPrckTKzJYdBTzy9QxOeX4ES9du4Znz2vHO3zpFRGOrrNWrXpl3L+/EY2e2ZvofG+j9zDBeGz6fwqLwnLl24arNPPndLA5/7CcufuN3hs3O47zD6vHFdYfz7U09uKJHlpp/IiIiIiISFvbbADSzG0uzLJx1rF+NY1vU4pWh81m7eYfX5USkoiLHS0Pn0ax2Mr2a1vS6HIkgtaok8PS57Zi1YiP3fxHZ1wOsCHksIuHFzHj4jNa0z6zKzQMmMW3Zeq9LKjfK5Mj188yVHPv0MF4ZNp9zcjL48ZYj6NMuXSewlcDMOPewTH64+QgOb5zKg1/N4KyXRzFnxUavSyuVTdsL+GhMLme/PIojn/yFF3+ZS5NayTx/fnt+u+toHujTitYZKfoZEBERERGRsFKaEYCX7GXZpWVch+duP74pm3cU8OIvc70uJSJ9P30Fc1du4pojNfpPyt4RTdL4+5GN6D8ml88nLvW6nFCqEHksIuElITaaVy7qSNXKsfR7ZxyrNm33uqTyokyOMCs3bOPa98dz2VtjqBwXzcCru/LIGW2oWjnO69LCRu2UBP53cQ7PnNeOhas2c9KzI3jh57nkFxZ5XdpfOOf4df5qbv1oEp0e+pF/fDyZ1Zt2cPvxTRn1z6N5+2+dOLlNXRJio70uVURERERE5KDs84J3ZtYXOB/IMrPBxR5KBtaEurDy1qRWMmd0yODt0Yu4tHtD0qtW8rqkiOGc46Vf5lK/RmVOal3H63IkQt1ybBN+X7CGuz6ZQuv0FLLSkrwuqcxUtDwWkfBTMznwof9ZL4/i6nfH8f6VnYmPicwPzZXJkaeoyPH+74t5/JuZbC8s4rbjmtCvZyPiYir81RIOipnRp1063Runcu/gaTzx3Sy+mvwHT5zdhpZ1U7wujyVrt/DJ+KUMGreExWu2kBQfw6lt63J2TgYdMqvpZEUREREREYkY+2wAAr8CfwCpwFPFlm8EJoeyKK/cdEw2gycu45kfZ/P4WW29LidijJq3mklL1vPw6a2JidYHKRIaMdFRPNu3PSc+O5xrP5jAp3/vFklnbFe4PBaR8NMqPYWnzm7HtR+M5+5Pp/L4WW0i9YN0ZXIEmfHHBu78ZAoTc9fRvXENHjqtta7zV0ZSk+J54fwOnNJmOf/6fCp9nh/J1Uc04vqjG5f7CQLb8gv5dupyBo7LZdS81TgHXbNqcNMx2fRuVZvKcSX9WSwiIiIiIhKeSvpLZ5BzrqOZbXHODS23ijyUUa0yF3Wtz5sjF3BljyyyayV7XVJEeOHnudRMjufMjulelyIRrm7VSjx9Tlv+9tZYHvxqOg+e1trrkspKhctjEQlPJ7Wpw6wV2Tw7ZA5NaydzRY8sr0sKBWVyBNiyo4BnhszhteELqFoplv+e244+7epGatPaU71b1aZrVg3+/dV0nv95Lt9NW87jZ7WhfWa1kO7XOceE3HUMHLuELyctY+P2AjKqVeLGo7M5s0MG9apXDun+RUREREREvFZSAzDKzO4CmpjZLXs+6Jx7OnRleefaXo0ZMCaXJ7+fxSsX5XhdTtibmLuOUfNWc9eJzSJ2KjDxl6Oa1aJfzyxeHTafrlmpnNQmIqadrZB5LCLh6aajs5mzYiMPfz2DRjWT6NW0ptcllTVlcpj7edZK/vXZVJas3cp5h9Xjnyc003X+QiylcixPnt2Wk9vU4a5PpnDmS6P4W/eG3HpcUyrFle3fCCs2bAtO8ZnLvLzNJMRGcWKrOpyVk0GXhjWIilKTV0REREREKoaSGoDnAacF16kwQ+GqJ8bRr2cWT/8wm/GL19IhxGemRroXf55LSqVYzu9c3+tSpAK5/fim/L5gDf/8eDKt0qtQv0bYT+VVIfNYRMJTVJTx1DltWfTSFm74YAKfXtudxjUj57qsKJPD1soN27j/y+l8NfkPGqUlMqBfFzpn1fC6rArlyKY1+e7mnjz27UxeG7GAH2as4LEz29DlEL8P2wsKGTJjJQPH5jJ0dh5FDjrWr8ajZ2RxUps6JCfEltERiIiIiIiIhI99NgCdc7OAx8xssnPum3KsyXOXH96Qd0Yv5LFvZtK/XxdNBXSQ5qzYyPfTV3DD0dkkxeu6GlJ+YqOjeK5ve056djjXfTCBQdd0DesRqBU5j0UkPFWOi+F/l+TQ5/kRXPH2GD67tnvEjLBSJoefoiLH+78v5vFvZrK9sIhbj21CvyOywvq9QThLTojlwdNac1Lruvzzk8mc9+qvXNglk3+e0PyA/2aYunQ9g8Yt4bOJS1m3JZ9aVeK5+ohGnNUxg6y0iDrxQERERERE5IDt8y8sM7vQOfce0MLMmu/5eCRPb5QYH8P1R2Vz7+BpDJ2dx5GRN3VVuXjpl3lUio3msm4NvC5FKqB61SvzxNltuerdcTz6zUzuPaWl1yUdtIqcxyISvtKrVuKVizrS99XfuPaD8bx1WSdio6O8LuuQKZPDy8zlG7jzkylMWLyO7o1r8OBprWmYGvYzA0SEro1q8O2NPXnq+1m8PnIBP8/M4+EzWnNEk7QSn7d603Y+m7iMQeOWMOOPDcRFR3Fsy1qc3TGDHtlpRGuKTxEREREREaDkKUB3/mVcIU+d7Nspk9dGzOexb2fRMztN14o4QLlrtvD5pGVc0rUB1RIj44x/CT/Ht6zNpd0a8ObIhXTJqsHxLWt7XdLBqtB5LCLhq2P96jx0eituHzSZB7+czv19WnldUllQJoeB3DVbeGf0Qt4cuZAqlWL5z7ltOa1dumb28JlKcdHcfXILTmxTh38Mmswlb/zOWR0z+NdJLUip/Oe0nQWFRfwyK4+B43L5aeZK8gsdbTJSeKBPS05tWzdiRhiLiIiIiIiUpZKmAH3FzKKBDc65/5RjTb4QFxPFrcc25aYBE/li8jL6tEv3uqSw8r/h84kyuLJnQ69LkQruzhObMW7RWm4fOIkWdapQr3plr0s6YBU9j0UkvJ2dU4/ZKzbyv+ELaFI7mQvC/LrAymT/2pZfyLdTl/PR2FxGzVuNGZzVIYO7TmyuE9J8rkNmNb664XCeGzKXl4bOY+jsPB48rRVZqYkMHLeET8YvZdWm7dRIjOOSrg04KyeDZrWreF22iIiIiIiIr5V4kQXnXKGZ9QUq5Icbp7aty8tD5/HU97M5oVUd4mLCf9qq8pC3cTsDxuRyRvsM6qRU8rocqeDiY6J5/vz2nPzsCK7/cAIDr+4allPQVfQ8FpHw9s8TmjNn5Sbu/XwaWalJdG1Uw+uSDoky2T+cc0xasp6PxubyxaRlbNxWQGb1ytxybBPO7JhBelW9Fw0X8THR3HZ8U3q3qs0/Bk3mqnfHARATZfRqVpOzO2bQq1nNsHwfJyIiIiIi4oXSXGV9pJk9DwwANu9c6JwbH7KqfCIqyrijdzMue2sMA8Ys5qKuDbwuKSy8MXIBOwqLuOqILK9LEQGgfo1EHj2zDdd+MJ4nvpvFXSf+5ZJN4aLC5rGIhLfoKOPZvu05/YWR/P39cXx+7eFk1gi/Edl7UCZ7KG/jdj6bsJSPxuYyZ+UmEmKjOLF1Hc7uWI/ODatr+v4w1io9hc+v686Hvy8mv9DRp11dUpPivS5LREREREQk7JSmAdgu+O8DxZY54Kgyr8aHjmyaRqeG1XlmyFzO6JBBYnxpXrKKa8O2fN4bvYgTW9chK02XxhH/OKlNHUbPz+TVYfPpklWdo5rV8rqkg9Eu+G+FzGMRCW9VEmJ5/ZLD6PPCSK54ZwwfX9ON5ITY/T/Rv9oF/1Uml5P84HXgPhqby88zV1JQ5OiQWZVHzmjNyW3qhPvPkxQTGx3FxTr5UkRERERE5JDst5vlnOtVHoX4lVlgFOCZL43izZELuO6obK9L8rV3Ry9i4/YCrjmikdeliPzF3Se1YNyiddzy0SS+ubFH2E1RW9HzWETCX4PURF68oAMXv/E7Nw+YyCsX5RAdpiO1lMnlZ86KjbtdBy41KZ7LD2/I2TkZNK6Z7HV5IiIiIiIiIr5UYgPQzJoC/YBmwUUzgFedc7NDXZifdKxfjWNb1OKVofO5oHN9qiXGeV2SL23dUcgbIxZwRJM0WqWneF2OyF8kxEbzwvntOeW5Edzw4QQ+vLILMWFyHRnlsYhEiu6NU7n3lBbc8/k0nvx+Fnf0brb/J/mMMjn0NmzL58tJf/DR2Fwm5q4jJso4qllNzsmpxxFN03QdOBEREREREZH92OdfzmbWFfgF2AS8CvyPwPVNfjGzLuVSnY/cfnxTNu8o4MVf5npdim99NDaX1Zt38PcjNfpP/CsrLYmHz2jNmIVrefqH8PicVnksIpHmoi71uaBzJi/9Mo9PJyzxupwDokwOnaIix6h5q7h5wEQ6PfQjd306hS07Crj7pOb8etfRvHpxDse0qKXmn4iIiIiIiEgplDQC8B6gr3Pul2LLPjOzn4B7gRNCWZjfNKmVzBkdMnh79CIu7d6Q9KrhNXVgqOUXFvHqsPnk1K9Gp4bVvS5HpER92qUzet5qXvxlHp2zanBEkzSvS9of5bGIRBQz475TWzIvbxN3fDyFBjUSaZ9ZzeuySkuZXMaWrN3Cx+OWMmh8LrlrtpKcEMOZHTI4J6cebTJSMAvPaWJFREREREREvFTS6bON9vhgAwDn3FAgK2QV+dhNx2SDg2d+DI9RQ+Vp8MRlLArpSJIAAElcSURBVF23lb/3aqQPaSQs3HtKS5rWSuaWARNZsWGb1+Xsj/JYRCJObHQUL13QkdpVEuj37jj+WL/V65JKS5lcBrblF/L5xKVc+Npv9Hj8Z/7z42wyq1fmmfPaMeb/juGh01vTtl5Vva8UkZAys95mNsvM5prZP/exzjlmNt3MppnZB+Vdo4hIRaA8FhEJjZIagBtLeGxzWRcSDjKqVeairvUZNG4Jc1aU9PJULEVFjpeGzqNZ7WR6Na3pdTkipVIpLpoXLmjPlh2F3Nh/AoVFzuuSSqI8FpGIVC0xjtcuyWHrjkL6vTOOrTsKvS6pNJTJB8k5x+Ql67j7sykc9tCP3Nh/IgtWbebGo7MZ/o9evH9FF/q0SychNtrrUkWkAjCzaOAFAiO3WwB9zazFHutkA3cC3Z1zLYGbyrtOEZFIpzwWEQmdkqYArWdmz+5luQHpIarH967t1ZgBY3J58vtZvHJRjtfl+ML301cwd+Umnu3bXmdpS1hpXDOZf5/WitsGTuLZIXO4+dgmXpe0L8pjEYlYTWol88x57bjinbHcPmgSz/n//YQy+QCt3rSdTycsZeDYJcxasZH4mChOaFWbc3Lq0SWrBlFRvv5+i0jk6gTMdc7NBzCz/kAfYHqxda4EXnDOrQVwzq0s9ypFRCKf8lhEJERKagDeXsJjY0uzcTPrDTwDRAOvOece3cs65wD3AQ6Y5Jw7vzTb9kr1xDj69czi6R9mM37xWjqEz/VqQsI5x0u/zKV+jcqc2Kq21+WIHLCzOmYwat4qnv1pDp0bVqdb41SvS9ob5bGIRLSjm9fijt7NePSbmTStlcz1R2d7XVJJDimTK0oeFxQWMXR2Hh+NzWXIjJUUFDna1qvKQ6e34uQ2dUmpFOt1iSIi6UBusftLgM57rNMEwMxGEsjt+5xz3+65ITPrB/QDyMzMDEmxIiIRTHksIhIi+2wAOufePpQNFxu+fSyB4B5jZoOdc9OLrVN8+PZaMwuL+SMvP7wh74xeyGPfzKR/vy5+P0s9pEbNW82kJet5+PTWxESXNKOsiH/9u08rJuWu48YBE/n6hh6kJcd7XdJulMciUhFc1TOL2cs38tQPs8mulUTvVnW8LmmvDiWTK0Iez125iYHjcvlk/FLyNm6nRmIcl3VvwNk59WhSK9nr8kREDlQMkA0cCWQAw8ystXNuXfGVnHOvAq8C5OTk+PraAiIiYUp5LCJyEELZsdk1fNs5twPYOXy7uLAcvp0YH8P1R2Xz24I1DJ2d53U5nnrh57nUTI7nzI6a8UrCV2J8DC9c0IENW/O5ecBEivx9PcCDEbF5LCKRw8x4+IzWtM+sys0DJjFt2XqvSwqFiMzjjdvy6f/7Ys54cSTHPD2U14YvoG1GVV69qCO/3nU0/3dSCzX/RMSPlgL1it3PCC4rbgkw2DmX75xbAMwm8AG0iIiUHeWxiEiIhLIBuLfh23t2iZoATcxspJn9GpwS6S/MrJ+ZjTWzsXl5/mi49e2USb3qlXj821mR2CwolYm56xg1bzVX9sgiPiba63JEDkmz2lW479SWjJi7ihd/met1OWUtovNYRCJHQmw0r1zUkaqVY+n3zjhWbdrudUllrczyGLzNZOccv85fzS0fTaTTQ0P45ydT2LCtgLtObMboO4/itUtyOK5lbWI1Q4SI+NcYINvMGppZHHAeMHiPdT4jMNoEM0slkNHzy7FGEZGKQHksIhIiXv9FXnz4dl/gf2ZWdc+VnHOvOudynHM5aWlp5VvhPsTFRHHrsU2Z/scGvpi8zOtyPPHiz3NJqRRL386aU1siw3mH1ePUtnV5+ofZ/DZ/tdfllLewzWMRiSw1kxP438U5rN68navfHcf2gkKvSypvpcpj8CaTl63bynND5nDEE79w3qu/8v20FZzWPp1P/96NH27uSb+ejaiZnFAutYiIHArnXAFwHfAdMAP4yDk3zcweMLNTg6t9B6w2s+nAz8DtzrkK94eCiEgoKY9FREJnvw1AM8sws0/NLM/MVprZx2aWUYptR/zw7VPb1qVZ7WSe+n42OwqKvC6nXM1esZHvp6/gkm4NSIrf56UkRcLKzunnMqtX5ob+E1jts5EnymMRqShapafw1NntGLtoLXd/OhXn/DfbwkFmcljm8bb8Qr6YtIyLXv+N7o/9xFM/zCa9aiX+c25bxvzfMTxyRmvaZ1ar0NfFFpHw5Jz72jnXxDnXyDn3UHDZPc65wcHbzjl3i3OuhXOutXOuv7cVi4hEJuWxiEholGYE4JsEhl3XAeoCXwSX7U/ED9+OijLu6N2MxWu2MGDMYq/LKVcv/zKPSrHRXNatgdeliJSppPgYnj+/A2s353PrwEl+m+JXeSwiFcZJbepww9HZDBy3hNdHLPC6nL05mEwOmzx2zjF16Xru+XwqnR8ewvUfTmB+3mauPyqbYbf34sN+XTi9fQaV4jQNvIiIiIiIiIgflWboVppzrviHGW+Z2U37e5JzrsDMdg7fjgbe2Dl8GxgbPIPjO+C44PDtQsJw+PaRTdPo1KA6zwyZyxkdMkisAKPhctds4fNJy7i0WwOqJcZ5XY5ImWuVnsK/Tm7Ovz6fxqvD53P1EY28Lmkn5bGIVCg3HZ3NnBUbefjrGTSqmUSvpjW9Lqm4A87kcMjjNZt38NmEpXw0NpeZyzcSFxNF75a1OSenHt0a1SAqSqP8RERERERERMJBabpVq83sQuDD4P2+QKk+hHDOfQ18vceye4rddsAtwa+wZGbccUIzznxpFG+OXMB1R0X+jHn/Gz6fKIMrejT0uhSRkLmwS31Gz1/NE9/N4rAG1ehYv7rXJYHyWEQqmKgo46lz2rLopS3c8MEEPr22O41rJnld1k4Hlcl+zOOCwiKGz1nFR2Nz+XHGCvILHW0yUvj3aa04tU1dUirHllcpIiIiIiIiIlJGSjMF6N+Ac4DlwB/AWcBloSwq3HSsX41jW9TilaHzWbt5h9flhFTexu0MGJPLGe0zqJNSyetyRELGzHj0zDbUrZrADR9OZN0WX/zfVh6LSIVTOS6G/12SQ3xsFFe8PcYveQwRkMnz8zbx2Lcz6f7YT1z21hh+W7CGi7s24NubejD4usO5qEt9Nf9EREREREREwtR+G4DOuUXOuVOdc2nOuZrOudOccxXrgnelcPvxTdm8o4AXf5nrdSkh9cbIBeQXFnH1kb6ZElEkZKokxPLC+R1YuXEbtw2cTGBQhneUxyJSUaVXrcQrF3Vk2bptXPvBePILi7wuKewzecqS9Rz11FBeGTqPVnVTePnCDvx659H86+QWNKtdxevyREREREREROQQ7XMKUDO7Z1+PEZid6N8hqCdsNamVzBkdMnh79CIu7d6Q9KqRNzpuw7Z83hu9iBNa16FhaqLX5YiUizYZVbnzhOY88OV03hi5kMsPL/+pb5XHIiLQsX51Hjq9FbcPmsyDX07n/j6tPKkjUjK5VXoV7j+1JSe0qk3NKglelyMiIiIiIiIiZaykEYCb9/IFcDlwR4jrCks3HZMNDp75cbbXpYTEu6MXsXF7AdccodF/UrFc1r0Bx7aoxaPfzGBS7jovSlAei4gAZ+fU48oeDXl79CI++M2zwXYRkclmxiXdGqj5JyIiIiIiIhKh9tkAdM49tfMLeBWoROC6Jv2BrHKqL6xkVKvMRV3rM2jcEuas2Oh1OWVq645C3hixgCOapNEqPcXrckTKlZnxxFltqJmcwLUfjGf91vxy3b/yWETkT/88oTlHNk3jns+n8uv81eW+f2WyiIiIiIiIiISDEq8BaGbVzexBYDKB6UI7OOfucM6tLJfqwtC1vRpTOS6GJ7+f5XUpZeqjsbms3ryDa3s19roUEU9UrRzHc+e3Z/n6bfzz4/K/HqDyWEQkIDrKeLZve+rXqMw1741j8eot5V6DMllERERERERE/G6fDUAzewIYA2wEWjvn7nPOrS23ysJU9cQ4+vXM4rtpKxi/ODJervzCIl4dNp+c+tXo1LC61+WIeKZDZjVuP74p30xdzru/Liq3/SqPRUR2VyUhltcvOYwiB1e8M4aN28pvZLYyWURERERERETCQUkjAG8F6gJ3A8vMbEPwa6OZbSif8sLT5Yc3JDUpjse+mVnuo4RCYfDEZSxdt5W/99K1/0Su7JFFr6ZpPPjlDKYuXV9eu1Uei4jsoUFqIi9e0IF5eZu5ecBECovK7T2XMllEREREREREfK+kawBGOecqOeeSnXNVin0lO+eqlGeR4SYxPobrj8rmtwVrGDo7z+tyDklRkeOlofNoVjuZXk1rel2OiOeiooynzmlH9cQ4rv1gfLmMOlEei4jsXffGqdx7Sgt+nLGy3KZfVyaLiIiIiIiISDgo8RqAcvD6dsqkXvVKPP7tLIrK74z0Mvf99BXMXbmJv/dqjJl5XY6IL1RPjOPZvu1ZsnYrd34yJSJG+oqIhKuLutTngs6ZvPTLPD6dsMTrckREREREREREfEENwBCJi4ni1mObMv2PDXwxeZnX5RwU5xwv/TKX+jUqc2Kr2l6XI+IrnRpW55Zjm/Dl5D/48Pdcr8sREamwzIz7Tm1Jl6zq3PHxFCZEyDWYRUREREREREQOhRqAIXRq27o0q53MU9/PZkdBkdflHLCRc1czacl6rurZiJho/aiI7OmaIxrRIzuV+7+Yxow/dNknERGvxEZH8dIFHaldJYE3Ri70uhwREREREREREc+V2NUxs2gz+7m8iok0UVHGHb2bsXjNFgaMWex1OQfsxV/mUjM5njM7pntdiogvRUUZT5/TjvSqlVi6dmtI96U8FhEpWbXEOD7s14Wnz2kb8n0pk0VERERERETE70psADrnCoEiM0spp3oizpFN0+jUoDrPDJnL5u0FXpdTahNz1zFq3mqu7JFFfEy01+WI+FZacjzf39yTY1rUCul+lMciIvuXXrUSseUwa4EyWURERERERET8LqYU62wCppjZD8DmnQudczeErKoIYmbccUJTznxpNG+OXMB1R2V7XVKpvPjzXFIqxdK3c6bXpYj4XjlOkas8FhHxD2WyiIiIiIiIiPhWaRqAnwS/5CB1rF+dY5rX4pWh87mgc32qJcZ5XVKJZq/YyPfTV3DD0dkkxZfmR0REyonyWETEP5TJIiIiIiIiIuJb++3uOOfeNrM4oElw0SznXH5oy4o8//j/9u493LK6vBP894USVCSIUomGQkBFlGi8VaMxHcVrwO6BSbQzknaiaRJy006i3R177DYZ8vRMq4km6cYoiYzGdKKGyaWSoJgY0I6KoYxXMGCJFwocKUWJhggi7/xxdpljWZdTeNbe66z9+TzPftxrrd9Z+/2dvevLcb/rcvrJ+f5fe2deddmOvPhfnLLocvbr1Zd9PHc/7ND86ONOWHQpwCryGGA8ZDIAAAAwZge8bl1VnZbkY0nOT/KqJNdU1eOHLWt6HvQdR+YHH7klr3/Pp3L9F/9x0eXs03U33ZI/+eANOfvU+43+TEVYNvIYYDxkMgAAADBma7lx1a8meVp3P6G7H5/k+5O8ctiypunnn3pS0smv/+U1iy5ln37rf16bQyr5se87cdGlAN9MHgOMh0wGAAAARmstDcC7dPfVuxe6+5okdxmupOnacvTd8+zHHp+L3rczH/vslxZdzjfZ9aVb86YrrssPPnJL7nvU3RZdDvDN5DHAeMhkAAAAYLTW0gDcXlW/XVWnzR6/lWT70IVN1fOe9MDc/bBN+ZW3XX3gwXN24bs+ka9+7Y785GkPWHQpwN7JY4DxkMkAAADAaK2lAfhTSa5K8m9nj6tm67gT7nXEYTn38ffPJVd+Nn/76S8supyv+/uvfDW/+55P5YyH3TcnHnPEossB9k4eA4yHTAYAAABGa58NwKp6++zped39iu7+wdnjld1961p2XlWnV9XVVbWjql60n3HPqKquqq0HWf+GdM4/PzHH3OOwvPQtf5fuXnQ5SZI3vOdT+dKtt+ennuDsPxgbeQwwHt9qJstjAAAAYB427WfbfavqcUnOrKo3JqnVG7v7b/e346o6NMn5SZ6aZGeSK6pqW3dftce4I5P8bJL33on6N6QjDt+U5z/ppPzitivzjmt25bSTv32h9fzjbV/LhX/9iZx28uY89NijFloLsFfyGGA87nQmy2MAAABgXvbXAHxJkv+cZEuSV+yxrZM86QD7PjXJju6+NklmX5CclZXLI632y0lemuTfr7HmSTj71Pvlt//62rzsrVfn8SdtziGH1IF/aCBv3n5dPv8Pt+WnT3vgwmoA9kseA4zHt5LJ8hgAAACYi31eArS7L+ruM5K8rLufuMfjQF82J8mxSa5btbxztu7rqupRSY7r7j/f346q6tyq2l5V23ft2rWGlx6/wzYdkhc+9eRc9Zm/z59+6IaF1fHVr92RC955bbYef3ROPfFeC6sD2Dd5DDAe32Imr1sez8bKZIBvgcsyA4yDPAYYxj4bgLt19y8P8cJVdUhWjpp+4RpquKC7t3b31s2bNw9RzkKc+fDvzIPvc2R+9W3X5Lbb71hIDX/ygRty/Rf/MT/9RPf+g7GTxwDjMUQmH0wez2qQyQB30qrLMp+R5JQkZ1fVKXsZ57LMAAOSxwDDOWAD8FtwfZLjVi1vma3b7cgkD01yWVV9Msljk2xbpiM4Djmk8gunPzifvumWvOmKT8/99e+4o/Pqd3w8D77PkXnigu9DCAxKHgOMgzwGGI+vX5a5u29LsvuyzHvafVnmr8yzOIAlIo8BBjJkA/CKJCdV1YlVdViSZyXZtntjd9/c3cd09wndfUKSy5Oc2d3bB6xpdE47eXNOPeFe+fW378gtt90+19d+21WfzY4bv5yffuIDU7W4exACg5PHAOMgjwHGw2XyAcZBHgMMZJ8NwKq61/4eB9pxd9+e5HlJLkny0SRv7u4rq+q8qjpz/aawsVVVfuGMk/O5L9+aC//6E3N73e7Ob162I8ff++55+kPvM7fXBQ6ePAYYj28lk+UxwMbhMvkA4yCPAe68TfvZ9r4knWRvp4Z1kvsfaOfdfXGSi/dY95J9jD3tQPubqkcff6885SHfkde849r868ccn6OPOGzw13zXjs/ngztvzv/1Aw/LpkOHPBEUWAfyGGA8vqVMlscAo3Ewl2VOkvtk5bLMzswGWF/yGGAg+2wAdveJ8yxk2f2H00/O9//aO/Oqy3bkxf/im+5zu+5eddmOfPuRh+cZjz72wIOBhZLHAOMhkwEm4+uXZc7KF83PSvLDuzd2981Jjtm9XFWXJfl3vmwGWHfyGGAg+zsD8Ouq6ugkJyW56+513f3OoYpaRg/6jiPzg4/ckte/51N57veemGPvebfBXusD130x7/745/Pipz8kh286dLDXAdafPAYYD5kMsHF19+1VtfuyzIcmuXD3ZZmTbO/ubfvfAwDrQR4DDOeADcCq+rEkP5uV068/kOSxSd6T5EmDVraEfv6pJ+VPP3hDfv0vr8nLnvnwwV7nVZfuyFF3u0vOfsz9BnsNYP3JY4DxkMkAG5/LMgOMgzwGGMZabv72s0n+WZJPdfcTkzwyyReHLGpZbTn67nn2Y4/PRe/bmY999kuDvMY1n/1S3nbVZ/Pcx52Qexy+phNAgfGQxwDjIZMBAACA0VpLA/Ar3f2VJKmqw7v775KcPGxZy+tnnviA3P2wTfmVt109yP5ffdnHc/fDDs1zH3fCIPsHBiWPAcZDJgMAAACjtZYG4M6qumeSP07yF1X1J0k+NWRRy+ze9zg8P/59988lV342f/vpL6zrvq+76Zb8yQdvyNmn3i9HH3HYuu4bmAt5DDAeMhkAAAAYrQNeA7K7f2D29Jeq6tIkRyV566BVLbkf+74T8zvv+WRe+pa/yxvPfWyqal32+1v/89ocUiv7BzYeeQwwHjIZAAAAGLMDngFYVb9RVY9Lku5+R3dv6+7bhi9teR1x+KY8/0kPzHs/cVPecc2uddnnri/dmjddcV2e8agtue9Rd1uXfQLzJY8BxkMmAwAAAGO2lkuAvi/Jf6qqj1fVr1TV1qGLIvnhxxyf4+51t7zsrVfnjjv6W97fhe/6RL76tTvyE094wDpUByyIPAYYD5kMAAAAjNYBG4Dd/frufnqSf5bk6iQvraqPDV7Zkjts0yF54VNPzlWf+fv86Ydu+Jb2dfM/fjW/+55P5YyH3TcnHnPEOlUIzJs8BhgPmQwAAACM2VrOANztgUkenOT4JH83TDmsdubDvzMPvs+R+dW3XZPbbr/jTu/ndy//VL506+356dOc/QcTIY8BxkMmAwAAAKOzlnsAvmx2NPN5ST6SZGt3/y+DV0YOOaTyC6c/OJ++6Za86YpP36l9/ONtX8uFf/2JnHby5nzXdx61zhUC8ySPAcZDJgMAAABjtmkNYz6e5Hu6+3NDF8M3O+3kzTn1hHvl19++I8949Jbc/bC1vGX/5M3br8vn/+G2/PRpDxyoQmCO5DHAeMhkAAAAYLTWcg/A1+z+YqOq/mz4klitqvILZ5ycz3351lz41584qJ/96tfuyAXvvDZbjz86p554r4EqBOZFHgOMh0wGAAAAxuxg7gGYJMcOUgX79ejj75WnPOQ78pp3XJsv/MNta/65P/nADbn+i/+Yn3mis/9gguQxwHjIZAAAAGBUDrYB+P5BquCA/sPpJ+fLt92eV122Y03j77ij8+p3fDwPue+35bSTNw9cHbAA8hhgPGQyAAAAMCr7bABW1V2r6ueq6r9X1U9U1abu/jfzLI5/8qDvODI/+Mgtef17PpUbvviPBxz/tqs+mx03fjk/ddoDUlVzqBAYijwGGA+ZDAAAAGwE+zsD8PVJtib5cJIzkvzqXCpin37+qSclnfzaX16z33Hdnd+8bEeOv/fd8/SH3mdO1QEDkscA4yGTAQAAgNHbtJ9tp3T3w5Kkql6b5G/mUxL7suXou+fZjz0+r3v3J3Lu4++fB377kXsd964dn88Hd96c//sHH5ZNhx7sVV6BEZLHAOMhkwEAAIDR21936Ku7n3T37XOohTX4mSc+IHc/bFNefsnV+xzzqst25Du+7fD84KOOnWNlwIDkMcB4yGQAAABg9PZ3BuDDq+rvZ88ryd1my5Wku/vbBq+Ob3LvexyeH/++++eVf3lN/vbTX8ij7nf0N2z/wHVfzLs//vm8+OkPyeGbDl1QlcA6k8cA4yGTAQAAgNHb5xmA3X1od3/b7HFkd29a9dwXGwv0Y993Yu59xGF56Vv+Lt39DdtedemOHHW3u+SHH3O/BVUHrDd5DDAeMhkAAADYCAa9QVxVnV5VV1fVjqp60V62v6CqrqqqD1XV26vq+CHrmYojDt+U5z/pgXnvJ27KO67Z9fX113z2S3nbVZ/Ncx93Qo44fH8ndwLLRh4DjIM8BgAAAOZhsAZgVR2a5PwkZyQ5JcnZVXXKHsPen2Rrd393kouSvGyoeqbmhx9zfLYcfbe87K1X5447Vs4CfPVlH8/dDzs0z33cCYstDhgVeQwwDvIYAAAAmJchzwA8NcmO7r62u29L8sYkZ60e0N2Xdvcts8XLk2wZsJ5JOWzTIXnh0x6Uqz7z9/nTD92Q6266JX/ywRty9qn3y9FHHLbo8oBxkccA4yCPAQAAgLkYsgF4bJLrVi3vnK3bl3OSvGVvG6rq3KraXlXbd+3atbchS+mshx+bB9/nyPzq267Jqy7bkUMq+fHvu/+iywLGRx4DjMO65XEikwEAAIB9G/QegGtVVc9OsjXJy/e2vbsv6O6t3b118+bN8y1uxA45pPIfTj85n77plvz+31yXZzxqS+5z1F0XXRawgcljgHE4UB4nMhkAAADYtyEbgNcnOW7V8pbZum9QVU9J8uIkZ3b3rQPWM0lPPPnbc+oJ98ohlfzEEx6w6HKAcZLHAOMgjwEAAIC52DTgvq9IclJVnZiVLzaeleSHVw+oqkcmeU2S07v7xgFrmayqyiuf9Yhc89kv5cRjjlh0OcA4yWOAcZDHAAAAwFwM1gDs7tur6nlJLklyaJILu/vKqjovyfbu3paVSxrdI8kfVFWSfLq7zxyqpqk69p53y7H3vNuiywBGSh4DjIM8BgAAAOZlyDMA090XJ7l4j3UvWfX8KUO+PgAr5DHAOMhjAAAAYB6GvAcgAAAAAAAAMGcagAAAAMDSqarTq+rqqtpRVS/ay/YXVNVVVfWhqnp7VR2/iDoBpk4eAwxDAxAAAABYKlV1aJLzk5yR5JQkZ1fVKXsMe3+Srd393UkuSvKy+VYJMH3yGGA4GoAAAADAsjk1yY7uvra7b0vyxiRnrR7Q3Zd29y2zxcuTbJlzjQDLQB4DDEQDEAAAAFg2xya5btXyztm6fTknyVv2tqGqzq2q7VW1fdeuXetYIsBSkMcAA9EABAAAANiHqnp2kq1JXr637d19QXdv7e6tmzdvnm9xAEtEHgMcnE2LLgAAAABgzq5Pctyq5S2zdd+gqp6S5MVJntDdt86pNoBlIo8BBuIMQAAAAGDZXJHkpKo6saoOS/KsJNtWD6iqRyZ5TZIzu/vGBdQIsAzkMcBANAABAACApdLdtyd5XpJLknw0yZu7+8qqOq+qzpwNe3mSeyT5g6r6QFVt28fuALiT5DHAcFwCFAAAAFg63X1xkov3WPeSVc+fMveiAJaQPAYYhjMAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEIGbQBW1elVdXVV7aiqF+1l++FV9abZ9vdW1QlD1gOwrOQxwDjIYwAAAGAeBmsAVtWhSc5PckaSU5KcXVWn7DHsnCRf6O4HJnllkpcOVQ/AspLHAOMgjwEAAIB5GfIMwFOT7Ojua7v7tiRvTHLWHmPOSvL62fOLkjy5qmrAmgCWkTwGGAd5DAAAAMzFkA3AY5Nct2p552zdXsd09+1Jbk5y7z13VFXnVtX2qtq+a9eugcoFmCx5DDAO65bHiUwGAAAA9m3QewCul+6+oLu3dvfWzZs3L7ocgKUljwHGQyYDAAAA+zJkA/D6JMetWt4yW7fXMVW1KclRST4/YE0Ay0geA4yDPAYAAADmYsgG4BVJTqqqE6vqsCTPSrJtjzHbkjxn9vyZSf6qu3vAmgCWkTwGGAd5DAAAAMzFpqF23N23V9XzklyS5NAkF3b3lVV1XpLt3b0tyWuTvKGqdiS5KStfggCwjuQxwDjIYwAAAGBeBmsAJkl3X5zk4j3WvWTV868k+VdD1gCAPAYYC3kMAAAAzMOQlwAFAAAAAAAA5kwDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAWDpVdXpVXV1VO6rqRXvZfnhVvWm2/b1VdcICygSYPHkMMAwNQAAAAGCpVNWhSc5PckaSU5KcXVWn7DHsnCRf6O4HJnllkpfOt0qA6ZPHAMPRAAQAAACWzalJdnT3td19W5I3JjlrjzFnJXn97PlFSZ5cVTXHGgGWgTwGGMimRRdwsN73vvd9rqo+dSd+9Jgkn1vvekbE/Da2qc8vmf4c7+z8jl/vQuZFHu/T1OeXTH+O5rexLV0eJzJ5P8xvYzO/jW3seXxskutWLe9M8ph9jenu26vq5iT3zh7zqqpzk5w7W7y1qj4ySMXjNvXP894s45wT814mJ8/pdeTx+lrGz2qynPNexjknyzvvO5XJG64B2N2b78zPVdX27t663vWMhfltbFOfXzL9OU59fnsjj/du6vNLpj9H89vYpj6/fZHJe2d+G5v5bWxTn99q3X1BkguS5Zr3ass472Wcc2Lei65jnqpq+6JrOFjy2LwXXcc8LeOck+We9535OZcABQAAAJbN9UmOW7W8ZbZur2OqalOSo5J8fi7VASwPeQwwEA1AAAAAYNlckeSkqjqxqg5L8qwk2/YYsy3Jc2bPn5nkr7q751gjwDKQxwAD2XCXAP0WXLDoAgZmfhvb1OeXTH+OU5/fepr672rq80umP0fz29imPr/1NvXfl/ltbOa3sY16frN7SD0vySVJDk1yYXdfWVXnJdne3duSvDbJG6pqR5KbsvKl9IGMet4DWsZ5L+OcE/NeJnOZszxed+a9PJZxzol5H5RysAQAAAAAAABMh0uAAgAAAAAAwIRoAAIAAAAAAMCETL4BWFUXVtWNVfWRRdcyhKo6rqouraqrqurKqvrZRde0nqrqrlX1N1X1wdn8/s9F1zSEqjq0qt5fVX+26FrWW1V9sqo+XFUfqKrti65nvVXVPavqoqr6u6r6aFV9z6JrGit5vLHJ441PHrPalDNZHk/DlPM4kclTUFWnV9XVVbWjql60l+2HV9WbZtvfW1UnLKDMdbWGOb9glr0fqqq3V9Xxi6hzvR1o3qvGPaOquqq2zrO+oaxl3lX1Q6v+e/t7865xva3hM36/2d8Y7599zp++iDrX24H+LqwVvzH7vXyoqh417xr3Rx7L472Mk8cTsIyZPEQeT74BmOR1SU5fdBEDuj3JC7v7lCSPTfIzVXXKgmtaT7cmeVJ3PzzJI5KcXlWPXWxJg/jZJB9ddBEDemJ3P6K7J/Ef3j38epK3dveDkzw8034fv1WvizzeyOTxNMhjdntdppvJ8ngapp7HiUzesKrq0CTnJzkjySlJzt5LzpyT5Avd/cAkr0zy0vlWub7WOOf3J9na3d+d5KIkL5tvletvjfNOVR2Zldx673wrHMZa5l1VJyX5j0m+t7u/K8nPzbvO9bTG9/o/JXlzdz8yybOSvGq+VQ7mddn/34VnJDlp9jg3yW/OoaY1kcfyeC/j5PEGz+NkqTP5dVnnPJ58A7C735nkpkXXMZTu/kx3/+3s+Zey8n+sjl1sVeunV3x5tniX2aMXWNK6q6otSf5Fkt9edC0cnKo6Ksnjk7w2Sbr7tu7+4kKLGjF5vLHJY8ZMHh+8KWeyPN745PHGtiSZfGqSHd19bXffluSNSc7aY8xZSV4/e35RkidXVc2xxvV2wDl396Xdfcts8fIkW+Zc4xDW8l4nyS9npanwlXkWN6C1zPvHk5zf3V9Iku6+cc41rre1zLmTfNvs+VFJbphjfYNZw9+FZyX5ndnfIJcnuWdV3Xc+1R2QPJbHe5LHGz+PkyXN5CHyePINwGUyO4X9kZnIEQ671crlfz6Q5MYkf9Hdk5pfkl9L8h+S3LHgOobSSd5WVe+rqnMXXcw6OzHJriT/z+x089+uqiMWXRSLJ483rF+LPN6o5DF7JY83rF/LtPM4kckb3bFJrlu1vDPffKDB18d09+1Jbk5y77lUN4y1zHm1c5K8ZdCK5uOA855dfuu47v7zeRY2sLW83w9K8qCqeldVXV5VG/3KAmuZ8y8leXZV7UxycZLnz6e0hTvYf//zJI/l8dfJ48nkcSKT9+Wg81gDcCKq6h5J/t8kP9fdf7/oetZTd3+tux+RlaNVTq2qhy64pHVTVf8yyY3d/b5F1zKgf97dj8rKKco/U1WPX3RB62hTkkcl+c3Z6eb/kGSf1yBnOcjjjUkeb3jymG8ijzemJcnjRCYzYVX17CRbk7x80bUMraoOSfKKJC9cdC0LsCkrlyA7LcnZSX6rqu65yILm4Owkr+vuLUmenuQNs88AjJI8XhrLmMeJTF4Tv5AJqKq7ZOXLjf/R3X+46HqGMrtszKWZ1v1qvjfJmVX1yaycyvykqvrdxZa0vrr7+tn/3pjkj7JyCvdU7Eyyc9VR9xdl5csOlpQ83tDk8cYmj/kG8nhDm3weJzJ5Aq5Pctyq5S2zdXsdU1WbsnJpqs/PpbphrGXOqaqnJHlxkjO7+9Y51TakA837yCQPTXLZLLcem2RbVW30e3uu5f3emWRbd3+1uz+R5JqsfAG9Ua1lzuckeXOSdPd7ktw1yTFzqW6x1vTvf0HksTzeTR5PJ48TmbwvB53HGoAb3Oya1a9N8tHufsWi61lvVbV59xELVXW3JE9N8ncLLWoddfd/7O4t3X1CVm5W+lfd/ewFl7VuquqI2c13M7vsz9OSfGSxVa2f7v7/klxXVSfPVj05yVULLIkFkscbmzze2OQxq8njjW3qeZzI5Im4IslJVXViVR2Wlc/qtj3GbEvynNnzZ2bls7yR79d5wDlX1SOTvCYrXzZP4f5DyQHm3d03d/cx3X3CLLcuz8r8ty+m3HWzls/4H2flbJNU1TFZuQTdtXOscb2tZc6fzkqmpaoekpUvm3fNtcrF2JbkR2rFY5Pc3N2fWXRRM/JYHieRx5lWHicyeV8OOo83zaeuxamq38/KP4BjZteD/cXufu1iq1pX35vkf0/y4dl9QJLk/+juixdX0rq6b5LXV9WhWWlYv7m7/2zBNbF235Hkj1a+h8umJL/X3W9dbEnr7vlJ/sfsP0bXJvnRBdczWvJ4w5PHG5s85htMPJPlMWMnkze47r69qp6X5JIkhya5sLuvrKrzkmzv7m1ZORDhDVW1I8lNWfniasNa45xfnuQeSf5g9vn+dHefubCi18Ea5z05a5z3JUmeVlVXJflakn/f3Rv2rKo1zvmFWbm03s9n5V6uz93gjaQke/+7MMldkqS7X52Ve2s9PcmOJLdkRJkuj+WxPJ5eHifLm8lD5HFt8N8JAAAAAAAAsIpLgAIAAAAAAMCEaAACAAAAAADAhGgAAgAAAAAAwIRoAAIAAAAAAMCEaAACAAAAAADAhGgAckBV9cqq+rlVy5dU1W+vWv7VqnrBndjv66rqmetU43dW1UXrsa997P8RVfWeqrqyqj5UVf/bqm0nVtV7q2pHVb2pqg6brX9BVV01G//2qjp+1c88p6o+Nns8Zx+vee+qurSqvlxV/32Pbf+lqq6rqi8foO69jquq51bVrqr6wOzxY3fm9wLMlzyWx8A4yGN5DAAAMHYagKzFu5I8Lkmq6pAkxyT5rlXbH5fk3Quo6+u6+4buXpcvS/bhliQ/0t3fleT0JL9WVfecbXtpkld29wOTfCHJObP170+ytbu/O8lFSV6WJFV1ryS/mOQxSU5N8otVdfReXvMrSf5zkn+3l21/OvvZA9nfuDd19yNmj9/exxhgXOSxPAbGQR7LYwAAgFHTAGQt3p3ke2bPvyvJR5J8qaqOrqrDkzwkyd9W1aOr6h1V9b7ZUdD3TZKqekBVvXW2/n9W1YP3fIGq+uXZEc+HVtV/XXVk8K/sZewTVh2Z+/6qOrKqTqiqj8y2P7eq/nD2mh+rqpet+tnTq+pvq+qDVfX22bojqurCqvqb2f7O2vM1u/ua7v7Y7PkNSW5MsrmqKsmTsvIFRpK8Psn/Oht3aXffMlt/eZIts+ffn+Qvuvum7v5Ckr/Iypcme77mP3T3X2fli449t13e3Z/Zc/2dHQdsGPJYHgPjII/lMQAAwKhtWnQBjF9331BVt1fV/bJyNPN7khyblS89bk7y4SSd5L8lOau7d9XKJYD+S5J/k+SCJD/Z3R+rqsckeVVWvhRIklTVy5McmeRHk9wryQ8keXB3d/3TUcSr/bskP9Pd76qqe2QvXwAkeUSSRya5NcnVVfXfZuN+K8nju/sTtXKkcZK8OMlfdfe/mb3e31TVX3b3P+zt91FVpyY5LMnHk9w7yRe7+/bZ5p2z382ezknyltnzY5Nct2rbvn5maM+oqscnuSbJz3f3dQf6AWCx5PE3ksfAosjjbySPAQAAxkcDkLV6d1a+3Hhckldk5f+QPy4rX3C8K8nJSR6a5C9WDvrNoUk+M/sC4nFJ/mC2PkkOX7Xf/5zkvd19bpJU1c1Z+SLitVX1Z0n+bC+1vCvJK6rqfyT5w+7euWrfu729u2+e7fOqJMcnOTrJO7v7E0nS3TfNxj4tyZlVtftSQndNcr8kH91zp7Ojtt+Q5DndfcdeXvebVNWzk2xN8oQDDp6fP03y+919a1X9RFaOzH7SAX4GGAd5HHkMjII8jjwGAAAYK5cAZa123+fkYVm5xNHlWTnCeff9TSrJlavumfGw7n5aVj5jX1y1/hHd/ZBV+70iyaN3H208O1L41KxcMuhfJnnrnoV0939N8mNJ7pbkXXu7ZFJWjmze7WvZf7O7kjxjVX336+69fbnxbUn+PMmLu/vy2erPJ7lnVe3e/5Yk16/6madk5QjqM7t7d03XJzlu1a63JLm+qn5g1aWbtu6n3r1PYuXyULt//rz9je3uz6+q57eTPPpgXw9YGHksj4FxkMfyGAAAYLQ0AFmrd2flC4ebuvtrs6OD75mVLzneneTqrNzz43uSpKruUlXf1d1/n+QTVfWvZuurqh6+ar9vTfJfk/x5rdyr5B5Jjurui5P8fJLVYzPbxwO6+8Pd/dKsfEGyty849ubyJI+vqhNn+9l9iaNLkjy/ZocrV9Uj9/KahyX5oyS/092772eS7u4klyZ55mzVc5L8yar9vCYrX27cuGp3lyR5Wq3cI+borBxhfUl3/9GqL1m2r3FOXzd7X3b//Ev2N3Z2pPZuZ2YvR3MDoyWP5TEwDvJYHgMAAIyWBiBr9eEkx2TlS4LV627u7s91921Z+T/5L62qDyb5QFaOfk6Sf53knNn6K5OctXrH3f0HWbn3yLas3Ovkz6rqQ0n+OskL9lLLz1XVR2Zjvpp/unfIfnX3riTnJvnDWS1vmm365SR3SfKhqrpytrynH0ry+CTPXXUU8SNm234hyQuqakdW7nny2tn6lye5R1Yu7/SBqto2q+Om2WtcMXuct+pyS9+gqj6ZlUtKPbeqdlbVKbP1L6uqnUnuPlv/S/v4+X2N+7dVdeXs9/Bvkzx3n784YGzksTwGxkEey2MAAIDRqpUDNAEAAAAAAIApcAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMyGANwKq6sKpurKqP7GN7VdVvVNWOqvpQVT1qqFoAlp1MBhgHeQwwDvIYYBzkMcBwhjwD8HVJTt/P9jOSnDR7nJvkNwesBWDZvS4yGWAMXhd5DDAGr4s8BhiD10UeAwxisAZgd78zyU37GXJWkt/pFZcnuWdV3XeoegCWmUwGGAd5DDAO8hhgHOQxwHA2LfC1j01y3arlnbN1n9lzYFWdm5UjPHLEEUc8+sEPfvBcCgQY2vve977PdffmRdeRNWayPAamaqPlcSKTgWmSxwDjII8BxuPOZvIiG4Br1t0XJLkgSbZu3drbt29fcEUA66OqPrXoGg6GPAamaqPlcSKTgWmSxwDjII8BxuPOZvKQ9wA8kOuTHLdqectsHQDzJ5MBxkEeA4yDPAYYB3kMcCctsgG4LcmP1IrHJrm5u7/p1G0A5kImA4yDPAYYB3kMMA7yGOBOGuwSoFX1+0lOS3JMVe1M8otJ7pIk3f3qJBcneXqSHUluSfKjQ9UCsOxkMsA4yGOAcZDHAOMgjwGGM1gDsLvPPsD2TvIzQ70+AP9EJgOMgzwGGAd5DDAO8hhgOIu8BCgAAAAAAACwzjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQgZtAFbV6VV1dVXtqKoX7WX7/arq0qp6f1V9qKqePmQ9AMtKHgOMgzwGGA+ZDDAO8hhgGIM1AKvq0CTnJzkjySlJzq6qU/YY9p+SvLm7H5nkWUleNVQ9AMtKHgOMgzwGGA+ZDDAO8hhgOEOeAXhqkh3dfW1335bkjUnO2mNMJ/m22fOjktwwYD0Ay0oeA4yDPAYYD5kMMA7yGGAgmwbc97FJrlu1vDPJY/YY80tJ3lZVz09yRJKnDFgPwLKSxwDjII8BxkMmA4yDPAYYyKD3AFyDs5O8rru3JHl6kjdU1TfVVFXnVtX2qtq+a9euuRcJsATkMcA4rCmPE5kMMAf+RgYYB3kMcCcM2QC8Pslxq5a3zNatdk6SNydJd78nyV2THLPnjrr7gu7e2t1bN2/ePFC5AJMljwHGYd3yeLZdJgPcef5GBhgHeQwwkCEbgFckOamqTqyqw7Jyg9Zte4z5dJInJ0lVPSQr4e3wDID1JY8BxkEeA4yHTAYYB3kMMJDBGoDdfXuS5yW5JMlHk7y5u6+sqvOq6szZsBcm+fGq+mCS30/y3O7uoWoCWEbyGGAc5DHAeMhkgHGQxwDD2TTkzrv74iQX77HuJaueX5Xke4esAQB5DDAW8hhgPGQywDjIY4BhDHkJUAAAAAAAAGDONAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQjQAAQAAAAAAYEI0AAEAAAAAAGBCNAABAAAAAABgQgZtAFbV6VV1dVXtqKoX7WPMD1XVVVV1ZVX93pD1ACwreQwwDvIYYDxkMsA4yGOAYWwaasdVdWiS85M8NcnOJFdU1bbuvmrVmJOS/Mck39vdX6iqbx+qHoBlJY8BxkEeA4yHTAYYB3kMMJwhzwA8NcmO7r62u29L8sYkZ+0x5seTnN/dX0iS7r5xwHoAlpU8BhgHeQwwHjIZYBzkMcBAhmwAHpvkulXLO2frVntQkgdV1buq6vKqOn1vO6qqc6tqe1Vt37Vr10DlAkyWPAYYh3XL40QmA3yL/I0MMA7yGGAgg94DcA02JTkpyWlJzk7yW1V1zz0HdfcF3b21u7du3rx5vhUCLAd5DDAOa8rjRCYDzIG/kQHGQR4D3AlDNgCvT3LcquUts3Wr7Uyyrbu/2t2fSHJNVsIcgPUjjwHGQR4DjIdMBhgHeQwwkCEbgFckOamqTqyqw5I8K8m2Pcb8cVaO3EhVHZOV07mvHbAmgGUkjwHGQR4DjIdMBhgHeQwwkMEagN19e5LnJbkkyUeTvLm7r6yq86rqzNmwS5J8vqquSnJpkn/f3Z8fqiaAZSSPAcZBHgOMh0wGGAd5DDCc6u5F13BQtm7d2tu3b190GQDroqre191bF13HnSGPgSnZyHmcyGRgOuQxwDjIY4DxuLOZPOQlQAEAAAAAAIA50wAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACRm0AVhVp1fV1VW1o6petJ9xz6iqrqqtQ9YDsKzkMcA4yGOA8ZDJAOMgjwGGMVgDsKoOTXJ+kjOSnJLk7Ko6ZS/jjkzys0neO1QtAMtMHgOMgzwGGA+ZDDAO8hhgOEOeAXhqkh3dfW1335bkjUnO2su4X07y0iRfGbAWgGUmjwHGQR4DjIdMBhgHeQwwkCEbgMcmuW7V8s7Zuq+rqkclOa67/3x/O6qqc6tqe1Vt37Vr1/pXCjBt8hhgHNYtj2djZTLAnedvZIBxkMcAAxn0HoD7U1WHJHlFkhceaGx3X9DdW7t76+bNm4cvDmCJyGOAcTiYPE5kMsCQ/I0MMA7yGODOG7IBeH2S41Ytb5mt2+3IJA9NcllVfTLJY5NscxNXgHUnjwHGQR4DjIdMBhgHeQwwkCEbgFckOamqTqyqw5I8K8m23Ru7++buPqa7T+juE5JcnuTM7t4+YE0Ay0geA4yDPAYYD5kMMA7yGGAggzUAu/v2JM9LckmSjyZ5c3dfWVXnVdWZQ70uAN9IHgOMgzwGGA+ZDDAO8hhgOJuG3Hl3X5zk4j3WvWQfY08bshaAZSaPAcZBHgOMh0wGGAd5DDCMIS8BCgAAAAAAAMyZBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEyIBiAAAAAAAABMiAYgAAAAAAAATIgGIAAAAAAAAEzIoA3Aqjq9qq6uqh1V9aK9bH9BVV1VVR+qqrdX1fFD1gOwrOQxwDjIY4DxkMkA4yCPAYYxWAOwqg5Ncn6SM5KckuTsqjplj2HvT7K1u787yUVJXjZUPQDLSh4DjIM8BhgPmQwwDvIYYDhDngF4apId3X1td9+W5I1Jzlo9oLsv7e5bZouXJ9kyYD0Ay0oeA4yDPAYYD5kMMA7yGGAgQzYAj01y3arlnbN1+3JOkrfsbUNVnVtV26tq+65du9axRIClII8BxmHd8jiRyQDfIn8jA4yDPAYYyKD3AFyrqnp2kq1JXr637d19QXdv7e6tmzdvnm9xAEtEHgOMw4HyOJHJAPPib2SAcZDHAAdn04D7vj7JcauWt8zWfYOqekqSFyd5QnffOmA9AMtKHgOMgzwGGA+ZDDAO8hhgIEOeAXhFkpOq6sSqOizJs5JsWz2gqh6Z5DVJzuzuGwesBWCZyWOAcZDHAOMhkwHGQR4DDGSwBmB3357keUkuSfLRJG/u7iur6ryqOnM27OVJ7pHkD6rqA1W1bR+7A+BOkscA4yCPAcZDJgOMgzwGGM6QlwBNd1+c5OI91r1k1fOnDPn6AKyQxwDjII8BxkMmA4yDPAYYxpCXAAUAAAAAAADmTAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJkQDEAAAAAAAACZEAxAAAAAAAAAmRAMQAAAAAAAAJmTQBmBVnV5VV1fVjqp60V62H15Vb5ptf29VnTBkPQDLSh4DjIM8BhgPmQwwDvIYYBiDNQCr6tAk5yc5I8kpSc6uqlP2GHZOki909wOTvDLJS4eqB2BZyWOAcZDHAOMhkwHGQR4DDGfIMwBPTbKju6/t7tuSvDHJWXuMOSvJ62fPL0ry5KqqAWsCWEbyGGAc5DHAeMhkgHGQxwAD2TTgvo9Nct2q5Z1JHrOvMd19e1XdnOTeST63elBVnZvk3NnirVX1kUEqHrdjssfvZUks47yXcc7J8s775Dm8hjxeX8v6WV3GeS/jnJPlnfeGyuNEJmd5P6vmvTyWcc7JfPI48TfyelvGz+syzjkx72UijzemZfysJss572Wcc7K8875TmTxkA3DddPcFSS5Ikqra3t1bF1zS3Jn38ljGOSfLPe9F13Aw5LF5L7qOeVrGOSfLPe9F13Cwlj2Tl3HOiXkvuo55WsY5J/J4o1rGeS/jnBPzXnQd8ySPNybzXh7LOOdkued9Z35uyEuAXp/kuFXLW2br9jqmqjYlOSrJ5wesCWAZyWOAcZDHAOMhkwHGQR4DDGTIBuAVSU6qqhOr6rAkz0qybY8x25I8Z/b8mUn+qrt7wJoAlpE8BhgHeQwwHjIZYBzkMcBABrsE6Ox6zM9LckmSQ5Nc2N1XVtV5SbZ397Ykr03yhqrakeSmrAT8gVwwVM0jZ97LYxnnnJj3YOTxujPv5bGMc07MezAD5nGynO/bMs45Me9lsoxzTuY0b38jr7tlnPcyzjkx72Uijzcm814eyzjnxLwPSjlYAgAAAAAAAKZjyEuAAgAAAAAAAHOmAQgAAAAAAAATMtoGYFWdXlVXV9WOqnrRXrYfXlVvmm1/b1WdsIAy19Ua5vyCqrqqqj5UVW+vquMXUed6O9C8V417RlV1VW2dZ31DWcu8q+qHZu/5lVX1e/OucQhr+Jzfr6ourar3zz7rT19Eneupqi6sqhur6iP72F5V9Ruz38mHqupR865xf5YxjxOZvEyZLI/l8art8niE5LE83mOMPJbHo7CMmSyPlyePk+XM5GXM42TjZ7I8lsd7GSePJ2AZM3mQPO7u0T2ycsPXjye5f5LDknwwySl7jPnpJK+ePX9Wkjctuu45zPmJSe4+e/5TG33Oa533bNyRSd6Z5PIkWxdd95ze75OSvD/J0bPlb1903XOa9wVJfmr2/JQkn1x03esw78cneVSSj+xj+9OTvCVJJXlskvcuuuaDfM8mlccHMW+ZPIFMlsfyeI/t8nhkD3ksj/cYI4/l8Sgey5jJ8nh58vgg3u9JZfKy5vFsLhs2k+WxPN7LOHm8wfP4IOY9uUweIo/HegbgqUl2dPe13X1bkjcmOWuPMWclef3s+UVJnlxVNcca19sB59zdl3b3LbPFy5NsmXONQ1jLe50kv5zkpUm+Ms/iBrSWef94kvO7+wtJ0t03zrnGIaxl3p3k22bPj0pywxzrG0R3vzPJTfsZclaS3+kVlye5Z1Xddz7VHdAy5nEik5cpk+WxPF5NHo+PPJbHq8ljeTwWy5jJ8nh58jhZzkxeyjxONnwmy2N5vCd5vPHzOFnSTB4ij8faADw2yXWrlnfO1u11THffnuTmJPeeS3XDWMucVzsnK93eje6A856dynpcd//5PAsb2Fre7wcleVBVvauqLq+q0+dW3XDWMu9fSvLsqtqZ5OIkz59PaQt1sP/+52kZ8ziRybstQybL4xXyeIU8Hh95vEIer5DH8ngsljGT5fGKZcjjZDkzWR7v25gzWR7L46+Tx5PJ40Qm78tB5/GmQcthEFX17CRbkzxh0bUMraoOSfKKJM9dcCmLsCkrp3CflpUjdd5ZVQ/r7i8usqg5ODvJ67r7V6vqe5K8oaoe2t13LLow2BuZvBTksTxmA5DHS0Eey2M2AHm8NJYxk+UxG4o8XhrLmMeJTF6TsZ4BeH2S41Ytb5mt2+uYqtqUldM8Pz+X6oaxljmnqp6S5MVJzuzuW+dU25AONO8jkzw0yWVV9cmsXNt22wRu4rqW93tnkm3d/dXu/kSSa7IS5hvZWuZ9TpI3J0l3vyfJXZMcM5fqFmdN//4XZBnzOJHJuy1DJsvjFfJ4hTweH3m8Qh6vkMfyeCyWMZPl8YplyONkOTNZHu/bmDNZHsvj3eTxdPI4kcn7ctB5PNYG4BVJTqqqE6vqsKzcoHXbHmO2JXnO7Pkzk/xV98qdEDeoA865qh6Z5DVZCe4pXMs3OcC8u/vm7j6mu0/o7hOyct3qM7t7+2LKXTdr+Yz/cVaO3EhVHZOV07mvnWONQ1jLvD+d5MlJUlUPyUp475prlfO3LcmP1IrHJrm5uz+z6KJmljGPE5m8TJksj+XxavJ4fOSxPF7tjyOP5fE4LGMmy+PlyeNkOTNZHu/bmDNZHsvjJPI408rjRCbvy8HncXeP8pHk6VnpVn88yYtn687Lyj/cZOUN/YMkO5L8TZL7L7rmOcz5L5N8NskHZo9ti655HvPeY+xlSbYuuuY5vd+VlVPXr0ry4STPWnTNc5r3KUneleSDs8/50xZd8zrM+feTfCbJV7NyVM45SX4yyU+ueq/Pn/1OPjy2z/gy5vEa5y2TJ5LJ8lgey+NxP+SxPJbH8niMn+9lzGR5vDx5vMb3e3KZvIx5PJvXhs5keSyP5fH08niN855cJg+RxzX7QQAAAAAAAGACxnoJUAAAAAAAAOBO0AAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ0QAEAAAAAACACdEABAAAAAAAgAnRAAQAAAAAAIAJ+f8BLXk5iZBmp6sAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -280,7 +313,6 @@ " 'fare_amount',\n", " 'extra',\n", " 'mta_tax',\n", - " 'tip_amount',\n", " 'tolls_amount',\n", " 'improvement_surcharge',\n", " 'total_amount_per_mile',\n", @@ -295,7 +327,7 @@ " df_data, time_index_col, date_slices[0], date_slices[1:],\n", " is_continuous_annotations)\n", "\n", - "plot_interweek_performance(\n", + "plot_feature_wise_interweek_performance(\n", " accessor_factory_annotated,\n", " TabularModel(),\n", " 'tip_percent_greater_15')" @@ -303,7 +335,21 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + " depend on alibi_detect implementation of trainer for\n", + " fast implementation of train loop\n", + "'''\n", + "from alibi_detect.models.pytorch.trainer import trainer\n", + "from torch.utils.data import TensorDataset, DataLoader" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -347,62 +393,91 @@ " df_data, time_index_col, date_slices[0], date_slices[1:],\n", " is_continuous_annotations)\n", "\n", - "drift_perf = get_drift_perf(\n", + "model_perf_dfs = []\n", + "runtime_dfs = []\n", + "\n", + "model_baseline_perf, runtime = get_drift_perf_with_runtimes(accessor_factory_default,\n", + " OutputClassifierAccuracyBaselineModel(RandomForestClassifier()), x_labels, y_label)\n", + "model_perf_dfs.append(create_df_model_performance('AccuracyBaseline', model_baseline_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('AccuracyBaseline', runtime, date_slices))\n", + "\n", + "# TODO: verify with Shreya that 'micro' arguments to sklearn f1_score\n", + "# is what works for this binary classifier case.\n", + "model_baseline_perf, runtime = get_drift_perf_with_runtimes(accessor_factory_default,\n", + " OutputClassifierF1ScoreBaselineModel(RandomForestClassifier()), x_labels, y_label)\n", + "model_perf_dfs.append(create_df_model_performance('F1ScoreBaseline', model_baseline_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('F1ScoreBaseline', runtime, date_slices))\n", + "\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_annotated, TabularModel(), x_labels, y_label)\n", - "np.savetxt('TabularModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('TabularModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('TabularModel', runtime, date_slices))\n", "\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, CVMModel(), x_labels, y_label)\n", - "np.savetxt('CVMModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('CVMModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('CVMModel', runtime, date_slices))\n", "\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, FETModel(), x_labels, y_label)\n", - "np.savetxt('FETModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('FETModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('FETModel', runtime, date_slices))\n", "\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, MMDModel(), x_labels, y_label)\n", - "np.savetxt('MMDModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('MMDModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('MMDModel', runtime, date_slices))\n", "\n", "proj = nn.Sequential(\n", " nn.Linear(len(x_labels), 10),\n", " nn.Linear(10, 10),\n", ")\n", "kernel = DeepKernel(proj, eps=0.01)\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, LearnedKernelModel(kernel), x_labels, y_label)\n", - "np.savetxt('LearnedKernelModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('LearnedKernelModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('LearnedKernelModel', runtime, date_slices))\n", "\n", "model = nn.Sequential(\n", " nn.Linear(len(x_labels), 10),\n", " nn.ReLU(),\n", " nn.Linear(10, 2),\n", ")\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, ClassifierDriftModel(model), x_labels, y_label)\n", - "np.savetxt('ClassifierDriftModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('ClassifierDriftModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('ClassifierDriftModel', runtime, date_slices))\n", "\n", - "drift_perf = get_drift_perf(\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", " accessor_factory_default, SpotTheDiffModel(), x_labels, y_label)\n", - "np.savetxt('SpotTheDiffModel.csv', drift_perf, delimiter=',')\n", + "model_perf_dfs.append(create_df_model_performance('SpotTheDiffModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('SpotTheDiffModel', runtime, date_slices))\n", "\n", "model = nn.Sequential(\n", " nn.Linear(len(x_labels), 10),\n", " nn.ReLU(),\n", " nn.Linear(10, 2),\n", ")\n", - "drift_perf = get_drift_perf(\n", - " accessor_factory_default, ClassifierUncertaintyModel(model), x_labels, y_label)\n", - "np.savetxt('SpotTheDiffModel.csv', drift_perf, delimiter=',')" + "def train_model_function(model, train_x, train_y):\n", + " x_tensor = torch.tensor(train_x, dtype=torch.float)\n", + " y_tensor = torch.tensor(train_y, dtype=torch.long)\n", + " dataloader = DataLoader(TensorDataset(x_tensor, y_tensor))\n", + " trainer(model, nn.CrossEntropyLoss(), dataloader, 'cpu', verbose=0)\n", + "drift_perf, runtime = get_drift_perf_with_runtimes(\n", + " accessor_factory_default, ClassifierUncertaintyModel(model, train_model_function), x_labels, y_label)\n", + "model_perf_dfs.append(create_df_model_performance('ClassifierUncertaintyModel', drift_perf, date_slices))\n", + "runtime_dfs.append(create_df_model_performance('ClassifierUncertaintyModel', runtime, date_slices))\n", + "\n", + "pd.concat(model_perf_dfs).to_csv('ModelPerfAggregated.csv')\n", + "pd.concat(runtime_dfs).to_csv('ModelRuntimeAggregated.csv')" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# TODO: get the f1 score of some model and also export csv" - ] + "source": [] } ], "metadata": { From cf0d7b5b65753559a19fc5cda94a365f08999e0e Mon Sep 17 00:00:00 2001 From: Yujie Wang <30487251+yuji3w@users.noreply.github.com> Date: Mon, 25 Apr 2022 14:34:45 -0700 Subject: [PATCH 3/4] Remove tip_amount from train labels `tip_amount` leaks information to `tip_percent_greater_15` --- model.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/model.ipynb b/model.ipynb index cd6150e..5f33cce 100644 --- a/model.ipynb +++ b/model.ipynb @@ -376,7 +376,6 @@ " 'fare_amount',\n", " 'extra',\n", " 'mta_tax',\n", - " 'tip_amount',\n", " 'tolls_amount',\n", " 'improvement_surcharge',\n", " 'total_amount_per_mile',\n", From d38724f6d02b0dd13426dd7949a654098332542c Mon Sep 17 00:00:00 2001 From: Yujie Wang <30487251+yuji3w@users.noreply.github.com> Date: Wed, 27 Apr 2022 18:50:19 -0700 Subject: [PATCH 4/4] Replace registration decorators with direct inheritance --- lib/model.py | 33 +++++++++++---------------------- 1 file changed, 11 insertions(+), 22 deletions(-) diff --git a/lib/model.py b/lib/model.py index a6d4738..1dba10c 100644 --- a/lib/model.py +++ b/lib/model.py @@ -32,22 +32,19 @@ def infer(self, x_infer, y_infer) -> float: ''' pass -@ModelWrapperInterface.register -class CVMModel: +class CVMModel(ModelWrapperInterface): def fit(self, x_fit, y_fit): self.model = CVMDrift(x_fit) def infer(self, x_infer, y_infer) -> float: return self.model.predict(x_infer)['data']['p_val'][0] -@ModelWrapperInterface.register -class MMDModel: +class MMDModel(ModelWrapperInterface): def fit(self, x_fit, y_fit): self.model = MMDDrift(x_fit) def infer(self, x_infer, y_infer) -> float: return self.model.predict(x_infer)['data']['p_val'] -@ModelWrapperInterface.register -class TabularModel: +class TabularModel(ModelWrapperInterface): def fit(self, x_fit_annotated, y_fit_annotated): ''' Because TabularModel chooses between KS and Chi-Squared @@ -66,8 +63,7 @@ def infer(self, x_infer_annotated, y_infer_annotated) -> float: x_infer, _ = x_infer_annotated return self.model.predict(x_infer)['data']['p_val'][0] -@ModelWrapperInterface.register -class FETModel: +class FETModel(ModelWrapperInterface): def __init__(self, classifier_model = None, train_drift_frac = .7): if classifier_model is None: classifier_model = RandomForestClassifier() @@ -86,8 +82,7 @@ def infer(self, x_infer, y_infer) -> float: x_infer_classified = self.classifier_model.predict(x_infer) return self.model.predict(x_infer_classified)['data']['p_val'][0] -@ModelWrapperInterface.register -class LearnedKernelModel: +class LearnedKernelModel(ModelWrapperInterface): def __init__(self, kernel:DeepKernel): self.kernel = kernel def fit(self, x_fit, y_fit): @@ -98,8 +93,7 @@ def infer(self, x_infer, y_infer) -> float: x_infer = x_infer.astype(np.float32) return self.model.predict(x_infer)['data']['p_val'] -@ModelWrapperInterface.register -class ClassifierDriftModel: +class ClassifierDriftModel(ModelWrapperInterface): def __init__(self, classifier_model:nn.Module): self.classifier_model = classifier_model def fit(self, x_fit, y_fit): @@ -111,8 +105,7 @@ def infer(self, x_infer, y_infer) -> float: x_infer = x_infer.astype(np.float32) return self.model.predict(x_infer)['data']['p_val'] -@ModelWrapperInterface.register -class SpotTheDiffModel: +class SpotTheDiffModel(ModelWrapperInterface): def fit(self, x_fit, y_fit): x_fit = x_fit.astype(np.float32) self.model = SpotTheDiffDrift(x_fit, backend='pytorch') @@ -120,8 +113,7 @@ def infer(self, x_infer, y_infer) -> float: x_infer = x_infer.astype(np.float32) return self.model.predict(x_infer)['data']['p_val'] -@ModelWrapperInterface.register -class ClassifierUncertaintyModel: +class ClassifierUncertaintyModel(ModelWrapperInterface): def __init__(self, classifier_model = None, train_fxn = None, train_drift_frac = .7): if classifier_model is None: classifier_model = nn.Sequential( @@ -147,15 +139,13 @@ def infer(self, x_infer, y_infer) -> float: return self.model.predict(x_infer)['data']['p_val'] # TODO: track the runtime -@ModelWrapperInterface.register -class CVMModel: +class CVMModel(ModelWrapperInterface): def fit(self, x_fit, y_fit): self.model = CVMDrift(x_fit) def infer(self, x_infer, y_infer) -> float: return self.model.predict(x_infer)['data']['p_val'][0] -@ModelWrapperInterface.register -class OutputClassifierAccuracyBaselineModel: +class OutputClassifierAccuracyBaselineModel(ModelWrapperInterface): ''' Wrapper for sklearn classifier model. ''' @@ -166,8 +156,7 @@ def fit(self, x_fit, y_fit): def infer(self, x_infer, y_infer) -> float: return self.model.score(x_infer, y_infer.reshape(-1)) -@ModelWrapperInterface.register -class OutputClassifierF1ScoreBaselineModel: +class OutputClassifierF1ScoreBaselineModel(ModelWrapperInterface): ''' Wrapper for sklearn classifier model. '''