From d190a36f315040b6d7a4c5a648f052256fbf153c Mon Sep 17 00:00:00 2001 From: Xinyue Zhang Date: Mon, 5 Feb 2024 00:16:47 +0100 Subject: [PATCH] clean up mimic3 notebook --- ehrdata.py | 793 +++++-- ml_usecases_mimic3_omop.ipynb | 3823 ++++++--------------------------- 2 files changed, 1278 insertions(+), 3338 deletions(-) diff --git a/ehrdata.py b/ehrdata.py index a93fccb..80ae05a 100644 --- a/ehrdata.py +++ b/ehrdata.py @@ -10,7 +10,7 @@ from anndata import AnnData import mudata as md from mudata import MuData -from typing import List, Union, Literal +from typing import List, Union, Literal, Optional import os import glob import dask.dataframe as dd @@ -21,8 +21,44 @@ import warnings import numbers import os +from pandas.tseries.offsets import DateOffset as Offset +import anndata as ad +from collections.abc import Collection, Iterable, Mapping, Sequence +from enum import Enum +from functools import partial +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, Callable, Literal, Union +import scanpy as sc +from scanpy.plotting import DotPlot, MatrixPlot, StackedViolin +from matplotlib.axes import Axes + + + +pth = 'auxillary_files/OMOP_CDMv5.4_Field_Level.csv' +field_level = pd.read_csv(pth) +dtype_mapping = {'integer': "Int64", + 'Integer': "Int64", + 'float': float, + 'bigint': "Int64", + 'varchar(MAX)': str, + 'varchar(2000)': str, + 'varchar(1000)': str, + 'varchar(255)': str, + 'varchar(250)': str, + 'varchar(80)': str, + 'varchar(60)': str, + 'varchar(50)': str, + 'varchar(25)': str, + 'varchar(20)': str, + 'varchar(10)': str, + 'varchar(9)': str, + 'varchar(3)': str, + 'varchar(2)': str, + 'varchar(1)': str, + 'datetime': object, + 'date': object} clinical_tables_columns = { "person": ["person_id", "year_of_birth", "gender_source_value"], "observation_period": [], @@ -61,7 +97,6 @@ "fact_relationship": [], "procedure_occurrence": [], } - health_system_tables_columns = { "location": [], "care_site": ["care_site_id", "care_site_name"], @@ -145,27 +180,31 @@ def check_csv_has_only_header(file_path): class OMOP: - def __init__(self, folder_path, delimiter=None): + def __init__(self, folder_path, delimiter=None, make_filename_lowercase=True, use_dask=False): self.base = folder_path + self.delimiter = delimiter + self.use_dask = use_dask # TODO support also parquet and other formats file_list = glob.glob(os.path.join(folder_path, "*.csv")) + glob.glob(os.path.join(folder_path, "*.parquet")) - self.loaded_tabel = None self.filepath = {} for file_path in file_list: file_name = file_path.split("/")[-1].split(".")[0] - - - new_filepath = os.path.join(self.base, file_path.split("/")[-1].lower()) if check_csv_has_only_header(file_path): pass else: # Rename the file - os.rename(file_path, new_filepath) - self.filepath[file_name] = new_filepath - + if make_filename_lowercase: + new_filepath = os.path.join(self.base, file_path.split("/")[-1].lower()) + if file_path != new_filepath: + warnings(f"Rename file [file_path] to [new_filepath]") + os.rename(file_path, new_filepath) + self.filepath[file_name] = new_filepath + else: + self.filepath[file_name] = file_path + self.check_with_omop_cdm() self.tables = list(self.filepath.keys()) - self.delimiter = delimiter + """ if "concept" in self.tables: df_concept = dd.read_csv(self.filepath["concept"], usecols=vocabularies_tables_columns["concept"]) @@ -197,12 +236,43 @@ def set_path(self, table_name, file_path): self.tables.append(table_name) self.filepath[table_name] = file_path - + def check_with_omop_cdm(self): + for file_name, path in self.filepath.items(): + if file_name not in set(field_level.cdmTableName): + raise KeyError(f"Table [{file_name}] is not defined in OMOP CDM v5.4! Please change the table name manually!") + # If not a single file, read the first one + if not os.path.isfile(path): + folder_walk = os.walk(path) + first_file_in_folder = next(folder_walk)[2][0] + path = os.path.join(path, first_file_in_folder) + + if path.endswith('csv'): + with open(path, "r") as f: + dict_reader = csv.DictReader(f, delimiter=self.delimiter) + columns = dict_reader.fieldnames + columns = list(filter(None, columns)) + elif path.endswith('parquet'): + df = dd.read_parquet(path) + columns = list(df.columns) + else: + raise TypeError("Only support CSV and Parquet file!") + columns_lowercase = [column.lower() for column in columns] + + invalid_column_name = [] + for _, column in enumerate(columns_lowercase): + cdm_columns = set(field_level[field_level.cdmTableName == file_name]['cdmFieldName']) + if column not in cdm_columns: + invalid_column_name.append(column) + if len(invalid_column_name) > 0: + print(f"Column {invalid_column_name} is not defined in Table [{file_name}] in OMOP CDM v5.4! Please change the column name manually!\nFor more information, please refer to: https://ohdsi.github.io/CommonDataModel/cdm54.html#{file_name.upper()}") + raise KeyError + + # TODO redo this using omop cdm csv file - def _get_column_types(self, path=None, columns=None): + def _get_column_types(self, + path: str = None, + filename: str = None): column_types = {} - parse_dates = [] - # If not a single file, read the first one if not os.path.isfile(path): folder_walk = os.walk(path) @@ -220,47 +290,9 @@ def _get_column_types(self, path=None, columns=None): else: raise TypeError("Only support CSV and Parquet file!") columns_lowercase = [column.lower() for column in columns] - for i, column in enumerate(columns_lowercase): - if hasattr(self, "additional_column") and column in self.additional_column.keys(): - column_types[columns[i]] = self.additional_column[column] - elif column.endswith( - ( - "source_value", - "reason", - "measurement_time", - "as_string", - "title", - "text", - "name", - "concept", - "code", - "domain_id", - "vocabulary_id", - "concept_class_id", - "relationship_id", - "specimen_source_id", - "production_id", - "unique_device_id", - "sig", - "lot_number", - ) - ): - column_types[columns[i]] = object - # TODO quantity in different tables have different types - elif column.endswith(("as_number", "low", "high", "quantity")): - column_types[columns[i]] = float - elif column.endswith("date"): - parse_dates.append(columns[i]) - elif column.endswith("datetime"): - parse_dates.append(columns[i]) - elif column.endswith(("id", "birth", "id_1", "id_2", "refills", "days_supply")): - column_types[columns[i]] = "Int64" - - else: - raise KeyError(f"{columns[i]} is not defined in OMOP CDM") - if len(parse_dates) == 0: - parse_dates = None - return column_types, parse_dates + for _, column in enumerate(columns_lowercase): + column_types[column] = dtype_mapping[field_level[(field_level.cdmTableName == filename) & (field_level.cdmFieldName == column)]['cdmDatatype'].values[0]] + return column_types def _read_table(self, path, dtype=None, parse_dates=None, index=None, usecols=None, use_dask=False, **kwargs): @@ -390,7 +422,7 @@ def load(self, level="stay_level", tables=["visit_occurrence", "person", "death" for table in tables: print(f"reading table [{table}]") - column_types, parse_dates = self._get_column_types(self.filepath[table]) + column_types = self._get_column_types(path = self.filepath[table], filename=table) df = self._read_table(self.filepath[table], dtype=column_types, index='person_id') # TODO parse_dates = parse_dates if remove_empty_column: # TODO dask Support @@ -406,19 +438,23 @@ def load(self, level="stay_level", tables=["visit_occurrence", "person", "death" # self.loaded_tabel = ['visit_occurrence', 'person', 'death', 'measurement', 'observation', 'drug_exposure'] # TODO dask Support joined_table = pd.merge(self.visit_occurrence, self.person, left_index=True, right_index=True, how="left") + joined_table = pd.merge(joined_table, self.death, left_index=True, right_index=True, how="left") # TODO dask Support #joined_table = joined_table.compute() + # TODO check this earlier + joined_table = joined_table.drop_duplicates(subset='visit_occurrence_id') joined_table = joined_table.set_index("visit_occurrence_id") - # obs_only_list = list(self.joined_table.columns) # obs_only_list.remove('visit_occurrence_id') columns_obs_only = list(set(joined_table.columns) - set(["year_of_birth", "gender_source_value"])) adata = ep.ad.df_to_anndata( joined_table, index_column="visit_occurrence_id", columns_obs_only=columns_obs_only ) + # TODO this needs to be fixed because anndata set obs index as string by default + #adata.obs.index = adata.obs.index.astype(int) """ for column in self.measurement.columns: @@ -444,12 +480,6 @@ def load(self, level="stay_level", tables=["visit_occurrence", "person", "death" """ return adata - - def add_additional_column(self, column_name, type): - if hasattr(self, "additional_column"): - self.additional_column[column_name] = type - else: - self.additional_column = {column_name: type} def feature_counts( self, @@ -475,8 +505,8 @@ def feature_counts( else: raise KeyError(f"Extracting data from {source} is not supported yet") - column_types, parse_dates = self._get_column_types(self.filepath[source]) - df_source = self._read_table(self.filepath[source], dtype=column_types, parse_dates = parse_dates, usecols=[f"{source}_concept_id"], use_dask=True) + column_types = self._get_column_types(path = self.filepath[source], filename=source) + df_source = self._read_table(self.filepath[source], dtype=column_types, usecols=[f"{source}_concept_id"], use_dask=True) # TODO dask Support #feature_counts = df_source[f"{source}_concept_id"].value_counts().compute()[0:number] feature_counts = df_source[f"{source}_concept_id"].value_counts().compute() @@ -509,9 +539,9 @@ def map_concept_id(self, concept_id: Union[str, List], verbose=True): concept_id_mapped_not_found = [] if "concept_relationship" in self.tables: - column_types, parse_dates = self._get_column_types(self.filepath["concept_relationship"]) + column_types = self._get_column_types(path = self.filepath["concept_relationship"], filename="concept_relationship") df_concept_relationship = self._read_csv( - self.filepath["concept_relationship"], dtype=column_types, parse_dates=parse_dates + self.filepath["concept_relationship"], dtype=column_types ) # TODO dask Support #df_concept_relationship.compute().dropna(subset=["concept_id_1", "concept_id_2", "relationship_id"], inplace=True) # , usecols=vocabularies_tables_columns["concept_relationship"], @@ -555,8 +585,8 @@ def get_concept_name(self, concept_id: Union[str, List], raise_error=False, verb if isinstance(concept_id, numbers.Integral): concept_id = [concept_id] - column_types, parse_dates = self._get_column_types(self.filepath["concept"]) - df_concept = self._read_table(self.filepath["concept"], dtype=column_types, parse_dates=parse_dates) + column_types = self._get_column_types(path = self.filepath["concept"], filename="concept") + df_concept = self._read_table(self.filepath["concept"], dtype=column_types) # TODO dask Support #df_concept.compute().dropna(subset=["concept_id", "concept_name"], inplace=True, ignore_index=True) # usecols=vocabularies_tables_columns["concept"] df_concept.dropna(subset=["concept_id", "concept_name"], inplace=True, ignore_index=True) # usecols=vocabularies_tables_columns["concept"] @@ -581,8 +611,8 @@ def get_concept_name(self, concept_id: Union[str, List], raise_error=False, verb return concept_name def extract_note(self, adata, source="note"): - column_types, parse_dates = self._get_column_types(self.filepath[source]) - df_source = dd.read_csv(self.filepath[source], dtype=column_types, parse_dates=parse_dates) + column_types = self._get_column_types(path = self.filepath[source], filename=source) + df_source = dd.read_csv(self.filepath[source], dtype=column_types) if columns is None: columns = df_source.columns obs_dict = [ @@ -640,8 +670,8 @@ def get_feature_info( # TODO support features name if "concept" in self.tables: - column_types, parse_dates = self._get_column_types(self.filepath["concept"]) - df_concept = self._read_table(self.filepath["concept"], dtype=column_types, parse_dates=parse_dates).dropna( + column_types = self._get_column_types(path = self.filepath["concept"], filename="concept") + df_concept = self._read_table(self.filepath["concept"], dtype=column_types).dropna( subset=["concept_id", "concept_name"] ) # usecols=vocabularies_tables_columns["concept"], concept_dict = df_to_dict(df=df_concept, key="concept_id", value="concept_name") @@ -755,60 +785,62 @@ def get_feature_statistics( "condition_occurrence", ], features: str or int or List[Union[str, int]] = None, - key: str = None, level="stay_level", + value_col: str = 'value_source_value', aggregation_methods: Union[Literal["min", "max", "mean", "std", "count"], List[Literal["min", "max", "mean", "std", "count"]]]=None, add_aggregation_to_X: bool = True, verbose: bool = False, + use_dask: bool = None, ): - #TODO query this from OMOP CDM table - if key is None: - if source in ["measurement", "observation", "specimen"]: - key = f"{source}_concept_id" - elif source in ["device_exposure", "procedure_occurrence", "drug_exposure", "condition_occurrence"]: - key = f"{source.split('_')[0]}_concept_id" - else: - raise KeyError(f"Extracting data from {source} is not supported yet") - - #TODO + if source in ["measurement", "observation", "specimen"]: + key = f"{source}_concept_id" + elif source in ["device_exposure", "procedure_occurrence", "drug_exposure", "condition_occurrence"]: + key = f"{source.split('_')[0]}_concept_id" + else: + raise KeyError(f"Extracting data from {source} is not supported yet") + if source == 'measurement': - columns = ["value_as_number", "time", "visit_occurrence_id", "measurement_concept_id"] + source_table_columns = ['visit_occurrence_id', 'measurement_datetime', key, value_col] elif source == 'observation': - columns = ["value_as_number", "value_as_string", "measurement_datetime"] + source_table_columns = ['visit_occurrence_id', "observation_datetime", key, value_col] elif source == 'condition_occurrence': - columns = None + source_table_columns = None else: raise KeyError(f"Extracting data from {source} is not supported yet") - source_column_types, parse_dates = self._get_column_types(self.filepath[source]) - df_source = self._read_table(self.filepath[source], dtype=source_column_types, usecols=columns, use_dask=True) + + if use_dask is None: + use_dask = self.use_dask + source_column_types = self._get_column_types(path = self.filepath[source], filename=source) + df_source = self._read_table(self.filepath[source], dtype=source_column_types, usecols=source_table_columns, use_dask=use_dask) info_df = self.get_feature_info(adata, source=source, features=features, verbose=False) info_dict = info_df[['feature_id', 'feature_name']].set_index('feature_id').to_dict()['feature_name'] # Select featrues - da_measurement = df_source[df_source.measurement_concept_id.isin(list(info_df.feature_id))] - #TODO - # Select time - da_measurement = da_measurement[(da_measurement.time >= 0) & (da_measurement.time <= 48*60*60)] - da_measurement[f'feature_name'] = da_measurement[key].replace(info_dict) + df_source = df_source[df_source[key].isin(list(info_df.feature_id))] + #TODO Select time + #da_measurement = da_measurement[(da_measurement.time >= 0) & (da_measurement.time <= 48*60*60)] + #df_source[f'{source}_name'] = df_source[key].map(info_dict) if aggregation_methods is None: aggregation_methods = ["min", "max", "mean", "std", "count"] if level == 'stay_level': - aggregated = da_measurement.groupby(['visit_occurrence_id', 'measurement_concept_id']).agg({ - 'value_as_number': aggregation_methods - }) - result = aggregated.compute() + result = df_source.groupby(['visit_occurrence_id', key]).agg({ + value_col: aggregation_methods}) + + if use_dask: + result = result.compute() result = result.reset_index(drop=False) result.columns = ["_".join(a) for a in result.columns.to_flat_index()] result.columns = result.columns.str.removesuffix('_') - result.columns = result.columns.str.removeprefix('value_as_number_') - result['measurement_name'] = result.measurement_concept_id.replace(info_dict) + result.columns = result.columns.str.removeprefix(f'{value_col}_') + result[f'{source}_name'] = result[key].map(info_dict) df_statistics = result.pivot(index='visit_occurrence_id', - columns='measurement_name', + columns=f'{source}_name', values=aggregation_methods) df_statistics.columns = df_statistics.columns.swaplevel() df_statistics.columns = ["_".join(a) for a in df_statistics.columns.to_flat_index()] + # TODO sort_columns = True if sort_columns: @@ -820,8 +852,11 @@ def get_feature_statistics( new_column_order.append(col_name) df_statistics.columns = new_column_order + + df_statistics.index = df_statistics.index.astype(str) adata.obs = adata.obs.join(df_statistics, how='left') + if add_aggregation_to_X: adata = ep.ad.move_to_x(adata, list(df_statistics.columns)) return adata @@ -840,137 +875,535 @@ def extract_features( "condition_occurrence", ], features: str or int or List[Union[str, int]] = None, - key: str | None = None, - dropna: bool | None = True, - columns_in_source_table: str or List[str] = None, - map_concept: bool | None = True, - add_aggregation_to_X: bool | None = True, - aggregation_value_column: str = None, - aggregation_methods: Union[Literal["min", "max", "mean", "std", "count"], List[Literal["min", "max", "mean", "std", "count"]]]=None, - add_all_data: bool | None = True, - exact_match: bool | None = True, - remove_empty_column: bool | None = True, - ignore_not_shown_in_concept_table: bool | None = True, - verbose: bool | None = False, + source_table_columns: Union[str, List[str]] = None, + dropna: Optional[bool] = True, + verbose: Optional[bool] = True, + use_dask: bool = None, ): - if key is None: - if source in ["measurement", "observation", "specimen"]: - key = f"{source}_concept_id" - elif source in ["device_exposure", "procedure_occurrence", "drug_exposure", "condition_occurrence"]: - key = f"{source.split('_')[0]}_concept_id" - else: - raise KeyError(f"Extracting data from {source} is not supported yet") - if source == 'measurement': - columns = ['visit_occurrence_id', 'time', 'value_as_number', 'measurement_concept_id'] - elif source == 'observation': - columns = ["value_as_number", "value_as_string", "measurement_datetime"] - elif source == 'condition_occurrence': - columns = None + if source in ["measurement", "observation", "specimen"]: + key = f"{source}_concept_id" + elif source in ["device_exposure", "procedure_occurrence", "drug_exposure", "condition_occurrence"]: + key = f"{source.split('_')[0]}_concept_id" else: raise KeyError(f"Extracting data from {source} is not supported yet") + if source_table_columns is None: + if source == 'measurement': + source_table_columns = ['visit_occurrence_id', 'measurement_datetime', 'value_as_number', key] + elif source == 'observation': + source_table_columns = ['visit_occurrence_id', "value_as_number", "value_as_string", "observation_datetime", key] + elif source == 'condition_occurrence': + source_table_columns = None + else: + raise KeyError(f"Extracting data from {source} is not supported yet") + if use_dask is None: + use_dask = self.use_dask + # TODO load using Dask or Dask-Awkward # Load source table using dask - source_column_types, parse_dates = self._get_column_types(self.filepath[source]) - df_source = self._read_table(self.filepath[source], dtype=source_column_types, usecols=columns, use_dask=True) + source_column_types = self._get_column_types(path = self.filepath[source], filename=source) + df_source = self._read_table(self.filepath[source], dtype=source_column_types, usecols=source_table_columns, use_dask=use_dask) info_df = self.get_feature_info(adata, source=source, features=features, verbose=False) info_dict = info_df[['feature_id', 'feature_name']].set_index('feature_id').to_dict()['feature_name'] # Select featrues - df_source = df_source[df_source.measurement_concept_id.isin(list(info_df.feature_id))] - # TODO - # Select time - df_source = df_source[(df_source.time >= 0) & (df_source.time <= 48*60*60)] + df_source = df_source[df_source[key].isin(list(info_df.feature_id))] + + # TODO select time period + #df_source = df_source[(df_source.time >= 0) & (df_source.time <= 48*60*60)] #da_measurement['measurement_name'] = da_measurement.measurement_concept_id.replace(info_dict) - - if dropna == True: - da_measurement_in_memory = df_source.compute().dropna() + + # TODO dask caching + """ + from dask.cache import Cache + cache = Cache(2e9) + cache.register() + """ + if use_dask: + if dropna == True: + df_source = df_source.compute().dropna() + else: + df_source = df_source.compute() else: - da_measurement_in_memory = df_source.compute() + if dropna == True: + df_source = df_source.dropna() + # Preprocess steps outside the loop - unique_feature_ids = set(info_dict.keys()) - unique_visit_occurrence_ids = set(adata.obs.index.astype(int)) - empty_entry = {'value_as_number': [], 'time': []} - + unique_visit_occurrence_ids = set(adata.obs.index)#.astype(int)) + empty_entry = {source_table_column: [] for source_table_column in source_table_columns if source_table_column not in [key, 'visit_occurrence_id'] } + # Filter data once, if possible - # Example: Create a dictionary with each feature_id - # This assumes da_measurement_in_memory is a DataFrame-like object filtered_data = { - feature_id: da_measurement_in_memory[da_measurement_in_memory.measurement_concept_id == feature_id] - for feature_id in unique_feature_ids + feature_id: df_source[df_source[key] == feature_id] + for feature_id in set(info_dict.keys()) } - for feature_id in unique_feature_ids: - df_feature = filtered_data[feature_id][['visit_occurrence_id', 'time', 'value_as_number']] + for feature_id in set(info_dict.keys()): + df_feature = filtered_data[feature_id][list(set(source_table_columns) - set([key]))] grouped = df_feature.groupby("visit_occurrence_id") - print(f"Adding feature [{info_dict[feature_id]}] into adata") + if verbose: + print(f"Adding feature [{info_dict[feature_id]}] into adata.obsm") # Use set difference and intersection more efficiently feature_ids = unique_visit_occurrence_ids.intersection(grouped.groups.keys()) # Creating the array more efficiently adata.obsm[info_dict[feature_id]] = ak.Array([ - grouped.get_group(visit_occurrence_id)[['value_as_number', 'time']].to_dict(orient='list') if visit_occurrence_id in feature_ids else empty_entry + grouped.get_group(visit_occurrence_id)[list(set(source_table_columns) - set([key, 'visit_occurrence_id']))].to_dict(orient='list') if visit_occurrence_id in feature_ids else empty_entry for visit_occurrence_id in unique_visit_occurrence_ids ]) return adata - def drop_nan(adata, - key: str, - slot: str | None = 'obsm', + def drop_nan(self, + adata, + key: Union[str, List[str]], + slot: Union[str, None] = 'obsm', ): + if isinstance(key, str): + key_list = [key] + else: + key_list = key if slot == 'obsm': - ak_array = adata.obsm[key] - combined_mask = ak.zeros_like(ak_array[ak_array.fields[0]], dtype=bool) + for key in key_list: + ak_array = adata.obsm[key] + + # Update the combined mask based on the presence of None in each field + for i, field in enumerate(ak_array.fields): + field_mask = ak.is_none(ak.nan_to_none(ak_array[field]), axis=1) + if i==0: + combined_mask = ak.full_like(field_mask, fill_value=False, dtype=bool) + combined_mask = combined_mask | field_mask + ak_array = ak_array[~combined_mask] + adata.obsm[key] = ak_array - # Update the combined mask based on the presence of None in each field - for field in ak_array.fields: - field_mask = ak.is_none(ak.nan_to_none(ak_array[field]), axis=1) - combined_mask = combined_mask | field_mask + return adata - ak_array = ak_array[~combined_mask] - adata.obsm[key] = ak_array + # downsampling + def aggregate_timeseries_in_bins(self, + adata, + features: Union[str, List[str]], + slot: Union[str, None] = 'obsm', + value_key: str = 'value_as_number', + time_key: str = 'measurement_datetime', + time_binning_method: Literal["floor", "ceil", "round"] = "floor", + bin_size: Union[str, Offset] = 'h', + aggregation_method: Literal['median', 'mean', 'min', 'max'] = 'median', + time_upper_bound: int = 48# TODO + ): - return adata + if isinstance(features, str): + features_list = [features] + else: + features_list = features + + # Ensure the time_binning_method provided is one of the expected methods + if time_binning_method not in ["floor", "ceil", "round"]: + raise ValueError(f"time_binning_method {time_binning_method} is not supported. Choose from 'floor', 'ceil', or 'round'.") + + if aggregation_method not in {'median', 'mean', 'min', 'max'}: + raise ValueError(f"aggregation_method {aggregation_method} is not supported. Choose from 'median', 'mean', 'min', or 'max'.") + if slot == 'obsm': + for feature in features_list: + print(f"processing feature [{feature}]") + df = self.to_dataframe(adata, features) + if pd.api.types.is_datetime64_any_dtype(df[time_key]): + func = getattr(df[time_key].dt, time_binning_method, None) + if func is not None: + df[time_key] = func(bin_size) + else: + # TODO need to take care of this if it doesn't follow omop standard + if bin_size == 'h': + df[time_key] = df[time_key] / 3600 + func = getattr(np, time_binning_method) + df[time_key] = func(df[time_key]) + + df[time_key] = df[time_key].astype(str) + # Adjust time values that are equal to the time_upper_bound + #df.loc[df[time_key] == time_upper_bound, time_key] = time_upper_bound - 1 + + # Group and aggregate data + df = df.groupby(["visit_occurrence_id", time_key])[value_key].agg(aggregation_method).reset_index(drop=False) + grouped = df.groupby("visit_occurrence_id") + + unique_visit_occurrence_ids = adata.obs.index + empty_entry = {value_key: [], time_key: []} + + # Efficiently use set difference and intersection + feature_ids = unique_visit_occurrence_ids.intersection(grouped.groups.keys()) + # Efficiently create the array + ak_array = ak.Array([ + grouped.get_group(visit_occurrence_id)[[value_key, time_key]].to_dict(orient='list') if visit_occurrence_id in feature_ids else empty_entry + for visit_occurrence_id in unique_visit_occurrence_ids + ]) + adata.obsm[feature] = ak_array + + return adata + + def timeseries_discretizer(self, + adata, + key: Union[str, List[str]], + slot: Union[str, None] = 'obsm', + value_key: str = 'value_as_number', + time_key: str = 'measurement_datetime', + freq: str = 'hour', #TODO + time_limit: int = 48, #TODO + method: str = 'median' #TODO + ): + + pass + + def from_dataframe( + self, + adata, + feature: str, + df + ): + grouped = df.groupby("visit_occurrence_id") + unique_visit_occurrence_ids = set(adata.obs.index) + + # Use set difference and intersection more efficiently + feature_ids = unique_visit_occurrence_ids.intersection(grouped.groups.keys()) + empty_entry = {source_table_column: [] for source_table_column in set(df.columns) if source_table_column not in ['visit_occurrence_id'] } + + # Creating the array more efficiently + ak_array = ak.Array([ + grouped.get_group(visit_occurrence_id)[list(set(df.columns) - set(['visit_occurrence_id']))].to_dict(orient='list') if visit_occurrence_id in feature_ids else empty_entry + for visit_occurrence_id in unique_visit_occurrence_ids]) + adata.obsm[feature] = ak_array + + return adata + # TODO add function to check feature and add concept # More IO functions def to_dataframe( self, adata, - feature: str, # TODO also support list of features + features: Union[str, List[str]], # TODO also support list of features # patient str or List, # TODO also support subset of patients/visit ): # TODO - # join index (visit_occurrence_id) to df # can be viewed as patient level - only select some patient + # TODO change variable name here + if isinstance(features, str): + features = [features] + df_concat = pd.DataFrame([]) + for feature in features: + df = ak.to_dataframe(adata.obsm[feature]) + + df.reset_index(drop=False, inplace=True) + df["entry"] = adata.obs.index[df["entry"]] + df = df.rename(columns={"entry": "visit_occurrence_id"}) + del df["subentry"] + for col in df.columns: + if col.endswith('time'): + df[col] = pd.to_datetime(df[col]) + + df['feature_name'] = feature + df_concat = pd.concat([df_concat, df], axis= 0) + + + return df_concat - df = ak.to_dataframe(adata.obsm[feature]) - df.reset_index(drop=False, inplace=True) - df["entry"] = adata.obs.index[df["entry"]] - df = df.rename(columns={"entry": "visit_occurrence_id"}) - del df["subentry"] - return df + def plot_timeseries(self, + adata, + visit_occurrence_id: int, + key: Union[str, List[str]], + slot: Union[str, None] = 'obsm', + value_key: str = 'value_as_number', + time_key: str = 'measurement_datetime', + x_label: str = None + ): + + + if isinstance(key, str): + key_list = [key] + else: + key_list = key + + # Initialize min_x and max_x + min_x = None + max_x = None + + if slot == 'obsm': + fig, ax = plt.subplots(figsize=(20, 6)) + # Scatter plot + for i, key in enumerate(key_list): + df = self.to_dataframe(adata, key) + x = df[df.visit_occurrence_id == visit_occurrence_id][time_key] + y = df[df.visit_occurrence_id == visit_occurrence_id][value_key] + + # Check if x is empty + if not x.empty: + ax.scatter(x=x, y=y, label=key) + ax.legend(loc=9, bbox_to_anchor=(0.5, -0.1), ncol=len(key_list), prop={"size": 14}) + + ax.plot(x, y) + + + if min_x is None or min_x > x.min(): + min_x = x.min() + if max_x is None or max_x < x.max(): + max_x = x.max() + + + else: + # Skip this iteration if x is empty + continue + + if min_x is not None and max_x is not None: + + # Adapt this to input data + # TODO step + #plt.xticks(np.arange(min_x, max_x, step=1)) + # Adapt this to input data + plt.xlabel(x_label if x_label else "Hours since ICU admission") + + plt.show() + - # More Plot functions - def plot_timeseries( + def violin( self, - ): - # add one function from previous pipeline - pass + adata: AnnData, + obsm_key: str = None, + keys: Union[str, Sequence[str]] = None, + groupby: Optional[str] = None, + log: Optional[bool] = False, + use_raw: Optional[bool] = None, + stripplot: bool = True, + jitter: Union[float, bool] = True, + size: int = 1, + layer: Optional[str] = None, + scale: Literal["area", "count", "width"] = "width", + order: Optional[Sequence[str]] = None, + multi_panel: Optional[bool] = None, + xlabel: str = "", + ylabel: Union[str, Sequence[str]] = None, + rotation: Optional[float] = None, + show: Optional[bool] = None, + save: Union[bool, str] = None, + ax: Optional[Axes] = None, + **kwds, + ): # pragma: no cover + """Violin plot. + + Wraps :func:`seaborn.violinplot` for :class:`~anndata.AnnData`. + + Args: + adata: :class:`~anndata.AnnData` object object containing all observations. + keys: Keys for accessing variables of `.var_names` or fields of `.obs`. + groupby: The key of the observation grouping to consider. + log: Plot on logarithmic axis. + use_raw: Whether to use `raw` attribute of `adata`. Defaults to `True` if `.raw` is present. + stripplot: Add a stripplot on top of the violin plot. See :func:`~seaborn.stripplot`. + jitter: Add jitter to the stripplot (only when stripplot is True) See :func:`~seaborn.stripplot`. + size: Size of the jitter points. + layer: Name of the AnnData object layer that wants to be plotted. By + default adata.raw.X is plotted. If `use_raw=False` is set, + then `adata.X` is plotted. If `layer` is set to a valid layer name, + then the layer is plotted. `layer` takes precedence over `use_raw`. + scale: The method used to scale the width of each violin. + If 'width' (the default), each violin will have the same width. + If 'area', each violin will have the same area. + If 'count', a violin’s width corresponds to the number of observations. + order: Order in which to show the categories. + multi_panel: Display keys in multiple panels also when `groupby is not None`. + xlabel: Label of the x axis. Defaults to `groupby` if `rotation` is `None`, otherwise, no label is shown. + ylabel: Label of the y axis. If `None` and `groupby` is `None`, defaults to `'value'`. + If `None` and `groubpy` is not `None`, defaults to `keys`. + rotation: Rotation of xtick labels. + {show_save_ax} + **kwds: + Are passed to :func:`~seaborn.violinplot`. + + Returns: + A :class:`~matplotlib.axes.Axes` object if `ax` is `None` else `None`. + + Example: + .. code-block:: python + + import ehrapy as ep + + adata = ep.dt.mimic_2(encoded=True) + ep.pp.knn_impute(adata) + ep.pp.log_norm(adata, offset=1) + ep.pp.neighbors(adata) + ep.tl.leiden(adata, resolution=0.5, key_added="leiden_0_5") + ep.pl.violin(adata, keys=["age"], groupby="leiden_0_5") + + Preview: + .. image:: /_static/docstring_previews/violin.png + """ + + if obsm_key: + df = self.to_dataframe(adata, features=obsm_key) + df = df[["visit_occurrence_id", "value_as_number"]] + df = df.rename(columns = {"value_as_number": obsm_key}) + + if groupby: + df = df.set_index('visit_occurrence_id').join(adata.obs[groupby].to_frame()).reset_index(drop=False) + adata = ep.ad.df_to_anndata(df, columns_obs_only=['visit_occurrence_id', groupby]) + else: + adata = ep.ad.df_to_anndata(df, columns_obs_only=['visit_occurrence_id']) + keys=obsm_key + + violin_partial = partial( + sc.pl.violin, + keys=keys, + log=log, + use_raw=use_raw, + stripplot=stripplot, + jitter=jitter, + size=size, + layer=layer, + scale=scale, + order=order, + multi_panel=multi_panel, + xlabel=xlabel, + ylabel=ylabel, + rotation=rotation, + show=show, + save=save, + ax=ax, + **kwds,) + + return violin_partial(adata=adata, groupby=groupby) - # More Pre-processing functions - def sampling( + + def qc_lab_measurements( self, - ): - # function from dask - # need to check dask-awkward again - pass + adata: AnnData, + reference_table: pd.DataFrame = None, + measurements: list[str] = None, + obsm_measurements: list[str] = None, + action: Literal["remove"] = "remove", + unit: Literal["traditional", "SI"] = None, + layer: str = None, + threshold: int = 20, + age_col: str = None, + age_range: str = None, + sex_col: str = None, + sex: str = None, + ethnicity_col: str = None, + ethnicity: str = None, + copy: bool = False, + verbose: bool = False, + ) -> AnnData: + + if copy: + adata = adata.copy() + + preprocessing_dir = '/Users/xinyuezhang/ehrapy/ehrapy/preprocessing' + if reference_table is None: + reference_table = pd.read_csv( + f"{preprocessing_dir}/laboratory_reference_tables/laposata.tsv", sep="\t", index_col="Measurement" + ) + if obsm_measurements: + measurements = obsm_measurements + for measurement in measurements: + best_column_match, score = process.extractOne( + query=measurement, choices=reference_table.index, score_cutoff=threshold + ) + if best_column_match is None: + rprint(f"[bold yellow]Unable to find a match for {measurement}") + continue + if verbose: + rprint( + f"[bold blue]Detected [green]{best_column_match}[blue] for [green]{measurement}[blue] with score [green]{score}." + ) + + reference_column = "SI Reference Interval" if unit == "SI" else "Traditional Reference Interval" + + # Fetch all non None columns from the reference statistics + not_none_columns = [col for col in [sex_col, age_col, ethnicity_col] if col is not None] + not_none_columns.append(reference_column) + reference_values = reference_table.loc[[best_column_match], not_none_columns] + + additional_columns = False + if sex_col or age_col or ethnicity_col: # check if additional columns were provided + additional_columns = True + + # Check if multiple reference values occur and no additional information is available: + if reference_values.shape[0] > 1 and additional_columns is False: + raise ValueError( + f"Several options for {best_column_match} reference value are available. Please specify sex, age or " + f"ethnicity columns and their values." + ) + + try: + if age_col: + min_age, max_age = age_range.split("-") + reference_values = reference_values[ + (reference_values[age_col].str.split("-").str[0].astype(int) >= int(min_age)) + and (reference_values[age_col].str.split("-").str[1].astype(int) <= int(max_age)) + ] + if sex_col: + sexes = "U|M" if sex is None else sex + reference_values = reference_values[reference_values[sex_col].str.contains(sexes)] + if ethnicity_col: + reference_values = reference_values[reference_values[ethnicity_col].isin([ethnicity])] + + if layer is not None: + actual_measurements = adata[:, measurement].layers[layer] + else: + if obsm_measurements: + actual_measurements = adata.obsm[measurement]['value_as_number'] + ak_measurements = adata.obsm[measurement] + else: + actual_measurements = adata[:, measurement].X + except TypeError: + rprint(f"[bold yellow]Unable to find specified reference values for {measurement}.") + + check = reference_values[reference_column].values + check_str: str = np.array2string(check) + check_str = check_str.replace("[", "").replace("]", "").replace("'", "") + if "<" in check_str: + upperbound = float(check_str.replace("<", "")) + if verbose: + rprint(f"[bold blue]Using upperbound [green]{upperbound}") + upperbound_check_results = actual_measurements < upperbound + if isinstance(actual_measurements, ak.Array): + if action == 'remove': + if verbose: + rprint(f"Removing {ak.count(actual_measurements) - ak.count(actual_measurements[upperbound_check_results])} outliers") + adata.obsm[measurement] = ak_measurements[upperbound_check_results] + else: + upperbound_check_results_array: np.ndarray = upperbound_check_results.copy() + adata.obs[f"{measurement} normal"] = upperbound_check_results_array + + elif ">" in check_str: + lower_bound = float(check_str.replace(">", "")) + if verbose: + rprint(f"[bold blue]Using lowerbound [green]{lower_bound}") + + lower_bound_check_results = actual_measurements > lower_bound + if isinstance(actual_measurements, ak.Array): + if action == 'remove': + adata.obsm[measurement] = ak_measurements[lower_bound_check_results] + else: + adata.obs[f"{measurement} normal"] = lower_bound_check_results_array + lower_bound_check_results_array = lower_bound_check_results.copy() + else: # "-" range case + min_value = float(check_str.split("-")[0]) + max_value = float(check_str.split("-")[1]) + if verbose: + rprint(f"[bold blue]Using minimum of [green]{min_value}[blue] and maximum of [green]{max_value}") + + range_check_results = (actual_measurements >= min_value) & (actual_measurements <= max_value) + if isinstance(actual_measurements, ak.Array): + if action == 'remove': + adata.obsm[measurement] = ak_measurements[range_check_results] + else: + adata.obs[f"{measurement} normal"] = range_check_results_array + range_check_results_array: np.ndarray = range_check_results.copy() + + if copy: + return adata diff --git a/ml_usecases_mimic3_omop.ipynb b/ml_usecases_mimic3_omop.ipynb index c6a6d94..900f313 100644 --- a/ml_usecases_mimic3_omop.ipynb +++ b/ml_usecases_mimic3_omop.ipynb @@ -1,49 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# # FIX\n", - "# # combine all measurement and drug_exposure tables together\n", - "# omop.set_path(table_name='measurement', file_path=\"/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciv/measurement\")\n", - "# omop.set_path(table_name='drug_exposure', file_path=\"/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciv/drug_exposure\")\n", - "\n", - "# # FIX\n", - "# # remove duplicated rows in person table\n", - "\n", - "# import pandas as pd\n", - "# df = pd.read_csv(f\"{omop.filepath['person']}\", sep=\";\")\n", - "# df = df.drop_duplicates(\"person_id\")\n", - "# df.drop(columns='Unnamed: 0').to_csv(f\"{omop.filepath['person']}\", sep=\";\")\n", - "\n", - "\n", - "# # FIX\n", - "# # add concpet id\n", - "# import pandas as pd\n", - "# df = pd.read_csv(f\"{omop.filepath['concept']}\", sep=\";\")\n", - "# df.loc[df.concept_id == 4099154, 'concept_id'] = 3711521\n", - "# df.to_csv(f\"{omop.filepath['concept']}\", sep=\";\")\n", - "\n", - "\n", - "\n", - "# # FIX BlendedICU\n", - "\n", - "# import pandas as pd\n", - "# import csv\n", - "# base = \"/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciv\"\n", - "# df = pd.read_csv(f\"{base}/PERSON.csv\", sep=';')\n", - "# df.loc[:, 'location_id'] = 0\n", - "# df.to_csv(f\"{base}/PERSON.csv\", sep=';')\n", - "\n", - "# df = pd.read_csv(f\"{base}/LOCATION.csv\", sep=';')\n", - "# new_row = {'location_id': 0, 'county': 'US', 'country_source_value': 'US'}\n", - "# df.loc[len(df)] = new_row\n", - "# df.to_csv(f\"{base}/LOCATION.csv\", sep=';')" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -61,54 +17,63 @@ "source": [ "import ehrapy as ep\n", "import dask_awkward as dak\n", - "import dask.dataframe as dd\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from ehrdata import OMOP\n", + "import dask.dataframe as dd\n", "import pandas as pd\n", "import awkward as ak\n", "import numpy as np\n", + "import warnings\n", + "import seaborn as sns\n", + "import ehrapy as ep\n", + "import anndata as ad\n", + "\n", "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "from IPython import display\n", + "\n", + "\n", + "plt.style.use(\"ggplot\")\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", "\n", - "omop = OMOP(folder_path=\"/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciii\", delimiter=';')" + "from ehrdata import OMOP" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "OMOP object (OMOP-CDM-mimiciii) with 10 tables.\n", + "Tables: source_to_concept_map, care_site, death, concept, visit_occurrence, person\n", + "observation, domain, measurement, drug_exposure" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "omop.add_additional_column(column_name='time', type='int')\n", - "omop.add_additional_column(column_name='unit_source', type='str')\n", - "omop.add_additional_column(column_name='value_source_value', type='float')" + "omop = OMOP(folder_path=\"/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciii\", delimiter=';', use_dask=False)\n", + "omop" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "reading table [visit_occurrence]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "reading table [visit_occurrence]\n", "reading table [person]\n", "reading table [death]\n", - "\u001b[1;35m2024-01-26 13:05:03,448\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Transformed passed dataframe into an AnnData object with n_obs x n_vars = `57874` x `2`.\u001b[0m\n" + "\u001b[1;35m2024-02-04 23:50:26,717\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `57874` x `2`.\u001b[0m\n" ] } ], @@ -119,399 +84,55 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ArrayView([[1962],\n", - " [1962],\n", - " [1962],\n", - " ...,\n", - " [1982],\n", - " [1997],\n", - " [1975]], dtype=object)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "adata[:, \"year_of_birth\"].X" + "adata.obs['mortality'] = adata.obs['death_datetime'].isnull().replace({True: 0, False: 1})" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploratory data analysis" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "adata.obs" + "We can print the number of ICU stays by calculating the length of adata" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
visit_start_datedeath_datevisit_end_datetimedischarged_to_source_valuegender_concept_iddeath_datetimebirth_datetimevisit_start_datetimeadmitted_from_source_valuevisit_type_concept_idvisit_end_datevisit_concept_idvisit_source_valueperson_source_valueUnnamed: 0
visit_occurrence_id
20000002023-01-01True01:53:11.040000Nursing Facility8532True1962-01-0100:00:00Other448185182023-01-0432037mimic3-200001mimic3-559730
20114982023-01-01True22:01:12Hospital8532True1962-01-0100:00:00Other448185182023-01-0532037mimic3-219717mimic3-559730
20156292023-01-01True09:37:35.040000Hospital8532True1962-01-0100:00:00Other448185182023-01-0832037mimic3-226977mimic3-559730
20163912023-01-01True19:31:17.760000Hospital8532True1962-01-0100:00:00Other448185182023-01-1332037mimic3-228256mimic3-559730
20172232023-01-01True23:52:48Nursing Facility8532True1962-01-0100:00:00Other448185182023-01-0132037mimic3-229674mimic3-559730
................................................
20578622023-01-01True15:58:27.840000Rehabilitation8507True1958-01-0100:00:00Other448185182023-01-0232037mimic3-299979mimic3-4272843457
20578632023-01-01True06:03:53.280000Home8507True1961-01-0100:00:00Other448185182023-01-0332037mimic3-299981mimic3-1753243458
20578682023-01-01True00:00:00Rehabilitation8507True1982-01-0100:00:00Emergency448185182023-01-1532037mimic3-299992mimic3-1308343459
20578692023-01-01True19:56:21.120000Home8507True1997-01-0100:00:00Other448185182023-01-0332037mimic3-299993mimic3-1362043460
20578732023-01-01True07:08:49.920000Home8507True1975-01-0100:00:00Other448185182023-01-0232037mimic3-299999mimic3-763043461
\n", - "

57874 rows × 15 columns

\n", - "
" - ], - "text/plain": [ - " visit_start_date death_date visit_end_datetime \\\n", - "visit_occurrence_id \n", - "2000000 2023-01-01 True 01:53:11.040000 \n", - "2011498 2023-01-01 True 22:01:12 \n", - "2015629 2023-01-01 True 09:37:35.040000 \n", - "2016391 2023-01-01 True 19:31:17.760000 \n", - "2017223 2023-01-01 True 23:52:48 \n", - "... ... ... ... \n", - "2057862 2023-01-01 True 15:58:27.840000 \n", - "2057863 2023-01-01 True 06:03:53.280000 \n", - "2057868 2023-01-01 True 00:00:00 \n", - "2057869 2023-01-01 True 19:56:21.120000 \n", - "2057873 2023-01-01 True 07:08:49.920000 \n", - "\n", - " discharged_to_source_value gender_concept_id \\\n", - "visit_occurrence_id \n", - "2000000 Nursing Facility 8532 \n", - "2011498 Hospital 8532 \n", - "2015629 Hospital 8532 \n", - "2016391 Hospital 8532 \n", - "2017223 Nursing Facility 8532 \n", - "... ... ... \n", - "2057862 Rehabilitation 8507 \n", - "2057863 Home 8507 \n", - "2057868 Rehabilitation 8507 \n", - "2057869 Home 8507 \n", - "2057873 Home 8507 \n", - "\n", - " death_datetime birth_datetime visit_start_datetime \\\n", - "visit_occurrence_id \n", - "2000000 True 1962-01-01 00:00:00 \n", - "2011498 True 1962-01-01 00:00:00 \n", - "2015629 True 1962-01-01 00:00:00 \n", - "2016391 True 1962-01-01 00:00:00 \n", - "2017223 True 1962-01-01 00:00:00 \n", - "... ... ... ... \n", - "2057862 True 1958-01-01 00:00:00 \n", - "2057863 True 1961-01-01 00:00:00 \n", - "2057868 True 1982-01-01 00:00:00 \n", - "2057869 True 1997-01-01 00:00:00 \n", - "2057873 True 1975-01-01 00:00:00 \n", - "\n", - " admitted_from_source_value visit_type_concept_id \\\n", - "visit_occurrence_id \n", - "2000000 Other 44818518 \n", - "2011498 Other 44818518 \n", - "2015629 Other 44818518 \n", - "2016391 Other 44818518 \n", - "2017223 Other 44818518 \n", - "... ... ... \n", - "2057862 Other 44818518 \n", - "2057863 Other 44818518 \n", - "2057868 Emergency 44818518 \n", - "2057869 Other 44818518 \n", - "2057873 Other 44818518 \n", - "\n", - " visit_end_date visit_concept_id visit_source_value \\\n", - "visit_occurrence_id \n", - "2000000 2023-01-04 32037 mimic3-200001 \n", - "2011498 2023-01-05 32037 mimic3-219717 \n", - "2015629 2023-01-08 32037 mimic3-226977 \n", - "2016391 2023-01-13 32037 mimic3-228256 \n", - "2017223 2023-01-01 32037 mimic3-229674 \n", - "... ... ... ... \n", - "2057862 2023-01-02 32037 mimic3-299979 \n", - "2057863 2023-01-03 32037 mimic3-299981 \n", - "2057868 2023-01-15 32037 mimic3-299992 \n", - "2057869 2023-01-03 32037 mimic3-299993 \n", - "2057873 2023-01-02 32037 mimic3-299999 \n", - "\n", - " person_source_value Unnamed: 0 \n", - "visit_occurrence_id \n", - "2000000 mimic3-55973 0 \n", - "2011498 mimic3-55973 0 \n", - "2015629 mimic3-55973 0 \n", - "2016391 mimic3-55973 0 \n", - "2017223 mimic3-55973 0 \n", - "... ... ... \n", - "2057862 mimic3-42728 43457 \n", - "2057863 mimic3-17532 43458 \n", - "2057868 mimic3-13083 43459 \n", - "2057869 mimic3-13620 43460 \n", - "2057873 mimic3-7630 43461 \n", - "\n", - "[57874 rows x 15 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ICU stays: 57874\n", + "Number of survivors: 48796\n", + "Number of non-survivors: 9078\n", + "Mortality: 16 %\n" + ] } ], "source": [ - "adata.obs" + "print(f\"Number of ICU stays: {len(adata)}\")\n", + "print(f\"Number of survivors: {sum(adata.obs['death_datetime'].isna())}\")\n", + "print(f\"Number of non-survivors: {sum(~adata.obs['death_datetime'].isna())}\")\n", + "print(f\"Mortality: {round(100 * sum(~adata.obs['death_datetime'].isna()) / len(adata))} %\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore features in MIMIC-III OMOP dataset" ] }, { @@ -548,20 +169,20 @@ " \n", " \n", " 0\n", - " Age group\n", - " 44804452\n", + " Body weight\n", + " 3711521\n", " 57874\n", " \n", " \n", " 1\n", - " Body weight\n", - " 3711521\n", + " Normal height\n", + " 4203099\n", " 57874\n", " \n", " \n", " 2\n", - " Normal height\n", - " 4203099\n", + " Age group\n", + " 44804452\n", " 57874\n", " \n", " \n", @@ -570,9 +191,9 @@ ], "text/plain": [ " feature_name observation_concept_id count\n", - "0 Age group 44804452 57874\n", - "1 Body weight 3711521 57874\n", - "2 Normal height 4203099 57874" + "0 Body weight 3711521 57874\n", + "1 Normal height 4203099 57874\n", + "2 Age group 44804452 57874" ] }, "execution_count": 6, @@ -581,7 +202,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZuUlEQVR4nO3deVxU9eL/8dcMA7KoICoqoiIiaaLgmkspqSWlWS5lVyvL5VZa+a1rN9szMzOzm7Zfl5JsM9NyIfclDcwtF9wQ0UTRQGVQBISB+f3hj3MhlxSXgdP7+XjwsDnnM+d8Zvo8Zt7zOZ/P51icTqcTERERESn3rK6ugIiIiIhcHQp2IiIiIiahYCciIiJiEgp2IiIiIiahYCciIiJiEgp2IiIiIiahYCciIiJiEgp2IiIiIiahYCciIiJiEgp2IiIiIiZhc3UF/uzEiRPMnDmTLVu2cObMGWrWrMmwYcNo0KABAE6nk1mzZrF8+XJOnz5No0aNGDJkCLVq1TKOkZWVxfTp09m0aRMWi4WbbrqJRx55BE9PT6PM77//zrRp09i3bx+VK1cmOjqau+++u0Rd4uPj+fbbb0lPT6dmzZoMGDCAFi1aXJ83QkREROQyWcrSvWKzsrJ47rnnaNKkCbfffjuVK1fmyJEj1KhRg5o1awLwww8/8MMPPzB8+HACAgL49ttvOXjwIO+++y4eHh4AvPnmm2RkZPDPf/6TgoICPvroIxo0aMCIESMAyM7OZsSIETRt2pRevXpx8OBBPv74Yx5++GG6du0KwJ49e3j11Vfp378/LVq0YO3atfz444+MHz+eunXrXvJrysjIwOFwXOV3SkRERP4ubDYbVapUubSy17gul+XHH3+katWqDBs2zNgWEBBg/LfT6SQ2NpbevXvTunVrAJ544gmGDh3Khg0b6NChA4cOHWLLli2MGzfO6OUbNGgQ48aN48EHH8Tf35+1a9ficDgYNmwYNpuNOnXqcODAARYsWGAEu9jYWCIjI+nZsycA999/P9u3b2fRokX885//vOTX5HA4yM/Pv+L3RkREROSvlKlgt3HjRiIiInj33XfZuXMn/v7+3H777UbYSktLw26306xZM+M53t7ehIaGkpiYSIcOHUhMTMTHx8cIdQBNmzbFYrGQlJREmzZtSExMpHHjxths/3v5ERER/Pjjj2RlZVGxYkUSExPp0aNHifpFRESwYcOG89Y9Pz+/RICzWCx4eXkZ/y0iIiJyrZWpYJeWlsbSpUvp3r07vXr1Yt++fXz22WfYbDaioqKw2+0A+Pr6lnier6+vsc9ut1O5cuUS+93c3KhYsWKJMsV7AgH8/PyMfUVlL3aeP5s7dy6zZ882HtevX5/x48dTvXr1y3gHREREREqvTAW7wsJCGjRoQP/+/YGz4ejgwYMsXbqUqKgo11buL/Tq1atED19RL116errG2ImIiEip2Wy2S+4oKlPBrkqVKgQFBZXYFhQUxK+//gr8r1ctMzOzxCDCzMxMgoODjTInT54scYyCggKysrKM5/v5+Z3T81b0uHiZzMzMEmUyMzON/X/m7u6Ou7v7efeVofkpIiIiYmJlah27G264gdTU1BLbUlNTjZQaEBCAn58f27dvN/ZnZ2eTlJREWFgYAGFhYZw+fZrk5GSjTEJCAk6nk9DQUKPMrl27SvSkbdu2jcDAQCpWrGiUKX6eojINGza8iq9YRERE5OopU8Gue/fu7N27lzlz5nD06FHWrl3L8uXL6datG3D28uadd97JnDlz2LhxIwcPHuSDDz6gSpUqxizZoKAgIiMj+fTTT0lKSmL37t1Mnz6d9u3b4+/vD8DNN9+MzWbjk08+ISUlhbi4OH766acSl1LvvPNOtm7dyvz58zl8+DCzZs1i3759REdHX/83RkREROQSlKl17AA2bdrEV199xdGjRwkICKB79+7GrFj43wLFy5YtIzs7m0aNGjF48GACAwONMllZWUybNq3EAsWDBg264ALFlSpVIjo6mnvuuadEXeLj4/nmm29IT0+nVq1apVqgOD09XcudiIiISKm5u7tf8hi7MhfszEbBTkRERK7E5QS7MnUpVkRERERKT8FORERExCQU7ERERERMQsFORERExCQU7ERERERMokzdeULO78izQ1xdBSmHak2Y6uoqlPDwjHhXV0HKoc8HtnN1FQyL5x1xdRWkHOrWs9Z1PZ967ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCQU7ERERERMQsFORERExCRsrq5AcbNmzWL27NkltgUGBvLee+8BkJeXR0xMDHFxceTn5xMREcGQIUPw8/Mzyh87dowpU6awY8cOPD096dSpE/3798fNzc0os2PHDmJiYkhJSaFq1ar06dOHqKioEuddtGgR8+fPx263U69ePQYNGkRoaOi1eukiIiIiV6xMBTuAOnXq8PLLLxuPrdb/dSrOmDGDzZs388wzz+Dt7c20adOYOHEiY8aMAaCwsJBx48bh5+fHG2+8QUZGBh988AFubm70798fgLS0NN566y1uu+02nnzySRISEvjkk0/w8/MjMjISgLi4OGJiYhg6dCgNGzZk4cKFjB07lvfeew9fX9/r92aIiIiIXIYydynWarXi5+dn/FWuXBmA7OxsVqxYwcCBAwkPDyckJIRhw4axZ88eEhMTAdi6dSuHDh3iySefJDg4mObNm9OvXz8WL16Mw+EAYMmSJQQEBPDQQw8RFBREdHQ0bdu2ZeHChUYdFixYQJcuXbj11lsJCgpi6NCheHh4sHLlyuv/hoiIiIhcojIX7I4ePcqjjz7KE088weTJkzl27BgAycnJFBQU0LRpU6Ns7dq1qVatmhHsEhMTqVu3bolLs5GRkeTk5JCSkgLA3r17SxwDICIiwjiGw+EgOTm5RBmr1UrTpk2NMueTn59Pdna28ZeTk2Pss1gsV/QnUhpX2u6u9p9Iabi63aoNy5W63m2vTF2KbdiwIcOGDSMwMJCMjAxmz57NK6+8wsSJE7Hb7dhsNnx8fEo8x9fXF7vdDoDdbi8R6or2F+0r+vfPl1N9fX3JyckhLy+PrKwsCgsLzzmOn58fqampF6z73LlzS4wPrF+/PuPHj6d69eqX8Q6c34XPKnJhtWrVcnUVRK5Y2WrH+jSWy3e923CZCnbNmzc3/rtevXpG0IuPj8fDw8OFNftrvXr1okePHsbjooSdnp5uXAYWuZ6OHDni6iqIXDG1YynvrkYbttlsl9xRVKaC3Z/5+PgQGBjI0aNHadasGQ6Hg9OnT5fotcvMzDR61/z8/EhKSipxjMzMTGNf0b9F24qX8fLywsPDg8qVK2O1Wo0eviLn6w0szt3dHXd39/Puczqdl/BqRa4utTsxA7VjKe+udxsuc2PsisvNzeXo0aP4+fkREhKCm5sb27dvN/anpqZy7NgxwsLCAAgLC+PgwYMlgtu2bdvw8vIiKCgIOHu5t/gxisoUHcNmsxESEkJCQoKxv7CwkISEBKOMiIiISFlUpoJdTEwMO3fuJC0tjT179jBhwgSsVis333wz3t7edO7cmZiYGBISEkhOTuajjz4iLCzMCFwREREEBQXxwQcfcODAAbZs2cI333xDt27djN6022+/nbS0NGbOnMnhw4dZvHgx8fHxdO/e3ahHjx49WL58OatWreLQoUNMnTqVM2fOnLPWnYiIiEhZUqYuxZ44cYJJkyZx6tQpKleuTKNGjRg7dqyx5MnAgQOxWCxMnDgRh8NhLFBcxGq1MmrUKKZOncpLL71EhQoV6NSpE/369TPKBAQEMGrUKGbMmEFsbCxVq1blscceM9awA2jfvj0nT55k1qxZ2O12goODeeGFFy56KVZERETE1SxODWC4ptLT08nPz7+iYxx5dshfFxL5k1oTprq6CiU8PCPe1VWQcujzge1cXQXD4nmayCGXr1vPK58V6+7ufsmTJ8rUpVgRERERKT0FOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTULATERERMQkFOxERERGTsLm6Ahfyww8/8NVXX3HnnXfy8MMPA5CXl0dMTAxxcXHk5+cTERHBkCFD8PPzM5537NgxpkyZwo4dO/D09KRTp070798fNzc3o8yOHTuIiYkhJSWFqlWr0qdPH6Kiokqcf9GiRcyfPx+73U69evUYNGgQoaGh1+GVi4iIiJROmeyxS0pKYunSpdSrV6/E9hkzZrBp0yaeeeYZRo8eTUZGBhMnTjT2FxYWMm7cOBwOB2+88QbDhw9n1apVfPvtt0aZtLQ03nrrLZo0acLbb79N9+7d+eSTT9iyZYtRJi4ujpiYGPr27cv48eOpV68eY8eOJTMz85q/dhEREZHSKnPBLjc3l/fff59HH30UHx8fY3t2djYrVqxg4MCBhIeHExISwrBhw9izZw+JiYkAbN26lUOHDvHkk08SHBxM8+bN6devH4sXL8bhcACwZMkSAgICeOihhwgKCiI6Opq2bduycOFC41wLFiygS5cu3HrrrQQFBTF06FA8PDxYuXLl9X0zRERERC5DmQt2U6dOpXnz5jRr1qzE9uTkZAoKCmjatKmxrXbt2lSrVs0IdomJidStW7fEpdnIyEhycnJISUkBYO/evSWOARAREWEcw+FwkJycXKKM1WqladOmRhkRERGRsqhMjbH75Zdf2L9/P+PGjTtnn91ux2azlejFA/D19cVutxtlioe6ov1F+4r+LdpWvExOTg55eXlkZWVRWFh4znH8/PxITU29YN3z8/PJz883HlssFry8vIz/Frne1O7EDNSOpby73m24zAS7Y8eO8fnnn/PSSy/h4eHh6upctrlz5zJ79mzjcf369Rk/fjzVq1e/4mNfOE6KXFitWrVcXQWRK1a22rE+jeXyXe82XGaCXXJyMpmZmTz33HPGtsLCQnbt2sWiRYt48cUXcTgcnD59ukSvXWZmptG75ufnR1JSUonjFk14KF7mz5MgMjMz8fLywsPDg8qVK2O1Wo0eviLn6w0srlevXvTo0cN4XJTQ09PTjfF9ItfTkSNHXF0FkSumdizl3dVowzab7ZI7ispMsGvatCnvvPNOiW0ff/wxgYGB3H333VSrVg03Nze2b99O27ZtAUhNTeXYsWOEhYUBEBYWxpw5c8jMzDQut27btg0vLy+CgoIAaNiwIb/99luJ82zbts04hs1mIyQkhISEBNq0aQOcDZgJCQlER0dfsP7u7u64u7ufd5/T6bzct0PkiqndiRmoHUt5d73bcJkJdl5eXtStW7fEtgoVKlCpUiVje+fOnYmJiaFixYp4e3szffp0wsLCjFAWERFBUFAQH3zwAQMGDMBut/PNN9/QrVs3I3TdfvvtLF68mJkzZ3LrrbeSkJBAfHw8o0aNMs7bo0cPPvzwQ0JCQggNDSU2NpYzZ86cs9adiIiISFlSZoLdpRg4cCAWi4WJEyficDiMBYqLWK1WRo0axdSpU3nppZeoUKECnTp1ol+/fkaZgIAARo0axYwZM4iNjaVq1ao89thjREZGGmXat2/PyZMnmTVrFna7neDgYF544YWLXooVERERcTWLU/3c11R6enqJ2bKlceTZIX9dSORPak2Y6uoqlPDwjHhXV0HKoc8HtnN1FQyL52m8n1y+bj2vfPKEu7v7JY+xK3Pr2ImIiIhI6SjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISZQ62K1evZq0tLQL7k9LS2P16tWlPbyIiIiIXKZSB7uPPvqIxMTEC+5PSkrio48+Ku3hRUREROQyXbNLsbm5ubi5uV2rw4uIiIjIn9gup/Dvv//OgQMHjMe7du2ioKDgnHKnT59m6dKl1KpV64orKCIiIiKX5rKC3fr165k9e7bxeNmyZSxbtuy8Zb29vXniiSeurHYiIiIicskuK9h17dqVli1b4nQ6eeGFF7jvvvto3rz5OeU8PT2pUaOGLsWKiIiIXEeXFeyqVKlClSpVAHj11VepXbs2vr6+16RiIiIiInJ5LivYFXfjjTdezXqIiIiIyBUqdbAD2LJlCytWrCAtLY3Tp0/jdDpL7LdYLLz//vtXVEERERERuTSlDnbz5s3jyy+/xM/PjwYNGlC3bt2rWS8RERERuUylDnaxsbGEh4fz/PPPY7NdUcefiIiIiFwFpV6g+PTp07Rt21ahTkRERKSMKHWwCw0NJTU19WrWRURERESuQKmD3eDBg1m/fj1r1669mvURERERkVIq9XXU9957j4KCAt5//32mTJlC1apVsVpL5kSLxcKECROuuJIiIiIi8tdKHewqVqxIpUqVdD9YERERkTKi1MHutddeu4rVEBEREZErVeoxdiIiIiJStpS6x27nzp2XVE63HhMRERG5Pkod7EaPHn1J5b799tvSnkJERERELkOpg92rr756zrbCwkLS0tJYvnw5hYWFDBgw4LKOuWTJEpYsWUJ6ejoAQUFB9O3bl+bNmwOQl5dHTEwMcXFx5OfnExERwZAhQ/Dz8zOOcezYMaZMmcKOHTvw9PSkU6dO9O/fHzc3N6PMjh07iImJISUlhapVq9KnTx+ioqJK1GXRokXMnz8fu91OvXr1GDRoEKGhoZf1ekRERESup1IHu4tdYo2KiuLVV19lx44dhIeHX/Ix/f396d+/P7Vq1cLpdLJ69Wrefvtt3n77berUqcOMGTPYvHkzzzzzDN7e3kybNo2JEycyZswY4GywHDduHH5+frzxxhtkZGTwwQcf4ObmRv/+/QFIS0vjrbfe4rbbbuPJJ58kISGBTz75BD8/PyIjIwGIi4sjJiaGoUOH0rBhQxYuXMjYsWN577338PX1Le1bJiIiInJNXZPJE1arlfbt27NixYrLel6rVq1o0aIFtWrVIjAwkH/84x94enqyd+9esrOzWbFiBQMHDiQ8PJyQkBCGDRvGnj17SExMBGDr1q0cOnSIJ598kuDgYJo3b06/fv1YvHgxDocDONsrGBAQwEMPPURQUBDR0dG0bduWhQsXGvVYsGABXbp04dZbbyUoKIihQ4fi4eHBypUrr96bJCIiInKVXbNZsVlZWZw+fbrUzy8sLOSXX37hzJkzhIWFkZycTEFBAU2bNjXK1K5dm2rVqhnBLjExkbp165a4NBsZGUlOTg4pKSkA7N27t8QxACIiIoxjOBwOkpOTS5SxWq00bdrUKHM++fn5ZGdnG385OTnGPovFckV/IqVxpe3uav+JlIar263asFyp6932Sn0p9tixY+fdfvr0aXbt2sW8efNo3LjxZR/34MGDvPjii+Tn5+Pp6cnIkSMJCgriwIED2Gw2fHx8SpT39fXFbrcDYLfbS4S6ov1F+4r+/fPlVF9fX3JycsjLyyMrK4vCwsJzjuPn53fRe+POnTuX2bNnG4/r16/P+PHjqV69+mW8+vPTHXmlNLR4uJhB2WrH+jSWy3e923Cpg93w4cMvur9hw4YMHTr0so8bGBjIhAkTyM7OZt26dXz44YeXPAPXlXr16kWPHj2Mx0UJOz093bgMLHI9HTlyxNVVELliasdS3l2NNmyz2S65o6jUwe7xxx8/Z5vFYsHHx4eaNWsSFBRUquPabDZq1qwJQEhICPv27SM2Npb27dvjcDg4ffp0iV67zMxMo3fNz8+PpKSkEsfLzMw09hX9W7SteBkvLy88PDyoXLkyVqvV6OErcr7ewOLc3d1xd3c/7z6n0/lXL1vkqlO7EzNQO5by7nq34VIHuz8vD3KtFBYWkp+fT0hICG5ubmzfvp22bdsCkJqayrFjxwgLCwMgLCyMOXPmkJmZaVxu3bZtG15eXkbQbNiwIb/99luJc2zbts04hs1mIyQkhISEBNq0aWPUISEhgejo6OvymkVERERK46pMnjh06BC//fYbv/32G4cOHSr1cb766it27txJWloaBw8eNB7fcssteHt707lzZ2JiYkhISCA5OZmPPvqIsLAwI5RFREQQFBTEBx98wIEDB9iyZQvffPMN3bp1M3rTbr/9dtLS0pg5cyaHDx9m8eLFxMfH0717d6MePXr0YPny5axatYpDhw4xdepUzpw5c93CrIiIiEhplLrHDmDDhg3ExMSQlpZWYntAQAADBw6kVatWl3W8zMxMPvzwQzIyMvD29qZevXq8+OKLNGvWDICBAwdisViYOHEiDofDWKC4iNVqZdSoUUydOpWXXnqJChUq0KlTJ/r161eibqNGjWLGjBnExsZStWpVHnvsMWMNO4D27dtz8uRJZs2ahd1uJzg4mBdeeOGil2JFREREXM3iLOXF382bN/P2229TvXp1unTpYlzqPHToEMuXLyc9PZ1Ro0aVCEx/R+np6eTn51/RMY48O+SvC4n8Sa0JU11dhRIenhHv6ipIOfT5wHauroJh8TxN5JDL163nlc+KdXd3v/aTJ77//nvq1avH6NGj8fT0NLa3atWK6OhoXnnlFb777ru/fbATERERuV5KPcbu4MGDdOrUqUSoK+Lp6UlUVBQHDx68osqJiIiIyKUrdbBzd3cnKyvrgvuzsrIuuPyHiIiIiFx9pQ524eHhxMbGnvc2W3v37uWnn34659ZdIiIiInLtlHqM3QMPPMCLL77Iyy+/TGhoKIGBgcDZteWSkpLw9fVlwIABV62iIiIiInJxpQ52AQEBvPPOO8ydO5ctW7YQFxcHQPXq1bnzzju55557zrknq4iIiIhcO6UOdgUFBbi7u/Pwww+fd392djYFBQW4ubmV9hQiIiIichlKPcbus88+4+WXX77g/pdffpmYmJjSHl5ERERELlOpg92WLVu46aabLri/bdu259yTVURERESunVIHu4yMDPz9/S+4v0qVKpw4caK0hxcRERGRy1TqYFexYkVSU1MvuP/w4cN4eXmV9vAiIiIicplKHewiIyNZtmwZ+/fvP2dfcnIyy5Yto3nz5ldUORERERG5dKWeFduvXz+2bNnCCy+8QMuWLalTpw4AKSkpbNq0icqVK9OvX7+rVlERERERubhSBzt/f3/eeustvvzySzZu3MiGDRsA8PLy4uabb+Yf//jHRcfgiYiIiMjVVepgB2cnSDzxxBM4nU5OnjwJQOXKlbFYLFelciIiIiJy6a4o2BWxWCy6y4SIiIiIi5V68oSIiIiIlC0KdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImoWAnIiIiYhIKdiIiIiImYXN1BYqbO3cu69ev5/Dhw3h4eBAWFsYDDzxAYGCgUSYvL4+YmBji4uLIz88nIiKCIUOG4OfnZ5Q5duwYU6ZMYceOHXh6etKpUyf69++Pm5ubUWbHjh3ExMSQkpJC1apV6dOnD1FRUSXqs2jRIubPn4/dbqdevXoMGjSI0NDQa/02iIiIiJRKmeqx27lzJ926dWPs2LG89NJLFBQU8MYbb5Cbm2uUmTFjBps2beKZZ55h9OjRZGRkMHHiRGN/YWEh48aNw+Fw8MYbbzB8+HBWrVrFt99+a5RJS0vjrbfeokmTJrz99tt0796dTz75hC1bthhl4uLiiImJoW/fvowfP5569eoxduxYMjMzr8t7ISIiInK5ylSwe/HFF4mKiqJOnToEBwczfPhwjh07RnJyMgDZ2dmsWLGCgQMHEh4eTkhICMOGDWPPnj0kJiYCsHXrVg4dOsSTTz5JcHAwzZs3p1+/fixevBiHwwHAkiVLCAgI4KGHHiIoKIjo6Gjatm3LwoULjbosWLCALl26cOuttxIUFMTQoUPx8PBg5cqV1/+NEREREbkEZSrY/Vl2djYAFStWBCA5OZmCggKaNm1qlKlduzbVqlUzgl1iYiJ169YtcWk2MjKSnJwcUlJSANi7d2+JYwBEREQYx3A4HCQnJ5coY7Vaadq0qVHmz/Lz88nOzjb+cnJyjH0Wi+WK/kRK40rb3dX+EykNV7dbtWG5Ute77ZWpMXbFFRYW8vnnn3PDDTdQt25dAOx2OzabDR8fnxJlfX19sdvtRpnioa5of9G+on+LthUvk5OTQ15eHllZWRQWFp5zHD8/P1JTU89b37lz5zJ79mzjcf369Rk/fjzVq1e/nJd9Xuc/o8jF1apVy9VVELliZasd69NYLt/1bsNlNthNmzaNlJQUXn/9dVdX5ZL06tWLHj16GI+LEnZ6erpxCVjkejpy5IirqyByxdSOpby7Gm3YZrNdckdRmQx206ZNY/PmzYwePZqqVasa2/38/HA4HJw+fbpEr11mZqbRu+bn50dSUlKJ4xVNeChe5s+TIDIzM/Hy8sLDw4PKlStjtVqNHr4i5+sNLOLu7o67u/t59zmdzr96ySJXndqdmIHasZR317sNl6kxdk6nk2nTprF+/XpeeeUVAgICSuwPCQnBzc2N7du3G9tSU1M5duwYYWFhAISFhXHw4MESwW3btm14eXkRFBQEQMOGDUsco6hM0TFsNhshISEkJCQY+wsLC0lISDDKiIiIiJQ1ZSrYTZs2jTVr1jBixAi8vLyw2+3Y7Xby8vIA8Pb2pnPnzsTExJCQkEBycjIfffQRYWFhRuCKiIggKCiIDz74gAMHDrBlyxa++eYbunXrZvSo3X777aSlpTFz5kwOHz7M4sWLiY+Pp3v37kZdevTowfLly1m1ahWHDh1i6tSpnDlz5py17kRERETKijJ1KXbJkiUAvPbaayW2Dxs2zAhUAwcOxGKxMHHiRBwOh7FAcRGr1cqoUaOYOnUqL730EhUqVKBTp07069fPKBMQEMCoUaOYMWMGsbGxVK1alccee4zIyEijTPv27Tl58iSzZs3CbrcTHBzMCy+8cMFLsSIiIiKuZnFqAMM1lZ6eTn5+/hUd48izQ/66kMif1Jow1dVVKOHhGfGuroKUQ58PbOfqKhgWz9NEDrl83Xpe+axYd3f3S548UaYuxYqIiIhI6SnYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEgp2IiIiISSjYiYiIiJiEzdUVKG7nzp3MmzeP/fv3k5GRwciRI2nTpo2x3+l0MmvWLJYvX87p06dp1KgRQ4YMoVatWkaZrKwspk+fzqZNm7BYLNx000088sgjeHp6GmV+//13pk2bxr59+6hcuTLR0dHcfffdJeoSHx/Pt99+S3p6OjVr1mTAgAG0aNHi2r8JIiIiIqVUpnrszpw5Q3BwMIMHDz7v/h9//JGffvqJoUOH8uabb1KhQgXGjh1LXl6eUWby5MmkpKTw0ksvMWrUKHbt2sWnn35q7M/OzuaNN96gWrVqvPXWWzzwwAN89913LFu2zCizZ88eJk2aROfOnRk/fjytW7dmwoQJHDx48Nq9eBEREZErVKaCXfPmzbn//vtL9NIVcTqdxMbG0rt3b1q3bk29evV44oknyMjIYMOGDQAcOnSILVu28Nhjj9GwYUMaNWrEoEGDiIuL48SJEwCsXbsWh8PBsGHDqFOnDh06dOCOO+5gwYIFxrliY2OJjIykZ8+eBAUFcf/99xMSEsKiRYuuzxshIiIiUgplKthdTFpaGna7nWbNmhnbvL29CQ0NJTExEYDExER8fHxo0KCBUaZp06ZYLBaSkpKMMo0bN8Zm+99V6IiICFJTU8nKyjLKNG3atMT5IyIi2Lt37wXrl5+fT3Z2tvGXk5Nj7LNYLFf0J1IaV9rurvafSGm4ut2qDcuVut5tr0yNsbsYu90OgK+vb4ntvr6+xj673U7lypVL7Hdzc6NixYolygQEBJQo4+fnZ+wrKnux85zP3LlzmT17tvG4fv36jB8/nurVq1/iK7yw1Cs+gvwdFR97KlJela12rE9juXzXuw2Xm2BX1vXq1YsePXoYj4sSdnp6Og6Hw1XVkr+xI0eOuLoKIldM7VjKu6vRhm022yV3FJWbYFfUq5aZmUmVKlWM7ZmZmQQHBxtlTp48WeJ5BQUFZGVlGc/38/M7p+et6HHxMpmZmSXKZGZmGvvPx93dHXd39/PuczqdF35hIteI2p2YgdqxlHfXuw2XmzF2AQEB+Pn5sX37dmNbdnY2SUlJhIWFARAWFsbp06dJTk42yiQkJOB0OgkNDTXK7Nq1q0Qv2rZt2wgMDKRixYpGmeLnKSrTsGHDa/b6RERERK5UmQp2ubm5HDhwgAMHDgBnJ0wcOHCAY8eOYbFYuPPOO5kzZw4bN27k4MGDfPDBB1SpUoXWrVsDEBQURGRkJJ9++ilJSUns3r2b6dOn0759e/z9/QG4+eabsdlsfPLJJ6SkpBAXF8dPP/1U4jLqnXfeydatW5k/fz6HDx9m1qxZ7Nu3j+jo6Ov+noiIiIhcKouzDPVz79ixg9GjR5+zvVOnTgwfPtxYoHjZsmVkZ2fTqFEjBg8eTGBgoFE2KyuLadOmlVigeNCgQRdcoLhSpUpER0dzzz33lDhnfHw833zzDenp6dSqVavUCxSnp6eTn59/2c8r7sizQ67o+fL3VGvCVFdXoYSHZ8S7ugpSDn0+sJ2rq2BYPE/j/eTydet55ZMn3N3dL3mMXZkKdmakYCeuomAnZqBgJ+Xd9Q52ZepSrIiIiIiUnoKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEko2ImIiIiYhIKdiIiIiEnYXF2Bsm7RokXMnz8fu91OvXr1GDRoEKGhoa6uloiIiMg51GN3EXFxccTExNC3b1/Gjx9PvXr1GDt2LJmZma6umoiIiMg5FOwuYsGCBXTp0oVbb72VoKAghg4dioeHBytXrnR11URERETOoWB3AQ6Hg+TkZJo2bWpss1qtNG3alMTERBfWTEREROT8NMbuAk6ePElhYSF+fn4ltvv5+ZGamnpO+fz8fPLz843HFosFLy8vbLYrf4u9ghtc8THk78fd3d3VVSghtIafq6sg5VBZasdVq3m5ugpSDl2NNnw5WULB7iqZO3cus2fPNh536NCBESNGUKVKlSs+dvWx71/xMURc7aNBXVxdBZEr0rNvdVdXQeQv6VLsBVSuXBmr1Yrdbi+x3W63n9OLB9CrVy8+//xz42/o0KElevDk6svJyeG5554jJyfH1VURKTW1Yynv1IbLFgW7C7DZbISEhJCQkGBsKywsJCEhgbCwsHPKu7u74+3tXeKvLF1CMCOn08n+/ftxOp2uropIqakdS3mnNly26FLsRfTo0YMPP/yQkJAQQkNDiY2N5cyZM0RFRbm6aiIiIiLnULC7iPbt23Py5ElmzZqF3W4nODiYF1544byXYkVERERcTcHuL0RHRxMdHe3qash5uLu707dvX13ylnJN7VjKO7XhssXi1EVxEREREVPQ5AkRERERk1CwExERETEJBTsRERERk1CwExERETEJBTspcwoLC11dBZErpnYsIq6gYCdlyunTp7FazzbLgwcPurg2IqVX1I5TU1NdXBORy6MfJeWbgp2UGVu3buWLL77g1KlTTJ8+nTfeeIPs7GxXV0vkssTFxbFs2TIAZsyYwRdffEFubq6LayVyaQoLC40fJcnJyezcuZPjx4/jcDhcXDO5VFqgWMqMP/74g6SkJMaMGcPx48cZM2YM3t7eOJ1OLBaLq6sn8pccDgeHDx9m9uzZbNiwgV27dvH666/j6enp6qqJXJKiUBcTE0N8fDxZWVnUrFmT2rVr89hjj6ktlwPqsZMy4/bbbycwMJDff/+dJk2aGB8gCnVSXthsNu69917q1avHli1b6NGjB8HBwbq0JWVe8Ta6YcMGNm3axPDhwxk3bhxdu3YlPT2dcePGqfe5HFCwE5cquvGJw+GgoKCAkJAQ+vTpQ3p6OrNnzzbGJ+mLUcqLgoICGjZsSJcuXfj+++9ZunQpVqsVp9OpdixlVlFP3YYNG9ixYwc33XQT4eHhBAUF0bVrV/r27UteXh5z585FN6wq23QpVlzG4XBgs51tgvn5+Xh5eXHPPfcAULlyZVauXMmCBQvo0aMHgYGBACQlJREaGuqqKouco6CgADc3N+DsDxA3NzeGDh0KgL+/P1OnTgXgtttuM3qf9+/fT/369V1TYZFiioa6FBYWkpubS0xMDGlpabRu3doo4+bmRvPmzdmwYQOJiYkaHlPGKdjJdbd+/XratGljhLoffviBzZs34+vrS+PGjbnzzjuJjo4GYPXq1fzwww/cfPPNzJ8/n4yMDCZMmKAPFXG5tLQ0qlWrZoS6RYsWcejQISwWC7169cLf35/evXsDMG3aNBwOBx06dOCTTz7By8uLJ5980pXVFwH+N9QlOzubihUrMnr0aCZPnsz+/ftZv349LVu2NNp4aGgoSUlJRlkpm3QpVq6rNWvW8PHHH/Pjjz8CZ78M582bR3h4OAUFBSxdupTp06cDEB0dTZcuXfjjjz+YMmUKeXl5vPXWWwp14nLTpk3j1VdfNZbk+f777/nqq6/Izc0lPj6eMWPGsHXrVgB69+5N//79+fzzzxk9ejR//PEHjz/+uCurL1LCqlWrmDp1Kqmpqfj7+/PUU09RuXJlFixYwNq1a8nNzcVut/Pzzz9TtWpVfHx8XF1luQiLUxfL5TpKS0tj+fLlrF+/nltuuQWLxUL9+vWJjIzk1KlTrFmzhtjYWJo3b87gwYMBOHr0KPn5+dSuXRur1Vri0peIK+Tk5PD888/j6enJoEGDiI2NpXv37jRs2BCA1157jZMnT/LQQw/RrFkzrFYrycnJnDhxghYtWqgdS5kyb9484uPjqV+/vjH05fjx40ycOJGUlBQCAgKoVasWOTk5jBo1Cnd3d12OLcMU7OS6O3bsGEuXLmXjxo1kZWXx7LPPGuPmsrKy+Pnnn/npp59o0aIFjzzySInnFl9jScQVisaG5ubm8uyzz2Kz2fD29ubJJ5+kZs2awNlxS6+//jonT57kwQcfpEmTJri7uxvHUDsWV7lQ21u8eDE///wzderUoWfPngQGBnLixAkmTZrEiRMn6NOnDx07dsRqtZYYHy1ljz5Z5LooPhuwWrVq3HrrrbRq1Yrs7Gw2btxo7KtYsSIdO3ake/furFixgoULF5Y4jr4MxZUKCwux2Ww4nU48PT2ZMGECHh4eJCUlcfToUWO2oMVi4ZVXXsHPz4/333+f/fv3lziO2rG4SlHb27lzJ3a73djerVs3brnlFg4dOsS8efM4evQo/v7+jBgxAm9vb1avXs3OnTspKChQqCvj1GMn11zxLvtly5bRrl07fHx8SEtLY9myZcTHx9OlSxdjRizAqVOn2LFjB23atNGXoJQ5iYmJ+Pn5ERAQQG5uLqNGjcLDw4Nhw4YRHBxslHM6nXz22Wc8/PDDasdSZuzcuZMPP/yQDh060KNHDypXrmzsmzdvHt9//z0dOnTgzjvvJCgoiIyMDCZOnEheXh4PPfQQ4eHhLqy9/BV90sg1VVhYaIS6I0eOMGfOHN58801ycnIICAigS5cutGvXjlWrVhkTKgAqVapE27ZtsVqtWvtLXK54G0xISGDcuHGsXbuWEydO4OnpyVtvvUVubi4ff/wxBw4cMMpaLBYGDRqkdiwu9ef+mxtvvJH27duzfft2YmNjyczMNPbdeeed+Pn58dtvv7Fx40YKCgqoUqUKTz/9NBUrVqRGjRrXu/pymdRjJ9dM8Z6677//nv3793PkyBEOHTpESEgIL7/8Mt7e3vzxxx+sWLGCDRs20KZNG+6//34X11zkf4q349jYWPLy8vj++++x2WzcdddddOrUiapVq5Kbm8tzzz2Hj48PgwYN0nqLUib8eUxd8Uk733zzDZs3b6ZFixZ0796dSpUqGYvDh4WFceutt5aY6KOxoeWDgp1ccwsWLGDWrFn8+9//xtfXl8TERBYtWoTFYuG1114zwt2CBQvIysriqaee0mwrKROKh7rZs2ezYMECnnjiCSwWC7/99hu//PILd911F1FRUfj7+5Obm8ujjz5K27ZttaSJuFzxILZo0SISExNxOByEhIQYQ19mzZrFb7/9RvXq1WnRogW//PIL7u7uPPvss8bCxUXH0EzY8kHBTq6qHTt20KRJE+Nxfn4+H3zwAdWrV+eBBx4Azn7YbN++nWnTplGpUiVeeuklvLy8OHHiBFWqVMFisegDRFzqz3c4yc7OZsyYMbRr146ePXsa27/++msWLlxI79696dixI9WqVSMvLw83NzctZSJlxpdffsnKlSu56aabyM/P55dffiE8PJzhw4dTuXJlFi9ezMaNG0lLS6NmzZrGbG99DpdPmtoiV82iRYtYsWIF48ePB86OL3J3d8fhcJSYFWi1WomIiKBVq1YsXLiQN954gxdffBF/f39AvwrFtaZMmYK7uzsNGjQo0Q4LCgqMx3l5eXh4ePCPf/yD33//ncWLF2Oz2YiKijIGouuylZQFycnJrF27lv/7v/8zJj3cfffdjB49mv/+97+MHDmSbt26ERUVRU5ODr6+vlgsFq2zWI7pU0eumqioKOPOEKmpqcb2yMhIsrOzWbduHQUFBcb2unXr0qFDBzw8PJg+fbqxT6FOXOm2227jgQcewGKxkJaWBoC3tze1a9dm2bJlFBYW4uHhgcPhAM4u3+Pn58f8+fPZvXs3oFAnrvPnSToOh4PCwkLjftsFBQXUrl2bf//732zdupX169cDUKFCBfz8/IzLrwp15Zc+eeSq8fT0xGq1sm3bNp555hni4+MBaNOmDd7e3ixZsoS1a9dy5swZsrKyWL9+PYGBgURGRpKUlFRiTSURVwkODsZms7Fq1So++ugjNm/eDMCAAQOwWq288sornDlzxvgBcvLkSYYOHUrTpk35+uuvcTqdCnXiMkVtb8aMGSxatAh/f3+ysrLYtWsXAG5ubjidTgICAoxxoRc6hpRP+r8nV12DBg244447+OCDD4iLi8PX15fhw4fj6enJggULGDZsGK+88gqpqan07duXBg0a4HA4zpmSL+JK1apVIz8/nxUrVrBt2zaqVavG448/Tk5ODk899RRvvvkmI0eOZP/+/YSGhhIWFoaHh4fasbhE8XZX1BMXFBSEr68vUVFRxMbGGj9SLBYLFSpU0ELDJqX/q3JFznfJycfHhwcffBCASZMmAdC+fXuGDx/OH3/8we7du/H19aVdu3YA/Prrr1StWhVvb+/rW3mR/+987Tg8PJwHHniAr7/+mtjYWNzc3GjSpAnjxo1j/vz55OTk4O7uTp8+fQDYv38/VapUweFw4O7uriEFcl0VtbcNGzawefNmOnfubIyp69SpE6dPn2bGjBkkJSVRtWpV4uLisFqt3Hzzza6stlwDCnZSasW/DJcuXUpKSgonT54kMjKStm3bGqvtFw93ISEhhISEAGdX74+Li2Pt2rW8+uqrCnbiEsXbcVxcHMePHyczM5PbbruNxo0b8+CDD/LFF1+wYMECHA4HERERRpgDsNvtzJkzhw0bNjB69Gg8PDxc9VLkb6hospnT6SQ1NZV58+aRkpJC165djTJFvcmbN29myZIl1KhRg0qVKvH8888bi2fr8qt5aLkTuWIzZ85k1apVREdHc+zYMXbu3ElYWBjDhg0jNzeXOXPmEBsby2OPPUbHjh2N5/3888+sWrWKhx9+mLp167rwFYjAF198QXx8PMHBwRQWFrJlyxaeeuop2rdvz+7du/n666+pVKkSUVFRtGrVCoATJ06wfv16fv75Z/75z3+WuJ2YyLV2vhUENm7cyPz58zl27BjDhw/nxhtvLLH/zJkzWK1WbDabZr+alHrs5Irs2LGD9evXM2rUKEJDQ9m4cSNr1qwhPDwcq9WKt7c3999/P1lZWSxbtoyOHTsaH0YdO3akVatW6qkTlyvqOX7++ecJDg5mx44d/Pbbb0YvRqNGjbj//vv573//y549e4xg5+/vT9u2bbn55pupWLGiK1+C/M0U72VbtWoV+/btY/DgwbRq1Qqr1crChQv54YcfsNlshIWFGc+pUKGCcQyn06lQZ0IKdnJZ/vwL8eTJk/j4+BAaGsq6dev4+OOPGThwIFFRUeTm5pKYmEh4eDiDBg3C3d0doMQCxAp1UhbY7XZatmxJcHAwcXFxfPrppwwePJi2bdty+vRp3NzcaNy4MSNGjDB6l4vasJ+fn2srL387xUPd7t27SUhI4Ndff6VKlSr07t2bFi1a4HA4WLp0Kd9//z19+vQhLCzsnMutGgdqTrqoLpel6IOgaIq81WrFz8+PjRs38tFHHzFgwABuv/12AHbu3MnGjRux2+14eHgYga74cUTKghMnTmC329m6dSuffvppiXa8evVqvvzySxwOB8HBwcaYJLVhcZWigPbFF1/w9ddf43A48PPzY9GiRXz11VfA2WWmbrvtNgA+++wzDh486LL6yvWlHju5bPPnz8dut/Pggw9yww038N///pfNmzfz6KOP0rlzZ+DsyvyLFi2iUqVKVKlSxXiuvgzFlS40nqhNmzZMnz6dt956i4EDBxqhLjc3l+3bt1O9evUSz9NAc3G1X3/9lRUrVvD888/TsGFD7HY7CxcuZP369VitVu6//37atGlDfn4+SUlJBAUFubrKcp0o2Mlf+vPlV19fX2bOnEmLFi1o0qQJTz/9NO+++y47duzA19cXp9PJokWLsNvtPPfcc7r3q7hcbm4unp6eRjhbv349drudmjVr0qxZM4KDg2nUqJGxeHZGRgbp6el8//33ZGRkMHLkSLVjKVPS0tKoWrUqoaGhWCwWqlSpwh133EFWVhaLFi3Cw8OD3r1706FDB9q1a6fZr38jCnZyUcW/yIo+FDp27MiuXbuIjY2lVq1ahIeH88wzzzB9+nT27NlDpUqVqF69OqNGjcLNzU0fJuJS77zzDtWqVePee+/Fx8eHr776ip9++onAwEAOHDhAt27duO+++7jvvvtwOp3Ex8czZ84c6tSpQ6VKlXjzzTfVjqXMqV69OgUFBRw8eNCYjV21alU6d+5MfHw8K1eupKCggHvvvRer1ao7ovyNKNjJRRWFujlz5rBr1y569OhB48aNiYqK4rPPPmP37t20b9+e8PBwxo0bx6lTp/Dw8KBSpUqaSi9lQpMmTfj888/x8vKiZcuW7Nmzh1dffZWQkBB+++03Jk+eTF5eHg888AADBw4kNzeX5ORkAgICqFatGlarVe1YypygoCAcDgfLly/n7rvvplq1agB4eHgQERFBzZo12bp1K+3atSMoKEg9zX8jCnbyl7Kzs0lOTmbbtm34+/uzcuVKHn30UcLDw/n6669p06YNNpuNChUqlJhKrxtJS1lwxx134OXlxccff0xGRgbVq1enfv36WK1WWrZsyYgRI5g8eTIWi4V77rmHGjVqGCv2g9qxlE1BQUEMHDiQ999/n7y8PJo1a0ZQUBBffvklAQEBdOzYkR9//JGUlBSNr/ubUb+snKP4mtWFhYV4e3tz5513UqFCBWrUqEG1atUYOXIkdevW5dSpU8TExJz3OOr2F1crastRUVE8/vjjrFy5kj179pCRkWHsb9GiBU899RTr16/nq6++4sSJEyWOoXYsrna++wg4nU5atWrFiBEjSEtL4/PPP2fChAlkZWUxcOBAAgICqFevHj4+Pi6osbiSeuzkHEVd9mvXriUlJYVevXpx4403ct9997Fhwwaee+45atasybp16/Dw8GDp0qW0b9+eRo0aubjmIiXHhRaf8BAVFYW7uzuTJ09myZIl9OzZ01hUuEWLFgwdOpTly5drXTpxuT+P57zQZdSiHyYNGzYkJyeH3Nxc6tSpg8ViYebMmZw+fVq9dX9DCnZyXg6Hg8TERPbv38+GDRsYPnw4TZo0IS0tjXXr1tG1a1fCwsLYvn07W7ZsMVY2F3GlvLw8PDw8SnwxFg93HTp0IC8vj08++QSr1UqPHj2McNe2bVvatm0LnPvFKnK9FG97P//8M7///jt5eXk0b96cFi1aGOWKh71KlSpRqVIl4Ow9uOfNm8eePXt48cUX8ff3v74vQFxO94qVC3I4HBw7doxvvvmG3bt307FjR1JTU7HZbAwbNuycm53ry1BcKSYmhjVr1jBp0iS8vb3PaY/Fe/JWrlzJJ598Qp8+fbjjjjuML0WRsmLmzJn88ssvNGnShIoVK/LTTz/x8MMPEx0dfdGJENnZ2fz444/ccsst6q37m9K3sFxw/IbNZqNmzZr83//9H3369OH48eMcOXKE+Ph4pk6des5zFOrElTp27Ii/vz+vvvoq2dnZxrpdRYrf+eTWW2/l8ccf5/vvv2f9+vWuqrLIeW3ZsoVffvmFp59+mieeeILIyEgAvLy8LhrqnE6ncX9uhbq/L30T/80V78XIy8szthdfuw7gtttuo0+fPvTs2ROA48ePnzcQirhKcHAwTz75JACvvPLKX4a7qKgonnvuOaKiolxRXZELOnHiBPXr1ycsLIx169bx7rvvMnToUKKiosjOzr7g7cGKjy2Vvy9dihUAVq1axaFDhxgwYABQ8oPhz6vtp6enU7VqVWPRS32ISFly6NAhJk2ahNPp5PXXX//Ly7Jw4VuNiVxr5xvCsmbNGlatWkWnTp2YNm1aiXsXr1u3jg0bNjBw4EAqV67siipLGaceOwFg9+7dbN++HYvFUqJXA0qGvMLCQqpXr64boUuZULw3rkhgYCBPPfUUFovloj13xSnUiSsUvxvEhg0bjO01a9YkOzubTz/9lN69exuh7syZM6xatcpYBF7kfBTs/ob+vE4dQP/+/bHb7fz000/Ahbvyi/+y1Jg6caXiPR2HDh0iNTWV9PR0rFYrQUFBjBgx4qLhTsSViv8wTktL45133mHatGkANGzYkDZt2lCxYkUyMzPZsWMH27dv55133uH48eMMGTLknB/gIkV0KfZv5kIzV/Py8oiJiSE7O9sYp6TeOCmril9KnTVrFnFxcRQWFnL69GkeffRR2rRpA5wNfJMnTwbg1Vdf1WKtUiYUb79z5szh+PHjbNiwgczMTDp27Mjw4cOBs217165d7Ny5k7CwMHx8fBg5ciQ2m02rEMgFKdj9TcyZM4fw8HBjvbkFCxZw6NAhevToQc2aNbHZbGzbto1x48bx/PPP06xZMxfXWOSvzZo1i6VLlzJ8+HCCg4OZPn06mzZt4pFHHqFr167A2XA3ZswYmjZtyhNPPOHiGov8z/fff8+CBQsYMWIEVquVAwcO8N1339G6dWueeuopAE6fPs2JEyfw9fXVPbjlkmiB4r+BvXv3sm7dOvbu3cu9995LSEgINpuNhIQEUlJS8PHxoX///jRq1Iju3buzYsUKQkND8fb2dnXVRS7owIED7N69m+HDhxMZGcnGjRvZvn074eHhTJkyBYCuXbsSFBTEmDFjjJuki5QFeXl5JCYm0qNHD2M5k8aNGxMQEMD777/Pp59+yqOPPoqPjw/e3t4lVipQqJOLUT/u30DDhg3p27cveXl5zJo1i99//53o6Gjee+897rrrLjw8PBg/fjyTJ09m3759HDt2jJycHOD8g9NFygIfHx9at25Ns2bN2LFjB1OmTKFfv348//zzREZGMmPGDBYuXAhAQECAxthJmWKxWEhPT+fYsWPGNnd3d1q0aEGHDh1YsWKF8QPFYrEYbVeXX+WvqIWYnMPhAKBNmzZ06NABh8PBV199xf79+7HZbLRt25aRI0cyZMgQQkJCSElJYe/evXz33XeAPkSkbDhfIKtevTq33HILVquV1atX07JlS2677TYAqlSpQs2aNfn1119LDDBXexZXKGq/xf91d3cnKiqK5ORktm3bZpT18PCgdu3a3HTTTcTFxTFr1ixAbVcunS7FmljR3SMA5s6dS0pKCseOHePIkSMA9OvXj5CQEABatmxJy5Yt6dixI4sWLSIpKQm73a4boovLFR8kvm3bNvLy8ggMDCQwMJCKFSuSk5PDwYMHadasGW5ubhQUFJCVlcXgwYO54YYbStwrVuR6++WXX9i6dSv33HMP/v7+eHp6Gu25cePGbN++naVLl1JYWEhkZCTZ2dns2bOHiIgIgoKC2Lx5M7fffrs+i+WSKdiZWNEX2cKFC/nhhx/417/+xb333svWrVtZs2YNs2bN4v777yc4OBg4u0hrtWrViI6O5l//+hfbtm2jY8eOLnwFIv/rqfjiiy/4+eefycvLo06dOrRu3ZqePXvi5eVFs2bNWLBgAadPn2bfvn0UFBQQFhamUCculZ2dzTfffENOTg7JycmEhobSqFEj424nDRs2pHv37ixatIhPPvmESpUq4XA4sFqtdOvWjRUrVnDmzJlz7sstcjEKdibmdDpxOp3s2rWLW265xZjpWqtWLSpVqsSsWbP4+uuvGTBgAHXr1sXNzY3CwkKqVatGWFgYJ0+edPErkL+zokDmdDo5evQoiYmJvPjii3h4eLBo0SLWr19PdnY2999/P/3798fNzY39+/cTHBzMkCFDjDF1uoQlruLp6Um7du2oXr06DRo0ICEhgRkzZrBt2zaCgoLo2bMnkZGR1K9fnwMHDpCQkEDVqlWNGd3JycnUqFFDbVgui4KdiRXdRcLb25uTJ0+WmCLfoUMH9u3bx5IlS/jvf//LY489RlBQEFarlbi4OLZt28Yjjzzi4lcgf1fFA9mZM2eAs+Pmateujbu7O/369WPu3Lls374dNzc37r33Xvr160dubi6enp6AbhMmrme1WmncuDHvvfcer7/+Oj179iQ6Opq5c+fy7bffsm7dOjp06EBkZCQRERFEREQAcOTIEZYuXcratWt5/fXXjTYtcin0M8BELjTjr3bt2uzatYu9e/eW2F70K7JZs2YEBgYa21u2bMmkSZNKbBO5nopC3XfffcfLL7/M5MmTycjIwN3dHTg7I7ZXr17ceOONbNu2jc8++wzA+AJ0Op0KdVImNG/enFtuuYWlS5cCZydH/Prrr7Rq1YqmTZuSkJDAv//9b1asWAGcnfC2bt069u/fz2uvvUbdunVdWX0ph7RAsUkU7+HYs2cPBQUFFBYWEh4eDsD48eNJTk7m8ccfp06dOlSsWJFJkybRuHFjevTooen0UiYUb8erV6/m888/p3fv3uzdu5eEhARuuukmHn30UaP86dOn+fLLL3E6nfzzn//UWDopk1asWMHKlSt57rnnGDNmDB4eHjz//PN4e3tz4sQJdu/ezU033WT8GMnLyyMvL4+KFSu6uOZSHinYmczMmTOJj4+noKCAvLw8QkNDefzxx6lSpQrvvPMO+/btA872bBQWFvLuu+/i5uamAeZSpvz666+cOnUKHx8f2rVrR05ODsuXL2f16tWEhYUxdOhQo2xubi4VKlTQRAkp055//nmSk5Np3LgxI0eOPG9oKygowGq1qg3LFVGwM5ElS5bw7bff8vzzz+Pp6Ulubi7/+c9/qFKlCq+88goeHh789ttvnDp1CofDQadOnYwJE+qlE1cq3gYPHjzIm2++SUZGBk899RQdOnQAzvbOrVy5ktWrV9OoUSMGDx5c4hgKdVIWFbXLn3/+mR9//JHhw4cTEhKi9irXjL7NTeTgwYO0bt2a0NBQgoKCCA0NZdy4cfzxxx9MnToVODveo2PHjnTu3FmhTsqMojY4d+5cNm7cyIABA6hevTpr1qwxyvj4+NC5c2duvfVW1q1bx7x580ocQ1+SUhYVtcvw8HCysrKMxYjVXuVa0Te6CRQUFOB0Ovnjjz+w2+3G9vz8fCpXrsy9995LcnIyJ0+ePGeChUKduFLx9vjLL7+wePFiWrVqRevWrenfvz/79+/nvffeM8p4e3vTsWNHHnnkEXr06OGCGouUjr+/P/fccw/z58/n0KFDrq6OmJi+1cuh7du3s2DBAmbOnElOTg5ubm5YLBY6d+7M/v37Wbt2LYAxg9Bms+Hm5oa7u7uCnJQpRe0xISGBffv2cdddd1G3bl08PT1p1aoVDz30EHv27GHSpEnGcypWrEj79u1171cpd5o3b07z5s214oBcU/qWL2eWL1/O5MmT+e2331izZg3PP/+8cT/YkJAQIiMjWbx4MatWrQLAbrfz66+/Ur16da2FJGWO0+kkLS2NCRMmsHDhQjIyMox9Hh4etG7dmgcffJDExETGjh17zvP1Q0XKk5o1azJ8+HD9KJFrSpMnypGlS5cyffp0nn76aZo1a4bdbue1115j5MiRNGjQAIvFwuHDh/npp59Ys2YN3t7eeHp64uHhwdixY7HZbBpTJy53vkHju3fv5sMPP6Ry5coMHDiQsLAwY19eXh5xcXFs3LiRZ555Ru1XROQiFOzKifXr1zNx4kSeffZZWrVqBZz9wnv22Wdp2rQpKSkptGvXjg4dOuDt7c2RI0fYs2cPvr6+tGjRAqvVqpX4xeWK/7DIy8vDw8PDaJcJCQl8/PHH3HDDDfTs2dO4hzGcHS9aNLRAP05ERC5MtxQrB/Lz89m6dSsBAQGkpaUZ2ydPnkxubi5eXl54eXkxY8YMTpw4Qd++fQkKCiIoKMgoW1hYqFAnLlU8kC1YsIBdu3aRm5tLnTp1uOeeewgPD+fRRx/l008/Zf78+dx1111GuCsKdaDLryIiF6Meu3IiIyODH3/8kb1799KhQwd2797N0aNHGTlyJAEBAQB88MEHbN26lYkTJ1K5cmUX11jk/L766iuWL19O9+7dOXr0KIcPH+bEiROMGTOGatWqsW3bNqZMmUJgYCAPP/wwtWrVcnWVRUTKDf30LSeqVKnCPffcQ4MGDYiNjSUhIYFRo0YREBBg3CS9UaNGVKtWDWV1KSuKBogXtcnU1FTWr1/Pk08+Se/evRk2bBiPP/44tWvXZsyYMWRlZdGsWTMGDx6Mh4cHNWrUcGX1RUTKHQW7csTPz4/evXvTsmVLAgICjGVNKlSoQEFBAevWraNGjRrqrZMyo2hdxaJgl52dzbFjx6hSpYpRJjAwkPvvvx8PDw+2bduG0+kkMjKSf/3rX5o9KCJymRTsyhk/Pz969epFWFhYidX333nnHU6cOMGTTz5p3DNTxJUOHDjA448/zrp164xxcTVr1qRWrVps2bLFCGxWq5U6deqQm5tLenr6OTNmNaZOROTS6ROzHCrquQsNDWXDhg0MHTqU1NRU3n77bdzc3CgoKNDtasTl/Pz86NKlC5MnT2bDhg3A2bXp6tevz6ZNm1i/fr1R1ul0UqlSJXx8fFxVXRERU9DkiXLMbrczc+ZMTp06xbPPPovNZtOSJlKm2O125s6dy6JFi/jXv/5FmzZtOHXqFO+//z6nTp2iVq1aNGjQgI0bN3Ly5Enjx4mIiJSOgl05l5WVhbe3t9apkzLh+PHjeHh4UKlSJWOb3W5nzpw5LF68mKeffpq2bduSlZXFkiVL2LlzJw6Hg2rVqvHYY49pEW0RkSukYGcS+jIUV1u3bh2ffvopVapUoUuXLvj6+nLzzTcD4HA4+OKLL1i0aBH/93//R7t27Yw2e+bMGSpUqACgHyciIldICxSbhEKduJLD4SAhIYGCggJOnTrF+vXrSU9PZ+7cudSqVYtu3brRunVrvLy8eO+99/D29iYiIgLACHVOp1OhTkTkCqnHTkSuCrvdzg8//EBaWhpBQUH06NGD9evXs2XLFn7//Xfy8vKoWbMmiYmJFBYWMm7cOEJCQlxdbRERU1GPnYhcFX5+fvTs2ZO5c+eyfft2/P39iY6OpmvXrhw+fBi73c6qVatwOBycOnWKevXqubrKIiKmox47EbmqMjIymDt3LklJSbRq1YrevXsb+5xOp7HOosVi0Zg6EZGrTAOzROSqqlKlirHO4qZNm/jhhx+MfUWLElssFgoLCxXqRESuMvXYicg1UbTMyf79+2nSpAn333+/q6skImJ66rETkWui6A4pNWrUIDMzU7e5ExG5DtRjJyLXVPFFtIvG1omIyLWhYCci14UW0RYRufYU7ERERERMQj+fRURERExCwU5ERETEJBTsRERERExCwU5ERETEJBTsREREREzC5uoKiIj8laSkJD7//HN+//13zpw5w9tvv01wcLCrqyUiUuYo2IlImeZwOPjPf/6Du7s7AwcOxMPDg2rVql3Vc5w4cYJly5bRpk0bBUYRKdcU7ESkTPvjjz9IT0/n0UcfpUuXLtfkHBkZGcyePZuAgAAFOxEp1zTGTkTKtMzMTAB8fHxcXJPLl5eXR2FhoaurISJ/I7rzhIiUWR9++CGrV68use3GG2/ktdde4/Dhw3zzzTckJCSQl5dHnTp16Nu3L61atTLKZmVlMWfOHLZu3UpaWhpWq5UbbriB/v37Gz1zO3bsYPTo0eece9iwYURFRTF8+HBuvPFGhg8fXmL/a6+9VuLfouOMGDGClJQUVq5cid1uZ/r06fj4+LB3715mzZpFYmIiBQUFNGjQgH/84x80atTokt+PtLQ0nnjiCR544AG8vb358ccfOX78OPXq1WPw4MGEhoYaZX///XcWLFjArl27yMjIwNvbm+bNm/Pggw9SqVIlo9ysWbOYPXs27733HrNnz2bTpk3YbDZuu+02+vXrx/Hjx5k+fTo7duzAw8ODnj17ctddd5WoV35+PnPnzmXNmjUcP34cX19fOnToQL9+/XB3d7/k1yciV06XYkWkzLrtttvw9/dn7ty53HHHHTRo0AA/Pz9SUlJ4+eWX8ff355577qFChQrEx8czYcIE/vWvf9GmTRvg7GXcDRs20K5dOwICArDb7SxbtozXXnuNd999F39/f2rXrs19993HrFmz6Nq1qxG0brjhhlLV+fvvv8dms3HXXXfhcDiw2WwkJCTw5ptvEhISwr333ovFYmHVqlW8/vrrvP766yUC2aX45ZdfyMnJoWvXrlgsFn788UcmTpzI+++/j8129mN927ZtpKWlERUVhZ+fH4cOHWLZsmUcOnSIsWPHYrFYShzzvffeo3bt2gwYMIDNmzczZ84cKlasyLJlywgPD2fAgAGsWbOGL774ggYNGnDjjTcCZ+8B/Pbbb7N79266dOlCUFAQBw8eZOHChaSmpvLvf/+7VO+jiJSOgp2IlFlhYWFGb1Djxo1p27YtAGPGjKFatWqMGzfO6BHq1q0br7zyCl9++aUR7OrWrcukSZOwWv836qRjx448/fTTrFixgr59++Ln50fz5s2ZNWsWYWFhdOzY8YrqnJ+fz1tvvYWHhwcATqeTKVOm0KRJE1544QUjUN12220888wzfPPNN7z00kuXdY5jx44xadIkKlasCEBgYCBvv/02W7dupWXLlsb78eeetYYNGzJp0iR2795N48aNS+wLDQ3ln//8JwBdu3Zl+PDhfPHFF/zjH//gnnvuAaBDhw48+uijrFy50gh2a9euZdu2bYwePbpE72OdOnWYMmUKe/bsKXVIFpHLpzF2IlKuZGVlkZCQQLt27cjJyeHkyZOcPHmSU6dOERERwZEjRzhx4gQA7u7uRqgrLCzk1KlTeHp6EhgYyP79+69J/Tp16mSEOoADBw5w5MgRbr75Zk6dOmXUNzc3l/DwcHbt2nXZ4/DatWtnhDrACFR//PGHsa14HfLy8jh58iQNGzYEOO9r79y5s/HfVquVkJAQnE5nie0+Pj4EBgaSlpZmbFu3bh1BQUEEBgYar+3kyZOEh4cDZy9Ri8j1ox47ESlXjh49itPp5Ntvv+Xbb789b5nMzEz8/f0pLCwkNjaWJUuWkJaWViJAFQ9GV1NAQECJx0eOHAHOjhe8kOzs7Muqz5+Xeyl67unTp41tWVlZfPfdd8TFxRkTUIqf76+O6e3tjbu7O5UrVz5n+6lTp4zHR44c4fDhwwwZMuS8df3zuUXk2lKwE5FypSic3XXXXURERJy3TM2aNQGYO3cu3377Lbfeeiv9+vWjYsWKWCwWZsyYwZXOGyssLCxxibdI8Z4ywDjPAw88cMGlVDw9PS/r3Oc7b/FzAfznP/9hz5499OzZk+DgYDw9PSksLOTNN988bw/h+Y55ofP8+Zx169bloYceOu/+q73moIhcnIKdiJQrNWrUAMDNzY1mzZpdtOy6deto0qQJjz/+eIntp0+fLjEz9M8TCYqrWLFiiZ6wIunp6UZdLqW+3t7ef1nfqyUrK4vt27dz33330bdvX2N7Ue/h1VSjRg1+//13mjZtetH3UUSuD42xE5FyxdfXlyZNmrBs2TIyMjLO2X/y5Enjv8/X4xQfH2+MwStSoUIFgPMGuBo1arB3714cDoexbdOmTRw/fvyS6hsSEkKNGjWYP38+ubm5F63v1VL0uv/cK7lw4cKrfq527dpx4sQJli9ffs6+vLy8875mEbl21GMnIuXO4MGDefnllxk5ciRdunQhICCAzMxMEhMTOXHiBBMmTACgZcuWzJ49m48++oiwsDAOHjzI2rVrz+lpq1GjBj4+PixduhQvLy8qVKhAw4YNCQgIoHPnzqxbt46xY8fSrl07/vjjD9asWXNJvXVwNmQ99thjvPnmmzzzzDNERUXh7+/PiRMn2LFjB15eXowaNeqqvj/e3t40btyYefPmUVBQgL+/v7GW39XWsWNH4uPjmTJlCgkJCTRq1IjCwkIOHz5MfHw8L774Ig0aNLjq5xWR81OPnYiUO0FBQbz11ls0b96cVatWMW3aNJYuXYrFYqFPnz5GuV69etGjRw+2bt3K559/zv79+xk1ahRVq1YtcTybzcbw4cOxWq1MmTKFSZMmsXPnTgAiIyN56KGHOHLkCDNmzCAxMfG8x7iYJk2aMHbsWEJCQli8eDGfffYZq1evxs/Pjx49elydN+VPRowYQUREBIsXL+arr77Czc2NF1544aqfx2q18uyzz9K/f39SUlL44osv+O6779i3bx933nkntWrVuurnFJEL050nRERERExCPXYiIiIiJqExdiIiLlZYWPiXkyg8PT0ve1kUEfn7UbATEXGxY8eO8cQTT1y0TN++fbnvvvuuU41EpLzSGDsRERfLy8tj9+7dFy1To0aNS56JKyJ/Xwp2IiIiIiahyRMiIiIiJqFgJyIiImISCnYiIiIiJqFgJyIiImISCnYiIiIiJqFgJyIiImISCnYiIiIiJqFgJyIiImIS/w9wUHJ9k0b5UAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -592,7 +213,7 @@ ], "source": [ "# Explore most frequent n features in observation table\n", - "observation_feature_counts = omop.feature_statistics(source='observation', number=20)\n", + "observation_feature_counts = omop.feature_counts(source='observation', number=20)\n", "observation_feature_counts.head()" ] }, @@ -677,7 +298,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -688,729 +309,278 @@ ], "source": [ "# Explore most frequent n features in measurement table\n", - "measurement_feature_counts = omop.feature_statistics(source='measurement', number=20)\n", + "measurement_feature_counts = omop.feature_counts(source='measurement', number=20)\n", "measurement_feature_counts.head()" ] }, { - "cell_type": "code", - "execution_count": 10, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Trying to extarct the following features: ['Body weight', 'Normal height']\n",
-       "
\n" - ], - "text/plain": [ - "Trying to extarct the following features: \u001b[1m[\u001b[0m\u001b[32m'Body weight'\u001b[0m, \u001b[32m'Normal height'\u001b[0m\u001b[1m]\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Detected: feature Body weight, feature ID 3711521 in concept table, match socre = 1.0.\n",
-       "
\n" - ], - "text/plain": [ - "Detected: feature \u001b[32mBody weight\u001b[0m, feature ID \u001b[1;32m3711521\u001b[0m in concept table, match socre = \u001b[1;32m1.0\u001b[0m\u001b[32m.\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1;35m2024-01-18 14:50:45,719\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Added `['Body weight_min', 'Body weight_max', 'Body weight_mean', 'Body weight_std']` columns to `obs`.\u001b[0m\n", - "\u001b[1;35m2024-01-18 14:50:45,720\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Added `['Body weight_min', 'Body weight_max', 'Body weight_mean', 'Body weight_std']` features to `X`.\u001b[0m\n" - ] - }, - { - "data": { - "text/html": [ - "
Detected: feature Normal height, feature ID 4203099 in concept table, match socre = 1.0.\n",
-       "
\n" - ], - "text/plain": [ - "Detected: feature \u001b[32mNormal height\u001b[0m, feature ID \u001b[1;32m4203099\u001b[0m in concept table, match socre = \u001b[1;32m1.0\u001b[0m\u001b[32m.\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1;35m2024-01-18 14:51:41,896\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Added `['Normal height_min', 'Normal height_max', 'Normal height_mean', 'Normal height_std']` columns to `obs`.\u001b[0m\n", - "\u001b[1;35m2024-01-18 14:51:41,897\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Added `['Normal height_min', 'Normal height_max', 'Normal height_mean', 'Normal height_std']` features to `X`.\u001b[0m\n" - ] - } - ], "source": [ - "features = ['Body weight', 'Normal height']\n", - "adata = omop.extract_features(adata, source='observation', features=features, add_aggregation_to_X=True, aggregation_value_column='value_source_value', verbose=True, remove_empty_column=True)" + "### Get aggregation statistics of selected features (min/max/mean/count/std)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# TODO\n", - "# pH and temperature couldn't be found in the dataset" + "Next we run `ep.pp.qc_metrics`, which calculates various quality control metrics, to get number of missing data and summary statistics. The associated results can be shown as a table with `ep.pl.qc_metrics`. (# TODO)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "#features = ['Glasgow coma score total', 'Glucose [Moles/volume] in Blood', 'Heart rate', 'Mean blood pressure', 'Peripheral oxygen saturation', 'Respiratory rate', 'Diastolic blood pressure', 'Systolic blood pressure', ]\n", - "#features = ['Glasgow coma score total']\n", - "\n", - "adata = omop.extract_features(adata, source='measurement', features=features, add_aggregation_to_X=True, aggregation_value_column='value_as_number', verbose=True, remove_empty_column=True, columns_in_source_table=['value_as_number', 'time'])" + "observation_features = ['Body weight', 'Normal height']\n", + "measurement_features = ['Glasgow coma score total', 'Glucose [Moles/volume] in Blood', 'Heart rate', 'Mean blood pressure', 'Peripheral oxygen saturation', 'Respiratory rate', 'Diastolic blood pressure', 'Systolic blood pressure', ]" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
feature_namefeature_id
0Glasgow coma score total3007194
1Glucose [Moles/volume] in Blood3020491
2Heart rate4239408
3Mean blood pressure4239021
4Peripheral oxygen saturation4196147
5Respiratory rate4313591
6Diastolic blood pressure4154790
7Systolic blood pressure4152194
\n", - "
" - ], - "text/plain": [ - " feature_name feature_id\n", - "0 Glasgow coma score total 3007194\n", - "1 Glucose [Moles/volume] in Blood 3020491\n", - "2 Heart rate 4239408\n", - "3 Mean blood pressure 4239021\n", - "4 Peripheral oxygen saturation 4196147\n", - "5 Respiratory rate 4313591\n", - "6 Diastolic blood pressure 4154790\n", - "7 Systolic blood pressure 4152194" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;35m2024-02-04 20:37:45,673\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Added `['Body weight_min', 'Body weight_max', 'Body weight_mean', 'Body weight_std', 'Body weight_count', 'Normal height_min', 'Normal height_max', 'Normal height_mean', 'Normal height_std', 'Normal height_count']` features to `X`.\u001b[0m\n" + ] } ], "source": [ - "features = ['Glasgow coma score total', 'Glucose [Moles/volume] in Blood', 'Heart rate', 'Mean blood pressure', 'Peripheral oxygen saturation', 'Respiratory rate', 'Diastolic blood pressure', 'Systolic blood pressure', ]\n", - "#features = []\n", - "#features = ['Capillary refill rate']\n", - "info_df = omop.get_feature_info(adata, source='measurement', features=features, verbose=False)\n", - "info_df" + "adata = omop.get_feature_statistics(adata, add_aggregation_to_X=True, source='observation', level='stay_level', features=observation_features, verbose=False, use_dask=False)" ] }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 10, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/latex": [ - "$\\displaystyle \\left[ 3007194, \\ 3020491, \\ 4239408, \\ 4239021, \\ 4196147, \\ 4313591, \\ 4154790, \\ 4152194\\right]$" - ], - "text/plain": [ - "[3007194, 3020491, 4239408, 4239021, 4196147, 4313591, 4154790, 4152194]" - ] - }, - "execution_count": 116, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;35m2024-02-04 20:38:00,572\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Added `['Glasgow coma score total_min', 'Glasgow coma score total_max', 'Glasgow coma score total_mean', 'Glasgow coma score total_std', 'Glasgow coma score total_count', 'Glucose [Moles/volume] in Blood_min', 'Glucose [Moles/volume] in Blood_max', 'Glucose [Moles/volume] in Blood_mean', 'Glucose [Moles/volume] in Blood_std', 'Glucose [Moles/volume] in Blood_count', 'Heart rate_min', 'Heart rate_max', 'Heart rate_mean', 'Heart rate_std', 'Heart rate_count', 'Mean blood pressure_min', 'Mean blood pressure_max', 'Mean blood pressure_mean', 'Mean blood pressure_std', 'Mean blood pressure_count', 'Peripheral oxygen saturation_min', 'Peripheral oxygen saturation_max', 'Peripheral oxygen saturation_mean', 'Peripheral oxygen saturation_std', 'Peripheral oxygen saturation_count', 'Respiratory rate_min', 'Respiratory rate_max', 'Respiratory rate_mean', 'Respiratory rate_std', 'Respiratory rate_count', 'Diastolic blood pressure_min', 'Diastolic blood pressure_max', 'Diastolic blood pressure_mean', 'Diastolic blood pressure_std', 'Diastolic blood pressure_count', 'Systolic blood pressure_min', 'Systolic blood pressure_max', 'Systolic blood pressure_mean', 'Systolic blood pressure_std', 'Systolic blood pressure_count']` features to `X`.\u001b[0m\n" + ] } ], "source": [ - "list(info_df.feature_id)" + "adata = omop.get_feature_statistics(adata, add_aggregation_to_X=True, source='measurement', value_col='value_as_number', level='stay_level', features=measurement_features, verbose=False)" ] }, { - "cell_type": "code", - "execution_count": 121, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "source = 'measurement'\n", - "source_column_types, parse_dates = omop._get_column_types(omop.filepath[source])\n", - "if parse_dates:\n", - " if len(parse_dates) == 1:\n", - " columns = list(source_column_types.keys()) + [parse_dates]\n", - " else:\n", - " columns = list(source_column_types.keys()) + parse_dates\n", - "else:\n", - " columns = list(source_column_types.keys())\n", - "df_source = omop._read_table(\n", - " omop.filepath[source], dtype=source_column_types, parse_dates=parse_dates, use_dask=False\n", - ")" + "### Extract selected meserment features" ] }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 11, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
value_as_numbertimevisit_occurrence_idvisit_start_datevisit_source_valueperson_idmeasurement_datetimemeasurement_datemeasurement_timemeasurement_concept_idmeasurement_source_valueunit_sourceunit_concept_idmeasurement_id
0NaN18000.020000792023-01-01mimic3-20012410000792023-01-012023-01-0105:00:00607590NaNcm85822.200000e+11
1NaN18000.020005702023-01-01mimic3-20096210005642023-01-012023-01-0105:00:00607590NaNcm85822.200000e+11
2144.88999918000.020005892023-01-01mimic3-20099310005832023-01-012023-01-0105:00:00607590144.889999cm85822.200000e+11
3NaN18000.020005982023-01-01mimic3-20100610005922023-01-012023-01-0105:00:00607590NaNcm85822.200000e+11
4NaN18000.020006042023-01-01mimic3-20101410005982023-01-012023-01-0105:00:00607590NaNcm85822.200000e+11
.............................................
376973895.000000165068.020040892023-01-01mimic3-20704510039502023-01-022023-01-0221:51:0830090945.000000No matching concept01.250000e+11
376973905.000000172268.020040892023-01-01mimic3-20704510039502023-01-022023-01-0223:51:0830090945.000000No matching concept01.250000e+11
376973915.000000179468.020040892023-01-01mimic3-20704510039502023-01-032023-01-0301:51:0830090945.000000No matching concept01.250000e+11
376973925.000000186668.020040892023-01-01mimic3-20704510039502023-01-032023-01-0303:51:0830090945.000000No matching concept01.250000e+11
376973935.000000195848.020040892023-01-01mimic3-20704510039502023-01-032023-01-0306:24:0830090945.000000No matching concept01.250000e+11
\n", - "

37697394 rows × 14 columns

\n", - "
" - ], - "text/plain": [ - " value_as_number time visit_occurrence_id visit_start_date \\\n", - "0 NaN 18000.0 2000079 2023-01-01 \n", - "1 NaN 18000.0 2000570 2023-01-01 \n", - "2 144.889999 18000.0 2000589 2023-01-01 \n", - "3 NaN 18000.0 2000598 2023-01-01 \n", - "4 NaN 18000.0 2000604 2023-01-01 \n", - "... ... ... ... ... \n", - "37697389 5.000000 165068.0 2004089 2023-01-01 \n", - "37697390 5.000000 172268.0 2004089 2023-01-01 \n", - "37697391 5.000000 179468.0 2004089 2023-01-01 \n", - "37697392 5.000000 186668.0 2004089 2023-01-01 \n", - "37697393 5.000000 195848.0 2004089 2023-01-01 \n", - "\n", - " visit_source_value person_id measurement_datetime measurement_date \\\n", - "0 mimic3-200124 1000079 2023-01-01 2023-01-01 \n", - "1 mimic3-200962 1000564 2023-01-01 2023-01-01 \n", - "2 mimic3-200993 1000583 2023-01-01 2023-01-01 \n", - "3 mimic3-201006 1000592 2023-01-01 2023-01-01 \n", - "4 mimic3-201014 1000598 2023-01-01 2023-01-01 \n", - "... ... ... ... ... \n", - "37697389 mimic3-207045 1003950 2023-01-02 2023-01-02 \n", - "37697390 mimic3-207045 1003950 2023-01-02 2023-01-02 \n", - "37697391 mimic3-207045 1003950 2023-01-03 2023-01-03 \n", - "37697392 mimic3-207045 1003950 2023-01-03 2023-01-03 \n", - "37697393 mimic3-207045 1003950 2023-01-03 2023-01-03 \n", - "\n", - " measurement_time measurement_concept_id measurement_source_value \\\n", - "0 05:00:00 607590 NaN \n", - "1 05:00:00 607590 NaN \n", - "2 05:00:00 607590 144.889999 \n", - "3 05:00:00 607590 NaN \n", - "4 05:00:00 607590 NaN \n", - "... ... ... ... \n", - "37697389 21:51:08 3009094 5.000000 \n", - "37697390 23:51:08 3009094 5.000000 \n", - "37697391 01:51:08 3009094 5.000000 \n", - "37697392 03:51:08 3009094 5.000000 \n", - "37697393 06:24:08 3009094 5.000000 \n", - "\n", - " unit_source unit_concept_id measurement_id \n", - "0 cm 8582 2.200000e+11 \n", - "1 cm 8582 2.200000e+11 \n", - "2 cm 8582 2.200000e+11 \n", - "3 cm 8582 2.200000e+11 \n", - "4 cm 8582 2.200000e+11 \n", - "... ... ... ... \n", - "37697389 No matching concept 0 1.250000e+11 \n", - "37697390 No matching concept 0 1.250000e+11 \n", - "37697391 No matching concept 0 1.250000e+11 \n", - "37697392 No matching concept 0 1.250000e+11 \n", - "37697393 No matching concept 0 1.250000e+11 \n", - "\n", - "[37697394 rows x 14 columns]" - ] - }, - "execution_count": 122, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding feature [Systolic blood pressure] into adata.obsm\n", + "Adding feature [Diastolic blood pressure] into adata.obsm\n", + "Adding feature [Glucose [Moles/volume] in Blood] into adata.obsm\n", + "Adding feature [Mean blood pressure] into adata.obsm\n", + "Adding feature [Heart rate] into adata.obsm\n", + "Adding feature [Peripheral oxygen saturation] into adata.obsm\n", + "Adding feature [Respiratory rate] into adata.obsm\n", + "Adding feature [Glasgow coma score total] into adata.obsm\n" + ] } ], "source": [ - "df_source" + "adata = omop.extract_features(adata, source='measurement', features=measurement_features, verbose=True, use_dask=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rename 'Glucose [Moles/volume] in Blood' as 'Glucose [Moles per volume] in Blood'" ] }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 12, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/Users/xinyuezhang/BlendedICU/BlendedICU/OMOP-CDM-mimiciii/measurement.parquet'" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "omop.filepath[source]" + "adata.obsm['Glucose [Moles per volume] in Blood'] = adata.obsm['Glucose [Moles/volume] in Blood']\n", + "del(adata.obsm['Glucose [Moles/volume] in Blood'])" ] }, { "cell_type": "code", - "execution_count": 104, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "ak_measurement = ak.from_parquet(omop.filepath[source], columns=['visit_occurrence_id', 'time'])\n", - "ak_measurement = ak.drop_none(ak_measurement)" + "adata.X = adata.X.astype(float)\n", + "#adata.layers['original'] = adata.layers['original'].astype(float)\n", + "adata.write_h5ad(\"adata_mimic3_after_loading_data.h5ad\")" ] }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "ak_measurement = ak.values_astype(ak_measurement, int)" + "measurement_features = ['Glasgow coma score total', 'Glucose [Moles per volume] in Blood', 'Heart rate', 'Mean blood pressure', 'Peripheral oxygen saturation', 'Respiratory rate', 'Diastolic blood pressure', 'Systolic blood pressure', ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Imputation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can easily use `ep.pl.missing_values_barplot` to visualize a bar chart of the null values:" ] }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
[{time: 18000, visit_occurrence_id: 2000079},\n",
-       " {time: 18000, visit_occurrence_id: 2000570},\n",
-       " {time: 18000, visit_occurrence_id: 2000589},\n",
-       " {time: 18000, visit_occurrence_id: 2000598},\n",
-       " {time: 18000, visit_occurrence_id: 2000604},\n",
-       " {time: 18000, visit_occurrence_id: 2000610},\n",
-       " {time: 18000, visit_occurrence_id: 2000706},\n",
-       " {time: 18000, visit_occurrence_id: 2000848},\n",
-       " {time: 18000, visit_occurrence_id: 2000983},\n",
-       " {time: 18000, visit_occurrence_id: 2001014},\n",
-       " ...,\n",
-       " {time: 129068, visit_occurrence_id: 2004089},\n",
-       " {time: 136268, visit_occurrence_id: 2004089},\n",
-       " {time: 150668, visit_occurrence_id: 2004089},\n",
-       " {time: 157868, visit_occurrence_id: 2004089},\n",
-       " {time: 165068, visit_occurrence_id: 2004089},\n",
-       " {time: 172268, visit_occurrence_id: 2004089},\n",
-       " {time: 179468, visit_occurrence_id: 2004089},\n",
-       " {time: 186668, visit_occurrence_id: 2004089},\n",
-       " {time: 195848, visit_occurrence_id: 2004089}]\n",
-       "----------------------------------------------\n",
-       "type: 37697394 * {\n",
-       "    time: ?int64,\n",
-       "    visit_occurrence_id: ?int64\n",
-       "}
" - ], "text/plain": [ - "" + "" ] }, - "execution_count": 106, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "ak_measurement" + "variables_end_with_mean = [var_name for var_name in adata.var_names if var_name.endswith(\"mean\")]\n", + "ep.pl.missing_values_barplot(adata[:, variables_end_with_mean + ['year_of_birth', 'gender_source_value']])" ] }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "awkward.highlevel.Array" + "['Glasgow coma score total_mean',\n", + " 'Glucose [Moles per volume] in Blood_mean',\n", + " 'Heart rate_mean',\n", + " 'Mean blood pressure_mean',\n", + " 'Peripheral oxygen saturation_mean',\n", + " 'Respiratory rate_mean',\n", + " 'Diastolic blood pressure_mean',\n", + " 'Systolic blood pressure_mean']" ] }, - "execution_count": 96, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "type(ak_measurement)" + "variables = [feature + '_mean' for feature in measurement_features]\n", + "variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outliers\n", + "#### Data visualization\n", + "\n", + "We already saw that outliers are present in the dataset, but we need to take a closer look at data before deciding how to handle them. Using `ehrapy` and its `violin` plot function we can easily create one boxplot for every variable." ] }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "37697394 * {\n", - " time: ?int64,\n", - " visit_occurrence_id: ?int64\n", - "}\n" + "\u001b[1;35m2024-02-04 19:06:57,500\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `561484` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:07:00,597\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `693690` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:07:16,623\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `7927136` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:07:41,568\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1292523` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:07:47,349\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1176813` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:08:02,596\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `6116149` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:08:25,936\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1289488` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 19:08:32,699\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1290091` x `1`.\u001b[0m\n" ] - } - ], - "source": [ - "ak_measurement.type.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ + }, { "data": { - "text/html": [ - "
[{time: 1.8e+04, visit_occurrence_id: 2000079},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000570},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000589},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000598},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000604},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000610},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000706},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000848},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000983},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2001014},\n",
-       " ...,\n",
-       " {time: 1.29e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.36e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.51e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.58e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.65e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.72e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.79e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.87e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.96e+05, visit_occurrence_id: 2004089}]\n",
-       "------------------------------------------------\n",
-       "type: 37697394 * {\n",
-       "    time: ?float32,\n",
-       "    visit_occurrence_id: ?int64\n",
-       "}
" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 94, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "ak_measurement" + "adata.X = adata.X.astype(float)\n", + "fig = plt.figure(figsize=(10, 10))\n", + "for i, variable in enumerate(measurement_features, start=1):\n", + " ax = plt.subplot(4, 3, i)\n", + " omop.violin(adata, ax=ax, show=False, obsm_key=variable, keys=variable)\n", + "fig.tight_layout()\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 119, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "da_measurement = dd.read_parquet(omop.filepath[source], columns=['visit_occurrence_id', 'time', 'value_as_number', 'measurement_concept_id'])\n", - "#da_measurement = dd.drop_none(da_measurement)\n", - "da_measurement = da_measurement[da_measurement.measurement_concept_id.isin(list(info_df.feature_id))]" + "#### Exclusion\n", + "\n", + "Ideally, we should keep extreme values related to the patients' poor health condition and exclude impossible values (such as negative temperature) and probable outliers (such as heart rate above 250 beats/min). In order to do so, values that fall outside boundaries defined by expert knowledge are excluded. This way, we avoid excluding extreme (but correct/possible) values. We can use `ep.pp.qc_lab_measurements` function to examine lab measurements for reference ranges and outliers. To do so, we need to define a custom reference table which contains possible values for each measurement.\n" ] }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1434,682 +604,391 @@ " \n", " \n", " \n", - " visit_occurrence_id\n", - " time\n", - " value_as_number\n", - " measurement_concept_id\n", + " Traditional Reference Interval\n", " \n", " \n", " \n", " \n", - " 1174\n", - " 2030101\n", - " 4077.0\n", - " 88.0\n", - " 4239408\n", - " \n", - " \n", - " 1175\n", - " 2030101\n", - " 4377.0\n", - " 84.0\n", - " 4239408\n", - " \n", - " \n", - " 1176\n", - " 2030101\n", - " 5277.0\n", - " 82.0\n", - " 4239408\n", - " \n", - " \n", - " 1177\n", - " 2030101\n", - " 6177.0\n", - " 83.0\n", - " 4239408\n", - " \n", - " \n", - " 1178\n", - " 2030101\n", - " 7077.0\n", - " 83.0\n", - " 4239408\n", + " Diastolic blood pressure\n", + " <300\n", " \n", " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", + " Systolic blood pressure\n", + " <300\n", " \n", " \n", - " 37682012\n", - " 2004089\n", - " 165068.0\n", - " 13.0\n", - " 3007194\n", + " Mean blood pressure\n", + " 0-300\n", " \n", " \n", - " 37682013\n", - " 2004089\n", - " 172268.0\n", - " 13.0\n", - " 3007194\n", + " Glucose [Moles per volume] in Blood\n", + " <2000\n", " \n", " \n", - " 37682014\n", - " 2004089\n", - " 179468.0\n", - " 13.0\n", - " 3007194\n", + " Heart rate\n", + " <400\n", " \n", " \n", - " 37682015\n", - " 2004089\n", - " 186668.0\n", - " 14.0\n", - " 3007194\n", + " Respiratory rate\n", + " <300\n", " \n", " \n", - " 37682016\n", - " 2004089\n", - " 195848.0\n", - " 14.0\n", - " 3007194\n", + " Peripheral oxygen saturation\n", + " 0-100\n", " \n", " \n", "\n", - "

20347374 rows × 4 columns

\n", "" ], "text/plain": [ - " visit_occurrence_id time value_as_number \\\n", - "1174 2030101 4077.0 88.0 \n", - "1175 2030101 4377.0 84.0 \n", - "1176 2030101 5277.0 82.0 \n", - "1177 2030101 6177.0 83.0 \n", - "1178 2030101 7077.0 83.0 \n", - "... ... ... ... \n", - "37682012 2004089 165068.0 13.0 \n", - "37682013 2004089 172268.0 13.0 \n", - "37682014 2004089 179468.0 13.0 \n", - "37682015 2004089 186668.0 14.0 \n", - "37682016 2004089 195848.0 14.0 \n", - "\n", - " measurement_concept_id \n", - "1174 4239408 \n", - "1175 4239408 \n", - "1176 4239408 \n", - "1177 4239408 \n", - "1178 4239408 \n", - "... ... \n", - "37682012 3007194 \n", - "37682013 3007194 \n", - "37682014 3007194 \n", - "37682015 3007194 \n", - "37682016 3007194 \n", - "\n", - "[20347374 rows x 4 columns]" + " Traditional Reference Interval\n", + "Diastolic blood pressure <300\n", + "Systolic blood pressure <300\n", + "Mean blood pressure 0-300\n", + "Glucose [Moles per volume] in Blood <2000\n", + "Heart rate <400\n", + "Respiratory rate <300\n", + "Peripheral oxygen saturation 0-100" ] }, - "execution_count": 120, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "da_measurement.compute()" + "measurements = [\n", + " \"Diastolic blood pressure\",\n", + " \"Systolic blood pressure\",\n", + " \"Mean blood pressure\",\n", + " \"Glucose [Moles per volume] in Blood\",\n", + " \"Heart rate\",\n", + " \"Respiratory rate\",\n", + " \"Peripheral oxygen saturation\",\n", + "]\n", + "reference_table = pd.DataFrame(\n", + " np.array(\n", + " [\n", + " \"<300\",\n", + " \"<300\",\n", + " \"0-300\",\n", + " \"<2000\",\n", + " \"<400\",\n", + " \"<300\",\n", + " \"0-100\",\n", + " ]\n", + " ),\n", + " columns=[\"Traditional Reference Interval\"],\n", + " index=measurements,\n", + ")\n", + "reference_table" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "num_before = 0\n", + "num_now = 0\n", + "for measurement in measurements:\n", + " num_before += ak.count(adata.obsm[measurement]['value_as_number'])\n", + "omop.qc_lab_measurements(adata, obsm_measurements=measurements, reference_table=reference_table, verbose=False)\n", + "\n", + "for measurement in measurements:\n", + " num_now += ak.count(adata.obsm[measurement]['value_as_number'])" ] }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 18, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
╭─────────────────────────────────────── Traceback (most recent call last) ───────────────────────────────────────╮\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/dask_awkward/lib/core.py:1504 in __getattr__     │\n",
-       "│                                                                                                                 │\n",
-       "│   1501 │   def __getattr__(self, attr: str) -> Any:                                                             │\n",
-       "│   1502 │   │   if attr not in (self.fields or []):                                                              │\n",
-       "│   1503 │   │   │   try:                                                                                         │\n",
-       "│ ❱ 1504 │   │   │   │   cls_method = getattr_static(self._meta, attr)                                            │\n",
-       "│   1505 │   │   │   except AttributeError:                                                                       │\n",
-       "│   1506 │   │   │   │   raise AttributeError(f\"{attr} not in fields.\")                                           │\n",
-       "│   1507 │   │   │   else:                                                                                        │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/inspect.py:1650 in getattr_static                              │\n",
-       "│                                                                                                                 │\n",
-       "│   1647 │   │   │   │   │   pass                                                                                 │\n",
-       "│   1648 │   if default is not _sentinel:                                                                         │\n",
-       "│   1649 │   │   return default                                                                                   │\n",
-       "│ ❱ 1650 │   raise AttributeError(attr)                                                                           │\n",
-       "│   1651                                                                                                          │\n",
-       "│   1652                                                                                                          │\n",
-       "│   1653 # ------------------------------------------------ generator introspection                               │\n",
-       "╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
-       "AttributeError: isin\n",
-       "\n",
-       "During handling of the above exception, another exception occurred:\n",
-       "\n",
-       "╭─────────────────────────────────────── Traceback (most recent call last) ───────────────────────────────────────╮\n",
-       "│ in <module>:3                                                                                                   │\n",
-       "│                                                                                                                 │\n",
-       "│   1 dak_measurement = dak.from_parquet(omop.filepath[source],                                                   │\n",
-       "│     columns=['visit_occurrence_id', 'time', 'value_as_number', 'measurement_concept_id'])                       │\n",
-       "│   2 dak_measurement = dak.drop_none(dak_measurement)                                                            │\n",
-       "│ ❱ 3 dak_measurement =                                                                                           │\n",
-       "│     dak_measurement[dak_measurement.measurement_concept_id.isin(list(info_df.feature_id))]                      │\n",
-       "│   4                                                                                                             │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/dask_awkward/lib/core.py:1506 in __getattr__     │\n",
-       "│                                                                                                                 │\n",
-       "│   1503 │   │   │   try:                                                                                         │\n",
-       "│   1504 │   │   │   │   cls_method = getattr_static(self._meta, attr)                                            │\n",
-       "│   1505 │   │   │   except AttributeError:                                                                       │\n",
-       "│ ❱ 1506 │   │   │   │   raise AttributeError(f\"{attr} not in fields.\")                                           │\n",
-       "│   1507 │   │   │   else:                                                                                        │\n",
-       "│   1508 │   │   │   │   if hasattr(cls_method, \"_dask_get\"):                                                     │\n",
-       "│   1509 │   │   │   │   │   return cls_method._dask_get(self._meta, type(self._meta), self)                      │\n",
-       "╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
-       "AttributeError: isin not in fields.\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/dask_awkward/lib/\u001b[0m\u001b[1;33mcore.py\u001b[0m:\u001b[94m1504\u001b[0m in \u001b[92m__getattr__\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1501 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m__getattr__\u001b[0m(\u001b[96mself\u001b[0m, attr: \u001b[96mstr\u001b[0m) -> Any: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m attr \u001b[95mnot\u001b[0m \u001b[95min\u001b[0m (\u001b[96mself\u001b[0m.fields \u001b[95mor\u001b[0m []): \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mtry\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1504 \u001b[2m│ │ │ │ \u001b[0mcls_method = getattr_static(\u001b[96mself\u001b[0m._meta, attr) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1505 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mexcept\u001b[0m \u001b[96mAttributeError\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1506 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mAttributeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33m{\u001b[0mattr\u001b[33m}\u001b[0m\u001b[33m not in fields.\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1507 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/\u001b[0m\u001b[1;33minspect.py\u001b[0m:\u001b[94m1650\u001b[0m in \u001b[92mgetattr_static\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1647 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0m\u001b[94mpass\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1648 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m default \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m _sentinel: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1649 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m default \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1650 \u001b[2m│ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mAttributeError\u001b[0m(attr) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1651 \u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1652 \u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1653 \u001b[0m\u001b[2m# ------------------------------------------------ generator introspection\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", - "\u001b[1;91mAttributeError: \u001b[0misin\n", - "\n", - "\u001b[3mDuring handling of the above exception, another exception occurred:\u001b[0m\n", - "\n", - "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", - "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m3\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1 \u001b[0mdak_measurement = dak.from_parquet(omop.filepath[source], \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m columns=[\u001b[33m'\u001b[0m\u001b[33mvisit_occurrence_id\u001b[0m\u001b[33m'\u001b[0m, \u001b[33m'\u001b[0m\u001b[33mtime\u001b[0m\u001b[33m'\u001b[0m, \u001b[33m'\u001b[0m\u001b[33mvalue_as_number\u001b[0m\u001b[33m'\u001b[0m, \u001b[33m'\u001b[0m\u001b[33mmeasurement_concept_id\u001b[0m\u001b[33m'\u001b[0m]) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0mdak_measurement = dak.drop_none(dak_measurement) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m3 dak_measurement = \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m dak_measurement[dak_measurement.measurement_concept_id.isin(\u001b[96mlist\u001b[0m(info_df.feature_id))] \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m4 \u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/dask_awkward/lib/\u001b[0m\u001b[1;33mcore.py\u001b[0m:\u001b[94m1506\u001b[0m in \u001b[92m__getattr__\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mtry\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mcls_method = getattr_static(\u001b[96mself\u001b[0m._meta, attr) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1505 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mexcept\u001b[0m \u001b[96mAttributeError\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1506 \u001b[2m│ │ │ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mAttributeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33m{\u001b[0mattr\u001b[33m}\u001b[0m\u001b[33m not in fields.\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1507 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1508 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(cls_method, \u001b[33m\"\u001b[0m\u001b[33m_dask_get\u001b[0m\u001b[33m\"\u001b[0m): \u001b[31m│\u001b[0m\n", - "\u001b[31m│\u001b[0m \u001b[2m1509 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0m\u001b[94mreturn\u001b[0m cls_method._dask_get(\u001b[96mself\u001b[0m._meta, \u001b[96mtype\u001b[0m(\u001b[96mself\u001b[0m._meta), \u001b[96mself\u001b[0m) \u001b[31m│\u001b[0m\n", - "\u001b[31m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", - "\u001b[1;91mAttributeError: \u001b[0misin not in fields.\n" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of observations removed: 228\n", + "Observations corresponding to outliers: 0.0011523363366520282%\n" + ] } ], "source": [ - "dak_measurement = dak.from_parquet(omop.filepath[source], columns=['visit_occurrence_id', 'time', 'value_as_number', 'measurement_concept_id'])\n", - "dak_measurement = dak.drop_none(dak_measurement)\n", - "dak_measurement = dak_measurement[dak_measurement.measurement_concept_id.isin(list(info_df.feature_id))]" + "print(f\"Number of observations removed: {num_before - num_now}\")\n", + "print(\n", + " f\"Observations corresponding to outliers: {(num_before - num_now)*100/num_before}%\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 19, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;35m2024-02-04 20:45:28,562\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `561484` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:45:31,627\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `693690` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:45:50,381\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `7927124` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:46:18,155\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1292488` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:46:23,721\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1176813` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:46:39,037\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `6116130` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:46:58,483\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1289345` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:47:05,300\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1290072` x `1`.\u001b[0m\n" + ] + }, { "data": { - "text/html": [ - "
[{time: 1.8e+04, visit_occurrence_id: 2000079},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000570},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000589},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000598},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000604},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000610},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000706},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000848},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2000983},\n",
-       " {time: 1.8e+04, visit_occurrence_id: 2001014},\n",
-       " ...,\n",
-       " {time: 1.29e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.36e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.51e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.58e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.65e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.72e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.79e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.87e+05, visit_occurrence_id: 2004089},\n",
-       " {time: 1.96e+05, visit_occurrence_id: 2004089}]\n",
-       "------------------------------------------------\n",
-       "type: 37697394 * {\n",
-       "    time: ?float32,\n",
-       "    visit_occurrence_id: ?int64\n",
-       "}
" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 114, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "dak_measurement.compute()" + "adata.X = adata.X.astype(float)\n", + "fig = plt.figure(figsize=(10, 10))\n", + "for i, variable in enumerate(measurement_features, start=1):\n", + " ax = plt.subplot(4, 3, i)\n", + " omop.violin(adata, ax=ax, show=False, obsm_key=variable, keys=variable)\n", + "fig.tight_layout()\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "#### Data visualization after outliers exclusion\n", + "\n", + "The same code can be used to verify the data distribution after exclusion of outliers. The `ep.pl.violin` function allows to visualize the underlying distribution and the number of observations. Setting `groupby = \"mortality_cat\"` shows the plots partitioned by outcome." + ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 20, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dask.awkward" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "dak_measurement" + "adata.obs['mortality'] = adata.obs['death_datetime'].isnull().replace({True: 0, False: 1})\n", + "adata.obs[\"mortality_cat\"] = adata.obs[\"mortality\"]\n", + "adata.obs[\"mortality_cat\"] = adata.obs[\"mortality_cat\"].astype(int).astype(str)" ] }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 21, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;35m2024-02-04 20:47:18,669\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `561484` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:47:23,357\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `693690` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:47:46,570\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `7927124` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:47:59,526\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1292488` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:48:03,418\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1176813` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:48:18,129\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `6116130` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:48:26,552\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1289345` x `1`.\u001b[0m\n", + "\u001b[1;35m2024-02-04 20:48:30,675\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;37mINFO - Transformed passed DataFrame into an AnnData object with n_obs x n_vars = `1290072` x `1`.\u001b[0m\n" + ] + }, { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
timevisit_occurrence_id
entry
0180002000079
1180002000570
2180002000589
3180002000598
4180002000604
.........
376973891650682004089
376973901722682004089
376973911794682004089
376973921866682004089
376973931958482004089
\n", - "

37697394 rows × 2 columns

\n", - "
" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMJCAYAAAAeYVW/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUZfrw8e+Zkt4ISUgFEkJIaCG00EF6UwREBKwIuoCurqv+VrGALi9iQdeC6yqoWCgiSO9NpAZCCTWkAOmF9DLJlPP+MWQkkgAZJpmU53NdXMnMOTPnHiY5mfs8z3PfkizLMneQnZ19p12q5OHhYdbjBEEQBEEQBEEQBKExkO4m6Z48ebJZT75q1SqzHicIgiAIgiAIgiAIjYHqbnaaNWtWbcchCIIgCIIgCIIgCI3OXY10C4IgCIIgCIIgCIJQcwprByAIgiAIgiAIgiAIjdVdTS+vzsWLF0lMTKSkpISqBswfeuihe3l6QRAEQRAEQRAEQWjQzEq6i4qKWLhwIXFxcbfdTyTdgiAIgiAIgiAIQlNmVtL9ww8/cO3aNV544QWCg4N5/vnnmTt3Ll5eXmzatInLly/z2muvWTpWQRCEBik5OZmMjAyKi4urnBU0cOBAK0QlCIIgCIIg1AWzku6TJ08ydOhQ+vTpQ2FhIQCSJOHt7c2MGTP48MMP+e6773jxxRctGasgCEKDkp6ezmeffXbHWUEi6RYEQRAEQWi8zEq6i4uLCQgIAMDOzg4AjUZj2t65c2dWrFhhgfAEQRAarq+//ppr167x5JNPEhYWhqOjo7VDEgRBEARBEOqYWUm3u7s7eXl5AKjValxcXLh69So9evQAICcnB0mSLBZkfZGbm4tOp7N2GIIg1CKVSkWzZs0s8lwXL15k/PjxjBo1yiLPV1+Jc6MgNH6WPDc2FeLcKAiN392eG81KusPCwjhz5gwTJkwAoE+fPqxfvx6FQoHBYGDLli2Eh4eb89T1mk6nQ6vVWjsMQRAaCBcXFxwcHKwdRq0T50ZBEIRbiXOjIAgVzEq6x44dy5kzZ9BqtajVaiZNmkRycjKrVq0CjEn5U089ZdFABUEQGpphw4Zx4MABRo4ciUKhsNjzrlu3jmPHjpGSkoKNjQ0hISE8+uij+Pr6mvYpLy9n+fLlHDp0CK1WS3h4ODNmzMDNzc20T3Z2Nl9//TXnzp3Dzs6OgQMHMnXqVJRKpcViFQRBEARBaOokuapSumYqLi5GoVBgb29vqaesV7KyssQVS0Fo5NRqNZ6enhZ5rsOHD/Pbb7+h0+m47777aN68eZXJd2RkZI2ed8GCBfTt25c2bdqg1+tZsWIFSUlJLF682FRn4+uvvyY6Opo5c+bg4ODA0qVLUSgUvPvuuwAYDAZeeeUV3NzceOyxx8jNzeXzzz9nyJAhTJ06tUbxiHOjIDR+ljw3NhXi3CgIjd/dnhvNSrrXrFlDz549admyZZXbk5KSOHr0aKPr0y1OnoLQ+Fnyg+XkyZPvar+KWULmKigoYMaMGcybN4/27dtTUlLC008/zQsvvECvXr0ASElJ4R//+Af//ve/CQkJ4eTJk7z33nt89dVXptHvHTt28NNPP7F06VJUqrufCCXOjYLQ+Imku+bEuVEQGr+7PTeaNb38l19+wdvb+7ZJ9y+//NLokm5BEISaePvtt+vkOCUlJQA4OTkBkJCQgF6vp1OnTqZ9/Pz88PDwIDY2lpCQEGJjY2nZsmWl6eZdunThm2++ISkpicDAwFuOo9VqK32AlCTJNLOpMRbPFARBEARBsASzku47KSoqqtEoiSAIQmPUvn37Wj+GwWDgu+++o127dqYLoXl5eahUqltalLm6upo6T+Tl5VVKuCu2V2yryrp161izZo3pdmBgIIsWLRKjX4Ig1As7duxgx44dZGVlAeDv789DDz1EREQEIGpdCIJgPXedGZ8/f57z58+bbh89epT09PRb9isuLubQoUPVjoI3FcePH+fLL79EpVIRFhZm0SJKQs3IskxiYiKFhYU88sgjDBs2rNaOde7cOdavX49Op7sloRHqnsFgICUlhV69ejFhwoRGORq7dOlSkpKSeOedd2r9WOPHj2fs2LGm2xX/n1lZWU2uLU5qaio7d+5k7NixNG/e3NrhCHUoNzcXNze3Rnk+uR2VSlXvL7C5u7szdepUfHx8kGWZ/fv38/777/P+++8TEBDA999/T3R0NC+99JKp1sVHH31UqdbFwoULcXNz49///rep1oVSqaxxrYumKi4ujsOHDzNx4sQm0b1DEO7WXSfd586dqzTCcezYMY4dO1blvv7+/kyfPv3eo2vAdu7cCRjbRcTExFg5GqHCxo0bGTp0aK19WNq/fz/x8fEAXL16tVaOIdTctm3bGDFihGn6dW2ZP38+kiQxd+5clEol8+fPv+NjJEnirbfeMut4S5cuJTo6mvnz51dK/Nzc3NDpdBQXF1ca7c7PzzddDHJzcyMuLq7S8+Xn55u2VUWtVqNWq6vcZsGanA3Ct99+S3x8PIWFhcyZM8fa4Qh1JCoqiv/+979MmDCBMWPGWDsc4S+6d+9e6faUKVPYsWMHly9fpnnz5uzZs4cXXniBjh07AjB79mz+8Y9/mJbdnD59muTkZN58803c3Nxo3bo1kydP5qeffuLhhx8WszjvwpIlS8jPz8fBwYGJEydaOxxBqDfu+uwxbtw4Ro4ciSzLzJw5k5kzZ95ScVeSJGxsbLCxsbF4oA3NjBkzWLhwoelD7F+pgOZK8FAYv7opQNG0LppbhCxDgQGuGyBbb/xadpvP/i+99FKtjk5MmjSJEydOVI7RqTlyM3+wc6m14wo36MuR8lIhNwVJNpjunjZtWq0n3HBr4inL8h1/3sxJVmVZZtmyZRw7dox58+bh5eVVaXtQUBBKpZKYmBhTIbXU1FSys7MJCQkBICQkhLVr15Kfn2+aVn7mzBns7e3x9/evcUxNTcXFtejoaCtHItSlFStWALB27VqRdNdzBoOBw4cPU1ZWRkhISK3VugBR7+JmFZ974+Pjm9xrb8pOnjzJihUreOaZZwgODrZ2OPXSXSfdNyfTn3/+OS4uLtja2tZaYA2dp6cnixcvNo10Hz58mNOnT5umYOqADL3xH1pQAu43EvCbk/HmSnCWQNGET1yyLFMsQ44esg1wXf9ngn1dD9XVBZUkibCwMHr37k1ERESdtLLz9PRkyZIlfP/99xw9etQYR9F1pKLryHYuyO7+xgTc1RtU4uLUPZMNUJyDlJOClJsEBRlINyWxzZs3Z/bs2bRu3bpOwpk3b95tb1vK0qVL+eOPP3j11Vext7c3rcF2cHDAxsYGBwcHBg8ezPLly3FycsLBwYFly5YREhJiSrrDw8Px9/fn888/Z9q0aeTl5bFy5UpGjBhR7Wi2IDR1ZWVl1g5BuINr164xd+5ctFotdnZ2vPzyy/j7+3PlypVaqXUBot5FVWxsbPDx8bF2GEIdeeaZZ9DpdPz88898+eWX1g6nXjJrnkzFSUSj0XD+/Hmys7MB8PDwoH379qY+sYJxDVRERAQRERGUlpaSnJxMRkYGGRkZpKenk5mZSUZGBlqtliwDZBm4JYtUAc0UMu5KaKYAd6UxQW+mgGZKsGkECblOlskzGBPrXAPk3Py9Hspv81ilUomHhwfe3t60aNGCFi1a4O3tja+vLy4udT+6bGtryzPPPMOoUaOIiYnh7NmzXI6Lw6ApQEo9D6nnkQEc3JCdPcHZE9nZCxzdQaz9r54sQ1kxFGYhFWYiFWZBYTaSofJaYi8vLzp27EjHjh0JCwtrlDNvduzYAdya1M+ePZtBgwYB8MQTTyBJEh999BE6nc5UMKiCQqHgX//6F9988w1vvPEGtra2DBw48K7bnAmCINRHvr6+fPDBB5SUlHDkyBG++OKLu1rqcy9EvYtblZeXk5aWZu0whDpS8XOenJzc5N73u613YfbilK1bt7Jy5Uo0Gk2l++3s7JgyZQojR44096kbLXt7e9q2bUvbtm0r3W8wGMjNzTUl4hVJeUZGBtnZ2egMhj8T8io4SzLNbiTi7kporgAflfGrsh4l5LIsk2uAdD1k3pRQ5xiMU8RvN8lWkiSaNWtWKamu+L558+b1cp1VQEAAAQEBjB49mtLSUi5evMjZs2c5d+6csbJqSR5SSR5kXAZAVijBqbkxAXfxMn61q/0p0fWWXmtMsAsqEuwspPKSW3azs7OjXbt2pkT7r1OtG6PVq1ffcR8bGxtmzJhRKdH+K09PT1577TVLhiYIgmBVKpUKb29vwLjUJj4+ni1bttCnT59aqXUBot5FdZrya2/KxPteNbMylf379/Pdd98REhLCqFGj8PPzAyAlJYWtW7fy7bff4uDgwIABAywabGOlUCho3rw5zZs3v6XFkF6vJycnh6ysLNO/zMxMsrOzyczMpLS0lEIZCnVw7S/PqwJaKGW8VeCjBG8leKvArg4Sca0sk6GHdJ0xyU7TG7/ebr21jY0Nnp6epn9eXl6m75s3b96gp7za29ubZjwAFBQUkJiYSEJCAgkJCSQmJlJaWgoFmUgFmZBifJxs44js6gXOLZBdvMCpOSgaYdsSWYayIuNrL8hAKsiAohykv1yKUSgU+Pn5ERQURFBQEIGBgfj4+IjuAIIgCEKVDAYDWq1W1LoQBMGqzEq6N23aRFhYGG+99ValD7utWrWiV69evPPOO2zcuFEk3RagVCpNiWdVioqKyM7ONiXjWVlZpKamkpycTFlZGSl6SNFXfkwzhYyvEjrZQpjaMqPhsiwTr4NTZZCqhyx91SPXKpUKX19f/Pz8KiXVnp6euLi4NJmiGy4uLoSHhxMeHg4YPxRkZmaakvCEhASSkpIwlBcjZSVCViJQMRruiezmg+zRChybQ0P9PysvRcq5hpSTbEy0qxjFbtasGW3atDEl2S1bthS1JARBEIQq/fzzz3Tp0gUPDw80Gg1//PEH58+fZ+7cuaLWhSAIVmVW0p2amspjjz1W5eiSQqGgV69e/PDDD/ccnHBnTk5OODk53VIoymAwkJWVRVJSEteuXSM5OZlr166Rm5tLrsE4tfuc1likraedTHdbcDajfLpGljlVBkc1t05/d3JyomXLlqZp1gEBAXh7e9fLqeDWplAo8Pb2xtvbmz59+gDGgj2JiYnEx8cTHx9PXFwcxcXFUJCOVJAO104i2zohN2+J3LwVuPrU/zXhpflI2VeRrl81jmbfRKlU0rJlS9q0aUNwcDBt2rTB3d3dSoEKgiAIDU1+fj5ffPEFubm5ODg40KpVK+bOnUvnzp0BUetCEATrMSv7cXBwMK5JrUZWVhYODg5mByXcO4VCYVrzfHPfyqKiIpKTk7lw4QK///47BQUF7C6FfaUwxkGmp93dJ95xWpmfC/8scmZra0vfvn3p3Lkz/v7+uLm5NZmR69pga2tLaGgooaGhgHE2QUZGBpcvX+bMmTOcPXuW8rKiP4uzqWyQfTsgB4SDsp5d2MhJRpEYhVR8vdLdrVq1okuXLoSGhtK6detGWfRMEARBqBuzZs267XZR60IQBGsx65N5165d2bZtG0FBQfTt27fStkOHDrFt2zb69+9vkQAFy3JycjIlcvfffz8nTpxg48aNpKWlEaeFnjUoPJ+oNSbcrq6ujB07lt69e9dJW66mSpIk02h4//79KS8v58KFC5w8eZLTp09TUFCAdO0kckYscmBPZM8g6089L81HEX8UKcdYcUChVBLarh0RERF06dJFjGQLgiAIgiAIjZ5ZSfe0adOIjY3l008/Zfny5aY+fGlpaeTl5eHn58fUqVMtGqhgeSqViubNm5uqDHrX8KfB58b+BoMBNzc30SqujtnY2JjWhRsMBk6cOMEvv/zC9evXkS7uxVCSh9y6m/UCLMlFGb0eDDoUCgVDhw5lzJgxODk13orsTzzxxD09/v/+7/9uKaYoCIIgCIIgNGxmJd0uLi4sWrSIXbt2cfLkSVOf7pYtWzJu3DiGDh0qponWc7m5ufz6668cPnwYADsJwmv4lgWrjW3JrhcW8sUXX9C+fXumTJmCr69vLUQs3I5CoaBHjx6Eh4ezadMmNm/ejCL5DHqfULB1vPMT1EZMV06AQUdgYCBPP/206eJcY6bRaAgNDaVFixY1elx5eTmHDx/GYKimL6AgCIIgCILQYJm98NPGxobRo0czevRoS8Yj1LKSkhK2bt3Krp07KddqkYCutjDMHpxqWEjNTpKY4yqzvxT+0MD58+d566236NevHw888ICYOmwFNjY2jB8/nkuXLhEXF4eUHovcKqLuAykrQcq+giRJTJ8+vUkk3BWGDRtGv379avSYgoIC0wUwQRAEQRAEoXExq9Txc889x/Hjx6vdfuLECZ577jmzgxJqx4EDB/jXv/7Fli1bKNdqaamCZ11gvKNU44S7go0kMcxB4u+u0F5tLPZ14MABXn/9dX777TcxcmcFkiQRFBRkvKEvv/3OteXGce3t7ZvUzIdRo0bh5+dX48fZ2toyatQoPDw8aiEqQRAEQRAEwZrMGunOyspCo9FUu12j0dy2urlQ96Kjo/nuu+8A8FTAcAcIVWOx6uLNlRJTneGaVmZ7KVzVatm4caNpRoRQt0zt/GQrXfS4cdyq2go2Zk8++aRZj7O1tTX7sYIgCIIgCEL9ViufiOPj43F0tM46UuFWubm5LF26FIBIW3jOFcJspFpp59VSLTHDGcbc6Bi3du1a4uLiLH4c4fYqpvZLmiLrBKApBKBZs2bWOb4gCIIgCIIg1BN3PdK9ZcsWtmzZYrr9/fffs3Llylv2Kykpobi4uMZrGoXac/36ddPMhDZqUNZyGylJkghUySgBvSyTmppKcHBwrR5TqKxly5YAxlZdRdfBqXndHVyWUSSdqRRHU5adnc3atWs5d+4cBQUFvPLKK7Rv356CggLWrFnDfffdR2BgoLXDFARBEARBEGrJXSfdLi4u+Pv7A8bp5e7u7reMYkmShK2tLUFBQYwYMcKykQpmCw4OZtCgQezbt49fiqC3nUxfO3A0cx337ZTLMlEa2K8BPRAWFnZLL3eh9gUHB9O1a1eio6NRXNiDodNIsHOu/QPLBqSEo0gFGdja2jJu3LjaP2Y9lpyczFtvvYUsywQHB5Oenm6qc+Di4sKlS5coKytj1qxZVo5UEARBEARBqC13nXT369fPNHo9f/58JkyYQKdOnWotMMGypkyZwvXr14mJieF3DRzRQC8LJt8VyfbvGig2tv3Gz8+Pv/3tbyiVynt+fqFmJEli2rRpxMfHk5+fj+LkegwdhoFLzVpZ1YiuHMXFfcbRdYw/c82b1+EIez30448/4ujoyIIFCwCYOXNmpe0RERGiarkgCIIgCEIjZ1YhtbffftvScQi1TKVS8cILL3D69Gk2bNjA1atX+V0DhzTQ1Vamjx14KGuefBcZZA5r4FgZlN5Itj08PBg7diy9e/dGpTK7K51wj9zc3HjjjTf49NNPSUpKQnl6E4aWEcgBXcDSBc7y0lDE/o6kKUStVjN9+nR69uxp2WM0QBcuXGDixIm4uLhQWFh4y3YPDw9ycnKsEJkgCIIgCIJQV+pVRnT+/Hk2bNhAYmIiubm5vPzyy6YP7jqdjpUrV3Ly5EkyMzNxcHCgU6dOTJ069bb9oFevXs2aNWsq3efr68snn3xSmy+lXpIkiS5duhAeHs7p06fZtGkTiYmJHCuDqDIIU8sMsYcWqjsn3wUGmT2lcKoMdDfu8/LyYvTo0SLZrkfc3d3517/+xXfffUdUVBSKq9HI169hCB0IDhYocmbQIyVGoUg5C0Dz5s3529/+9mfLsibOYDBga2tb7faCggLxuyIIgiAIgtDI1atPe2VlZbRu3ZrBgwfz4YcfVtpWXl5OYmIiEydOpHXr1hQVFfHdd9/x/vvv89577932eQMCAnjzzTdNt5taG6O/ujn5jo2NZfv27Zw+fZrzWriohf52MoPsQV1FwTWDLBNVBjtKoezGyHZQUBAjR44kIiKiyf/f1kd2dnY8++yzRERE8OOPP1JSlI0y+jcMbXoje7cDcwvrleSiuLAXqdg4Utu/f38mT56Mvb29BaNv2IKCgoiOjq6yxoVer+fQoUOEhIRYITJBEARBEAShrtSrpDsiIoKIiIgqtzk4OFRKnAGmT5/O66+/TnZ2Nh4eHtU+r0KhwM3NzZKhNgqSJNGuXTvatWtHamoqa9as4fTp0+zXwNlyeMJZxv2mKecag8zyIrh2Y2g7MDCQyZMn07ZtWyu9AuFuSZJEZGQkISEhLFu2jPPnz6O4/AeGvFTkdgNBUbN191JWAopL+8Ggx8nJienTpxMeHl5L0TdcDz74IO+99x5ff/21qaBgXl4eZ86cYd26daSkpDB9+nQrRykIgiAIgiDUpnqVdNdUSUkJkiTh4OBw2/3S09N59tlnUavVhISEMHXq1Nsm6VqtFq1Wa7otSZJp9K42elvXB35+fvz9738nOjqan3/+meu5uawugpkusqnF2MYSY8JtZ2fHxIkTue+++8TIdgPj7u7OSy+9xPbt2/n117WQlYCs12JoPwQUd3c6kDIuo7j0OyDTvn17ZsyYIS5qVSMiIoI5c+bw7bffsmvXLgA+++wzAOzt7ZkzZw7t27e3ZoiCIAiCIAhCLWuwSXd5eTk//fQTffv2vW3S3bZtW2bPno2vry+5ubmsWbOGt956i48++qjaabDr1q2rtA48MDCQRYsW4enpafHXUd/4+voSGRnJ7FmzSC4u5kgZ9LWDy1qZ0+XGWQMLFiwQiUIDN336dCIiIpg3bz7lOUlIl35HDht85wfmJBtHuIGRI0fy/PPPiwsvdzBgwAB69uzJmTNnTC3DvL29CQ8PF1PxBUEQBEEQmoB7SrpjY2M5d+4c+fn5jBgxAh8fH8rKykhJScHX1xc7OztLxVmJTqfj448/BmDGjBm33ffm6eqtWrUyJeGHDx9m8OCqk4zx48czduxY0+2K0e2srCx0Ol2Vj2lsBt13H5s2bSLjxsut+BoREUGzZs1IS0uzXnCCRXh7e/PCC3/no48+gqwE9D6h4OZb/QMMBhTxxvZWffv25aGHHiIjI6OOoq07KpXK4hfY7OzsRDV3QRAEQRCEJsqspFun0/HJJ58QFRVluq979+74+PggSRILFixgzJgxTJgwwWKB3nzsjz/+mOzsbN566607Ti3/K0dHR3x9fUlPT692H7VajVqtrnKbLMs1Ol5DVVpaCoDNjdn0FV9LS0ubzP9BUxAaGsqAAQPYt28fiqsnMdwm6ZayEpBK83F2dmbKlClIkiR+Fu6STqcjJyeH4uLiKv/PRLV3QRAEQRCExsuspHvlypWcOHGCmTNn0qFDB1588UXTNhsbG3r16kVUVJTFk+6KhDs9PZ23334bZ2fnGj+HRqMhPT2d/v37WzS2xqS0tJTDh40jmkE3rj20vvH1woULpKWl4ePjY6XoBEsbMmQI+/btg8JMkA0gVTNdvMB4oapPnz5iWvRdKi4u5ocffuDAgQO3nSWzatWqOoxKEARBEARBqEtmJd0HDx5k+PDhDB06lMLCwlu2+/n5ceTIkRo/b0VCXCEzM5MrV67g5OSEm5sbixcvJjExkf/7v//DYDCQl5cHgJOTk6nX7TvvvEPPnj0ZOXIkAMuXL6d79+54eHiQm5vL6tWrUSgU9OvXz4xX3jTs3r2bkpISPBUQeiPZ9lJKhKllLmhlNm7cyDPPPGPdIAWL8fb2xsbGhvLyctAUgr1rlftJxXkAtGzZsg6ja9i++OILTpw4Qd++fQkODq7xzBxBEARBEASh4TMr6S4oKLjtB2+FQkFZWVmNnzc+Pp758+ebbi9fvhyAgQMHMmnSJI4fPw7Aq6++Wulxb7/9Nh06dAAgIyODgoIC07acnBz+85//UFhYiIuLC6GhoSxYsAAXF5cax9cUFBcXs23bNgAG2YPipmrt99nDBS0cO3aM0aNH4+/vb60wBQtSKBTY29sbk279bWoWGIwV/R0dHesosobvzJkzjBo1iieffNLaoQiCIAiCIAhWYlbS3bx5c1JSUqrdfunSJby9vWv8vB06dGD16tXVbr/dtgpffPFFpds3T30X7iwmJobS0lI8FdDJpvI2X9Wfo93Hjh0TSXcjYqphYLhd0q2vvK9wR87OzmadCwVBEARBEITGw6xeP/369WPXrl3Exsbesm3Xrl0cPnyYAQMG3HNwQt1LSEgAoK268ih3hRB15f2ExsHUaUCvrX6nG9tsbW3rIKLGYciQIRw6dAiDwWDtUARBEARBEAQrMWuke8KECVy+fJm3334bPz8/AL7//nuKiorIyckhIiKiUsstoeGoSA6qyLcr3S+SiMalYrmFpCmiynrkBj2UlwDg6lr1mm/hVg899BA6nY7XXnuN/v3707x58yr7mkdGRlohOkEQBEEQBKEumJV0q1QqXn/9dQ4cOMCRI0cwGAzodDpatWrFI488woABA0y9rYWGpU2bNuzdu5fLWhghy7eMdl8u/3M/ofHw9/fn/PnzUHS96h2Kc5FkGXt7e5o1a1a3wTVgOTk5nD17litXrnDlypVq9xPVywVBEARBEBqvGifd5eXlrFixgg4dOjBgwAAxjbyR6dSpE/b29mSWlnK6HCJumkmcrJM5pwVJkujRo4f1ghQsrm3btuzYsQMpJ8nYR/ovF1uknCQAQkJCxAW1Gvjyyy9JTEzkwQcfpG3btqJ6uSAIgiAIQhNU46TbxsaGXbt2iSJajZSTkxNjxoxhzZo1bC+BMLWMnULCIMtsKjbu07t3b9E2qpHp0KGDsW1YWREUZoGL158bZRkpy7iGPyIiwkoRNkwXL15k3LhxPPzww9YORRAEQRAEQbASswqpBQUFkZSUZOlYhHpi6NChtGjRgiIZdpUa7zteBsl6Y8GtCRMmWDdAweJsbW3p2rUrAFLG5cobi7KRSnJRq9V069bNCtE1XG5ubjg5OVk7DEEQBEEQBMGKzEq6n3jiCQ4ePMju3bvR6/WWjkmwMrVazaOPPgpAVBnkG2T2aYzbHnzwQbGmt5Hq06cPgHFU+6ZCeVJmPGAc5RbTo2tm7Nix7N69G41GY+1QBEEQBEEQBCsxq5DakiVLUCgU/O9//+Pbb7/F3d0dG5vKTZ0lSeKDDz6wSJBC3Wvfvj1t2rQhPj6eHwqhwGDsOTxo0CBrhybUktDQUFxcXCgoKIC8VHD3vzG1PBEQFbbNodVqUalUPP/88/Tu3RsPD48qq5fXtNvD+fPn2bBhA4mJieTm5vLyyy/Ts2dP0/YvvviC/fv3V3pMeHg4c+fONd0uKipi2bJlnDhxAkmSiIyM5KmnnvqzfZwgCIIgCIJgEWYl3U5OTjg7O+Pr62vpeIR6pG/fvsTHx5N+YzJDZGQkarXaukEJtUapVBIeHs6BAweQ8lKR3f2htACpvBi1Wk2HDh2sHWKD88MPP5i+3759e7X71TTpLisro3Xr1gwePJgPP/ywyn26dOnC7NmzTbdVqsqn+08//ZTc3FzeeOMN9Ho9S5Ys4auvvuKFF16oUSyCIAiCIAjC7ZmVdM+bN8/CYQj1UUBAQKXbonhe49emTRtj0l2YiQxIhZkAtGrVSlxwMcPnn39eK88bERFxx6J2KpUKNze3KrclJydz6tQpFi5caGr/N336dBYuXMhjjz2Gu7u7pUMWBEEQBEFossxKuoWm4a/TYJVKpZUiEeqKt7e38ZuykhtfjSXrW7RoYaWIGjZPT0+rHfv8+fPMmDEDR0dHOnbsyCOPPIKzszMAsbGxODo6mhJuMLYLlCSJuLi4SlPVb6bVatFqtabbkiRhb29v+r6pasqvvSkT77sgCIJwt8xOug0GA7///jvR0dFkZ2cD4OHhQbdu3ejfv3+V6xaFhiU3N/e2t4XGx9HR0fiNrqzSV9P9QoPQpUsXIiMj8fLyIj09nRUrVvD//t//Y8GCBSgUCvLy8nBxcan0GKVSiZOTE3l5edU+77p161izZo3pdmBgIIsWLbLqxYX6wMfHx9ohCHXk5kRbvO+CIAjC3TIr6S4pKWHBggXExcVhb29vGgWLiYnh6NGj7Nixg7lz54pKxw1cYmLibW8LgnB7c+bMueNomCRJfPbZZxY9bt++fU3ft2zZklatWvH8889z7tw5OnXqZPbzjh8/vtL684rXlpWVhU6nMz/gBi4tLc3aIQh1RJZl0/dN7X1XqVRN/gKbIAiCucxKulesWEFCQgLTp09nyJAhpgI9Op2OPXv28O2337Jy5UqmT59u0WCFuhUXFwdAVxuILjfelmVZTKlrxMrLy43fKFSVvpruF2qkffv2t/y+GAwGsrKyuHTpEgEBAQQGBtZ6HC1atMDZ2Zn09HQ6deqEm5ubsUr9TfR6PUVFRdWuAwdjO8Hq1vbfnIw0NU35tTdl4n0XBEEQ7pZZSfexY8cYPnw4I0aMqPxkKhXDhw8nOTmZo0ePiqS7AdPpdCQkJADQ2w7OlENhYSGZmZlifW8jVlRUZPxGbVvpa3FxsZUiatjmzJlT7bYrV66wYMEC+vXrV+txXL9+naKiIpo1awZASEgIxcXFJCQkEBQUBMDZs2eRZZng4OBaj0cQBEEQBKEpMWvhdVFR0W3bhfn5+f354V1okK5fv45Wq0UNeCuhxY0aaqmpqVaNS6hdhYWFxm/UN3o1q+0r3y9YTOvWrRk2bBg//fRTjR+r0Wi4cuUKV65cASAzM5MrV66QnZ2NRqPhhx9+IDY2lszMTGJiYnj//ffx9vYmPDwcMHYi6NKlC1999RVxcXFcvHiRZcuW0adPH1G5XBAEQRAEwcLMGun29vbm+PHjt4x0Vzh+/LgYDW3gKoopuSiM6zadFTLoIT8/37qBCbWqYsqxfCPZlm8k33+diixYhqurK8nJyTV+XHx8PPPnzzfdXr58OQADBw5k5syZXLt2jf3791NcXIy7uzudO3dm8uTJlaaG//3vf2fp0qW88847SJJEZGSkmJ0kCEKd0mq1JCYmkp+fT7t27W4p8CgIgtBYmJV0Dx8+nGXLlrFw4UJGjx5tquCZmprK1q1bOXPmDE8//bRFAxXqVkV7MMON2xVfRVX6xs1Uod7WodJXUbne8goLC9mzZw/Nmzev8WM7dOjA6tWrq90+d+7cOz6Hk5MTL7zwQo2PLQiCYAlbtmzhl19+oaTE2KLyzTffpGPHjhQUFPCPf/yDadOmMXjwYCtHKQiCYBlmJd0jRowgPz+f9evXc+rUqcpPqFLx0EMPMXz4cEvEJ1iJq6srAIUGMMgyhTeybnEVunHLysoyfmN7o0WYrRMApaWlFBUV4eTkZKXIGqabR6NvVlJSQkpKCjqdjueee66OoxIEQbCuvXv38v3339OnTx/Cw8P58ssvTdtcXFzo0KEDhw4dEkm3IAiNhtl9uh9++GFGjhxJTEyM6YO6p6cnnTp1EolZI9C8eXNsbGwoLy8nUw+ZeuP9fn5+1g1MqDWyLJuK58lOHsY7lWpke1ek0nzi4+NNa4KFu1Ndtf+Kc+V9990nfqcEQWhyNm3aRPfu3XnhhReqrBkSFBTE1q1brRCZIAhC7TA76Qbj1cib+8EKjYdCocDf35+EhATOlYMesLe3x8PDw9qhCbXk4sWLFBQUICuU4Pzn+yy7eiOV5nP06FGRdNfQvHnzrB2CIAhCvZOens6oUaOq3e7k5CQK8gqC0KiYtUD3zJkz/Pzzz9VuX7FiBWfPnjU7KKF+8PT0BOCKznjbw8ND9OhupPR6Pb/99hsAsne7P/t0A7JPGGBsFXjt2jVrhCcIgiA0Ig4ODrct0JmcnIybm1vdBSQIglDLzBrp/vXXX2874pmTk8Ovv/5Kx44dzQ5MsD693jin/MbMcgwGQ/U7Cw2WLMv88MMPxMXFgUKFHPCX0WxnD+TmreD6VT799FNef/110VaqGvv37zfrcQMHDrRwJIIgCPVXREQEu3fvrrILTlJSErt37+a+++6zQmSCIAi1w6yk+9q1a/Tu3bva7W3atCE6OtrsoATrKyoq4tKlSwD0soVrOmN1+vT0dLy9va0cnWApZWVl/PTTTxw8eBCQ0Ifd92cRtZsYQvqjOJ1Pbm4uH3zwAbNmzaJly5Z1H3A9t2TJErMeJ5JuQRCakkceeYS5c+fyz3/+k27dugGwb98+9uzZw9GjR2nWrBkPPfSQlaMUBEGwHLOSbp1Oh06nu+32srIys4MSrEur1bJkyRIKCwtxVUCYDQSWQaJO5j//+Q+vv/46zs7O1g5TuEepqal8+eWXpKamAmBo2xeat6p6Z7Udho4jUZzeRGZmJgsWLOCRRx5h0KBBYsnBTT7//HNrhyAIglDvubu7895777FixQoOHToEwIEDB7Czs6Nv375MmzbNrKK869at49ixY6SkpGBjY0NISAiPPvoovr6+pn3Ky8tZvnw5hw4dQqvVEh4ezowZMypNZ8/Ozubrr7/m3Llz2NnZMXDgQKZOnWpqpyoIglBTZiXdAQEBHDt2jLFjx96yTZZljh49ir+//z0HJ9S9ixcv8uOPP5KWloatBI85gVqSmOwk898CyMzM5K233mLy5MlERkaKhKsBKisrY/PmzWzbtg29Xo9sY48h9D5w8739A+2cMHR9EMWl/ehykvjxxx+Jiopi2rRpogL3DRV1EARBEITbc3V15W9/+xt/+9vfKCgowGAw4OLigkJhVrkhAM6fP8+IESNo06YNer2eFStW8O9//5vFixdjZ2cHwPfff090dDQvvfQSDg4OLF26lI8++oh3330XMC6lW7hwIW5ubvz73/8mNzeXzz//HKVSydSpUy3y2gVBaHrMOrONHDmSS5cusXjxYq5du4Zer0ev13P16lUWL15MbGwsI0eOtHSsQi3KyMjg66+/5oMPPiAtLQ1HCaY6gbfKmFQ7KSQedwYPBRQUFPD111/z4YcfmlpMCfWfLMucPHmSN998k82bNxsTbvcADF3H3znhrqC2w9BhOIagSFAouXTpEvPmzWP16tWUlpbW7gto4JKTkzl58iQnT54kOTnZ2uEIgiBYzZIlS7h8+bLptouLC25ubqaEOy4uzqzlOnPnzmXQoEEEBATQunVr5syZQ3Z2tumzSklJCXv27OGJJ56gY8eOBAUFMXv2bC5dukRsbCwAp0+fJjk5meeff57WrVsTERHB5MmT2b59+21neQqCYPysKVTNrJHuAQMGkJGRwa+//srRo0dNJ0mDwYAkSUycOJFBgwZZMk6hlsTHx7Nt2zZOnjxp7CkM9LSFofZgr6g8iu2llHjOVeaABvaXGkfFFyxYQEhICCNHjqRTp073dIVaqD2ZmZn8/PPPxMTEACDbOmFo0xuat4SazlaQJGT/Tug9WqOIP4Lh+lW2b9/OsWPHmDx5Mt27dxczIG4SFRXF8uXLyczMrHS/l5cXTzzxBN27d7dSZIIgCNaxf/9+OnfuTNu2bavcnpmZyf79+5k9e/Y9HaekpAQwtiADSEhIQK/X06lTJ9M+fn5+eHh4EBsbS0hICLGxsbRs2bLSdPMuXbrwzTffkJSURGBg4C3H0Wq1aLVa021JkrC3tzd931Q15dfeVEmSJN73apjdp3vSpEn079+fY8eOmT5MtmjRgh49eohCWw3AxYsXWb9+venKLkA7NdxnD/6q6n9ZVJLEffYQbiOztxTOlENsbCyxsbH4+vrywAMP0K1bN5F81xOyLLNjxw7Wrl1rvEIvKTD4d0Ju2QWU6nt7cjtnDB2GQU4SirjD5Obm8t///peOHTvy9NNPm7Uer7GJjo7mo48+wtPTkylTppiW3SQnJ7N7924+/PBD/vWvf9GlSxfrBioIglCP5OTkYGNjc0/PYTAY+O6772jXrp2p8GdeXh4qlQpHx8oFQ11dXcnLyzPt89d2Za6urqZtVVm3bh1r1qwx3Q4MDGTRokVNesmRjY0NPj4+1g5DqGOSJIn3vRpmJ90A3t7ePPDAA5aKhfPnz7NhwwYSExPJzc3l5ZdfpmfPnqbtsiyzevVqdu/eTXFxMaGhocyYMeOOb+62bdvYuHEjeXl5tGrViunTpxMcHGyxuBuSy5cv89tvv3Hx4kUAlEC4DfSzN45k3y13pcREJxhqkDmsgagyY2Gu//73v/j5+TFu3Di6du0qrnZZkUaj4dtvv+X48eMAyG6+GIL7gIObZQ/kHoChuw9S0hkU105z9uxZ3nnnHebMmVPliEBT8uuvv9KqVSvmz59vWk8I0L17d0aOHMlbb73FL7/8IpJuQRAavaioKKKioky3d+3axZkzZ27Zr6SkhJiYmHv+nLZ06VKSkpJ455137ul57sb48eMr1Tmq+OyTlZXVZKekl5WVkZaWZu0whDomy3KTe99VKtVdXWAzK+kuLS2luLi4Uq/unJwcdu7ciVarpVevXmadLMvKymjdujWDBw/mww8/vGX7+vXr2bp1K3PmzMHLy4tVq1axYMECFi9eXO0V0UOHDrF8+XJmzpxJ27Zt2bx5MwsWLOCTTz4xXblsKtauXcvmzZsBY7LdwxYG2IOLwvzE2FUhMdIBBtrJHC6DgxpISUlhyZIldO3alVmzZolRbyswGAwsXryY+Ph44+h2m17IPmE1n0p+txQq5FZd0XsGoji3i9zcXN577z1ee+01WrduXTvHbACuXbvGlClTKiXcFezs7Bg0aBArVqywQmSCIAh1Kzk5mSNHjphuX758+Za6MJIkYWtrS1hYGI8//rjZx1q6dCnR0dHMnz+f5s2bm+53c3NDp9NRXFxcabQ7Pz/fNLrt5uZGXFxcpefLz883bauKWq1Gra569lhTXeMqSVKTfe1NnXjfq2ZW0v3VV1+RlZXFggULAONVyblz55KTk4MkSWzdupXXX3+dDh061Oh5IyIiiIiIqHKbLMts2bKFCRMm0KNHDwCee+45Zs6cSVRUFH379q3ycZs2bWLIkCHcd999AMycOZPo6Gj27t3Lgw8+WOVjGuPanCNHjpgS7u62MMgO3Gowsn0n9gqJwfbQ21bmoAb+0Bin1m7cuLHa/2eh9hw7doz4+HhkpRpDx5Hg2qJuDuzQDEPEOBTnd6PLS+GXX37hlVdeabC/N/dKrVZTVFRU7faioqJqP6gJgiA0JuPHj2f8+PEATJ48mVmzZtGvXz+LHkOWZZYtW8axY8eYN28eXl5elbYHBQWhVCqJiYmhV69egHGWXnZ2NiEhIQCEhISwdu1a8vPzTYMzZ86cwd7eXnTmEQTBbGYl3ZcuXWLo0KGm2wcOHCA3N5d3332XgIAA3nnnHdauXVvjpPt2MjMzycvLo3Pnzqb7HBwcCA4OJjY2tsqkW6fTkZCQUCnpUygUdOrUqdJa5r9qbGtzDAYDP//8MwCRtnC/Y+0lQPYKiaEO4KSQ2VQCGzZsYNKkSZVmRQi17+DBgwDI/p3rLuGuoLLBENIPZdRqLl68iMFgaLIfVDp27MiWLVvo0qWL6QNdhcuXL7N169ZK5zRBEISmYNWqVbXyvEuXLuWPP/7g1Vdfxd7e3rQG28HBARsbGxwcHBg8eDDLly/HyckJBwcHli1bRkhIiOkcHR4ejr+/P59//jnTpk0jLy+PlStXMmLECHGR9A5unkpvMBisGIlgLXq93toh1FtmJd0FBQW4u7ubbh8/fpzQ0FDTCWvgwIH88ssvlonwhooT51+nhN9c/KKqOA0Gwy3Tgdzc3EhNTa32WI1xbU5QUBBnzpzhshZy9TLNLDjK/VclBpmz5cbvvb29KS0tbXLrO6ztXgvQ3DNJAbKMJEkUFRU1qPf/btfm3I1HH32UuXPn8uabbxIcHIyvr7E1W2pqKnFxcbi6ujJt2jSLHEsQBKGp27FjBwDz5s2rdP/s2bNNXXWeeOIJJEnio48+QqfTER4ezowZM0z7KhQK/vWvf/HNN9/wxhtvYGtry8CBA5k8eXJdvYwG6+Z2mNV9Nhcan5tbxsqyjMFgEEtLq2BW0u3o6Gj6ZSovL+fixYumKUNgPGGVl5dbJEBraIxrc55++mneffddsrOz+SQfetjKDLQH53tYz/1XZbJxavlBDZTJYGtry5w5c1AqlQ32/62hCg8P59SpU0gpMcgercDR/c4PshSDAcXlPwDjLBEXF5cm+/57eXnx4Ycfsm7dOk6dOsWhQ4cA8PT0ZPTo0Tz44INNrraEIAgCwMmTJ9m0aROJiYmUlJRU+XeipiPiq1evvuM+NjY2zJgxo1Ki/Veenp689tprNTq2ABcuXDB9n5WVRXZ2tpjp2AScO3eu0u0rV64QFBRkpWjqL7OS7pCQEHbs2IGfnx+nTp2ivLzctM4aIC0trdJIuCVUjFbn5+fTrFkz0/35+fnVFmpycXFBoVDccrWtqnYQjZ2TkxP/+Mc/+PHHH7lw4QJHyuBEGUTayfSzA6d7SL7LZJljGjiggZIbfzP9/f159NFHTSN7Qt3q3bs3Bw8eJC4uDkXMNgzhY8C+DpI72YAU+ztSThJqtVqMDGCcjfPkk09aOwxBEIR648iRI3z88ccEBATQp08fdu7caVomGBUVhY+PT6XPlUL9J8syhw8frnTf4cOHuf/++60UkVBXTp48ecttkXTfyqyx/0cffRSlUslHH33E7t27GTt2LAEBAYBxDceRI0cICwuzaKBeXl64ubkRExNjuq+kpIS4uLhb1kpWUKlUBAUFcfbsWdN9BoOBs2fPVvuYxszb25uXX36Zl19+maCgILQYC559mAebi2UKDDUbjdQYZPaVynyYB9tLjQl3ixYtePbZZ3n77bdp27ZtbbwM4S6o1Wqef/55fH19kcpLUJzaBEXXa/egBj2KC3tQZMahUCiYNWtWk23NV2H79u0UFBRYOwxBEIR65bfffiM4OJj333+fhx9+GIDBgwfz97//nY8++ojc3NxbiqAJ9du1a9dISUlBBYxxMN536NChJjvTrakoKyszJd0GX2Mtr6ioKLGmvwpmjXR7e3vzySefkJycjIODQ6UTY1lZGdOnT6dVq1Y1fl6NRkN6errpdmZmJleuXMHJyQkPDw9Gjx7N2rVr8fHxwcvLi5UrV9KsWbNKV0PfeecdevbsyciRIwEYO3YsX3zxBUFBQQQHB7NlyxbKyspMa3uaorCwMF5//XViYmLYuHEjCQkJHC4z9toe7SDT0+7Oo96x5TK/FEPpjXNpixYtGDNmDL169UKpVNbyKxDuhpOTEy+//DIff/wxSUlJKM5sxtBlHDjUwoi3LKO4sAfp+lVUKhXPPvss4eHhlj9OA7Ns2TK+++472rdvT9++fenZsydOTk7WDksQBMGqkpOTmTp1KgqFwvSZoaJmjpeXFyNGjGD9+vUMHDjQmmEKNbBnzx4AQm2gqy3sKDF+jj979iydOnWycnRCbdm2bRtlZWXItk7Igd2RM2LJysri4MGD9O/f39rh1StmJd1gHEWualq3vb292VOC4uPjmT9/vun28uXLAWNhtjlz5jBu3DjKysr46quvKCkpITQ0lNdff71S0aiMjIxKI0t9+vShoKCA1atXk5eXR+vWrXn99deb3PTyv5Ikic6dO9OpUyfOnz/Phg0biIuLY0MJpOplxjqAqoo2T7Is87sGdpWCDPj4+DB27Fh69uwpiibUQ66urrz66qt8/PHHJCQkoLiwB0PEA6Cw7IURKeUs0vWrqNVq/v73v9O+fXuLPn9D9fHHH3Po0CEOHz7MV199xTfffEOnTp3o27cv3bt3x8HBwdohCoIg1DlbW1tUKuNHUEdHR1QqVaWlgK6urmRmZlopOqGmDhw4wB9/GGu59LQFW0miq63M0TJMBekaagcgoXrnzp1jy5YtAMhBPUGpRm4ZgZR4jNWrVxMQEFDtEuCmSJLFvI+7lpWVVal/d2MiyzJbt25l7dq1yLLMSHvoZ39r0n2pXOaHG22HBw4cyJQpU0QLjQYgNzeXefPmUVRUhKFNL2S/jpZ7cq0G5ZGfQTbw2GOPNfhZJGq1ulY+HCQlJXHw4EGOHDlCWloaKpWK8PBw+vbtW2XLw4akMZ8bq/P000+bvl+6dKkVIxHq0pw5c9BoNEDTe98teW588803CQwMZPr06QDMnTsXW1tb5s6di16vZ8GCBeTn5/PJJ59Y5HjW0tjPjQaDgc2bN7NhwwYMBgOD7WHwjc+OWlnmmwJI0RvrMs2cOZPQ0FArRyxYgizLbNu2jV9//RVZlpHdAzB0GA6SZCyme2oDUlE2KpWKxx9/vMF/xrmTuz03iqFJATCOfI8ePZoRI0YAcL2apRg5N+7v1KkTjz/+uEi4G4hmzZpx3333GW+U5Fn2yTWFIBtb84mpgNULCAjgkUce4ZNPPmHRokWMGTOGc+fO8dlnn1k7NEEQhDrVo0cPoqKiTAnphAkTOHfuHE8++SQzZszg4sWLPPjgg9YNUrit/Px8PvzwQ3777TcMBgPdbOE+uz+3qyWJac7goTAWMP7www9Zu3atWOvbwGm1Wr7++mvWrFljbA/mHYKh/VBjwg2gUGDoPBrZPQCdTseyZctYtWqVeN+5h+nlQuOTkJDAsWPHAKhuWbftjfsvX75MdHQ0Xbt2raPohHtVXFxs/EZv4V7zN55Pp9NRXl6Ora2tZZ+/kbl69SqHDx/myJEjaDQa6/dUFwRBqGMPPPAADzzwgOl2t27dmDdvHkePHkWhUNC1a1c6drTgjCzBorRaLZ999hmJiYnYSHC/A0TY3vrB0UUhMdtVZnMJnCiT2bx5M3Z2dowePdoKUQv3Kj8/n88//5yEhASQJAxteiP7hP2ZcFdQ2WDoMBzpajSKayfZsWMHaWlpPPvss9jb21sn+HpAJN0CpaWl7N69m40bN6LT6fBQQGQ1eVNHG2OrsasaDV988QWDBw9mzJgxTX6NfH2XkpLCvn37AJC92lj2yV08kW2dKCoqYsOGDUyaNMmyz98IJCcnm9Z2p6ammqaWP/zww3Tv3t3a4QmCINQZrVbL6dOn8fT0rFR0NywszOKdbwTLMxgM/PTTTyQmJmIvwTMu4KmsvgCvjSQx3hF8lDKbSmDt2rX4+fmJYqsNTGZmJosXLyYrKwtZZYshbAg0u01bYElCbt0Ng2MzFJf2ExMTwwcffMCLL76Ii4tL3QVej4ikuwkrKipi165d7N69m5KSEgDC1DDREeyq6dttI0lMd5bZXgKHyozVKn///Xf69+/PyJEj8fDwqMuXINyF7OxsPv74YwwGA7J7ALgHWPYAChWGNr1Qnt/Ftm3b8PLyEtPMb1izZg2HDx8mOTkZhUJBp06dGDduHD179hRF1ARBaJJUKhWLFy/mySefNKvTjWA9xcXF/O9//zO14n3I8fYJ980ibSFFByfLZT777DMeeughRowYgVRF0V6hfrlw4QL/+9//KCgoQLZzxtBx5F13wpE9g9DbOaM4u52rV6+ycOFC/va3vzXJ332RdDdBRUVF7Nixg127dlFWVgaApwIG2EO4DSjucAJUShKjHaGtjczeUrim07F3715+37+fPn37MnbsWJF81xNFRUUsXryY3NxcZHtXDCEDaudAHq0x+HdGkXyGH374AUdHRzGCC/z666+0b9+eUaNGERkZibOzs7VDEgRBsCpJkvDx8aGwsNDaoQh3yWAwcOTIEdavX092djZqYLwjtLO5+4RZkiTGOcpIQHS5zC+//MKFCxeYMGFCk0zAGoLCwkJWr17NoUOHAJAd3TF0Ggk2NRw0cPbEEH4/ipitZGZm8u677zJs2DDGjRuHnZ3dnR/fSJiddJ88eZJNmzaRmJhISUkJVRVBX7Vq1T0FJ1hWaWkpO3bsYOfOnZSWlgLgo4SB9tBefedk+6/aqiWCVTKJOthfCvE6AwcOHODQoUMMGDCAMWPG0KxZs9p4KcJd0Ol0LFmyhIyMDGRbJwydR4NN7a2lkQN7YNCXo0i7yDffLL1l6mBT9N///hdX11roiy4IgtCAjR8/nu+//57evXvj63ubKaqCVcmyTFRUFBs2bCAtLQ0ANwVMdQJfVc1HqFWSxHhHGV8VbCmBs2fPcvbsWbp27cq4cePw9/e39EsQzHT+/Hn+97//mS6OGXzCkAN7gMrMOjQOrhgixiHFH0aRlcCOHTuIjo5m9uzZTeazollJ95EjR/j4448JCAigT58+7Ny501QOPioqCh8fH7N7dQu1o7S0lIULF5KSkgKAtxKG2EOomnua2iNJEkFqCFLDNa3MrlJI0OnZu3cvx48f54033hCj3layY8cOLl26hKxUY+g4Amwda/eAkoQc3AdZU4Q2N5mvvvqKBQsWNOmpYyLhFgRBuFVsbCzOzs7885//pH379nh6et5SVFKSJJ566ikrRSgAbNu2jTVr1gBgL0E/O+hlZ+zDbS5JkuhlB8Fq42zJM+UQHR1NTEwMb731lrgIY2W3tANzaIYhpB+4tLj3J7exRw4bjL5FWxSXD5Kdnc3ChQt57LHHGn1bMTAz6f7tt98IDg7m3XffpaioiJ07dzJ48GA6duxIZmYmc+fOxcvLy9KxCmaSZZlly5aRkpKCkwRjHc0b2b6TlmqJ6WpI0BqLZWQWFvL555/z2muviYrWVhAdHQ2AHNgTHOtoxoGkwBB2H4ojP5ORkUFKSoq4ci0IgiBUsn37dtP3FeuDqyKSbuspLS1ly5YtAPS1g/vswc6Cnxs9lBKTnGCgXmZdESRptWzevJmZM2da7BhCzR04cMB0ocXQoi1ycF9QWng1snsAhm7jUVzchzYniWXLluHq6troOxaY9b+YnJzM1KlTUSgUKJVKwDiVFcDLy4sRI0awfv16UUypnkhJSTElYPc7QocarMExR5Ba4hEnmU/zISkpiVOnThEZGVmrxxQqk2WZq1evGr93qeMLYCpbcHCDoutcuXJFJN2CIAhCJWL5Yf139OhRSkpK8FDACHvLD9RU8FJK3O8os6TAeMyHH35YzBKzEoPBwLZt24zft+yC3Krbre3ALEVla2wrFnsARUYs27Zta/RJt8KcB9na2qJSGfN1R0dHVCoVeXl5pu2urq5kZmZaJEDh3nl7e5vWS+wthQzdrevvLSnfILPVWAwdV1dX0QLECiRJom3btsbv0y/V7cELs5GKrleKQRAEQRCEhuP48eMAdLOtvYS7gq9Kwk9pHDA4depUrR5LqN7BgweNdYCUamT/zrWXcFeQJORWXUGSuHDhwm1nvTQGZiXdvr6+JCcnm263bt2a33//Hb1eT3l5OX/88YdYx1uPqFQq5syZg7OzM+l6+LwAVhXJZOotm3wXGGQ2FcsszoPLWuNxn3vuuSbbj8/aRo0aBYAi9TzSleNQRbFDiyvMQnHWeJW0a9eutGhhgTVAgiAIgiDUmePHj3PhwgUA2ptZN6umOtw4zvr168nPz6+bgwomFZXKAeSWEeYXTKspOycMPu0B+OGHH9BqtXVzXCswK+nu0aMHUVFRpv+YCRMmcO7cOZ588klmzJjBxYsXefDBBy0Zp3CPmjdvzmuvvUa3bt2QgZhy+CwfVhbJpNzjyPd1vczGG8n2kTLQAyEhIbzyyisEBQVZInzBDBU9oQEU104hXdoPuvJaO56UGY/y9GYkrYZWrVrx2GOP1dqxGoKysjKmT5/Ohg0bLP7c58+f57333uPZZ5/l4Ycf5tixY5W2y7LMqlWreOaZZ5g2bRrvvvuuqfJshaKiIj799FOeeOIJnnzySb788ks0Go3FYxUEQRAajry8PL799lsABthB87vsw32vetmBlxLy8/P57rvv6uSYwp/i4uKM3ajsXJD963aatxzYHVlpQ3Z2NqmpqXV67Lpk1pruBx54gAceeMB0u1u3bsybN4+jR4+iUCjo2rVro5+X3xC1aNGC2bNnk5SUxIYNG4iOjuZsOZwthyCVTH87CK5BNfMUncwBDZwrh4q0PTg4mHHjxhEWFtakq1bXFw888AAuLi78+OOPKDLjkAsyMYQOAkuu89aVI8UdQpEZB0D79u2ZPXs29va1156sIbC1tUWpVNZKEcGysjJat27N4MGD+fDDD2/Zvn79erZu3cqcOXPw8vJi1apVLFiwgMWLF5sqBH/66afk5ubyxhtvoNfrWbJkCV999RUvvPCCxeMVhMaiqvaogtCYFBYWmi7A9q3DFso2kkQvW5kNJYglqlZQUaMLlRoks8Zk7+HgalAoQH9THI2QxcrRhYWFibW7DURAQABz5swhKSmJ7du3c+zoURJ0BhKKoI0KHnSUaXabK5ulN9ZsR980aNqpUydGjhxJu3btRLJdzwwaNAgfHx+++eYbcnJyUJ7eiCEwEtmvw72v1ym6juL8biRNAZIkMXbsWO6///5GfdKsicjISI4cOcLw4cMt+nsRERFBREREldtkWWbLli1MmDDB1LrxueeeY+bMmURFRdG3b1+Sk5M5deoUCxcupE2bNgBMnz7d1LrD3d3dYrEKgiAIDYe/vz++vr6kpqYSU24cga4rp298ruzVq1fdHVQA+PPvfkk+GPSgqMPPcWXFSFoNkiTh5uZWd8etYxauAS80JAEBAcyYMYPx48ezc+dO9u3bR7xWy2f5MNxBJtL21lHvC+Uy64uhSDZui4yMZOTIkQQEBFjpVQh3o127dsybN48ffviBqKgoFAlHMBRmIIcMMF5hNIOUcRnF5T/AoMfd3Z1nnnlGFE77iz59+rB06VLmz5/PkCFDquxFC1h0GUZmZiZ5eXl07tzZdJ+DgwPBwcHExsbSt29fYmNjcXR0NCXcYLxwJkkScXFx9OzZs8rn1mq1ldZbSZJkmtHQlC+2NeXX3pSJ911ojCRJYtCgQfz8888c1EBPW7nWC6kBJOlkruqMI539+vWr9eMJlfn5+eHi4kJBQQHkpkDzlnV2bOn6NcBYI8zJyanOjlvXzE66f//9d/bu3UtmZiZFRUVV7vP999+bHZhQd5o3b84jjzzCoEGD+O6777h8+TKbSsBOgi43zYxN1sn8XGScSu7j48MTTzwhkqwGxNHRkWeffZa2bduycuVKyEpE1pZh6Diixlc0pfRYFLG/A9CxY0dmzpzZqE+U5po/f77p+4qiNFWxZPucik4Sf2254urqatqWl5d3S4FDpVKJk5NTpU4Uf7Vu3TpT/06AwMBAFi1ahKenp0Vib6h8fHysHYJQRxSKP6ddivfdfM899xxPPvkk3bt3r3L7iRMn+Pbbb/n888/rODIBoF+/fmzYsIHcoiIuaSGsDmpqHblRUqRXr140a9as9g8oVFIxkLZz504UyTEY6irplg1IKTEA1V7wbyzMSrp//PFHNm7ciLu7O23atMHBwcHScQlW4O3tzauvvsqvv/7Ktm3b2FYCoTYydpKELMtsLDYm3F27duWZZ55BrTZvhFSwHkmSGDJkCC1btuTjjz+mLC8VKfYAcruBdz/VPDcFxeUDAAwdOpTJkydX+iAq/GnWrFnWDsGixo8fz9ixY023K0b6srKy0Ol01grL6v5apE5ovG5e093U3neVSmWxC2xZWVm3Ldyo0WjIysqyyLGEmrO1taV3797s3LmTM+W1n3SXyzIXbkwtHzhwYO0eTKjW8OHD2bNnD/r8NLh+FZq3qvVjSqkXkEoLcHBwYMCAAbV+PGsyK+nevXs33bp14+WXXxYfthsZhULBgw8+yB9//EFRURGpOghSQ7EMKXrjPlOmTBEJdwPXtm1bZs2axaeffgqZceh9299dcTVZRhF/BGSZXr16iYT7DgYNGlTnx6xYD5Wfn19ptCA/P5/WrVub9ikoKKj0OL1eT1FR0W3XU6nV6mp/95tygamm/NqbMvG+1574+HgcHR2tHUaT1qtXL3bu3Mm5cuNMR39V7U0x31cK5YCHh4foemNF7u7uDB8+nK1bt6K4fBCDSwtQ1+Ki/tJCY0tbjBf17ezqsICAFZg9vTwiIkJ82G6kysrKKC4uBsDjxqxjB8k43VwjQ05Ojii01Ah06tSJXr16cejQIaS0C8h3k3QXZCCV5GJjY8O0adPEOaAGcnNzyc/Px9vbu1b/sHh5eeHm5kZMTIwpyS4pKSEuLo7hw4cDxpZ+xcXFJCQkmD7gnD17FlmWCQ4OrrXYBEFourZs2cKWLVtMt7///nvjUqe/KCkpobi4WKzrtbLWrVubWgSvLYY5LjLKWljbXdEJB+Dhhx8WtRKs7IEHHiA6OpqMjAwUF/Zi6DSidqqZ67Uozu9E0mtp27atVQYp6ppZ/4vdunXj4sWLlo5FqAdkWebnn39GlmW8lOCiMJ78FJJE8I0BrhUrVjTpqaSNSUV1a6kw+672lwqN0/06duwolpXcpaioKF588UX+9re/8X//93/ExRlbqxUUFPDqq6/e0mP7bmg0Gq5cucKVK1cAY/G0K1eukJ2djSRJjB49mrVr13L8+HGuXbvG559/TrNmzUzvt7+/P126dOGrr74iLi6OixcvsmzZMvr06SMuqAmCUCtcXFzw9/fH398fMI6qVdyu+BcQEEDnzp2ZNm0azzzzjJUjFh599FGcnZ3J1EN0We0cY3uJceliz5496datW+0cRLhrNjY2zJo1CxsbG6S8FKQr0bVyHCnuEFJxDi4uLjzzzDNNYhDHrJHu6dOns2jRIpYuXcp9992Hh4dHlf9ZorBSw3P48GFjv3Xgwb/kVCPtIV4LV65cYd26dUyaNMkqMQqWY5q+p9fefscKel3lxwm3dfz4cT788ENCQkLo168fv/zyi2mbi4sL7u7u7Nu3r8bFQ+Lj4ysVaVu+fDlgXAs3Z84cxo0bR1lZGV999RUlJSWEhoby+uuvV6qc/ve//52lS5fyzjvvmAqoTJ8+/R5fsSAIQtX69etnGr2eP38+EyZMoFOnTlaOSrgdJycnxo4dy4oVK9inga62lh3tvqKVSbhRsXzixIkWe17h3gQEBPDUU0/x1VdfoUg+g75FMDi4We4AeWkoMi4jSRKzZ89uMhf7zUq6bW1tCQkJYcOGDezYsaPa/SxZkVeofenp6fz4448A3GcPLdWVT6xuSokHHWVWFMG2bdsICwujY8eO1ghVsJCyshuXrpV3eSq40X+7vLz8DjsKAL/++ivt27fn7bffprCwsFLSDcZp3jt37qzx83bo0IHVq1dXu12SJCZPnszkyZOr3cfJyYkXXnihxscWBEG4F2VlZTg4ONy2U4JQfwwcOJCNGzeSX1REgg7aWrCkT8Xoee/evfHw8LDcEwv3rEePHhw6dIiYmBgUiVEYOgyzzBPLMoqEI4DxZ6spdUEyK+leunQpu3fvJiQkhODgYDHNtJFYtWoVZWVlBKlgYDVLTjvYSPS0lTlWBj/88APvvfeeWH/TgJmKaant7+4BauPven5+fi1F1Lhcu3aNJ554otrtrq6utxQ0EwRBaMxsbW05e/YsERER1g5FuAtqtZqePXuyZ88e9pdCG5Vl+nZn62Vibly/79Onzz0/n2BZFRfvz549a6xkXpwDjhYYkc5NRiq6jo2NDQ8++OC9P18DYlbSffjwYQYMGMCcOXMsHY9gJaWlpZw7dw6AsY7c9oQ60gFOlkF2djbXrl2jVavabykg1A6t9sa08rsc6ZZv7CfW9N8dW1vb27bFycjIEMtwBEFockJDQ4mNjWXo0KHWDkW4C8OGDePgwYNcKStjnwYG3+V1+uroZJlVRaAF2rVr16RGOxsSHx8funXrxvHjx1FcPoQhfPS9FVXT64wdcDB2d3F2drZQpA2DWf9zSqVS/II0Mmlpaej1emwl8LzDT4WNJNHiRlXzpKSk2g9OqH132fpGkg21HEjj0qFDB/bv349er79lW15eHrt37yY8PNwKkQmCIFjP9OnTuXjxIitXruT69evWDke4Ay8vLx5//HEAfi8FjeHe2uWdLYc0vXGZ08yZM5tEEa2G6qGHHsLW1hapIB0p+ew9PZeUeAypNB83NzfGjBljoQgbDrNGuvv06cOJEydM7WeEhs/f3x9bW1vKyspI1kPAbX4yig0yaTdyCNFeqGHz8rrRJqwk7+4eUJJf+XHCbU2ZMoW5c+fy2muv0atXLwBOnTrF2bNnTWu5H3roIWuGKAiCUOdeeeUV9Ho969atY926dSiVStTqWxcLf//991aITqhKZGQkmzdvJjU1lfNa6Gpr/nOduTGtfPDgwTRr1swyAQq1wtPTkylTpvDdd98hJZ9B9usACmXNn0irQUozdr566qmnmuQsP7OT7m+//ZaFCxfetnq5aHDfcNjY2NClSxeOHj3KumL4m4uMTRVTzA2yzNpi0GOsbujt7V33wQoWExAQgEKhwFBWBKUFYO9y2/2lvFQAWrZsWRfhNXi+vr688847fPfdd6bCkhs3bgSgffv2PP300+IChiAITU5kZKSoB9PASJJEREQEqampXNPdW9J97cYKNbGuv2Ho06cP69atM9bzyUkGj5ovK5Uy45FkA61atWqyRZjNSrrffvtt0/enTp2qdj9RvbxhmTx5MhcvXiQzP5/1xfCQo3zLH8XfNXBJCyqViqeeespKkQqW4uDgQEhICBcvXkTKvoIc0Ln6nctLkfLTAfGHsiYCAgJ48803KSoqIj09HVmWadGiBS4ut7/AIQiC0FiJmkANk6enJwD597DSrEyW0ciVn0+o35RKJR06dODQoUNIJbnImFHLqSQXoEm3CTQr6Z41a5al47hrc+bMISsr65b7hw8fzowZM265f9++fSxZsqTSfWq1mp9++qnWYmyoXF1defbZZ/nwww85XW7AVwV9b6pifqlcZnep8fupU6eKAmqNRPfu3Y1Jd1bCbZNuKfsKINO6dWvR2sMMTk5OYjmGIAiC0GApb7QNvZcl3TeXkFGpzEpDBCswTQfXlZn3BDce1xSnlVcw66d90KBBFg7j7i1cuBCD4c9LbNeuXePf//43vXv3rvYx9vb2/Oc//6mL8Bq8du3aMXnyZFasWMH2EminlvFQSpTJMr8Wg4yxr97AgQOtHapgId27d+fnn3/GUJQNmiKwq/qEKGUnAsbejcLdKygo4LfffuPkyZOmC4aenp5ERETwwAMP4ObmZt0ABUEQrOT69eskJiZSUlKCXEVBT/FZo34pKioCwOEe6p7ZSMYqzoYbzyfWdDcMpvbQunKzHi/pjN1yHB0dLRVSg3PPl5g0Gg3Z2dkAeHh4YGdXTYNnC/nrlMzffvuNFi1a0L59+2ofI0mS+GBbA0OGDOHs2bPExMRwQAPjHeG4BkpkYwGtqVOnWjtEwYKcnZ0JCAjg6tWrUJRVddIty1Bk/D2/3e+aUFlSUhLvvPMOBQUFBAcHm4qppaWlsXnzZg4cOMCbb74p1sgLgtCklJeX88UXX3D06NEqk+0KIumuXyouHLvdQ9KtkCRcFDJ5BuPziaS7YTB1YTG3i82Nx1XVzaWpMDvpjouL46effuLixYumkWeFQkFoaCiPPvoobdq0sViQ1dHpdBw4cIAxY8bctiCHRqNh9uzZyLJMYGAgU6ZMISAgoNr9tVrtn/2LMSbt9vb2pu8bO0mSGDVqFDExMZwvNybd5278dwwfPrzKCqNCw+bj48PVq1eRSgqo8uOPrgzpxtVNX1/fJvF7YAlLly7FYDCwYMGCW6aWx8XFsXDhQr799ttKdTIEQRAauxUrVnDs2DEeeeQRQkJCmD9/PnPmzMHNzY0tW7aQm5sr1n3XM3q9nnPnzgHgYUbx6pt5KSHPADExMYSEhFggOqE2ybJseu9xNq/4q+zsiZSXSkxMDP3797dgdA2HWUn35cuXmTdvHiqVisGDB+Pn5wdASkoKBw8e5O2332bevHm1vn7x2LFjFBcX33a6u6+vL7NmzaJVq1aUlJSwYcMG3njjDRYvXkzz5s2rfMy6detYs2aN6XZgYCCLFi1qUgUfNBoN8Gcj94qvfn5++Pj4WCUmofZUrNNCVc0FFcWfp4rmzZs36elBNREXF8f48eOrPBcGBwczatQofvvtt7oPTBAEwYqOHDnCoEGDePDBByksLATA3d2djh070rlzZ+bPn8/27duZOXOmlSMVKuzevZuMjAwcJOhgc2/P1cMWYrWwa+dO+vbtKzrh1HN79uwhISEBJAnZvfpBy9uRm7eCpNOcOHGC6OhounbtauEo6z+zku6VK1fi7u7Ou+++e8u07UmTJvHmm2+yYsUK3nzzTUvEWK29e/fSpUsX3N3dq90nJCSk0lW0kJAQ/vGPf7Bz504eeeSRKh8zfvx4xo4da7pdMaqXlZWFTqezUPT1W0Vbo4opRBVft2/fTrt27awUlVAbZFnm8uXLxu9tqkmmlSpklS2SroyoqKhG/TOgUqksdoHN1dX1tjNDbGxscHV1tcixBEEQGoqKJTdgPA/Cnxf7wdhS7NdffxVJdz2xc+dOU0ei++zB7h5nu4WqoZUKrmq1LFq0iJdeeum2M1AF6zl58qTpvTcE9qy27s8duXhh8OuIIuUsS5cuxdnZmbZt21ow0vrPrFUZly9fZtiwYVWuk3Zzc2Po0KGmD/G1JSsrizNnzjBkyJAaPU6lUhEYGEh6enq1+6jVahwcHEz/KqaWgzFBaez/4uPj2bFjB2A8uQIMtDf+sJw6dYrDhw9bPUbxz3L/rl69SmZmJrJCCc18q/29kJsb1x1HRUVZPeba/GdJo0ePZufOneTl5d2yLScnhx07djB69GiLHlMQBKG+c3V1NY1w29ra4ujoSGpqqml7aWkp5eXmFWwSLGvjxo2sXLkSgN62EHkP/bkrSJLEFCfwVhovwCxatMg4kirUKwcPHmTJkiXo9XoMnm2Q/e6tv7Yc2BPZ1QeNRsNHHy0mJibGQpE2DGaNdEuSdNuF8AaDodbXfO7duxdXV9caT08wGAxcu3ZN9BmuRnJyMh9//DF6vZ4wNYTaGN9HT6VEfzuZ/RpYtnQpDg4OdO58m57OQoOxZ88eAGT3lqCsflRW9mwDGZc5dOgQ48eP/7OSpVAtWZaxs7Pj+eefp2fPnqYpdGlpaURFReHt7Y0sy2zatKnS426eaSMIgtDYBAcHc/HiRdPtbt26sXHjRpo1a4Ysy2zevFms9bUyWZZZv369aebjYHu4z85ytY2cFBJPO8v8UATXSkv56KOP+Mc//iFaa9YDer2eX3/9le3btwNgaNEWOaQ/3Ot7r1Bg6DgCxfldaHOT+fTTT5k4cSIjRoxoErWCzEq627Vrx/bt2+nXr98t0zCzs7PZsWMHoaGhFgmwKgaDgX379jFw4MA/16Le8Pnnn+Pu7m6qsL1mzRratm2Lt7c3xcXFbNiwgaysrBqPkDcF169fZ/HixZSUlBCggkl/mUEyxB5yDXCm3MCSJUt45ZVX6qRgnlB7CgsLOXLkCACy/x2uYDbzQ3ZwQ1OSxx9//MHw4cPrIMKG7YcffjB9/8cff9yy/dq1a5X2qSCSbkEQGrPRo0dz+PBhtFotarWayZMnExsby+effw5AixYteOqpp6wcZdOVk5PDjz/+yOnTpwEYYQ/97S2fFNkrJJ5wlvmhEK5oNHzwwQc88MADjBgxQvTwtpKsrCy+/fZbLl26BIAhoDNy6x73nnBXUKowdBiGdPkPyLjML7/8Qnx8PI8++mijX25n1k/0lClTePvtt3nxxRfp2bOnqbBWamoqx48fR6lUMmXKFIsGerOYmBiys7O57777btmWnZ1d6WpJUVERX331FXl5eTg6OhIUFMS///1v/P39ay2+hqikpIRPPvmE/Px8WijhcSew+csvmEKSmOgoo5EhVqvl008/Ze7cuXh5mVfJULC+w4cPo9PpkJ08wKXF7XeWJGTf9khxhzhw4ADDhg1rElcm70XFB0hBEAThT6GhoZUGZzw8PPj444+5du0aCoUCPz+/WwZVhNpnMBj4/fffWfPLL5RqNCiBkQ7Q2672/tbbShKPO8usLoKLWh1r164lKiqKxx9/nKCgoFo7rlBZaWkpW7ZsYceOHcbPhUo1hpAB4Blo+YMplMghAzA4e6GIP0x0dDTnz5/n/vvvZ8iQIY22S5Ikm7mIMTk5mRUrVnDmzBnTuhsbGxvCw8N55JFHGmVSm5WVVamVWGPy22+/sXHjRpwleNYF3JTVn2DLZJmlBZCqN04Jmz17dh1GKljSe++9x+XLlzEE90H2vYv+27oyFId/RpL1LFiwoFFWHFWr1U2qU4ElNOZzY3Wefvpp0/dLly61YiRCXZozZ46p4FdTe9/FubHmGtK58cKFC6xcuZLk5GQA/JXGlrEtVHVzcV2WZU6Xw5YSKLmRmfTu3ZuJEyeKXt61SKvVcuDAATZt2kR+fj4AspsfhuA+4FAHI8+FWSjiDiEVGnvAe3l5cf/99xMZGdlgLrzd7bnR7Lkb/v7+vPLKKxgMBgoKCgBwcXFBoTCrNptgRbIsm6YYj3S4fcINxquS4x1lviiA06dPU1JSItb3NlBpaWkAyHca5a6gsgVHNyi6Tnp6eqNMugVBEITaV1JSwo4dOzh37hz5+fk888wzBAcHU1RUxL59++jevbv4G1MHkpKS+O233zh16hQAdpJxOWGkrXGGY12RJIkuthCsltleAifLjbPxTpw4wfDhwxk2bBhOTmZWzhZuUZFsb9myhdzcXABkOxcMbSLBvaXlppPfibMnhi4PIGVcRroSRWZmJkuXLmXTpk2MHTu2QSXfd3LPCyYUCkWVVcyFhkOv15OdnQ0YK0neDQ8lKAGdTkdOTo5IuhsgWZYpKSkx3lDVoOmmyli6tKioqBaiEgRBqL8s3eGgqbp+/Trz5s0jOzsbHx8fUlJSTDMInJyc2LlzJ1lZWWJddy1KSkpiw4YNREdHA8YONT1tjQXTHBTWWzrmpJCY6ASROpktJXCtvJxNmzaxe/duhg4dytChQ0XyfQ9KS0vZv38/O3bs+HNk28YRuWU4snc7UFghwZUkZO8QZM9ApJTzSMlnyMjIYOnSpWzcuJGRI0fSp0+fBj/t3Ow+3SdOnOCDDz6ocvurr75Kjx49mDRp0j0FJ9QNlUpFhw4dOHv2LCfKYPRd/FScKgM94O7ujq9v9W2mhPpLkiQ8PT3JyMiAknywc77zg2QZSo0n6RYt7nJ0XBAEQRBu8sMPP1BaWsoHH3yAi4vLLf24e/ToYUoGBcuRZZnY2Fi2b99uKpImAR1tjC1ive4w07Eu+askZjrLnNfC3lJILy1l48aN7Ny5kwEDBjBs2DDc3d2tHWaDUVBQwN69e9m1a5dpwMXqyfZfKdXGeHzDkNIuICWdITMzk+XLl7NhwwaGDx9O//79G+xAn1lJ95EjR+jZs2e12yMiIjh06JBIuhuQQYMGcfbsWQ6VgbdKpqtt9SfeK1qZzSV/Pk4sKWi4goKCyMjIQMq+gux+F3UYCrOQyopRqVSNsm6DIAiCUPvOnDnDmDFj8Pf3N/XrvlmLFi24fv16jZ/3/PnzbNiwgcTERHJzc3n55ZcrfV6VZZnVq1eze/duiouLCQ0NZcaMGaaCwGCcxbVs2TJOnDiBJElERkby1FNPYWdnZ96LrQf0ej0nTpxg+/btXLlyBai/yfbNJEmigw2EqWUuVCTfGg07duxg965d9OjZk+HDh9OqVStrh1ovybJMYmIiu3fv5vjx4+h0OuP99q7IAZ2RvYLrR7L9Vyob5IBwY/HetEtIyWfIy8tj9erVrF+/nt69ezN48GD8/PysHWmNmJV0Z2dn33aUy8vLyzRdWWgYIiIiGDVqFFu3buW3YnCUZNrZ3HoSTtfJ/FQEOqBr166MGjWq7oMVLKZ///4cPnwYKSseOaiHaep4daS0C4BxFMLe3r4uQhQEQag3RMcGyygvL8fFxaXa7aWlpWY9b1lZGa1bt2bw4MF8+OGHt2xfv349W7duZc6cOXh5ebFq1SoWLFjA4sWLsbExLrP69NNPyc3N5Y033kCv17NkyRK++uorXnjhBbNisqaioiJ+//139uzZY1q3qwK62kIfO/Cop8n2XyluSr4va+EPDSTqDBw5coQjR44QEhLC0KFD6dKlS6NZ/3svNBoNUVFR7Nu3z3SRBUB29sTg3wk8WoPUAAbMlGpk/47Gke+MOKSUGMpK8ti3bx/79u2jXbt2DBo0iIiIiAYx9dyspNvOzo6srKxqt2dmZjaIFy9UNmHCBHJzczly5AgriuBxZ5kg9Z8n5Gy9zHeFUCpDmzZtmDFjhhjlbuBCQkLw8/MjJSUFKfU8csuI6nfWFKHIjANg8ODBdRRh45SRkYFWqxWzBQRBaJL8/f25cOECw4YNq3J7VFQUrVu3rvHzRkREEBFR9d8xWZbZsmULEyZMoEePHgA899xzzJw5k6ioKPr27UtycjKnTp1i4cKFtGnTBoDp06ezcOFCHnvssQYznTk5OZndu3dz5PBhym9UT3eUINLOWCDN0Yprtu+FQpJoZwPtbCBFJ3NQA2fLITY2ltjYWNzd3Rk8eDD9+/dvcuu+K0a1Dxw4wNGjRykrKzPeLymRvYKMHWqcG2j3AYUS2acdsncI5KehSD2PdP0qly5d4tKlSzg5OdG7d2/69+9fr0e/zUq627dvz65duxg+fPgtJ6Ds7Gx27dpFhw4dLBKgUHcUCgVPPfUUpaWlnD59mlVF8KKrjL1CwiAbeygWyRAQEMCLL76Ire3tR0WF+k+SJEaPHs3XX39tTLoDwqu9+imlnQdZJjQ0VPTOvEtbtmwhNjaWF1980XTfkiVL2L9/PwCBgYG89tpruLrWQVsOQRCEemL06NF88cUXtGzZkt69ewPGHtHp6en88ssvxMbG8s9//tOix8zMzCQvL4/OnTub7nNwcCA4OJjY2Fj69u1LbGwsjo6OpoQboFOnTkiSRFxcXLVLK7VabaXWYJIkmWaD1dXsCJ1Ox8mTJ9m9ezexsbGm+32U0NsOOtmAuhHN1PBTSTzsBCMMMsc0EFUGOTk5rFmzhvXr19OrVy8GDx7c6Keel5aWcuTIEfbu3Wtq9wYg27sge7dDbhECNo1kZqIkgZsvBjdf0BQhpV9CSo+lqKiInTt3snPnTtq0acOgQYPo2bNnvRsANivpfuSRR3jttdd46aWXGDx4sGm0Jikpib179yLLMpMnT7ZooELdUKlUzJo1i/nz55OWlsbuUhjraDyZperB3t6eF198scEWMRBu1b17d1asWGGsRp6bAu4Bt+4kG5AyxCh3Te3Zs6fSBchTp06xf/9+hg4dSsuWLVm5ciW//PILM2bMsGKUgiAIdWvAgAFkZ2ezatUqVq5cCcD/+3//D1mWUSgUTJky5ba1g8yRl5cHcMtFTldXV9O2vLy8W6a9K5VKnJycTPtUZd26daxZs8Z0OzAwkEWLFtVJX/Pi4mI2b97Mhg0bTOvgFUB7G+hlC61UjXtZhKtCYpgDDLKXOVMORzSQdqMd1oEDB2jfvj2TJk0iMjKyUf0/JCYmsmnTJvbu3WtajiErlMgegcbCaK7eddf2yxrsnJBbd0NuFQG5KSjSLiLlXCM+Pp74+HhWr17NsGHDGDNmTL0p+GxW0u3r68s777zDsmXL2Lx5c6VtYWFhPPXUU2LaZAOmVquZPHkyn3zyCafLjUn3mXLjtvvvv1+0iGtkVCoV3bp1Y//+/Ui5KchVJd2l+UjlJdja2lYaJRBuLysrq9JUp8OHD+Pl5WWq1JuXl8fvv/9urfAEQRCsZsKECQwYMIAjR46Qnp6OLMu0aNGCyMjIBtcdY/z48YwdO9Z0uyK5y8rKMhWvsrTi4mJ27drFzp07TdWoHSXoYQs97cClgU4hN5dakuhmC11tZJJ0cKTMOPX8/PnzzJ8/n4CAAMaOHUu3bt0a7NJIvV7PyZMn2bVrV6XZDLK9K7JvGLJXW1A3sVmokgLcAzC4B0B5iXH0O+0ShYWFrF27lrVr19K5c2eGDh1K+/bta+W9V6lUd3WBzew+3a1atWL+/PkUFBSQmZkJGAuo3a4whtBwBAYGAsb12zpZptBQ+X6hcalIDCVNIVV2odUYe3J7eXnVu+k6DcmZM2fo3r276banp+dtR08EQRAaMw8Pj0rJam2qGDDIz8+nWbNmpvvz8/NN68fd3NwoKCio9Di9Xk9RUdFtBxzUanW1fxst3ds9PT2dvXv38scff5h6m3soYIA9dLYBVWMe3bwLkiTRUg0t1TDKIHNIA0c1xtm4X375JS1atGDIkCH06dOnwRSELSws5MCBA+zdu5ecnJwb90oYPFoj+4aBq0/jHtW+WzYOyC0jjEslc5JQpF5Ayk3mzJkznDlzBm9vbwYPHmy1997spLuCi4uLSLQboWvXrgFgg7GthN2N3+WkpCRCQkKsFpdQO0zVPmVD1TsY9IDxap5w93x8fIiKimL48OGcOnWKnJycSkV+cnJycHR0tGKEgiAITYOXlxdubm7ExMSYkuySkhLi4uIYPnw4YCwuWlxcTEJCgql2ydmzZ5FlmeDgYGuFjsFgICYmhj179nD27FnT/S2UMMgOOtgYi4wJlTkrJEY4QH87mcMaOFxmLGT6888/s3btWvr06cPgwYMrtYyrT65cucKePXs4evTon+2+1HbIPqHIPmFgKz4/VElSQPNWGJq3Ms7UTD2PlB5Lenq6Vd978QlauIXBYGDr1q0AdLEFpSTR1VYmtQR27txJv379RBG1RqaixZ9sW021zxv3Z2dnI8tyo1oXVZvuv/9+Pv30U5566ik0Gg3+/v6Eh4ebtp89e9asCr2CIAgNzcsvv1yj/SVJ4oMPPqjRYzQaDenp6abbmZmZXLlyBScnJzw8PBg9ejRr167Fx8cHLy8vVq5cSbNmzUzVzP39/enSpQtfffUVM2fORKfTsWzZMvr06WOVyuUVI5z79+83/Z2WgBC1cb12G7VItu+Gg0JiiAP0s5c5WWYc+c7SaNizZw979uwhLCyMQYMG0aVLl3oxuHDx4kV+/fVXEhISTPfJTs2RfTsgewWBwvoxNhj2rshteiO36oaUcRkp9Tya0vxK7/2kSZPqpOCeeNeEW+zevZvz58+jwtjHEYzJ9/5S4/qklStX8sQTT1g1RsGyLl++bPzGqXnVOzi4IUsKCgsLycjIwNvbu+6Ca8D69u2Ls7Mz0dHRODo6MmLECNOsgqKiIpycnBgwYICVoxQE4W5ZeqpwU+Lk5FTpgq1OpyM2NpaWLVtarL1TfHw88+fPN91evnw5AAMHDmTOnDmMGzeOsrIyvvrqK0pKSggNDeX111839egG+Pvf/87SpUt55513kCSJyMhIpk+fbpH47lZaWhqbNm3i+PHjphFOOwm62UJPW2jeQPpr1ze2kkQvO4i0lYnXGYuuXdLChQsXuHDhAq6urgwcOJBRo0ZV+pmoK1qtlnXr1rFjxw7juUZSYPC8qd2XuMBiPpUNsl8H4/9lXuqNtmPXuHDhAgsWLODBBx9k5MiRtbreX5LFX5C7lpWVVaklRGOUnJzMu+++i06n434HiLT78xc8Xmvs0y0Dc+bMoWvXrtYLVLCY0tJS/v73v2MwGND3nAx2zlXupzi9GSk/jWnTpjXqCuZqtbpOKs42Jk3h3PhXTz/9tOn7pUuXWjESoS7NmjWL8nJjZdGm9r5b+txYUFDAzJkzefPNN+nYsaPFnrc+Mffc+M4773D16lUA/JTGwmidbMBGJF0Wl6uXOV4Gx8ug+EZGNHHiREaPHl2ncej1et5//33i4oydYgze7ZBbdwMb0S2o1mgKUcQfQbpu/F3r2rUrc+bMqfHT3O25sWGW7xNqhU6n45tvvkGn09FObbyaerM2aol+N0a+ly9fTmFhYd0HKVhcXFwcBoMB2c652oQbQG5mbLlw8eLFugqt0cjJyeGPP/5gy5YtppYuBoOBoqIiDIZq1tELglDvVCTcwr0Ty5SqV/F3YZwDzHKV6GYriYS7ljRTSgxzkHjFzTht31oSExOJi4tDVqjQdxiGHNJfJNy1zc4ZQ/uhGEIGABLR0dE3FaqzPJF0Cybnzp0jKSkJewkedKz6D+IQe2PhjsLCQv744w8rRClY2pUrVwCQXW7fokV2MU4pr7j6LtyZLMt8//33zJkzh88++4zvv/+etLQ0wLj2cM6cOab6CYIg1H8iURRqW2FhoenirKv4lF5nVJKE041f74rPRXWloKCAjRs3Gm8084Pmtb++WLhBkpC9Q5CdjDUbfv31V1Pfc0sz69d57ty5/PTTT5w4cYLi4mJLxyRYSUVFzE42xoqPVVFJEt1tK+8vNGymGQt3qoJp61B5f+GONmzYwJYtW7j//vt54403Km1zcHCgZ8+eHD161ErRCYJQU2JFnlCbysrK+PbbbykpKcFbaSyUJtSd3nbGxOjEiRPs27evTo555swZ3nrrLeNnakmBwSesTo4rVCb7dgDgyJEjzJs3j/j4eIsfw6xCao6OjuzcuZMNGzYgSRL+/v6EhobSvn17QkNDrVLhUbh3JSUlANjf4UK+w43ttXUlSKhbppGbG23BqlVdOzGhWrt372bgwIFMnTq1yosVrVq14tSpU7Vy7NWrV7NmzZpK9/n6+vLJJ58Axmmyy5cv59ChQ2i1WsLDw5kxY8Zte9EKQlNnY2MjppgLtSI1NZUvv/yS1NRUFMA4R2P3GKHu+Kgk+tnJ/K6BH374gYSEBKZNm1arHXv++9//UlZWhuzYDEO7QdUXtBVqlewdgt7OGcUlY6eAZcuWsWDBAosew6yk+/XXX0eWZa5cucKFCxe4ePEix44dY+fOnYCxF2JYWBizZ8+2aLBC7Wrfvj1HjhzhXDncZy+jquJkL8syZ2583ggLE1fjGoOKHoVScQ63G8ORiozrXHx9fesgqsbh+vXrt+1rb2tra7rYVRsCAgJ48803Tbdvrsr5/fffEx0dzUsvvYSDgwNLly7lo48+4t133621eAShoavNyraN3c3tj+DPC/1paWk4OFS9drWiV3Zjp9FoWLRoEUVFRQC0VkGJATQGGbtqZh4KliXLMrkGaK40Di6VyHDw4EH0ej0zZ86steP6+/sTHx+P7OQJNva1dhzhLtg5gaM7lBUREBBg8ac3u2WYJEkEBgYSGBjI6NGj0el0HDhwgPXr15OWlkZmZqZIuhuY8PBwHB0dyS4uZk8pDK/ib+CpcmN7BYVCQa9eveo+SMHiKpJCKT8NykuqLdwhZRk/MLVt27bOYmvoXFxcTGvzqpKQkICHh0etHV+hUFQ5cl1SUsKePXt44YUXTFWDZ8+ezT/+8Q9iY2OrvVCg1WorVeKVJAl7e3vT901VU37tTc3N08vF+14zr732WpX3f/PNN9U+ZtWqVbUVTr2iUqnw9PQ0Jd0JOkgoMvbk9lbKBKqgrRqC1eLnzpLKZJmYMkjUwRUd5P9lQp8kSbXeInXw4MHEx8ejyIiFjMvI7v4YWoRA85agUNbqsQVAr0XKSjT28M5PM9193333WfxQZifdGo2GS5cumUa64+Li0Gq1+Pn5MXToUDEK2gA5OTnx+OOP8+WXX3JAA4EqmbY2f57cs/QyG28Myj3wwAO1chVIqHu+vr4EBQWRkJCAlHYJuVXErTtpCpFyrgHQr1+/Oo6w4YqMjGTnzp0MGjTolpGc06dPs2/fPsaNG1drx09PT+fZZ59FrVYTEhLC1KlT8fDwICEhAb1eT6dOnUz7+vn54eHhcduke926dZWmrAcGBrJo0aIm32KtYraI0PjdPNIt3veamTVrlrVDqLdUKhVz587l+vXrxMbGcunSJWJjY8nMzCRND2l6OFQGgSoY4yDjrRKJ970wyDKny2FHCRTeNMVPqVTSunVrQkJCaNeuHW3atKl2FoalREZGYjAY2LdvH/Hx8Ug5SShzkpBVtsituyP7hIr+3LXBoEdKjkFKOo2kNw4mSJJEWFgYQ4YMoV27dhY/pFlJ97/+9S9TBePWrVsTFhbG6NGjCQsLw9m5+pZDQv3XvXt3Bg4cyP79+1ldDLOVMs2UEmWyzM+FUC5Du3btGDNmjLVDFSxo6NCh/O9//0NKOYvs1wFUNpW2S0mnQZYJCwvDz8/PSlE2PA8//DDnzp3j1VdfJTQ0FID169ezatUqYmNjCQwMZPz48bVy7LZt2zJ79mx8fX3Jzc1lzZo1vPXWW3z00Ufk5eWhUqlwdKxcPM/V1ZW8vLxqn3P8+PGMHTvWdLtixCUrKwudTlcrr6MhqKhILzR+N7f4a2rve8VorLkGDRpkuWAaIUmS8PDwwMPDgz59+gCQm5trSsIPHTpEolbLFwXQ01ZmtINY822O63qZX4og+UYZG09PT3r16kVISAht2rSp1fXbVZEkiT59+tCnTx/S09M5ePAghw8fJjc3FynuIHLmZQxt+xmnPQuWkZ+O4vJBpJJcwLgsum/fvvTu3ZvmzWtvTb1ZSXdiYiKSJNGzZ08iIiIICwur9ekXQt2ZMmUKV69e5cqVK2wpgWnOsL8Usgzg5ubGs88+K9a1NTI9evRgw4YNpKenI6VdQA4I/3NjWTGK9FgA7r//fitF2DA5ODiwYMECNm7cyJEjR7CxseH8+fN4e3szadIkHnjgAWxsbO78RGaIiPhzxkKrVq1MSfjhw4fNPqZarUatrrqcblOu6tyUX3tTJt53obY1a9aMyMhIIiMjGT16NGvWrCEqKoqjZcap52Pv0HREqKzUILO8EK4bjDVVxo4dy7Bhw6r9u1bXvL29mThxIuPHj2fPnj2sXbuWsoJMlCfWIrsHYPDtYGwpJi621JxsgOtXUaScQ8pPB4wzfB955BF69epVJ8s2zEq6Fy5cyMWLF7lw4QI///wzBQUFuLq6EhoaSlhYGGFhYbRq1UqsO2mg1Go1Tz/9NG+//TYXtAaiy2QOaozbHnvsMVxdXa0boGBxCoWC0aNHs2zZMqTkG6PdCuPpQUo5C7KBtm3b1sp0m8bOxsaGiRMnMnHiRKvG4ejoiK+vL+np6XTu3BmdTkdxcXGl0e78/HxRvVwQbkN8rhGsxcPDg7/97W9069aN//73vxwpg1yDTEsVBKjATwW24ufzFvkGmWQdJOkgVmtMuN3d3XnttdfqbbclhULB0KFD6dq1KytXruTEiRN/Tju3d0X2CUNu5gsOzUQCfjuyAYpykHKTkdIuIpUZayYoFAr69u3LQw89hJOTU52FY1bSHRQURFBQEKNHjwaMbQ4qkvBNmzbx3Xff4eDgwLfffmvRYIW64+vry4ABA9i3bx9rb7Rib9u2LeHh4bd/oNBgRUZGsm7dOnJzc+F6EngGGte83BjlHjVqlJUjFO6FRqMhPT2d/v37ExQUhFKpJCYmxlQQMTU1lezs7NtWWxcEQRCsq0ePHqSnp/Pbb79xSWssbgvGkW8vpYy/CvyVxkTcSwmKJpSUlcvGBLviX5Ku8pptMI5wP/fcc/U24b6Zu7s7s2fPJj09nT179nDw4EE0pflICUcAkFW24NIC2dUb2dXb2G6sKRdf0+ugMAspPx2pIB0KMk3rtcE4sj1w4EAGDRpklfff7EJqFcrLy8nJySE7O5vs7GwKCgoA4wc8oWHr2rUr+/btM93u1q2buMrfiKlUKnr16sXWrVtRZMVj8AyEvFQkXRkuLi6mKtdC9ZYsWVLjx0iSVCsFhpYvX0737t3x8PAgNzeX1atXo1Ao6NevHw4ODgwePJjly5fj5OSEg4MDy5YtIyQkRCTdgnAbYkq5UB/cf//9dOzYkdjYWBISEkhISCAnJ4cMPWTo4cSN/RwlaKeWCbOBNmqwaYSf4fINMhfL4aIWErSg/8t2hUKBn5+facCwQ4cONGvWzCqxmsvb25upU6cyfvx4Dh06xMmTJ4mPj6e8vAxyrpkK3coKpTEJd/dHbt4a7F2sG3htk2UoyUXKvoqUmwSF2Uhy5RL09vb2BAcH0717dyIjI626lMCspPvEiRNcuHCBCxcukJiYiF6vR61WExwczJgxYwgLCxPTUBuBv/ZjFv2ZG78uXbqwdetWyE8HWTatewkPD0epbMJXT+/SuXPnavyY2rqQlZOTw3/+8x8KCwtxcXEhNDSUBQsW4OJi/CP8xBNPIEkSH330ETqdjvDwcGbMmFErsQiCIAiWVdG2t0JeXh4JCQkkJiaavhaXlRFdDtHlxg/8wWqZUDV0tKFB9//O0svElMPFckj9S5bdrFkzU4IdFBREq1at6rw4Wm2xt7dnyJAhDBkyBJ1Ox7Vr17h8+TKxsbFcvnyZ4uJi42BJXiokHEN2aIbs0cqYgDs1bxxT0WWDcQT7+lVjsq0pqLTZ1dWVtm3bmgYR/Pz86k0dKrOS7vfffx8HBwfatWvH5MmTCQsLIygoCJXqngfOhXrkrz+k9eWHVqg9rVq1QqlUotdqoLwEqcjYY/rmP+xC9b744gtrh2Dy4osv3na7jY0NM2bMEIm2IAhCI+Dm5kbXrl3p2rUrADqdjtjYWE6dOsWpU6e4fv06F7XGEeGtpdDVRqaXHTRXNoxETJZl4nRwWGNcm11BkiSCgoLo0qULXbp0wcfHp0nMylSpVKYLCyNGjMBgMJCWlsaFCxc4efIksbGxGEpyka7lwrVTyLZOyF7ByC3agkMDq80ky1CcY+ylnRmPpC01bVKpVLRv354uXboQGhqKl5dXvX3/zcqSP/jgAwICAurtixIs46+tg/Lz860TiFBn1Go1Li4uxnXd5SVQblzQX5stFARBEARBsKyKZKR9+/ZMmTKF5ORkTp06xdGjR0lLS+NwGRwpg1C1TAcbCFKDSz0b/TbIMhl6iNcaR+szb4xqS5JEx44d6datG507dxYFfvlzGr2fnx9Dhw6lqKiIM2fOcPLkSc6ePUt5WRFS0ilIOoXs7IXcIhjZozXY1G4f8nuiKUTKSkTKvIxUnGu6297envDwcCIiIujQoQP29vZWDPLumZV0t2zZstLt8vJygFprfVNh9erVrFmzptJ9vr6+fPLJJ9U+5vDhw6xatYqsrCy8vb2ZNm2a6SqgcHvZ2dmVbmdlZVkpEqEuOTk5GZNubZnx3437BPNlZmZy8uRJ0++Qp6cnEREReHl5WTkyQRAEobGTJImAgAACAgIYO3Ys586dY+fOnZw9e5YLWrhwY+TYQyETpDYm4IEqcKzjJFyWZbINxrXZCVpI1EHJTWUUbG1t6devH0OGDKFFixZ1GltD4+TkZOr/XVZWxunTpzl06BDnzp3DUJiJVJgJcYeM1dBdvcHVB9nNB2yt1IdOlo1Jdn4a5KUj5aeZqo2D8SJSeHg4ffr0oWPHjg1ydrXZEWdnZ7N69WpOnjxpKp7m4uJCREQEkyZNwtPT02JB3iwgIIA333zTdPt2U54vXbrEf/7zH6ZOnUrXrl35448/+OCDD1i0aNEtFw6EW2VkZFS6nZmZaaVIhLpkOpHJeuPamZvvE2ps+fLlbNmy5ZYCTJIkMXr0aB5//HErRSYIQk2JGX5CQ1cxStyxY0dSU1M5ePAgFy9e5OrVq2QbZLLL4Jjxejs+SmMRtg5qaKGqnZ99vSyToIWzWogtr7raeEhICB07dqRPnz44ONTjkdl6ytbWlp49e9KzZ0/y8/M5evQoR44c4dq1a1Caj1SaD+mXAJDtnI1JeDM/ZPeWoKrFAVWtBin7qnEden4aUnlJpc0KhYI2bdrQq1cvevToUanFaUNk1ifplJQU3nrrLYqLi+ncuTN+fn6AseXM77//zokTJ3j33XdrpfCWQqG46z6yW7ZsoUuXLjzwwAMAPPLII8TExLBt2zaeeeaZah+n1WrRav9cMCJJkmnqQlP6g5uTkwOAuwJyDMbbTen1N1WmC1mybPyHMekW733Nbdy4kc2bNxMZGcn9999vOlempKSwefNmNm/ejLu7O2PHjrVypIIgCEJT4+vry6RJkwAoLi4mNjaWCxcucPHiRVJSUkjTQ1op7CkFT4VxGnpHG2ihvLfPwzpZJl4L58qNo+ylNyXaKpWK4OBgwsLCCA0NpXXr1uLCvwW5uroyfPhwhg8fTnFxMZcvX+bSpUvExsZy9epV42izphAyLiNLCmPy7RGI3LwVqC1QkK68xFgALTsRKS8N+PPNVyqVBAUFmYqgBQcHY2dnd+/HrCfM+in+6aefkCSJ999//5YR42vXrvHuu+/y008/8corr1gkyJulp6fz7LPPolarCQkJYerUqXh4eFS5b2xs7C0fZsPDw4mKirrtMdatW1dpGntgYCCLFi2qtdH7+qpiZK4i6S4vL8fHx8fKUQm1zbQ2RjaYRrpbtGgh3nsz7N69m27duvHSSy9Vur9t27a8+OKLlJeXs2vXLpF0C4IgCFbl6OhIREQEERERABQUFBATE8OJEyc4d+4cWTod+zSwTwN+SrjPXqadumbJd5ksc0wDf2ig+KZE28XFha5du9KtWzfatm1r1bZOTYmjo6OpAB1AaWkpcXFxXLp0iZMnT5Keng45SUg5SciSBM38MQSEg6t3zQ4ky5CThCL5jKkrToVWrVoRHh5Ou3btCAoKqvWlytZkVtJ94cIFxo4dW+UU7ZYtWzJixAg2b958z8H9Vdu2bZk9eza+vr7k5uayZs0a3nrrLT766KMqF9Hn5eXdUlzB1dX1lgJhfzV+/PhKH4IrTihZWVnodLp7fyENREWv9Yrzok6nIy0tzXoBCXWi4mKLZNCDwVi1JDc3t8lUr1epVBa7wJaVlcXo0aOr3d6lSxdOnz5tkWMJglD7RJ9uoalwcXGhb9++9O3bl5KSEs6cOcPx48eJiYkhRafjxyLwvZF8h94h+S6XZQ5r4KDmzzXarq6udOvWje7du9O2bdsm8xmjPrO3t6dTp0506tSJiRMnkpqayvHjx4mOjiY5ORlyklDmJCG7+WFo3Q1c7lCXRpYhNwXF1RNIhX/WhQoMDKR79+5069atSQ1ompV063S6216JsLW1rZXktOLqGxivjFQk4YcPH2bw4MEWO45ara72KltT+oNbsW7muuHP203p9TdVpn6WunKkGyPdNjY24r03g4uLC1euXKl2+5UrV0x9swVBEAShPnJwcKBXr1706tWLgoICduzYwZ49e0gtK+OnIuhpC2McZJRVJN55epkfiiDjRuXxFi1aMHbsWCIjI1EqlXX8SoS7JUmSqRr6uHHjSEtLY+fOnRw4cABDXgrKUykYvEOQg/uCoor3UVeO4tI+pOvXAFDb2DBk8GAGDx7cZDvimJV0BwYGsmfPHoYMGXJLQYOSkhL27NlDUFCQRQK8HUdHR3x9fY3TH6rg5uZ2S5ur/Pz8u14T3tRV/FLkGSrfFho306wRTSFgPPGKwiXm6d27N1u2bMHLy4uRI0ea1iZpNBq2bdvGnj17bjsSLgiCIAj1iYuLCw899BAjRoxg27ZtbN++nWNlMvkGeMRJRn1T4p2uk/m+0FgczdXVlYcffpiePXuKUe0GyMfHh8cff5xRo0axceNGDh06hCI9Frm0AEP7oaC+ae21pgjFuR1IxTmoVCoGDRrE6NGjm3xrN7OS7ocffpgFCxbw4osvMmjQIFPBtNTUVPbv309hYSFPP/20RQOtikajIT09nf79+1e5PSQkhJiYGMaMGWO678yZM7Rt27bWY2sM/rqGV6zpbRoqqkNKJXmAMQkXfyDNM3nyZK5cucKKFStYtWoV7u7ugLEoocFgoEOHDkyePNnKUQqCcLdEQUlBMHJ2dmbSpEm0adOG//3vf1zSatlaAg/cKDCtkWV+LDIm3L6+vrz44oti8KYR8PT0ZPr06fTo0YP//ve/aPLTUZzbgSF8LEgK0OtQnNmCpCnAxcWF559/vk4GYhsCs5Lujh078tprr/Hjjz+yfv36Sttat27Nc889R8eOHS0S4M2WL19O9+7d8fDwIDc3l9WrV6NQKOjXrx/A/2fvzuOqqvPHj7/O5bJdkE3EDRcQ0dwQ99zAJTWzLFtsncrRmYwpv82UU9miljnNpNVkzc8plzRzHbfcl9z3XRQTcUdEQLhsFy5c7vn9QZy8AiZ44bK8n48HD+5ZOOd9PPLhvM9nY8aMGfj5+fHss88CMHToUCZOnMhPP/1Ep06d2LNnD+fPn7/jyOXiN7ePPl8Ro9GLqkebkzs3w3ZZlJmrqysffPABhw4d4tixY6SkpACFAzoWDRojD/FCCCGqq06dOvGXv/yFzz//nINmaO2sEuqisC67sKWkv78/b7/9drWf7knYat++Pe+88w5Tp04lNyMJJeEMauO2KJePoORm4OvryzvvvCMvWm5R7jH4O3TowD//+U+MRiPJyYWd4+vVq1ehTbdTU1P58ssvyczMxMvLi9atWzNlyhStT2RKSorNA2yrVq14/fXXWbRoEQsXLqRhw4a89dZbMkf3Xapbty56vV7rn9+gQRlHKxTVkvaHMTcLoMRBCkXZdO3ala5duzo6DCHEPZKxLYQorl27dgwcOJAtW7awKQd8nFSO5hVuGz16tCTcNVRgYCBPPPEEP/zwA8rlI6h+TdBdOwXACy+8IAn3be554jsfH59K6yP9f//3f3fcPnHixGLr7r//fu6///6KCaiG0+l0uLi4aEm39IWvHYoGEbx1EDUhhBBCiNI8/PDD7Nq1i0Szme8Lh4QhPDxcunTWcBEREWzYsIGUlBR0pzaAqhISEkJYWJijQ6tyypV079ix447bFUXB2dmZunXrEhQUJPPtVWO39uXVRrUWNdrtzZ2l+XPZfPrpp2XaX1EUxo8fX0HRCCGEEBXP09OT+++/n+3bt5P+6wC8AwcOdGxQosIVdfNduXIlSk5ht8TSxtqq7cqVdH/zzTd3va/BYODRRx9l+PDh5TmVqEKsVqsMqFUL5Ofn33FZ3NnRo0dxdnbGx8fnrpqiyksNIYQQNUGbNm3Yvn07UNhKrkWLFo4NSFSK1q1b2yzfd999DoqkaitX0v3Pf/6Tr7/+mjp16jB48GCtr+/169fZuHEj2dnZ/PGPf8RoNLJhwwZ+/PFH3N3dGTRokF2DFxVLVVXy8vK0ZaPRqI2+LGqurKzCvtyqmxdKbgbZ2dkOjqh68fPzIzU1lTp16tC7d2969eolXTOEEELUeLeOmdSwYUNp6VpL3HrfFUWRvtylKFfSvXbtWry9vZkwYYLN+qZNm9KtWzc++eQTfv75Z1555RW6dOnChx9+yMaNGyXprmYyMjJsku7ExERJumsBbW57Tz/IzSA9PR1VVaVG9i795z//ISYmht27d/O///2PH374gTZt2tC7d2969OghA9MJIYSokXx9fbXPknDXHrd2P5VnxdKVq63woUOHSh2JV1EUunTpwoEDBwpPoNPRvXt3EhMTyx+lcIhLly7ZLF++fNkxgYhKlZqaCoDqFQCA2WyW2u4yatOmDX/605/473//y1//+lc8PT2ZPXs2o0eP5rPPPmP//v3SbF8IIUSNotf/Vpcn3RFrJ7nvpStXTbfVaiUhIaHU7deuXbPpy6jX62UE5Gro9qT79mVRM2lJt7s3qrMbSn4uN2/elPm6y0Gv12vTheXm5nLgwAE2b97M559/zpNPPskTTzzh6BCFEEIIu5Maz9pJplUsXbleR3Tp0oWNGzeyYcMGm+bHeXl5rF+/ns2bN9O5c2dtfWxsrMzxXA0V1Wy3/rWF0JUrVxwYjagsRUk3rp7gWji3ZlpamgMjqv7y8/M5fvw4hw4d4uLFi7i4uBAQEODosIQQZSQPlEIIUTp52VK6ctV0v/zyy9y4cYM5c+Ywf/58bZAgo9GIxWIhJCSEl19+GShMxF1cXHjooYfsFrSoHMnJyQC0cYFf8iElJUVGMK/hrFYrmZm/TrDp4g4uBuDmb+vEXbNarZw8eZI9e/Zw6NAhzGYzHTp04M9//jPdunXDzc3N0SGKcsrNzbVZljEPagdVVSkoKNCWMzMzqVOnjgMjEkIIUV2UK+n29PTko48+4uDBg5w4cUJLzsLCwggLC6Nr165aYubi4sIrr7xiv4hFpSkaxTrAqXDZarViMpmkmXENZjKZflvQu6LqXVFA+nSXwdmzZ9m9ezf79+8nMzOTli1b8swzz3D//ffj5eXl6PCEHVy/ft1m+ebNm/j7+zsoGlFZUlJSbJLuq1ev0qZNGwdGJIQQorooV9INhc0HunfvTvfu3e0Zj6hCnJwKs+18tfg6UTMVdRdRFR3onMCpsIgwm82ODKta+eCDD3BxcSE8PJxevXpRr149oPCBPSUlpcSfCQ4OrswQxT06depUseXIyEjHBCMqzZEjR2yWDx8+LEm3EEKIu1LupPt2ZrOZPXv2YLFYCA8P1x40RfXl6elJWloaib++2Nfr9dIktobTRtTW/fpyRae3XS/uSl5eHgcOHNBmcfg9ixcvruCIhL1cu3aNLVu2AFBXBzethdNotmvXTmq7a7C0tDQ2bdoEgNU/CF3KRfbt20e/fv1o0qSJg6MTQghR1ZUr6f7Pf/5DXFwc06ZNA8BisTBhwgSuXr0KgMFg4IMPPiAoKMh+kYpK16BBA65evcrpvN+Wpd9izaYNjPhrsl2UfN86YKK4s7Fjxzo6BFFB4uPjmTZtGllZWTR2gufqwOwMSElN5bPPPuNvf/ubvHCugTIzM/nqq69IT09HNfiihvZBtZjJMybw73//m/Hjx8t9F0IIcUflSrpPnz5Nnz59tOXdu3dz9epVXnvtNZo3b860adNYunQp48ePt1ugovIFBgZy6NAhLlkKlxs3buzYgESF0/p0638dsl7vYrte/C5pZlwz7d27l/nz5pGXn08DJ3ixDhh0CqO8VL7NKBx4cvLkyfzxj3+kY8eOjg5X2MmJEyeYO3cuGRkZqHpXrG0fAL0L1vsGoDu+mtTUVD788EOeeeYZevfuLS+mhRBClKhcSbfRaLR5q3vw4EGCg4Pp3bs3AAMGDGD16tX2iVA4TP369W2WZdq3mq9oUERcfx2R17Vw0LzS+iILUVNlZ2cTFxdHXFwcZ8+e5fz58wCE6OEpz8KEG8BLpzDGS2VhFlw1mfjqq69o1aoVoaGhhISE0KJFC9zd3R15KaIMTCYT58+f59y5c9q9B1ANPlhb9wP3XwdDdHbF2v5BdL9sx5yRyNy5c9m2bRutWrWiZcuWtGjRAm9vbwdeiRBCiKqkXEm3q6urVvNVUFBATEwMQ4YM0ba7ublJzVgNcPtUKDI1Ss0XFxcHgOrha/P98uXLmM1mXF1dHRZbdXDgwAFCQkKoW7dumX7OYrFw5MgR7rvvPhnh3AFyc3MxGo1cunSJc+fOce7cOa5du2azjwJEukE/d9DdVpvppVP4Yx2VjSbYZy4cwb4oWVMUhSZNmtCyZUtatmxJs2bN8Pb2lt+lKsBsNpOWlsaFCxeIi4vj3LlzXL9+vdhc3NbG7VCDuvzW7aaImyfWsKEo8dHoLh3h8uXLXL58Wev7HRAQQEhIiPbypW7duri5uUltuBBC1ELlSrqDg4PZunUrbdu25fDhw+Tk5NClSxdt+40bN+QNbw1w+1y0OTk5DopEVIb8/HyOHz8OgOr368BABl9UV0/yzFlER0fb/J6L4qZPn85rr72mtfq5Wzk5OUyfPp3333+fdu3aVVB0tYeqquTk5JCRkUF6ejoZGRlkZGSQmZlZbF1GRkapYxb466CpHpo5Q5Ae/JxKT5b0isJDHtDNTeVSPly2FH6lWVWuXLnClStX2Lp1q7a/q6sr3t7eeHl5aV916tTRPt+6TRK1u2O1WsnMzNTu8+3fb19X2qwMqpsXqnd98KqP6tMQ3O/wPKPoUJuEURAQgmJMgIwbKOk3UExpJCUlkZSUxN69e7XdnZ2dtft86/2+fV2dOnWoU6cOer3dxrsVQgjhQOUqzZ9++mmmTJnC22+/DUD37t0JCQnRth88eJBWrVrZJ0LhMCdPniy2PHToUAdFIyrajh07yMzMRHXxAO9fuxIoCmpAC5SrJ1izZg2dOnVCp9M5NtAq7syZMzZz+d6N219wiZIVJdJGo5H09PRiyfOtXxaLpUzHdgbqOxUm2M30hcm2p67siW49J4V6TtD11+UMq8rlfLhigUsWSC4AC4W1rEVJ2e/G5uxsk5zfnpj7+Pjg7e1dI2vQixJpo9GofZWUUGdmZpKVlVWslvr3qDon8KyL6lUf1as+eAWAi6Hsgbp6oNZvCfVbogJYzJCRhJJxAyUjCTKTUQryyc/PJzU1ldTU1Ls6rIeHh00SXvT51ntfdP9lSk8hhKi6ypV0t2jRgi+++IKzZ8/i4eFhM09ldnY2gwcPlrkrq7mEhAT27dsHwBMe8L9sOHfuHNHR0bRv397B0Ql7y8jI4KeffgJAbdrxtynDADWwPWpCDFevXmXPnj02gyiK4rZs2aJNKSV+n6qqZGdn2yTSpX0u63zxrgp4KuCpK/zuofvt8+3rXCuoJtlLp9DeFdr/mgurqooZyLIWfmWrv33OUouvy6OwFcrNmze5efPm757P3d29WCJe0meDweDQ2vNb7/udvtLT07FarXd/XABnt1+/3FFd3LXPuLijap9//e7kDBXx76B3Bb8mqH5N0F4DFORDXi7k50B+Dor2ORfyclB+XV+4Ty4Khf9G2dnZXL9+/Y6nUxTFJgkv7cvT01NenAohhAOUu92Sl5cXXbt2Lbbew8NDakOrOZPJxDfffENeXh7BeujgAlctcMAM3377Le+//75Mj1KDqKrKDz/8UFhL5OGL2iDUdgdnN9Sm4SgXD7Jo0SLatGlT5j7LtcWMGTPu6ed9fHzsE0gVtnv3bo4dO2ZTU12WWmkXoI6u8Ov2BNrz13Uev352roJNshVFwQ1wcwL/u6iYzFPVUpPzLCtk/vo50wr5FLYGyMnJ4caNG3c8rl6vt0nGu3fvXqHdR06cOMG+ffswGo2kpaVhNBrv+r6rKODiXlgD7VKUSLvbJtJacu0GShVNKp2cwd0Z3AvHR7m9Tt5mWVULa8vzfk3Qf03Mi5JyJT8H8kxgNhV+V1Xtd+ry5culh+DkpL188fHxoUOHDvIiVQghKsE9dxbKycnBZDKV2KTL39//Xg8vKllWVhbTp0/n+vXr1FEKR+nVKQoPGlTiLXAtO5tPP/2UN998U0YzryEOHDjAkSNHQFGwtoqwqeUuoga2Q025RG5mErNnz+Zvf/ub1JaUQF5G3ZmqqixZsoTs7OxyH0MBzCpghVwVMhRwKQAXBZyVwtptZ6UwOXdRVFwUfvvi120lrHOqxAS9QFXJUwuT5Dz1tq9b1uWXsO7W/fJvWS5r9BaLhZSUFG1mgoSEhApNupcvX058fHz5flhRwFpQWCNstRQmoLpMcNKjOjmjOOkLE1rdr99vWVadnIut05ZLKOsqnGotrPEusNh+txZ+V25db7XdT7GW8HNqQeFLBvXuurQUFBTYNG8/ffo0vXr1kvJcCCEqWLmT7k2bNrFmzZo7vk1fvHhxeQ8vHCAzM5PPPvuM+Ph4DAr8oc5vfRr1isJzdVTmZEByWhqffvop48ePp2HDhg6OWtwLo9HIDz/8AIC1aSfwLOVFmaLD2ioCp6PL+eWXX9i2bRsDBgyoxEhFTaAoCq+//jpnz57FbDaTm5tLXl4eZrP5jl/5+fnaMcwUJt1ZZeu6+7v0/Jag++kK+3cHOP36XQ9uZUjKc6wqNwrgRgEk/fo9zfpbgly2Hv/l4+LigouLC25ubri4uODq6qp9lbSuogfwGzVqFCdPnrS5r0X3v6TvZrNZa1auqNbCWl9L8e4F9/KqRFV0vybfzuDihuruAwYfVI/C77h5Q1mSUdUKuVlgMqKY0n79biysoS5KnO8yOS4vRVFs7mvR/b59XdFXaGioJNxCCFEJypV0b9q0iVmzZhEWFka/fv1YtGgRDz30EM7Ozmzfvh0fHx8efPBBe8cqKlBOTg6ff/458fHx1FHgZS8IuG2kXi+dwh+9VOZmQmJGBtOmTePtt9+WFg3V2E8//UROTg6qpz9q07A772zwxhrcHV3cXlatWkXPnj1l/uEaYMOGDfz0008YjUaaNWvGqFGjbAbGtLeiKZTKwmq1/m5ifqevWxO525O7olZaFsCigkkFoxUu3Nby2VunUt/JNhn3d/otqU4qgBuWws+Zd/lCQKfTlZoM3c1XUVJ9+zpXV9cql0g1a9aMZs2a3fX+qqpisVhKvae3J+h381W0b9FAh4XJfB6QB3nZKFm2feZVRSkcudzgg2rwKZzNweBTmJDnZPyWVJvSCr/npKNY7y6pLrr3d0qIS/u60884OzvLSPd2UtlloxCiZitX0r1hwwbCwsJ49913yczMZNGiRXTq1Il27doxfPhw3n77bTIzM+0dq6hAc+bM4fLlyxhKSbiLeOoUXq6jMisTktLS+PLLL5k0aVKVe8ATvy8tLY2dO3cCYG3R4676QaoNW6NeO012djrbtm2T8Ruqub179zJv3jzGjBlDy5YtWbt2LVOmTOGLL76oUtM+6nQ63N3d7f6S59bEriiJM5lMJCYmcu3aNRISErh27RppaWmkWyHdCrH5v39cAD8/PwIDA2ncuDGNGzemfv36xZIlvV4vCVIpFEXB2dkZZ2dnPD097XrskpJ5o9FIQkICCQkJXL9+nevXrxcO3GcyFibXd3lsvV5PgwYNaNSoEQ0bNqRRo0b4+fnJva9mqkvZKISoPsqVdN+4cYPBgwcDaFNUFA2IYjAY6N+/P5s2beLhhx+2U5iiIt28eZOjR48CEO4K1y1w3XLnqppOLrAxp7Af4JkzZ2jbtm1lhCrs6Pz581itVlQXA4o5G5LO39XPqZ7+KDnpnD17VpLuam7NmjUMGDCAfv36ATBmzBiOHj3Ktm3bePTRR4vtn5+fb9PUW1EULRGujgmEoihaM+w6depo61u2bGmzX3Z2NteuXePatWvEx8dz7do1YmNjte333XefllwXfUkrkKqrtGQ+PDxc+2y1WklLS9OS8KKEPC4uTtsnKCjIJrlu2LAh9erVk5fQNUBtLxvtoaCgoNZee22mqqrc91KUK+k2GAxa8yyDwYCLi4s2GAsUTlliNBrtEqCoeCdPntSaWO4px3TBx48fl6S7GiqaH1jJM6H8sq3MP5+cnGzvkEQlslgsXLhwweYBUqfT0b59e5uE8lYrVqxg2bJl2nJQUBCffvpprRhA7vZmpePGjSM2NpZu3boxadIkB0UlKlLjxo2L9XWfPHky+/bto3nz5nzzzTcOikxUJCkb7aNu3boy7k8tVPQCUhRXrqS7SZMmNlNShIaGsnnzZjp16oTVamXLli3yD16NtG3blo4dO5KbW/aMW6/X061btwqISlS0zp07c/HiRUwmU7l+/v7777dzRDVXfn4+Fy9eJD09nVatWuHl5eXokMjIyMBqtRabpszHx4eEhIQSf+axxx5j2LBh2nLR2+zk5OQyTftVEzz99NOsX7+e4cOH/+4cyqLmeOSRR8jPz2fQoEG17r7r9fpakURK2Xhv/vCHP3Dy5EmGDBlS635HarPXX3+dHTt2MHTo0Fp33++2bCxX0t2nTx82b95Mfn4+zs7OPPnkk3z00UeMHTtWO/nf/va38hxaOEBAQACvvfaao8MQlax+/fpERUU5Oowab926dSxdulR7ufH+++/Trl07MjIyeOONN3juuefo37+/g6O8O0XNcktS0rSRNVmzZs145ZVXgNp37bVZQECA9qwj910UkbLxNxEREURERAC179prs7CwMMLCCgfklftesnIl3f369dP6uQC0bt2a6dOnc+TIEXQ6HR06dKBRo0Z2C1IIIaqjbdu28f3339OzZ0/CwsL4z3/+o23z8vKibdu27N271yFJt5eXFzqdrlhXIKPRWKyGRwghagspG4UQFaHc83Tfrn79+hU+qNKKFSs4ePAg165dw8XFhdDQUJ5//vk7Jvjbt28v1u/K2dmZBQsWVGisQgixZs0aunTpwrhx40qc0SE4OJj169c7ILLCFknBwcGcOnVK6yJitVo5deoUQ4YMcUhMQgjhaFI2CiEqgt2S7soQExPD4MGDadGiBQUFBSxcuJCPP/6Y6dOn4+bmVurPubu78+WXX1ZipEIIAYmJiTz44IOlbvf09CQrK6sSI7I1bNgwvv76a4KDgwkJCWHdunWYzWYiIyMdFpMQQjialI1CCHu7q6R75MiRZT6woigsWrSozD93JxMmTLBZjoqKYvTo0Vy4cIE2bdrcMRZpEiSEqGwGg4GMjIxSt8fHxzu0bOrZsycZGRksWbIEo9FI8+bNeffdd6W8FELUalI2CiHs7a6S7scff7xKzrlWNDDR7XNt3i43N5dXX30VVVUJCgrimWeeoUmTJqXuL/MtCiHsITw8nK1btzJ48OBi265evcrWrVttxsdwhCFDhkiTSSGEuI2UjUIIe1LUajrEnNVq5Z///CfZ2dl89NFHpe4XGxvL9evXadasGSaTidWrV3PmzBmmT59O3bp1S/yZJUuW2My3GBoayscff2z3axBC1GypqalMmDABVVXp3LkzW7ZsoU+fPlitVg4cOICvry+ffPJJlZhC7F6kpaXVumlxhKht9Ho9vr6+jg6jWpGyUYia727LxmqbdH/77bccP36cyZMnl5o8l8RisfDGG2/Qq1cvnn766RL3ub2mW6fT3bHPuBBClCY9PZ2FCxdy4MABrXWOm5sb3bt357nnnsPb29vBEQohhBBCiIqkK8vOKSkppKamast5eXmsWbOm2NfevXvtHuitZs2axdGjR/nwww/LlHBD4duIoKAgEhMTS93H2dkZg8GgfdXmhDsnJ4e///3v5OTkODoUUYnkvtuPt7c3r7zyCnPmzOHbb79l5syZzJkzh1dffVUS7mpMfkdqJ7nvQtyZ/I7UTnLff99dj15+5coVxo8fz0svvaT1cTGbzcyfP7/YvjqdjsDAQJo2bWq/SCmcbH327NkcPHiQiRMnEhAQUOZjWK1Wrly5Qnh4uF1jq6lUVeXixYsy0X0tI/e9YhQ1I7dYLOTl5dXqF3rVnfyO1E5y34W4M/kdqZ3kvv++u066N2/eTL169Rg0aFCxba+99hqtWrUCCv/RJ06cyObNm/njH/9ov0gprOHevXs348ePx93dHaPRCBSOEOzi4gLAjBkz8PPz49lnnwVg2bJltGzZkgYNGpCdnc3q1atJTk5mwIABdo1NCCFut2fPHs6dO8dLL72krVu6dCnLly8HoFOnTrz22muSfAshhBBC1GB3nXSfPn2abt26odMVb5Hu4+NDvXr1tOXevXtz+PBh+0R4i02bNgEwceJEm/WvvvqqNndiSkqKzQjjWVlZzJw5E6PRiIeHB8HBwXz88ccEBgbaPT4hhLjVmjVraN68ubZ89uxZli1bRnh4OIGBgaxfv57ly5drLwmFEEIIIUTNc9dJd3JyMo0bN7ZZ5+TkRLNmzYrV0gQEBJCcnGyfCG+xZMmS393n9oT8pZdesqllEmXj7OzME088gbOzs6NDEZVI7rt9JCYmEhERoS3v3r0bHx8f3nrrLZycnLRRzCXprn7kd6R2kvsuxJ3J70jtJPf999110g2F/aFvZTAY+Oc//2nXgETV4uzszFNPPeXoMEQlk/tuHxaLxeYP0MmTJ+nYsSNOTk4ABAYGai14RPUivyO1k9x3Ie5MfkdqJ7nvv++uRy/38/Pj8uXLd7Xv5cuX8fPzK3dQQghREwQEBBAdHQ3A+fPnSUxMpGPHjtr29PR06c8thBBCCFHD3XVNd4cOHdi9ezdPPPHEHae5SU9PZ/fu3fTu3dsuAQohRHU1cOBA5s6dS3x8PDdv3sTPz4/OnTtr28+ePUuTJk0cGKEQQgghhKhod13T/fDDD2OxWJg8eTLnz58vcZ/z58/z0UcfYbFYePjhh+0WpBBCVEcPPvggY8aMoX79+nTt2pX33ntPm2khKysLo9EoLyiFEEIIIWo4RS3DhGpHjhzhyy+/xGw206BBA5o0aYKbmxu5ublcvXqVxMREXFxcGDduHF26dKnIuIUQQgghhBBCiCqvTEk3wI0bN1i1ahVHjx4lLS1NW+/j40OnTp0YPnw4DRo0sHugQghRncXHx2uzOtSrV0+mLRRCCCGEqCXKnHTfKicnh5ycHNzc3DAYDPaMS1QRGzZs4KeffsJoNNKsWTNGjRpFSEiIo8MSFSQmJobVq1dz8eJF0tLSePPNN+nWrZujw6rWDh06xLx580hKSrJZHxAQwIsvviitgqohKRdrHykbhfh9UjbWPlI23r277tNdEnd3d/z8/CThrqH27t3LvHnzeOKJJ/j0009p1qwZU6ZMIT093dGhiQpiNptp3rw5f/zjHx0dSo1w9OhRpk2bBsAzzzzDW2+9xVtvvcUzzzwDwGeffcbx48cdGKEoKykXaycpG4W4MykbaycpG+9emebpFrXLmjVrGDBgAP369QNgzJgxHD16lG3btvHoo486NjhRIcLDwwkPD3d0GDXG//73P5o1a8akSZNspgbr0qULQ4YM4YMPPmDp0qU204iJqk3KxdpJykYh7kzKxtpJysa7d0813aLmslgsXLhwgfbt22vrdDod7du3JzY21oGRCVF9XLlyhYiIiBLn4nZzcyMyMpIrV644IDJRHlIuCiFEcVI2CvH7JOkWJcrIyMBqteLj42Oz3sfHB6PR6JCYhKhunJ2dycrKKnV7VlYWzs7OlRiRuBdSLgohRHFSNgrx+yTpFkKICtKuXTvWrVtX4pv+c+fOsX79epuaASGEEEIIUfNIn25RIi8vL3Q6XbE3lEajsdibTCFEyZ5//nkmTJjA+++/T0hICI0aNQIgISGBuLg4vL29ee655xwcpbhbUi4KIURxUjYK8fukpluUSK/XExwczKlTp7R1VquVU6dOERoa6sDIhKg+AgIC+Oyzz3jwwQfJzs5m79697N27l+zsbIYOHcq//vUvAgICHB2muEtSLgohRHFSNgrx+6SmW5Rq2LBhfP311wQHBxMSEsK6deswm81ERkY6OjRRQXJzc0lMTNSWk5KSuHTpEp6envj7+zswsurL29ubl156ydFhCDuRcrF2krJRiDuTsrF2krLx7imqqqqODkJUXRs2bGD16tUYjUaaN2/Oyy+/TMuWLR0dlqggp0+fZtKkScXWR0REEBUV5YCIqreCggLMZjMGg6HE7SaTCVdXV5ycnCo5MnEvpFysfaRsFOL3SdlY+0jZePck6RZCiAry3XffcebMGaZNm1bi9r/97W+0a9eOl19+uZIjE0IIIYQQlUX6dAshRAU5fvw43bt3L3V7jx49OHbsWCVGJIQQQgghKpsk3UIIUUHS0tLw8/Mrdbuvry+pqamVGJEQQgghhKhsknQLIUQF8fT0JCEhodTt165dw93dvRIjEkIIIYQQlU2SbiGEqCAdO3Zky5YtXLx4sdi2CxcusGXLFsLDwx0QmRBCCCGEqCwykJoQQlSQ1NRU3nnnHTIyMujcuTNNmjQB4OrVqxw5cgQvLy8++eQT6tat6+BIhRBCCCFERZGkWwghKlBaWhoLFizg8OHD5OTkAODu7k7Xrl155pln7tjnWwghhBBCVH+SdAshRCVQVZWMjAwAvLy8UBTFwREJIYQQQojKIH26hSjBkiVLeOqpp2zWRUVF8fXXXzsoIlHdKYqCt7c33t7eknCLakvKRiGEKE7KRvF79I4OQAh7S01NZcuWLXTr1o3mzZtX2Hni4+PZu3cvkZGRBAQEVNh57sXZs2c5ceIEDz30EB4eHo4Op9ZZtmzZXe33xBNPVHAkQkjZeCspG4UQRaRs/I2UjRVHkm5R46SlpbFs2TICAgLsWnh+8cUXNjWU8fHxLFu2jLZt21bpwnPZsmVERkZK4ekAS5cuvav9JOkWlUHKxt9I2SiEKCJl42+kbKw4knSLGqOgoICKHKLA2dm5wo4taqbFixcXW2e1WklJSWHDhg2cOXOGd9991wGRidpEykYhhChOykZRmWQgNWFXS5YsYdmyZXzxxRcsW7aMI0eOoNfreeCBBxg5ciQ3b95k9uzZnD59GhcXFx555BEefvhhm2Okp6fz448/cvToUUwmE40aNeKhhx4iMjJS2ycpKYm//OUvPP/88zg5ObFhwwaSkpL4wx/+wPfff18srldffZXIyEjOnDnD+vXrOXfuHOnp6Xh7e9O9e3eeffZZXFxcil3HkiVLtHVRUVG0adOGqKgotm/fzjfffFPsPB9++CHbtm3j2LFjzJw5E73e9r3Wxx9/THJyMl9++eUd/x3PnTvHsmXLiI2NxWKxUL9+ffr378/QoUMBuHz5MmvWrOHMmTOkpaVhMBgIDw/nhRdeoE6dOjbXcLsZM2ZU2Testc2///1vVFVl3Lhxjg5FVDApG6VsFEIUJ2WjlI21hdR0iwrxxRdf0LhxY5577jmOHj3K8uXL8fT0ZMuWLbRr147nnnuOXbt2MX/+fFq0aEGbNm0AyMvLY+LEiSQmJjJkyBACAgLYv38/33zzDSaTSSs8imzfvp38/HwGDBiAs7Mz3bp1IycnhyVLljBw4EBat24NQKtWrQDYt28fZrOZQYMGUadOHeLi4tiwYQOpqan89a9/vevru++++3jwwQdZv349jz32GI0bNwagcePG9O3bl507d3LixAk6d+6s/YzRaOTUqVO/25T45MmT/OMf/8DX15cHH3wQHx8frl27xpEjR7TrP3nyJElJSURGRuLj40N8fDxbtmwhPj6eKVOmoCgK3bt35/r16+zZs4cXX3xRK1S9vLzu+jpFxbrvvvtYsGCBo8MQlUjKRikbhRDFSdkoZWNNJ0m3qBAhISH86U9/AmDgwIFERUUxf/58nnnmGR599FEAevXqxZ///Ge2bdumFZ5btmzh2rVrvPbaa/Tp0weABx54gIkTJ7Jo0SL69euHu7u7dp6bN2/y1Vdf2RQI4eHhLFmyhNDQUPr27WsT1/PPP2/zZnLgwIE0aNCAhQsXkpKSgr+//11dX/369bnvvvtYv349HTp0oG3btto2Ly8v6taty65du2wKz927d6OqarGYbmW1Wvnvf/+Lr68v//znP23609zaKGXw4MHF3vS2bNmSL7/8kl9++YX77ruPZs2aERQUxJ49e+jatau8payCzp8/LyOZ1zJSNkrZKIQoTspGKRtrOpkyTFSI/v37a591Oh3BwcGoqmqz3sPDg0aNGpGUlKStO3bsGD4+PvTq1Utbp9frefDBB8nNzSUmJsbmPN27dy/TG7hbC87c3FwyMjIIDQ1FVVUuXrxYpmssjU6no3fv3hw+fJicnBxt/e7duwkNDb1jIXbx4kWSkpIYOnRosQEsbk3Obr2OvLw8MjIyaNmypXYMUTXs2LGjxK9169Yxbdo0tm3bRo8ePRwdpqhEUjZK2SiEKE7KRikbazqp6RYV4vY3fwaDAWdn52IFncFgIDMzU1tOTk6mYcOG6HS274OKmuEkJyfbrC/rW7iUlBQWL17M4cOHyc7OttlmMpnKdKw7iYiIYNWqVRw8eJCIiAgSEhK4cOECY8aMuePP3bhxA4AmTZrccb+srCyWLl3K3r17SU9Pt9lmz+sQ96ak/ltF6tSpw/Dhw2Xk8lpGykYpG4UQxUnZKGVjTSdJt6gQtxd+pa27V7e+ufs9VquVjz76iKysLIYPH07jxo1xdXUlNTWVb775xq4jWAYGBhIcHMyuXbuIiIhg586d6PV67r//frsc//PPP+fs2bM88sgjNG/eHDc3N6xWK5988glWq9Uu5xD3bsaMGcXWKYqCh4eHTXM3UXtI2ShloxCiOCkbpWys6STpFlVKvXr1uHz5Mlar1aawTUhI0Lb/ntL6yF65coXr168TFRVFRESEtv7kyZP3GHXJ+vbty7x580hLS2PPnj106tQJT0/PO/5M/fr1Abh69SodOnQocZ+srCyio6N56qmnbGpJr1+/Xmxf6S/sWHfz/1WIuyFlo5SNQojipGyUsrG6kD7dokoJDw/HaDSyd+9ebV1BQQHr16/Hzc1NGzjjTlxdXQGKNQMqKoxvfTOpqirr1q0rV6xubm4lnqdI7969URSFOXPmcOPGDW2AjzsJCgoiICCAdevWFTtuUdwlXQfA2rVrix2v6N9Cmg4JUb1J2ShloxCiOCkbpWysLqSmW1QpAwcOZPPmzXzzzTdcuHBBm/rh7NmzvPTSS3fVJLd+/fp4eHiwefNm3N3dcXV1pWXLljRq1Ij69eszf/58UlNTMRgMHDhwgKysrHLF2rx5c3Q6HatWrcJkMuHs7Ey7du3w9vYGCkejDAsLY//+/Xh4eNCpU6ffPaZOp2P06NF8+umnjB8/nsjISHx9fbl27Rrx8fFMmDABg8HAfffdx+rVqykoKMDPz48TJ07YDCxSJDg4GICFCxfSq1cvnJyc6Ny5s1bwC/saOXJkmX9GURQWLVpUAdGImkTKRikbhRDFSdkoZWN1IUm3qFJcXFyYOHEiCxYsYMeOHeTk5NCoUSNeffVVIiMj7+oYer2eqKgofvzxR7799lsKCgq0n//73//OnDlzWLlypTY/45AhQ3jrrbfKHKuPjw9jxoxh5cqV/L//9/+wWq18+OGHWuEJhQNjHD16lPvvvx9nZ+e7Om7Hjh358MMPWbZsGWvWrMFqtdKgQQMGDBig7TNu3Dhmz57Nxo0bUVWVDh068O677/LnP//Z5lghISGMHDmSzZs3c/z4cVRVZcaMGVJ4VpDHH39cmmaJCiFlo5SNQojipGyUsrG6UFR7jgIghLBx6NAh/vWvfzFp0iTuu+8+R4cjhBBVgpSNQghRnJSNNZf06RaiAm3dupX69evTunVrR4cihBBVhpSNQghRnJSNNZc0LxeiAuzZs4fLly9z9OhRXnrpJWlyXMukpKSg0+nw8/PDarVy+PBhdu7cSV5ens1AJu7u7jRt2lTm6ha1hpSNQghRnJSNNZ80LxeiAjz11FO4ubnRs2dPxowZg5OTk6NDEpXkypUrjB8/npdeeomWLVsybdo0bt68Wep8noqisHjx4kqOUgjHkLJRCCGKk7Kx5pOkWwgh7GjWrFkcP36cL7/8kgkTJpCcnMyLL77IV199xeuvv06rVq2Awqk7Jk6cSOfOnfnjH//o4KiFEEIIIURFkeblQghhR6dPn6Zbt27odDquXLnC008/TceOHVEUBR8fH+rVq6ft27t3bw4fPuzAaIUQQgghREWTgdSEEMKOkpOTady4MQB+fn6oqoqTkxPNmjUrNuVGQEAAycnJjghTCCGEEEJUEkm6hRDCzqxWKwDDhw9n69atAPzzn/8kJCTEkWEJIYQQQggHkOblQghhR35+fly+fBmA3Nxc3NzceP311+nZsyf+/v7odL+96zxw4AAuLi6OClUIIYQQQlQCSbqFEMKOOnTowO7du3niiSeYP3++tn7jxo3F9pVxLIUQQgghaj4ZvVwIIewoKSmJv/3tbwQEBPDMM8/QrFmzYvtcvnyZH374gZSUFN577z1at27tgEiFEEIIIURlkKRbCCHs7MiRI3z55ZeYzWYaNGhAkyZNcHNzIzc3l6tXr5KYmIiLiwvjxo2jS5cujg5XCCGEEEJUIEm6hRCiAty4cYNVq1Zx9OhRUlNTtfUGg4GWLVvy/PPPl1gLLoQQQgghahZJuoUQogKtX7+eRYsWkZuba7Pezc2NZ555hiFDhjgoMiGEEEIIURlkIDUhhKggO3bsYO7cuYSGhvLggw9q83dfu3aN9evXM2fOHAwGA3379nVwpEIIIYQQoqJITbcQQlSQt956Cw8PDz744AObqcKgcC7vyZMnk52dzb/+9S8HRSiEEEIIISqa7vd3EUIIUR4JCQn06NGjWMINoNPp6NGjBwkJCQ6ITAghhBBCVBZJuoUQooIYDAaSk5NL3Z6cnIzBYKjEiIQQQgghRGWTpFsIISpIp06d2LBhA3v27Cm2be/evWzYsIHOnTs7IDIhhBBCCFFZpE+3EEJUkIyMDD788EMSEhLw8fGhYcOGAFy/fh2j0Ujjxo2ZOHEiXl5eDo5UCCGEEEJUFEm6hRCiAuXl5bFlyxaOHTtGSkoKAP7+/oSHhzNw4EBcXFwcHKEQQtQMmzZtYtOmTVq3nsDAQJ544gnCw8OBwvJ43rx57N27l/z8fMLCwhg9ejQ+Pj7aMVJSUvj22285ffo0bm5uRERE8Oyzz+Lk5OSISxJC1BCSdAshhBBCiGrv8OHD6HQ6GjZsiKqq7Nixg9WrV/PPf/6TJk2a8O2333L06FGioqIwGAzMmjULnU7HRx99BBTOKvHWW2/h4+PDCy+8QFpaGjNmzGDAgAE8++yzDr46IUR1Jn26hRBCCCFEtdelSxc6depEw4YNadSoEc888wxubm6cO3cOk8nEzz//zIsvvki7du0IDg7m1Vdf5ezZs8TGxgJw4sQJ4uPjee2112jevDnh4eGMHDmSjRs3YrFYHHx1QojqTO/oAIQQoqaYNGkSiqIwYcIEnJycmDRp0u/+jKIofPDBB5UQnRBC1B5Wq5V9+/ZhNpsJDQ3lwoULFBQU0L59e22fxo0b4+/vT2xsLKGhocTGxtK0aVOb5uYdO3bku+++4+rVqwQFBZV4rvz8fPLz823WOTs74+zsXCHXJoSofiTpFkIIO7m9t46qqiiKUqafEUIIUX5XrlxhwoQJ5Ofn4+bmxptvvklgYCCXLl1Cr9fj4eFhs7+3tzdGoxEAo9Fok3AXbS/aVpoVK1awbNkybblXr16MGzfOLtcjhKgZJOkug7S0NGleJEQNp9fr8fX1LdfPTpw48Y7LNZWUjULUfPdSNlamRo0a8a9//QuTycT+/fv5+uuv76rV0b147LHHGDZsmLZc9LJVykYhar67LRsl6S4Di8VSrPmQEEKUJiYmhsDAwFKnBMvIyCA+Pp42bdpUcmT2JWWjEKKq0Ov1NGjQAIDg4GDOnz/PunXr6NmzJxaLhezsbJva7vT0dK1228fHh7i4OJvjpaena9tKU1pTcikbhRBFZCA1IYSoIJMmTeLkyZOlbj916lSF18AIIURtZrVayc/PJzg4GCcnJ6Kjo7VtCQkJpKSkEBoaCkBoaChXrlzREm2AkydP4u7uTmBgYKXHLoSoOaSmWwghHCQ/Px+dTt59CiGEPfz444907NgRf39/cnNz2b17NzExMUyYMAGDwUD//v2ZN28enp6eGAwGZs+eTWhoqJZ0h4WFERgYyIwZM3juuecwGo0sWrSIwYMHy6BoQoh7Ikm3EELYUUpKCklJSdrytWvXiImJKbafyWRiy5Yt1KtXr8zniImJYfXq1Vy8eJG0tDTefPNNunXrpm1XVZUlS5awdetWsrOzad26NaNHj6Zhw4baPllZWcyePZsjR46gKArdu3fn5Zdfxs3NrczxCCFEVZCens7XX39NWloaBoOBZs2aMWHCBDp06ADAiy++iKIoTJs2DYvFQlhYGKNHj9Z+XqfT8fbbb/Pdd9/x3nvv4erqSkREBCNHjnTUJQkhaghFrcJD565YsYKDBw9y7do1XFxcCA0N5fnnn6dRo0baPhMnTiz2QDtw4ED+9Kc/acspKSl8++23nD59Gjc3NyIiInj22WdxcnIqUzzJycnSN0eIGs7Z2blciXCRpUuX2oxieyc6nY4xY8bQv3//Mp3j2LFjnD17luDgYD777LNiSffKlStZuXIlUVFRBAQEsHjxYq5cucL06dNxcXEB4JNPPiEtLY0//elPFBQU8M0339CiRYtyjbgrZaMQNd+9lo21kZSNQtR8d1s2Vuma7piYGAYPHkyLFi0oKChg4cKFfPzxx0yfPt2mNmbAgAE2byGLHiqhsC/P1KlT8fHx4eOPPyYtLY0ZM2bg5OTEs88+W6nXUx2pqsqVK1do3Lgxen2V/u8iRJVw//3306RJEwA+//xzHnzwQVq3bm2zj6IouLq60rx58zsOzlOa8PBwwsPDS9ymqirr1q1jxIgRdO3aFYC//OUvjBkzhkOHDtGrVy/i4+M5fvw4U6dOpUWLFgCMGjWKqVOn8sILL+Dn51fisW+fi1ZRFNzd3bXPdyMtLY2tW7fi7u5OnTp18PDwkLLFASwWC5mZmWRmZlJQUED//v1LHfDPHjIzM9m6dStOTk7UqVMHT09Paa7rABaLhaysLLKysjCZTAwYMKDU33chyiM/P5/ExEQCAwPv+u+CELVBlX7SmTBhgs1yVFQUo0eP5sKFCzaj/bq6upb64HrixAni4+N5//338fHxoXnz5owcOZIFCxbw1FNPycPe79izZw9z5sxh8ODBPPXUU44OR4gqLzAwUBtwZ+zYsbRp04aAgIBKO39SUhJGo1FrTglgMBgICQkhNjaWXr16ERsbi4eHh5ZwA7Rv3x5FUYiLi7OpNb/V7XPRBgUF8emnn9517Zeqqvztb38jLS2tnFcnKsrJkyf5z3/+U2HH/8c//kFsbGyFHV+Uz549e1i4cKGMLSHsZt68eezdu5fXX3+dsLAwR4cjRJVRrTJOk8kEgKenp836Xbt2sWvXLnx8fOjcuTOPP/44rq6uAMTGxtK0aVObpLxjx4589913XL16laCgoGLnsUdtTk2xfPlyADZu3Ch9moQoo8jIyEo/p9FoBMDb29tmvbe3t7bNaDQWq9V0cnLC09NT26ckpc1Fm5ycfNdz0fbs2ZO1a9fe1b7l0bhsvYaqlWsFFXfsbt26cf369Qo7fufOnSs06VZdDODq8fs7VjeWPJSc9N/fr5x69uzJjRs37mpfvV4vzcvF79q7dy9Q+NwoSbcQv6k2SbfVamXu3Lm0atWKpk2baut79+6Nv78/fn5+XL58mQULFpCQkMCbb74JFD5c3l4LXvQwWtrD5b3W5tQkt3b5v3UQJiHE3cnLy+PAgQNcvHgRk8mE1Wq12a4oCmPHjnVQdGVT2ly0YFtW3MmIESMYMWIEUFium0wmsrKytKbOmZmZ2nJJ381mc6nHdgFe8aqZL0fNqspHv9NAwM3NDU9PT6359q3fi75uXe/u7m5Tw1mRQ7wMHDiQgQMHaufJycnRmjkX3dtbl29fl52dfcf41PohqEElt9CozpTrv6Cc233HfQwGg819vdPnolG7K+u+CyGEKGS3pNtqtbJv3z5Onz5Neno6I0eOpGnTpphMJqKjo2nVqlW5+i4WmTVrFlevXmXy5Mk264v+iAM0bdoUX19fJk+eTGJiIg0aNCjXuexRm1NT3PrHuCJrQYSoKuxZm5OcnMykSZNITk7GYDBgMpnw9PTUku86derYfbTwonI2PT0dX19fbX16ejrNmzfX9snIyLD5uYKCArKysu6pnC4rnU6nJQJ3W17n5eUVS8x++OEHcnJyaOtSMxNuAFdFIdRZJTYffH19efLJJ4sl0dWlj7SiKBgMBgwGw113vbBarWRnZ9sk5klJSSxduhQA1adxRYbsMKrPby+7Bw0aRIsWLWySaBkTQQhRFdy4cYOdO3cyaNCgYi3tRCG7lNTZ2dl88sknxMXF4ebmRm5uLg8++CBQ+OZ9zpw59O3bt9wDl82aNYujR48yadIk6tate8d9Q0JCALSk28fHh7i4OJt90tMLm2qV9nBpj9qcmqg2X7sQ5TF//nxMJhNTpkwhICCAMWPG8MYbb9CqVSvWr1/Phg0bio1dca8CAgLw8fEhOjpaS7JNJhNxcXEMGjQIgNDQULKzs7lw4QLBwcEAnDp1ClVVtTK0qnJxccHPz08b/MlisTBnzhwAQqpHzlluLZwhNr/wBUn37t0dHU6l0ul0Wm19katXr2pJN841dKo7nTOqTo9itdCyZUs6derk6IiEEKKYefPm8csvv5CRkcEf//hHR4dTJdll5IwFCxZw9epVJkyYwFdffWV7Ap2OHj16cOzYsTIfV1VVZs2axcGDB/nggw/u6o34pUuXALQantDQUK5cuaIl2lA4YIy7u7s22JEQQlSE06dPM2jQIEJCQrTmnKqq4uzszCOPPEK7du2YO3dumY+bm5vLpUuXtPIuKSmJS5cukZKSgqIoDB06lOXLl3P48GGuXLnCjBkz8PX11UYzDwwMpGPHjsycOZO4uDh++eUXZs+eTc+ePavdSMZ6vV57mbDeBNFmtca9ILSqKkfMKttyCpeHDh3q2ICqiCZNmtC5c2cAdGd+huxUB0dkZ7lZ6M5sRbFaaNasmfSPFUJUWb/88gsABw8edHAkVZddaroPHTrEkCFD6NChA5mZmcW2N2zYkO3bt5f5uLNmzWL37t2MHz8ed3d3rQ+2wWDAxcWFxMREdu/eTadOnfD09OTKlSt8//333HfffTRr1gyAsLAwAgMDmTFjBs899xxGo5FFixYxePDgatMUTwhRPZnNZu1lYdFgjEUDQkLhS8H58+eX+bjnz59n0qRJ2vK8efMAiIiIICoqiuHDh2M2m5k5cyYmk4nWrVvz7rvv2kyn+PrrrzNr1iwmT56Moih0796dUaNGles6HW3YsGEcPXqUxMREFmfDnlx4wKASpAddNW5uXqCqnMuHzTlw49dB1IKCgujXr59jA6tCnnvuOc6dO0dGRjpOR1dhDeqM2qgt6KrxiHqqipIUhxK3D6UgDxcXF15++WWcnKrxNQkhRC1nl6TbZDLdsRa6oKCAgoKyD7u6adMmACZOnGiz/tVXXyUyMhK9Xk90dDTr1q3DbDZTt25dunfvrg3SA4U17W+//Tbfffcd7733Hq6urkRERMhI3HepptUYCVGZ/P39uXnzJlA4Orifnx/nzp3TmgbHx8fbJMJ3q23btixZsqTU7YqiMHLkyDuWc56enowbN67M566KXF1d+eCDD9i4cSMbNmwg3mxmTiYYFAhxVmnpXNj0vI6u6ifgxoLCRDsuH85bIPfXIthgMDBs2DD69+8vfXhv4e3tzYcffsjcuXOJjo5Gd+Eg6pUTqPWCUeuHQJ0AqC4vXrJTC5PtG+dR8rKBwpcso0ePLvcYNUIIIaoGu/zlbtCgARcvXix1+4kTJ8rVlPtOD5VQ+EB7a21PaerVq8c777xT5vMLUVslJyfzr3/9iwceeIAHHnjA0eFUW+3atePw4cM8+eSTQOEUYitXriQrKwtVVdm5cycREREOjrJmcHV15ZFHHiEiIoLVq1dz4MABTDk5nMyDk3mF+zR0UglxhpbO0FQP+iqQjOWrKpfyKUy0LZB02/tpDw8PevfuzUMPPYSHRw2cEssOfHx8GDduHDt37mTVqlWkp6ejXD8D18+gunmhBrRA9WsCdfxBqULzUasqmNJQUq+iJJ1HuaV5vLu7O4MHD2bo0KFSwy2EEDWAXZLu/v37s2DBAtq2bUu7du209fn5+Sxbtozjx4/z5z//2R6nEkJUgp9++ombN2+yaNEiSbrvwaOPPkpcXBz5+fk4Ozvz2GOPkZaWxoEDB9DpdPTu3Zs//OEPjg6zRvH29uaFF17gmWee4eLFi0RHR3Pq1CkuX77M9QK4XgC7cgunFwtyLkzCQ5zBX1c5I5+rqsqNgsKa7HP5cNkCt86JoSgKwcHBtGvXjnbt2tG8eXOb6Z1EyRRFISIigt69e3PmzBn279/P0aNHMedmoFw5BleOoepdUX0bg29g4XdHzOudn4uSdg3SrqGkxaPk/dbdxMnJiQ4dOnD//ffToUMH6QInhBA1iF2S7qFDh3L16lW+/PJLDAYDAP/+97/JzMzEarUycOBA+vfvb49TCSEqQVZWlqNDqBH8/f3x9/fXll1cXHjllVd45ZVXHBhV7aDX62nZsiUtW7ZkxIgRZGRkEBMTQ3R0NDExMWRkZHA2H87mF+7vrYM2zird3KCek/2T7+sWlQNm+CUPsm7rtePr66u9tG7Tpo3UaN8DJycn7YWF2Wzm2LFjHDlyhDNnzpCTk4OSfAGSLwCgGnxR6zZDrRcEHn4V1ww9JwMl+SLKzUsomck2m1xcXAgNDSU8PJwuXbrg6elZMTEIIYRwKLsk3Yqi8MorrxAZGcn+/fu5fv06qqpSv3597r//ftq0aWOP0wghRLVhNpsZO3Ysjz76KI888oijw6n1vLy86NGjBz169MBqtXLt2jVOnz7N6dOniY2NJd1iYZ8Z9pmhhV6luxu0cgane0jELKrK6Tw4YIYrt1Rnu7i40KpVK9q2bUvbtm1p2LBhjZ1f3JFcXV21e15QUMCFCxc4ffo0p06dKhz535SGYkqDq8dR3b0L+4HXCwKD770n4DmZKCkXCpPtrBSbTY0bN9ZesoSGhkqNthBC1AL3nHSbzWa++uorunfvTp8+fWjdurU94hJCiGrN1dUVJycnXF1dHR2KuI1Op6NJkyY0adKEIUOGYDab+eWXX9i5cycnTpzgvEXlfBb46mCoQaW1c9manquqyok82GiCzF9rtZ10Ojp36UKfPn1o2bKlJFqVzMnJSWv58Oijj5KVlcWpU6c4fPgw0dHRWHLSf2uG7umPNagr+DYu+4kyU9BdPIhiTNBW6XQ6WrduTZcuXejQoYM2pakQQoja456TbldXV6Kjo+nYsaMdwhFCiJqje/fu7N+/n0GDBklNZhXm6upKWFgYYWFhpKSksH37dnbt2kVaVhYLsgprvIcaVOreRbPzGxaVn0xw6deabW9vbyIjI+nbty8+Pj4VeyHirnl6emq14Dk5OZw4cYJDhw5x6tQpLFkpOEWvR/VtjDWoG3jW/f0D5mSgXDqM7tem64qi0Lp1a7p27UqnTp2oU6dOBV+REEKIqswuzctbt25NbGwsAwcOtMfhhBCiRujZsyezZs1i0qRJDBgwgHr16pU4RVhwcLADohMl8ff354knnuDhhx9mzZo1bNy4kbP5BVxMh2c8VVq6lJ54R5tVlmVDAeDi7Mywhx9m0KBBUqtdxbm7u2sJeGZmJmvWrGHbtm0UpF3DKW0l1uBuqI3bldrkXEk6jy52J1gLtDnvH330UerVq1fJVyKEEKKqskvSPWrUKKZMmaKNdFy37l28FRZCiBru1ikNz5w5U+p+ixcvroxwRBm4urry+OOP06tXL+bOncu5c+eYnwWPeaiEuxZPvvbmqqz7dSDq9u3b8/zzz9sMoieqhzp16vDMM88wcOBAli5dypEjR9BdOIA16yZqaB/Q3TJ9l6oW1m5fPQFAq1atePrpp2natKmDohdCCFFV2SXpfuuttygoKGDFihWsWLECJyenEt/sf//99/Y4nRBCVAtjx451dAjiHjVo0IA333yT2bNnc+DAAZZnQ4CTSmP9b4n3ubzfEu7+/fvzzDPPyDRf1Vy9evUYO3YsP//8M4sWLYKkOKwu7qjB3bV9lOtntIR7yJAhPP7443LfhRBClMguSXf37t2lv6IQQtwmMjLS0SEIO9Dr9YwePZqCggIOHz7MimwY66XipCjkqSqrfk24IyMjefbZZ+XvYQ2hKAoDBgzAx8eHb775Bl38KQr8g8ArAHKzUC4eAuDJJ59kyJAhDo5WCCFEVWaXpDsqKsoehxFCCCGqJJ1Ox3PPPceZM2dIzM4mOg86usKhXDBawc/PjyeffFIS7hqoc+fO9OjRg/3796O7sB9r2MMolw6hFOQTEhLCoEGDHB2iEEKIKs4uSbcQQojivvnmm9/dR1EUaYZeTXh5eTF48GCWL1/Orlxo76KyJ7dw2yOPPIKbm5tjAxQV5sknn+To0aPkZSShXD2BLuk8gHQlEEIIcVfsknTv2LHjrvaLiIiwx+mEEKJaOH36dLF1VqsVo9GI1WrFy8tL5vGuZvr168eqVau4UVDAmXzIUMFgMNCjRw9HhyYqkI+PD7179+bnn39Gd+kwUDhgXvPmzR0bmBBCiGrBLkn33dTmgCTdQlQX0kTWPr7++usS11ssFrZs2cLatWt5//33KzkqcS8MBgNNmzbl4sWL7M4pXNeyZUuZFqwWaNasmc2yJNxCCCHull2S7hkzZhRbZ7VaSU5OZuPGjaSkpEi/byGqEVVVHR1CjabX6xkyZAjx8fHMmjWLd955x9EhiTIIDg7m4sWLxBcULgcFBTk2IFEpGjdubLPcqFEjB0VSc6SmphITE0NGRgbdu3enbt26WK1WTCYTBoNBmu4LIWoMuyTd9erVK3F9/fr1adeuHVOnTmXDhg2MHj3aHqcTQogaoVmzZuzcudPRYYgyur3G8/ZlUTM1atQIRVG0l5K3J+Hi7qmqyrx589iwYQNWqxWApk2bUrduXXJzc4mKiuKpp57ioYcecnCkQghhH5XyCrFz587s27evMk4lhBDVxsmTJ6VPdzUUEBBwx2VRM7m6utp0I/D29nZgNNXb6tWrWbduHQ8//DDvvfeezTaDwUC3bt04cOCAg6ITQgj7q5TRyxMTE8nPz6+MUwkhRJWxbNmyEtdnZ2dz5swZLl68yPDhwys5KnGvfHx8bJZ9fX0dE4hwKIPB4OgQqq2tW7cSERHBs88+S2ZmZrHtzZo14/jx45UfmBBCVBC7JN0xMTElrjeZTMTExLB+/Xq6du1qj1MJIUS1sXTp0hLXe3h4UL9+fcaMGcOAAQMqOSpxr7y8vGyWpbVC7ST9jcvv5s2bhIaGlrrd1dUVk8lUiREJIUTFskvSPWnSpFK36XQ6evTowahRo+xxKiGEqDYWL17s6BBEBZAku/aSmR3sw8vLi5s3b5a6/cKFC/j7+1diREIIUbHsknR/+OGHJa739PTE399fmmAJIWqlmJgYAgMDi9WMFsnIyCA+Pp42bdpUcmRCCOE43bt3Z/PmzURGRhZ7Rjxx4gTbt2+XrjdCiBrFLkm3PDAKIURxkyZN4rXXXqN3794lbj916hRffvml1IgLIWqVp556itOnTzN+/Hhat24NwKpVq1i8eDGxsbEEBQXx2GOPOThKIYSwnwobSM1sNrNnzx4sFgvh4eGlTismhBC1VX5+vvQLFaIakebl9mEwGJgyZQo//fQT+/fvx8XFhZiYGBo0aMCTTz7JI488gouLi6PDFEIIu7FL0v2f//yHuLg4pk2bBoDFYmHChAlcvXoVKCxcP/jgA4KCguxxOiGEqLJSUlJISkrSlq9du1biYJMmk4ktW7ZU2AtJq9XKkiVL2LVrF0ajET8/PyIiInj88ce1xEFVVZYsWcLWrVvJzs6mdevWjB49moYNG1ZITEIIUcTFxYXHH3+cxx9/3NGhCCFEhbNL0n369Gn69OmjLe/evZurV6/y2muv0bx5c6ZNm8bSpUsZP368PU4nhBBV1rZt22ymClu+fDnLly8vcV+dTseYMWMqJI6VK1eyefNmoqKiCAwM5MKFC3zzzTcYDAaGDh0KFDbnXL9+PVFRUQQEBLB48WKmTJnC9OnTpZZJCFFhJk2axIgRI2jfvn2J20+dOsX//ve/UscMEkKI6sYuSbfRaLSprTl48CDBwcFaP8YBAwawevXqMh93xYoVHDx4kGvXruHi4kJoaCjPP/88jRo10vbJy8tj3rx57N27l/z8fMLCwhg9erTNPKopKSl8++23nD59Gjc3N21uSCcnp/JftBBClOD++++nSZMmAHz++ec8+OCDWp/FIoqi4OrqSvPmzYvN+WwvsbGxdOnShU6dOgEQEBDA7t27iYuLAwprudetW8eIESO0KR3/8pe/MGbMGA4dOkSvXr0qJC4hqjNVVR0dQo0QExNzx+kSMzIySp2OVgghqiO7JN23zqdYUFBATEwMQ4YM0ba7ubmVa77FmJgYBg8eTIsWLSgoKGDhwoV8/PHHTJ8+HTc3NwC+//57jh49yl//+lcMBgOzZs1i2rRpfPTRR0BhE8upU6fi4+PDxx9/TFpaGjNmzMDJyYlnn33WDlcvhBC/CQwMJDAwEICxY8fSpk0bAgICKj2O0NBQtm7dSkJCAo0aNeLSpUucPXuWP/zhDwAkJSVhNBrp0KGD9jMGg4GQkBBiY2NLTLrz8/PJz8/XlhVFwd3dXftcW9Xma6/N5L5XnMTERK1sEUKImsAuSXdwcDBbt26lbdu2HD58mJycHLp06aJtv3HjBt7e3mU+7oQJE2yWo6KiGD16NBcuXKBNmzaYTCZ+/vlnxo0bR7t27QB49dVXeeONN4iNjSU0NJQTJ04QHx/P+++/j4+PD82bN2fkyJEsWLCAp556Cr2++D+BPFiWrDZfe20m9738IiMjHXbuRx99lJycHN544w10Oh1Wq5Wnn35a6wpkNBoBipXN3t7e2rbbrVixwqbpfFBQEJ9++mmtHyhT+sDXHrcOfCj3vWy2b9/Ojh07tOXly5ezdevWYvuZTCYuX75MeHh4ZYYnhBAVyi5J99NPP82UKVN4++23gcL5F0NCQrTtBw8epFWrVvd8nqLack9PTwAuXLhAQUGBTZ+gxo0b4+/vryXdsbGxNG3a1KYJZ8eOHfnuu++4evVqiYO7yYPlb+QBo3YqakkCct/vVV5eHgcOHODixYuYTCasVqvNdkVRGDt2rN3Pu2/fPnbv3s3rr79OkyZNuHTpEnPnzsXX17fcLwMee+wxhg0bpi0XvZBJTk7GYrHYI+xq6fr1644OQVSSW5uX17b7rtfr7+k5KC8vj4yMDG05Jyen2Evdoq43DzzwAE888US5zyWEEFWNXZLuFi1a8MUXX3D27Fk8PDxs5u3Ozs5m8ODB9zyXt9VqZe7cubRq1YqmTZsChTU1er0eDw8Pm31vrakxGo3F+kwW1eyUVpsjD5a/uTVBqG0PGLVZbm6u9rm23fd7fbC8VXJyMpMmTSI5ORmDwYDJZMLT01NLvuvUqWPzgsOefvjhB4YPH641E2/atCnJycmsXLmSyMhIrVxMT0/H19dX+7n09HSaN29e4jGdnZ1xdnYucVtt7utam6+9trn1Xst9L5tBgwYxaNAgoLDl4ssvv2zTKlIIIWoyu83T7eXlpQ3GcysPDw9tpNx7MWvWLK5evcrkyZPv+Vi/Rx4sS1abr702k/tefvPnz8dkMjFlyhQCAgIYM2YMb7zxBq1atWL9+vVs2LChWDcaezGbzcXmANfpdNr9DAgIwMfHh+joaC3JNplMxMXFaQ/GQghREb7++mtHhyCEEJXKLkl3SkoKKSkpNiP0Xrp0iTVr1pCfn0+vXr3o1q1buY8/a9Ysjh49yqRJk6hbt6623sfHB4vFQnZ2tk1td3p6ulaL4+Pjo43We+v2om1CCFFRTp8+zaBBgwgJCSErKwsofInh7OzMI488Qnx8PHPnzuWdd96x+7k7d+7M8uXL8ff3JzAwUCuT+/XrBxS24Bk6dCjLly+nYcOGBAQEsGjRInx9fUt8gSqEEBUhJycHk8lU4gtef39/B0QkhBD2Z5eke/bs2ZjNZt5//32gsNn2pEmTsFgsuLu7s3//fv7617/SvXv3Mh1XVVVmz57NwYMHmThxYrERgIODg3FyciI6OpoePXoAkJCQQEpKCqGhoUDhCL7Lly8nPT1da1Z+8uRJ3N3dtRGGhRCiIpjNZq3cKhqM8daZHEJDQ5k/f36FnHvUqFEsXryY7777jvT0dPz8/Ir1kxw+fDhms5mZM2diMplo3bo17777rszRLYSocJs2bWLNmjXcuHGj1H0WL15ciREJIUTFsUvSff78eR588EFteefOneTl5TFt2jQCAgL45JNP+Omnn8qcdM+aNYvdu3czfvx43N3dtT7YBoMBFxcXDAYD/fv3Z968eXh6emIwGJg9ezahoaFa0h0WFkZgYCAzZszgueeew2g0smjRIgYPHlxqE3IhhLAHf39/bt68CYCTkxN+fn6cO3dOKwvj4+MrLMF1d3fnpZde4qWXXip1H0VRGDlyJCNHjqyQGIQQoiSbNm1i1qxZhIWF0a9fPxYtWsRDDz2Es7Mz27dvx8fHx+a5Ugghqju7JN1ZWVk2084cOXKENm3a0KBBAwC6devGwoULy3zcTZs2ATBx4kSb9a+++qo2+u6LL76IoihMmzYNi8VCWFgYo0eP1vbV6XS8/fbbfPfdd7z33nu4uroSEREhD5lCiArXrl07Dh8+zJNPPgkUTiG2cuVKsrKyUFWVnTt3EhER4eAohRCicm3YsIGwsDDeffddMjMzWbRoEZ06daJdu3YMHz6ct99+m8zMTEeHKYQQdmOXpNvLy4vk5GSgcLTyc+fO8eyzz2rbrVZrsWly7saSJUt+dx8XFxdGjx5tk2jfrl69ehXSZ1IIIe7k0UcfJS4ujvz8fJydnXnsscdIS0vjwIED6HQ6evfuzR/+8AdHhymEEJXqxo0bDB48GChsBQRos8MUtWLctGkTDz/8sMNiFEIIe7JL0t2+fXvWr1+PwWDg9OnTqKpqM3BafHy8zQBoQghRG/j7+9sMBOTi4sIrr7zCK6+84sCohBDCsQwGAwUFBdpnFxcXUlJStO23dikUQoiawC5J97PPPsv169eZP38+er2eF154QRs8KD8/n3379mlzxQohRG1nsViwWCwVNke3EEJUZU2aNOHy5cvacmhoKJs3b6ZTp05YrVa2bNlCw4YNHRihEELYl12Sbh8fHz766CNMJhMuLi7o9b8dVlVV3n//fZn2QQhR6+zZs4dz587ZDGa2dOlSli9fDkCnTp147bXXJPkWQtQqffr0YfPmzVrXmyeffJKPPvqIsWPHAqDX6/nb3/7m4CiFEMJ+7JJ0FzEYDMXWubi40Lx5c3ueRgghqoU1a9bYlH9nz55l2bJlhIeHExgYyPr161m+fLnNGBhCiKpLURRHh1Aj9OvXj379+mnLrVu3Zvr06Rw5cgSdTkeHDh1o1KiRAyMUQgj7slvSnZKSwvLlyzl9+jQZGRm89dZbtGnThoyMDJYtW0a/fv0ICgqy1+mEEKLKS0xMtBmdfPfu3fj4+PDWW2/h5OSE1WrlwIEDknQLUU2oquroEKq9vLw8tmzZQvPmzWnTpo22vn79+gwdOtSBkQkhRMWxS9IdHx/PBx98gKqqhISEkJiYqI1W7uXlxdmzZzGbzVqzISGEqA0sFgvOzs7a8smTJ+nYsaM2Wm9gYKA2NaIQQtQGLi4uLFiwgJdfftkm6baHFStWcPDgQa5du4aLiwuhoaE8//zzNrXmeXl5zJs3j71795Kfn69NNevj46Ptk5KSwrfffsvp06dxc3MjIiKCZ599Viu7hRCirHT2OMgPP/yAh4cHX375Ja+99lqx7eHh4fzyyy/2OJUQQlQbAQEBREdHA3D+/HkSExPp2LGjtj09PV36cwshap2mTZtqU83aU0xMDIMHD2bKlCm89957FBQU8PHHH5Obm6vt8/3333PkyBH++te/MmnSJNLS0pg2bZq23Wq1MnXqVCwWCx9//DFRUVFs376dxYsX2z1eIUTtYZek+8yZMzzwwAN4eXmV2N/J39+f1NRUe5xKCCGqjYEDB7Jv3z7efPNNPv74Y/z8/OjcubO2/ezZszRp0sSBEQohROV7+umn2bJlCydPnrTrcSdMmEBkZCRNmjShefPmREVFkZKSwoULFwAwmUz8/PPPvPjii7Rr147g4GBeffVVzp49S2xsLAAnTpwgPj6e1157jebNmxMeHs7IkSPZuHGjNpe4EEKUlV2al1utVlxdXUvdnpGRYTOiuRBC1AYPPvggzs7OHDt2jODgYIYPH46LiwsAWVlZGI1GHnjgAQdHKYQQlWvDhg14enoyZcoUAgICCAgI0MrGIoqiMH78+Hs6j8lkAsDT0xOACxcuUFBQQPv27bV9GjdujL+/P7GxsYSGhhIbG0vTpk1tmpt37NiR7777jqtXr5Y4PlF+fj75+fk2sbu7u2ufa6vafO21mdz3ktklEw4ODubo0aMMHjy42LaCggL27t1LaGioPU4lhBDVysCBAxk4cGCx9Z6envzjH/9wQERCCOFYV65cAQpbQlqtVhITE4vtc68P7larlblz59KqVSuaNm0KgNFoRK/X4+HhYbOvt7c3RqNR2+fWhLtoe9G2kqxYsYJly5Zpy0FBQXz66afUq1fvnq6hOnNxcZG51mshRVHkvpfCLkn3o48+yj/+8Q++/fZbevXqBRQWTCdPnmTFihVcu3aNUaNG2eNUQgghhBCiGvv6668r/ByzZs3i6tWrTJ48ucLP9dhjjzFs2DBtueiFQXJycq1tkp6Xl8f169cdHYaoZKqq1rr7rtfr7+oFm12S7vDwcKKiopgzZw5btmwB4KuvvgLA3d2dqKgou49QKYQQQgghxO1mzZrF0aNHmTRpEnXr1tXW+/j4YLFYyM7OtqntTk9P12q3fXx8iIuLszleenq6tq0kzs7ONjNV3Ko2TzNXm6+9NpP7XjK7dbTu27cv3bp14+TJk9qUYQ0aNCAsLEzr1yKEEEIIIURFUFWV2bNnc/DgQSZOnEhAQIDN9uDgYJycnIiOjqZHjx4AJCQkkJKSonWDDA0NZfny5aSnp2vNyk+ePIm7uzuBgYGVe0FCiBrjnpPuovm3H330UR555BG6detmj7iEEEIIIYS4a7NmzWL37t2MHz8ed3d3rQ+2wWDAxcUFg8FA//79mTdvHp6enhgMBmbPnk1oaKiWdIeFhREYGMiMGTN47rnnMBqNLFq0iMGDB5damy2EEL/nnpNuV1dXnJyc7jh6uRBCCCGEEBVp06ZNAEycONFm/auvvkpkZCQAL774IoqiMG3aNCwWC2FhYYwePVrbV6fT8fbbb/Pdd9/x3nvv4erqSkREBCNHjqysyxBC1EB2aV7evXt39u/fz6BBg2SYeCGEEEIIUemWLFnyu/u4uLgwevRom0T7dvXq1eOdd96xZ2hCiFrOLkl3z549mTVrFpMmTWLAgAHUq1ev2HyLUNiXRgghapOsrCz27NnDjRs3yM7OLjbAiKIojB071kHRCSGEEEKIimaXpHvSpEna5zNnzpS63+LFi+1xOiGEqBaOHz/O9OnTMZvNuLu7F5sbFu59LlohROWR31f7+OSTT7QBeEuqpBFCiJrGLkm31NIIIURx8+fPx8fHhzfffJOmTZs6OhwhhKgSbty4wVdffYWbmxtdu3alb9++tG/fXl5qCCFqLLsk3UWDUwghhPhNYmIizz//vCTcQghxiy+//JK4uDh27drFvn372LVrFz4+PvTu3Zs+ffrQvHlzR4cohBB2Zbd5uoukp6eTnJwMFA5EUTTHoRBC1DYNGjQgJyfH0WEIIUSVExISQkhICC+++CInT55k165dbNmyhTVr1hAYGEjfvn3p3bs3devWdXSoQghxz+yWdEdHR7NgwQIuXrxosz4oKIhnn32WDh062OtUQghRLTz99NPMmjWL3r17ExAQ4OhwhBCiytHpdHTs2JGOHTuSnZ3Nf//7X/bv38+PP/7IwoULadu2LQ899BCdOnVydKhCCFFudkm6Dx48yPTp0/H29mb48OE0bNgQgISEBHbu3MnUqVN544036Natmz1OJ4QQ1UJ0dDReXl688cYbdOjQgbp166LT6Wz2URSFl19+uULOn5qayg8//MDx48cxm800aNCAV199lRYtWgCgqipLlixh69atZGdn07p1a0aPHq2V4UIIURl++eUXdu7cyYEDB8jKyqJJkyb07dsXvV7Ptm3b+PTTTxkxYoTMlS2EqLbsknQvWrSIJk2aMHnyZNzd3W22PfbYY3zwwQcsWrSozEl3TEwMq1ev5uLFi6SlpfHmm2/aHOPrr79mx44dNj8TFhbGhAkTtOWsrCxmz57NkSNHUBSF7t278/LLL+Pm5laOKxVCiLu3ceNG7fPRo0dL3a8iku6srCzef/992rZty7vvvouXlxfXr1+3GUF91apVrF+/nqioKAICAli8eDFTpkxh+vTpMqKwEKJCxcfHs3PnTvbs2UNKSgre3t5ERETQt29fmz7dQ4cOZebMmWzcuFGSbiFEtWWXpPvGjRs899xzxRJuAIPBQP/+/fnxxx/LfFyz2Uzz5s3p378/n332WYn7dOzYkVdffVVb1uttL+nf//43aWlpvPfeexQUFPDNN98wc+ZMxo0bV+Z4hKgtbp9LWpSPI6dJXLVqFXXr1rUpH29t4q6qKuvWrWPEiBF07doVgL/85S+MGTOGQ4cO0atXr0qPWQhRO7z11ltcuXIFZ2dnunTpwujRowkLCyvWEqhI27Zt+fnnnys5SiGEsB+7JN2NGzcmPT291O1Go7FczRXDw8MJDw+/4z56vR4fH58St8XHx3P8+HGmTp2qNaccNWoUU6dO5YUXXsDPz6/MMQkhRHVw+PBhwsLCmD59OjExMfj5+TFo0CAGDhwIQFJSEkaj0Wa8DYPBQEhICLGxsSUm3fn5+eTn52vLiqJoL1tr81Q/tfnaazO57+Xn4eHBn//8Z3r06IHBYPjd/bt27cqMGTMqITIhhKgYdkm6n3/+eb744gtCQkK0GpMiBw8eZMuWLfzf//2fPU5VTExMDKNHj8bDw4N27drx9NNPU6dOHQBiY2Px8PDQEm5AmwcyLi6u1Obu8mBZstp87bWZ3Pd7Fxsby+nTp0lPT2fw4ME0bNgQs9nMtWvXaNSoUYV0d0lKSmLz5s089NBDPPbYY5w/f545c+ag1+uJjIzEaDQCFJthwtvbW9t2uxUrVrBs2TJtOSgoiE8//ZR69erZPf7qRPrA1x63lody38snLy+Pbt260aBBg7tKuAFcXV1rfTkjhKje7JJ0r1+/Hi8vLz777DP8/Pxo0KABUDhHbWpqKo0aNWL9+vWsX79e+xlFURg/fvw9nbdjx450796dgIAAEhMTWbhwIZ988glTpkxBp9NhNBrx8vKy+RknJyc8PT1LfagEebC8lTxg1E63JoFy38vPYrHwxRdfcOjQIW1dly5daNiwIYqiMGXKFB566CFGjBhh93NbrVZatGjBs88+CxSWY1euXGHz5s1ERkaW65iPPfYYw4YN05aLyofk5GQsFss9x1xdXb9+3dEhiEpitVq1z7Xtvuv1ers8B7m4uPDjjz/y0ksv0aZNGztEJoQQVZ9dku4rV64A4O/vDxTWsEDhNBD+/v7k5eVp+xSxR+3Zrc0fmzZtSrNmzXjttdc4ffo07du3L/dx5cHyN7X5AaM2M5vN2ufadt/t9WAJhYNMHjlyhDFjxtC2bVubFj8uLi706NGDQ4cOVUjS7evrS2BgoM26wMBADhw4AKB1y0lPT8fX11fbJz093WYQo1s5Ozvj7Oxc4rbaPA5Abb722kzue/k1adKE5ORkR4chhBCVxi5J99dff22Pw9yz+vXrU6dOHRITE2nfvj0+Pj5kZGTY7FNQUEBWVlap/cBBHixLU5uvvTaT+15+e/bs0fpRZ2ZmFtveuHFj9u/fXyHnbtWqFQkJCTbrEhIStBcKAQEB+Pj4EB0drSXZJpOJuLg4Bg0aVCExCVHdSXcb+3j66af597//Tdu2bW3GlRBCiJrKLkl3VXHz5k2ysrK0WpvQ0FCys7O5cOECwcHBAJw6dQpVVQkJCXFkqNWGPGAIUX4ZGRk0bdq01O06nc6mVYE9PfTQQ7z//vssX76cnj17EhcXx9atW/nTn/4EFP5uDx06lOXLl9OwYUMCAgJYtGgRvr6+xcbmEEIIe9qwYQOenp5MmTKFgIAAAgICik1TaI9uiEIIUVVU6aQ7NzeXxMREbTkpKYlLly7h6emJp6cnS5cupXv37vj4+HDjxg1++OEHGjRoQFhYGFDYlLJjx47MnDmTMWPGYLFYmD17Nj179pSRy4UQFa5u3bpcu3at1O1nz57VxsCwt5CQEN58801+/PFH/ve//xEQEMCLL75Inz59tH2GDx+O2Wxm5syZmEwmWrduzbvvvitzdAtRCnkRbR+3dku0Wq02z3pF5N9aCFGTVOmk+/z580yaNElbnjdvHgARERGMGTOGK1eusGPHDrKzs/Hz86NDhw6MHDnSpmn466+/zqxZs5g8eTKKotC9e3dGjRpV6dciRHUiTcrto3fv3qxZs4YePXoUG5Buy5Yt7Nu3TxvorCJ07tyZzp07l7pdURRGjhzJyJEjKywGIWoSKRvto6p0SxRCiMpSpZPutm3bsmTJklK3T5gw4XeP4enpybhx4+wZlhBC3JURI0Zw7tw5PvzwQxo3bgzA999/T1ZWFqmpqYSHh9sM2iiEEEIIIWqeKp10C8eTt/q1063N+lRVlWZ+5aTX63n33XfZtWsX+/fvx2q1YrFYaNasGU8//TR9+/aVf1shRK0VExPD0aNHtZHM69WrR6dOnWQqMSFEjSNJtxDijiwWS6mj+YvfpygKffv2pW/fvo4ORQghqgSLxcIXX3zBoUOHADAYDEDhDAo//fQT3bp1Y9y4cej18pgqhKgZpDQTdyS1cLXTrS0ccnNzJekWQgik9Ze9LF26lEOHDvHwww8zbNgwbRrX9PR0fvrpJ3766SeWLVvG008/7dhAhRDCTsqVdEdFRZU5GVMUha+++qo8pxNVhDQzrj3y8/O1z2azmTp16jgwmurr1oEgS6IoCs7OztStW5e2bdvSo0cPnJycKik6IYRwjN27dxMREcHzzz9vs97b25vnn3+e9PR0du3aJUm3EKLGKFfS3aZNm2LJ1/nz54mPjycwMFAbpff69evEx8fTpEkTbZ5sUb1YrVbtc05OjtYETNRstybdt34WZaOqKqmpqdy4cQMPDw/q1asHQHJyMtnZ2TRo0ACDwaDNob1y5Uref/99vLy8HBy5EKIk8uLZPoxGIyEhIaVub9myJXv37q3EiIQQomKVu6b7VgcPHuTQoUO89957tG/f3mbbyZMn+fzzz2VKmmoqLy9P+5yVlSVJdy2Rm5urfTabzQ6MpHp7+umn+de//kVUVBS9e/dGp9MBhS+zdu7cyfz584mKiqJly5bs2LGDmTNn8uOPP/LKK684OHIhhKg4fn5+xMTEMGjQoBK3x8TE4OfnV8lRCSFExdHZ4yBLlixhyJAhxRJugA4dOjB48GAWLVpkj1OJSpSfn4/FYtGWb03ERM2Wk5OjfTaZTA6MpHqbP38+kZGR9O3bV0u4AXQ6HZGRkURGRvL999+jKAqRkZH069ePY8eOOTBiIYSoeBEREezbt4///ve/JCQkYLVasVqtJCQk8O2337Jv3z4iIyMdHaYQQtiNXQZSu379+h37fNapU4cbN27Y41SiEt2ebEnyVXvcmnTf+lmUzeXLl+nTp0+p2+vVq8fGjRu15eDgYHbs2FEZoQkhhMOMGDGCGzdusHXrVrZu3WrTCggKk/LHHnvMkSEKIYRd2SXpbtCgAdu2baN///64ubnZbMvJyWHbtm3Ur1/fHqcSlchoNN5xWdRM+fn5Nol2ZmamA6Op3nx9fTlw4ACDBg2yqemGwofLffv2aaP2QuG/taenZyVHKYQQlUun0xEVFcWwYcM4duyYzTzd4eHhNGvWzMERCiGEfdkl6R45ciTTp0/n//7v/4iMjKRBgwZAYQ34jh07SE9P54033rDHqUQlunnz5h2XRc108+ZNm2lxih6GRNk99NBDzJkzh/fff58BAwZoZWNiYiJbt24lLi6Ol19+Wdt///79tGjRwlHhCiFEpUhJScHLy4tmzZqVmGDn5eWRkZGBv7+/A6ITQgj7s0vS3a1bN9555x0WLFjAihUrbLY1b96cV155hY4dO9rjVKISJSUl2SxLF4Ha4fr16zbLiYmJDoqk+hsyZAg6nY7Fixczc+ZMm22enp68/PLLDBkyBChsYfDiiy9qI5wLIURNFRUVxWuvvUbv3r1L3H748GG+/PJLFi9eXMmRCSFExbBL0g0QFhZGWFgYRqPRppnQrU0nRfVy7do1ABo4QWLBb8uiZouPjwdAdTGg5Jm0ZVE+gwYNon///ly4cMGmbAwODkav/60IdnZ2pk2bNo4KUwhxF2TKsMphsViKdckRQojqzG5JdxEfHx9JtGuIS5cuARDuCutNhclYfn4+zs7Ojg1MVKiLFy8CoDZsjXL5KCkpKWRkZMjc0eWQlpaGr68ver2e0NBQQkNDHR2SEOIe3Nr1RpSNyWSyGZA1MzOTlJSUYvtlZ2ezd+9eeZYUQtQodku6TSYTa9eu5ejRo1oh6u/vT+fOnRk6dKjM71zNZGZmkpCQAEBHF9iZA9kWCxcvXpTEoQYzm8388ssvAKh+TVBTLqFkp3Ly5MlSmwGK0o0dO5Z27drRt29funXrVmygSSGEqC3Wrl3LsmXLtOW5c+cyd+7cUvcfOXJkJUQlhBCVwy5Jd2pqKh9++CFJSUk0atSIVq1aAZCQkMDSpUvZsWMHkydPxtfX1x6nE5XgzJkzANR3Ag+dQpCzyqk8iImJkaS7Bjt27BhmsxnVzQs8/VHrBaNkp7Jv3z5JusvhqaeeYs+ePXz99dd8++23dO3alb59+9KhQwdpOimEqFXCwsJwc3NDVVUWLFhAr169CAoKstlHURRcXV0JDg6WQSWFEDWKXZLuBQsWYDQa+fvf/06nTp1sth07dozp06ezYMEC/vKXv9jjdKISnDhxAoCWv7Ykb+kMp/IK1w8fPlz6tdVQR44cAUANCAZFQQ1oAZcOc/bsWTIzM6lTp46DI6xeRowYwYgRI7h48SK7du1i79697NmzBy8vL3r16kWfPn3kwVIIUSvc2sXGbDbTvXt3mjZt6uCohBCictgl6T5+/DhDhw4tlnADhIeH8+CDD7J161Z7nEpUguTkZA4dOgRAW5fCda2cC/+zXLlyhTNnzsiATzVQZmYm0dHRAKj+v9Y+uNVB9awLWTfZv38/DzzwgAMjrL6CgoIICgrihRde4NSpU+zevZvt27ezfv16GjVqRJ8+fejbt69MjyOEqBWefPJJR4cghBCVyi5Jt9lsxtvbu9TtPj4+mM1me5xKVILVq1dTUFBACz000RfWaHvqFLq6quwzw/Lly7nvvvuktruG2bx5M/n5+ah16oGHn7ZebdAaJW4PmzZtol+/fjYjbouyURSF++67j+zsbFJTC/vKJyYmsnTpUpYsWUK3bt14+eWXpSuOEKJW+OWXX7h48SImk6nEQeqeeOIJB0QlhBD2Z5en58DAQPbs2cOgQYOKPZBbLBb27NlDYGCgPU4lKlh8fDz79u0D4IHbxr6LcIcj5sLRrY8cOUKXLl0cEKGoCGlpaWzevBkAa5MOcMsLFbVBS9QrR0lNTWXr1q0MHjzYUWFWa0U13AcOHMBkMtG0aVNeeOEFevfujZOTE9u2bWPFihXMmDGD999/39HhCiFEhcnKymLq1KnExcXdcT9JuoUQNYVdku7hw4fzxRdf8M477zB48GAaNmwIFA6ktnnzZi5fvswbb7xhj1OJClRQUMD8+fNRVZW2zhCot63J9tQp9HJT2ZYLixcvpk2bNjIqfQ2gqio//vgjeXl5qF71oW5z2x10etRmXVDO7eKnn36iU6dO1KtXzyGxVjeXLl1i9+7d7Nmzh9TUVHx8fOjfvz8RERHF+jI+8sgjuLi4MH/+fAdFK4QQlWP+/PlcuXKFcePGERISwmuvvcaECRMICAhgzZo1nDt3jnfeecfRYQohhN3YJem+//77MZvNLFiwgG+//dZmm5eXF2PHjqVHjx72OJWoQGvXriUuLg5XBQaXkkv3docTeYUj1s+bN48///nP0sy8mlu3bh1Hjx4FRYe1xf02tdxF1AYtURPPkpOZxIwZM3jnnXdk+qu78Pe//x0XF5e7HrU8MDBQZgcQQtR4x44dY+DAgfTs2ZPMzEygsPtNgwYNGD16NJ999hlz587l//7v/xwbqBBC2IndOmdGRkbSp08fzp8/bzNPd4sWLXBycrLXaUQF2bVrF6tWrQJgmAH8nEpOpF0VhSc9Vb7NgEOHDlG3bl2eeOIJSbyrqUOHDrFixQoArCE9oU4pA3kpOqxtBqA7upL4+Hj++9//EhUVJb/bv6PohePdvqBo164d7dq1q+CohBDCsbKzs2nSpAmAVj7m5uZq2zt06MDChQsdEpsQQlQEu04U6+TkRGhoKD179qRnz56EhobKQ3k1sH//fr7//nsAerlBR5c7799Er/CIR+HnDRs2sHr16hIHQBFVW0xMDN999x2qqmJt1Aa1Yes7/4CrB9a2A0HnxIkTJ5g3bx5Wq7Vygq2mIiIifjfhNplMlRSNEEJUDX5+fhiNRgCcnZ3x8vLi8uXL2vbU1FR5mS+EqFHsVtNttVrZuXMnR48etanp7ty5M3369Lljk0rhOD///DM//vgjqqrSxRWGuHNXf+i6uCqYrSrrcwpHO8/Ozubpp5+W+1xNHDp0iO+++w6LxYLq3xy1xV12//CqT0HrfjjFbGX37t3k5uYyevRonJ2dKzbgauqDDz4gKiqKBg0alLj92LFj/Pe//+U///lPhcaxcuVKfvzxR4YOHcpLL70EQF5eHvPmzWPv3r3k5+cTFhbG6NGj8fHxqdBYhBDivvvu4+TJk4wYMQKAnj17smrVKnQ6HVarlXXr1hEWFubgKIUQwn7sknSbTCamTJlCXFwc7u7u1K9fH4Do6GgOHDjApk2bmDBhQpkH3YqJiWH16tVcvHiRtLQ03nzzTbp166ZtV1WVJUuWsHXrVrKzs2ndujWjR4/WBnKDwhEyZ8+ezZEjR1AUhe7du/Pyyy/X+v6oBQUFLFu2jE2bNgHQwxWGGu4u4S7Sy11Bp6isNcHWrVtJS0tj1KhRuLu7V1TY4h5ZLBZWrVrF+vXrUVUV1T8Ia+sIUMrwssS/Odb7+qH7ZTuHDx8mNTWV0aNHa7/34jc3btzgrbfe4rnnnmPIkCHa+pycHL7//nu2bdtGixYtKjSGuLg4Nm/eTLNmzWzWf//99xw9epS//vWvGAwGZs2axbRp0/joo48qNB4hhBg2bBgnT54kPz8fZ2dnnnzySeLj41m8eDFQmJSPGjXKwVEKIYT92CXpXrhwIRcuXGDUqFEMGDBAmzbMYrHw888/M2fOHBYtWlTmAtRsNtO8eXP69+/PZ599Vmx7UfIQFRVFQEAAixcvZsqUKUyfPh0Xl8I20v/+979JS0vjvffeo6CggG+++YaZM2cybty4e7/waiozM5OZM2dy5swZAPq7Qz+3siXcRe53UzAoKsuz4ejRoyQmJt6xZk84ztWrV5k1axZXr14FKGxS3qJH2RLuX6n1ginQu6GL2cKFCxeYOHEiTz75JJGRkdLa4RbTp0/nu+++Y86cORw8eJCxY8dy/fp1Zs6cidFoZOTIkTz66KMVdv7c3Fy++uor/vznP7N8+XJtvclk4ueff2bcuHFaH/JXX32VN954g9jYWBnMTQhRoZo2bWozg4Onpyfvv/8+2dnZ6HQ6eXkvhKhx7JJ0Hzx4kEGDBhWbv1ev1zNo0CDi4+M5cOBAmZPu8PBwwsPDS9ymqirr1q1jxIgRdO3aFYC//OUvjBkzhkOHDtGrVy/i4+M5fvw4U6dO1WqTRo0axdSpU3nhhRfw8/Mr8dj5+fnk5+dry4qiaH8Aqnsfo+PHjzN37lwyMjJwAR73hLYu93ZNYa4Kfk4qP2YWThM3adIkRo4cSWRkZLX/96oJMjIyWLlyJTt27Cis3XZ2w9qyF/gH3duBfRth7TwCXexO8owJLFiwgF27dvHss89K0vYrT09P/u///o8ePXowa9Ys/vrXv5KXl0dQUBB///vfi00bZm/fffcd4eHhdOjQwSbpvnDhAgUFBbRv315b17hxY/z9/e+YdNfksvFe1OZrr83kvpeP2Wzmgw8+YMCAAQwaNMhmm4eHh4OiEkKIimWXpDsrK4tGjRqVur1x48ZkZWXZ41SapKQkjEYjHTp00NYZDAZCQkKIjY2lV69exMbG4uHhYdN8s3379iiKQlxcnE1T9VutWLGCZcuWactBQUF8+umn1Xpu4vT0dObMmcPGjRsBCHCCkR5QX2+fh4YmeoVXvVWWZMHFvDzmz59PTEwMUVFRNs39ReUpejE1Z84csrOzAbD6B6GG3A8udppf3c0Ta/sHURJiUC4d4cqVK/zjH/+gb9++REVF4eXlZZ/zVHM+Pj64ubmRkZEBQPPmzQkICKjQc+7Zs4eLFy8yderUYtuMRiN6vb7YA663t7c2uFFJamLZaA9SxtUetybact/Lx9XVlaSkJHlpIYSoVeySdDdo0IDDhw8Xq+kucvjwYbv39yx6MPT29rZZf+tDo9FoLPbQ7+TkhKen5x0fLB977DGGDRumLRf9YUhOTsZisdx78JWoqIn/qlWryMnJQQF6usFAd3C28x+8OjqFl+uo7DfDJhMcOXKEP/3pTzzwwAMMGzZMmotVouzsbObMmVM4/zagetbFGtwDfCrgIVFRUBu3Ra0XjHL5CLrrZ9m5cyfR0dH86U9/olWrVvY/ZwXS6/V2SyLz8/NZuHAh69evJzAwkKlTp3L8+HH+97//cfr0acaOHUubNm3scq5bpaSkMHfuXN577z2tq4091KSy0Z6uX7/u6BBEJbl1po7adt/tWTZ27NiREydO8MADD9jleEIIUdXZJekeNGgQs2fPZurUqQwdOlR7+5uQkMD69es5efIkf/zjH+1xqkrh7Oxc6mjM1WVqLKvVyqFDh1i1ahU3btwAoKETPGSA5s4V93ZZpyj0dIOWziprsuG8xcL69evZvXs3w4YNIyIiQka6rkAFBQXs3buXlStXFr5YUnRYg7qiNm5brr7bZeLijtqyNwUNW6M7s420tDT++c9/0rdvXx555JFaOSr2+PHjSUxM5JFHHuHJJ59Er9cTHBxM586d+eabb5g8eTJDhgzRRhS3lwsXLpCens7f//53bZ3VauXMmTNs2LCBCRMmYLFYyM7OtqntTk9Pv+N9qgllY0Wozddem8l9L7/HH3+czz//nK+++ooHHniAgICAEl8Qenp6OiA6IYSwP7sk3YMHDyY9PZ1Vq1Zx/Phx2xPo9TzxxBPF+u3cq6IHw/T0dHx9fbX16enpNG/eXNunqDlnkYKCArKysmpsAmC1Wjl69CirVq0iISEBAA8FHjBAJ5fCpLgy1HNSeKmOytl82GCClMxMFi5cyIYNGxg6dCh9+vSR5NuOVFXl2LFjLF++XKt9Ud28sN7XH+r4V24wnv5YOz2KErcX3Y1z7Nixg3379vHAAw8wZMiQMs9iUN199NFHhISE2Kxr1qwZn3zyCf/73/9YuXKl3ZPu9u3bFxt88j//+Q+NGjVi+PDh+Pv74+TkRHR0ND16FE4Xl5CQQEpKivTHF0JUuL/97W8AxMfHs3v37lL3KxrNXAghqju7zdP91FNPMWTIEKKjo0lOTgagXr16tG/fvkL6dQYEBODj40N0dLSWZJtMJuLi4rQEPzQ0lOzsbC5cuEBwcDAAp06dQlXVYg/B1V1BQQEHDx5k3bp1WrLtpkBvN7jfDVwd0HdKURRau0CIs8oxM2zPhbS0NBYsWMC6desYPHgwffv2xdXVtdJjqymsViuHDx9m7dq1xMfHA6DqXVGbdkRtdB/o7PYrXjZOzqitIiho0ArdxYPkZSSxdu1atm7dSv/+/Rk0aBB16tRxTGyV6NNPPy21ebeTkxNPPfWUNhCkPbm7uxcbpM3V1ZU6depo6/v378+8efPw9PTEYDAwe/ZsQkNDJekWQlS4xx9/XPp0CyFqFbs+kXt5edGrVy+7HS83N5fExERtOSkpiUuXLuHp6Ym/vz9Dhw5l+fLlNGzYkICAABYtWoSvr6/2EBsYGEjHjh2ZOXMmY8aMwWKxMHv2bHr27FnqyOXVjdlsZu/evWzYsIGUlBQAXBXo6VrYd9td5/g/anpFoasbhLuqHDbDjpzC5HvRokWsWbOGgQMH0q9fP2lGVgb5+fns37+f9evXa90HVCdn1EZtUJuEgd5+/XjviXcDrGEPw83L6C4dIdeUxrp169i8ZQt9+/Rh0KBB+PtXck18JSpKuJOS9PaZWAAAxu5JREFUkjh27JjNC8nw8HACAgIICrrHUeTL6cUXX0RRFKZNm4bFYiEsLIzRo0c7JBYhRO3y1FNPVchxY2JiWL16NRcvXiQtLY0333zTZtBcVVVZsmQJW7duJTs7m9atWzN69GibQfGysrKYPXs2R44cQVEUunfvzssvv4ybm1uFxCyEqB3KlXQXJXdlVdaH6/PnzzNp0iRted68eQBEREQQFRXF8OHDMZvNzJw5E5PJROvWrXn33XdtapZef/11Zs2axeTJk7XCs6xTl1VFN27cYPv27ezevRuTyQQUNiO/3w26u1aNZPt2ekWhhxt0cS2s+d6VC6lZWaxcuZK1a9fSrVs3+vfvr7VcEMVlZmayfft2tm7dSmZmJvBrzXbjtqiN2oBzFXwoUBTwb461bjO4eQXd1ePkZyazdetWfv75Z7p06cKgQYO01ig1zbx581i3bl2x/p+KojB06FD+8Ic/VEocEydOtFl2cXFh9OjRkmgLIWoMs9lM8+bN6d+/f7EuNgCrVq1i/fr1REVFERAQwOLFi5kyZQrTp0/Xnh3//e9/k5aWxnvvvUdBQQHffPMNM2fOZNy4cZV9OUKIGqRcSXdUVFS5TlbWvjlt27ZlyZIlpW5XFIWRI0cycuTIUvfx9PSsMQWl1WolOjqabdu2ER0dra331RXWand2BZdq0FyrqOa7k6vK6TzYnQsJ+fns2bOHPXv2EBwcTL9+/ejSpYtdR16urqxWK7/88gt79uzhyJEj2jzJqqtHYbLdoHXVqdm+E0UB/2ZY6zYF4zV08dGQdo1Dhw5x6NAhgoKC6N27N926dasx/b5/+ukn1q5dS/fu3Xn44Ydp3LgxANeuXWPt2rWsXbsWPz8/mxHBhRCipimaanDEiBHodDqbqQfv5IknnijTecLDwwkPDy9xW9E0miNGjNBaRP7lL39hzJgxHDp0iF69ehEfH8/x48eZOnWqNt3sqFGjmDp1Ki+88EKNaSUphKh85Uq6x44da+84xB0YjUZ27drFzp07SU1NBUABWjoX1mq3dK68AdLsyUlR6OAK7V1U4gtgfy6cyiscefnChQssWrSIXr16ERERQYMGDRwdbqVLTk5mz5497N27l5s3b2rrVc+6qIEdUP2DQFfBI5JXBEUB30CsvoGQdRPl2il0See5ePEiFy9eZOHChXTq1IlevXrRpk0bdNXxGn+1detWOnfuzF//+leb9S1btuT//u//yMvLY8uWLZJ0CyFqtKVLlwLw6KOPotPptOXfU9ak+06SkpIwGo106NBBW2cwGAgJCSE2NpZevXoRGxuLh4eHlnBD4cCUiqIQFxdn01T9Vvn5+doLcSisFCqaJrU2912vzddem8l9L1m5ku7IyEg7hyFup6oqcXFxbNmyhWNHj1JgtQJgUCDcFbq5Ql2nmvGfWlEUmuihiSc8aC3s933YDMbsbDZt2sSmTZto3bo1AwcOJCwsrFonYb8nPz+fY8eOsWvXLmJiYrT1qpMLakAwav1QqFOvMHGtCTzrFg64FtQNJSkOJTEWiymNgwcPcvDgQerWrUufPn3o1atXtaxhSE5OZujQoaVuL5qrVggharLbWzo6YlRyo9EIgLe3t816b29vbZvRaCw2+K+TkxOenp7aPiVZsWKFTe19UFAQn376qd3mNa+OXF1dbfrKi9pD7nvJ7D60saqq2jRdXl5e8rajjPLz8zl48CBbtmzhypUr2vqm+sJEu60LONfgf1NPnUKkO/R1UzmXDwfNEJsPv/zyC7/88gv+/v7079+fPn361JgmyFA4XdPOnTvZt28fWVlZ2nrVpxFqg1aodZuBk4NGIq8MLu6oge1RG7eDrBSUxFiU5PPcvHmTlStXsmrVKtq1a0ffvn0JCwvDycnJ0RHfFS8vLy5dulTq9kuXLlXI7A5CCCEqz2OPPWbTYqno2Tc5ORmLxeKosBzKbDZrU5iK2qW23Xe9Xn9XL9js9hQfHx/P4sWLOXHiBGazGSh8yxUWFsaTTz5ZbPoaYSs1NZXt27ezc+dObYAsPRDmCve7QgN9zU20S6JTFFq5QCsXSCtQOfhr7XdKSgpLlixh1apV3H///fTr14/AwEBHh1su+fn5HDlyhO3bt3Pu3DltvepiKEy064eCe82fVsuGokCdeqh16qEGd0dJuYSSeBbSrxMdHU10dDTe3t706dOHPn36VPmRz++//37WrVtHQEAAQ4YM0Ua/zc3NZcOGDfz88893rAkXQoiaLCsri5MnTxabarYippT08fEBID09HV9fX219enq6NoCrj4+PVnFUpKCggKysLO3nS+Ls7Iyzs3OJ224fRLM2qc3XXpvJfS+ZXZLuM2fO8Mknn6CqKl26dKFRo0ZAYe3d4cOHOX78OO+++y733XefPU5XY6iqytmzZ9m6dSvHjh3T/pN66Qr7and1BUMVHIW8svk6KQw2QD93lRNm2GeGJLOZ7du3s337dlq1akX//v0JDw+vFjWgWVlZ2sjdWq22oqD6NcXaoBX4BYJSc5vQ3zUnPWr9ENT6IZCTjnL9LMqNWNLT01mzZg1r166lY8eODB06tMqOfD5y5EguXbrEwoULWbx4sdZEPjU1FavVStu2be84EKQQQtRURS/Qb68J1uv1PPLII3YvGwMCAvDx8SE6OlpLsk0mE3FxcQwaNAiA0NBQsrOzuXDhgvZ35dSpU6iqSkhIiF3jEULULnZJur///nu8vb2ZOHFisZqnlJQUPvzwQ+bNm8fUqVPtcbpqz2KxcOjQITZu3MjVq1e19UF66OEGrZ0LBxkTtlx+HfW8i6vKRQscyIUz+XD27FnOnj2Lv78/AwcOpHfv3toAJlVJWloaGzduZOfOnVprENXVs7BWu0EouHo4OMIqzN0bNbgbavPOhXN+X/8FjAkcO3aMY8eO0bp1a4YNG1blXuy5urrywQcfcOjQIY4dO6ZNtxgWFkanTp3o3LmzdMERQtQ6y5Yt43//+x/h4eEMGTLEprJmw4YNLF++HCcnpzIPpJabm0tiYqK2nJSUxKVLl/D09MTf35+hQ4eyfPlyGjZsSEBAAIsWLcLX11cbzTwwMJCOHTsyc+ZMxowZg8ViYfbs2fTs2bNajisihKg67JJ0X716lZEjR5bY1NPf359Bgwbd9UiVNVl+fj5bt25ly5YtpKWlAeBM4cBo3V2hfi1rQl5eiqIQ7AzBzmAsUDlkhkO/Nj1ftGgRq1atIjIykiFDhuDp6enocMnPz2fjxo2sXbuWvLw84NcRyJuEofo3l1rtstA5Qb1grPWCwZSGcvUkuqQ4rc9/hw4dGDlyZJUb7b5r167aQ50QQtR2mzdvpnPnzowfP95mfUBAAB07duQf//gHmzdvLnPSff78eSZNmqQtz5s3D4CIiAiioqIYPnw4ZrOZmTNnYjKZaN26Ne+++67N9KSvv/46s2bNYvLkySiKQvfu3Rk1atQ9XK0QQtgp6a5Xr94dB4qwWCzUrVvXHqeqllRV5fDhwyxbtkyr6fJUCmu1u0kT8nvi46TwgAEi3FWOm2FvLqTk5LB+/Xp27tzJ8OHDiYiIQK93zCBkp06dYv78+dp9V70CsDbtBL6Na84I5I5i8C0c+bxZJ5T4aHTXz3Dy5ElOnz7NAw88wKOPPlpqHzshhBCOYzKZ6NixY6nbO3XqZDODx91q27YtS5YsKXW7oiiMHDnyjk3XPT09GTduXJnPLYQQd2KXTOSJJ57g+++/p1OnTlo/mSIXL15kw4YNvPjii/Y4VbWTlpbGzJkztYGyvHQwwB3CXEAvSZfduCgK3X5ten42H7bkwI3sbH788Ue2bdvGn//8Z5o0aVJp8VitVlavXs1PP/0E/Do4WnB31HrBkmzbm1sd1JCeFDRqg+7CAQpSr7JhwwbOnj3L2LFja/ULPyGEqIpat27NuXPntL7Utzt37hytWrWq5KiEEKLilCvpnj17drF13t7e/P3vf6dVq1Za087r168TGxtL06ZNOXfuHL179763aKuZhIQEPv/8c1JTU3EG+rhDb7fCBFFUDJ2icJ8LtHJWOWIuTL6vX7/OP/7xD6KiomjTpk2Fx2A2m/nPf/5DdHQ0ANaG96EGdwMnqXWtUAYfrO0GQ8oldLG7uHjxIpMnT+b111+nRYsWjo5OCCHEr8aMGcOUKf+fvfsOj6rMHjj+vTOTSa+kk4SQhITeISAIESkK2BBBUdcCrD/FslVXUSmCLGvDxi4iKChS7QUEFKRI75BA6JBGeq+Tub8/hoyMSZCEmUzK+TxPHuaW3Hsml7yZc+/7nnc2H3/8Mbfccgv+/v6AaQz2unXrOHnyJC+88IKdoxRCCOupV9L9448/1rqtqqjVlS5cuMCFCxd45JFH6nO6JiknJ4c5c+ZQXFyMrwb+5A4+Wkm2G4rmctG1znqVzwrhbGkp8+bN47nnnrNpAlZSUsI777xDYmIiaHQYowei+kvF0wblG47RrRWa+J8oLMzkjTfe4JlnnpGnJkII0Uj84x//QFVV1q5dy9q1a9FoTLVNjEYjYJqC65///Ge171uyZEmDximEENZSr6R75cqV1o6j2dm2bRvFxcUEaGGiu4zbthdnjcJD7irLC+FERSUbN260adL99ddfk5iYiKp1wNj5FvAMsNm5xFU4uWPsNgrNsQ2U5aYwf/58Xn/9dRnjLYQQjUBsbKzM3CCEaFHsU12qBdi3bx8AA5wk4bY3naJwk7NprPf+/fsxGo3mu+rWlpycDIAaESsJt71pHTB2Ho5m+1IKCwvJz8+X8d1CCNEITJkyxd4hCCFEg5Kk20ZcXU1zLhcb7RyIAH67Dq6urja9u151bCX7omnubZkOzL6yk1FU08VviKcq8+fPr/P3KIrC448/boNohBBCCCFEYyBJt41069aN48eP82MJZBtVbnYGV3ni3eDKVZVtpbC1xLTctWtXmyZfo0aN4sSJExiyzqMc/wW13QDQ6f/4G4V1qSpKxmk0iVsBGDRoED4+PjY/7bFjx+r8PdLFUgjR0hw5coSzZ89y++23m9f9/PPPrF69GoPBwIABA/jTn/5ks15pQgjR0CTptpG4uDjOnDnDnj172F0Gh8thgJNKX0dJvhtCuWqat/uXUsi7/JS7Xbt23HnnnTY9b0xMDJMmTWLBggVoMk6j5qdhbDcQvENkqrCGUlaM5tR2lKzzgOkG2AMPPNAgp37//fcb5DxCCNGUrV69Gl9fX/PyhQsXWLhwIWFhYQQGBrJ27Vq8vLxs/jdbCCEaiiTdNqLX6/m///s/brrpJpYvX87Fixf5qQR+KYHujir9HSFAJ0mYteVWquwqg71lUKKa1vn4+DBu3Dh69+7dIE8V+/Tpg6enJx999BHp6eloj/6I6uyB6heJ6h8JLl42j6HFMZSjZJ1HST+NkpMMqGi1Wm677TZuvfVWtFqtvSMUQghxWXJyMrGxseblLVu24OzszMyZM3F0dOSDDz5gy5YtknQLIZoNSbptLCYmhpdffpldu3axYcMGzp8/z97LSWFrrUq0A8ToIVhrmuZK1I2qqmQYIbEcTlTAeQNUDaP38/Pj5ptvZtCgQTg6OjZoXNHR0UyfPp3PP/+crVu3Ul6Sj3LhAFw4gOrWCtW3Lap3CLi1kifg9VVWjJKbjJJ1AbIvoBgrzZuioqJ44IEHCA0NtWOAQgghalJaWoqzs7N5+eDBg3Tv3t38tzoqKoqtW7faKzwhhLA6SbobgEajoX///vTr149Tp06xYcMG9u/fT3KlSnIlbCoFVwXaOajEOECkg1Q8v5oyVeVcBSRWmBLt3N8Vq4uJiWHYsGF069bNruPBHB0dmTBhAnfddRcHDx5k165dHDsWj7EwC6UwC87tRdU5onq3Bq/Wpn+d3OwWb6NXWQF5aSg5yaav4hyLzYGBgcTGxhIbG0tAQOOpHH/gwAG+++47zp49S3FxMaqqVttHpmEUQrQkvr6+nD59miFDhpCWlsbFixcZPXq0eXthYaFM8SiEaFaslnQfPHiQn3/+mfT0dIqKiqp9sFQUhXfffddap2uSFEWhXbt2tGvXjry8PI4cOcLhw4c5duwYRaWlHCyHg+Wmff21Km100EYH4Trw0rbcJLzQqHLeAOcvP8lOrfztaTaATqejffv2dOnSha5du+Lv72+3WGvi7OxM//796d+/PwUFBezbt4/Dhw9z/PhxysrKUDLOQMYZAFM3dI9A8AhA9QwAZ8+W+yS8ohTy01HyL6HkXYKCdHMlcjD9PoWFhdGpUyd69+5NWFhYoytKtnPnTt566y1CQ0O54YYb2LBhAwMGDABgz549BAUF0adPHztHKYQQDWvgwIGsWbOG7OxskpKScHV1tWgLz5w5Q1BQkB0jFEII67JK0v3NN9+wbNkyvLy8iIyMJCwszBqHbdY8PT0ZOHAgAwcOxGAwcOrUKQ4fPsyRI0dISUkhvRLSK2FP2eX9Nao5AQ93AD9N86x6rKoquUY4ZzB9na+AzBqmXWvVqhWdO3ema9eudOjQocG7j9eXu7s7cXFxxMXFYTAYOHv2LMeOHSM+Pp6zZ89iLMlHKcmHS4kAqDpHcwKuegSAux9omuH4ZFWF0nxTcp1/yZRoF+dW283Hx4dOnTrRsWNHOnTogLu7e8PHWgdfffUVUVFRvPLKKxQWFrJhwwaGDBlC586dSU9PZ+rUqY3uJpEQQtjamDFjMBgMHDhwAF9fX5544gnzVKuFhYUcO3aMkSNH2jlKIYSwHqsk3T/88AOdO3fm+eefR6eTHut1VfWktn379owbN46CggJOnjxp/jp//jx5RiOHy01V0AFcFGijUwnXQRsHCNKCtgkm4UZVJaPS9AS7KtHOryHJDg4OJjo6mnbt2hEdHd0g0z/Zmk6nM/d8uPPOOykuLubkyZOcOnWKU6dOcfbsWSoqykzjlbMvAKAqWvDwQ/UMvPxE3L9pTkmmqlCUjZJ/CfJSUfLSUMpLqu0WGBhIVFQUUVFRtGvXjoCAgCZ1sykpKYkJEyag0WjMxdwMBgMA/v7+jBgxgq+//prBgwfbM0whhGhQWq2W++67j/vuu6/aNjc3NxYuXGiHqIQQwnaskiEXFRXRr18/SbitxN3dnZ49e9KzZ0/AVHDkzJkzJCYmcvLkSc6cOUNxeTkJFZBQAZSAHgjVqURcHhPeWJNwVVVJr4QzBjhzubt48e+GuGq1Wtq0aWNOsKOionBza/5jnV1cXOjWrRvdunUDTMnZ+fPnzUn4qVOnyM/PN41rzksDQEUBd19TEu4ZBJ6BjTMJV1UoykLJTUHJTTM9zTaUWeyi0+kIDw83J9iRkZGN/kn2H3F0dDS3i66uruh0OnJzc83bPT09SU9Pt1N0Qghhfzk5OeTl5REYGIiTk5O9wxFCCJuwSpYcFRVFSkqKNQ5VZ6tWrWLNmjUW64KDg5k3bx4A5eXlLF26lF9//ZWKigq6devGpEmT8PLyavhg68nJyYmOHTvSsWNH4LdkrCoJP3nyJMXFxZw2wGkDbCgBJwXCdSqRDhChA3+t/bqj51SqnL6cZJ+pgMLfJdl6vZ6IiAiio6OJjo4mIiKiyXQXtyWdTkdkZCSRkZGMGDECVVW5dOkSiYmJ5q+srCwoyEApyICkI6iKAu5+qF6tUb2CTU/C7dEdvaq7eE4KSm4K5KZUS7IdHR2JjIy0uO7NrXBOcHAwSUlJ5uXw8HC2bNnCjTfeSGVlJdu2bbOYq9aavvzyS3bv3k1ycjJ6vZ7o6GgeeOABgoODzfs0h/ZRCNE07dmzh2XLlpGamgrASy+9ROfOncnPz2fWrFmMHTuWvn372jlKIYSwDqsk3RMnTmTOnDlERkYycOBAaxyyTkJDQ3nppZfMy1dWrF6yZAn79+/nb3/7Gy4uLixatIg33niDV155pcHjtJYrk7Fbb70Vo9FIcnIyiYmJJCQkcPz4cUpKSjheAccrTN/jrkBHvUpnvak4my2nJ1NVldRKOFoOx8oh63fdxfV6PVFRUXTo0IGYmBjatGkjvSSugaIoBAYGEhgYyKBBgwDIysri5MmTHD9+nISEBDIzMy8XH0s3TU+m0Zoqo/tHorYKA60Nk1pVhcJM01zZmedQygotNjs6OhIdHU379u2JiYkhNDS02V/3Pn36sHbtWh588EEcHBwYM2YM//nPf3j44YdRFIWysjIef/xxm5w7Pj6eESNGEBkZSWVlJcuXL2fWrFm8+eab5qdJzbF9FEI0fnv37uX1118nOjqagQMHsnr1avM2Dw8PfHx82Lx5syTdQohmwyqfeOfNm0dlZSXvvvsuCxcupFWrVtWmalIUhddee80ap6tGo9HU+GSmuLiYn3/+mWeeeYbOnTsD8MQTT/DXv/6VxMREoqOjbRJPQ9NoNISGhhIaGsrNN9+M0Wjk/PnzJCQkkJCQwMmTJymoqGBXGewqAzcFOutVOlk5AU81qBwtNyXbVybaGo2GiIgIOnToQPv27YmMjGx2TzTtpVWrVrRq1Yp+/foBkJGRYU7AExISTN3RL48JVzU6VN82qP5R4N0aFCtNp1ach5J+ypRsl+abV1fdHOrQoQMdOnQgPDy82SfZv3f77bdz++23m5d79erF9OnT2bVrFxqNhp49e5rbJmubOnWqxfKUKVOYNGkSZ86coWPHji2mfRRCND6ff/45HTt2ZNq0aRQUFFgk3QDR0dFs2LDBTtEJIYT1WeUTsJubG+7u7nab3iEtLY3HHnsMBwcHoqOjmTBhAr6+vpw5c4bKykq6dOli3rd169b4+vpe9UNlRUUFFRUV5mVFUXB2dja/buy0Wi0RERFEREQwatQoKioqSEhIYM+ePezfv5/CkhJ2lsHOMlO38xudVLrq6zcGXFVVTlbAllJTEbQqDg4OdO3alT59+tClSxfzz0/Ylr+/P/7+/gwaNAhVVUlKSmLPnj3s2rWLjIwMlPTTkH4a1dENtXUn1MCY+o0BV1XITUGTdAQl57fu03q9nh49ehAbG9ukqsrbQkVFBYcOHcLPz482bdqY11fdhGhoxcXFAOb6CPVpH5t622grLfm9tzRXTocq173+Lly4wEMPPVTrdk9PT9NNYyGEaCasknRPnz7dGoepl3bt2vHEE08QHBxMTk4Oa9as4eWXX+aNN94gNzcXnU5nnoaiiqenp0Uxo9/78ssvLcaJt23blrlz5+Ln52ert2FzYWFhjBgxgoqKCg4cOMDWrVvZvn076SUlfF4EP5XAQCeVPo7XlnyrqsqxCthcAmmVpnU6nY6+ffty4403EhsbK4l2IxAcHEzfvn154oknOHHiBJs2bWLz5s3k5+ejnNmFev4AalB71LBuoLuGBFlVUTLPolw4iFKUDZh6MvTq1YubbrqJfv36yXW/TKfT8eabb/Lwww9bJN32YDQa+fjjj4mJiTFP6Vif9rE5to3WIPMJtxxX9uKT615/jo6OlJaW1rr90qVLLaKAqhCi5WjyfT179Ohhfl1V8fqJJ55gx44d6PX1q+J81113MXr0aPNy1d3sjIwM83Q/TVloaCgTJkzgzjvvZNOmTWzYsIHc/Hy+K4ZD5XCPq4qPtvbEu9io8nURHLv8wMvR0ZHBgwczYsQIvL29AdMH+qvd2BANz9PTkzvvvJORI0eyY8cOfvzxR9LS0lCSDqOmn8IYPQh8Qmo/QHkxmpPbUbLOA6an2jfeeCPDhg0zzzXdHK67TqezShKpKApBQUEUFBRYIarrs2jRIi5evMjMmTOv6zjNvW2sr6pCUKL5Mxp/GzvV0q67tdpGgE6dOvHLL78watSoattyc3P56aef6NWrl1XOJYQQjYFVk26DwUBKSgrFxcUWf5iqVFXftiVXV1eCg4NJS0uja9euGAwGioqKLJ7m5OXlXbU6r4ODQ61jjq/sWtbUOTs7M3LkSIYOHcq2bdv44osvuFhSwvv5cLerSkd99cQ7yaDyWaFpLm2tRsPIUaMYOnSo+Y50c/r5NFcODg4MGjSIgQMHcvjwYVauXEl6ejrao+swtu6MGhELv+/tkJuKJn4jiqEMrVZr/n8j1/3q7rrrLpYsWUL//v0tqoY3pEWLFrF//35mzJhBq1atzOu9vLzq3D62lLaxrlrye2/J5LrX33333cfUqVN5/vnnzTVJDh48yNGjR81juceOHWvPEIUQwqqsknQbjUY+++wz1q9fT1lZWa37rVy50hqnu6rS0lLS0tK48cYbiYiIQKvVcuTIEXOjnpKSQmZmphQJuoJer2fIkCF07dqVhQsXcurUKVYWwkPuKhEOvyVfWZUqSwtM82oHBATw5z//mfDwcPsFLq6LRqOhe/fudOjQgc8//5yffvoJTfJRjGCZeOdfQnv0RzAaCA0NZeLEiYSGhto19qYiMTERd3d3/v73v9OxY0f8/Pyq9cBRFIVHHnnE6udWVZXFixeze/dupk+fbu6NUEXaRyGEvQQHBzNz5kw+/vhj82fDb7/9FjA9oJk4cWK1NksIIZoyqyTdX375Jd9++y1Dhw6lffv2vPfee9x///24uLiwfv16FEXh/vvvt8apqlm6dCm9e/fG19eXnJwcVq1ahUajYeDAgbi4uDBkyBCWLl2Km5sbLi4uLF682DwvsLDk6+vLs88+ywcffMDevXtZXghTPFS8tArlqsonlxPu8PBw/vnPf5qnHRJNm6OjIxMmTCAsLIyPPvrIlHi7eKEGtYfyEjRH14PRQMeOHXn66ael8nwd/Pjjj+bXR48erXU/WyTdixYtYtu2bTz77LM4Ozubu/27uLig1+ulfRSiHqR4mvVUTfdaWFhIWloaqqoSEBCAh4cHYLpxKD9vIZoW6QFUO6sk3Zs3b6Z///5MnjzZPH4xIiKCzp07ExcXx9SpUzl69Chdu3a1xuksZGdn8/bbb1NQUICHhwft27dn9uzZ5kb7oYceQlEU3njjDQwGA926dWPSpElWj6O50Gq1TJw4kaysLM6ePcvGEhjrBjtLIdNo6pL61FNPScLdDA0cOJC8vDy++OILlPP7UQOiUJIOoxjKCAkJ4cknn5SEu44aondPbdavXw9UL3T5xBNPEBcXB0j7KISwPzc3N6KioszLBoOBzZs38+233/L222/bMTIhRF3JjbLaWSXpzs7O5o477gAwfygvLy83nUCn48Ybb+T7779nwoQJ1jidhb/85S9X3a7X65k0aZJ8kKwDvV7P/fffz6xZszhUDgMNKlsuFxm9++67rzoeXjRtw4cPZ/PmzWRnZ6NcOo2SehyAMWPGtOjpv5qiVatW/eE+0j4KIRqSwWBg7969pKWl4ebmRs+ePfHx8QGgrKyMdevW8cMPP5Cbm0tAQICdoxVCCOux2jzdVVM/ODk54ezsTHp6usU+hYWF1jiVaCBt27alY8eOxMfH820xlKrg4+NjHvspmicHBwf69+/P999/j3JuD0plBZ6enjbppdKSJCYmcuzYMfLy8hgxYgRBQUGUlZWRnJxMcHCw9BwRQjR72dnZzJgxg7S0NPM6vV7Ps88+i06n45133iE7O5uoqCgeeeQRYmNj7RitEKI+pHt57aySdLdt25ZTp06Zlzt16sT3339PeHg4qqqydu1aKbjVBPXo0YP4+HjOX54JqFu3bhZzlIrmqer3V6koNS9Ld6H6MRgMzJs3jz179pjX9e7dm6CgIBRFYfbs2YwaNYoxY8bYMUohhLC9FStWkJ6ezh133EH79u1JT0/n888/54MPPiA/P5/Q0FCeeuqpBpnpRtjGlQlXTbMYCdGSWSWDGjp0KAaDgYoK08TN9913H8XFxUybNo3p06dTUlLCgw8+aI1TiQbUtm1bi+WIiAg7RSIaUnh4uMXNlcjISDtG07StWLGCffv2MXnyZObNm2exTa/X069fP4uEXAghmqvDhw8TFxfHhAkT6NmzJ7fccgsTJ04kPT2dDh06MHPmTEm4m7gre7VWVlbaMRLRkLKzs82vKysrzfmgsGSVJ929e/emd+/e5uWQkBDeffddjh07hkajISYmxjyfr2g6fj+eSqbvaBkcHR3x8/Pj0qVLAAQFBdk5oqZr+/btDB8+nKFDh5qLTF6pdevW7Ny50w6RCSFEw8rLy6Ndu3YW66pmShgyZIj0pGsGkpOTza8zMzOlAn0LcfjwYYvl+Ph4unXrZqdoGi+btXAuLi706dOHXr16ScLdRDk7O1tUq5YCai1HVfV/AE9PTztG0rTl5+cTFhZW63aNRkNZWVkDRiSEEPZhNBrR6/UW66o+Y7i4uNgjJGFlCQkJ5tf5+fkWSbhonsrLy/n+++8t1n3zzTcyvKAGVnnSDabGdMeOHeZiQePHjycsLIzi4mKOHDlCTEyMJG1NjKIo6PV6czcRd3d3O0ckGsqVhb2uTMBF3bRq1eqqHzpOnDhBYGBgA0YkhBD2k56ezpkzZ8zLxcXFAKSmptaYeMuwtqbjyJEjrP3hB4t1//3vf/nXv/4lnx+bIVVVOXToECtXriQ7OxvV0RVjt9Fo9n3BuXPnmDVrFuPHjycmJsbeoTYaVkm6i4qKePXVVzl16hROTk6UlpZy6623AqYP7x999BGDBg2yyZRhouH8/g61aL6u7A7m7Oxsx0iatoEDB/Ldd9/Rr1+/at30N27cyI4dO6RdFEK0GCtXrmTlypXV1n/44Ye17i8aL1VVSUxMZMuWLezdu5dKo5GuehjuDAsLIC0tjenTp3PjjTcycOBAfH197R2ysIILFy6wevVq4uPjAVAdnDFGDwYnd4zRN6JJ3Mr58+f5z3/+Q69evbj77rtlCkCslHQvW7aMixcvMnXqVMLDw5k8ebJ5m0ajoV+/fhw4cEA+XDZxMi6nZZLrXn9jxozh5MmTTJs2jdatWwOwZMkSCgsLyc7OpkePHowePdrOUQohhO09/vjj9g5BWIGqqqSnp3PgwAG2bNlirv8C0MEBxriCTlF42F3lo3zIzc3l22+/5bvvvqNTp04MHDiQjh074urqasd3IeojIyODr7766rdaNIoWY0hn1NBuoLv8YM4vAqNnEMr5fWhST7Bv3z4OHDjA4MGDue2221r0kEWrJN179uzhlltuoWvXrjUWCwoKCmLz5s3WOJVoYJJwtUxy3a1Dp9PxwgsvsHXrVnbu3InRaMRgMNCmTRvuvfdeBg0aJD9rIUSLEBcXZ+8QRD2oqsqlS5c4ceIEJ06cIDExkZycHPN2PdDVEXo7Qmvtb58f/LQKf/NSiS+HvWVwxqBy9OhRjh49iqIohISEEBMTQ0xMDNHR0VL/qREqLi7m9OnT5q8TJ06Yq9Ib/SJRw3uDcw1DB/TOqO0GUhncEc2Z3Rhzkti0aRPbt28nJiaGqKgoIiMjadu2rcVwxubOKkl3cXHxVStbV1ZWytQBQogWSVEUBg0axKBBg+wdihBCCFGN0WikoKCA3NxccnNzycvLIzc3l5SUFE6cOEF+fr7F/logVAfd9dDFERxruXmsUxS6OpqS8qxKlX1lEF8OmUaVixcvcvHiRTZu3AiYZvNo164dfn5+eHp64uXlZf7X2dlZblDbmKqqpKWlcerUKXOSnZKSUn0/r2CMbfuC+zUMFXD1wdjlFshNQXN2D+UFGRw5coQjR44AmG++REVFmRNxX1/fZnutrZJ0BwYGcvbs2Vq3Hzp0iJCQEGucSgjRAFRVtXcIQgjR6EjbKJqSyspK8vPzzUn07/+tep2fn3/VatM6TEl2uA7aOpheO9QxMWqlVRjuAsNdoMCocq4CzhrgnAHSK03TjdVWeFSv11dLxKv+vfK1i4tLs03YrE1VVVJTU809GGq6uQKgOnmgeviDRwCqZwC4+tT9ZF7BGLvfDoWZKPmXID/d9G9Zkfnmy6ZNmwDw8fGhffv25l4QzSkJt0rSPWTIEJYtW0anTp3o3LmzeX1FRQVr1qzh4MGDPPbYY9Y4lRCiATSXBq4xOHjwID///DPp6ekUFRVV+9CuKArvvvuunaITQgjR1FV1Aa96Snn+/Hlyc3PJz8+/5htFCuCqgLvmty9vDbTRQUg9kuyrcdcodHE0PSUHKDKqnDNAkgHyjVBQ9aVCqWqaliojI4OMjIyrHlen0+Hl5UWrVq2IjIwkMjKSqKioFt91XVVV8vPzSU1NJTk5mZMnT9aYZKuKFjz8UD38UT0CwN0f9FYqpqso4O6H6u4HrUEFKCuC/EsoVUl4YSbZ2dn8+uuv/Prrr4ApCa/qkh4cHExwcHCTvZ5WSbpHjhzJxYsXefvtt81TPrzzzjsUFBRgNBoZOnQoQ4YMscaphBCiyfjmm29YtmwZXl5eREZGXnXObiGEEOJalJeXc+7cOXOSferUKQoLC2vcVwHcfpdMuyvgobFc56qA1k433F01Cp300KmGSXLKVfW3JPxyIl7TcokKBoOBzMxMMjMzOXHihPkYgYGBREZG0q5dOyIjIwkMDESj0TTgO2w4+fn5pKSkkJycTEpKivmrpv8fqkZ7+Ql2EKpXELj7gUbbcME6uoJfBKpfhCkJr6wwJeG5qSh5aVCQQXZ2Njt27GDHjh3mb/P09DQn4MHBwbRu3Zrg4OBGX5zPKkm3oij83//9H3FxcezcuZPU1FRUVSUgIID+/fvTsWNHa5xGCCGalB9++IHOnTvz/PPPo9NZpbkVQgjRQpSVlZGamkpqaqo5eUpNTSUjI6Nad3Ad0FoHYZefTHtfkUxrmnDvNb2i0EoLrf4gF6y4nJwXGiHdCBcq4KIBMoymqcvS0tLYvn07AI6OjgQFBREUFERwcLD5Xz8/v0abjKuqSmlpaa1DBLKzs0lNTa315osK4OQBrl6obn72SbL/iNYBvENQvUOuSMLTUfJSUQoyoTgXpayQvLw88vLySEhIsPh2T09PgoKC8Pb2rjb8oGrZ0dHRLm8NrJR0V2nfvj3t27e35iGFEKLJKioqol+/fpJwCyGEuKr09HROnDhhTqxTUlLIysqqdX83xZRgt9FBmAMEaU2Fy1oqB0XBRws+WgjDVE0doNioctEA5w1wwQDJBtPNjHPnznHu3DmLY+h0OgIDAy0S8i5duti0wraqqhQXF1dLomtaLisr++PjwW/JtYs3uHihunqDsxdom9hnEa0DeLdG9W6NeZCEodyUfBfnQnEOSlFOtWT8apydnS2S8Nr+dXa2Urf6KzSxn74QQjQdUVFRNVb/FEI0TVLvQthCcXExL730EgaD4ar7uSkQ4QBtdRCss3+38KbARaMQo4dwB5VCI+QZTcn3mQrTv1f+xA0GA0lJSSQlJZnXdevWjaefftpm8c2bN4+jR49e8/6q1gH0LqB3QdW7mMZc613A0QXV2QtcvJpecl0XOj14+JuKu0H1ZLwkD8qLzV9KWclvr40GSkpKKCkpIS0t7aqnGTRoEA899JB1Q6/vN86dO7dO+yuKwrPPPlvf0wkhRJMzceJE5syZQ2RkJAMHDrR3OEIIIRohJycnevXqxenTp8nNza01+S5U4XC56etKLoqKm+a3sdtuGvDRgL8WArSmxLM5M6oquUZTFfRLlaZibIWXx3sXXn5d/seHseDi4oKnpyc9evSwScxViouLa1yvOnui+keBsweqo+tvybXWwabxNFm/S8armJNyVTV1V69KwMtLoCgbJf00Sln1Lvm1XZfrCrG+37h//34cHBzw8vK6psqIcndYCNHc/eMf/6i2rrKyknfffZeFCxfSqlWrauPFFEXhtddea6gQhRBCNDIajYY///nPgKm7cUlJiXmqr6p/q77y8/MtthmNRopVKK6E9FqO766oBGghQPdbIu6vNY2XbkpUVaVIhbTK3xLsS5enHLuWpLpq6jFPT088PDzw8PAwL/9+nYNDwyS3zz33HAkJCezbt48DBw6Yx2QrJXlwfr9pPmyvIFTPYFPSLepHUQAVSvJMhdpyU1CKsi128fb2pmfPnvTq1Yt27dpZPYR6J90+Pj5kZ2fj7u7OwIEDGTBgAF5eXlYMTQghmhY3N7dqNxjd3d0JCgqyU0RCCCGaEkVRcHFxwcXFhcDAwKvuazQaKSoqskjO8/Pzyc3N5dKlSyQnJ5OZmWmq8G2AU1c8QFcAb41qTsADLyflrTSNo7t6qaqSbricWF/xVVzLcz6dTmdREK0qib7yX1uOza4vnU5Hly5d6NKlCw8++CCnTp1i3759HDlyhPT0dCjIQCnIgIuHUc3TbvmDgxPoHEGnR3VwBJ2T6WmvgyNo9ZeTzBZCNZq6lxvKTP9WlKEYykzLFWVQUWKalqwwiyuefQMQHBxMt27d6NWrF+Hh4TZ9SFzvpPu///0v8fHxbNu2jc8//5xPP/2Ujh07MnDgQPr162eTAehCCNGYTZ8+3d4hCCGEaCE0Gg3u7u64u7vXuk9JSYl5Cqkrv/Lz88k2QrYREip+218L+GlV8xPxqi8vjW16rRpUlczK3z29roRcY837K4qCv78/rVu3tvgKCAhAq21ElbjrQavVEhMTQ0xMDABZWVmcOHGC48ePk5CQQHZ2tqmad35tfRpMVBRTAq5zNCXhOkfUywl61TI6x8vJ+hVfDo72rWZeabicOF9Olg2/S54vJ9WK+fUV667xFAEBAebC3zExMXh6etr0LV3pukbad+zYkY4dO/Loo49y4MABtm3bxuLFi/nwww/p0aMHAwcOpFevXg3WRUMIIYQQQghh4uzsTGRkJJGRkRbrCwoKzAl4VfGw5ORkysrKSLucBF/JSYHWWpWQy1OStdaBRx3HihtVlYxKSKo0VRFPMpjOU0t+jbe3t0ViHRISQlBQEHp9DRN6N0OtWrXihhtu4IYbbkBVVTIzMzl+/DgpKSkUFxdTVFREUVGRxevy8nIU1N8S0lLTsa71SqkarSkB17uguniBizeqq+lfnNyv7wm6aoSS/MtVx3NN/xbnQkWp6em0WvlHR7gqR0dHXF1dcXV1xcXFxfza1dWV0NBQYmJi8Pb2vq5zXA+rlLfT6XT06dOHPn36UFpayq5du9iwYQNvvfUW99xzD2PHjrXGaYQQosmpqKjgp59+4sCBA6auYoC/vz89evRgyJAhLebDgxBCiMbD3d292lS/qqqSlZVlTsSrkvLU1FRKKys5bYDTV3RR91BUcwIeqoNwneWc4CVGldOXk+skA6QYah577ezsTEhIiEVyHRwcjJubmw1/Ak2Loij4+fnh5+d31f0qKipqTMavZZ2qqijGyt+KjRVmWhxb1WhNU5C5eP+WjLv6mJJxix1NY6cpyrGc2qskD0Wt7RaLiUajqTFprm3dlesb+/SsVo2uoqKCgwcPsmfPHs6ePYter8ff3/+Pv1EIIZqhrKwsZs2aRUpKCl5eXubxeefOnePgwYOsW7eOl156iVatWtk5UiHEtbiWwrFCNFWKouDr64uvry/dunUzrzcYDKSkpHD27FnzV3JyMvmqSnwFxF/unh6pg3vdVJw1ChcNKssKTBXXr+To6Eh4eDht27albdu2hIeH06pVKym4bCVVRa7rWmfLaDRSWlpqTsSzs7NJTU0lOTnZPHe8wWCAwqzLY6Ov+F6/CNR2A03d18uK0Zz4BSU3ucbz6PV6goODLb68vLzMCbSTk1Oz/b9w3Um30Wjk8OHDbN++nT179lBWVkbXrl157LHH6Nu3b6MsWiCEEA1h0aJFZGRk8Ne//pV+/fpZbNuxYwfvv/8+ixYtkukUhRBCNFo6nY6wsDDCwsIYPHgwAKWlpVy4cMGchB86dIjT5eUsyIfujiqbS0xzYPv6+tK5c2dzkh0UFFRtFg9hfxqNxlzAz8/Pj/DwcIvtRqORjIwMc8+HqmQ8OTkZMs6g5qejBrVHST6KUlGKTqcz91io+mrdujU+Pj4t9vrXO+k+ceIE27ZtY+fOnRQUFNCuXTvuu+8++vfvj4eHhzVjtIp169bx7bffkpubS5s2bXj00UeJioqyd1hCiGbsyJEjjBo1qlrCDdC/f3/Onj3L2rVr7RDZb6RtFEKI6qRtvDonJyeio6OJjo4G4MKFC7z77rtkZmezscS0T48ePZg0aZI8gGsGNBoNAQEBBAQEWKw/c+YMCxYsIDMzE+XcXgBCQ0N57LHHZOaW36n3rYaXX36ZzZs306FDB/7617/yyCOP0K5dOzIzMzlz5kyNX/by66+/snTpUsaOHcvcuXNp06YNs2fPJi8vz24xCSGaP2dn56tWxvTy8rLrTA/SNgohRHXSNtZdWFgYjz32mHnZzc2Nxx9/XBLuZi4iIoJp06ZZrJs6daok3DW4ru7l5eXl7Nq1i127dl3T/itXrrye09Xbd999x80338xNN90EwOTJk9m/fz+bNm3izjvvtEtMQojmLy4ujs2bN3PzzTfj6Ohosa20tJRNmzYxZMgQO0UnbaMQQtRE2sa6yc3NZf369WzevNm8rrCwkJdeeolbb72V/v37N/oiV6J+cnNz+fTTTy3WLVu2jHHjxuHi4mKnqBqnev8GPP7449aMw2YMBgNnzpyxaCQ1Gg1dunQhMTGxxu+pqKigouK3SQsVRTE/jWqug/tr4+joSGFhIdDy3ntLduUfR7nu9RceHs6BAwf4y1/+wuDBg82F1NLS0vjll19wc3MjLCys2o3L2NhYm8cmbaN1uLq6ttj33hK5uLhQVlYGtNz/882dtI11k5CQwGuvvVbjtkuXLvHxxx+zevVq5s6dK0lYM5Odnc0//vGPauu3bt3K3r17ef311+3am6+xqXfSHRcXZ8UwbCc/Px+j0Vitip+XlxcpKSk1fs+XX37JmjVrzMtt27Zl7ty5f1imvzl64oknmDVrFg8//LB0FWlBHn74YQ4dOsSoUaPkul+Ht99+2/z6yy+/rLY9OzvbYp8qDdErSNrG6zNlyhTmz5/P008/Lb8jLcjTTz/NzJkzmTx5slz3ZkraxrpJSEi4pv38/PwaZc0nUX+lpaaCaQaDocbtPj4+da6i3pxJX48a3HXXXYwePdq8XHWXMiMjo9b/WM1V27Zteffdd3FxcSE1NdXe4YgG4urqyttvv42Tk1OLu+46nc5qH5R+P86pqZO28Te9evXivffew9nZucX9jrRkbdq0abHX3ZptY3PTktvGDh068Oabb5p7gNTEw8PDPBWVaD6cnJx48803a7yuHh4elJSUUFJSYofIGta1to3NPun28PBAo9GQm5trsT43N7fWuy8ODg44ODjUuK0lztHp7OzcIt93S1dV/ESuff117NjR3iHUStrG6+fk5NQi33dLJ9e9eZO2se6uVjC0Skv4ObREVfNr10SuuaVmP1GaTqcjIiKCo0ePmtcZjUaOHj1qnuZACCFaGmkbhRCiOmkbhRC20OyfdAOMHj2a999/n4iICKKiovjhhx8oKytrMuPShRBNw4wZM1AUhalTp6LVapkxY8Yffo+iKLz88ssNEF110jYKIUR10jYKIaytRSTdN9xwA/n5+axatYrc3FzCw8N54YUXZHC/EMKqft+VSlXVP6xca8/uV9I2CiFEddI2CiGsTVGlw/01y8jIsJgSQgjR/Dg4OEixoDqStlGI5k/axrqTtlGI5u9a28YW8aTbWq6cu1gI0TxZ6/e8vLyc5cuX06lTJ3r37m2VYzZW0jYK0fzJ73ndyc9MiObvWn/PpTWoA29vb3uHIIRoIvR6PRs3biQkJMTeodictI1CCFGdtI1CiCrNvnq5uD4lJSU899xzLWKePfEbue7WERERwcWLF+0dhrAB+R1pmeS6C3F18jvSMsl1/2OSdIurUlWVs2fPylx7LYxcd+t46KGH2L59Oz/99BOVlZX2DkdYkfyOtExy3YW4OvkdaZnkuv8x6V4uhBA2Mn/+fDQaDR988AEfffQRPj4+6PV6i30UReG1116zU4RCCCGEEMLWJOkWQggbcXNzw93dneDgYHuHIoQQQggh7ESSbnFVDg4OjB07FgcHB3uHIhqQXHfrmD59ur1DEDYivyMtk1x3Ia5OfkdaJrnuf0zm6RZCCCGEEEIIIWxEnnQLIYQNFRcXs379eo4dO0ZeXh5//vOfiYqKorCwkM2bN9O7d28CAwPtHaYQQgghhLARSbqFEMJGsrKymD59OpmZmQQFBZGcnExpaSlgGu+9YcMGMjIyeOSRR+wcqRBCCCGEsBVJuoUQwkY++eQTSkpKeO211/Dw8GDy5MkW2/v06cP+/fvtFJ0QQgghhGgIMk+3EELYyOHDh7n11lsJCQlBUZRq2wMCAsjKyrJDZEIIIYQQoqFI0i2EEDZSXl6Oh4dHrdtLSkoaMBohhBBCCGEP0r1cXNW6dev49ttvyc3NpU2bNjz66KNERUXZOyxhI/Hx8XzzzTecPXuWnJwc/vGPf9C3b197h9VkhYSEkJCQwLBhw2rcvmfPHsLDwxs2KHHdpF1seaRtFOKPSdvY8kjbeO3kSbeo1a+//srSpUsZO3Ysc+fOpU2bNsyePZu8vDx7hyZspKysjPDwcCZOnGjvUJqFkSNHsn37dr766iuKi4sBMBqNpKWl8e6775KYmMioUaPsHKWoC2kXWyZpG4W4OmkbWyZpG6+dPOkWtfruu++4+eabuemmmwCYPHky+/fvZ9OmTdx55532DU7YRI8ePejRo4e9w2g2Bg0aRGZmJitXrmTFihUAvPrqq6iqikaj4b777pM7wk2MtIstk7SNQlydtI0tk7SN106SblEjg8HAmTNnLBpKjUZDly5dSExMtF9gQjQxY8aMYdCgQezcuZO0tDRUVSUgIIDY2FgCAgLsHZ6oA2kXhRCiOmkbhfhjknSLGuXn52M0GvHy8rJY7+XlRUpKin2CEqKJKC8vZ+/evaSnp+Pm5kavXr0YPXq0vcMS10naRSGEqE7aRiH+mCTdQghhRXl5ebz44oukp6eb1y1ZsoR//vOfdO3a1Y6RCSGEEEIIe5BCaqJGHh4eaDQacnNzLdbn5uZWu5MphPjN559/TkZGBqNGjeK5557joYceQq/Xs3DhQnuHJq6TtItCCFGdtI1C/DFJukWNdDodERERHD161LzOaDRy9OhRoqOj7RiZEI3boUOHGDRoEH/605/o2bMnI0eOZOLEiaSnp0s3uyZO2kUhhKhO2kYh/ph0Lxe1Gj16NO+//z4RERFERUXxww8/UFZWRlxcnL1DEzZSWlpKWlqaeTk9PZ1z587h5uaGr6+vHSNrOjIzM7njjjss1rVv3x4w3fUPDg62R1jCSqRdbJmkbRTi6qRtbJmkbbx2knSLWt1www3k5+ezatUqcnNzCQ8P54UXXpCuQs3Y6dOnmTFjhnl56dKlAAwePJgpU6bYK6wmxWAwoNfrLdY5ODgApjv/ommTdrFlkrZRiKuTtrFlkrbx2imqqqr2DkIIIZqL8ePHM378eLp3725eV1xczCuvvMKkSZOIjIys9j0RERENGKEQQgghhGhIknQLIYQVjR8/vs7fs3LlShtEIoQQQgghGgPpXi6EEFb0+OOP2zsEIYQQQgjRiMiTbiGEEEIIIYQQwkZkyjAhhBBCCCGEEMJGJOkWQgghhBBCCCFsRJJuIYQQQgghhBDCRiTpFkIIIYQQQgghbESSbiFqsGrVKsaNG2exbsqUKbz//vt2ikgIIexP2kYhhKhO2kbxRyTpFs1OdnY2q1at4ty5czY9T1JSEqtWrSI9Pd2m57keJ06cYNWqVRQVFdk7FCGEnUnb+BtpG4UQVaRt/I20jbYjSbdodnJyclizZo3VG8958+bx2GOPmZeTkpJYs2YNGRkZVj2PNZ04cYI1a9ZI4ymEkLbxCtI2CiGqSNv4G2kbbUdn7wCEsJbKykpsOe28g4ODzY4thBC2Im2jEEJUJ22jaEiKasv/baLFWbVqFWvWrGHevHmsWbOGffv2odPpGDZsGOPHjycrK4vFixdz7Ngx9Ho9t99+O7fddpvFMfLy8vjss8/Yv38/xcXFBAcHM2rUKOLi4sz7pKen8+STT/LAAw+g1WpZt24d6enp/OlPf2LJkiXV4nriiSeIi4sjISGBtWvXcvLkSfLy8vD09CQ2NpYJEyag1+urvY9Vq1aZ102ZMoWOHTsyZcoUNm/ezPz586udZ9q0aWzatIkDBw6wYMECdDrL+1qzZs0iIyODt99++6o/x5MnT7JmzRoSExMxGAwEBAQwZMgQRo4cCcD58+f57rvvSEhIICcnBxcXF3r06MGDDz6Iu7u7xXv4vffeew9/f/+rnl8IYV3SNkrbKISoTtpGaRtbCnnSLWxi3rx5tG7dmvvvv5/9+/fzxRdf4ObmxsaNG+ncuTP3338/W7du5ZNPPiEyMpKOHTsCUF5ezvTp00lLS+OWW27B39+fnTt3Mn/+fIqLi82NR5XNmzdTUVHBzTffjIODA3379qWkpIRVq1YxdOhQ2rdvD0BMTAwAO3bsoKysjOHDh+Pu7s6pU6dYt24d2dnZ/O1vf7vm99ehQwduvfVW1q5dy1133UXr1q0BaN26NYMGDWLLli0cOnSIXr16mb8nNzeXo0ePMnbs2Kse+/Dhw/z73//G29ubW2+9FS8vL5KTk9m3b5/5/R8+fJj09HTi4uLw8vIiKSmJjRs3kpSUxOzZs1EUhdjYWFJTU9m+fTsPPfSQuVH18PC45vcphLAuaRulbRRCVCdto7SNzZ0k3cImoqKi+POf/wzA0KFDmTJlCp988gn33Xcfd955JwADBgzgscceY9OmTebGc+PGjSQnJ/PUU09x4403AjBs2DCmT5/OihUruOmmm3B2djafJysri3fffdeiQejRowerVq0iOjqaQYMGWcT1wAMPWNyZHDp0KIGBgSxfvpzMzEx8fX2v6f0FBATQoUMH1q5dS9euXenUqZN5m4eHB61atWLr1q0Wjee2bdtQVbVaTFcyGo188MEHeHt785///AdXV1fztis7pYwYMaLand527drx9ttvc/z4cTp06ECbNm1o27Yt27dvp0+fPnKXUohGQNpGaRuFENVJ2yhtY3MnhdSETQwZMsT8WqPREBERgaqqFutdXV0JDg62qOJ44MABvLy8GDBggHmdTqfj1ltvpbS0lPj4eIvzxMbG1ukO3JUNZ2lpKfn5+URHR6OqKmfPnq3Te6yNRqNh4MCB7N27l5KSEvP6bdu2ER0dfdVG7OzZs6SnpzNy5EiLhhNAUZQa30d5eTn5+fm0a9fOfAwhROMkbaO0jUKI6qRtlLaxuZMn3cImfn/nz8XFBQcHh2oNnYuLCwUFBebljIwMgoKC0Ggs7wdVdcP5fcXHut6Fy8zMZOXKlezdu7daZcbi4uI6HetqBg8ezNdff83u3bsZPHgwKSkpnDlzhsmTJ1/1+y5dugRAaGjoVfcrLCxk9erV/Prrr+Tl5Vlss+b7EEJYl7SN0jYKIaqTtlHaxuZOkm5hE79v/Gpbd72uvHP3R4xGI6+88gqFhYXccccdtG7dGkdHR7Kzs5k/f75VK1iGhIQQERHB1q1bGTx4MFu2bEGn09G/f3+rHP+tt97ixIkT3H777YSHh+Pk5ITRaOTVV1/FaDRa5RxCCOuTtlHaRiFEddI2StvY3EnSLRoVPz8/zp8/j9FotGhsU1JSzNv/yJXdaa504cIFUlNTmTJlCoMHDzavP3z48HVGXbNBgwaxdOlScnJy2L59Oz179sTNze2q3xMQEADAxYsX6dq1a437FBYWcuTIEcaNG2dRXCM1NbXavrX9LIQQTYu0jdI2CiGqk7ZR2samQsZ0i0alR48e5Obm8uuvv5rXVVZWsnbtWpycnMyFM67G0dERoFo3oKrG+Mo7k6qq8sMPP9QrVicnpxrPU2XgwIEoisJHH33EpUuXzAU+rqZt27b4+/vzww8/VDtuVdw1vQ+A77//vtrxqn4W0nVIiKZN2kZpG4UQ1UnbKG1jUyFPukWjMnToUDZs2MD8+fM5c+aMeeqHEydO8PDDD1tUoKxNQEAArq6ubNiwAWdnZxwdHWnXrh3BwcEEBATwySefkJ2djYuLC7t27aKwsLBesYaHh6PRaPj6668pLi7GwcGBzp074+npCZiqUXbr1o2dO3fi6upKz549//CYGo2GSZMmMXfuXJ599lni4uLw9vYmOTmZpKQkpk6diouLCx06dOCbb76hsrISHx8fDh06ZFFYpEpERAQAy5cvZ8CAAWi1Wnr16mVu+IUQTYO0jdI2CiGqk7ZR2samQp50i0ZFr9czffp0Bg4cyC+//MLSpUspLCzkiSeeqDbXYm10Oh1TpkxBo9GwcOFC3n77beLj49HpdDz33HOEh4fz1VdfsXr1agIDA3nyySfrFauXlxeTJ08mPz+f//3vf7z99tskJSVZ7FPVHal///44ODhc03G7d+/OtGnTCAoK4rvvvmPJkiUcPXrUYhqJZ555hm7duvHjjz/y2WefodVqeeGFF6odKyoqivHjx3P+/Hnef/993n77bfLz8+v1foUQ9iNto7SNQojqpG2UtrGpUFRrVgEQQljYs2cPr732GjNmzKBDhw72DkcIIRoFaRuFEKI6aRubL3nSLYQN/fTTTwQEBNC+fXt7hyKEEI2GtI1CCFGdtI3Nl4zpFsIGtm/fzvnz59m/fz8PP/ywVIMUQgikbRRCiJpI29j8SdIthA28/fbbODk5MWTIEEaMGGHvcIQQolGQtlEIIaqTtrH5kzHdQgghhBBCCCGEjciYbiGEEEIIIYQQwkYk6RZCCCGEEEIIIWxEkm4hhBBCCCGEEMJGJOkWQgghhBBCCCFsRJJuIYQQQgghhBDCRiTpFkIIIYQQQgghbESSbiGEEEIIIYQQwkYk6RZCCCGEEEIIIWxEkm4hhBBCCCGEEMJGJOkWQgghhBBCCCFsRJJuIYQQQgghhBDCRiTpFkIIIYQQQgghbESSbiGEEEIIIYQQwkYk6RZCCCGEEEIIIWxEkm4hhBBCCCGEEMJGJOkWQgghhBBCCCFsRJJuIYQQQgghhBDCRiTpFkIIIYQQQgghbERnrQMVFxezfv16jh07Rl5eHn/+85+JioqisLCQzZs307t3bwIDA611OiGEEEIIIYQQotGzStKdlZXF9OnTyczMJCgoiOTkZEpLSwFwc3Njw4YNZGRk8Mgjj1jjdEIIIYQQQgghRJNglaT7k08+oaSkhNdeew0PDw8mT55ssb1Pnz7s37/fGqeyq5ycHAwGg73DEELYkE6nw9vb295hNCnSNgrR/EnbKIQQ9WeVpPvw4cOMGjWKkJAQCgoKqm0PCAggKyvLGqeyK4PBQEVFhb3DEEI0MYmJieahNyNGjCAoKIiysjKSk5MJDg7GycnJ3iFeF2kbhRBCCCFqZ5Wku7y8HA8Pj1q3l5SUWOM0QgjRpBgMBubNm8eePXvM63r37k1QUBCKojB79mxGjRrFmDFj7BilEEIIIYSwJatULw8JCSEhIaHW7Xv27CE8PNwapxJCiCZjxYoV7Nu3j8mTJzNv3jyLbXq9nn79+lkk5EIIIYQQovmxStI9cuRItm/fzldffUVxcTEARqORtLQ03n33XRITExk1apQ1TiWEEE3G9u3bGT58OEOHDsXNza3a9tatW5Oenm6HyIQQQgghREOxSvfyQYMGkZmZycqVK1mxYgUAr776KqqqotFouO++++jbt681TiWEEE1Gfn4+YWFhtW7XaDSUlZU1YERCCCGEEKKhWW2e7jFjxjBo0CB27txJWloaqqoSEBBAbGwsAQEB1jqNEEI0Ga1atSI5ObnW7SdOnCAwMLABIxJCCCGEEA3tupPusrIyXn75ZW6++WaGDx/O6NGjrRGXaCSSk5P56KOPuOOOO+jSpYu9wxGiSRk4cCDfffcd/fr1IygoyGLbxo0b2bFjBxMmTLBTdOJ6HD9+nDVr1vDggw/Spk0be4cjGsjFixdZsmQJd955J507d7Z3OEIIIZqI6x7T7ejoSHp6OoqiWCMe0ch89tlnnD17lvnz59s7FCGanDFjxhATE8O0adOYMWMGAEuWLOHxxx9n4cKFdO/eXW5UNlELFizg7NmzLFmyxN6hiAa0bNkyzp49y3//+197hyKEEKIJsUr38u7du3Po0CGGDRtmjcOJRiQpKQkwTQsnhKgbnU7HCy+8wNatW9m5cydGoxGDwUCbNm249957GTRokNywbKLy8/MBOH/+vJ0jEQ3p4sWLAJSWlto5EiGEEE2JVZLuu+++m7feeot3332XYcOG4e/vj16vr7ZfTdV7ReMmCYEQ9VNeXs7y5cvp1KkTgwYNYtCgQfYOSQghhBBC2IFVku6///3vgOmp6LZt22rdb+XKlXU67pdffsnu3btJTk5Gr9cTHR3NAw88QHBwsHmf6dOnEx8fb/F9Q4cO5c9//rN5OTMzk4ULF3Ls2DGcnJwYPHgwEyZMQKvV1ikeIYS4Vnq9no0bNxISEmLvUIQQQgghhB1Z7Um3LZ6IxsfHM2LECCIjI6msrGT58uXMmjWLN998EycnJ/N+N998M+PHjzcvX/mU3Wg0MmfOHLy8vJg1axY5OTm89957aLVaKWAkhLCpiIgIc3dUIYQQQgjRMlkl6R43bpw1DlPN1KlTLZanTJnCpEmTOHPmDB07djSvd3R0xMvLq8ZjHDp0iKSkJF566SW8vLwIDw9n/PjxLFu2jHHjxqHTWW3WNCGEsPDQQw8xZ84cQkNDiYuLk941QgghhBAtUJPKOIuLi4HqY8O3bt3K1q1b8fLyolevXtx99904OjoCkJiYSFhYmEVS3r17dz788EMuXrxI27Ztq52noqKCiooK87KiKDg7O5tft1Qt+b0LUR/z589Ho9HwwQcf8NFHH+Hj41Ot3oWiKLz22mt2ilAIIYQQQtiaVZLuNWvWXNN+Y8eOrfc5jEYjH3/8MTExMYSFhZnXDxw4EF9fX3x8fDh//jzLli0jJSWFf/zjHwDk5uZWewru6elp3laTL7/80uI9tW3blrlz5+Ln51fv+Jsqjea3WeV+P8+wEOLq3NzccHd3t6hDIYQQQgghWharJN2rV6++pv2uJ+letGgRFy9eZObMmRbrhw4dan4dFhaGt7c3M2fOJC0tjcDAwHqd66677rKYO7fqCW9GRgYGg6Fex2yqjEaj+XVqaqodIxGiYeh0OqvdYJs+fbpVjvN7UmRSCPtQVdXeIQghhGiCrJJ011SV3Gg0kpmZybp160hISOCFF16o9/EXLVrE/v37mTFjBq1atbrqvlFRUQDmpNvLy4tTp05Z7JOXlwdQ6zhwBwcHHBwcatzWkv/gtuT3LkRjIkUmhRBCCCGaDs0f71LPA2s0+Pv786c//YmgoCAWL15c52OoqsqiRYvYvXs3L7/8Mv7+/n/4PefOnQPA29sbgOjoaC5cuGBOtAEOHz6Ms7OzTOUjRC0MBgM///wzaWlp9g6lSYuPj7+mr7qaOnUqcXFxhIaGEh4ezpQpU8jMzOTMmTMW+1UVmaz6cnFxMW+rKjL51FNPER4eTo8ePRg/fjw//vhji+vRI4QQQghhSw1SSK1Dhw4sW7aszt+3aNEitm3bxrPPPouzs7N5DLaLiwt6vZ60tDS2bdtGz549cXNz48KFCyxZsoQOHTrQpk0bALp160ZISAjvvfce999/P7m5uaxYsYIRI0bU+jRbiJZu69atLFu2jLCwMKZNm2bvcJqsGTNmXNN+NfUWqgspMmlfLfm9tzRXXmu57kIIIa5VgyTdp0+frtcfp/Xr1wPVx0U+8cQTxMXFodPpOHLkCD/88ANlZWW0atWK2NhYxowZY95Xo9Hwr3/9iw8//JAXX3wRR0dHBg8ebNHlUghh6ciRIwBcuHDBzpE0bTXdsDAajaSnp/PTTz9hNBq5//77r+scUmTS/qTIZMtx5WcZue5CCCGulVWS7l9++aXG9UVFRSQkJLB7926GDBlS5+OuWrXqqtt9fX2v6UmSn58fzz//fJ3PL4QQ16Njx461bouLi2PatGkcO3aMzp071/scUmTS/qTIZMvRkouLWrPIpBBCtDRWSbrnz59f6zZ3d3fuuOOO66pcLoQQzY1Go+GGG27gq6++qnfPGyky2Ti05Pfeksl1F0IIca2sknS/99571dYpioKrq6t5vJ8QQghLhYWFFBUV1fn7VFVl8eLF7N69m+nTp9e7yOQXX3xBXl6euVu5FJkU4upkHLcQQoj6sErSLd2NhBCiuszMzBrXVw29+eabb+jQoUOdjytFJoWwD3m6LYQQoj6sknSXlJRQVFSEr6+veV12djYbNmygoqKCfv36mbs2CiFESzFlypSrbm/Xrh2TJ0+u83GlyKQQQgghRNNhlaR7wYIFZGRkMHv2bMA0fc3UqVPJzs5GURTWrl3LCy+8QKdOnaxxOiGEaBIef/zxauuqht4EBgbWuxu3FJkUwj6ke7kQQoj6sErSfeLECYtKuVu3biUnJ4dXXnmF0NBQZs6cyRdffCFJdxMkXemEqL+4uDh7hyCEsCL5myiEEKI+NNY4SH5+Pj4+PublvXv30r59e6Kjo3F2dmbw4MHmIj5CCNGSqarK0aNHOXDgACUlJfYORwghhBBC2JhVnnS7urqaC/mUl5dz/Phx7rrrLvN2jUZDeXm5NU4lhBBNxvLly0lMTGTatGmAKeGeNWsWR48eBUzdwF966aV6z5sthBBCCCEaP6s86Y6Ojmb9+vXs3r2bjz/+mPLycvr06WPenpqaavEkXAghWoJdu3YRGRlpXt65cydHjx7l3nvv5bnnnsNoNLJ69Wo7RiiEEEIIIWzNKkn3Aw88gFar5Y033uCnn35i9OjRhIaGAmA0Gtm5c2e9psURQoimLDs72+Ip9q5duwgJCeGuu+6iZ8+eDBs2jPj4eDtGKIQQQgghbM0q3csDAwOZN28eSUlJuLi44O/vb95WVlbGo48+ap4bVgghWgqtVovBYAB+G8s9aNAg83YvLy/y8/PtFZ4QQgghhGgAVkm6AXQ6HeHh4dXWOzs7W3Q1F0KIliI0NJStW7cycOBAdu/eTUFBAT179jRvz8jIwMPDw44RCiGEEEIIW7NK0n3u3DmSkpIYOHCged3Bgwf58ssvqaioYODAgYwcOdIapxJCiCZj7NixzJ07l4kTJwLQvn17OnfubN6+f/9+izHfQgghhBCi+bFK0v3pp5+i1+vNSXd6ejqvv/467u7ueHt7s2TJEvR6vcVc3kII0dx17dqVuXPncvjwYVxcXLjhhhvM2woLC+nQoYP0BBJCCCGEaOasknSfP3+e2267zbz8yy+/oNFomDt3Lh4eHrz11lts2LBBkm4hRIsTEhJCSEhItfVubm48/PDDDR+QEKLeFEWxdwhCCCGaIKsk3cXFxbi7u5uXDxw4QNeuXc1jFbt27crBgwetcSohhGgySkpKKCoqwtfX17wuOzubDRs2UFFRQb9+/YiKirJjhEKIulBV1d4hCCGEaIKsknR7eXmRnJwMQE5ODmfOnCEuLs68vbS0VO4OCyFanAULFpCRkcHs2bMB0w3KqVOnkp2djaIorF27lhdeeIFOnTrZOVIhhBBCCGErVkm6+/Tpw9q1aykvL+fUqVM4ODjQt29f8/bz588TEBBgjVMJIUSTceLECYthNVu3biUnJ4dXXnmF0NBQZs6cyRdffCFJtxBCCCFEM6axxkHuvfdeYmNj2bp1K3l5eTzxxBN4eXkBpic7O3fupGvXrtY4lRBCNBn5+fn4+PiYl/fu3Uv79u2Jjo7G2dmZwYMHc+7cOfsFKIQQQgghbM4qT7qdnJx4+umna932v//9D71eb41TCSFEk+Hq6kpubi4A5eXlHD9+nLvuusu8XaPRUF5ebqfohBBCCCFEQ7BK0v17xcXFODk5odFo0Gg0uLi42OI0QgjRqEVHR7N+/Xpat27NwYMHKS8vt5giLDU11eJJuBBCCCGEaH6s0r0c4PTp08yePZsHHniARx99lPj4eMDUvfI///kPx44ds9aphBCiSXjggQfQarW88cYb/PTTT4wePZrQ0FAAjEYjO3fupEOHDnaOUgghhBBC2JJVnnSfOHGCmTNn4uPjw4033sjPP/9s3ubh4UFxcTEbNmyQYkFCiBYlMDCQefPmkZSUhIuLC/7+/uZtZWVlPProo7Rp08aOEQohhBBCCFuzStK9fPlyWrduzezZsykpKbFIugE6derEL7/8Uufjfvnll+zevZvk5GT0ej3R0dE88MADBAcHm/cpLy9n6dKl/Prrr1RUVNCtWzcmTZpkLuQGkJmZycKFCzl27BhOTk4MHjyYCRMmoNVq6/2ehRDiWuh0OsLDw6utd3Z2tuhqLoQQQgghmierdC8/ffo0cXFxODg41Dgft4+Pj7mYUF3Ex8czYsQIZs+ezYsvvkhlZSWzZs2itLTUvM+SJUvYt28ff/vb35gxYwY5OTm88cYb5u1Go5E5c+ZgMBiYNWsWU6ZMYfPmzaxcubJe71UIIeqiuLiYr776itmzZ/Pss89y6tQpAAoLC/nuu+9IS0uzc4RCCCGEEMKWrPKkW6vVoqpqrduzs7NxcnKq83GnTp1qsTxlyhQmTZrEmTNn6NixI8XFxfz8888888wzdO7cGYAnnniCv/71ryQmJhIdHc2hQ4dISkripZdewsvLi/DwcMaPH8+yZcsYN24cOl31H0FFRQUVFRXmZUVRcHZ2Nr9uqVrye2/J5LrXX1ZWFtOnTyczM5OgoCCSk5PNNw3d3NzYsGEDGRkZPPLII3aOVAghhBBC2IpVku527dqxc+dORo0aVW1baWkpmzdvpmPHjtd9nuLiYsD0YRXgzJkzVFZW0qVLF/M+rVu3xtfX15x0JyYmEhYWZtHdvHv37nz44YdcvHiRtm3bVjvPl19+yZo1a8zLbdu2Ze7cufj5+V33e2hqNJrfOkMEBQXZMRLRkBwdHc2v5brX3yeffEJJSQmvvfYaHh4eTJ482WJ7nz592L9/v52iE0IIIYQQDcEqSfe4ceOYPn06c+bMYcCAAQCcO3eOS5cu8e2335Kfn8/dd999XecwGo18/PHHxMTEEBYWBkBubi46nQ5XV1eLfT09Pc3d2XNzcy0S7qrtVdtqctdddzF69GjzctWTvoyMDAwGw3W9j6bGaDSaX6emptoxEtGQysrKzK9b2nXX6XRWu8F2+PBhRo0aRUhICAUFBdW2BwQEkJWVVefjSr0LIYQQQoimw2pPup9//nkWLlzI+++/D5ie8IDpQ+Xzzz9/3RV6Fy1axMWLF5k5c+Z1x/tHHBwccHBwqHHb1brRN3ct+b23ZHLd66+8vBwPD49at5eUlNTruFX1LiIjI6msrGT58uXMmjWLN9980zyUZ8mSJezfv5+//e1vuLi4sGjRIt544w1eeeUV4Ld6F15eXsyaNYucnBzee+89tFotEyZMqFdcQgghhBCiuutOulVVpaSkhOjoaN5++23OnTtHamoqqqoSEBBARETEdY8JXbRoEfv372fGjBm0atXKvN7LywuDwUBRUZHF0+68vDzz0xwvLy9z4aIrt1dtE0IIWwkJCSEhIYFhw4bVuH3Pnj01Vjb/I1LvonFpye+9JZPrLoQQ4lpdd9JtMBh49NFHue+++7jjjjsIDw+v14fImqiqyuLFi9m9ezfTp0+3mOMWICIiAq1Wy5EjR+jXrx8AKSkpZGZmEh0dDUB0dDRffPEFeXl55m7lhw8fxtnZmZCQEKvEKYQQNRk5ciTvv/8+YWFh9O/fHzA9YU5LS2P16tUkJiby97///brPI/Uu7EvqHrRMPj4+FvUvhBBCiNpcd9Lt4OCAl5dXrd2xr8eiRYvYtm0bzz77LM7OzuYx2C4uLuj1elxcXBgyZAhLly7Fzc0NFxcXFi9eTHR0tDnp7tatGyEhIbz33nvcf//95ObmsmLFCkaMGGGTmIUQosqgQYPIzMxk5cqVrFixAoBXX30VVVXRaDTcd9999O3b97rOIfUuGt7v32tLq3vQUqmqanHtExMT8fX1tWNEDcua9S6EEKKlscqY7ri4OH755ReGDx9eY5fE+lq/fj0A06dPt1j/xBNPEBcXB8BDDz2Eoii88cYbGAwGc7GgKhqNhn/96198+OGHvPjiizg6OjJ48GDGjx9vtTiFEKI2Y8aMYdCgQezcuZO0tDTz0JvY2FgCAgKu+/hS76LhFRYWWiwbDAYpPtcCFBcXU1lZaV4uLCy0GPImhBBC1MYqGXJYWBh79uzhb3/7G3Fxcfj5+aHX66vtFxsbW6fjrlq16g/30ev1TJo0ySLR/j0/Pz+ef/75Op1bCCGuR1lZGS+//DI333wzw4cPt3hCbC1S78I+fl+JvrCw0NxLQDRfRUVFFsu/v/kihBBC1MYqSffbb79tfr1y5cpa97vaNiGEaE4cHR1JT0+3SbElqXdhX/n5+RbLBQUFknS3AFU3parUNA2gEEIIUROrJN3Tpk2zxmGEEKJZ6d69O4cOHaq1enl9Sb0L+/p98pWbmys3KlqA39c6qK32gRBCCPF7Vkm6O3bsaI3DCCFEs3L33Xfz1ltv8e677zJs2DD8/f1rHHpTVXX8Wkm9C/vKzMy86rJonrKzsy2Ws7Ky7BSJEEKIpsZ6Vc8wVdE9c+YM6enpAPj7+xMREYFGo7HmaYQQokmomg4sKSmJbdu21bpfXYfeSL0L+6r6G1fbsmieqm6uqFo9SmW53GwRQghxzayWdG/evJnPPvusWrc7Dw8P7rvvPoYMGWKtUwkhRJNw991322RMt7CvtLQ0AMJ1cM4Aly5dsnNEoiFU3VxRvVujZJ6Vmy1CCCGumVWS7g0bNvDhhx8SHh7OPffcQ1BQEGAq3LNx40YWLFiAwWBg+PDh1jidEEI0CePGjbN3CMIGqpKtaAdT0i3JV/Onqirnzp0zvfaPgMyzXLp0ieLiYlxcXOwbnBBCiEbPKv2+v/76a9q3b8/s2bMZNmwYnTt3pnPnzgwfPpxXX32VmJgYvvnmG2ucSgghmiRVVcnLyyMvL69FzWnd3BQVFZmnimp3ud5cRkaGxfzNovlJS0ujoKAAVdGCTxiqkweqqlabdk8IIYSoiVWedOfm5jJ69Gh0uuqH0+l03HDDDSxbtswapxJCiCYlKSmJlStXcujQIcrKygDTdGLdunXjnnvuISwszM4Riro4ffo0AK00EKAFJwVKKyq4ePEi4eHh9g1O2Mzx48dNLzz8QaNF9QpCScsnISGBrl272jc4IYQQjZ5Vku62bduSmppa6/bU1FT5MCKEaHESEhJ49dVXUVWV3r17ExwcDJiG3uzdu5eDBw/ywgsv0KFDBztHKq7ViRMnAGijA42i0EancqLClJTJ37nm69ixYwCoXqbfYbyCIe2Eeb0QQghxNVZJuh955BH+/e9/ExAQwNChQ81T4pSXl7N+/Xp27NghFXKFEC3OkiVL8PT0ZPr06fj6+lpsy8zMZNq0aSxdupQ5c+bYKUJRV1VJVuTlruWRDnCiwrT+lltusWNkwlbKysp+S7pbmXqmqN6tAYXk5GTS09Px9/e3Y4RCCCEaO6sk3fPnz0ej0bBkyRI+/fRTvL29AcjJyaGyshIfHx/ef/99i+9RFIXXXnvNGqcXQohG6eLFi4wfP75awg3g6+vL8OHDWb16tR0iE/WRnp7OxYsXUYCoy0l31b8nTpygsLCwznOui8bv4MGDlJeXozq6gauPaaWDk6mLeW4Ku3bt4rbbbrNvkEIIIRo1qyTdbm5uuLu7m6uWV5E7v0KIlszPzw+DwVDrdoPBQKtWrRowInE9duzYAUCkDlw1pqng/LUKgVqVtMpK9uzZw0033WTPEIUNbNu2DQA1oB1cMQWgGtAOJTeF7du3M2rUKDQaq9SmFUII0QxZJemePn26NQ4jhBDNytixY1myZAk9e/asNt737NmzrFu3joceesg+wYk6UVWVnTt3AtDN0XJbDz2sLYGdO3dK0t3MpKenEx8fD4AaEG2xTfUNRz31KxkZGRw/fpyOHTvaI0QhhBBNgFWSbiGEENUlJibi6enJc889R0xMDIGBgYCpuGRiYiJhYWEkJiaSmJho/h5FUXjkkUfsFbKoRWJiIunp6TgAHfWW27o6wroSOHXqFCkpKeaCeaLp27x5MwCqdwg4u1tu1Dqg+kehpCawadMmSbqFEELUSpJuIYSwkR9//NH8+sSJE+bK11UuXLjAhQsXqn2fJN2Nz3fffQeYnnI7XtHFGMBdo9DeQSWhAr7//nsmT55sjxCFlRUXF/PLL78AYAyuOaFWgztCagIHDhzg0qVLBAQENGSIQgghmghJuoUQwkZWrlxp7xCEFRw5coT4+Hg0wGCnmve5yRkSKmDXrl0MGzZMpg9rBtatW0dpaSmqixf4hNa8k6s3qk8oZF/kyy+/5P/+7/8aNEYhhBBNg1T9EEIIIWpRVlbGp59+CkA/R/DWKjXuF6xT6Ko3jf1eunQplZWVDRmmsLK0tDRzTxVjeG+LAmq/ZwzvBSjs2bPHPP5bCCGEuJIk3UIIIUQtvvzySzIzM/HQwM0uV993pAs4KXD+/HmLoQWiaSkuLua9997DYDCYxnK3anP1b3DzxRjcAYAPPviAzMzMBohSCCFEUyJJtxBCCFGDo0ePsnHjRgDudKk+lvv33DQKIy8n5l9//TXnzp2zcYTC2oxGIwsWLCA1NRVV74oxetBVn3JXUdv2QXVtRUFBAe+++y6lpaUNEK0QQoimQpJuIYQQ4ncuXLjAf//7X1RVpZcjROv/OPEC0/Rh7R1Mc7DPmzeP9PR0G0cqrOnzzz/n6NGjoNFi7DQMHP+ge0MVrQPGTsNQHZxJSkpi8eLFqKpq22CFEEI0GfUqpDZ+/Ph6nUyKCgkhhGjszp07x7x58ygtLaWtDm67xrwLTFO+3eOm8mE+pBYU8Nprr/G3v/2NoKAg2wUsrOLXX39l3bp1AKYn3O6+dTuAkxvGjjejPfwD+/bt4+uvv+bOO++0fqBCCCGanHol3XfffTfK77pb7d69m6SkJLp162aeozQ5OZnDhw8TGhpKnz59rj9aIYQQwoaOHDnCf//7X8rKygjWwgQ30F1D9+IrOSoKf3I3Jd5Z2dnMmTOHp59+mqioKBtFLa7X0aNH+eijjwAwhnZD9Y+s34E8AzFGDUBzcivffvst3t7eDB482IqRCiGEaIrqlXSPGzfOYnnjxo3k5+fzxhtvmBPuKklJScycORNvb+86nyc+Pp5vvvmGs2fPkpOTwz/+8Q/69u1r3v7++++b59Cs0q1bN6ZOnWpeLiwsZPHixezbtw9FUYiNjeWRRx7ByamWeV+EEEK0SD///DPLly/HaDQSpYP73P94HHdt3DUKf/ZQ+aQAkoqKeO2113j00UeJjY21ctTiem3ZsoVPP/0Uo9GI0S8SNbz3dR1PDYrBWFqA5uJBli5dSk5ODrfffjsajYzoE0KIlsoq83R/8803jBgxolrCDRASEsItt9zCN998w9ChQ+t03LKyMsLDwxkyZAivv/56jft0796dJ554wrys01m+pXfeeYecnBxefPFFKisrmT9/PgsWLOCZZ56pUyxCCPFHZsyYUefvURSFl19+2QbRiGtVWVnJypUr+emnnwDTuOw7XOv+hPv3XDUKj3qorCqE4xUGPvjgA9LS0rjtttskAWsEKioqWLFiBZs3bwZA9W2LGnNthdP+iBreC6PRgCb5KN9++y0XLlxg4sSJuLq6XvexhRBCND1WSbqzsrKqJbtX0mq1ZGVl1fm4PXr0oEePHlfdR6fT4eXlVeO2pKQkDh48yJw5c4iMNHUVe/TRR5kzZw4PPvggPj4+dY5JCCFqo6pqtaE3mZmZpKen4+Ligr+/PwDp6ekUFxcTEBBAq1at7BGquKygoID//e9/HD9+HIBhzjDIiWrXsb70isIEN5UfS2B7qekm9cWLF5k4cSLOzs5WOYeou7S0NP73v/9x8eJFwDQXtxrazSoJNwCKghrZD6OrD5qT2zl06BAzZszgz3/+swwzEEKIFsgqSXdYWBg//vgjAwcOrJbIZmVlsX79esLCwqxxqmri4+OZNGkSrq6udO7cmXvvvRd3d3cAEhMTcXV1NSfcAF26dEFRFE6dOmXRVf1KFRUVVFRUmJcVRTF/OLLWB7GmqCW/95bmymst1/3aTZ8+3WL5+PHjzJ07l8cee4zBgwej1WoB05PVTZs2sWzZMoueOtdKht5Yx8WLF3n33XfJyspCr8DdrtDpGquU14VGUbjVBfy1Kt8UwYEDB3j11Vd5+umn8fPzs/r5RO1UVWX79u189tlnlJWVoTo4YYwZDD6htjlfYDSVrj5oEn4mKyuLuXPncuedd3LrrbdKbwchhGhBrJJ0P/TQQ8yePZtnnnmGPn36EBgYCJjuJO/ZswdVVXnqqaescSoL3bt3JzY2Fn9/f9LS0li+fDmvvvoqs2fPRqPRkJubi4eHh8X3aLVa3NzcyM3NrfW4X375JWvWrDEvt23blrlz57bID0dXfiiQ6rsth6Ojo/m1XPf6++STT7jpppsYMmSIxXqtVsvQoUNJSUlh6dKlvPrqq3U6rgy9uX6HDh1iwYIFlJWV0UoD97uDv9a2N5h6OSr4a1U+K4CUlBRmzZrFlClTiI6Otul5hUlxcTFLly5lz549AKieQRjbx4Gjjbt8u/ti7HknysltkHGGL774gmPHjjFp0iTpcSeEEC2EVZLu9u3bM3v2bFauXMmePXsoLy8HQK/X061bN8aNG2eTJ90DBgwwvw4LC6NNmzY89dRTHDt2jC5dutT7uHfddRejR482L1c96cvIyMBgMNQ/4CbIaDSaX6emptoxEtGQSktLza9b2nXX6XRWu8F2/vx5brzxxlq3+/v7s379+jofV4be1F9lZSXffvst3333Haqq0lYH97mBi6ZhenSE6hQe91RZVgDJhYW8/vrr3H333QwbNkyefNrQhQsXeP/998nMzARFwdimF2poV1Aa6Geu06O2vwmjdwiaU79y4sQJpk+fzmOPPUanTp0aJgYhhBB2Y5WkG0xJ7z//+U+MRiP5+fkAeHh4NOiHiICAANzd3UlLS6NLly54eXmZY6lSWVlJYWFhrR9GARwcHHBwcKhxm6qq1gy5SWnJ770lk+tef97e3uzYsYNhw4aZu5ZXqays5Ndff63XzA7XQobeVJeZmckHH3zAqVOnAOjtaJqDW9vAsXtoFCZ6qHxRBEfLK1m1ahXx8fFMnDgRT0/PBo2lJdi5cycfffQxFRXlqE7uGNvfBB7+DR+Iopi6m3sGoEnYRFFhJm+99RZjx47llltuaRK/Q0IIIerHakl3FY1Gg4uLi/l1Q8rKyqKwsND8ITY6OpqioiLOnDlDREQEYJqLU1VVKWQihLC5O+64g4ULFzJ16lSGDRtmHnqTmprKhg0bOHfuHJMmTbL6eWXojSVVVVm/fj0LFiygpKQERwVud4FujvZLcvSKwnhXlQgd/FBs+ts0bdo0nnzyyav2jhDXrrKyksWLF/PFF18AoHqHmLqTO9i5boGzJ8buo1FO/ormUiKrV6/m0qVL/PWvf21RNRWEEKIlsVrSnZmZyapVqzhw4IDFk+4ePXpwzz331OtDWWlpKWlpaebl9PR0zp07h5ubG25ubqxevZrY2Fi8vLy4dOkSn376KYGBgXTr1g0wTVfWvXt3FixYwOTJkzEYDCxevJgbbrihWXefFEI0DkOHDkWj0bB8+XI++OADi20eHh5Mnjy5zlMpXgsZevOb3NxcPv74Yw4fPgxAqA7ucQUfG4/fvhaKotDXCdroVFYXQVp+Pq+++iqxsbHcf//9uLm52TvEJis7O5tFixaRkJAAgDG0G2p4r4brTv5HNDrU6BsxuvuiOb2DLVu2cObMGR577DFat25t7+hqZM2hN0II0dJYJelOTk7m5ZdfpqioiK5du5r/YKSkpLBlyxb27dvHK6+8UuM83ldz+vRpi3lvly5dCsDgwYOZPHkyFy5c4JdffqGoqAgfHx+6du3K+PHjLbqGP/300yxatIiZM2eaK/Q++uijVnjXQgjxx4YMGcLgwYM5ffq0aTwp4OvrS2RkZLUu57bSUofe7Nmzh08++YSioiK0wFBnGOBkqibemAToFP7PQ2VTCWwphV27dnHixAkeeeQROnfubO/wmhSDwcDGjRv55ptvKCsrA42OypjB4NfW3qFVpyiowR1N1c3jfyIpKYlp06YxfPhwbrvtNnnqLYQQzYhVku5ly5ahKAr/+c9/qhVMu3DhAq+88grLli3jn//8Z52O26lTJ1atWlXr9iunv6mNm5tbi6nGK4RonLRaLdHR0XarUt3Sht4UFRXx2WefsXPnTgCCtDDW1ZTcNlY6RWGYC3TQq6wphMzcXN566y3i4uIYN26cxYwCojpVVTl69CirVq0iJSXFtM4jAGO7geBqm7oJVuMZiLHnnWhO/Yox6zzr1q1j9+7djBkzhtjYWCmwJ4QQzYBVku6EhARGjx5dY4XysLAwRowYwffff2+NUwkhRJNiNBrZsmUL+/fvt3jS3atXL2688cZ6faCWoTe1O3r0KB9//DE5OTkowGAniHM2JbVNQYhO4QlPlfXFsLMMNm/ebC6y1hxuiNjC+fPnWb16tbkruerghNq2L2pAO2gi1x1HV4ydhkHWBTSnfiU7O5sPP/yQDRs2cM8999ChQwd7RyiEEOI6WCXpNhgM6PX6Wrc7Ojo22vF+QghhK8XFxcyePZtTp07h7OxMQEAAAEeOHGHXrl2sX7+eqVOnmotPXisZelNdSUkJq1ev5pdffgHAVwN3u5mm6Gpq9IrCaFdorzdVOE9PT+ff//43w4cP584777zq39uWpKSkhC+++IJNmzaZhjcoGoytO6GGdrN/sbT6ahWG0SsYJfkoysVDnD9/ntdff53evXtz3333XXX4hxBCiMbLKkl327Zt+fnnn7n55purfXgsLi7m559/NndhFEKIlmL58uWcOXOGRx99lJtvvhmdztTkGgwGfv75Zz766CNWrFhR52RXht5Yio+P56OPPiI7OxuAfo4w3MWUvDZlUQ4KT3mofF8MB8tVfvzxRw4fPswjjzxiMd1bS7R//36WLVtmrrZv9ItADe8Dzu72DcwatDrUsO6ogTEoFw6gSU1g7969HDt2jLFjxzJo0CDpci6EEE2MVZLucePGMXv2bP7yl78QFxdnLpiWkpLCL7/8QkFBARMnTrTGqYQQosnYvXs3w4cPZ8SIERbrdTodw4cPJykpiV27djXpJ8z2VFxczMqVK9m2bRsA3hq4yxUiHJp2sn0lZ43CWDfoVK7ydZFpurk5c+YwdOhQ7rrrrhY31jszM5Ply5dz8OBBAFQnD4ztBoB346z4fV30zqhRN1AZGIMmcSslhZl88skn7NixgwcffJCQkBB7RyiEEOIaWSXp7ty5M88//zyffvopX3/9tcW28PBwnnzySanAKoRocQoLC686a0Pr1q0pLCxswIiaB1VV2bdvH5999hl5eXkAxF5+uu3YxJ9u16aDXqGNzvTU+1C5yoYNGzh48CAPPPBAi/j7WlWV/Ouvv6a8vNzUlTykC2pYD9BabfbTxsmtFcYet6OkxKOc28epU6eYMWMGw4cPZ/To0Tg7O9s7QiGEEH/Aan+punbtyn/+8x9yc3PJyMgAwM/PT8YfCSFarMDAQPbu3VvtSXeVvXv3msd5i2tz/vx5VqxYQWJiIgCtLj/dDm9GT7dr46JRuMcNuparfF1smh/9rbfeokuXLowfP56goCB7h2h1qqpy6NAhVq1axaVLl0zrPAJNT7cbe1Vya1I0qK07o/q2RXN6B8bMc6xbt44dO3YwZswYbrjhBulyLoQQjZjVbw97eXlJoi2EEMDw4cNZvHgxc+bMYeTIkeakKCUlhbVr13L48GEZenONCgsLWbNmDdu2bUNVVXTAQCcY7AwOzfTpdm1i9ApPO6j8fLnC+ZEjR4g/dowhN9/MHXfc0WyefKakpLBixQqOHTsGgOrgjNq2T9OqSm5tjq4YOw41VTk/vZO8vDw++ugjNm3axH333ScV7oUQopGyWtJdXFzM999/X+O0OCNHjqxzdV4hhP2oqmrvEJqFESNGkJeXx9dff20eg1pFp9MxduxYhg8fbp/gmgij0cj27dtZs2aNuSt+Vz0MdwYvbQtNvAAnRWGkK/R1UllXDMcrjGzYsIE9e/Zw77330rt3b5QmmpgWFRXx9ddfs2nTJoxG4+Wu5J1RQ7uDTiq3A6Yq596tUZKPoVw4wLlz55gzZw6xsbGMHTu2yU/9J4QQzY1Vku7s7GymTZtGeno6wcHBxMTEAKa71FVTuMycORNv7xbUFUwIITAVmrzllls4fPiw+Yakn58fXbp0wcPDw87RNW7Z2dksWrSI48ePAxCghdtdoE0L6Ep+rXy1Cg+4w8lylW+LITs3l//97390796dhx9+GHf3plXN++jRo3z44YcUFBQAoLZqgzEiFpzld6UajRY1tCtqQBTKub1o0hLZtWsXBw8e5P7772fAgAH2jlAIIcRlVkm6q6bteO655+jZs6fFtgMHDvDmm2+ybNkynnzySWucTghhY031CVlj5eHhwcCBA+0dRpOyd+9elixZQnFxMQ7Azc7Q3wm08n+zRu30Ck85qGwpgS2lcPDgQaZNm8ajjz7aJAqtGQwGvvrqK9auXQuA6uKFMbIfeEuF7j+kd0GNHkRlUEc0p3+lLD+dxYsXk5CQwAMPPICTUxOds1wIIZoRqyTdBw8eZOTIkdUSboAePXpw66238tNPP1njVEKIBmY0GqVAz3WKj49n//79FkUme/bsSceOHe0cWeNTUFDAZ599xu7duwForYV73ExPdMXVOSgKN7tAR73KqkLIyMvjrbfeYvDgwdxzzz2Ndqx3WVkZ//3vfzly5AgAxqAOqJGxoGnmVcmtzd0XY7fRKBcOoTm/nx07dpCSksJf/vIX6VUjhBB2ZpW/aGVlZXh6eta63cvLi7KyMmucSgjRwCorKyXprieDwcC8efPYs2cPgLm2RXFxMd9++y19+/blmWeeQaeT5AJg//79LF26lIKCAjTAjU4wxFmebtdVkE7hcU+V9ZcLrf3yyy8cOXKERx99lA4dOtg7PAuFhYW88847nD59GjRaKmMGg1+EvcNquhQNapseVHoFoYnfyPnz55kzZw5///vf8fX1tXd0QgjRYlnlk3RISAjbt2/HYDBU22YwGNi+fTshIdJFrCm6sqCW0Wi0YySiIV153SsqKuwYSdO2evVq9uzZw2233caCBQv46KOP+Oijj/jggw+47bbb2L17N2vWrLF3mHZnNBr5/PPPef/99ykoKCBAC495wDAXRRLuetIrCqNdFR51B2+NaXz8G2+8wbp16xpNocTc3Fz+85//cPr0aVSdI5VdRkrCbS2egRi73Ybq6EZ6ejr//ve/SUlJsXdUQgjRYlkl6b7jjjs4deoUzz//PBs3buTYsWMcO3aMDRs28MILL3Dq1CnuvPNOa5xKNLArP5yVlpbaMRLRkK5MtOW619+2bdsYPHgwDzzwgMVUip6enjzwwAMMGjSIrVu32i/ARqC4uJh33nmHH374AYAbHOFxD2itk2TbGiIcFJ7yhB56U3u+evVqFi5caPebaZmZmcydO5fk5GRUvQvGbqPAU+astyoXT4zdb0N18SInJ4e5c+dy7tw5e0clhBAtklX6NPbv35+ysjKWLVvGwoULLbZ5eHjw+OOP069fP2ucSjQgVVUpLy83LxcVFcnUby1EUVGR+XVBQYFMP1NPubm5V503t127dvz6668NGFHjkpWVxdtvv01ycjIOwJ2u0M1Rkm1r0ysKY1xVQnTwfTHs2rWLrKwsnnzySbtUN09JSeGNN94gNzcX1ckdY5dbpTq5rTi6Yuw2Gs2RdRQWZvLaa6/x1FNP0b59e3tHJoQQLYrVBhLGxcVx4403cvr0aYt5uiMjI9FqtdY6jWhA5eXlFkMGCgsL8fPzs2NEoqFUTdfz+9eibnx8fIiPj691Lu74+PgWe0MjNzeXV199ldzcXNwUeNBdnm7bkqIoxDqBn1bls0I4deoUc+bM4cUXX2zQm6lJSUm89tprFBYWorp4Y+xyCzi6Ntj5WyQHJ4xdR6I5toHSvFTeeustnn76aTp16mTvyIQQosWwanUkrVZLdHQ0N9xwAzfccAPR0dGScDdhubm5Fst5eXn2CUQ0KIPBYHGts7Oz7RhN0zZ48GB27NjBBx98QEpKCkajEaPRSEpKCgsXLmTHjh3ExcXZO8wGZzQaWbRoEbm5ufhq4P+kO3mDiXBQ+LMHeGjg0qVLfPLJJw02xjstLY033njDlHC7+5m6lEvC3TB0eoxdRqD6hGEwGHjvvfc4efKkvaMSQogWo15PuuPj4+t1Mpkep2nJycmxWJbkq2XIysqyKJpXNc2VqLsxY8Zw6dIlfvrpJ3766SdzFfiqn+/gwYO566677BmiXWzfvp34+HgcgAnu4CXTgTUof63Cva4qHxbA7t27iY2NpXv37jY9Z2VlJe+99x75+fmorq0wdr4FHBxtek7xOxodxo43ozm2gfKcJN577z1effVVXF3lxocQQthavZLuGTNm1OtkK1eurNf3CfuoGiZQJSsry06RiIaUnp5usXzp0iU7RdL0aTQapkyZwujRozlw4IDFPN09evSgTZs2do6w4VVWVpqLpt3sbEoARcMLc1AY4KSytRS+++47unXrhmLDSvHbtm0jNTUV1cHJ1KVcEm770GgxdhyK5sBXFBbmsm7dOu6++257RyWEEM1evZLuadOmWTsO0Qj9PtmS5KtlqLrOqqJBUY1y3a2gTZs2LTLBrsn+/ftJT0/HRYG+TvaOpmUb4AQ7SuHs2bMkJiYSExNjs3NVVelXQ7uB3tlm5xHXQKvDGN4HbfwGtmzZIkm3EEI0gHol3dJNvGWomlqkqx4OlyNTjbQQ5iS7VRhkniM9PR2j0WjuGi3E9diwYQMAsY6mqtrCftw0Cj0cVfaUwfr1622adFcVZFQ9ZFqwRsHDHzAVSJX2XQghbM9q1cur5OXlWXSh9PT0tPYpRAMwGAycPn0agH6OcLTcNMY7IyNDKpg3cxcuXABA9QmF7IuUl5eTnp5OYGCgnSNr/MaPH1/n71EUhRUrVtggmsZHVVXOnz8PQGe9nYMRgOk67CnDfF1sxdx13VBm0/OIa2QwTQeq1Wol6RZCiAZgtaT7yJEjLFu2jLNnz1qsb9u2LRMmTKBr167WOpVoAOfOnaOsrAwXBUJ0pq8LBkhISJCkuxkrLy83f/hWPQJQ3Hwh/xInT56UpPsa3H333TYdF9vUKYpCYGAgSUlJpFZCgNVv+4q6Srs8K2RQUJBNz9OpUyc2b96Mcumk6YaesCvlkqlyeUxMDDqd/CIKIYStWaWl3b17N2+++Saenp7ccccd5j/eKSkpbNmyhTlz5vDXv/6Vvn371um48fHxfPPNN5w9e5acnBz+8Y9/WBxDVVVWrVrFTz/9RFFREe3bt2fSpEkWHx4KCwtZvHgx+/btM81TGhvLI488gpOTDCa8msOHDwMQ6QAaRSHKQeWCwbR+0KBBdo5O2MrRo0epqKhAdXQDZ09U79Yo+Zc4cOAAN954o73Da/TGjRtn7xAavc6dO5OUlMT3xRCiU/GVQmp2k2JQ2Vhiet25c2ebnqt///5s3rwZTcYZjB7+qK1tez5xFZnn0Fw8CMCAAQPsG4sQQrQQVulPtGLFCkJDQ5k3bx4TJkzgpptu4qabbuL+++/nrbfeonXr1vXqPllWVkZ4eDgTJ06scfvXX3/N2rVrmTx5Mq+++iqOjo7Mnj2b8vJy8z7vvPMOFy9e5MUXX+Rf//oXCQkJLFiwoN7vtSUwGo3s3bsXgPYOWPx77NgxioqK7BSZsDVzsSPfcFAUVN+2gKkni0wZJ6zhzjvvJCIighIVlhRAVmXDzBEtLKUaVJYWQAWmhHvYsGE2PV9UVBT33HMPAJrTO1HST9v0fKIWeWloj28CIC4ujtjYWDsHJIQQLYNVnnRfunSJ+++/H2fn6hVJXVxcGDJkCJ999lmdj9ujRw969OhR4zZVVfnhhx8YM2YMffr0AeDJJ59k8uTJ7NmzhwEDBpCUlMTBgweZM2cOkZGRADz66KPMmTOHBx98EB8fnxqPXVFRQUVFhXlZURTze2sJXUf37NnDpUuXcFIg5vK4yyAtBGjhUnk569evZ8yYMfYNUljdhQsXzD0c1OAOppWu3qiegRjz0li3bh3333+/HSNsmvLz8/nqq69qnDLs9ttvx8vLq87HbMq9gBwcHJgyZQr//ve/ycjI4IN8eNBdJUTX/NvWxuJ0hcpnhVCmQmhoKI899liDjOkdMWIEmZmZbNq0Cc2JzVRqdOArVf0bTEEGmqPrwVhJly5dmDBhQov4TCOEEI2BVZLu1q1bk5eXV+v23Nxcq48XS09PJzc312KsuIuLC1FRUSQmJjJgwAASExNxdXU1J9wAXbp0QVEUTp06VWt39y+//JI1a9aYl9u2bcvcuXNbxFjmvLw8Pv/8c8A0nYzT5T/IiqIwxFlleSFsWL+e0aNHyxRIzUhFRQWzZs0CwOgXAc6/FUA0hnZHm7eOn3/+mZEjR8rsBXVw8eJFZs6cSX5+PlFRUfTr1w+A1NRUvv/+e7Zu3cpLL71EWFhYnY5b1QtoyJAhvP7669W2V/UCmjJlCv7+/qxcuZLZs2fz5ptvoteb7qS988475OTk8OKLL1JZWcn8+fNZsGABzzzzzPW/8T/g5eXF888/z1tvvcXFixdZkA+xjipDncFJI0mArRQaVX4shgOXO4O1a9eOp59+GhcXlwY5v6IoTJgwgeLiYnbt2oU2fgNG/0jUiFjQN0wMLZKhHOX8fjQpx0BVadeuHY8//jhardbekQkhRIthlaT7gQceYN68eURFRZmfOlfZvXs3Gzdu5C9/+Ys1TmWWm5sLUK06uqenp3lbbm4uHh4eFtu1Wi1ubm7mfWpy1113MXr0aPNy1Z3gjIwMDAbD9QffSKmqyjvvvENWVha+Grjhdw+8OjpAlA5OlZfzyiuv8OKLL+Lo6GifYIVVrVmzhjNnzqDqHFEj+1lu9AnB6N8OTfpJ5s6dy7Rp02rs1dJc6HQ6q91gW7RoEUajkdmzZxMVFWWx7dSpU8yZM4ePPvqIadOm1em4zaEXkJeXF8899xxLlixhz5497CwzzZIwyFmlux5cJPm2mkKjyt4y2FYKpZd78w8aNIgJEyaYb8I0FK1Wy8SJE3F1dTU98U4/jZp1AbV1J1T/SHDxbtB4mrXSApSMMyjJx1DKiwHo3bs3Dz/8sNS1EUKIBlavpHvu3LnV1nl4ePD666/j4+NjrnKclpZGdnY2wcHBrFu3rslUMHdwcMDBwaHGbarafMcf/vjjjxw6dAgdMN4NHH/3IVpRFMa6qbyXB8nJyXz22Wc8/PDDdolVWM+xY8dYu3YtAMZ2A2t84qRG9UPNSyU9PZ2lS5cyefJk6ZZ4DU6dOsVdd91VLeEG0xjXW2+9la+++sqq52xqvYBmzpzJgQMHeP/990lOTuaHYlhfDJ31Kn0cIUzXMob1WJtRVTlrME0HFl8OxsvrIyMjmTJlCh06dLBrfP/85z+5/fbbef/99zl58iTKhYNw4SCqqw+qXwSqXwQ4e/zhccTvlBejZJxFyTiNkp9uXh0cHMwTTzxBr1697BicEEK0XPVKuqvm8f09X19fwPShD0Cj0eDr60t5eXmt31NfVeMg8/Ly8Pb+7c54Xl4e4eHh5n3y8/Mtvq+yspLCwsJ6jaNszo4fP87nlz9Mj3SBoFrGV7ppFMa5qXxUYCq61bZtWwYPHtyQoQorysjI4IMPPkBVVYyB7cGvbc076hwxtr8J7eHv2LVrFxEREQwdOrRhg22CPD09a72BB6DX66v11rleTbEXUGBgIC+//DLbtm1j8+bNXLx4kYPlcLAc/LXQS6/SzdHU/oiryzOqHCiD/WWQbfxtfWRkJHFxcfTv3x+NRkNqaqr9grzMw8OD5557ztTTYedOjh49SmVRNkpRNpzbi+ruh+oXierXFhxd7R1u41VRipJ5zvRUOzcVMD0cUBSFmJgY+vbty4ABA3BwcLiu627NXkBCCNHS1Cvpfv/9960dR535+/vj5eXFkSNHzEl2cXExp06dYvjw4QBER0dTVFTEmTNniIiIAExTIqmqWuOTp5bqzJkzvPPOO1QajXTRQ58/6DEe4WAa3/1TCXzyySc4OzvXeTo4YX8FBQW88847FBYWorr5Vu9W/nueARjb9kVzZhcrV67E19eX7t27N0isTdXIkSNZt24dgwYNqnajLzs7m/Xr1zNy5Ej7BFcPtuwFpNPpiIuLY/DgwZw9e5bNmzezZ/du0isqWFsCP5ZAjINKL0do5wBaefptVqGqnKiAfWVwqqIq5QInJyf69+/P4MGDCQ39bW7sxtRjS1EU+vbtS9++fSksLOTAgQPs3r2bhIQEKMhAKciAMztRPQN/S8AdpGs0hnKUrPOmRDsnCa64phEREfTt25fevXtbPJRoTNddCCFaGquM6baV0tJS0tLSzMvp6emcO3cONzc3fH19GTlyJF988QVBQUH4+/uzYsUKvL29zeMYQ0JC6N69OwsWLGDy5MkYDAYWL17MDTfcUOuYxZYmPj6e+fPnU1ZWRoQOxrheW1fOOCfIM8LeMpUPFy6krKxM5nFuQgoLC3njjTdISUlB1btg7DgUtH/cHKitO2MsyoZLJ5k/fz5TpkyhW7duDRBx0/Ddd99VW+fk5MRTTz1F3759zUNvUlNT2bNnD4GBgVb/INzUewEpikJERAQRERHce++97N69m23btnH27FkSKiChApwV6KhX6aKHtrqWmYAbVJVTFaZx8AkVpkrkVaKjoxkwYAC9e/duUmN33dzcuPHGG7nxxhvJy8tj37597N6929T9PC8NJS8NTv+K6tUa1T8StVUb0DXsmHS7MlZC9kVT1/GsCyjGSvOm0NBQ+vbtS58+feRptBBCNEKNOuk+ffo0M2bMMC8vXboUgMGDBzNlyhTuuOMOysrKWLBgAcXFxbRv354XXnjBojDM008/zaJFi5g5c6Z5WpxHH320wd9LY7Rt2zaWLllCpdFIGx084A4O1/jhVVEUbndRqVThQLmRjz/+mIyMDO68884GmXpG1F9aWhrvvPMOly5dQnVwxth1JDi5Xds3Kwpq9I0YjQbIOMt7773H/fffT1xcnE1jbio++eSTWrdt27at2roLFy7wySefWHTZvl7NqReQi4sLcXFxxMXFkZSUxPbt29mxYwcFBQXsKzM92XVRoJNepaMDhDtcexvWFJWrKmcq4NjlRLv0ikTb29ubG264gQEDBhAQEGC/IK3E09OTIUOGMGTIELKzs9m9eze7d+/m/PnzKDlJKDlJqBotqk+Yafy3d+vmmYBXGiAv1TROO/McSmW5eVNAQACxsbH06dOH4OBgOwYphBDijyiq9De6ZhkZGRaVe5uqiooKVqxYwebNmwHoqoe7XOv3YVVVTd3MN5ealrt06cKkSZNwc7vGJE40GFVV2b17N59++inFxcWojm4Yu4yoX7VgoxElcQua9FOA6UbY2LFjG2zqIVtycHCo95Oiqnm466qu57uyF9Czzz7Ln/70Jzp37mzuBfTVV1/x9ddfm6cMW7FiBRcuXLCYMuzVV18lLy/P3Avov//9LxEREfWaMqwh28bKykoSExPZs2cP+/bto7Cw0LzNAWjrANEOpi7orbRNOwFXVZUMIySWQ2IFnDdA5RXbPT096d27N3369CEyMrJF3PBMS0tj165d7Nq1i0uXLpnXq4oCHgGoPqGo3iHg6gNN9QZMSR5KdhJK9kVTwn3FE21vb2/69u1LbGwsYWFhDVpk8HraRiGEaOkk6a6D5pB0JyUlsXjxYtPTAkzdxG9yBs11/uE+UKbydREYAB8fHyZOnEj79u2tErO4fklJSXz22WecOHECANXdD2OnYdc3N66qolw4iOb8PgDc3d25++67GTBgQJP+8N8UPlgeO3bMohdQlapeQKqqsmrVKjZu3GjuBTRx4kSLp2GFhYUsWrSIffv2WfQCqk93ZHu1jZWVlZw4cYK9e/dy+PBhcnJyLLa30piS73YOpmRc3wSSsDJV5XSFKck+WWEaxnMlX19funbtSp8+fYiKimrSv2vXQ1VVzp8/z65duzh06JBFAg6g6l1MCXirMPBqfU3DZ+zGaDQl11kXULIvopRaDv3w9vama9euxMbG0q5dO7td86bQNgohRGMlSXcdNOWku6ioiK+//ppNmzZhNBpxUeAeV2int96H0FSDyopCyLr8IbF3796MGzeOVq1aWe0com5+f93RaDGGdkcN7QIaK30IzUlBc/pXlOJcwDSN1IQJE8zdlpsa+WBZd42hbVRVleTkZI4cOcLRo0c5mZhIpfG3jFWHKfFud/lJeCtN45iKTFVV0itNSXZiBVz43dNsnU5H+/bt6dy5M126dCEgIKBRxN3YpKenc+TIEY4cOcKJEycoL/+tG7aq0YJXa9RWYaYk/HpuNlqLoQwlOwmyzpueal/RbVyj1dIuKoquXbvSuXNnWrdu3SiuubSNQghRf5J010Fj+GBZV+Xl5WzevJnvv//e3A2zkwOMdAVPG0y/U6qqbCiG3WWmCrp6BweGDhvGiBEjpMt5AzIajWzZsoUvv/zSfN3VVm0wRvYDJ3dbnBAl5RjK+f0olabfkf79+zN27Fi7F+aqK/lgWXeNsW0sKSkhISGBo0ePcuTIEbKzsy22t9JAT0fTl7sdpiLLrVTZWwYHyqs/zfb39zcn2TExMTg6/sGUEsJCeXk5iYmJHDp0iIMHD1a79qpnIMbgjuAbDkoDPjVWVchJRpNyDHKSUK74+OXu7k7Xrl3p1q0bHTt2xNnZueHiukbSNgohRP1ZJelOT0/nwoUL9O7du8bte/fuJSwsDH9//+s9lV01xg+WtamoqOCXX37hhx9+IC8vDwA/DYxyhSgH23/ATDWofF8M5y5P3evo6MjQoUMZPny4JN82dvLkST777DMuXLgAgOribUq2vVvb/uTlxShn96C5dBIwVe6+7bbbGDp0KDpdI+7eeQX5YFl3jb1tVFWVlJQU81PwxMREKitNz5M1QAcH6O0EkbrrH2pzNZWqSmIF7CkzdR2v+uPr4OBA+/bt6dKlC507d24WhdAaC1VVSUpK4uDBgxw6dIizZ8/+tk3vihrcATWovW2nIausQLl0EiX5GEpJnnl1cHAw3bt3p1u3bkRERDT6oQLSNgohRP1ZJel+/fXXKSkp4aWXXqpx++zZs3F1deUvf/nL9Z7Krhr7B0swzb28adMmfv75ZwoKCgDw0kCcM/TQN+zUOqqqcrwCfi6B1Mv9JR0dHRk4cCDDhg2TP95Wdv78eX744Qf27t0LgKrTo7bphRrcoWGf5gDkp6M5vcM0xy6mKrsjR46kX79+jT75lg+WddcU2sYrlZSUsG/fPrZs2cLp06fN6/00MNAZuulBZ8W2slxV2V8G20sh54qn2u3bt2fw4MF0797dYtYNYTvZ2dls2bKFzZs3m/9GqhotanBH1JCuoLfiE2ZDOcr/t3fncVHd9/7HX2cYdgVcUQEFBBdE3Fdw343GJDWmJm2T2Hi9iWnSX9OmTdJmeXjNrenDG222m/a2vbFN43ZtoiaaxLiL+wa4ExQFFUQERHbm/P6YOBF3YYZheT8fDx8P55zDfD/jke98P+e7nT2MkZGMUVEK2B9ExsfHM2LECNq2beu8smqB6kYRkepzStI9a9YsJk6cyJQpU256fuXKlXz++ed8+OGHNS3KrepywzIzM5NvvvmGxMRER4yBFvtCab28nduAvFemaXLku+T7/HfJt2EY9O7dmzFjxhAVFVUn5qvVR6ZpcuTIEdasWcPhw4cdx21tOmOG93VuA/Leg7P37pzchVFuX96+WbNmjBkzhqFDh9bJ4ZOghmV11OW68U4yMjLYtGkT27dvp7i4GIAAA+J9oJ9PzRZfKzFNtpfA9hIo+u6btkmTJiQkJDBkyBDHvu1S+8rLy9m9ezfr1q0jPT0dANNitfd8h/WoWc93Zbm9V/uaZLt169aMHj2awYMH19m6705UN4qIVJ9Tku7HHnuMxx9/3LEH7PW++uorPvroIz7++OOaFuVWda1hWVpayp49e9i8eTOpqamO4+087A3G2Fru2b4T0zRJrYDEEvvQyqvatm3LsGHDGDRokIae36XCwkK2b9/Opk2bOHfunP2gYWBrFWnvrWlShxavqyjDOHfE3ggtKwLsIx4GDhzIsGHD6NChg5sDrMqZDcvKykpKS0tvuZVaUVER3t7eeHh4OKU8d6lrdWN1FBUVsWnTJr7++mvHlJxAC4z3tdel9/Jg0PZdz/bXxXDlu2/Yli1bMm7cOOLj4zVHuw4xTZPk5GRWrlzpGHpuenhitu+JGdLt3hacNG0Y509gpO911HXBwcHcf//99O/fv84PH78TJd0iItXnlKT7+eefp2PHjjz33HM3Pb9w4UJSU1N55513alqUW9WFhuXVbVK2bdtWpWfGAnTxhEE+EG6tG6vy3k5WhUliKSSVwtV/UavVSp8+fUhISKBLly71voHibKZpkpqayubNm9m9e7fj/6JpsWK26YQZ2t01i6Q5i63S3vOdkVxlXmNERATDhg2jX79+1dquytmc2bD8n//5H44cOcL8+fNvev6FF14gNjaWJ5980inluUtdqBudpby8nO3bt7Nq1SrHAlztrfAD/7vb9/tchcmKK99PqQkODmbKlCn07du33j9caciuJt8rVqzgzJkz9mPeTbBFDYYW7e/8BgXZWI5vwSiyb1vXsmVLHnjgAQYMGNBgvsuUdIuIVJ9Tku6lS5fyf//3fzz++OOMHz/e8QVjs9lYu3YtH330EQ899BCPPPJIjQN2J3c2LC9fvsz27dvZtm0bGRkZjuPNLNDXjSvw1lSJzeRgGewp/b6RCtCiRQsGDx5MfHx8o/+Sz8/PJzExka1bt3L+/HnHcdO/OWbbrpitO4K1Hs0HNU37nrTnjmLJOQWmfZKrt7c3/fv3Z8iQIURGRrrtwZEzG5bPPvssQ4cOZdq0aTc9v2zZMrZs2cIf//hHp5TnLg0p6b6qtLSUL7/8kjVffEFZeTl+BvykKYRab/3/MrXc5JNCKDXB19eX+++/n5EjR9b5dQzkezabjR07drBixQrHvu+2qMGY7WJu/UMX0/E4sh5slfj5+TF58mRGjBiBp6dnLUVdO5R0i4hUn1OS7vLycn7/+9+TkpJCQEAA7dq1A+Ds2bMUFBQQExPDyy+/XO+/gGq7YVlRUUFSUhKJiYkkHTzo2HPWCnT1gj7eEOni1XZri2manK2EvaWQVAYl1/yv7Ny5M4MHD6ZPnz71di7cvSotLeXgwYPs2LGD5OQUbDb7EwnTYsVsFWlfbbdpK6jv976sGCPrOMb5YxjFBY7Dbdu2ZdCgQQwYMICWLVvWakjObFg+9thjPPnkk4wePfqm59etW8f//u//8o9//MMp5blLQ0y6r8rNzeXdd98lPT0dT+DJptD+JjtAHCsz+WehfY/tLl268O///u80bVqHR57IbZWWlrJ48WI2b94MgC2in32u93WMC2lYjmwATLp3785TTz3VYKdJKekWEak+p+3TbbPZ2LRpEzt37iQrKwuwD6sbOHAgQ4cObRDDq2qjYWmaJqdOnSIxMZFdu3Y59lgGCPGw92jHeYFvPezVvlvlpsnhMthXCmkV32+r4+XlRe/evYmPj2+Qw89tNhtHjx5l+/bt7Nu3j5KSEsc5s2lr+xDyVpH1q1f7bpkm5J/HOH8cIycNw/b9sIfo6GgGDhxI3759a6Ux68yG5axZs4iPj+cnP/nJTc9/9NFHbN26lT//+c9OKc9dGnLSDfbVzt9//30OHz5MMws8Gwje1zzwKrSZvJNvn7/dp08fZs6cWe8fMov9+3jlypWsXLkSDIPKHpMh4JqtT0suY9m7AqOy3PF73pBHNSjpFhGpPqcl3Y2BKxuWeXl57Nixg23btnH27FnH8aYG9PC2b/cVfJthjQ1VXqXJgTI4UAo512y106xZM8fw8/q+p21WVhbbtm0jMTHRMZwR7PMJzdYdMVtHgX8zN0ZYyyrKMHJOYWSnYuR9/7tgtVrp1asX8fHxxMTEuGx+rDMblh988AHbt2/njTfeICIiosq5tLQ0XnvtNQYNGsQzzzzjlPLcpaEn3WBPvF977TUuXrzIQG+Y5P99fby40CSlDEJDQ/ntb3+rhLuB+dOf/sTOnTsx/YKw9XnIsQWjJXktxqUMoqKi+PWvf93gHgRfT0m3iEj1Kem+B85uWFZUVHDgwAG2bdtGSkoKtmuGj8d42RPtjp4NY/h4TZmmSUYl7L/J8POoqCji4+Pp379/nViI624UFRWxe/duEhMTq6w8b1q97MPHW0dBQHD9Hz5eU6VXMLK/tSfgV3IdhwMDAxk0aBCDBg0iNDTUqUU6s2GZm5vLSy+9REFBAX369CEsLAyAM2fOsHfvXgICAnjzzTdp0aIOrTZfDY0h6QY4fPgw8+fPxwI8FwgtPQzOVJh8WGBfvPJ3v/tdnVuNX2qusLCQl19+mStXrlDZdSS0ioTLOXjs/xSLxcKcOXMaxfZvSrpFRKqvWkn3G2+8gWEYvPLKK3h4ePDGG2/cuSDD4NVXX61WkHWFsxqWubm5bN68mc2bNzu2pgH7Crm9vKC7F/g04OHjNVVumhwtg/1l9q3Hrv4H9vHxYfDgwYwYMcKxrkBdUlFRQUpKComJiRw8eJCKiorvzhiYzUKwtelkXyX3XraoaUwKL9rnf2d/69j3G6B9+/aO+d+BgYE1LsbZDctLly7x8ccfs2fPHsduA76+vvTr14/p06fTvHlzp5XlLo0l6QZYsGABycnJ9PKCHzQxWHTZ5Hg5xMfHM2PGDHeHJy7y6aefsmrVKsyA1th63o9xdCOW7FQGDhzIzJkz3R1erVDSLSJSfdVq3V+fp5umeceVhtWhDunp6axevZoDBw44erWbGPZ52r297b0mcmeehkF3b+juDQU2k4Ol9tXPL5aUsH79etavX0/nzp2ZOHEisbGx7g6XoqIiNmzYwLp16ygo+H6xMNOvGWZwlL1X29vfjRHWE01aYDYZhBnRH3LPYMk6gZF7htOnT3P69GmWLVtGnz59mDhxIu3b38UWP7WkWbNmPPvss5im6bj/AQEBdX5bP7m5++67j+TkZA6VwYhKkxPfPWuYOHGiewMTlxoxYgSrV6+Ggmy4nIORY9/Te9SoUW6OTERE6gMNL78H1e3NKSws5NNPP2Xjxo2Ohw/hVhjoA109wUON7xqzmSZpFbCrBI5c0/vdq1cvfvjDH9b6Cthg3+btyy+/ZOPGjY4eTtPT1z5POzga/Jtr+HhNlZdgXEjDyErFuJztOBwbG8ukSZOIjo6+57dUb869a0w93aZp8pvf/IacnBxiPOFwuX2v+d/+9rfuDk1c7O233yYlJQUzIBijIIvWrVvz5ptvNpoHaKobRUSqT+NYXWzv3r0sWrTIsQp5dy8Y7tM4F0VzJYthEOUJUZ72xde2lcDOUti/fz8pKSk89NBDjBkzplYaR6ZpsnPnTj755BPHfTf9mmGGxWG26ggNfLGdWuXpg9kuxr6HbuFFjDNJWC6kkZKSQkpKCkOGDGHatGn4+fnVSjjLly8H4KGHHsJisThe38nUqVNdGZY4kWEYdOrUiZycHA5/95yhc+fO7g1KakV0dDQpKSkYBVmO140l4RYRkZqpVtKdk5NTrcLc0dvoLpWVlSxfvpyvvvoKgNYeMMkPIm+yv6s4V5CHwX3+0NfbZFURnCovZ8mSJaSmpvLkk0+6dK/viooKPvzwQ/bt2weA6d8MW3hfaN5evdqu1qQFZtcRVIb3wThzAMv542zZsoXk5GSee+65WlngatmyZQA88MADWCwWx+s7UdJdv1xdEO9Wr6Vhun7RRmcv4igiIg1XtZLu2bNnV6uwJUuWVOvn6qPFixezfv16ABJ8YIyvhpHXtmCrwU+bmuwshTVF9lEHhYWFvPjiiy4rc+/evfaE27Bga98LM6yHerZrm28AZqehVLaOxnJiC3l5eSxfvpwXXnjB5UVfX8c1pjqvMWndunWV1xpy2zhcf9/r+3aVIiJSe6qVdD/99NPOjqPBOXToEACT/WCAj5JtdzEMg4E+EOxh8pfLcOzYMSorK122x/PevXsBsIXGYXbo5ZIy5C4FtcUWOx6P3Us5cuQIhYWFNGnSxN1RSQNw/RZv9X3LN7k714/Wa0yj90REpGaqlXQPHz7cyWE0PFcXFWrpmtxO7tG196GsrMxlQ8zLysrsf/GunTnEcgdefpgYYJrXbNEmUjNBQUFVXgcEBLgnEKlVXl5eeHl5Oer5Zs2auTkiERGpL1yykNrVLyQvLy9XvH29EB0dzc6dO9lcDGFWEy8NLXebStNkg33xcMLCwvDx8XFZWe3btyc5ORkjfR+mpy+0inBZWXIHJZexHN+CgUlAQIBT9vC+k9mzZ9/zwkqGYfDOO++4KCJxBX//qlv8WTSFpNG49vfbleuDiIhIw+K0pDsnJ4elS5eyf//+KnvR9urVi4cffthlc96WLl16wwrB7dq1Y8GCBYD9AcCiRYtITEykvLycHj168NRTT93QU+FsU6ZMYffu3XxbYWN+Hgz2MRngDT4WJd+1pcI02V8KW0og174tOg899JBLV5sdNWoUBw4cIDMzE48j32Bmd8DWoTc00fDTWlNRhnH2CMaZAxiV5Xh6ejF9+vRaWWU4JiZGqxk3AkqyBdDvuoiI3DWnJN2ZmZm8+uqrXLlyhbi4OEJCQgA4e/YsmzdvZu/evcyZM4d27do5o7gbhIWF8bvf/c7x+toG0UcffcS+ffv4xS9+gZ+fH3/5y1+YP38+c+bMcUksVwUHBzNr1iyWLVtGTk4OXxfD5hLo7WXSyxvaeugL21UuVpocKIU9pXD5uw27mzRpwqRJk+jevbtLyw4MDOR3v/sdq1ev5osvvsB2MR2Pi+mYzcOwhfWAgGCtYu4qZcUYmSn2hLvSPtomKiqKGTNm1NqCR9VdZNIV6uoDSREREZHGxilJ98cff4xhGLz11lu0b9++yrnTp08zZ84cPv74Y371q185o7gbWCyWmzYUi4qKWL9+Pc8//zyxsbEAPPPMM/y///f/OH78OJ06dXJJPFf17duXXr16sXv3bj7//HPOnj3L9lLYXgrBHtDTy6SHNwSo97vGim0mKWWwvwxOXzN1t1mzZowbN46hQ4fi7e1dK7F4enry4IMP0q9fP1avXs2ePXsg9wweuWcwfQMxW0VgtowA/+ZKwGuqvAQjJx0j5yRGXiaY9qcsbdu2ZeLEiQwcOLBR90rWxQeSIiIiIo2NU5LuI0eOMGnSpBsSbrDPcR03bhyff/65M4q6qfPnzzNr1iw8PT3p1KkTjz76KC1btiQtLY3KysoqvZshISG0bNnytkl3eXm5YyE0sPdIX527da+901arlUGDBjFgwABSUlLYtm0b+/fvJ6uigi+L4atiCPEwifKEKE8Is2prsbthM03OV0Jquf1PegVUfnfOMAxiYmIYPHgw/fr1w2p1ydIFdxQWFsbTTz9NVlYWa9asITExkYrifIzTB+D0AUzfAMyWEZjNQiGgNVi06t4dmSaUFGBcOouRcwoj7yxgOk5HRERw33330bNnzzqTbNtsNjZv3sy+ffvIyckB7Kse9+nThyFDhrg0zrr6QFJERESkMXFKNlJRUXHbRdO8vb1dtnJwdHQ0zzzzDO3atePSpUssX76cV199lfnz55OXl4fVar1h0ZvAwEDy8vJu+Z7/+te/qgzLjIiIYN68eTWelx4SEsK4ceMoLCxky5YtrF+/npSUFDIqIaMSNpaANxDpaU/CO3pCC4uGoV9VYDP5tvz7RPuKWfV8eHg4o0aNYsSIEXVqC5+2bdvSs2dPrly5wq5du9i6dSt79uyhrLgA48xBOHMQ02KFwGDMoHaYQSHQpDkYdSNpdLvSK/bkOu8sRt45jNLCKqcjIyMZMmQICQkJhIaGuinImysqKmLu3Lmkpqbi6+vrGOaenJzMzp07+eqrr3jllVfw83PNavd1+YFkQ9KYP3tjpvsuIiJ3yylJd0REBOvXr2fUqFE3NB6v9qhERkY6o6gb9Or1/V7IHTp0cCTh27dvr/bq6Q8++CCTJk1yvL76xXrhwgWnPTzo2bMnPXv25NKlSxw6dIiUlBQOHz5MYWEhR8rhyHft2gADIjxNIqwQ4QnNG1ESXmAzOVkOJyvgZDlctFU97+3tTdeuXenWrRsxMTG0adMGwzAoKyvj3Llz7gn6Drp06UKXLl340Y9+RFJSEvv37+fIkSP2xQcvZWJcygR2Y1q9IbANZmAwZkAbaNIS6kjPrUuZJpQWYuSfh4IsjPzzGEV5VS6xWq107NiR2NhY+vbtW2W+tjPuu9VqddrCj5988glpaWnMmDGDUaNGOUZdVFRUsH79ev72t7+xePFiZsyY4ZTyrlWfHkjWd23btnV3CFJLrh2ZovsuIiJ3yylJ97Rp05g7dy4///nPGT58uGPBtLNnz7Jp0yYuX77MT3/6U2cUdUf+/v60a9eO8+fPExcXR0VFBVeuXKnSuMzPz7/tYkGenp54enre9Jxpmjc9Xl1BQUHEx8cTHx+PzWbj9OnTHDp0iEOHDvHtt99SUFHBwTI4+N32zwEWiLCaRHhCRys082g4CXjhd0n2txVwqhxyrkuyDcOgQ4cOdOvWjW7dutGxY8cbho47+/64ire3N/369aNfv36YpklmZiZHjhzhyJEjHDt2jJKSEriYjnExHQDT4gFNW2MGtsEMbGMfju5x8/+j9YppQtEle5Kd/12SXXalyiWGYdC+fXu6du1K165diY6OrjI/vy7f8127djF27FjGjRtX5bjVamXs2LFkZGSwc+dOlyTd9fWBZH1UVx/yifPZbN9/MTW2++7MB5IiIo2NU5Lu2NhYXnrpJf7xj3/w2WefVTkXHh7Os88+65g36GolJSWcP3+eIUOGEBkZiYeHB8nJyQwcOBCwPwjIycmpk3MWLRYL4eHhhIeHc99991FWVsa3337LsWPHOHr0KGlpaRRUVlZJwptZTCI9IdIKkZ7QtB4tylZsMzlVAWnlkFYBWZVVz19Ntjp37kyXLl2Ijo522TBcdzIMg9DQUEJDQxkzZgyVlZWcOnWKEydOcPz4cU6cOEFRURHkn8PItzfyTMOApq0wA9tiBrWFgDbg4Z656/fkapKd991nyTuHUVFa5RKLxeJIEqOjo+nUqRNNmjRxU8A1U1hYeNtdG0JCQigsLLzleWeqbw8k65PG/NkbM913ERG5W05rpcfFxfHWW2+Rl5fHhQsXAGjVqpXLt59ZtGgRffv2pWXLlly6dImlS5disVhISEjAz8+PkSNHsmjRIpo0aYKfnx9//etf6dSpU51Muq/n5eXl6N0DKC0t5dtvv+Xo0aMcO3aMtLQ0Ltls7C2Fvd/lLa09TKKs0MkLwq1grUND0W2mSWYlHCuDE+VwtvLaJbDswsLCHEOwO3Xq1CCT7Dvx8PCgY8eOdOzYkfHjx2Oz2Th37hwnTpxwJOK5ublQkI1RkG2fE25Y7El4UFvMZmEQ0KruzAkvKcTIPWOfl51/DqO8pMppLy8vOnbs6EiyO3bsWGsrzbtamzZt2LNnzw093Vft2bOn1rYzq88PJEVERETqM6ck3cuXL6d///60b9+eoKCgGxLtM2fOsHPnTqZOneqM4qrIzc1l4cKFXL58mYCAALp06cLcuXMJCAgA4PHHH8cwDObPn09FRYVjL9r6yNvbm5iYGGJiYgAoLi7mxIkTjmHJZ86cIbsSsishsRS8gI6eJp08IdoTgtwwFL3IZnKiHI6X2xPtouuy7ODgYLp27epItJs2bVrrMdZ1FouFkJAQQkJCGD58OKZpkpOTw7FjxxyjIOxJeBZGQZZ9ZXSrN2bzMGgeZl8d3bMWk1jTBgUXMHJP25PtK7lVTnt5eREVFUWXLl3o3Lkz4eHhblth3tXGjh3LX//6V/7zP/+TiRMnOuaAnj17ljVr1pCUlOSyqTcN+YGkiIiISH3ilJbusmXLaNOmzU23DAN70r1s2TKXJN0///nPb3vey8uLp556qt4m2rfj6+tLXFwccXFxAFy+fJmjR4+SkpJCcnIy+fn5VRZla+th0t0LYr2guQsT8EKbyaEySC6zb+V1bZ7t6+tLbGwssbGxxMTE0Lx5c5fF0VAZhkGrVq1o1aoVCQkJjiT86NGjjvUAioqKMLJTITsVMOw94K06YrYKB6sLEnDThPzzGNmp9q28rhkybhiGY+Gzrl27Nugk+3rjxo0jPz+fzz77jAMHDlQ5Z7VamTp1KmPHjnVJ2Y3pgaRIbWksC5mKiIhz1UrLt7CwsNE0st2padOmjsW5bDYbZ86cISkpieTkZNLS0jhXaXLumr3Bu3tBd28IdMI88OJrEu206xLt0NBQ4uLi6N69O5GRkfq/4GTXJuFDhgyhsrKS1NRUkpKSSEpK4uzZsxh59j9m6jZoHoatdRS0aF/zvcELL9oT7ey0Kgug+fn50b17d+Li4oiNja23c7KdYdq0aYwfP57k5OQqU2+6d+/uSIBdoTE/kBQRERGpS6qd/Rw+fJjDhw87Xu/cuZPz58/fcN2VK1dITEy8ZS+4uMbVxag6dOjA5MmTuXz5Mvv27WPXrl0cO3aMzEqTzO8S8J5eJsN8oUU1er8LbSbbSmBnCZRdczw8PJx+/fo5hrdK7fHw8KBz58507tyZhx9+mAsXLrB792527NhBZmYmXEzH42I6pncTzLA4zDadwHKPVUH+eSynD2BcynAc8vPzo0+fPgwYMIBOnTrh4VHDhL4BOHz4MKGhoQQEBBAfH3/D+YKCAjIyMhxTRkSkbtPiaSIiUh3VTroPHTpUZb/WXbt2sWvXrpteGxoa6pItceTuNW3alGHDhjFs2DDy8/PZu3cvu3bt4sSJE+wrg/1lEOdlMsr37oaeF9lMNhbD7lL4bvQ6ISEhDBw4kH79+mlbkTqkVatWTJw4kYkTJ5KRkcGOHTtITEwkPz8fIzUR8/QBzPa9MNt2gTsNnbySiyV1u2MVdYvFQq9evRg4cCDdu3e/5crWjdUbb7zBz372MxISEm56PiUlhYULF7JkyZJajkxEREREaku1k+4pU6Ywfvx4TNNk5syZzJw5kwEDBlS5xjAMvLy8qr0nrLhGYGAgI0eOZOTIkXz77besXr2apKQkDpbZ53/f72fS0/vWyVdaucnyQij47oF/REQEkydPJi4uTvPd6rjQ0FCmTp3KlClT2LJlC2vWrCE3NxcjdRu2gizM6IRbbz124SQexzaBrQIPDw/i4+OZOHGiHrDUQHl5ORZLHVllXkRERERcotpJ97XJ9LvvvktAQECD2eanMenYsSPPP/886enpfPLJJ5w4cYLlV+DbcpMH/MHjuiR6Y7HJN8X2Odtt2rRh+vTpdOvWTcl2PePp6cnIkSMZOnQo33zzjX3USnYqZnEBtrgJ4FG1x9rITMHy7Q4AYmJieOKJJ2jRooU7Qq/zcnJyyM7OdrzOzMysMhXnqqKiItatW6eHFiL1iL7rRESkOpyyotXNGo2lpaVs27aNiooKevXqpYZlHdehQwdefPFFVq1axapVq9hfZuJtwCT/76/ZWWKyrtj+94SEBB599FE9aKnnrFYr48aNo3379nzwwQdcuZyN5ehGbDGjvx9qnnPKkXCPGTOGhx9+WPO1b2PDhg1Vpt6sWLGCFStW3PRai8XCzJkzays0EakhzekWEZHqcErS/cEHH5Camsr8+fMBqKio4JVXXuHMmTOAfYGlV199lYiICGcUJy5isViYMmUKISEhfPDBB+wohbZWkz7eBqfKTT4vsl/3wAMPMHnyZPcGK07VtWtXnnvuOf7whz9QcTEdIzMZMzQOSgqxHN0IwIgRI3jkkUfU03MHgwYNIiwsDIC3336bCRMm0KVLlyrXGIaBt7c34eHhBAUFuSFKEREREaktTkm6Dx06xJAhQxyvt27dypkzZ/jZz35GeHg48+fPZ9myZbz44ovOKE5crG/fvjzwwAN8+umnrCuyL7D2VTHYgAEDBjBp0iR3hyguEBUVxaOPPsqiRYswTu3DbNURS9oODFsFUVFRTJ8+XQn3XQgNDSU0NBSAp59+mpiYGFq3bu3mqERERETEXZyygk9eXl6V4eO7du0iMjKShIQEQkNDGTVqFKmpqc4oSmrJhAkTaN68OZdNWHUFTlfYhyI//PDDSrwasCFDhhAVFYVhq8D4dgdGzikMw+DHP/6xhpRXw/Dhw2+acGdlZZGRkXGTnxARERGRhsYpSbe3tzdFRfaxx5WVlRw+fJgePXo4zvv4+DjOS/1gtVoZNmwYAPu+24C7T58+NGvWzI1RiatZLBZGjRpl/3vOScC+cNrVnlu5N2vWrGHBggVVjr3//vs899xzvPDCC/zmN78hPz/fPcGJyD3TQ2cREakOpyTdkZGRfPPNN5w8eZIVK1ZQXFxM3759HeezsrIIDAx0RlFSi2JiYm77Whqm67d+i4uLc2M09ds333xTpe47cOAAmzZtYvTo0cyYMYOsrCyWLVvmxghFRERExNWcMqf7hz/8IXPnzuU3v/kNYJ/3GxUV5Ti/a9cuOnfu7IyipBaFhYVhGIZjtdYOHTq4OSKpDT4+PrRs2ZILFy4AqJe7Bi5cuEBISIjj9fbt22ndurVjxfK8vDw2b97srvBEREREpBY4Jenu2LEjCxYs4NixY/j7+1fpEb1y5Qrjxo1TL2k95Onpia+vr2NqgLZ9azyaN2/uSLqbN2/u5mgajqSkpCqjgFq1akVeXp77AhIRERERl3NK0g0QEBBAv379bjju7+/PxIkTnVWM1LJrhxn7+Pi4MRKpTdfuv960aVM3RlK/tW3blt27dzN27FgOHDhAbm4uvXr1cpzPzc3F39/fjRGKiIiIiKs5Lem+qri4mKKiIseQ5Gu1bNnS2cWJi2nRGNHDluqbPHkyf/zjH3nyyScpKSkhNDS0yiKTKSkphIeHuy9AEREREXE5pyXdX331FatXryYrK+uW1yxZssRZxYmIC137sEUPXqovPj6epk2bsm/fPvz9/Rk3bpxj67XCwkKaNGnC0KFD3RyliIiIiLiSU5Lur776ir/85S/06NGDESNGsHjxYu677z48PT3ZuHEjQUFBTJgwwRlFiYjUK3FxcTddAb5Jkyb88pe/dENEIlJdeggpIiLV4ZQtw9auXUuPHj14+eWXGT16NAC9e/dm+vTpvP322xQXF3P58mVnFCUiUm+8+eabbN26lbKyMneHIiJOcLOpcyIiInfilKQ7KyuLPn36ADiGTlZUVADg5+fHyJEj+eqrr5xRlIhIvZGVlcU777zDzJkzeffdd0lKSlKjXURERKSRccrwcj8/PyorKx1/9/LyIicnx3He19dX2+KISKOzcOFCUlNT2bJlC9u3b2fLli0EBQWRkJDAkCFDtIiaiIiISCPglKQ7LCyM9PR0x+tOnTrx9ddf07t3b2w2G+vWraNt27bOKEpEpF6JiooiKiqKxx9/nKSkJLZs2cK6detYvXo1oaGhDB06lISEBFq0aOHuUEVERETEBZySdA8ZMoSvv/6a8vJyPD09efjhh5kzZw5PP/20vRCrlRdeeMEZRYmI1EsWi4WePXvSs2dPrly5wp/+9Cd27NjBP//5Tz755BO6devGfffdR+/evd0dqoiIiIg4kVOS7hEjRjBixAjH6y5duvBf//Vf7N27F4vFQlxcHO3atXNGUdW2du1aVq1aRV5eHh06dGDGjBlERUW5NSYRaVyOHj3K5s2b2blzJ4WFhYSFhTF06FCsVisbNmxg3rx5PPTQQzzyyCO1FpPqRpG7pzUZRESkOpy2T/f1goODmThxoqve/p4kJiayaNEiZs6cSXR0NJ9//jlz585lwYIFBAYGujs8EWnAMjIy2Lx5M9u2bSMnJ4fAwECGDRvG0KFDq8zpnjhxIh9++CFffvllrSXdqhtFREREXM9lSXddsnr1akaNGuXojZ85cyb79u1jw4YNPPDAA+4NTkQarF/96lecPn0aT09P+vbty1NPPUWPHj2wWG6+cUS3bt1Yv359rcWnulFERETE9aqVdD/yyCMYhsE//vEPrFbrXfXKGIbB4sWLq1NcjVRUVJCWllalAWmxWOjevTvHjx+/6c+Ul5dTXl7ueG0YBr6+vo6/N1aN+bM3Zrrv1efv78+sWbMYOHAgfn5+d7y+X79+vPvuu7UQmepGZ2rMn70x030XEZG7Va2k+wc/+AGGYTh6a66+rosKCgqw2WwEBQVVOR4UFMTZs2dv+jP/+te/WL58ueN1REQE8+bNo1WrVq4MtU4aPnw4q1evpnv37lqBvhGJj4/n4MGDRERE6L7XwOuvv35P13t7e9daPaO6sWZ69OjBwYMHGTZsmH5HGpGxY8eyatUq+vbtq/suIiJ3rVpJ97Rp0277ur578MEHmTRpkuP11QcKFy5coKKiwl1hucXYsWPx9fWlX79+nDt3zt3hSC3p0aMH06dPJzY2ttHdd6vV6rIkMjMzk+3bt5OXl0e7du0YPnz4XfWA1xWqG7/32GOPERUVRUJCQqP7HWnMrn4n9u/fv9Hdd1fWjSIiDV2Dn9MdEBCAxWIhLy+vyvG8vLwbeniu8vT0xNPT86bnGtvKpf7+/owfPx5ofJ+9MbNarYwePRrQfb9Xa9euZc2aNcyZM4eAgADH8T179vD2229XSU7XrFnD3Llzq1xXW1Q31kyLFi0ci4U2ts/emPn5+TFu3DhA911ERO5ejZPu8vJytmzZwsGDB8nKyqK4uBhfX1/atGlDz549SUhIwGp1X25vtVqJjIwkJSWF/v37A2Cz2UhJSXEkkyIizrJnzx6Cg4OrJNKVlZV8+OGHWCwWnn76aTp27Mi+fftYvHgxK1as4Iknnqj1OFU3ioiIiNSOGmXDp0+f5q233uLChQuA/Qmwj48PBQUFnDx5ku3bt7NixQpefPFFQkNDnRJwdUyaNIn33nuPyMhIoqKi+OKLLygtLWX48OFui0lEGqaMjAxGjRpV5dihQ4coKCjgwQcfdNQ7YWFhpKens3//frck3aC6UURERKQ2VDvpLikpYd68eRQUFDB9+nSGDh1K8+bNHedzc3PZtGkTK1asYN68efzhD3/Ax8fHKUHfq8GDB1NQUMDSpUvJy8sjPDycl19++ZZDKEVEquvy5cu0aNGiyrHk5GQAR4/yVZ07d2bnzp21Ftv1VDeKiIiIuF61k+4NGzaQk5PDq6++Srdu3W4437x5cx588EGio6OZM2cOGzdudOuQxfHjx2vIpIi4XFBQ0A3zpI8ePYq3tzcdOnSoctxqtbp1+g2obhQRERFxNUt1f3Dfvn306NHjpgn3tWJjY4mLi2Pv3r3VLUpEpN6IjIxk06ZNFBcXA3DmzBlSU1Pp0aMHHh4eVa7NzMy8oVdcRERERBqWanexnD59mgkTJtzVtbGxsXzxxRfVLarOcHePlIi4Xk1/zx9++GFeeuklnnvuOcLCwkhLSwPs221db/fu3Xd8cFkfqG4Uafj0ey4iUn3VrkELCwvvet5fYGAghYWF1S2qzmjWrJm7QxCROq59+/a8+uqrrFixguzsbKKjo5k8eTKRkZFVrjt06BBeXl4MGjTITZE6j+pGERERkVur9vDyioqKu37q6eHhUWVvWqk/iouL+fWvf+0YKiuNg+57zXTu3JmXXnqJt99+m1deeYW4uLgbrunWrRvz58+nR48ebohQakq/I42T7ruIiFRHjcYKZWdnO4ZO3uk6qZ9M0+TkyZOYpunuUKQW6b6L3J5+Rxon3XcREamOGiXdS5YsYcmSJc6KRURERERERKRBqXbS/fTTTzszDhEREREREZEGp9pJ9/Dhw50YhtRVnp6eTJ06FU9PT3eHIrVI913k9vQ70jjpvouISHUYpiYmiYiIiIiIiLhEtVcvFxEREREREZHbU9ItIiIiIiIi4iJKukVERERERERcREm3iIiIiIiIiIvUaJ9uafjWrl3LqlWryMvLo0OHDsyYMYOoqCh3hyUucvjwYVauXMnJkye5dOkSv/zlL+nfv7+7wxKpU1QvNj6qG0VEpCbU0y23lJiYyKJFi5g6dSrz5s2jQ4cOzJ07l/z8fHeHJi5SWlpKeHg4P/3pT90dikidpHqxcVLdKCIiNaGkW25p9erVjBo1ihEjRhAaGsrMmTPx8vJiw4YN7g5NXKRXr1788Ic/VA+OyC2oXmycVDeKiEhNKOmWm6qoqCAtLY3u3bs7jlksFrp3787x48fdGJmIiHuoXhQREZHqUNItN1VQUIDNZiMoKKjK8aCgIPLy8twSk4iIO6leFBERkepQ0i0iIiIiIiLiIkq65aYCAgKwWCw39N7k5eXd0MsjItIYqF4UERGR6lDSLTdltVqJjIwkJSXFccxms5GSkkKnTp3cGJmIiHuoXhQREZHq0D7dckuTJk3ivffeIzIykqioKL744gtKS0sZPny4u0MTFykpKeH8+fOO19nZ2Zw6dYomTZrQsmVLN0YmUjeoXmycVDeKiEhNGKZpmu4OQuqutWvXsnLlSvLy8ggPD+fJJ58kOjra3WGJixw6dIg33njjhuPDhg1j9uzZbohIpO5Rvdj4qG4UEZGaUNItIiIiIiIi4iKa0y0iIiIiIiLiIkq6RURERERERFxESbeIiIiIiIiIiyjpFhEREREREXERJd0iIiIiIiIiLqKkW0RERERERMRFlHSLiIiIiIiIuIiSbhEREREREREXUdItchNLly5l2rRpVY7Nnj2b9957z00RiYi4n+pGERGRe6ekWxqc3Nxcli5dyqlTp1xaTkZGBkuXLiU7O9ul5dTEsWPHWLp0KVeuXHF3KCLiZqobv6e6UUREapOSbmlwLl26xPLly53esFywYAGzZs1yvM7IyGD58uVcuHDBqeU407Fjx1i+fLkaliKiuvEaqhtFRKQ2Wd0dgIizVFZWYpqmy97f09PTZe8tIuIqqhtFRETcyzBd+U0sjc7SpUtZvnw5CxYsYPny5ezduxer1cqYMWN45JFHuHjxIn/96185dOgQXl5e3H///UyePLnKe+Tn5/PPf/6Tffv2UVRURLt27bjvvvsYPny445rs7GyeffZZfvSjH+Hh4cHatWvJzs7mJz/5CR999NENcT3zzDMMHz6cI0eOsGbNGk6cOEF+fj6BgYEMGDCARx99FC8vrxs+x9KlSx3HZs+eTUxMDLNnz2bjxo28//77N5Tz2muvsWHDBvbv38+HH36I1Vr1udZ//Md/cOHCBRYuXHjbf8cTJ06wfPlyjh8/TkVFBcHBwYwcOZKJEycCkJ6ezurVqzly5AiXLl3Cz8+PXr168eMf/5imTZtW+QzXe/fdd2nduvVtyxcR51LdqLpRREQaL/V0i0ssWLCAkJAQHnvsMfbt28eKFSto0qQJ69atIzY2lscee4wtW7bw97//nY4dOxITEwNAWVkZr7/+OufPn2f8+PG0bt2aHTt28P7771NUVORoWF21ceNGysvLGTVqFJ6envTv35/i4mKWLl3K6NGj6dKlCwCdO3cGYPv27ZSWljJ27FiaNm1Kamoqa9euJTc3l1/84hd3/fm6du3KhAkTWLNmDQ8++CAhISEAhISEMHToUDZv3szBgwfp06eP42fy8vJISUlh6tSpt33vpKQkfv/739OsWTMmTJhAUFAQmZmZ7N271/H5k5KSyM7OZvjw4QQFBZGRkcG6devIyMhg7ty5GIbBgAEDOHfuHNu2bePxxx93NDgDAgLu+nOKiHOpblTdKCIijY+SbnGJqKgo/u3f/g2A0aNHM3v2bP7+978zffp0HnjgAQDi4+OZNWsWGzZscDQs161bR2ZmJj/72c8YMmQIAGPGjOH1119n8eLFjBgxAl9fX0c5Fy9e5J133qnSWOrVqxdLly6lU6dODB06tEpcP/rRj6r02owePZo2bdrwySefkJOTQ8uWLe/q8wUHB9O1a1fWrFlDXFwc3bp1c5wLCAigRYsWbNmypUrDcuvWrZimeUNM17LZbPzpT3+iWbNmvPXWW/j7+zvOXTsoZdy4cTf0gkVHR7Nw4UKOHj1K165d6dChAxEREWzbto1+/fqpB0ekDlDdqLpRREQaHy2kJi4xcuRIx98tFguRkZGYplnluL+/P+3atauywu3+/fsJCgoiPj7eccxqtTJhwgRKSko4fPhwlXIGDBhwT70T1zYqS0pKKCgooFOnTpimycmTJ+/pM96KxWIhISGBPXv2UFxc7Di+detWOnXqdNsG3smTJ8nOzmbixIlVGpUAhmHc9HOUlZVRUFBAdHS04z1EpG5S3ai6UUREGh/1dItLXN8r4ufnh6en5w2NQD8/Py5fvux4feHCBdq2bYvFUvV50NUhitevhnuvPRQ5OTksWbKEPXv23LBqbVFR0T291+0MGzaMzz77jF27djFs2DDOnj1LWloaM2fOvO3PZWVlARAWFnbb6woLC1m2bBmJiYnk5+dXOefMzyEizqW6UXWjiIg0Pkq6xSWubxje6lhNXdurcSc2m405c+ZQWFjIlClTCAkJwdvbm9zcXN5//32nru4bGhpKZGQkW7ZsYdiwYWzevBmr1cqgQYOc8v5vv/02x44d4/777yc8PBwfHx9sNhtvvvkmNpvNKWWIiPOpblTdKCIijY+SbqlTWrVqRXp6OjabrUpD9OzZs47zd3LtUMNrnT59mnPnzjF79myGDRvmOJ6UlFTDqG9u6NChLFq0iEuXLrFt2zZ69+5NkyZNbvszwcHBAJw5c4a4uLibXlNYWEhycjLTpk2rsvDQuXPnbrj2Vv8WIlK/qG5U3SgiIvWX5nRLndKrVy/y8vJITEx0HKusrGTNmjX4+Pg4FhW6HW9vb4Abhkhebahe22tjmiZffPFFtWL18fG5aTlXJSQkYBgGf/vb38jKynIsfnQ7ERERtG7dmi+++OKG970a980+B8Dnn39+w/td/bfQsEqR+k11o+pGERGpv9TTLXXK6NGj+frrr3n//fdJS0tzbItz7NgxnnjiiSqr895KcHAw/v7+fP311/j6+uLt7U10dDTt2rUjODiYv//97+Tm5uLn58fOnTspLCysVqzh4eFYLBY+++wzioqK8PT0JDY2lsDAQMC+Um+PHj3YsWMH/v7+9O7d+47vabFYeOqpp5g3bx4vvvgiw4cPp1mzZmRmZpKRkcErr7yCn58fXbt2ZeXKlVRWVtK8eXMOHjxYZdGlqyIjIwH45JNPiI+Px8PDgz59+jgaxSJSP6huVN0oIiL1l3q6pU7x8vLi9ddfJyEhgU2bNrFo0SIKCwt55plnbtiH9lasViuzZ8/GYrHw5z//mYULF3L48GGsViu//vWvCQ8P59NPP2XZsmW0adOGZ599tlqxBgUFMXPmTAoKCvjv//5vFi5cSEZGRpVrrg7VHDRoEJ6ennf1vj179uS1116jbdu2rF69mo8++oiUlJQqW+w8//zz9OjRgy+//JJ//vOfeHh48PLLL9/wXlFRUTzyyCOkp6fz3nvvsXDhQgoKCqr1eUXEfVQ3qm4UEZH6yzCduUKKiFSxe/du/vCHP/DGG2/QtWtXd4cjIlInqG4UEZHGRD3dIi70zTffEBwcTJcuXdwdiohInaG6UUREGhPN6RZxgW3btpGens6+fft44okntFKuiAiqG0VEpHFS0i3iAgsXLsTHx4eRI0cybtw4d4cjIlInqG4UEZHGSHO6RURERERERFxEc7pFREREREREXERJt4iIiIiIiIiLKOkWERERERERcREl3SIiIiIiIiIuoqRbRERERERExEWUdIuIiIiIiIi4iJJuERERERERERdR0i0iIiIiIiLiIv8fv2T/lX6PnVgAAAAASUVORK5CYII=", "text/plain": [ - " time visit_occurrence_id\n", - "entry \n", - "0 18000 2000079\n", - "1 18000 2000570\n", - "2 18000 2000589\n", - "3 18000 2000598\n", - "4 18000 2000604\n", - "... ... ...\n", - "37697389 165068 2004089\n", - "37697390 172268 2004089\n", - "37697391 179468 2004089\n", - "37697392 186668 2004089\n", - "37697393 195848 2004089\n", - "\n", - "[37697394 rows x 2 columns]" + "
" ] }, - "execution_count": 108, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "ak.to_dataframe(ak_measurement)" + "fig = plt.figure(figsize=(10, 10))\n", + "for i, variable in enumerate(measurement_features, start=1):\n", + " ax = plt.subplot(4, 3, i)\n", + " omop.violin(adata, ax=ax, show=False, obsm_key=variable, keys=variable, groupby=\"mortality_cat\", stripplot=False,)\n", + "fig.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 22, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
[{value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000079, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000570, ...},\n",
-       " {value_as_number: 145, time: 1.8e+04, visit_occurrence_id: 2000589, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000598, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000604, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000610, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000706, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2000848, ...},\n",
-       " {value_as_number: 170, time: 1.8e+04, visit_occurrence_id: 2000983, ...},\n",
-       " {value_as_number: None, time: 1.8e+04, visit_occurrence_id: 2001014, ...},\n",
-       " ...,\n",
-       " {value_as_number: 5, time: 1.29e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.36e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.51e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.58e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.65e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.72e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.79e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.87e+05, visit_occurrence_id: 2004089, ...},\n",
-       " {value_as_number: 5, time: 1.96e+05, visit_occurrence_id: 2004089, ...}]\n",
-       "---------------------------------------------------------------------------\n",
-       "type: 37697394 * {\n",
-       "    value_as_number: ?float32,\n",
-       "    time: ?float32,\n",
-       "    visit_occurrence_id: ?int64,\n",
-       "    visit_start_date: ?datetime64[D],\n",
-       "    visit_source_value: ?string,\n",
-       "    person_id: ?int32,\n",
-       "    measurement_datetime: ?datetime64[D],\n",
-       "    measurement_date: ?datetime64[D],\n",
-       "    measurement_time: ?datetime64[us],\n",
-       "    measurement_concept_id: ?int32,\n",
-       "    measurement_source_value: ?float32,\n",
-       "    unit_source: ?string,\n",
-       "    unit_concept_id: ?int32,\n",
-       "    measurement_id: ?float32\n",
-       "}
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 79, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "ak_measurement" + "adata.X = adata.X.astype(float)\n", + "#adata.layers['original'] = adata.layers['original'].astype(float)\n", + "adata.write_h5ad(\"adata_mimic3_after_exclusion.h5ad\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 23, "metadata": {}, + "outputs": [], "source": [ - "## Feature Extraction" + "adata = ad.read_h5ad(\"adata_mimic3_after_exclusion.h5ad\")" ] }, { - "cell_type": "code", - "execution_count": 123, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Select features\n", - "df_source = df_source[df_source.measurement_concept_id.isin(list(info_df.feature_id))]\n", - "# Select columns\n", - "df_source = df_source[['visit_occurrence_id', 'measurement_concept_id', 'value_as_number', 'time']]\n", + "### Aggregate data by hour\n", "\n", - "df_source.reset_index(drop=True, inplace=True)\n", - "info_dict = info_df[['feature_id', 'feature_name']].set_index('feature_id').to_dict()['feature_name']\n", - "df_source.measurement_concept_id = df_source.measurement_concept_id.replace(info_dict)" + "As mentioned before, the dataset contains information regarding the first 2 days in the ICU. Every observation is associated with a time stamp, indicating the number of hours elapsed between ICU admission and the time when the observation was collected (e.g., 0.63 hours).\n", + "To allow for ease of comparison, individual data is condensed into hourly observations by selecting the median value of the available observations within each hour. First, the 'floor' operator is applied in order to categorize the hours in 48 bins (hour 0, hour 1, ..., hour 47). Then, the 'groupby' function with the 'median' operator is applied in order to get the median heart rate for each hour of each ICU stay:" ] }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 24, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
visit_occurrence_idmeasurement_concept_idvalue_as_numbertime
02030101Heart rate88.04077.0
12030101Heart rate84.04377.0
22030101Heart rate82.05277.0
32030101Heart rate83.06177.0
42030101Heart rate83.07077.0
52030101Heart rate83.08877.0
62030101Heart rate85.010677.0
72030101Heart rate88.013377.0
82030101Heart rate87.014277.0
92030101Heart rate87.016077.0
\n", - "
" - ], + "name": "stdout", + "output_type": "stream", + "text": [ + "processing feature [Glasgow coma score total]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "processing feature [Glucose [Moles per volume] in Blood]\n", + "processing feature [Heart rate]\n", + "processing feature [Mean blood pressure]\n", + "processing feature [Peripheral oxygen saturation]\n", + "processing feature [Respiratory rate]\n", + "processing feature [Diastolic blood pressure]\n", + "processing feature [Systolic blood pressure]\n" + ] + } + ], + "source": [ + "adata = omop.aggregate_timeseries_in_bins(adata, features = measurement_features, time_key = 'measurement_datetime', value_key='value_as_number', time_binning_method='floor', bin_size='h', aggregation_method='median')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "adata.write_h5ad(\"adata_mimic3_after_aggregation.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "adata = ad.read_h5ad(\"adata_mimic3_after_aggregation.h5ad\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next example shows the vital signs for a specific ICU stay (ID = 2024697). Consecutive hourly observations are connected by line. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", "text/plain": [ - " visit_occurrence_id measurement_concept_id value_as_number time\n", - "0 2030101 Heart rate 88.0 4077.0\n", - "1 2030101 Heart rate 84.0 4377.0\n", - "2 2030101 Heart rate 82.0 5277.0\n", - "3 2030101 Heart rate 83.0 6177.0\n", - "4 2030101 Heart rate 83.0 7077.0\n", - "5 2030101 Heart rate 83.0 8877.0\n", - "6 2030101 Heart rate 85.0 10677.0\n", - "7 2030101 Heart rate 88.0 13377.0\n", - "8 2030101 Heart rate 87.0 14277.0\n", - "9 2030101 Heart rate 87.0 16077.0" + "
" ] }, - "execution_count": 124, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "df_source.head(10)" + "omop.plot_timeseries(adata, visit_occurrence_id=adata.obs.index[1], key=measurement_features, time_key = 'measurement_datetime')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Time Series Conversion" + "### Select minimum number of observations\n", + "\n", + "We decided to keep all time-variant variables available. However, and as you can see in the previous example, since not all variables have an hourly sampling rate, a lot of information is missing (coded as NaN). In order to train ML algorithms it is important to decide how to handle the missing information. Two options are: to replace the missing information with some value or to exclude the missing information. In this work, we will avoid introducing bias resultant from replacing missing values with estimated values (which is not the same as saying that this is not a good option in some situations). Instead, we will focus on a complete case analysis, i.e., we will include in our analysis only those patients who have complete information.\n", + "\n", + "Depending on how we will create the feature set, complete information can have different meanings. For example, if we want to use one observation for every hour, complete information is to have no missing\n", + "data for every t=0 to t=47, which would lead to the exclusion of the majority of data. In order to reduce the size of the feature space, one common approach is to use only some portions of the time series. This is the strategy that will be followed in this work. Summary statistics, including the mean, maximum, minimum and standard deviation will be used to extract relevant information from the time series. In this case, it is important to define the minimum length of the time series before starting to select portions of it. One possible approach is to use all patients who have at least one observation per variable. Since, the summary statistics have little meaning if only one observation is available, a threshold of two observations will be used. \n", + "\n", + "In the following function, setting 'min_num_meas = 2' means that we are selecting ICU stays where each variable was recorded at least once at two different hours. Again, we are using the 'groupby' function to aggregate data by ICU stay, and the 'count' operator to count the number of observations for each variable. We then excluded ICU stays where some variable was recorded less than 2 times. Later on this chapter we will show how to extract features from the time series, in order to reduce the size of the feature space." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO this should be moved into eariler stage\n", + "# Only select measurements from first 48 hours\n", + "for measurement_feature in measurement_features:\n", + " df = omop.to_dataframe(adata, measurement_feature)\n", + " df['measurement_datetime'] = pd.to_datetime(df['measurement_datetime'])\n", + " df = df[(df['measurement_datetime'] < '2023-01-03 00:00:00') & (df['measurement_datetime'] > '2023-01-01 00:00:00')]\n", + " adata = omop.from_dataframe(adata, measurement_feature, df)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Select minimum number of observations\n", + "selected_ids = set(adata.obs.index)\n", + "for measurement_feature in measurement_features:\n", + " data_median_hour = omop.to_dataframe(adata, measurement_feature)\n", + " data_count = data_median_hour.groupby([\"visit_occurrence_id\"]).count()\n", + " selected_ids = selected_ids.intersection(set(data_count[data_count.value_as_number >= 2].index))\n", + " \n", + "adata = adata[adata.obs.index.isin(selected_ids), :]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": {}, + "outputs": [], "source": [ - "Pivot the time series data for each visit" + "df_feature = omop.to_dataframe(adata, features = measurement_features)" ] }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "def convert_events_to_timeseries(df_feature, visit_occurrence_id, col_time='time', col_value='value_as_number', col_variable='measurement_concept_id', variables=None):\n", - " if not variables:\n", - " variables = list(df_feature[[col_variable]].unique())\n", - " metadata = df_feature[[col_time]].sort_values(by=['time'])\\\n", + "def convert_events_to_timeseries(df_feature, visit_occurrence_id, col_time='measurement_datetime', col_value='value_as_number', col_variable='feature_name', variables=None):\n", + " #if not variables:\n", + " # variables = list(df_feature[[col_variable]].unique())\n", + " metadata = df_feature[[col_time]].sort_values(by=[col_time])\\\n", " .drop_duplicates(keep='first').set_index(col_time)\n", " timeseries = df_feature[[col_time, col_variable, col_value]]\\\n", " .sort_values(by=[col_time, col_variable, col_value], axis=0)\\\n", @@ -2120,46 +999,17 @@ " for v in variables:\n", " if v not in timeseries:\n", " timeseries[v] = np.nan\n", - " timeseries['visit_occurrence_id'] = visit_occurrence_id\n", - " return timeseries" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 57770/57770 [06:34<00:00, 146.36it/s]\n" - ] - } - ], - "source": [ - "processed_chunks = []\n", - "\n", - "# Group by 'visit_occurrence_id'\n", - "grouped = df_source.groupby('visit_occurrence_id')\n", - "\n", - "# Process each group\n", - "for name, group in tqdm(grouped):\n", - " processed_chunk = convert_events_to_timeseries(\n", - " group, \n", - " col_variable='measurement_concept_id', \n", - " variables=features\n", - " )\n", - " processed_chunk['visit_occurrence_id'] = name\n", - " processed_chunks.append(processed_chunk)\n", + " timeseries = timeseries[[col_time] + variables]\n", + " \n", + " return timeseries\n", "\n", - "# Concatenate all processed chunks\n", - "time_series = pd.concat(processed_chunks, axis=0)" + "def wrapper(df, group_key, variables):\n", + " return convert_events_to_timeseries(df_feature=df, visit_occurrence_id=group_key, variables=variables, col_time='measurement_datetime')" ] }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -2183,264 +1033,161 @@ " \n", " \n", " \n", - " time\n", - " Diastolic blood pressure\n", + " \n", + " measurement_datetime\n", " Glasgow coma score total\n", - " Glucose [Moles/volume] in Blood\n", + " Glucose [Moles per volume] in Blood\n", " Heart rate\n", " Mean blood pressure\n", + " Peripheral oxygen saturation\n", " Respiratory rate\n", + " Diastolic blood pressure\n", " Systolic blood pressure\n", - " Peripheral oxygen saturation\n", + " mortality_cat\n", + " \n", + " \n", " visit_occurrence_id\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", + " 2000006\n", " 0\n", - " -633372.0\n", - " NaN\n", - " NaN\n", - " 4.9950\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1\n", + " 13.0\n", " NaN\n", - " 2000000\n", + " 92.0\n", + " 83.0\n", + " 99.0\n", + " 19.0\n", + " 78.0\n", + " 100.0\n", + " 0\n", " \n", " \n", " 1\n", - " -565572.0\n", - " NaN\n", + " 2\n", " NaN\n", - " 4.1070\n", " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 2000000\n", + " 87.0\n", + " 83.0\n", + " 98.0\n", + " 19.0\n", + " 74.0\n", + " 113.0\n", + " 0\n", " \n", " \n", " 2\n", - " -474972.0\n", - " NaN\n", + " 3\n", " NaN\n", - " 4.4400\n", " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 2000000\n", + " 105.0\n", + " 103.0\n", + " 100.0\n", + " 20.0\n", + " 97.0\n", + " 125.0\n", + " 0\n", " \n", " \n", " 3\n", - " -387432.0\n", - " NaN\n", - " NaN\n", - " 5.3835\n", - " NaN\n", + " 4\n", " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 2000000\n", + " 5.106\n", + " 105.0\n", + " 87.0\n", + " 99.0\n", + " 20.0\n", + " 74.0\n", + " 125.0\n", + " 0\n", " \n", " \n", " 4\n", - " -303672.0\n", - " NaN\n", - " NaN\n", - " 3.8295\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 2000000\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 37\n", - " 91609.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 68.0\n", - " NaN\n", - " 21.0\n", - " NaN\n", - " NaN\n", - " 2057873\n", - " \n", - " \n", - " 38\n", - " 95209.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 71.0\n", - " NaN\n", - " 25.0\n", + " 5\n", " NaN\n", " NaN\n", - " 2057873\n", - " \n", - " \n", - " 39\n", - " 98809.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 72.0\n", - " NaN\n", - " 25.0\n", - " NaN\n", - " NaN\n", - " 2057873\n", - " \n", - " \n", - " 40\n", - " 102409.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 70.0\n", - " NaN\n", + " 108.0\n", + " 90.0\n", + " 99.0\n", " 22.0\n", - " NaN\n", - " NaN\n", - " 2057873\n", - " \n", - " \n", - " 41\n", - " 106009.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 70.0\n", - " NaN\n", - " 24.0\n", - " NaN\n", - " NaN\n", - " 2057873\n", + " 77.0\n", + " 127.0\n", + " 0\n", " \n", " \n", "\n", - "

9094853 rows × 10 columns

\n", "" ], "text/plain": [ - " time Diastolic blood pressure Glasgow coma score total \\\n", - "0 -633372.0 NaN NaN \n", - "1 -565572.0 NaN NaN \n", - "2 -474972.0 NaN NaN \n", - "3 -387432.0 NaN NaN \n", - "4 -303672.0 NaN NaN \n", - ".. ... ... ... \n", - "37 91609.0 NaN NaN \n", - "38 95209.0 NaN NaN \n", - "39 98809.0 NaN NaN \n", - "40 102409.0 NaN NaN \n", - "41 106009.0 NaN NaN \n", + " measurement_datetime Glasgow coma score total \\\n", + "visit_occurrence_id \n", + "2000006 0 1 13.0 \n", + " 1 2 NaN \n", + " 2 3 NaN \n", + " 3 4 NaN \n", + " 4 5 NaN \n", "\n", - " Glucose [Moles/volume] in Blood Heart rate Mean blood pressure \\\n", - "0 4.9950 NaN NaN \n", - "1 4.1070 NaN NaN \n", - "2 4.4400 NaN NaN \n", - "3 5.3835 NaN NaN \n", - "4 3.8295 NaN NaN \n", - ".. ... ... ... \n", - "37 NaN 68.0 NaN \n", - "38 NaN 71.0 NaN \n", - "39 NaN 72.0 NaN \n", - "40 NaN 70.0 NaN \n", - "41 NaN 70.0 NaN \n", + " Glucose [Moles per volume] in Blood Heart rate \\\n", + "visit_occurrence_id \n", + "2000006 0 NaN 92.0 \n", + " 1 NaN 87.0 \n", + " 2 NaN 105.0 \n", + " 3 5.106 105.0 \n", + " 4 NaN 108.0 \n", "\n", - " Respiratory rate Systolic blood pressure Peripheral oxygen saturation \\\n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - ".. ... ... ... \n", - "37 21.0 NaN NaN \n", - "38 25.0 NaN NaN \n", - "39 25.0 NaN NaN \n", - "40 22.0 NaN NaN \n", - "41 24.0 NaN NaN \n", + " Mean blood pressure Peripheral oxygen saturation \\\n", + "visit_occurrence_id \n", + "2000006 0 83.0 99.0 \n", + " 1 83.0 98.0 \n", + " 2 103.0 100.0 \n", + " 3 87.0 99.0 \n", + " 4 90.0 99.0 \n", "\n", - " visit_occurrence_id \n", - "0 2000000 \n", - "1 2000000 \n", - "2 2000000 \n", - "3 2000000 \n", - "4 2000000 \n", - ".. ... \n", - "37 2057873 \n", - "38 2057873 \n", - "39 2057873 \n", - "40 2057873 \n", - "41 2057873 \n", + " Respiratory rate Diastolic blood pressure \\\n", + "visit_occurrence_id \n", + "2000006 0 19.0 78.0 \n", + " 1 19.0 74.0 \n", + " 2 20.0 97.0 \n", + " 3 20.0 74.0 \n", + " 4 22.0 77.0 \n", "\n", - "[9094853 rows x 10 columns]" + " Systolic blood pressure mortality_cat \n", + "visit_occurrence_id \n", + "2000006 0 100.0 0 \n", + " 1 113.0 0 \n", + " 2 125.0 0 \n", + " 3 125.0 0 \n", + " 4 127.0 0 " ] }, - "execution_count": 127, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "time_series" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "time_series['HOURS'] = time_series.time / 3600" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "time_series.reset_index(drop=True, inplace=True)\n", - "columns_sorted = ['visit_occurrence_id', 'HOURS', 'time'] + list(info_dict.values())\n", - "time_series = time_series[columns_sorted]" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "time_series.to_csv(\"mimic3_time_series.csv\")" + "data_median_hour = df_feature.groupby(\"visit_occurrence_id\").apply(lambda df: wrapper(df, df.name, variables=measurement_features))\n", + "data_median_hour['measurement_datetime'] = data_median_hour['measurement_datetime'].dt.hour\n", + "data_median_hour = data_median_hour.join(adata.obs['mortality_cat'])\n", + "data_median_hour = data_median_hour.reset_index(drop=False)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -2465,1390 +1212,150 @@ " \n", " \n", " visit_occurrence_id\n", - " HOURS\n", - " time\n", + " level_1\n", + " measurement_datetime\n", " Glasgow coma score total\n", - " Glucose [Moles/volume] in Blood\n", + " Glucose [Moles per volume] in Blood\n", " Heart rate\n", " Mean blood pressure\n", " Peripheral oxygen saturation\n", " Respiratory rate\n", " Diastolic blood pressure\n", " Systolic blood pressure\n", + " mortality_cat\n", " \n", " \n", " \n", " \n", " 0\n", - " 2000000\n", - " -175.936661\n", - " -633372.0\n", - " NaN\n", - " 4.9950\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2000006\n", + " 0\n", + " 1\n", + " 13.0\n", " NaN\n", + " 92.0\n", + " 83.0\n", + " 99.0\n", + " 19.0\n", + " 78.0\n", + " 100.0\n", + " 0\n", " \n", " \n", " 1\n", - " 2000000\n", - " -157.103333\n", - " -565572.0\n", - " NaN\n", - " 4.1070\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2000006\n", + " 1\n", + " 2\n", " NaN\n", " NaN\n", + " 87.0\n", + " 83.0\n", + " 98.0\n", + " 19.0\n", + " 74.0\n", + " 113.0\n", + " 0\n", " \n", " \n", " 2\n", - " 2000000\n", - " -131.936661\n", - " -474972.0\n", - " NaN\n", - " 4.4400\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2000006\n", + " 2\n", + " 3\n", " NaN\n", " NaN\n", + " 105.0\n", + " 103.0\n", + " 100.0\n", + " 20.0\n", + " 97.0\n", + " 125.0\n", + " 0\n", " \n", " \n", " 3\n", - " 2000000\n", - " -107.620003\n", - " -387432.0\n", - " NaN\n", - " 5.3835\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2000006\n", + " 3\n", + " 4\n", " NaN\n", + " 5.106\n", + " 105.0\n", + " 87.0\n", + " 99.0\n", + " 20.0\n", + " 74.0\n", + " 125.0\n", + " 0\n", " \n", " \n", " 4\n", - " 2000000\n", - " -84.353333\n", - " -303672.0\n", - " NaN\n", - " 3.8295\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 5\n", - " 2000000\n", - " -59.786667\n", - " -215232.0\n", - " NaN\n", - " 5.2725\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 6\n", - " 2000000\n", - " -36.103333\n", - " -129972.0\n", - " NaN\n", - " 4.4400\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 7\n", - " 2000000\n", - " -12.853333\n", - " -46272.0\n", - " NaN\n", - " 4.4955\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 8\n", - " 2000000\n", - " -0.003333\n", - " -12.0\n", - " NaN\n", - " NaN\n", - " 115.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 9\n", - " 2000000\n", - " 0.013333\n", - " 48.0\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2000006\n", + " 4\n", + " 5\n", " NaN\n", " NaN\n", + " 108.0\n", + " 90.0\n", + " 99.0\n", " 22.0\n", - " NaN\n", - " NaN\n", + " 77.0\n", + " 127.0\n", + " 0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " visit_occurrence_id HOURS time Glasgow coma score total \\\n", - "0 2000000 -175.936661 -633372.0 NaN \n", - "1 2000000 -157.103333 -565572.0 NaN \n", - "2 2000000 -131.936661 -474972.0 NaN \n", - "3 2000000 -107.620003 -387432.0 NaN \n", - "4 2000000 -84.353333 -303672.0 NaN \n", - "5 2000000 -59.786667 -215232.0 NaN \n", - "6 2000000 -36.103333 -129972.0 NaN \n", - "7 2000000 -12.853333 -46272.0 NaN \n", - "8 2000000 -0.003333 -12.0 NaN \n", - "9 2000000 0.013333 48.0 NaN \n", + " visit_occurrence_id level_1 measurement_datetime \\\n", + "0 2000006 0 1 \n", + "1 2000006 1 2 \n", + "2 2000006 2 3 \n", + "3 2000006 3 4 \n", + "4 2000006 4 5 \n", "\n", - " Glucose [Moles/volume] in Blood Heart rate Mean blood pressure \\\n", - "0 4.9950 NaN NaN \n", - "1 4.1070 NaN NaN \n", - "2 4.4400 NaN NaN \n", - "3 5.3835 NaN NaN \n", - "4 3.8295 NaN NaN \n", - "5 5.2725 NaN NaN \n", - "6 4.4400 NaN NaN \n", - "7 4.4955 NaN NaN \n", - "8 NaN 115.0 NaN \n", - "9 NaN NaN NaN \n", + " Glasgow coma score total Glucose [Moles per volume] in Blood Heart rate \\\n", + "0 13.0 NaN 92.0 \n", + "1 NaN NaN 87.0 \n", + "2 NaN NaN 105.0 \n", + "3 NaN 5.106 105.0 \n", + "4 NaN NaN 108.0 \n", "\n", - " Peripheral oxygen saturation Respiratory rate Diastolic blood pressure \\\n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "5 NaN NaN NaN \n", - "6 NaN NaN NaN \n", - "7 NaN NaN NaN \n", - "8 NaN NaN NaN \n", - "9 NaN 22.0 NaN \n", + " Mean blood pressure Peripheral oxygen saturation Respiratory rate \\\n", + "0 83.0 99.0 19.0 \n", + "1 83.0 98.0 19.0 \n", + "2 103.0 100.0 20.0 \n", + "3 87.0 99.0 20.0 \n", + "4 90.0 99.0 22.0 \n", "\n", - " Systolic blood pressure \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - "5 NaN \n", - "6 NaN \n", - "7 NaN \n", - "8 NaN \n", - "9 NaN " + " Diastolic blood pressure Systolic blood pressure mortality_cat \n", + "0 78.0 100.0 0 \n", + "1 74.0 113.0 0 \n", + "2 97.0 125.0 0 \n", + "3 74.0 125.0 0 \n", + "4 77.0 127.0 0 " ] }, - "execution_count": 18, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "time_series.head(10)" + "data_median_hour.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Get statistics of features" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "stats = time_series.groupby('visit_occurrence_id')[features].agg(['mean', 'median', 'max', 'min'])\n", - "\n", - "# Flatten the MultiIndex columns\n", - "stats.columns = ['_'.join(col).strip() for col in stats.columns.values]\n", - "import anndata as ad\n", - "adata_stats = ad.AnnData(stats)\n", - "\n", - "adata = ad.concat([adata, adata_stats], axis=1, merge='unique', uns_merge='unique')\n", - "adata.uns['time_series'] = time_series" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "AnnData object with n_obs × n_vars = 57770 × 34\n", - " obs: 'visit_start_date', 'death_date', 'visit_end_datetime', 'discharged_to_source_value', 'gender_concept_id', 'death_datetime', 'birth_datetime', 'visit_start_datetime', 'admitted_from_source_value', 'visit_type_concept_id', 'visit_end_date', 'visit_concept_id', 'visit_source_value', 'person_source_value', 'Unnamed: 0'\n", - " uns: 'numerical_columns', 'non_numerical_columns', 'time_series'" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "adata" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
year_of_birth
gender_source_value
Glasgow coma score total_mean
Glasgow coma score total_median
Glasgow coma score total_max
Glasgow coma score total_min
Glucose [Moles/volume] in Blood_mean
Glucose [Moles/volume] in Blood_median
Glucose [Moles/volume] in Blood_max
Glucose [Moles/volume] in Blood_min
Heart rate_mean
Heart rate_median
Heart rate_max
Heart rate_min
Mean blood pressure_mean
Mean blood pressure_median
Mean blood pressure_max
Mean blood pressure_min
Peripheral oxygen saturation_mean
Peripheral oxygen saturation_median
Peripheral oxygen saturation_max
Peripheral oxygen saturation_min
Respiratory rate_mean
Respiratory rate_median
Respiratory rate_max
Respiratory rate_min
Diastolic blood pressure_mean
Diastolic blood pressure_median
Diastolic blood pressure_max
Diastolic blood pressure_min
Systolic blood pressure_mean
Systolic blood pressure_median
Systolic blood pressure_max
Systolic blood pressure_min
\n", - "
" - ], - "text/plain": [ - "Empty DataFrame\n", - "Columns: []\n", - "Index: [year_of_birth, gender_source_value, Glasgow coma score total_mean, Glasgow coma score total_median, Glasgow coma score total_max, Glasgow coma score total_min, Glucose [Moles/volume] in Blood_mean, Glucose [Moles/volume] in Blood_median, Glucose [Moles/volume] in Blood_max, Glucose [Moles/volume] in Blood_min, Heart rate_mean, Heart rate_median, Heart rate_max, Heart rate_min, Mean blood pressure_mean, Mean blood pressure_median, Mean blood pressure_max, Mean blood pressure_min, Peripheral oxygen saturation_mean, Peripheral oxygen saturation_median, Peripheral oxygen saturation_max, Peripheral oxygen saturation_min, Respiratory rate_mean, Respiratory rate_median, Respiratory rate_max, Respiratory rate_min, Diastolic blood pressure_mean, Diastolic blood pressure_median, Diastolic blood pressure_max, Diastolic blood pressure_min, Systolic blood pressure_mean, Systolic blood pressure_median, Systolic blood pressure_max, Systolic blood pressure_min]" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "adata.var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data Imputation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can easily use `ep.pl.missing_values_barplot` to visualize a bar chart of the null values:" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ep.pl.missing_values_barplot(adata)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['Glasgow coma score total_mean',\n", - " 'Glucose [Moles/volume] in Blood_mean',\n", - " 'Heart rate_mean',\n", - " 'Mean blood pressure_mean',\n", - " 'Peripheral oxygen saturation_mean',\n", - " 'Respiratory rate_mean',\n", - " 'Diastolic blood pressure_mean',\n", - " 'Systolic blood pressure_mean']" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "variables = [feature + '_mean' for feature in features]\n", - "variables" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Quality control metrics missing. Calculating...\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mQuality control metrics missing. Calculating\u001b[0m\u001b[1;33m...\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1;35m2024-01-23 11:59:52,354\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[1;30mINFO - Added the calculated metrics to AnnData's `obs` and `var`.\u001b[0m\n" - ] - }, - { - "data": { - "text/html": [ - "
Feature Peripheral oxygen saturation_max had more than 83.48% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mPeripheral oxygen saturation_max \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m83.48\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Diastolic blood pressure_mean had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mDiastolic blood pressure_mean \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Glasgow coma score total_mean had more than 59.61% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mGlasgow coma score total_mean \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.61\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Mean blood pressure_median had more than 59.99% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mMean blood pressure_median \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.99\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Systolic blood pressure_min had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mSystolic blood pressure_min \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Diastolic blood pressure_max had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mDiastolic blood pressure_max \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Peripheral oxygen saturation_mean had more than 83.48% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mPeripheral oxygen saturation_mean \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m83.48\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Systolic blood pressure_median had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mSystolic blood pressure_median \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Diastolic blood pressure_median had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mDiastolic blood pressure_median \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Diastolic blood pressure_min had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mDiastolic blood pressure_min \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Systolic blood pressure_max had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mSystolic blood pressure_max \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Mean blood pressure_max had more than 59.99% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mMean blood pressure_max \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.99\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Mean blood pressure_mean had more than 59.99% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mMean blood pressure_mean \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.99\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Peripheral oxygen saturation_median had more than 83.48% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mPeripheral oxygen saturation_median \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m83.48\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Glasgow coma score total_median had more than 59.61% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mGlasgow coma score total_median \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.61\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Mean blood pressure_min had more than 59.99% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mMean blood pressure_min \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.99\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Peripheral oxygen saturation_min had more than 83.48% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mPeripheral oxygen saturation_min \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m83.48\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Systolic blood pressure_mean had more than 59.98% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mSystolic blood pressure_mean \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.98\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Glasgow coma score total_min had more than 59.61% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mGlasgow coma score total_min \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.61\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Feature Glasgow coma score total_max had more than 59.61% missing values!\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1;33mFeature \u001b[0m\u001b[1;34mGlasgow coma score total_max \u001b[0m\u001b[1;33mhad more than \u001b[0m\u001b[1;34m59.61\u001b[0m\u001b[1;34m% \u001b[0m\u001b[1;33mmissing values!\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "adata_1 = ep.pp.explicit_impute(adata, replacement=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data preprocessing\n",
-    "### Outliers\n",
-    "#### Data visualization\n",
-    "\n",
-    "We already saw that outliers are present in the dataset, but we need to take a closer look at data before deciding how to handle them. Using `ehrapy` and its `violin` plot function we can easily create one boxplot for every variable."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 76,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
╭─────────────────────────────────────── Traceback (most recent call last) ───────────────────────────────────────╮\n",
-       "│ in <module>:2                                                                                                   │\n",
-       "│                                                                                                                 │\n",
-       "│   1 # TODO TypeError                                                                                            │\n",
-       "│ ❱ 2 ep.pl.violin(adata, keys='Glasgow coma score total_mean')                                                   │\n",
-       "│   3                                                                                                             │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/ehrapy/plot/_scanpy_pl_api.py:598 in violin      │\n",
-       "│                                                                                                                 │\n",
-       "│    595 │   │   │   return violin_partial(adata=adata.anndata, groupby=None)                                     │\n",
-       "│    596 │                                                                                                        │\n",
-       "│    597 │   else:                                                                                                │\n",
-       "│ ❱  598 │   │   return violin_partial(adata=adata, groupby=groupby)                                              │\n",
-       "│    599                                                                                                          │\n",
-       "│    600                                                                                                          │\n",
-       "│    601 @_doc_params(                                                                                            │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scanpy/plotting/_anndata.py:843 in violin        │\n",
-       "│                                                                                                                 │\n",
-       "│    840 │   │   else:                                                                                            │\n",
-       "│    841 │   │   │   axs = [ax]                                                                                   │\n",
-       "│    842 │   │   for ax, y, ylab in zip(axs, ys, ylabel):                                                         │\n",
-       "│ ❱  843 │   │   │   ax = sns.violinplot(                                                                         │\n",
-       "│    844 │   │   │   │   x=x,                                                                                     │\n",
-       "│    845 │   │   │   │   y=y,                                                                                     │\n",
-       "│    846 │   │   │   │   data=obs_tidy,                                                                           │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/categorical.py:2305 in violinplot        │\n",
-       "│                                                                                                                 │\n",
-       "│   2302 │   ax=None, **kwargs,                                                                                   │\n",
-       "│   2303 ):                                                                                                       │\n",
-       "│   2304 │                                                                                                        │\n",
-       "│ ❱ 2305 │   plotter = _ViolinPlotter(x, y, hue, data, order, hue_order,                                          │\n",
-       "│   2306 │   │   │   │   │   │   │    bw, cut, scale, scale_hue, gridsize,                                        │\n",
-       "│   2307 │   │   │   │   │   │   │    width, inner, split, dodge, orient, linewidth,                              │\n",
-       "│   2308 │   │   │   │   │   │   │    color, palette, saturation)                                                 │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/categorical.py:903 in __init__           │\n",
-       "│                                                                                                                 │\n",
-       "│    900 │   │                                                                                                    │\n",
-       "│    901 │   │   self.establish_variables(x, y, hue, data, orient, order, hue_order)                              │\n",
-       "│    902 │   │   self.establish_colors(color, palette, saturation)                                                │\n",
-       "│ ❱  903 │   │   self.estimate_densities(bw, cut, scale, scale_hue, gridsize)                                     │\n",
-       "│    904 │   │                                                                                                    │\n",
-       "│    905 │   │   self.gridsize = gridsize                                                                         │\n",
-       "│    906 │   │   self.width = width                                                                               │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/categorical.py:973 in estimate_densities │\n",
-       "│                                                                                                                 │\n",
-       "│    970 │   │   │   │                                                                                            │\n",
-       "│    971 │   │   │   │   # Determine the support grid and get the density over it                                 │\n",
-       "│    972 │   │   │   │   support_i = self.kde_support(kde_data, bw_used, cut, gridsize)                           │\n",
-       "│ ❱  973 │   │   │   │   density_i = kde.evaluate(support_i)                                                      │\n",
-       "│    974 │   │   │   │                                                                                            │\n",
-       "│    975 │   │   │   │   # Update the data structures with these results                                          │\n",
-       "│    976 │   │   │   │   support.append(support_i)                                                                │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scipy/stats/_kde.py:267 in evaluate              │\n",
-       "│                                                                                                                 │\n",
-       "│   264 │   │   │   │   │      f\"dataset has dimension {self.d}\")                                                 │\n",
-       "│   265 │   │   │   │   raise ValueError(msg)                                                                     │\n",
-       "│   266 │   │                                                                                                     │\n",
-       "│ ❱ 267 │   │   output_dtype, spec = _get_output_dtype(self.covariance, points)                                   │\n",
-       "│   268 │   │   result = gaussian_kernel_estimate[spec](                                                          │\n",
-       "│   269 │   │   │   self.dataset.T, self.weights[:, None],                                                        │\n",
-       "│   270 │   │   │   points.T, self.cho_cov, output_dtype)                                                         │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scipy/stats/_kde.py:712 in _get_output_dtype     │\n",
-       "│                                                                                                                 │\n",
-       "│   709 │   This was necessary in order to deal with the fused types in the Cython                                │\n",
-       "│   710 │   routine `gaussian_kernel_estimate`. See gh-10824 for details.                                         │\n",
-       "│   711 │   \"\"\"                                                                                                   │\n",
-       "│ ❱ 712 │   output_dtype = np.common_type(covariance, points)                                                     │\n",
-       "│   713 │   itemsize = np.dtype(output_dtype).itemsize                                                            │\n",
-       "│   714 │   if itemsize == 4:                                                                                     │\n",
-       "│   715 │   │   spec = 'float'                                                                                    │\n",
-       "│ in common_type:200                                                                                              │\n",
-       "│                                                                                                                 │\n",
-       "│ /opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/numpy/lib/type_check.py:730 in common_type       │\n",
-       "│                                                                                                                 │\n",
-       "│   727 │   │   else:                                                                                             │\n",
-       "│   728 │   │   │   p = array_precision.get(t, None)                                                              │\n",
-       "│   729 │   │   │   if p is None:                                                                                 │\n",
-       "│ ❱ 730 │   │   │   │   raise TypeError(\"can't get common type for non-numeric array\")                            │\n",
-       "│   731 │   │   precision = max(precision, p)                                                                     │\n",
-       "│   732 │   if is_complex:                                                                                        │\n",
-       "│   733 │   │   return array_type[1][precision]                                                                   │\n",
-       "╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
-       "TypeError: can't get common type for non-numeric array\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m──────────────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n",
-       "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m2\u001b[0m                                                                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m1 \u001b[0m\u001b[2m# TODO TypeError\u001b[0m                                                                                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2 ep.pl.violin(adata, keys=\u001b[33m'\u001b[0m\u001b[33mGlasgow coma score total_mean\u001b[0m\u001b[33m'\u001b[0m)                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m3 \u001b[0m                                                                                                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/ehrapy/plot/\u001b[0m\u001b[1;33m_scanpy_pl_api.py\u001b[0m:\u001b[94m598\u001b[0m in \u001b[92mviolin\u001b[0m      \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 595 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[94mreturn\u001b[0m violin_partial(adata=adata.anndata, groupby=\u001b[94mNone\u001b[0m)                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 596 \u001b[0m\u001b[2m│   \u001b[0m                                                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 597 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94melse\u001b[0m:                                                                                                \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 598 \u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m violin_partial(adata=adata, groupby=groupby)                                              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 599 \u001b[0m                                                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 600 \u001b[0m                                                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 601 \u001b[0m\u001b[1;95m@_doc_params\u001b[0m(                                                                                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scanpy/plotting/\u001b[0m\u001b[1;33m_anndata.py\u001b[0m:\u001b[94m843\u001b[0m in \u001b[92mviolin\u001b[0m        \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 840 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94melse\u001b[0m:                                                                                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 841 \u001b[0m\u001b[2m│   │   │   \u001b[0maxs = [ax]                                                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 842 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mfor\u001b[0m ax, y, ylab \u001b[95min\u001b[0m \u001b[96mzip\u001b[0m(axs, ys, ylabel):                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 843 \u001b[2m│   │   │   \u001b[0max = sns.violinplot(                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 844 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mx=x,                                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 845 \u001b[0m\u001b[2m│   │   │   │   \u001b[0my=y,                                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 846 \u001b[0m\u001b[2m│   │   │   │   \u001b[0mdata=obs_tidy,                                                                           \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/\u001b[0m\u001b[1;33mcategorical.py\u001b[0m:\u001b[94m2305\u001b[0m in \u001b[92mviolinplot\u001b[0m        \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2302 \u001b[0m\u001b[2m│   \u001b[0max=\u001b[94mNone\u001b[0m, **kwargs,                                                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2303 \u001b[0m):                                                                                                       \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2304 \u001b[0m\u001b[2m│   \u001b[0m                                                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2305 \u001b[2m│   \u001b[0mplotter = _ViolinPlotter(x, y, hue, data, order, hue_order,                                          \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2306 \u001b[0m\u001b[2m│   │   │   │   │   │   │    \u001b[0mbw, cut, scale, scale_hue, gridsize,                                        \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2307 \u001b[0m\u001b[2m│   │   │   │   │   │   │    \u001b[0mwidth, inner, split, dodge, orient, linewidth,                              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m2308 \u001b[0m\u001b[2m│   │   │   │   │   │   │    \u001b[0mcolor, palette, saturation)                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/\u001b[0m\u001b[1;33mcategorical.py\u001b[0m:\u001b[94m903\u001b[0m in \u001b[92m__init__\u001b[0m           \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 900 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 901 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[96mself\u001b[0m.establish_variables(x, y, hue, data, orient, order, hue_order)                              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 902 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[96mself\u001b[0m.establish_colors(color, palette, saturation)                                                \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 903 \u001b[2m│   │   \u001b[0m\u001b[96mself\u001b[0m.estimate_densities(bw, cut, scale, scale_hue, gridsize)                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 904 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 905 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[96mself\u001b[0m.gridsize = gridsize                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 906 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[96mself\u001b[0m.width = width                                                                               \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/seaborn/\u001b[0m\u001b[1;33mcategorical.py\u001b[0m:\u001b[94m973\u001b[0m in \u001b[92mestimate_densities\u001b[0m \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 970 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m                                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 971 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[2m# Determine the support grid and get the density over it\u001b[0m                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 972 \u001b[0m\u001b[2m│   │   │   │   \u001b[0msupport_i = \u001b[96mself\u001b[0m.kde_support(kde_data, bw_used, cut, gridsize)                           \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 973 \u001b[2m│   │   │   │   \u001b[0mdensity_i = kde.evaluate(support_i)                                                      \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 974 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m                                                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 975 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[2m# Update the data structures with these results\u001b[0m                                          \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m 976 \u001b[0m\u001b[2m│   │   │   │   \u001b[0msupport.append(support_i)                                                                \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scipy/stats/\u001b[0m\u001b[1;33m_kde.py\u001b[0m:\u001b[94m267\u001b[0m in \u001b[92mevaluate\u001b[0m              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m264 \u001b[0m\u001b[2m│   │   │   │   │      \u001b[0m\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mdataset has dimension \u001b[0m\u001b[33m{\u001b[0m\u001b[96mself\u001b[0m.d\u001b[33m}\u001b[0m\u001b[33m\"\u001b[0m)                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m265 \u001b[0m\u001b[2m│   │   │   │   \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mValueError\u001b[0m(msg)                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m266 \u001b[0m\u001b[2m│   │   \u001b[0m                                                                                                  \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m267 \u001b[2m│   │   \u001b[0moutput_dtype, spec = _get_output_dtype(\u001b[96mself\u001b[0m.covariance, points)                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m268 \u001b[0m\u001b[2m│   │   \u001b[0mresult = gaussian_kernel_estimate[spec](                                                          \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m269 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[96mself\u001b[0m.dataset.T, \u001b[96mself\u001b[0m.weights[:, \u001b[94mNone\u001b[0m],                                                        \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m270 \u001b[0m\u001b[2m│   │   │   \u001b[0mpoints.T, \u001b[96mself\u001b[0m.cho_cov, output_dtype)                                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/scipy/stats/\u001b[0m\u001b[1;33m_kde.py\u001b[0m:\u001b[94m712\u001b[0m in \u001b[92m_get_output_dtype\u001b[0m     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m709 \u001b[0m\u001b[2;33m│   \u001b[0m\u001b[33mThis was necessary in order to deal with the fused types in the Cython\u001b[0m                                \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m710 \u001b[0m\u001b[2;33m│   \u001b[0m\u001b[33mroutine `gaussian_kernel_estimate`. See gh-10824 for details.\u001b[0m                                         \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m711 \u001b[0m\u001b[2;33m│   \u001b[0m\u001b[33m\"\"\"\u001b[0m                                                                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m712 \u001b[2m│   \u001b[0moutput_dtype = np.common_type(covariance, points)                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m713 \u001b[0m\u001b[2m│   \u001b[0mitemsize = np.dtype(output_dtype).itemsize                                                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m714 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94mif\u001b[0m itemsize == \u001b[94m4\u001b[0m:                                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m715 \u001b[0m\u001b[2m│   │   \u001b[0mspec = \u001b[33m'\u001b[0m\u001b[33mfloat\u001b[0m\u001b[33m'\u001b[0m                                                                                    \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m in \u001b[92mcommon_type\u001b[0m:\u001b[94m200\u001b[0m                                                                                              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[2;33m/opt/anaconda3/envs/ehrapy_latents/lib/python3.9/site-packages/numpy/lib/\u001b[0m\u001b[1;33mtype_check.py\u001b[0m:\u001b[94m730\u001b[0m in \u001b[92mcommon_type\u001b[0m       \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m                                                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m727 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94melse\u001b[0m:                                                                                             \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m728 \u001b[0m\u001b[2m│   │   │   \u001b[0mp = array_precision.get(t, \u001b[94mNone\u001b[0m)                                                              \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m729 \u001b[0m\u001b[2m│   │   │   \u001b[0m\u001b[94mif\u001b[0m p \u001b[95mis\u001b[0m \u001b[94mNone\u001b[0m:                                                                                 \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m730 \u001b[2m│   │   │   │   \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mTypeError\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mcan\u001b[0m\u001b[33m'\u001b[0m\u001b[33mt get common type for non-numeric array\u001b[0m\u001b[33m\"\u001b[0m)                            \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m731 \u001b[0m\u001b[2m│   │   \u001b[0mprecision = \u001b[96mmax\u001b[0m(precision, p)                                                                     \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m732 \u001b[0m\u001b[2m│   \u001b[0m\u001b[94mif\u001b[0m is_complex:                                                                                        \u001b[31m│\u001b[0m\n",
-       "\u001b[31m│\u001b[0m   \u001b[2m733 \u001b[0m\u001b[2m│   │   \u001b[0m\u001b[94mreturn\u001b[0m array_type[\u001b[94m1\u001b[0m][precision]                                                                   \u001b[31m│\u001b[0m\n",
-       "\u001b[31m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
-       "\u001b[1;91mTypeError: \u001b[0mcan't get common type for non-numeric array\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# TODO TypeError\n",
-    "ep.pl.violin(adata, keys='Glasgow coma score total_mean')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Exclusion\n",
-    "\n",
-    "Ideally, we should keep extreme values related to the patients' poor health condition and exclude impossible values (such as negative temperature) and probable outliers (such as heart rate above 250 beats/min). In order to do so, values that fall outside boundaries defined by expert knowledge are excluded. This way, we avoid excluding extreme (but correct/possible) values. We can use `ep.pp.qc_lab_measurements` function to examine lab measurements for reference ranges and outliers. To do so, we need to define a custom reference table which contains possible values for each measurement.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
Traditional Reference Interval
diastolic BP<300
systolic BP<10000
mean BP0-300
glucose<2000
heart rate<400
respiratory rate<300
temperature20-50
pH6.8-7.8
oxygen saturation0-100
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                  Traditional Reference Interval\n",
-       "diastolic BP                                <300\n",
-       "systolic BP                               <10000\n",
-       "mean BP                                    0-300\n",
-       "glucose                                    <2000\n",
-       "heart rate                                  <400\n",
-       "respiratory rate                            <300\n",
-       "temperature                                20-50\n",
-       "pH                                       6.8-7.8\n",
-       "oxygen saturation                          0-100"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "measurements = [\n",
-    "    \"diastolic BP\",\n",
-    "    \"systolic BP\",\n",
-    "    \"mean BP\",\n",
-    "    \"glucose\",\n",
-    "    \"heart rate\",\n",
-    "    \"respiratory rate\",\n",
-    "    \"temperature\",\n",
-    "    \"pH\",\n",
-    "    \"oxygen saturation\",\n",
-    "]\n",
-    "reference_table = pd.DataFrame(\n",
-    "    np.array(\n",
-    "        [\n",
-    "            \"<300\",\n",
-    "            \"<10000\",\n",
-    "            \"0-300\",\n",
-    "            \"<2000\",\n",
-    "            \"<400\",\n",
-    "            \"<300\",\n",
-    "            \"20-50\",\n",
-    "            \"6.8-7.8\",\n",
-    "            \"0-100\",\n",
-    "        ]\n",
-    "    ),\n",
-    "    columns=[\"Traditional Reference Interval\"],\n",
-    "    index=measurements,\n",
-    ")\n",
-    "reference_table"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of observations removed: 194\n",
-      "Observations corresponding to outliers: 0.02%\n"
-     ]
-    }
-   ],
-   "source": [
-    "ep.pp.qc_lab_measurements(\n",
-    "    adata, measurements=measurements, reference_table=reference_table\n",
-    ")\n",
-    "nulls_before = adata.to_df().isnull().sum().sum()\n",
-    "for measurement in measurements:\n",
-    "    adata[~adata.obs[f\"{measurement} normal\"], measurement].X = np.nan\n",
-    "nulls_now = adata.to_df().isnull().sum().sum()\n",
-    "\n",
-    "print(f\"Number of observations removed: {str(nulls_now - nulls_before)}\")\n",
-    "print(\n",
-    "    f\"Observations corresponding to outliers: {str(round((nulls_now - nulls_before)*100/adata.n_obs,2))}%\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Data visualization after outliers exclusion\n",
-    "\n",
-    "The same code can be used to verify the data distribution after exclusion of outliers. The `ep.pl.violin` function allows to visualize the underlying distribution and the number of observations. Setting `groupby = \"mortality_cat\"` shows the plots partitioned by outcome."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAPdCAYAAACXzguGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU9f748deZYQfZZBEEWUREEAU3TM09NfVWLmk/rdvNtFJLb93qtljftLxdb3vZYqWWLa6pWe67ue+KoCCiArILw74Nc35/jIyMiALOMDB8no+HD2bmzPIeB86c9/l8Pu+3JMuyjCAIgiAIgiAIgiAIBqcwdQCCIAiCIAiCIAiCYK5E0i0IgiAIgiAIgiAIRiKSbkEQBEEQBEEQBEEwEpF0C4IgCIIgCIIgCIKRiKRbEARBEARBEARBEIxEJN2CIAiCIAiCIAiCYCQi6RYEQRAEQRAEQRAEIxFJtyAIgiAIgiAIgiAYiUi6BUEQBEEQBEEQBMFILEwdQFOWm5uLWq02dRiCIBiQhYUFLi4upg7DrIh9pSCYH7GvNDyxrxQE81PXfaVIuu9ArVZTUVFh6jAEQRCaNLGvFARBuDuxrxSElktMLxcEQRAEQRAEQRAEIxFJtyAIgiAIgiAIgiAYiZheLgiC0MTFxsayYcMGLl++TG5uLi+//DK9evXSbf/yyy/Zu3ev3mO6du3Km2++ecfn3bJlC3/88QcqlQo/Pz+mTJlCUFCQUd6DIAiCIAhCSyWSbkEQhCaurKwMf39/Bg8ezIcffnjb+0RERDBjxgzddQuLO+/eDx48yLJly5g2bRodOnRg48aNzJ8/n08//RQnJyeDxi8IgiAIgtCSiaRb0FGr1ZSXl2NnZ2fqUARBqCYyMpLIyMg73sfCwgJnZ+c6P+eff/7JkCFDGDRoEADTpk3j5MmT7N69m0ceeeS2j6moqNArAiRJEra2trrLdVFYWMj169dRKMTqJlPTaDS0bdv2ridoDCUvL4/8/PxGeS1BS5Ik2rRp02ifsSAILVteXp44cV8LsRcWdP73v/+RmprK//73P5F4C0IzExsby9SpU7G3t6dz58489thjtGrV6rb3VavVJCYm6iXXCoWC8PBw4uPja32NdevWsWbNGt31gIAAFixYgLu7e51iVKlUTJ8+nbKysrq9KcHoQkND+eijj4z+OlevXuVf//oXGo3G6K8l6OvWrRvz5883dRiCIJi5/fv3s3TpUiZMmMDw4cNNHU6TI5JuQefSpUsAXLhwgW7dupk4GkEQ6ioiIoKoqCg8PDxIT09n+fLl/Oc//2H+/Pm3HVHOz89Ho9HUGBl3dnYmNTW11tcZM2YMo0eP1l2vGt3OysqqU+/ZkpISrK2t75h0O9RtwFyoIw1QLNe+3dPTk7S0NKPHsXfvXjQaDbJCCRZWRn89AZBBqijhzJkzJCUlYWlpWa+HW1hY1PmEmiAIwi+//ALAqlWrRNJ9GyLpFgRBaOb69u2ru9yuXTv8/Px44YUXiImJITw83GCvY2lpWeuBuyzfIbO7wcbGho8++ogLFy6wb98+Tp48SWVlpd59ymVwV2r/uSnB48ZlVwUo6ziFvSUqk2WyKyHrln/XbzOwbG9vT9++fenfvz9eXl51+uzulUql0l5wcEfTdSRIYnmB0RVkoTz1O5WVleTn5+Pq6mrqiARBMGPl5eWmDqFJE0m3IAiCgVVUVHD58mXy8vLo2LEjjo6Ojfr6np6etGrVivT09Nsm3Y6OjigUipuJ0A0qlape68IbQqFQEBoaSmhoKPn5+Rw8eJBLly6RlpZGZmYm5ZWVXKuEa5W3PA5orZBpfSMBr/rpqgTnFpKQl8syOZWQo4GcGwl1TiVkayDvDrO2ra2tadOmDV5eXoSHh9O9e/d6j3req969e7Nz507K89OR4v9CDuoDysaNoUUpyEIRsx2A8PBwXFxcTByQIAhCyyaSbkEQBAPatGkTq1evpri4GIC33nqLzp07k5+fz4svvsjkyZMZPHiwUWO4fv06hYWFtR5oW1hYEBgYyLlz53StxzQaDefOnWPEiBFGja06R0dHvddTq9VkZmaSnp5OWloaqampustlZWVkaSDrNsmlAnCulpC73pKYWzSjhLxUlrleeTOpvl4tyS64y4C0o6MjXl5eugTby8sLb29vnJ2dTV64zsfHh6effpqvv/4aRcZFZFUamg59wdXXpHGZncoKpCsnUFyLAWS8vLx45pln6lzoUBAEQTAOkXQLgiAYyO7du/nxxx/p06cPXbt25euvv9Ztc3R0JCwsjIMHD9Y76S4tLSU9PV13PTMzkytXruDg4ICDgwOrV68mKioKZ2dnMjIy+Pnnn2nTpg1du3bVPWbevHn06tVLl+SOHj2aL7/8ksDAQIKCgti0aRNlZWUMHDjw3v4T7oGFhQXe3t54e3vr3S7LMrm5ubrR8Or/srKyqKio0CamtSTkbkqZNkrwVKL76aSoe8V1Y6iUZa5rIEMN6ZWQUan9qbpLnTE7Ozs8PT3x8PDA3d0dDw8PPDw88PLywsHBoXGCb6AePXrw4osv8tNPP5GdnY3y3FZkFx80ft3A0cPU4TVvGjVS2gWk5LNI5doTfr179+axxx4ThVEFQRCaAJF0C4IgGMiff/5Jjx49mD17NgUFBTW2BwYGsnnz5no/76VLl5g7d67u+rJlywAYMGAA06ZNIykpib1791JUVISrqytdunRh4sSJelOIMzIy9No19enTh/z8fFatWoVKpcLf35833njD6NPLG0KSJFxdXXF1dSUsLExvm0ajIS8v77bJeEZGBqWlpWRWQuYt09VtJPC8kYx7W0CIJdgrjJeEZ1bKXCzXJtbpN9Zb11Z6ztHREU9PT72kuirJbuqJ9d107tyZefPmsX79enbs2IEmNwVlbgqyqy+adpEi+a6vSjVSehxS8hldsu3m5sbjjz9u0HoOgiAIwr0RSbcgCIKBpKen8+CDD9a63cHBgcLCwno/b1hYGKtWrap1+5tvvnnX5/jyyy9r3DZixIhGnU5uDAqFAhcXF1xcXOjYsaPetqoR8uTkZFJSUrh27RrJycmkp6dTqtFwVQ1X1UAZSECAhUxnKwi1AgcDJOCZlTLnyuFcec2kH7Rrrdu2bYuPj4/eP3t7+3t+7abM2tqaiRMnMnjwYP744w8OHTqEJicZZU4ysrM3mnYR4OQFYkp07dTlSGnnkVLOIVWUAODq6sqoUaPo169fi+nLHRsby4YNG7h8+TK5ubm8/PLLuiUzoN0HrFq1ip07d1JUVERISAhTp07Fy8tLd5/CwkKWLFnCiRMnkCSJqKgonnrqKWxsbHT3uXr1KosXL+bSpUu6ZTEPP/xwo75XQRCat5axVxbqRaz9EoSGsbOz0xtNvlVKSkqTHEk2V9VHyKtPta+oqCA9PV2XjF+4cIGrV6+SqIZENfxRDO0tZB6xB2dl/feHCRUym4r1E22lUkloaCiBgYG65NrNzc3ka61Nyd3dnSlTpjBq1Cj+/PNPDh8+jEaVilKVitzKA41fJLj4iOS7OnUZ0rUY7T+1tvWeq6srI0eOpF+/fo1eIM/UysrK8Pf3Z/DgwXz44Yc1tv/+++9s3ryZmTNn4uHhwcqVK5k/fz4ff/wxVlba1nWff/45ubm5zJkzh8rKSr766isWLVrE7NmzASguLua9994jPDxcN7Po66+/xt7enqFDhzbq+xUEofkSSbdQQ2O0jxEEcxQZGcnOnTtv258yOTmZnTt3MmjQIBNEJlRnaWmJr68vvr43i3hlZWVx4sQJjh8/zuXLl0lQw0+F8IyjjHU9kr5UtcwvBVCBdo16WFgYPXr0ICIiQqytrYWnpydPP/00Dz/8MFu3bmXfvn2oCzK1a75buWvXfLf05FuXbJ9DUmvb8rRp04YHH3yQ3r17t5iR7VtFRkYSGRl5222yLLNp0ybGjh1Lz549AXj++eeZNm0ax44do2/fvqSkpHD69Gnef/992rdvD8CUKVN4//33eeKJJ3B1dWX//v2o1WpmzJiBhYUFvr6+XLlyhT///LPWpLuiooKKigrddUmSsLW11V0WBHMnfs9rapl7aUEQBCN47LHHePPNN/nXv/5F9+7dAdizZw+7du3iyJEjuLi4MH78eBNHKdyOu7u7brp9WloaH3zwARl5efxZBOPquIy6Upb5pVCbcIeFhfHcc8+JRLse3NzcmDx5MqNHj2bLli3s3rOHioIsbfLt6IkmMKrlrfnWVCKlxiAlndGNbHt7e/O3v/2NHj16tOiZEneTmZmJSqWiS5cuutvs7OwICgoiPj6evn37Eh8fj729vS7hBm2LNUmSSEhIoFevXsTHx9OpUye9Extdu3bl999/p7Cw8LZ1FtatW8eaNWt01wMCAliwYAHu7u5GereC0LRUX8IhaImkWxAEwUBcXV3573//y/Llyzl48CAAf/31FzY2NvTt25fJkyc3es9uof68vLwYMmQIa9eupaieE3+KblQfHzt2rEi4G8jJyYmJEycyYsQIbfK9ew8V+RkoT29A4x6IHNATbFqZOkzjkmWkrESkK8eRSrVFGb29vXnooYfo3r27SLbrQKVSAdrfp+qcnJx021QqVY19slKpxMHBQe8+Hh76J3uqlgmpVKrbJt1jxoxh9OjRuutVo35ZWVmo1bWVUBQE85GWlmbqEBqNhYVFnU6oiaRbEATBgJycnHjuued47rnnyM/PR6PR4OjoKA6Sm5lLly4B4F+Pb0mlJNHOQiZRrX28v7+/cYJrIaqS72HDhrFu3ToOHjyIIisRrl9F064bsk9nUChNHabhFeehSDiApEoFtP8PY8aMoW/fvmI/0kxYWlrWur5eLOETWgLxe15Tk0q6161bx9GjR7l27RpWVlYEBwfz+OOP6/VsLS8vZ9myZRw8eJCKigq6du3K1KlT9YoTZWdn89133xETE4ONjQ0DBgxg0qRJKJVm+OUsCEKTJUa1m6eKigrOnz8PQId61qXqYKktxhYdHc2QIUOMEF3L4+LiwpQpU3jggQdYsWIFFy5cQHHlGHLmRTTB/c1nyrlGg5R8BkXSaZArsbS05MEHH2TEiBFYW1ubOrpmp+q4MC8vDxcXF93teXl5uhNizs7ONYpfVlZWUlhYqHu8s7OzbtS7StV1URhTEIS6alJJd2xsLMOHD6d9+/ZUVlayfPly3nvvPT7++GNd64Yff/yRkydP8tJLL2FnZ8fixYv56KOPePfddwFtz9b3338fZ2dn3nvvPXJzc1m4cCFKpZJJkyaZ8u0JgmBmqq/Zqw+xrrtpu379OuXl5SgAj3qeq/W68a2amppq8LhaOl9fX15++WUOHz7MypUrKShQoTz9BxrfLsh+3Zr3qHdRLoq4PUiF1wFtP/PJkyfXmNYs1J2HhwfOzs5ER0frkuzi4mISEhIYNmwYAMHBwRQVFZGYmEhgYCAA586dQ5ZlgoKCdPdZvnw5arVat6777NmzeHt733ZquaBPo9GIGRqCQBNLum/tNTtz5kymTp1KYmIioaGhFBcXs2vXLmbPnk3nzp0BmDFjBi+++CLx8fEEBwdz5swZUlJSeOutt3B2dsbf35+JEyfyyy+/MGHChBZb4bM+RMVBQaib1atXN+hxIulu2tzd3bG1taWkpIQramhfj9HuSzcKFvv5+RknuBZOkiTuu+8+wsPDWbFiBYcOHUKRfAY5JwlNyGCwd7n7kzQlsox0LQbF5aMga7Czs2Py5MlERUWJ7+I6KC0tJT09XXc9MzOTK1eu4ODggJubGyNHjmTt2rV4eXnh4eHBihUrcHFx0VUz9/HxISIigkWLFjFt2jTUajVLliyhT58+uLq6AtCvXz9Wr17NN998w8MPP0xycjKbN2/mySefNMl7bk4uXbrExx9/zLhx4xg8eLCpwxEEk2rSGWhxcTGA7kxiYmIilZWVhIeH6+7Ttm1b3NzcdEl3fHw87dq105vyExERwffff09ycjIBAQE1Xke0dqippb5vQaiPlStXmjoEwQiUSiXdunXjwIEDrCmE6U4yjoq77xPjy2X2l2ovV1WvF4zDwcGBqVOn0q1bN5YtW0ZBQS7KU+vRBPZG9gppHu3FyktQxO9DykkGoEuXLjz55JNiynI9XLp0iblz5+quL1u2DIABAwYwc+ZMHn74YcrKyli0aBHFxcWEhITwxhtv6Hp0A8yaNYvFixczb948JEkiKiqKKVOm6Lbb2dkxZ84cFi9ezGuvvUarVq0YN26c6NFdBytWrKC0tJRffvlFJN1Ci9dkk26NRsMPP/xAx44dadeuHaBdQ2NhYYG9vb3efW+tRHnrF1ZV5cpb1+RUEa0d9Lm4uIhS/4IgtGiPPfYYly9fJjU1lR8K4B+t7px4J1bIrCgEGe3IWFRUVOMF24J169aN9u3bs2TJEs6dO4ci4QCavHTk4H6grOeC/MaUl47i/C6k8mIsLCyYOHEigwYNEie86yksLIxVq1bVul2SJCZOnMjEiRNrvY+DgwOzZ8++4+v4+fkxb968BsfZUhUWFpo6BEFoMpps0r148WKSk5MbZScnWjvoU6lULarUv9Cy1LW1g9Cy2dnZMWvWLBYsWEBmbi7f58OUVjLOyppJUXy5zK+FoAZCQ0N54oknRPLUiJycnJg9ezbbt2/XnkDPuoRcdB1N6FCwczZ1ePpkGSk1BkXiEZBlvLy8eO655/Dx8TF1ZIIgCIIRNcmke/HixZw8eZK5c+fSunVr3e3Ozs6o1WqKior0Rrvz8vL0qkwmJCToPV9eXp5u2+2I1g76NBpNi3zfgmAIV69eZfPmzVy+fJni4uIaf0uSJPHFF1+YKDqhPtzd3fn3v//Nhx9+SHZ2Nj8XwjRHGetqCXWaWjvCrQa6du3K9OnTRe0QE1AoFAwfPpzAwEC++eYbVCoVilMb0IQOBpcmktBqKpESDqBIjwegV69ePPnkk7pCsYIgCIL5alLlBGVZZvHixRw9epS33367RtXOwMBAlEol0dHRuttSU1PJzs4mODgY0FaZTEpK0iXaoK0yaWtrK84kC4JgVDExMbzxxhucPHkSFxcXMjMz8fT0xMXFhaysLGxsbOjUqZOpwxTqwd3dnVdffRVHR0fSK2FttdmSpbLMz4VQjnaEe8aMGbWewBUaR4cOHXj77bcJCgpCqixHeW4rUtoFU4cF6nIU0ZtRpMcjSRITJkzgmWeeEQm3IAhCC9Gkku7Fixfz119/MXv2bGxtbVGpVKhUKsrLywHtdL/BgwezbNkyzp07R2JiIl999RXBwcG6pLtr1674+PiwcOFCrly5wunTp1mxYgXDhw8XB0OCIBjVqlWr8PDw4NNPP2XGjBmAdvnKu+++y3vvvcf169e57777TBylUF+tW7fmhRdeQJIkYiogu1I7e+F0GeRpwM3Njeeee06McDcRTk5OvPzyy/Tp0wdkGcXF/UhJZ8BUM7jKi1Gc2YiUl46NjQ2zZ89m+PDhYgmCIAhCC9KkjhC2bdsGwDvvvKN3+4wZMxg4cCAATz75JJIk8dFHH6FWq+natStTp07V3VehUPDaa6/x/fffM2fOHKytrRkwYMAdi2gIgiAYQmJiIhMmTMDOzk5XQEaj0QDaEbgHHniAlStXEhkZacowhQYIDAykS5cunDlzhtNlMNROm3QDDBs2rEaBT8G0LC0tmTJlCi4uLmzcuBHFlWNoZA2yXyP/7VWUoji7CalYRatWrXjxxRdFOzlBEIQWqEkl3XeqQFnFysqKqVOn6iXat3J3d+f11183ZGiCIAh3pVQqde0G7e3tUSqVektdPDw8SElJMVV4wj3y8/PjzJkzFN8YMC2Sb94uND2SJDF27FhsbW1Zs2YNiqsn0FhYIbcNa5wA1OUoorcgFatwcXHhlVdewdPTs3FeWxAEQWhSmtT0ckEQhOasTZs2usr/kiTRtm1bjh49qtt+8uRJ0YO3GSst1TbhVt64bnHL7ULT9OCDD/LQQw8BoLh0GHIa4cSXLKOI24tUmI2DgwMvvfSSSLgFQRBaMJF0C4IgGEhkZCQHDhygsrISgFGjRnH06FFmzZrFrFmzOHHiBEOHDjVxlEJDXb58GYA2N7Ltqp9VtwtN10MPPcT9998PyCgu7IbSAqO+npR8Bun6VSwsLJg9ezbe3t5GfT1BEAShaWtS08sFQWg8a9eupaSkhMmTJ5s6FLMxbtw4Ro4ciUKhPZ85cOBAFAoFR44cQaFQMHbsWF19CqF50Wg0XL16FQDfG9+cvhYQXS6S7uZAkiQmT55MSkoKly9fRhG3D02XkWCMYmYF2SiungDg8ccfJzAw0PCvIQiCIDQrIukWhBZIo9GwceNGQFsEyt3d3cQRmQcLCwtatWqld1v//v3p37+/iSISDCU9PZ3y8nKsALcbc8S8b8wzT0pKMllcQt1ZWloybdo03nnnHcrz0pDSziN7hxr2RTQaFHF7QZbp0aMH/fr1M+zzC4IgCM2SmF4uCC1cRUWFqUMwG4WFhbrR0NtJSkrSVTUXmpeqddt2ClDcGB11UOhvE5o+T09Pxo8fD4B0+TiUlxj0+aXUc0jFuTg4OPD444+LtmCCIAgCIJJuQWjxxEGh4fzwww98++23tW7/9ttv+emnnxoxIsFQlErtsHa5DPKNfs/lsv42oXkYNGgQfn5+SJXlSFeOG+6Jy0uQrp4CYPz48TVmvQiCIAgtl0i6hRpEEmb+qpKGWy8L9yYmJobu3bvXur179+5ER0c3YkSCoXh5eaFUKimWIUfbep1ktfZnu3btTBeYUG8KhYJJkyZpL6fHQ1GOQZ5XunoSqbICPz8/+vbta5DnFARBEMyDSLqFGkQSJggNk5+fj6OjY63bW7Vqpde3W2g+rKysaN++PQAXbqzIqPrZsWNHE0UlNFRQUBDdunUDZBRXT977E5YWoEi/AMCECRN0xRQFQRAEAUQhNUEQBINxdna+YyXrxMTEOybltYmNjWXDhg1cvnyZ3NxcXn75ZXr16gWAWq1mxYoVnDp1iszMTOzs7AgPD2fSpEm4urrW+pyrVq1izZo1erd5e3vz6aef1ju+lqJnz57Ex8dzpgy6Wslcqrh5u9D8jBkzhlOnTkH2FSi8Dg6tG/xcUtJpkGVCQ0MJCQkxWIyCIAiCeRCnYoUaxPRy81f9Mxaft+H07NmTXbt2cfx4zXWix44dY/fu3bpkuT7Kysrw9/fn6aefrrGtvLycy5cvM27cOBYsWMC//vUvUlNT+d///nfX5/X19eXbb7/V/Zs3b169Y2tJevbsiSRJpFbCoVLQAP7+/nh6epo6NKEBvL296dGjBwBSyj0s+ygvRpFxEdD2AxcEQRCEW4mRbqEGMb3c/Ik13cYxYcIEoqOj+eCDD/D398fX1xeA5ORkrly5go+PDxMmTKj380ZGRhIZGXnbbXZ2drz11lt6t02ZMoU33niD7Oxs3Nzcan1ehUKBs7NzneOoqKjQq3YvSRK2tra6y+bO0dGR4OBg4uLi2HujYHm3bt1axHs3Vw8++CDHjh1DkXWJysBeYGVX7+eQ0i6ArCEoKIjg4GAjRCkIgiA0dyLpFgRBMBA7Ozvmz5/Phg0bOHLkCIcPHwa0bYrGjRvHQw89hI2NjdHjKC4uRpIk7OzunECkp6fz7LPPYmlpSXBwMJMmTbpjkr5u3Tq9KekBAQEsWLCgRfV5j4iIIC4uTne9d+/eeHl5mTAi4V54eXnRsWNH4uLikDIvIfuE1+8JZBnpxij3mDFjxO+CIAiCcFsi6RYEQTAgGxsbJkyY0KARbUMoLy/nl19+oW/fvndMujt06MCMGTPw9vYmNzeXNWvW8Pbbb/PRRx/pRq9vNWbMGEaPHq27XjXCm5WVhVqtNuwbaaIcHBz0rltYWJCWlmaiaARD6NGjhzbpzr5S/6S7KAeptABra2sCAwPN6nfBwsKiRZ1QEwRBMCaRdAs1iKmSgmBYGRkZVFRU4OPjY9TXUavVfPLJJwBMnTr1jvetPl3dz89Pl4QfOnSIwYMH3/YxlpaWWFpa3nZbS1mmcOv7t7S0bDHv3VyFh99ItAsyobIClLf/Hb8dSZUKQHBwMFZWVuJ3QRAEQbiteifdGo2G/Px87OzssLKyMkZMgomJgwbzJ06sGMemTZuIj4/nn//8p+62L7/8kn379gHa6divv/46Tk5OBn/tqoQ7Ozubt99++65Ty29lb2+Pt7c36enpBo/NnFRf036760Lz4+7uTqtWrSgoKICSPHCofYlFDUW5ALp2ckLTotFoWLVqFX/99RcqlQpXV1cGDBjAuHHjdN+DsiyzatUqdu7cSVFRESEhIUydOlVvqUBhYSFLlizhxIkTSJJEVFQUTz31VKMsFxIEwTzUuXq5LMv8+uuvPPXUUzz77LM8+eSTfPDBBxQWFhozPkEQhGZj165degn16dOn2bdvH0OHDmXKlClkZGSwevVqg79uVcKdnp7OW2+9RatWrer9HKWlpaSnp9ersFpLVFBQcMfrQvPUuvWNdmFlRfV6nFRWqP94oUlZv34927dv5+mnn+aTTz5h8uTJbNiwgc2bN+vu8/vvv7N582amTZvGf/7zH6ytrZk/fz7l5eW6+3z++eckJyczZ84cXnvtNc6fP8+iRYtM8ZYEQWim6px079mzh99//x07OzuioqJo164dx48f56uvvjJmfIIJiFFQQWiYrKws2rZtq7t+6NAhPDw8mDZtGsOHD2fEiBHavsD1VFpaypUrV7hy5QoAmZmZXLlyhezsbNRqNR9//DGJiYm88MILaDQaVCoVKpVKb531vHnz2LJli+76smXLiI2NJTMzk7i4OD744AMUCgX9+vVr+H9AC3DriWZx4tk83Ov3nvjebJri4+Pp0aMH3bp1w8PDg969e9OlSxcSEhIA7YDSpk2bGDt2LD179sTPz4/nn3+e3Nxcjh07BkBKSgqnT5/mueeeo0OHDoSEhDBlyhQOHjxITk6OKd+eIAjNSJ2nl2/btg1/f3/effdd3bTypUuXsnXrVvLz83F0dDRakELjEtPLBcEwzp49q+sDDNpprCqVqt7Pc+nSJebOnau7vmzZMgAGDBjAo48+qusL/uqrr+o97v/+7/8ICwsDtOvK8/PzddtycnL47LPPKCgowNHRkZCQEObPny/25Xchkm7zpPsc67GeGwAL7fGQmPHQNAUHB7Nz505SU1Px9vbmypUrxMXF8fe//x3QnsBUqVR06dJF9xg7OzuCgoKIj4+nb9++xMfHY29vr7eEIDw8HEmSSEhIoFevXjVet6W3V7ydlvq+WyrxeddU56Q7IyOD8ePH663jHj58OFu2bCE9PV0cqJkR8Ydi/sSJFePw8vLi2LFjDBs2jNOnT5OTk6NXsCwnJwd7e/t6P29YWBirVq2qdfudtlX58ssv9a5XX3cu1N2ta7hbStV2c1ZQUEBWVpb2in39ponL9q2Rsm/OQhGalkceeYSSkhJefPFFFAoFGo2Gxx57jPvvvx9AdxL01jobTk5Oum0qlarGMa5SqcTBwaHWk6iivaKWUqnUXRbt9FoW8XnXVOeku6ioqMZOp2rdYPV1L0LzJxKylkWcZDGcv/3tb3z++ec89dRTlJaW4uPjQ9euXXXbz507h7+/v+kCFO6Z+HsxP1XTiGV7F7C0rtdjZac2AJw5c4bS0lJRWKuJOXToEPv372fWrFn4+vpy5coVfvjhB1xcXBg4cKDRXle0V9SqrKzUXTandnrC3bWkz7uu7RVFyzBBaOHESRbD6du3L61ateLkyZPY29szfPhw3Zn+wsJCHBwc6N+/v4mjFO6FtbV+UiaSrOZNrVaza9cuAOQ2Hev/BE5tkG0cKS3NZ//+/QwdOtTAEQr34ueff+bhhx+mb9++ALRr146srCzWr1/PwIEDdYUj8/LycHFx0T0uLy9Pd4LU2dlZb2kOaJPJwsLCWgtPivaKNbXU991Sic+7pnol3b/++ivr16/XXddoNAAsWrSoxoGIJEl88MEH9x6hIAhCM9KlSxe99YFVHBwcePnll00QkWBIVesyq4iku3nbvXs3aWlpyJY2yJ4d6v8EkoTsE46UcIDff/+dqKioBnUPEIyjrKwMhUK/ZrBCodAlBB4eHjg7OxMdHa1LsouLi0lISGDYsGGAdl14UVERiYmJBAYGAtpZS7IsExQU1HhvRhCEZq3OSXenTp1uO63OGP1mBUFoPGK6rCDUXfW6Jre7LjQfKSkp/PbbWgBk/x5gUb+p5VVkr47IaecpLsph6dKlPP/88zUSPcE0unfvztq1a3Fzc8PHx4crV67w559/MmjQIED7/Tdy5EjWrl2Ll5cXHh4erFixAhcXF3r27AmAj48PERERLFq0iGnTpqFWq1myZAl9+vTB1dXVlG9PEIRmpM5J9zvvvGPEMARBaEwi0RaEhrm1homoadI8FRUV8fXXX1NRUY7s0rZhU8urSAo0HfujPPUHZ86cYfPmzYwaNcpwwQoNNmXKFFauXMn3339PXl4erq6uPPDAA4wfP153n4cffpiysjIWLVpEcXExISEhvPHGG3on1GbNmsXixYuZN28ekiQRFRXFlClTTPGWmhVxrCEIN4k13YLQwol1N4JQd6mpqTWuh4SEmCgaoSEqKipYuHAh6enpyFZ2aDoOhHtNDhzc0ATdh+LiftauXYuLiwt9+vQxSLxCw9na2vKPf/yDf/zjH7XeR5IkJk6cyMSJE2u9j4ODA7NnzzZChIIgtBQGmf+UnJzMtm3b2LBhA2fOnDHEUwqCYEQi0RaE+ispKeHChQsAhN6okXTq1CkTRiTUl1qt5ptvviE+Ph5ZaYmm83Cwsr37A+tA9gpB4xMOwNKlSzl9+rRBnlcQBEFo/uo80q3RaPj11185cOAACoWCgQMH8uijj/Ljjz+yadMmvftWTc25tbia0DyI6UCCIAg1bdmyhdLSUtwUMMwOLuRBbGws8fHxBAcHmzo84S4qKyv57rvvtMmwpEQT9gA41K8v993IAb3QlBdD5iW+/vprnn/+ecLDww36GoIgCELzU+eke9u2bfzxxx+0b98eJycn1q1bR35+Ptu3b2f48OGEh4dTWVnJ8ePH+euvv/jtt9+YNGlSvYKJjY1lw4YNXL58mdzcXF5++WV69eql2/7ll1+yd+9evcd07dqVN998U3e9sLCQJUuWcOLECd26m6eeekpUmK0HMQoqCIKgLyUlhS1btgDahNtNKdHDWuZoGfz000+89dZboqhaE6bRaFi8eDHHjx8HSUFl2FBw9jb8C0kScscByJpK1NlX+PLLL5k1axahoaGGfy1BEASh2ahz0r1r1y4iIyN57bXXAO0Z/6VLlzJ8+HC9YhK9e/emrKyMw4cP1zvpLisrw9/fn8GDB/Phhx/e9j4RERHMmDHj5huw0H8Ln3/+Obm5ucyZM4fKykq++uorFi1aJNbi1IMY6RaEhisvL+fIkSNcvnyZ4uJiXWvFKpIkMX36dBNFJzSEWq3mu+++Q61WE2wJnW5MLR9iC7Hl2nXda9asqfd3ntA4ZFlm2bJlHDlyBCSJyk5DwNXXeC8oKdCEDEJxficV15P44osveOmll+jQoQEtyQRBEASzUOekOyMjg6FDh+qud+vWjaVLl9K5c+ca9w0PD+fEiRP1DiYyMpLIyMg73sfCwgJnZ+fbbktJSeH06dO8//77tG/fHtBWrnz//fd54oknRGuHOhIj3eav+mcsTrIYTlZWFnPnziUrKws7OzuKi4txcHDQJd+tWrUSs26aoa1bt5KSkoKdBGPtb/7N2CskxtrLLCvUnpju3bu3ro+v0HSsWbOGv/76C5CoDBkEbn7Gf1GFEk2nIShitlOem8Jnn33Gv//9b3x9jZjsC4IgCE1WnQuplZaWYmdnp7tua6stPFL9turbKisrDRBeTbGxsUydOpXZs2fz3XffUVBQoNsWHx+Pvb29LuEG7QkASZJISEio9TkrKiooLi7W/SspKdFtkySpxfxrie+5Jf+rztSxmOp9G9pPP/1EcXEx8+fP57PPPgPgxRdfZNmyZUyePBkrKyu95TBC05efn88ff/wBwEg7cFDo/w4FW0lEWGlPZC1fvtwUIQp3sHPnTt2yAE3w/eDeiCdFFEo0oUORHT0pKSnhk08+ITc3t/FeXxBMTAziCMJNzaplWEREBFFRUXh4eJCens7y5cv5z3/+w/z581EoFKhUKhwdHfUeo1QqcXBwQKVS1fq869atY82aNbrrAQEBLFiwAHd3d2O9lSbNxcUFLy8vU4chGFFFRYXusru7u/i8DSQmJoZhw4YRFBREYWEhoD3osLS05KGHHiIlJYUffviB119/3cSRCnUVGxtLRUUFbZTQtZYl28Pt4HQ5JCYmUlBQQKtWrRo3SOG2YmJidCdCNP49kduYoNid0gJN2DAUZ/4gL0/FwoUL+fe//y3W/wuCILQw9Uq6T548qUtey8rKADh06BBXrlzRu19iYqJBgrtV3759dZfbtWuHn58fL7zwAjExMfdUHXTMmDGMHj1ad71qNCwrKwu1Wt3wgJup3Nxc0tLSTB2GYETVf6+zs7OxtLQ0YTSNy8LCwmgn1MrKyvDw8ABuzgYqLi7WbQ8ODuann34yymsLxlH1/eZnUftSjFYKCTeFTLZGe39Rrdr0cnJyWLRoEbIso/HsgOzbxXTBWFprE+9Tv3PlyhV+/fXXO/aNNmfZ2dmsXbuWmJgY8vPzeeWVVwgNDSU/P581a9YwaNAgAgICTB2mIAiCwdUr6T5w4AAHDhzQu23Hjh0GDag+PD09adWqFenp6YSHh+Ps7Ex+fr7efSorKyksLKx1HTiApaVlrUlHS50a01Lfd0tRvbiXRqMRn7eBuLm5cf36dUA7y8bV1ZWLFy8SFRUFaOtOiBGu5sXNzQ2AXE3t91HLMqob21vqDKmmpLKykm+//ZaioiJkBzfkDv3AyEtL7srWEU2nwSijN/PXX3/RqVMn3X6hpUhJSeHtt99GlmWCgoJIT0/XfRc5OjoSFxdHWVmZKDQpCIJZqnPSvXDhQmPG0SDXr1+nsLAQFxcXQDuKVFRURGJioq6Yzblz53Q7eKFuRAImCA3TuXNnjh8/zqOPPgrAwIEDWb9+PYWFhciyzL59+xgwYICJoxTqo2PHjgAkVMD1SpnWyprJ2+kyUKNNHDw9PRs5QuFWmzZt4uLFi8hKSzSdBoNCaeqQtFzaomkXiSLpFMt++on27dvrTuq0BD///DP29vbMnz8fgGnTpultj4yM5NChQ6YITRAEwejqnHQ3xtn70tJS0tPTddczMzO5cuUKDg4OODg4sHr1aqKionB2diYjI4Off/6ZNm3a0LVrVwB8fHyIiIhg0aJFTJs2DbVazZIlS+jTp4+oXC4IgtE98sgjJCQkUFFRgaWlJWPGjCE3N5cjR46gUCjo168ff//7300dplAPvr6+hIeHEx0dzfYSeMxBf3u5LLPzRu3NkSNHGr1Yn3BniYmJbNiwAQA5qC/YOt7lEY1L9otEVl2jND+T77//nldffRWFos41bZu18+fPM27cOBwdHfWK4FZxc3MjJyfHBJEJgiAYX5MqpHbp0iXmzp2ru75s2TIABgwYwLRp00hKSmLv3r0UFRXh6upKly5dmDhxot7U8FmzZrF48WLmzZuHJElERUXp9REX7k4cNLYs4vM2HDc3N72RKysrK5577jmee+45E0Yl3Kvx48dz7tw5zpXLXFPLtLW4+TdzuBQKZO1nP3DgQNMFKVBSUsK3336LRqNB4x6I7NH+7g9qbJICTceBKE6u4+LFi2zcuJG//e1vpo6qUWg0GqytrWvdnp+fj4VFkzosFQRBMJgmtXcLCwtj1apVtW6vS6sdBwcHZs+ebciwWhwxvdz8Vf+MxectCHfm4+NDVFQUhw8f5mApPHpjtFuWZQ6Wai8//PDDLaogYVMjyzI//fQTWVlZyNYOyB36mn4dd21sHZGD+iDF7WXDhg2EhITQoUMHU0dldIGBgZw8eZLhw4fX2FZZWcnBgwcJDjZBhXlBEIRG0KSSbqFpECOf5k8k2sZTWlrKkSNHyMjI0BZyuuX/WpIknnrqKRNFJzRUr169OHz4MBmVN28rkqFQ1n6mPXr0MF1wAnv37uXIkSMgSWhCBoJF7SOqTYHsEYQm9xpkJvDNN9/wzjvvmH2ruUceeYT//ve/fPfdd7puNCqVirNnz7Ju3TquXbsmZiYKgmC2RNIt1CASMvNX/TMWJ1kMJzo6mo8//livTdjtiKS7+an6OymptnusuqxUKvU6AgiN68qVK3r9uHFqY+KI6kCSkDv0RS7IQqVS8e233/Liiy+a9fruyMhIZs6cydKlS3Wdb7744gtA22Jx5syZhIaGmjJEQRAEoxFJt1CDSMLMn5hebhyLFy/GxsaGF198kaCgIOzs7EwdkmAAsiyzd+9eAEKqzSB3U0BrBVxXqzl48CCDBw82UYQtV3FxMV9//TVqtRq5dTtkn2bUI11piSZ0KMpTvxMbG8uGDRt45JFHTB2VUfXv359evXpx9uxZXcuwqoK4tra2pg5PMDBxPCkIN4mkW6hBJGGC0DDZ2dlMnjyZLl26mDoUwYB27drF6dOnkYAe1WYtS5JELxuZzcWwatUq2rdvj5+fn8nibIl+/vlnsrOzkW1aoek4oOmu466NvQuaDv1QxO3hzz//JCwszOzXd9vY2NCrVy9ThyE0AnE8KQg3NWge04oVK3jllVdq3f7qq6+yevXqBgclCELjEWeiDcfPz++uU8uF5iUmJoYVK1YAMMIWvCz0/17us4ZgS6ioqGDhwoWoVCoTRNkynT59uto67kFNfh13bWTPIDQeHZBlmSVLlqBWq00dklFkZ2dz4cIFvduuXLnCwoUL+eSTTzh69KiJIhMEQTC+BiXdhw8fJjIystbtkZGRHDx4sMFBCY1PrPFtucSZaMOZPHky27Zt49KlSwZ93tjYWP773//y7LPPMmHChBoHp7Iss3LlSp555hkmT57Mu+++S1pa2l2fd8uWLcycOZPJkyfzxhtvkJCQYNC4m7vU1FS+/uorNBoNEVbQx6bmfRSSxKP22qnmOTk5fP7555SVlTV+sC1MZWUla9asAUDjEw6OHiaO6N7IQfchW9qSmZnJnj17TB2OUSxZskRvQEalUjF37lyOHDnC+fPn+eijj7QnUQRBEMxQg6aXZ2dn4+npWet2Dw8PsrOzGxyU0PjEGl9BuHehoaE8+eSTzJkzh7Zt29K6desahZEkSeLVV1+t1/OWlZXh7+/P4MGD+fDDD2ts//3339m8eTMzZ87Ew8ODlStXMn/+fD7++GOsrKxu+5wHDx5k2bJlTJs2jQ4dOrBx40bmz5/Pp59+ipOTU73iM1fLly+npLQUfwt4xL72E5K2CoknWsksyoerV6+ye/duRowY0cjRtiyxsbGkpaUhW1gj+0aYOpx7Z2GF7NcNKeEAO3fuZOjQoaaOyOAuXbrEgw8+qLu+b98+ysvL+eijj/Dw8OA///kPf/zxB1FRUSaMUhAEwTgalHTb2NiQlZVV6/bMzEzRr7SZqT6dTYx0mz9xYsU4Dh8+zBdffIFGo+H69euUlJTUuE9D/r4iIyNrnV0kyzKbNm1i7Nix9OzZE4Dnn3+eadOmcezYMV1rnlv9+eefDBkyhEGDBgEwbdo0Tp48ye7du2st5lRRUUFFRYXee6kqfmRu+42rV68SGxuLAhhnDxZ3eX+tlRIj7GTWFsHWrVsZNmwYSqWycYJtgaKjowGQ3QLA4vYnlpob2aM98qVDZGZmkpGRQZs2zaAKez0UFhbqndA7ceIEoaGhuvfZq1cvXRV6QRAEc9OgpDs0NJQdO3YwbNgwXF1d9bZlZ2ezY8cOwsLCDBKg0Diqt7sRCZn5E8sJjOPXX3/F29ubf/3rX3h7ezfKa2ZmZqJSqfSKt9nZ2REUFER8fPxtk261Wk1iYqJecq1QKAgPDyc+Pr7W11q3bp1uSi9AQEAACxYswN3d3TBvpgm5ePEiAG2U4KKs299IpxvnmvPz83F2dsbBwcFY4bV4+fn52gutzOh3z8IK7JyhKAe1Wo2Xl5epIzIoR0dH3YBNUVERFy9eZNKkSbrtGo3GKK33cnJy+Pnnnzl9+jRlZWW0adOGGTNm0L59e0D7fbhq1Sp27txJUVERISEhTJ06Ve//v7CwkCVLlnDixAkkSSIqKoqnnnoKG5vbrDkRBEG4jQYl3Y899hivv/46L730EoMHD8bHxweA5ORkdu/ejSzLTJw40aCBCsYlEu2WRZxkMY7c3Fwef/zxRku4AV3hrlunhDs5OdVa1Cs/Px+NRoOzs7Pe7c7OzqSmptb6WmPGjGH06NG661UnbLKyssyu+FPVCH5WJRRoZFop7p54J974L3BycqKgoICCggJjhtiilZeXay/IZtYf/cb+WKVS1akugzFZWFgY9IRaeHg4mzdvxs7OjpiYGGRZ1qtinpKSQuvWrQ32eqBNlt966y3CwsJ44403cHR0JC0tDXt7e9196rI85/PPPyc3N5c5c+ZQWVnJV199xaJFi5g9e7ZB4xUEwXw1KOn29vZm3rx5LFmyhI0bN+pt69SpE0899ZQuEReah+pJmBj5NH/GGE0QoH379mZdz8LS0rLWpUPmdvLGy8sLX19fkpOTWV0IT7aSUd5h35inkfm9SHs5KirK7P4/mhovLy/OnDkD+Zng3cnU4RhGRSlSsQqANm3amN3v0KRJk0hLS+Onn37CwsKCJ554Ag8PbQG8iooKDh06VOtymIb6/fffad26NTNmzNDdVvWaULflOSkpKZw+fZr3339fNzo+ZcoU3n//fZ544okaMz6r3k9LWYpTVy31fbdU4vOuqcF9uv38/Jg7dy75+flkZmYC2h2Zo6OjwYITGk9lZaXusrl90Qs1VU+6RQJuOFOmTGHBggUEBATQp0+fRnnNqtHqvLw8XFxcdLfn5eXh7+9/28c4OjqiUChqjISrVKoao98tlUKh4Nlnn+Xdd98lsayM34vgEXsZxW0OJIo1Mj8WQLEM7dq1Y+zYsSaIuGUJDw9ny5YtSNevIqvLzWJdt5SVCMi6IozmxtnZmXfffZfi4mKsrKywsLh5CCrLMm+99RZubm4Gfc3jx4/TtWtXPv74Y2JjY3F1dWXYsGG6QnV1WZ4THx+Pvb29LuEG7e+fJEkkJCTctud4S1qKcyfVP2NzWy4h3Jn4vGtqcNJdxdHRUSTaZqD61FBzmyYq1FQ90a5+wkW4N59//jmVlZV89tlnLFq0qNbq5R988IHBXtPDwwNnZ2eio6N1SXZxcTEJCQkMGzbsto+xsLAgMDCQc+fO6Q4YNRoN586dE1W3q/Hy8mLq1Kl8/fXXnCzXYKeAEXb696mQZZYVQGaldlr5jBkzRCHRRhAcHIyXlxdpaWlIqTHI7WpvY9osaCqRks8CMHDgQNPGYmR2dnY1brOysqr1JOG9yMzMZPv27YwaNYoxY8Zw6dIlli5dioWFBQMHDqzT8hyVSlXjOFepVOLg4FDrEp6WtBTnTqq/V1MvlxAaV0v6vOu6FKdOSffevXsB6N+/P5Ik6a7fzYABA+p0P8H0RNLdslRPtEXSbTgODg60atXK4Gd4S0tLSU9P113PzMzkypUrODg44ObmxsiRI1m7di1eXl54eHiwYsUKXFxcdNMlAebNm0evXr10SfXo0aP58ssvCQwMJCgoiE2bNlFWVmb2B/z11a1bN5566ikWL17M/lLws5DpZHVztHtLMaRUgr29PS+//HKLG8kyFYVCwejRo/nuu++Qks8itwkBK1tTh9VgUmosUpm2uvf9999v6nCMpri4mI0bN3Ly5EndUhw3Nze6d+/OyJEjb5uQ3wuNRkP79u11BdsCAgJISkpi+/btRt3XtaSlOHXVUt93SyU+75rqlHR/9dVXAPTt2xcLCwvd9bsRSXfzIZKwlkVXhAj01p0J9+add94xyvNeunSJuXPn6q4vW7YM0O5jZ86cycMPP0xZWRmLFi2iuLiYkJAQ3njjDb0e3RkZGTcrPgN9+vQhPz+fVatWoVKp8Pf354033hDTy2+jT58+JCcns23bNtYVQXtLGStJ4kqFzJEy7X2mTZvWqAX0BG2Lqa1bt5KUlISUdAo5qHGWdBhcRRlS0ilAO0JqrjMlcnJy+L//+z8yMzPx9vamY8eOAKSmprJ69Wr27t3LvHnz9JbJ3CsXF5caNYZ8fHw4cuQIULflOc7Oznr7TtAeJxUWFor9pSAIdVanpHvhwoXaO99Ym1F1XTAf1Ue3RdJt/qp/3iLpbvrCwsJYtWpVrdslSWLixIl37Brx5Zdf1rhtxIgRYjp5HY0bN44TJ05w/fp1LlZAmBWcuXHuqk+fPoSHh5s2wBZIoVAwYcIEPvzwQxRpF6hs2xlsm99yNynlDJK6nLZt2xq8kFhT8ssvv6BSqfj3v/9Nt27d9LadOnWKjz/+mF9++YXnn3/eYK/ZsWPHGh0ZUlNTdTNS6rI8Jzg4mKKiIhITEwkMDATg3LlzyLJMUFCQwWIVBMG81SnpvnW6nJg+Z36qJ14iCTN/4iSL8Wg0Gvbt23fb6ZP3339/jTXeQvNgYWFBREQEO3fu5PKNpPvyjV1ljx49TBtcC9apUydCQ0OJjY1FSj6DHNzMpmZXlCFdiwW0J3bMef9w+vRpRo4cWSPhBoiMjOTBBx9k586dBn3NUaNG8dZbb7F27Vr69OlDQkICO3fu5JlnngG0JyzvtjzHx8eHiIgIFi1axLRp01Cr1SxZsoQ+ffrctnK5IAjC7dxzITXBPIiku2URI93GUVxczPz580lISMDW1hZPT08AoqOjOXLkCNu2bePNN980+LpFoXEolUoALG4s6a76WXW7YBqjR4/WJt2ZCcgBPcHSxtQh1ZmUHoekUePr66tXQdsclZWV1ShYVp2zszNlZWUGfc2goCBefvllfv31V3777Tc8PDx48skn9dbN12V5zqxZs1i8eDHz5s1DkiSioqKYMmWKQWMVBMG81Snprr6WsK4kSeLtt9+u9+ME06j+RVdaWmrCSITGUD3RFoXzDGf58uUkJiYyZcoUhgwZoluSo1ar2bVrF0uXLmXFihXiYK2ZqqrG6nhjMNJRAemV2ts7d+5swshatuDgYHx8fEhJSUHKvors1dHUIdWZlJkAwKBBg8y+r62Pjw8HDhxg2LBheq2kQLuPPHDgQI3114bQvXt3unfvXuv2uizPcXBwYPbs2QaPTRCElqNO85gaUoFOVK1rXgoLC3WXi4qKTBiJ0BiqJ93Vi6oJ9+bo0aMMGzaM4cOH6x1UWlhYMGzYMB544AFdAR+heVGr1cTFxQEQeOOjrfoZGxtroqgE0CZNVUmVlJNk4mjqobQQqSgHSZJuO+Xa3Dz88MMkJCTw+uuvs2PHDmJiYoiJiWH79u288cYbJCQk8Mgjj5g6TEEQBKOo00i3sSryCk1HSUmJ7nJxcbEJIxEagxjpNo7CwsI7VrBu27at3gkuoflISkqivLwcOwk8b8wmD7QESiAhIQGNRmPW63GburCwMH7//XfIzwBZhuYwalyQCYCfnx+tWrUycTDGd99991FWVsYvv/zCd999p7fN0dGR6dOn07t3bxNFJwiCYFxiTbcA6I9ui5Fu8yfW8BtHmzZtOH78OMOHD7/t9uPHj+vWeQvNS1KSdgTVxwLdNGBPpfZLtLi4mOzsbDw8PEwYYcvm4+Oj/VwqSrX/mkHPbqkoB4B27dqZOJLGM3DgQO6//34uXbqkV2iyffv2ojaCIAhm7Z6S7tjYWE6ePElWVhagrWrerVs3QkNDDRKc0HhUKpXucl5enukCERpF9SnlYnq54QwbNowlS5bw/vvvM3LkSLy8vABti5rNmzdz9uxZnn76aRNHKTRE1ckpm2oDqEpJwlKSUctixoipWVtb06pVK20/5fLiZpF0U6adVda6dWsTB9K4lEolwcHBBAcHmzoUwcjMvU6BINRHg5JutVrNp59+yrFjxwB0lXiLi4v5448/6NWrF7Nnz65RKENouqon3bm5uaYLRGgUYmaDcQwfPpy8vDx+//13Tp8+rbfNwsKC8ePH63q/Cs2LtbU1AIWam7dVyDLlN8qXVK90LJiGvb29NulWG7YCtrFIN+K0t7c3cSSNY//+/Zw5c4aZM2fedvtXX31FREQEffr0aeTIBGMR9Z0E4aYGZcWrV6/m2LFj/O1vf2P06NE4OzsD2hHSP/74gz/++IM1a9bw2GOPGTJWwYiqJ91FRUWUl5eLg0gzVjWtD9DNVBEMY8KECYwYMYLo6Gi9WUDh4eE4OjqaODqhodq3bw9AslqbbFtKEklqqETb6qiljVY2bc1kdO3GKGBLSUw2btxIQEBArdutrKzYuHGjSLoFQTBLDUq69+/fz4ABA3j88cf1bndycuLxxx8nLy+Pv/76SyTdzUj1JAwgJyeHNm3amCgawdiqWh/delkwDEdHR/r27WvqMAQD8vb2xtnZGZVKxcUKCLWCmBsrM8LCwsQ0yiZAV6TQwtK0gdSRrLRCouXMNkpNTWXQoEG1bvfz8+PAgQONGJEgCELjaVCpVZVKRVBQUK3bO3TooDdyKjRtxcXFui99lxu/EZmZmSaMSDC26ol2ZmamWI9qIGfPnuXXX3+tdfvy5cs5d+5cI0YkGIokSfTq1QuAc+WgkWVd0l11u2A6xcXFFBQUaK/YNJNK4DfizMjIMHEgjedO3VGKiorEd5EgmImWMoOnPhqUdLu6ut6xL2lsbCyurq71ft7Y2Fj++9//8uyzzzJhwgSOHj2qt12WZVauXMkzzzzD5MmTeffdd2uM0hUWFvL555/z5JNP8o9//IOvv/6a0tLSesfSklQl2PYStLlRPFRMOTZfRUVFegc+siyTk5NjwojMx2+//cb169dr3Z6Tk8Nvv/3WiBEJhhQREQFAYgVkVEKRrF3rHRISYtrABC5evAiAbOMIFtYmjqZu5FZuwM3YzZ2/vz8HDhy4bWJdUVHB/v377zj9XGh+ROLVctz6WYvcq6YGJd0DBgzg0KFDfPvtt6SmpqLRaNBoNKSmpvLdd99x6NAhBg4cWO/nLSsrw9/fv9bqvr///jubN29m2rRp/Oc//8Ha2pr58+frVV/+/PPPSU5OZs6cObz22mucP3+eRYsWNeRtthgpKSkAuCm1/wCSk5NNGJFgTFWjKrKVHbKdCwDp6emmDMlsJCUl0aFDh1q3t2/fXtd6Smh+AgMDUSgUFMoQf6PTXkBAgCga2gScPHkSANnF28SR1INTG2RJQXZ2NlevXjV1NEb3yCOPkJSUxNy5czl+/DgZGRlkZGRw/Phx3nnnHZKTk3nkkUdMHaYgCA1wayeckpISE0XSdDXoSGHs2LFkZGSwc+dOdu7ciUKhzd01Gm1Z1wEDBjBmzJh6P29kZCSRkZG33SbLMps2bWLs2LH07NkTgOeff55p06Zx7Ngx+vbtS0pKCqdPn+b999/XFb2ZMmUK77//Pk888USto+8VFRV6vYolScLW1lZ32dydP38eAH8L8LWAv6rd1hLef0uTkJCgvWDvimxhjVScS0JCAl27djVtYGZArVbfcXqkWq2mrKx5VFYWarK0tMTS0pKysjJKb5zUr/quEEynuLhYNzNO9qh96VuTo7REdvNDyrrMvn37eOKJJ0wdkVFFRkYyffp0li5dygcffKC3zcbGhmeffZZu3bqZKDrBGMQxZMtx67GNGOmuqUFJt0KhYObMmYwePZpTp07pVeiNjIzEz8/PoEGCdgq0SqWiS5cuutvs7OwICgoiPj6evn37Eh8fj729vS7hBggPD0eSJBISEmpdd7du3TrWrFmjux4QEMCCBQtwd3c3+PtoaqrOMgN0tARPC7BCW1jt8uXLohiUGYqOjgZAdvUBCxvIusTZs2eZOXOm+IK8R76+vhw9epTRo0fX2CbLMkeOHMHHx8cEkQmGUFhYqDuwcLoxT0zULzG9Xbt2UV5erp254+hp6nDqRfbqBFmXOXDgAA899BBOTk6mDsmoBg4cSK9evTh79qxu1pWnpyddu3YVJ7AEoRm7NekWAww1NSjpzs7OxtHRET8/v9sm2OXl5eTn5+Pm5nbPAVapOrC59QvJyclJt02lUtVoyaNUKnFwcLjjgdGYMWP0DpKrEo+srCyzL+qxePFi1Go1gRbQzlL7vvvYyOwp1W7z8/NDqVSaOErBUDIzM2/UY5CQ3QK0Iy0KJcnJyRw6dKhFrKezsLAw2gm1ESNG8OWXX/Lxxx8zfvx42rZtC2iXcKxZs4b4+HimT59ulNcWjC8+Ph4AN4X2JOWfaJcUFBcXY2dnZ9rgWqiSkhK2bdsGgNwuQteGq9lw8kJu5UFFQSZbtmxh4sSJpo7I6Ozs7Ojdu7epwxAEwYCqzxgGzD5/aogGJd0zZ87khRdeoF+/frfdfvz4cT777DNWrlx5T8E1lqopg7djzkUgrly5omvP8UC148W+NnC0TFvhevfu3QwZMsREEQqGduLECQBkZy+wttdebu2HlJXI8ePH8ff3N2F0zV///v3JyMjgt99+48iRI3pLbyRJYty4cQ2qdyE0DVVTmDtYgrMC3BWQVVnJiRMnuP/++00cXcu0bds2ioqKkG2dkN2b4UlDSULjF4ny3FZ27drFAw880KBCtM3Bra1Ja2PIARtBEBrHrUn2rUm40MCk+27UarXuYNNQnJ2dAcjLy8PFxUV3e15eni5RcHZ2Jj8/X+9xlZWVFBYW6h4v3LR27VoAulqBr8XN0QFbhcQQW5k/iuGPP/6gX79+WFs3j2qwwp2dOnUKANnN/+aNrf0gK5GTJ08ybtw4McX8Hj366KPcf//9HD16VNcZwNPTk549e9KmTRsTRyc0VFlZGWfOnAEgwlo7IyrCWmZ7iTYZF0l34ysqKtKNcmv8u4Nk2OOORuPig+zYBnV+Ops3b2by5MmmjsgoZs6cWaf7NZcBG0EQbro1yRZJd011TrqLi4v12gwVFBTc9qxlUVERBw8eNHiS6+HhgbOzM9HR0boku7i4mISEBIYNGwZAcHAwRUVFJCYmEhgYCMC5c+eQZfmOfcVboosXLxITE4MCGHqbZVQ9rGF/KeQWFLB7925GjBjR6DEKhpWdna0roia3vrksRHb1RZYUZGRkkJSUZJSaDC1NmzZteOihh0wdhmBAsbGxlJeX46wA7xsrbsKsYHsJxMXFiSnmJrBr1y5KS0u1a7ndmuEodxVJQuPXDWX0Jvbt28eoUaPMcqDgdktrNBoNWVlZ7Nu3D0dHR4YPH26CyARBuFe3ruG+tZq5UI+ke+PGjXrFxn744Qd++OGHWu/fkHVJpaWleq2LMjMzuXLlCg4ODri5uTFy5EjWrl2Ll5cXHh4erFixAhcXF101cx8fHyIiIli0aBHTpk1DrVazZMkS+vTpY7bTtRpCrVbz888/A9DNGlyUNUc2lZLEIFuZtUWwYcMGevXqJf4Pm7lNmzYBIDt766aWA2Bhhezmj5SVyMaNG5kxY4aJIhSEpquqtWKgxc26H25KCUdJJr+ykvT0dN3JXsH41Go1u3fvBkBu17X5reW+lbN2bbe6IJO//vqLv/3tb6aOyODutLTm4Ycf5s0339Qb3BEEofm4tVq5aBlWU52T7q5du2JjY4Msy/zyyy/07du3RtElSZKwtrYmMDBQr4J4XV26dIm5c+fqri9btgzQtiCbOXMmDz/8MGVlZSxatIji4mJCQkJ44403sLKy0j1m1qxZLF68mHnz5iFJElFRUUyZMqXesZiz9evXk5KSgq0ED9yhWGiEFRwrg+SyMpYsWcI///lP0Y+2mbp8WduSBkDTrmZbPrldBGQlcuLECWJiYggLC2vkCAWhaSsqKgLA7pYZzHYKyK+8uV1oHGfPniUvLw/Z0lZbFLK5kyRk71CkuEzdaLehl+k1ZTY2NgwcOJCNGzcycuRIU4cjCEI93fodKL4Ta6pzBhUcHExwcDCgnUIQFRVFu3btDBpMWFgYq1atqnW7JElMnDjxjqPoDg4OzJ4926BxmZM9e/awefNmAEbbgb2i9tEBhSTxiJ3Monxt3+4ff/yRp556qkUdCJiD8vJylixZgizLaNzbg7NXzTvZu6LxDkWRGssPP/zA3LlzxVRZQaimqjNGnubmbbIs6663atXKBFG1XLq+3J5BoDCPDhuyuz9ygiU5OTlcunSJDh06mDqkRiXLsmjBJwjNVEFBgd71wsJCE0XSdDUoe3r00Udvm3Cr1WrRDL0J27lzJz/99BMAg22hq/Xdp+N5Wkg85qD9RTl48CBLly6lsrLSyJEKhrRq1SpSU1ORrWyRg+6r9X5yQE9kG0dycnJ0s0wEQdCqqiVypQI0N7paZFRCiaxtQyf6rzeeiooKzp49C2Aeo9xVFBa6ehtVnSZaguLiYk6cOMGGDRtaRNtKQTBHtybdt14XGli9/MCBA1y8eJF//OMfuttWr16tq4bdrVs3XnjhBWxsbAwSpHDvNm7cqPt87rOGQfX4aIKtJMbaa9d3Hzx4kNLSUp599lkx1bwZiI2N1a171AQPAMs7fPBKSzQhA1Ge+YNjx47RvXt3Xb0EoWmbOXMmWVlZNW4fNmwYU6dOrXH7nj17+Oqrr/Rus7S05JdffjFajM1dhw4dsLOzo6C4mEQ1BFnC6Rt1Yrp06SL2h43owoULlJWVIVvZQSt3U4djUHJrP8hM4MyZM0ycONGsukncrdaPm5vbbfdXhrR+/Xp+/fVXRo4cqTuGLS8vZ9myZRw8eJCKigq6du3K1KlT9YrZZWdn89133xETE4ONjQ0DBgxg0qRJKJXmMctCEO5V1ci2bOOIVJovRrpvo0FHCX/++adeP9+4uDjWrFlDZGQkPj4+bN68mbVr1zJp0iRDxSncgx07dugS7kE22lHu+n6RR1hLWEsyKwvh5MmTLFmyhKlTp4qp5k2YWq3WzWzQeIeCax1G4hw90PhGoEg6xa+//kqXLl1Eu7h62L59O506dWr0Uc/3338fjebmvOekpCTee+897ruv9pkNtra2fPbZZ40RnlmwtLSkZ8+e7N27l3Pl0N5C5tyNpDsqKsq0wbUwVaPAcut2zb+A2q1c2iJLSjIzM0lJScHX19fUERnM7VpSSpKEvb09np6edO3a1ahJbEJCAtu3b6/RoePHH3/k5MmTvPTSS9jZ2bF48WI++ugj3n33XUBbYf3999/H2dmZ9957j9zcXBYuXIhSqRTHuYJwg24Nt60jiKT7thqUdKenpzNgwADd9f379+Ps7Mwrr7yCUqlEo9Fw5MgRsTMyMVmW2bZtm26d/CAbGGLX8AOUTlYS/89B5pdCOHLkCABPPfUUlpaWBolXMKz9+/eTmZmJbGmDHFD3EWu5XQRyZgL5+fls376d0aNHGzFK8/L9998D2toSISEhdOrUiZCQEAIDA416gqpqvXGV9evX4+npSWhoaK2PkSTJLNsSGVP37t3Zu3cv58shyhpUGrCysiI8PNzUobUYFRUVN5NudzOsFm9hpT1Bev0qhw8fNquke8KECSZ77dLSUr744gueffZZ3SAEaKe279q1i9mzZ9O5c2cAZsyYwYsvvkh8fDzBwcGcOXOGlJQU3nrrLZydnfH392fixIn88ssvTJgwQcxyEQRuViuXrR2QENXLb6dBewq1Wq2XaJ09e5aIiAjdGUofHx+2bdtmmAiFBqmoqGDlypW6qcV9b4xw36uOVhKP2susLtIm3iqViunTp4siQk1MQUGB7sBCbhcBynqcGFEokf27I13Yw8aNG+nduzdubm7GCdTMfPvtt5w/f54LFy5w/vx5fv75Z2RZxsbGhg4dOugScWNWh1er1fz111+MGjXqjjNaSktLmTFjBrIsExAQwP/7f//vrgf4FRUVVFRU6K5LkoStra3usrnr2LEjAEUyXFVrb/P39xdLqRrRkSNHKC4uRrZ2AKc2pg7HKDSeHVBev8r+/ft55JFH9Dq0CA3z/fffExkZSZcuXfSS7sTERCorK/VOnLVt2xY3Nzdd0h0fH0+7du30TlJGRETw/fffk5ycfNt16C19X3k7LfV9txS6JPtGS9rS0lLxmd+iQUm3h4cH0dHRDBkyhEuXLpGens5jjz2m256XlycOQkwoPj6eZcuWkZaWhgSMsIU+Nobb4YVbS9goZFYUapcWzJkzh0cffZS+ffuKP7AmoLy8nC+//JKioiJke1dk79pHO2sju7dHTr1AeX46Cxcu5NVXXxXVzOvAycmJ3r1707t3b0D7JRQXF8eFCxc4fPgwq1evRpIkVqxYYbQYjh49SlFR0R174np7ezN9+nT8/PwoLi5mw4YNzJkzh48//pjWrVvX+rh169axZs0a3fWAgAAWLFiAu7t5rau9E3t7e4qKiki/UU/S09MTL6/bdAQQDK6yspKdO3cCIHt3AslMlze1bods7UBhYSFnzpzhoYceMnVEDXJr3Yi6kCSJ6dOnGzSOAwcOcPnyZd5///0a21QqFRYWFtjb2+vd7uTkpKukrlKpaswKcnJy0m27HbGv1Kq+XEDsJ81bWVmZ9oKNdhCuuLhYfOa3aFDSPXToUH744QdSUlK4fv06rq6udO/eXbc9Li7OrKZENRe5ubmsX7+e/fv3A2AvwSP22mnhhtbBUmJaK5k1RZBeWMjSpUs5ePAgEydOrLFeSmg8arWab775hosXLyIrrdCEDGzYgakkoenYH8XpDSQnJ/PFF1/wz3/+U6zvrof09HTdiPf58+fJyMjA2tpa13rRWHbv3k1ERASurq613qd6C8iq6y+++CLbt2/XO4F6qzFjxugtN6g6yZaVlYVarTZA9E1bWVmZbt2a141jybS0NNLS0kwYVctx4MABkpKSkC2skb1CTB2O8UgKZN8uSAkH+eWXXwgPDzfJQIaFhcU9JYkxMTH1foyhT9xnZ2fzww8/MGfOnEadMdDS95VVqne7EftJ8yXLMjk5OdrLDtpjj9LSUi5fvtwiBmHruq9sUNL94IMPYmlpyalTpwgMDOThhx/W7cwKCwtRqVQ88MADDXlqoQFKSkrYvHkz27dto/zGdKYe1jDMFuzu0If7XrWxkJjuKHOwFHaVaE+2zJs3j969ezNmzBgxJbmRVVRU8N1333HmzBlQKNGEPQD2tSded2XriKbzCBRnNxIfH8/ChQt5/vnnReJ9B1u2bNFNL1epVDg4ONCxY0eGDRvWKGu7s7KyOHv2LC+//HK9HmdhYUFAQADp6el3vJ+lpWWtNRzkG220zFlCQgIADhL43fj2TEpKoqysTEwBNrKSkhLdyKHs2wUszHs/JLfpiJwSTX5+Phs3bmTs2LGmDqnevvzyS1OHQGJiInl5efz73//W3abRaDh//jxbtmzhzTffRK1WU1RUpDfanZeXpxvddnZ21v3tV99ete12Wvq+8nZa6vtuCQoKCm6eTLJ1QlZaIlVWkJOTI0a7q2lw9YehQ4cydOjQGrc7ODjw3//+956CEupGo9Fw8OBB1qxZo+uH185CO528nWXjTPNWShL320JnK5ntJXC2HA4fPszx48cZMWIEI0eOFElaIyguLmbhwoXExcWBpKAydCg4G2BH18oNTefhKKO3EBsby//+9z9mzZqlm1on6Fu6dCkKhYKoqCgeeughAgMbt9DT7t27cXJyolu3bvV6nEajISkpicjISCNFZh5OnjwJQEcr8FSCkwLyyss5d+5cvf/PhfrZtGkTeXl5yDatkNsaryZCk6FQogmMQhm7g61bt3L//fe3uKnJhhAeHs6HH36od9vXX3+Nt7c3Dz/8MG5ubiiVSqKjo3XLglJTU8nOztbNBgoODmbt2rXk5eXpvvvOnj2Lra1to3eqEISm6Pr16wDaNo4KJVg7QHEu169fF0l3NaLkYjOVnJzMzz//rDv76qaAYXbQydI0xSpclBITHKCvWmZrMSSq1fz5558cPnyY//f//h9du3YV672NJCUlha+++oqMjAxkpSWaTkPq1h6srpzaUNnlQRTntnHlyhXeffddpk+fTvv27Q33GmZi+PDhuvXbx44dIzAwUFfBPCQkxKjr4jUaDXv27GHAgAE12u4sXLgQV1dXXUeJNWvW0KFDB9q0aUNRUREbNmwgKyuLIUOGGC2+5k6j0eiS7rAb+9kwS5mDZXDq1CmRdBtRRkaGrjirJrA3KFrIoUtrP2Rnb9SqVFauXMnzzz9v6ojuyd36dIO2G4CrqythYWE89NBDtGlzb8XybG1tadeund5t1tbWtGrVSnf74MGDWbZsGQ4ODtjZ2bFkyRK9JThdu3bFx8eHhQsXMnnyZFQqFStWrGD48OGie4sgoF3GAYCNw82fN5Ju4aYGf3OpVCp27dpFYmIiJSUlej1iQXtA8vbbb99zgIK+7Oxs1q9fz+HDh5FlGStgkC3cZwMWTSCpbWsh8VQrmdgK2FisjfeLL74gODiY8ePHi0TNgGRZZt++fSxfvoKKinJka3s0YcPAofZCWA3m6Ikm8iEU57aRm5vLggULGDt2LMOGDRO92quZMmUKoJ15cOHCBd2/jRs3UllZia+vL506ddLdz5Cio6PJzs5m0KBBNbZlZ2frnfQqLCxk0aJFqFQq7O3tCQwM5L333hOjNneQnJxMXl4e1hIE3jjO7mQFB8u0o16yLIsTi0by22+/oVarkV3aQut2d3+AuZAkNO3vQ3lyLadOnSIuLk5XQb85GjduHMePHyc5OZnIyEhdQp2Wlsbp06dp164dnTt3Jj09nT179nDgwAHmzp2Lv7+/UeN68sknkSSJjz76CLVaTdeuXZk6dapuu0Kh4LXXXuP7779nzpw5WFtbM2DAgDqdRBCElkA30m3toPspUS0ZFwCQ5AYssrh69SrvvPMO5eXleHt7k5SUhI+PD8XFxeTk5ODp6Unr1q35v//7P2PE3GiysrL0Wj6YUk5ODlu2bGHv3r26dRPhVjDcFpyVTfNAr1yW2VMCB0uhqmxIt27dGDVqlNG/RM1dbm4uP/74I9HR0QDILj7aommWRi5YoS5HEf8XUvZlADp06MCUKVPw8PAw7usakKWlZaNO08zMzOTs2bNs3LiR1NRUAFauXNlor98YmtK+0liOHDnCt99+i58FTHPU7nPLZZl5udrtn332GQ4ODiaM0DxdvXqVefPmAVDZfey91alopqSL+1GkXSAoKIjXXnut0U7uGHpfuWPHDn777TfeeecdPD099balp6fzzjvvMHHiRAYNGkRaWhpz5swhKCiI119/3WAxmFpL2FdW9/rrr5OZmQnA4sWLTRyNYCzLly9nx44daHzCkQOjkJLPoLh8jN69ezNt2jRTh2d0dd1XNmik+9dff8XGxoYPPvgAKysrpk2bxlNPPUXnzp05dOgQ33//PbNmzWrIUwu3SE1NZfPmzRw5fJjKG7MJAi1guJ12VLkps5IkhtlBL2uZXSVwqly7JvLkyZOEhoby4IMP0qlTJzE6VA9qtZodO3awYcMGbXsGSYkmoAdy287QGP+PFlZoOg1GSo9DSjzCxYsXeeuttxg5ciQPPvigKCaFdrp/VcXy8+fP6yp6urq60qdPHzp16mTiCIWGKCwsBMCu2p+ZJWAFlN/YLpJuw/vzzz8B0Hi0b5EJN4DcLhIyLpKQkEBcXBwhIc2zcvuGDRsYPnx4jYQboE2bNgwfPpz169czaNAgvLy8eOCBB9i6dasJIhUEoT6qjnO4MdJd1atbd7sANDDpvnDhgq4ARdWBSNX08vvuu48LFy7w008/MXfuXMNF2oJoNBqio6PZtWsX586d090eYAEDbKG9hWnWbTeUs1JirAP0q5TZWwLR5RAbG0tsbCy+vr4MGjSI3r17i4JrdyDLMmfPnmX16tW6thuyoweaDveDvUvjBiNJyF4hyM7eKC7uR61KZcOGDRw8eJBx48bRs2fPZvX7aUhPP/20bp/o7e1NZGSkbj13c5oNINRU1b9cVW0lVbGsTbiBO7ZoExomIyODU6dOASD7Rpg2GFOytkfj2QFF2gW2bNnSbJPu69ev33E5klKp1JuO6u7u3qJGhc2RqFjeMmRlZQEg3+jRLVtrf4rp5foalHTLsqyr4GhnZ4dCodAdaAK0a9eOXbt2GSbCFqSwsJC//vqLPXv26H5RJbTF0frbgk8TH9m+Gw+lxKMOMLRS5kApnCjTrpNctmwZa9asoW/fvgwePFgkJ7e4fPkya9as4cKFCwDIljbIAb2QPTs0zuh2bWwd0YQ/CNmXUVw6THZ2NosWLWL79u2MHz++Wa89bKgBAwbokmxHR0dThyMYUNV69/RKKNLI2CskEm/kA56enmKWhxHs2rULWZaRXXwa/+RiEyP7hEPaBaKjo8nIyLjtaHFT5+vry/bt2+nfv3+NVlsqlYpt27bh6+uruy0jI6PWllxC89BST8C3JJWVlTfbjdre6Gxjp/2Zk5NDSUkJtra2JoquaWlQ0u3h4aFbo6FQKPDw8CA6Opo+ffoA2n7N1fsdCneWl5fHtm3b2L17t3bKMGArQTdr6GUNrZvomu2GclFKjLaHwbYyJ8vgSBnkFhezfft2duzYQa9evRg1ahRt27Y1dagmlZKSwvr163UjPUhKND5h2hEfiyZygC9J4B6IxtUXKSUaKfksiYmJ/O9//yMsLIyxY8e2qPX7f//7300dgmAkbm5u+Pn5cfXqVWLKoZeNdtYOQPfu3U0bnBkqKSnhwIEDAGjadjZxNE2ArROyqy9STjI7d+7UdSJoTp544gn+85//MGvWLHr27KkrpJaens6xY8eorKxk+vTpAJSXl7N3714iIiJMGLEgCHeTlpZGRUUFssICbG8MNljaIFvZI5UXcfXq1WY7O8fQGpR0d+nSRdcKCuCBBx7gp59+IjMzE1mWiYmJ4W9/+5tBAzVHWVlZbNu2jb/++ks3haqNUluJPNxKuybanNkpJPrZQh8bmYsVcLgMLlbIHDlyhCNHjtCtWzdGjBjRoiqey7JMQkICW7Zs4fTp0zduldB4BCH7d4MbU3eaHKUlsl835DYhSEknUaTHERMTQ0xMDKGhoYwYMYLQ0NAWc9Y7NjaWkydP6qZcubu7061bN0JDQ00cmXAvevbsydWrVzlbDl2sZOIrbt4uGNa+ffsoKSlBtnUCl5Z9AraKpm0Yypxk9u/fz0MPPdTsagiEhYXx3nvvsWrVKo4ePUp5ufaslaWlJeHh4Tz66KMEBgYC2tZhixYtMmW4ggGI6eXmLyYmRnvBqY3e7EvZqQ1S1iViY2NF0n1Dg5LusWPH0q9fP9RqNRYWFowaNYqysjKOHDmCQqFg3LhxjB071tCxmo3ExES2bt3KiRMndDskHyUMtIWOJuqzbUoKSaKjFXS0glS1dt13bMXNomtBQUEMHz6ciIgIs21PpVarOXnyJNu3bycxMVF3u+wWgMa/G9g1k6mV1nbIHfpR6dMF6epJFJmX9NbvDx06lKioKLPtbapWq/n00085duwYgK4vd3FxMX/88Qe9evVi9uzZWFi0kD7DZqZXr16sWbOGq2rtPkqNtgBU9Smxwr0rLy/XFdCSfcJNu4ymKXFui2zvSllRDjt27OCRRx4xdUT1FhAQwL///W80Gg35+fkAODo6mu13e0tX/XhWo9GIz9kMnT17FtB20dHj6gNZlzhz5ozICW9o0JGfg4OD3hlWSZIYN24c48aNM1hg5kaj0eiSqoSEBN3tHSyhn422InlLS7Zvx9tC4v+1gsxKmf0lcKYcEhISSEhIwMPDg6FDh9K3b19sbIzcGquRFBQUsG/fPnbv3k1u7o3eQ5ISjWeQ9mDTztmk8TWYrSNyyEAq/bojXYtGSo8nOTmZpUuXsmbNGgYOHMjAgQPNbr3e6tWrOXbsGH/7298YPXq07v3l5eXxxx9/8Mcff7BmzRoee+wx0wYqNEjr1q1p3bo1169f57h2JRDBwcFi321gu3fvJi8vD9naQVu7QtCSJDTtIlGe38m2bdsYMmQIrVo10dlPd6FQKMxu/y/cmUi6zU9BQQFxcXEAyK399LbJrr6AREpKSrOtQ2FoYrjFyEpKSti/fz87duzQFUdTAl2soK8NtGnmxdGMxeNGxfMHNDKHS+Fombbf8a+//sr69evp378/Q4YMabYVg69du8aOHTs4dOiQbmmBbGmD7NUJ2bsTWNmZOEIDsW2FHNQH2a8bUtoFpNTzFBQU8Mcff7Bp0yZ69uzJsGHD8PPzu/tzNQP79+9nwIABPP7443q3Ozk58fjjj5OXl8dff/0lku5mzN3dnevXr5Oq1l53c3MzbUBmpri4mI0bNwIg+0WCQmniiJoYN39kh9aUFV5n48aNYl8iNGlVnY1AO4NFzPIyLzExMdpil/auYHvLCUBLG2RnLyRVKtHR0SLppo5J91dffYUkSTz77LMoFAq++uqruz5GkiRdQYyWqLKykr/++ov169dTUFAAaPu79rSG3jbQSiGS7bpopZB4wA4G2MqcKoODpXC9uJgtW7awY8cOhg0bxoMPPqibxtuUlZWVceLECQ4cOKCrRA4gO7RGbtsZ2T3QfA8wLW2Q20Ug+3SB61dQXIuhMj+Dw4cPc/jwYdq3b0/fvn3p2bNns/gsa6NSqQgKCqp1e4cOHTh48GAjRiQYmlqtzbYtJVDL2n29YDjbt2+nqKgI2dZJjHLfjiSh8e+J8twWdu/ezfDhw3FxaSbLj4QWp6o4MGhHRZvz97tQU9V6btnV57bbZRcfJFUq586dY+jQoY0ZWpNUp6Q7JiYGSZJ0U0N0i+bvoCVPt4uLi+Pnn38mNTUVAFeFdgp5hLX5F0czFitJIsoGelprixf9VQpX1Wo2bdrEvn37GD9+PPfff7+pw6xBo9Fw8eJFDh48yLFjx6p9AUnIbn7aqryOni1nzaJCoa127h4IBVlIKedQZCdy6dIlLl26xPLly+nWrRt9+/alU6dOzW4qmqurK7GxsQwbNuy222NjY5vt7AxBWxSoqjWKvwWcr+BmqxThnpWXl+vajcp+3UBqXn//jcalLbKjJ+r8DHbt2iWW9glNUkVFhW7QCSA3N1eMdpqZixcvAiA7ed92u+zsBcClS5fE8gLqmHR/+eWXd7wu3HTkyBEWL15MZWUldhIMstWOblu0lKTKyBSSRIgVdLSUiauALcWQXVjIDz/8QFpaGuPHj28Sf9RZWVkcPHiQgwcP6pYVAMg2rZA9g5E9g5puJfLG0sodudMgKst6IWUmIGVcpKJYpate7+Liwn333UefPn3w8vIydbR1MmDAAFavXo2dnR2jR4/Wa4mzceNGDh06xIQJE0wcpdBQ2dnZFBYWogAirbVJ9+XLl00dltk4d+4chYWF2rXc7gGmDqfpkiQ0PuEoYzM4dOiQSLqFJql6wn2760Lzdv36dbKyspCRwNHj9neyb42ssKC4uJjk5GSzWUrYUGJxhQHt2rWLX375BYDOVvCwHdiKaeRGId1IvjtYyvxVCjtKYOvWrRQUFPCPf/wDpbLxp2lrNBrOnj3Lrl279GaDyEpLZLcA5DbBLWtUu66s7ZF9u2qnnhdmI6XHI2Ulkpuby6ZNm9i0aRPBwcEMHjyYyMjIJr0mbOzYsWRkZLBz50527typOwFUta5twIABjBkzxpQhCvcgPj4egLYWEGABEtpaE7m5uWKKrwFcvXoVANnZW4xy342zNzLa0cP8/HwcHR1NHZEg6CkqKtK7LpJu81JVtRxHD7Cwuv2dFApw9oacJM6ePSuSblMHYC62bt3KqlWrAOhtDSPttKOygnEpJYmBtuCokFlfBAcPHqSiooKpU6c2WnKmVqvZu3cv27Zt0x/Vdm6L7NkB2c0flOJP7a4kSTv63coduX1vuJ6EIiMeKSeF+Ph44uPjcXFxYciQIQwdOrRJth1TKBTMnDmT0aNHc+rUKb0+3ZGRkS3+C6e5S0pKAqCdhfaEqodSJqNSe7tIuu+dbvmNsun9bTc5CqX2xISsobS0VCTdQpOTl5end10k3eZDlmX27t2rvdz6zsc1sps/Uk4S+/fvZ9SoUU1iNqqp1CkTmDhxYoOefOXKlQ16XHNz4cIFXcI9wAaG2rbsNe2m0M1awkaSWVkIx44dw8fHh9GjRxv9dS9cuMAvv/yiW78vW1gjtwlG9gqtWclRqDuFEtwD0LgHQFkRUtp5pLQL5ObmsmbNGvbt28djjz1G165dTR3pbfn5+YkE2wxVnURpfeOYobUCMipv3i7cm4AA7ZRyKTcFWVNpvoUlDSE3BUnW4ODggLu7u6mjEYQarl+/fsfrQvN15swZkpOTkRVK7SzOO5DdA5ETj5Cdnc3Bgwfp169fI0XZ9NQp6R43blyNJPLo0aOkpKTQtWtXvL21C+ivXbvG2bNn8fX1pWfPngYPdtWqVaxZs0bvNm9vbz799FNAW4Rl2bJlutHOrl27MnXqVKP3gqyaEtfREh6wE8m2qYRaSQy2ldlecnNEypj27NnDTz/9BNxItv27I3sGi1FtQ7O2R/bvgdwuEinzEtKV42RmZvL5558zduxYRo0aZeoIhRaiqlJ5VafHqp/V2+IIDRcWFoaDgwOFhXlIlw4jB/URy3Fup6wIRfxfAERFRYmT/EKTlJycDEArCQrkm9eF5q2srIzly5cDILcNA0ubOz9AaYHs2wXp8jFWr15NREQEDg4OjRBp01On7ODWwj87duwgPz+fjz76SJdwV0lJSWHevHlGm2rn6+vLW2+9pbtefZrCjz/+yMmTJ3nppZews7Nj8eLFfPTRR7z77rtGiaVK1QFXiaydciG+AE2nRNb+NHYbn9OnT/Pzzz8DoGkTjBzQ6+47HuHe3DijKrv5I109ieLaOdauXYuLiwt9+vQxdXRA3WYFWVlZ4erqSlhYGA899JCu2JrQ9Nnb2wNQeCPHrvop2uAYhoODA08//TSfffYZirTzaCorkDv0Eycyq8vPRBG7A6miFB8fH8aPH2/qiAShBo1Gw6lTpwAYagfri7SDIZmZmXh41FJ0S2jyZFnmxx9/JDs7G9naHrldZN0e17YzcsZFCgtVfP/998yaNatFTjNv0DvesGEDw4cPr5FwA/j4+DBixAg2bNhwz8HdjkKhwNnZWfevah1TcXExu3bt4sknn6Rz584EBgYyY8YM4uLidMVvjKVHjx5YWVqSpIZjZXe/v2Ac19QyB0u1l42ZhBUUFLB06VJkWUbTpiNyh/tFwt2YLKyQ2/dG49sFgJ9//llvLb0pjRs3Dj8/PxQKBd27d2fUqFGMGjWKbt26oVAo8Pf3Z9iwYfj4+LBnzx7+/e9/c+XKFVOHLdSRr68vAMlq0Mgy17Qtu8VSAgPq0qULkydPRqFQoMhMQHF6AxQ0jb9vk9JokFLOojzzJ1J5MW3atGHmzJlYWdVSwEgQTOjEiROoVCpsJehqBe1vnDeragkoNE87duzgyJEj2g4KIYPqXn9DodTeX6EkOjqa33//3biBNlENOn18/fr1OxapUiqVRlu7kZ6ezrPPPoulpSXBwcFMmjQJNzc3EhMTqaysJDw8XHfftm3b4ubmRnx8PMHBta85qKiooKKiQnddkiRsbW11l+/Gw8ODhx95hNWrV/NHMdhIMl2sxWh3Y0pTy/xQABogMjKS7t27G23Gwe7du7VtbexdxPRHE5L9eyLnZVCWn8G2bduYPHmyqUPC1dWVgoICPv300xr9SNPT03nnnXfw8fHhiSeeIC0tjTlz5rB8+XJef/11E0Us1EfV98hlNVxVQxnaUe62bduaNjAzM3jwYLy9vfnmm28oKMhBeWo9Gq8QZP8eLfMEpyoNRcJBpOJcQPsd9/TTT+uOUwShKZFlmU2bNgHawsIWkkRfG5mEQti7dy+jRo2iVStR86a5OX78uK5WlyagFzjVc5aeQ2s0HfqhiNvLn3/+SevWrenfv78RIm26GpR0t2vXjq1bt9KvXz9cXV31tl2/fp1t27bRrl07gwRYXYcOHZgxYwbe3t66gkpvv/02H330ESqVCgsLC930vypOTk6oVKo7Pu+6dev01ooHBASwYMGCehUn+cc//kF+fj5bt25ldRGcKZfpYQ3BltoK24LhybJMSiUcL4OzZVABdOzYkTfffLPG74EhVbUjk1t5iEI/piRJyE5tkPIzUCgUTaKXd9UsoFsTboA2bdowfPhw1q9fz6BBg/Dy8uKBBx5g69atJohUaIiAgABatWpFQUEB24q1t4WHh7fIaXLGFhISwjvvvMOqVas4cuQIirQLyFmXte0FvUNbxpTzolwUV44jXdfWjXFwcGDcuHH069dP/M4JTdapU6dISkrCCrjvxjmyIEtoq4Rr5eVs3ry5xrJVoWmLjY3lu+++087w9OqE3LZzg55H9uyApiQPRdJpli1bhoODA926dTNwtE1Xg761nnzySebPn8/s2bPp2bOnbk1ieno6x44dQ5ZlXnjhBYMGCtqzu1X8/Px0SfihQ4fuaYrVmDFj9CpdV42QZmVloVar6/w8jz76KGVlZezZs4e4Coir0BaQ6G4tE24FHkpR1dwQ8jUyMeVwogzSqy3dDgoK4oUXXiA/P5/8/HyjvX7r1q0BUKTHobFzQm4bLka7G5ssI6XHoUjW9ol0c3MjLS2tTg+1sLAwWrXf69ev3/FgWKlU6k2Fd3d315tlIzRtCoWCzp07c+jQIZJv7Huqz64SDMvZ2ZlnnnmG/v3767pESJePIl87h+zXTVs11xz7eZcWautWZFwEtHVi+vfvz9ixY1tsASKheSgrK9ONht5nA3YK7bGRJGkL3f5UqJ2ifP/99zeJE+XC3SUkJLBw4ULUajVyaz/koPvu6ZhX9uuOpqwYRUY8ixYt4oUXXqBz54Yl8c1Ng5LukJAQ5s+fz8qVKzl27Bjl5eWAtkBQ165dmTBhglFGum9lb2+Pt7c36enpdOnSBbVaTVFRkd4oZ15e3l2rl1taWtba81eW5TrHI0kSTzzxBEOHDmXfvn0cPHiQgsJC9pTCnlJwUUAnS5kQK/CzECPgdSXL2l645yvgQjlcq5ZoW1pa0qNHD/r370+HDh2QJKlen1lDREVFkZSUxNatW1EkHkXOTETTvnf9p9oIDVOQheLSYaT8DAD69evH4MGDjf6514Wvry/bt2+nf//+NfY7KpWKbdu26dYFA2RkZBi9u4JgWCEhIRw6dEjvumBcVaPehw4d4vfffycnJwfp4n7klGg0/t3BLcA8TnyWlyAln0aReh5kbZW+yMhIxo4de9saOoLQlGg0Gl2RLScF9L9l9UOwpbbLT1xFJd988w2vvvqqUWclCvcuNjaWL774gvLycmRnbzSdBt/7iU5JQg7uh1xZjjr7Cl988QXPPPMM3bt3N0zQTViD52e1a9eOV155BY1GoxtVdHR0bNQpT6WlpaSnp3P//fcTGBiIUqldoN+7d28AUlNTyc7OvuN6bmPw8vJi4sSJjB07ltOnT3PgwAHOnz9PrlrNwTI4WAa2EnSwlAm0hEALcFWawQGDARVpZC6rIbEC4itAVa0jjyRJBAYGEhUVRe/evRt9py1JEo8++iiurq6sX7+eksJslGf+RG7loa2u7R4IFqK4jUFVViBlX0FKj0fK045oW1paMWrUSEaNGtVkplo+8cQT/Oc//2HWrFm3nQVUWVnJ9OnTAW2Lw7179xIREWHCiIX6ql40zdHR0WidOgR9SqWSfv36ERUVxe7du9m4cSOFhXkoz+9CdmiNJjAKnJtpYlqpRko5i5QSjVSpnfnSsWNHxo0bR/v27U0cXPO2bt06jh49yrVr17CysiI4OJjHH39c7yRGXdrNZmdn89133xETE4ONjQ0DBgxg0qRJuuVmLZ1Go2HZsmXapSDAGHuwvuVEmCRJ/M1O5lq+ttPRJ598wosvvigS7yZIlmX27dvHr7/+qh3hdmmLJnSo4ZZUSgo0IYOQLuxBnX2Zr7/+mvHjxzN8+HCznhEsyU1heKiOli1bRo8ePXBzcyM3N5dVq1Zx5coVPvnkExwdHfnuu+84deoUM2bMwM7OjiVLlgDw3nvvNej1srKyDDb1s7S0lNjYWE6dOsXZs2cpLCzU2+6iQJeAB1pCK4X5/tLdTqksc6VCm2QnqvWnjYN2RDs0NJTIyEi6dOmCk5OTaQK9RX5+Pr///jv79u3TtY6TFUpkN39kN39w8al7dUdBX6UaVKnaZDv7su5gVJIkevfuzdixY2vUlKgLS0tLo00vB7h8+TKrVq3i3LlzullAlpaWhIeH8+ijjxIYGGi01zYVQ+4rm7qysjJmzJgBaIt1zps3z8QRtUwlJSVs27aNbdu2UVqqbVshu/mjCYgC22ZSpEmWkbISkS4fRSorArQndcaOHUtYWJjJDz6Nva9sDPPnz6dv3760b9+eyspKli9fTnJyMh9//DE2NtoFx9999x0nT55k5syZunazCoVC125Wo9Hwyiuv4OzszBNPPEFubi4LFy5kyJAhTJo0qV7xmOO+sqKigm+//ZaTJ08iARPsIfwOxYTT1TKLC7QtXtu2bcs///nPBn2XC8ZRUlLCzz//zOHDhwGQ3QLQhAw0Tg0jWYN08QCK9DgAunbtylNPPdXsCu3VdV/ZrJLuTz/9lPPnz1NQUICjoyMhISE89thjutGkqrOVBw4cQK1W3/ZsZX0Ya+eo0WhISEggNjaW8+fPczkxkUqNRu8+HkroYKktPuFvAZZmduZHI8ukVsLFCu2/FLW28nh1bdu2JSQkhNDQUDp16oS1tbVJYq2LvLw8Dh06xP79+/XWFsuSApy9tetgWrcDa3FG947Ki5FykpGuJ0FuCpLm5tkXd3d3+vXrR58+fe7pC7qxDiRNOQuosZnjgeSdPP3004C2RebcuXNNHE3LVlBQwIYNG9i9e7d2iYmkROPfHdmnc9Ne711agCJun27mjqurK48++ig9e/Y0ebJdxRyS7lvl5+czdepU3nnnHUJDQykuLubpp59m9uzZulmS165d48UXX+S9994jODiYU6dO8d///pdFixbpjie3bdvGL7/8wuLFi2/bzae2rjj1rRXU1MXHx7Ns2TJSU1NRAo86QGeru//+pqtlfiyAAllbIHDixIn06dOnyfzut0QajYYDBw7w22+/aY9dJAmNfw9kny7GXb4jy0hpF1AkHgZNJXZ2djzyyCMMGjSo2cwkqWutoGaVdDe2xjqQLCkpISEhgfPnz3PhwgWSkpL01qdaoE28O1hCBytwVzTPgmz5GlmXZF+q0J7lrM7Dw4OQkBDdv6Yyml0fsixz6dIljh8/zunTp8nKytLfbu+C7OKL7OoDjm3AjBOxOpE1kJ+JlJOClJuMVKjfatDV1ZWIiAh69OhBhw4dDJK4muJAUq1Wo1ardSMrhrZq1Sq9DgwA3t7efPrpp7U+5tChQ6xcuZKsrCzatGnD5MmTG1xFtKUm3b6+vrzzzjumDUYAtNNVV6xYwfnz5wGQHT3QdBwAtk3se+RGEUgp8QhSZYVumczw4cObXM9tc0y609PTmTVrFh9++CHt2rXj3LlzzJs3j6VLl+pNc54xYwYjR45k9OjRrFy5kuPHj/PBBx/otmdmZvL888+zYMECAgICarzOrfvkqq445iItLY3ly5ezfft2AOwlmOgAgZZ1PzbNrZT5pfDmzMbw8HCeeuopOnXqZIyQhVpUVlZy+PBhVq5cycWLFwGQbZ3QBN/fuLWKCrO1JyKLcgDtrJ/HHnuMfv363bFNdXNiHu+imbO1tSU8PFxXBbewsJDY2FhiYmKIiYkhNzeXBDUkqGFzCTgpINhSJthSOxX91nUzTUWlLJOk1ibZ8RU1p4zb2trSqVMnOnfuTGhoqFl8uUuSRFBQEEFBQUycOJG0tDROnz7N6dOnSUxMhKJcpKJcSDmLrLQEl7bIrr7Irr5gZWfq8BtHRSlSTjLkJCPlXkNSl+lt9vPzIyIigsjISHx8fJrVCaYDBw5w8eJF/vGPf+huW716NWvXrgWgW7duvPDCC0ZJvn19fXnrrbd01+90giIuLo7PPvuMSZMm0a1bN/bv388HH3zAggULGqUIpiAYmo+PD//61784cOAAy1esoDQ/E8XJ9Wg6DQFXH1OHp6Wp1E6lzIgHtG1Qn3rqqdu2GBQMT6PR8MMPP9CxY0fdfq4u7WZVKlWNGZNVgwK1taQ1VFecpubatWts2rSJI0eO6JbUdbeG4bY3K5XXlYtSYrqjzIFS2F0C0dHRvPTSS4SEhDBq1ChCQ0Ob1fd/c1NcXMy+ffvYtWuXrquKrLRE9otE9g5r/Ja4Dm5ouj2ClBaHdOU4V69eZcGCBSxatIhBgwYxYMAAHB0dGzemOqrrSLdIupsgBwcHevXqRa9evZBlmbS0NM6dO0dMTAwXLlwgT63mWBkcKwMl4GchE2oFna3AwcRrwctlmbhyiKmAhAoorTaaLUkSAQEBhIWF0blzZwICAprN1JGGkCQJb29vvL29GTlyJIWFhcTExBAdHc25c+coKCiA7CtI2VcAkB3ctAm4ewDYm9n6pmKVdl12TjJSfqbeJjs7Ozp37kx4eDhhYWHNcoZDlT///BN/f3/d9bi4ONasWaM7gbB582bWrl1b73WAdaFQKOq8lGbTpk1ERETw0EMPAfDYY48RHR3Nli1beOaZZwwemyA0BkmS6NevH506deK7777j4sWLKGO2ognqi+xl4irz6nIUMduQ8tKRJInx48czbNgws1520tQsXryY5OTkRqnDYKiuOKYmyzJJSUmcOnWK06dPk5ycrNvWwRIG2UC7eoxu30opSfS3hXArmT2lcLoMLly4wIULF3Qz3SIjIwkODjab0U5TKi0t5cyZMxw/fpzo6GjdDDXZwhrZKwS5bZhpB4AkBbJ3J2T3AKTUWKS086hUKtatW8eGDRvo3LkzPXr0ICIiAju75jdQJX6Dm7jqiduwYcMoKysjLi6O6Ohozp49S3Z2NolqbfGxjcUQYKHtCR5qBfaNlIBXyDLxFRBdDnHlUH2SqYODA2FhYXTp0oWwsLBmVxzBkBwcHIiKiiIqKgqNRkNSUhJnzpwhOjqay5cvIxVmIxVmQ9IpZHtXZI8gZI/2zXcdeHmJtkhQZgJSgf40e19fX7p06UKXLl0IDAw0mwPP9PR0BgwYoLu+f/9+nJ2deeWVV1AqlWg0Go4cOWKUpDs9PZ1nn30WS0tLgoODmTRpEm5ubre9b3x8vN4oDGgLmBw7duyOr1HbOsWqyy1RS33fTZmbmxsvv/yyrsaL4uJ+NEpL7f7UFDSVKGJ3IOWlY2Njw/Tp00V/90a2ePFiTp48ydy5c2ndurXudmdn57u2m3V2diYhIUHv+fLy8nTbzE1+fj7x8fHExcVx+vRpcnJydNskoJMlDLCFthaG2/e5KCXG2MMgG+3I9/EyyMnJYdeuXezatQs7OzvCw8Pp1KkTHTt2xN3dXex766igoICYmBhOnDihl2gDyHYuyG3DkD2CQNmEUkJLG2S/bsi+XbXHkddiqCzM5syZM5w5cwalUklYWBjdu3cnPDy82QzWNKH/YaEurK2tdcnKpEmTyMjI4PTp0xw/fpzLly/rEvA/iiHUSuZ+G8PuGKvLrZQ5VAonyqD6BGE3Nzd69epFREQEAQEBZpNQGZJCocDf3x9/f38efvhh8vLyiI6O5tSpU0RHR1NZlIN0+ShcPors6ovGOxRc2jbtwkAAsgyqVBRp55GuX9VeR/t+w8LCiIyMJDw83GwrlarVar3RjbNnzxIREaGb0eHj48O2bdsM/rodOnRgxowZeHt7k5uby5o1a3j77bf56KOPdElxdSqVqsaXVPXplLVZt27dbdcpmsPSkIawtLTEy8vL1GEItXjzzTf55ptv2LBhA4q4vVTatAJHj0aPQ7q4H0mViq2tLQsWLKBDhw6NHkNLJcsyS5Ys4ejRo7zzzjt4eOh//nVpNxscHMzatWvJy8vT7TfPnj2Lra0tPj5NZOnCPcjNzSU+Pl6XaFcvBgtgiXZUO8RK22fbmAM6zkqJUfYwzE7mUgWcr4AL5VBUXMyRI0c4cuQIAC4uLgQHBxMcHEzHjh1p06aNSMJvqKysJDExkXPnznHu3DmuXr2qN7tCtnFEdg+4MauytXGLpN0rhRLZswOyZwft8sysRKTsy1QWqzh79ixnz54FtAM5YWFhhIeHExQU1GRnRTTNqIQ6kSSJNm3aMGLECEaMGEFWVhbHjh3j2LFjJCUlca4czpWDv4U2+Q62NMyoTJpa5q9S7XNXVRx3dXWlZ8+e9OrVCz8/P7HzqycnJyf69etHv379KCws5Pjx4xw6dIiEhASknGSUOcnI1g7aaTeewWBVM5EyqYoypIyLSGnnkUrydDcHBATQu3dvevXq1WTX4hiSh4cH0dHRDBkyhEuXLpGens5jjz2m256Xl2eU9dyRkZG6y35+frok/NChQwwePNhgr2Ou6xQbqry8vMYBqtC0PPTQQ1y7do0TJ06giN+HptuYxl2reD0JRcZFJEli+vTpODg4NJvfmbquU2zKFi9ezP79+3n11VextbXVnVi0s7PDysoKOzs7Bg8ezLJly3BwcNC1m61K6EA7C8jHx4eFCxcyefJkVCoVK1asYPjw4bVOIW/K8vLyuHDhAnFxcVy4cIGMjIwa9/FU3izg296y8TvoWEoSIVbaRF9jJ5Os1tYGuqyGa2rtiYLqSbijoyMdO3bUFeL19PRsMcehsiyTmZlJbGysritSSUmJ/n3sXW8sXwzULl9sjv839i7I9t2R/btrE/Dsy0jXk5AKs0lOTiY5OZktW7ZgbW2t63wUGhqKl5dXk/ldEEm3GXF3d2fkyJGMHDmS5ORktm7dytEjR7ii1nClUNsDfJSdjGcDR76LNDLbSuBkGVSdMwsJCWHEiBGEhYWJEW0DcXBwYODAgQwcOJCMjAz27NnD/v37KS4uRLp8DK6cQOMWoF2j6NTGdDtPWYaCLG2inZWoa+9lbW1Nnz59GDhwoFmMAtTH0KFD+eGHH0hJSeH69eu4urrSvXt33fa4uDh8fX2NHoe9vT3e3t6kp6ffdruzs7NuemSV6tMpa2Mu6xQNqaW+7+ZCkiT+/ve/Ex8fT0GBCik1FtmnkaZ2yzKKS9petw888ABhYWHi96WRVc0surXLwIwZMxg4cCAATz75JJIk8dFHH+m1m62iUCh47bXX+P7775kzZw7W1tYMGDCAiRMnNtbbuCc5OTlcvHiRixcvcuHChRonfSTA60aSHWAJfhb1L4pmTApJws8S/G589VTI2iT8cgVcUUOyWjslvmrQCbQj4R07diQ4OJgOHTrQpk0bszpGLSgo4Pz587pE+/p1/c4vsoU1sktbcPHR/myuyxRrY++i7Qbk1027lDH3mrbNbO41yspKdNPQQfu70KlTJ10Sbsqp6KJl2B2YQxucnJwctm/fzq5du1Cr1SiA3tYw1A6s6pisybLM0TLYXnKzMFqPHj0YOXIkfn5+xgte0CkrK+PYsWPs2bOHy5cv626XHVoj+3TRThNqrKnnsgzXr6JIOatXFM3Hx4cBAwZw33333XZKc1Nh7DY4O3bs4NSpU9jb2/Pwww/Ttm1bQNuV4L333uOBBx5gyJAhRnt90BZLmT59Oo8++igjR46ssf2TTz6hrKyM1157TXfbnDlzaNeuXYMKqZnDvrI+RMuw5mfPnj389NNP2lY4PcY3zsnKnBSU57ZgZ2fHhx9+iLW1tfFf04DMsWWYqRl7X6nRaEhJSSEhIYGLFy+SkJCgtyYbtEl2GyUEWGg74PhbgE0TSrLrS12VhKshsUKbhN/SLAc7OztdZ5mgoCACAgKaXIu+O6kqqly9G47elHFJAY4eyC5tkZ3bQiu3pr8c0RhkGYquazvj5F6DvAwkWf+3wd/fn65duxIREYGvr69BRsHruq8USfcdmNOBZFZWFitXruTUqVOAttf3ow7gfZdR7wKNzNoibdsv0B5kTp48WaxJM6ErV66wd+9eDh8+THl5OYB26nm7SOQ2HYy3o5Vl7Yj21ZO6KeQWFhb07NmTgQMH0r59+yYzhedOzPFActmyZfTo0QM3Nzdyc3NZtWoVV65c4ZNPPsHR0ZGFCxfi6uqqK+AWFxfHO++8o2sZduDAAdatW9fglmHmtK+si6qk28fHh7lz55o4GqEuSkpKeOmllygvL6ey+ziwdzH6a0oX96NIu8CgQYN4/PHHjf56hmaO+0pTM/S+sri4mMTERC5dukRCQgKJiYmUlpbq3UeBNsn2uzGS7d/ERrINreJGu9rLFXBVDSlq/QK/AEqlEj8/P4KCgmjfvj1BQUFNriieLMskJiZy7NgxTp8+TVaWfkFa2d4F2bmtdiTbqQ0om99SB6OrVEN+BpJKm4RLhfozAlxdXenatSs9e/YkODi4wcewdd1XiunlLYS7uzvPP/880dHRLF26lKy8PBblwyP2MpHWt/8lu6aWWVYARbL2F2r8+PEMHjzYrKboNEdVBdjGjRvHrl272LlzJ4WFhUgX/0K+Fo0moBe4+hp2JEeViiLxqLa6Otoe64MGDWLo0KHNpmqkOcvJyeGzzz6joKAAR0dHQkJCmD9/vm4dfXZ2tt6XSceOHZk1axYrVqxg+fLleHl58corr4ge3fXUHE4yCVpVRa8SExOhOLdxku6iXOD/s3ffYVFd6QPHv3cKZeiIIIhSRETFXmPvRs3G1RSTGFOMZhN1k03Z/e2marrJJpui7ppEE83GqHHVGKPG3jt2URFREQUBacLQhrm/P0ZHR1ARGYbyfp6Hx5l7LzPvdeBw33vOeQ9ERETY/b1E3ZCfn8+RI0c4fvw48fHxnD9/vtSUBWcFGuuufQXrwLkOtVV6RaHJlbnoACWqSnIJJJrgbLHl38tXio0lJCRYv8/Pz4+IiAiaNm1KmzZt8PGxfxtRFpPJxN69e1m7dq3tyEZFCz5BqL6NUes1rn1Dxu1BqwMfy40JNQwoMlqWrr2UCJnnycjIYMOGDWzYsIHg4GAGDBhA165d7VarQXq6b6G29t7k5uYyZ84c9u3bhwKMcodoJ9sG+aJJ5dvLkK9aenOeffZZ6zBZUb0UFhayceNGli9fjtFoBED1CcbcpCsYvO/uxQsuo0nYZV1L3MXFhXvvvZcBAwZU6yHkt2Lv3pusrCzWr19PQkIC+fn5mM1mm/2KovDWW2/Z7f0doba2lTcjw8trpi+//JKDBw9ibtqjStbt1sT8DyUvk5deeono6Gi7v19lk57uyleRtvLy5cscPHiQffv2cfTo0VJFK300luQ65EqS7a+1zIMWZVNVlUyzJfk+Z7L0hl8suVar6KomTZrQvn17OnToUGW/B3v37mXevHnXaq4oWsz1w1D9Qi0r2EhvduUpMUHWBZRLZ1BSE1DMlt8rd3d3HnroIXr06FHul5KebnFT7u7uTJgwgTlz5rBlyxZ+zgVfT9U61DzfrDI315Jwh4eH8/LLL9fYBKsucHZ2ZvDgwfTs2ZPffvuNtWvXYspMQhvzP8yN2qA2bg93OjpBNaMkHUZzdp9ljVmNhj59+vCHP/yhTlQhr6izZ88yefJkioqKCAoKIjExkeDgYIxGIxkZGQQEBNisESuEqDqZmZaeZ1Vf+SsIlEnvCmTedik+IcqiqioLFy5k7dq1Njdv62ksS3eF6C1JtkctHipuD4qi4KsFXy20vVJmoUBVSbrSEx5/JRk/deoUp06d4ueff6Zly5ZMnDjRrnUZTp06xTfffIPJZEJ1ckUNbGG5OVjdVqupLbQ6qGcZNaCGdUFJOYFyIZbc3Fy+//57vL29K/1mqSTdddTViq6XL1/mwIEDLMqDCZ4qOkVhhRGyzZblj1588UVJuGsIg8HAQw89RK9evViwYAEHDx5Ek3gANSMJc1Sf8vd6F+SiOb4RJcdS+ToqKopHH320zlUir4h58+bh4uLCJ598gpOTE+PHj+fpp58mOjqaHTt28O233/LCCy84Okwh6pz09HQSExMtTzyqptdK9aiPknWB/fv331GviRAAW7dutVZfD9RCCydoobf0ZMvUlsrloihE6CFCD/2BHLPKsSI4WmSpkH706FF++uknnnrqKbu8v9lsZubMmZaEu14I5ub9qnZpw7pO74zaqDVqcDRK3BY0F0/y9ddf8+mnn1bqUHOZnFuHaTQannrqKTw8PEgtgf2FkGJS2V9kadCfeeYZ3N3dHR2muEMBAQG88MILPPfcc7i5uaHkpqM58Ctkl16Ls5TcS2gO/IKSk4KzszNPPfUUr776qiTc5XT8+HEGDhyIn5+ftfbB1R6Ke+65hx49evDDDz84MkQh6qRly5YBoHoHVdlcSNXfMpf74MGDNnNHhSiPX3/9FQAXBVo6QQdnCNApknBXAU+NQltnaO1kGb4PsGXLFutoGXuw9qIbM6Hgst3eR9xCYR5KrqXavz2q20vSXcd5eHgwZMgQAPYUwt5Cy/b27dtL8ZcarlOnTkyZMoXw8HAUUyHawysgu+x1mwFLwn1wOUpRvrUqc8+ePeUP/B1QVdVaWM5gMKDRaMjNzbXub9y4sVx8C1HF9uzZw7Zt2wAwh7Svujd288FcvwmqqjJr1iybtkCI2xk8eDCurq4UqLA2H/6ZBV/nqCzNU9mWrxJXpJJRomKW0kx3RVVVLptVEopVdhWo/Jan8n2OytRMWGqES2ZLtfPevXvbrXCsRqPhxRdfpF69eij5OWj3LkJz4FeUlBNgKrLLe4orSkwoF+PRHFqBdvcClLxLeHh48PLLL1d6QTUZXi7o1q0bixYt4kKJmQtXlrPr2bOnY4MSlcLHx4dXX32VGTNmcOTIETSxazG3Gw4uHrYHFuWjOboGpaSYiIgIXnzxRQwGg2OCrsH8/f1JTbWsXa7RaPD39+fw4cN069YNsCzV5eYmFUeFqCq7d+/mm2++AcAc3MqytE4VUiPuQc1OJiUlhU8++YRXXnlF6mKIcunfvz89evQgJiaGTZs2ER8fT6LJUgDsejrAT6tSXwt+Gqh/Zb6yjwYMigxFv6pQVcksgUwzpJVYvtJLIM0MBTe5bxEQEECvXr3o1q2b3X9v/fz8+Nvf/saPP/7I4cOHLUtd5VxEjd9hqVbuHWQZqePiUbmr09RFBbkoWReuFFI7i1JyrbhhVFQUo0ePJigoqNLfVpJugYeHB+Hh4cTHxwOWIRVRUfav7CqqhrOzMxMmTGDq1KmcPXsWzbH1mNv84VpxNVVFc2IjSmGudWi6JNwV07p1a3bu3Mmjjz4KwMCBA/nhhx9ITU1FVVWOHj3KH/7wBwdHKUTtV1xczLJly1i5ciWqqmL2j0AN61T1gehdMLe6F82hlSQlJfH+++8zduxYmjVrVvWxiBrH2dmZbt260a1bN1JSUjhz5gwpKSkkJyeTnJzMxYsXMZlMpJRASknp73cCfLQqPhpLEu59JRm/+uVSi4qwFasqWWasiXXmlcdZVx4bbzEgQFEU6tevT4MGDQgMDCQwMJCGDRsSFhZWpTct/Pz8ePHFF8nMzGTHjh1s3bqVixcvoqQlQJpllJzq7G5Jvr0Dq3S6TI1WZETJSoasZJSsCygFOTa7/fz86NatG927d8fPz89uYUjSLQCIjIy0Jt1hYWF2W6NOOIazszMTJ05k8uTJGC+noZw7iBrSDgAl+RhK5nn0eicmTZokPbF3YeTIkfTo0QOTyYROp2PYsGEUFhaya9cuNBoNDzzwACNHjnR0mELUaqdPn+b7778nKSkJAHNQC9Qm9ziud8jNF3Pb+9AcXkV6ejqffPIJAwYMYPjw4VKoVJRbgwYNaNDAdqSG2WwmPT3dmoQnJ1tGVaSlpZGdnU0RluWwLpaRkAO4KireGvDTWnrI/bVQXwP1tKCrhr2p5iuJdeqVnurUEki/klznlmOUvZubG35+ftbk+uq/AQEB1eq618fHh6FDhzJkyBBOnTplXZs9ISGBksJclItxcDEOANXZDTz8UT3qo3rUBw+/ur20WIkJci+hXE6Fy2kol9NQbpgjrygKYWFhREVFER0dTdOmTa11eOxJkm4BYFMoS9bjrp3q1avH448/ztdff21JuhtEglaHciYGgIceetAuw2nqEnd3d5vig4qi8MADD/DAAw84MCoh6oZz586xdOlSDhw4AFiWBjM37QF+oQ6NCwBXL8ztR6Ak7EKTcoI1a9awfft27r33Xvr164eLSxUtYyZqlavTmPz9/WnTpo3NvuLiYi5dukRaWprNv+np6aSlpZGbm0u+CvklkHxDUq4BfDWWIetXvwKufGmrIBlXVZVLZsvNApsEuwRMt/g+FxcX/Pz8bvpV025yKYpCRESEtcZSQUEB8fHxHDt2jOPHj3P27FkozIPC0yjppwFQUcDN50oCfiURN/jc+dKxNYFqBmMWyuX0Kwl2KuRloJRR56BRo0ZERUXRvHlzmjZt6pARnZJ0CwC8vb2tj318fBwXiLCrzp07s3btWhISEiwFOnTOKKZCAgMD6dOnj6PDE0KIO6KqKidOnGDdunXs27fvylbFMpw8vHP1WuNW54Qa2ZMSv1A0p3aSl5fN//73P1avXk3//v3p2bOnzd9iIe6GXq8vs3f8qoKCAtLT00lPTyclJYULFy5Ye8vz8/NJN1t6kY9dm+6KDgjSqQRroZEOgnXgrbn7eeN5Zss62UkmSCqx/Jt/k55rnU5n7aEOCgoiMDCQ+vXr4+fnZ1mxpRr20FcWFxcXoqOjretH5+fnc/bsWRISEjh9+jSnT5+2VFjPy0DJy4CUEwCoihbcfVHd/cDdD9XDr+Yl4qoZjNkol9MgNx0lN93So20uPYzD09OT8PBwwsLCrF/VYdqkJN0CwGZIcXX4wRT2oSgK/fv3tyTdqadAb1miok+fPmi1sibknZoxY8Ydf4+iKDz//PN2iEaIusNoNLJt2zY2bdpEcnKydbu5fjhqSHsweDsuuNvxbYTZpyFK6imUs/u5fDmHpUuXsmzZr7Rr15a+ffsSFRVVq5MH4XguLi4EBweXWhJUVVWysrKsCfjVZPzcuXMYjcZrxdyurHbjrkAjnUprJ4hyAn05fm7NqsoZExwotKyDnWEufYxeryc4ONgmub6aYFfFUOCawNXVlaioKJs6TJmZmdYEPCEhgbNnz5Kfn28dan2VNRH38AdPf1RPf3B2rz5F2grzICcVJefilUT7Eoq59DgHFxcXQkJCCAkJITw8nPDwcHx9fatl+ylJtwCuWx/whsei9mndurWlMcrPhnzLtrZt2zo0pprq6NGjd/w91fEPgRA1QXFxMYcOHWLXrl0cPHgQk8lyAaZq9aj+TVCDWoCbr4OjLCdFgxrQFLV+E5S0BJTkY5hzLhITE0NMTAx+fn506dKFzp07l0qKhLAnRVHw8fHBx8eHFi1aWLerqsrFixdJSEiwfiUlJZFbUsKxYkuPuKsR2jipdHSGBrrSf+tyzCr7CiGm0FLc7HoNGjSw9k6Gh4cTHByMTidpyp26+tm1b29ZHlFVVdLS0jhz5gxnz561/muTiF+wXMuoTq6W+eGe/pZk3KM+aKvgMzCXwOV0lMupKDmplmS7KK/UYc7OzjRu3JjQ0FDrl7+/f425CSM/zQKwXQS+OhWTEJXPYDAQFBTE+fPnAfDy8rJrtcbabPr06Y4OQVSx/Px862OzuYzuGVGpTCYTx48fZ/fu3ezbt8/m/181+KAGNUf1jwCd0y1epRrTaFADIlADIiw9OcnHUVLjSU9P57fffuO3334jODiYzp0706lTJ/z9/R0dsaijFEWxDle/ugxmUVERiYmJHD58mG3btpGZmcnOQthZCN2cVQYbrs0BjylU+TXv2pxsFxcXunTpQvv27QkLC5MirnaiKIp13n/nzp0By9+utLQ0a294QkICiYmJlBTlw6WzKJfOAld6w70boPo2QvVtBK6VuE55wWWUjHMoGecsS3fdMExco9EQHBxMeHg4TZo0ITQ0lAYNGtSYBLssknQLwDbRrsk/0KJ8rk+6pXCeEOWXnp5ufXz58mVUVZXRC5WsuLiY2NhY9u7dy4EDBzAajdZ9qrMbav1wS6Lt5lt9hkJWBvd6qE27o4Z3QclItEwByjhHUlISSUlJLF68mEaNGtGhQwc6dOgghS+Fwzk5OVkLfQ0fPpzY2Fg2b95MTEwM2wvhfAmMdldZkw97rgxHDw8Pp2/fvnTo0EFGVjqIRqMhICCAgIAAunbtClhuoJw9e5ZTp06RkJDAqVOnyMrKgszzKJnn4dROVBdPSwJePww8A+68/b2cjpJ2ypJsG7Nsdl2dh92kSRNrkl3bfj4k6RaADCmvaxo3bsyePXusj4UQ5XPixAnr45ycHC5evHjTQkWi/IqLizly5Ah79uzh4MGDFBQUWPepehdUvzBU/yYVu9CrabQ6y42F+uFQXIiSfsZyoZplmVd7tUp7YGAgHTt2pHPnzpKAC4fTaDTWIl/79+9n1rffcraggH9lW4qiKYrCiBEjGDJkiHTuVENOTk40bdqUpk2bApZh6cnJyRw+fJjDhw8TFxdHSUEOyoWjcOGoZYmyhtGWBFy5xeepmuHSOTTnD6Nkp1g3azQamjRpQuvWrWnVqhXBwcG1/ga2JN0CQIpo1TEhISHWx5J0V55Ro0bd9hgnJyd8fX1p2bIl999/vyRsNYiqquzcudNm244dOxgxYoSDIqrZTCYTR48eZc+ePRw4cMB26LiTAdUvFNUvDLwCbn1RV5vpnVEDm6EGNoPiApRLZ1HSz0DmeZKTk/n111/59ddfadiwIZ06daJTp07SpgiHa9euHRMnTeKf//yntQr58OHDGTZsmGMDE+WmKApBQUEEBQUxePBg8vPzOXbsGPv372f37t2YLqehHN+AenoP5iZdwC+s9ItkJqE5uR2lIAcAjUZLx44daN++PS1atKhzUwok6Ral1PY7TQICAwOtj+UCrfI88MAD7N27l3PnztGuXTvr/21ycjIHDhygcePGREdHk5KSwsaNG9m2bRtTpkwhNDTUsYGLcomLi+P06dPogCEG+NUIGzduZMiQIbLO8h24ePGi9ec/L+9asRzVyXClhzcMPPxrf4/2ndK7oDZohtqgGZgKUS4loqQlQOZ5zp+3fC1dupSwsDD69OlDp06dZBSbcJjmzZvj6elJTo4l4Ro4cKCDIxJ3w9XVlfbt29O+fXseeughNmzYwIYNG7h8+TLa2HWYG7VGDe1ouUGqqijnDqI5sxew1BLq06cP/fr1q9PLEkvSLUpRy1hUXtQurq7X1q6VwnmVx9fXl8uXL/P5558TEBBgsy8lJYXJkycTHBzMmDFjSE5O5o033uCnn37iH//4h4MiFuWlqiqLFi0CoJ0zdHSG7QVwKTeXVatW8cc//tGxAVZzqqqyf/9+NmzYQGxs7LXtTq6WoeP1w+vG0PHKonO2VD8PaGpJwNPPWqqgZ523Lhe0YMECunfvTv/+/alfv76jIxZ10PXXF3Jjsvbw9PRk+PDhDB06lMWLF7N69Wo05w5hLspHbdYb5fRuNEmHAejZsyePPPKIfP7U4qR71apV/Prrr2RlZRESEsLYsWOJiIhwdFhCVAvXz5csLi52YCS1y7Jlyxg8eHCphBssIwoGDx7M0qVL6du3L4GBgQwcOJDff//dAZGKO7V//34SEhJwAvq5WiryDjKo/JQLv69aRb9+/fD09HR0mNVSeno6c+bMsU22fRthDmwOvsF1d+h4ZdE5ozaIRG0QCUX5KClxKMnHMBpzWbNmDRs3bmTEiBEMHDhQ5tLeJbm2vDPy81a76fV6Ro0aRVhYGF9//TWaiycxa/VoLlja+jFjxtCnTx/HBlmN1Mrfhu3btzN37lwefPBBpk6dSkhICO+//z7Z2dmODk2IamHfvn3WxwcOHHBcILXMpUuXbnmRodVqbapf169fX2561ACqqrJ8+XIA7nEBD42lN7aFHhpqoai4mDVr1jgyxGpr7969vP3225aEW6PF3Kg1JZ1HYY4eDPUaS8Jd2ZxcURu3wdz5YUqiB6N6BVJcXMzChQv56KOPyM3NdXSENZZcW945ma5YN3Tu3JlBgwYBWBPuHj16SMJ9g1r512758uX079+fvn37EhwczPjx43FycmLDhg2ODq3aysrKsj6+fnkWUfuYTCZWrlxpfb527Vqbnm9RcY0aNWLNmjU2v09XZWVlsXr1aho1amTddvHiRby9vasuQFEhycnJnD17Fh3Q7boRcoqi0PvKTI0dO3Y4JLbqzGw2M2fOHAoKClA9AyjpMBI1rDO4eDg6tNpP0YBvI8yth2Ju2gNVq+fUqVOsXr3a0ZHVWHJtKcTN/fGPf2TgwIF06tSJfv36lauwbF1T64aXm0wmEhISbObXaTQaWrVqRVxcXJnfU1xcbNPbpCiKdc5rXblLd/jwYevjuLg4evbs6cBohD0dOHCAzMxM63Oj0cjOnTvp27evA6OqHcaMGcMHH3zACy+8YFNFOCUlhT179lBSUsLzzz8PWNbE3LRpE23btnVgxKI8EhMTASgB/pUNcK3uxdUSGJmZmVy+fBkPD0kor0pMTLx2EzcvA83+XxwbUF1mLgHg+PHjDg6kZrrTa0u5rrS4fh5vXTrvusjZ2ZlHH33U0WFUa7Uu6c7JycFsNpfqPfL29ubChQtlfs+SJUusBXIAwsLCmDp1ap0qPFKvXj3rY09PT5vq1qJ2KWveqbu7u3zmlaBly5a89957LFy4kN27d1NUVARY5j21atWKhx56iPDwcMCydNjMmTMdGa4oJ29vbzQaDWazmYKb1Jl0c3PDycmpagOr5lxdXdHrnSguLkIpkWkU1YGXl5ejQ6iR7vTaUq4rLf70pz/xxhtv8Pjjj8s1hqjzFLWWlarOyMjgueee47333iMyMtK6/b///S+xsbF88MEHpb7nZnck09LSMJlMVRJ3dZCRkUFxcTH169eX4he1XEZGBoWFhYAlIfTz83NwRFVHp9NVyYWP2Wy2LpXi6elZq3+n0tLSav3c9OzsbJt1pG/k7e0t1VnLkJubK/OIqxF/f/9yt0V6vb7OJYk3c6fXlnJdeY3RaMRgMDg6DCHsprzXlbWup/vqxe2NcyqzsrJuOndSr9ffdNmkWnZP4pauXzuvLp13XXTjOonyeVc+jUYj87VrES8vL+klrAB3d3fc3d0dHYYQd+VOry3luvIaV1fXOnfOQpSl1iXdOp2O8PBwjhw5QufOnQFLj9ORI0e49957HRydEEJUviVLlrB7927Onz+Pk5MTkZGRPP744wQFBd30ezZu3MiMGTNstun1en788Ud7hyuEEDWKXFsKIe5WrUu6Ae677z6mT59OeHg4ERERrFixgsLCQildL4SolWJjYxk8eDBNmjShpKSEn376iffee4/PPvvslkOeXV1d+eKLL6owUiGEqJnk2lIIcTdqZdLdrVs3cnJyWLhwIVlZWYSGhvLaa6/JUE8hRK30+uuv2zyfOHEi48aNIyEhgRYtWtz0+xRFkXZRCCHKQa4thRB3o1Ym3QD33nuvDPkRQtRJV5dput1c2oKCAiZMmICqqoSFhfHoo4/arCN+I1kGRwhRl8m1pRCiompd9fLKlJmZWeeqTApR2+l0ulKF5GoTs9nMxx9/TF5eHu++++5Nj4uLiyM5OZmQkBCMRiPLli3j2LFjfPbZZzZLCF5v4cKFNsvgREZG8t5771X6OQghRG0k15VC1D7lva6UpFsIIWqRb775hgMHDvDOO+/cNHkui8lk4qWXXqJ79+488sgjZR5zY0+3RqORZbKEEEIIIW6j9i4cK+5Yfn4+//d//3fLtWhF7SGfd+0za9Ys9u3bx9tvv31HCTdY7tSGhYWRkpJy02P0ej0Gg8H6VVcTbvndqVvk8xaiYuR3p26Rz/vWJOkWVqqqcvr0aVlPsY6Qz7v2UFWVWbNmsXv3bt566y38/f3v+DXMZjOJiYm1euh9ZZHfnbpFPm8hKkZ+d+oW+bxvrdYWUhNCiLpi1qxZbN26lb/97W+4urqSlZUFgMFgwMnJCYBp06bh6+vLY489BsCiRYto2rQpDRo0IC8vj2XLlpGWlkb//v0ddRpCCCGEELWSJN1CCFHDrV69GoDJkyfbbJ8wYYJ1Ddn09HSbCuO5ubnMnDmTrKws3NzcCA8P57333iM4OLiqwhZCCCGEqBMk6RZWer2eBx98EL1e7+hQRBWQz7v2WLhw4W2PuTEhf+qpp3jqqafsE1AtJ787dYt83kJUjPzu1C3yed+aVC8XQgghhBBCCCHsRAqpCSGEEEIIIYQQdiJJtxBCCCGEEEIIYSeSdAshhBBCCCGEEHYiSbcQQgghhBBCCGEnknQLIYQQQgghhBB2IkuGCQBWrVrFr7/+SlZWFiEhIYwdO5aIiAhHhyXsIDY2lmXLlnH69GkyMzN59dVX6dy5s6PDEqJGkLay7pC2Uoi7I+1l3SBtZflIT7dg+/btzJ07lwcffJCpU6cSEhLC+++/T3Z2tqNDE3ZQWFhIaGgozzzzjKNDEaJGkbaybpG2UoiKk/ay7pC2snwk6RYsX76c/v3707dvX4KDgxk/fjxOTk5s2LDB0aEJO2jXrh2PPPKI3IUU4g5JW1m3SFspRMVJe1l3SFtZPpJ013Emk4mEhARatWpl3abRaGjVqhVxcXEOjEwIIaoPaSuFEKJ8pL0UojRJuuu4nJwczGYz3t7eNtu9vb3JyspySExCCFHdSFsphBDlI+2lEKVJ0i2EEEIIIYQQQtiJJN11nKenJxqNptSdx6ysrFJ3KIUQoq6StlIIIcpH2kshSpOku47T6XSEh4dz5MgR6zaz2cyRI0eIjIx0YGRCCFF9SFsphBDlI+2lEKXJOt2C++67j+nTpxMeHk5ERAQrVqygsLCQPn36ODo0YQcFBQWkpKRYn6empnLmzBnc3d3x8/NzYGRCVG/SVtYt0lYKUXHSXtYd0laWj6KqquroIITjrVq1imXLlpGVlUVoaChPP/00TZs2dXRYwg6OHj3KlClTSm3v3bs3EydOdEBEQtQc0lbWHdJWCnF3pL2sG6StLB9JuoUQQgghhBBCCDuROd1CCCGEEEIIIYSdSNIthBBCCCGEEELYiSTdQgghhBBCCCGEnUjSLYQQQgghhBBC2Ikk3UIIIYQQQgghhJ1I0i2EEEIIIYQQQtiJJN1CCCGEEEIIIYSdSNIt6qyFCxfy8MMP22ybOHEi06dPd1BEQghRPUl7KYQQtydtpbgZSbpFjZSRkcHChQs5c+aMXd8nKSmJhQsXkpqaatf3uRsnTpxg4cKF5OXlOToUIUQ1JO3lNdJeCiFuRtrKa6StrHySdIsaKTMzk0WLFlV6w/j555/zpz/9yfo8KSmJRYsWkZaWVqnvU5lOnDjBokWLpGEUQpRJ2strpL0UQtyMtJXXSFtZ+XSODkCIO1FSUoKqqnZ7fb1eb7fXFkKIqiTtpRBC3J60laIqKKo9f8pErbRw4UIWLVrE559/zqJFi4iJiUGn0zFw4EBGjRrFpUuXmD17NkePHsXJyYn777+fP/zhDzavkZ2dzbx589i3bx9Go5GgoCCGDRtGnz59rMekpqYyadIkHn/8cbRaLatWrSI1NZUnnniCOXPmlIprwoQJ9OnTh2PHjrFy5UpOnjxJdnY2Xl5edOnShcceewwnJ6dS57Fw4ULrtokTJ9KiRQsmTpzIxo0bmTFjRqn3efvtt9mwYQP79+9n5syZ6HS2967ee+890tLS+OKLL275/3jy5EkWLVpEXFwcJpOJgIAA+vXrx9ChQwE4e/Ysy5cv59ixY2RmZmIwGGjXrh1jxozBw8PD5hxuNG3aNPz9/W/5/kII+5P2UtpLIcTtSVspbWVtJz3dosI+//xzGjZsyOjRo9m3bx+LFy/G3d2dtWvXEh0dzejRo9myZQs//PADTZo0oUWLFgAUFRUxefJkUlJSuPfee/H392fnzp3MmDEDo9FobRiu2rhxI8XFxfTv3x+9Xk/nzp3Jz89n4cKFDBgwgKioKACaNWsGwI4dOygsLGTQoEF4eHgQHx/PqlWryMjI4OWXXy73+TVv3pwhQ4awcuVKRowYQcOGDQFo2LAhvXr1YvPmzRw8eJAOHTpYvycrK4sjR47w4IMP3vK1Dx06xEcffYSPjw9DhgzB29ub8+fPExMTYz3/Q4cOkZqaSp8+ffD29iYpKYm1a9eSlJTE+++/j6IodOnSheTkZLZt28aTTz5pbTA9PT3LfZ5CCPuT9lLaSyHE7UlbKW1lbSVJt6iwiIgInn32WQAGDBjAxIkT+eGHH3j00Uf54x//CED37t3505/+xIYNG6wN49q1azl//jx//vOf6dmzJwADBw5k8uTJzJ8/n759++Lq6mp9n0uXLvHVV1/Z/LK3a9eOhQsXEhkZSa9evWzievzxx23uOg4YMIAGDRrw008/kZ6ejp+fX7nOLyAggObNm7Ny5Upat25Ny5Ytrfs8PT2pV68eW7ZssWkYt27diqqqpWK6ntls5uuvv8bHx4ePP/4YNzc3677rB54MHjy41F3cpk2b8sUXX3D8+HGaN29OSEgIYWFhbNu2jU6dOskdSCGqKWkvpb0UQtyetJXSVtZWUkhNVFi/fv2sjzUaDeHh4aiqarPdzc2NoKAgmwqN+/fvx9vbm+7du1u36XQ6hgwZQkFBAbGxsTbv06VLlzu6u3Z9o1hQUEBOTg6RkZGoqsrp06fv6BxvRqPR0KNHD/bu3Ut+fr51+9atW4mMjLxlA3X69GlSU1MZOnSoTaMIoChKmedRVFRETk4OTZs2tb6GEKLmkPZS2kshxO1JWyltZW0lPd2iwm68q2cwGNDr9aUaMYPBwOXLl63P09LSCAwMRKOxvedzdYjNjdUc7/QOW3p6OgsWLGDv3r2lqi4ajcY7eq1b6d27N7/88gu7d++md+/eXLhwgYSEBMaPH3/L77t48SIAjRo1uuVxubm5/Pzzz2zfvp3s7GybfZV5HkII+5P2UtpLIcTtSVspbWVtJUm3qLAbG7abbbtb19+Vux2z2cy7775Lbm4uw4cPp2HDhjg7O5ORkcGMGTMqtTplcHAw4eHhbNmyhd69e7N582Z0Oh333HNPpbz+v/71L06cOMH9999PaGgoLi4umM1mPvjgA8xmc6W8hxCiakh7Ke2lEOL2pK2UtrK2kqRbVLn69etz9uxZzGazTUN64cIF6/7buX6ozPUSExNJTk5m4sSJ9O7d27r90KFDdxl12Xr16sXcuXPJzMxk27ZttG/fHnd391t+T0BAAADnzp2jdevWZR6Tm5vL4cOHefjhh20KZyQnJ5c69mb/F0KImk/aS2kvhRC3J22ltJXVnczpFlWuXbt2ZGVlsX37duu2kpISVq5ciYuLi7Uoxq04OzsDlBric7Whvf6uo6qqrFixokKxuri4lPk+V/Xo0QNFUfjuu++4ePGitXjHrYSFheHv78+KFStKve7VuMs6D4Dffvut1Otd/b+QYUFC1D7SXkp7KYS4PWkrpa2s7qSnW1S5AQMGsGbNGmbMmEFCQoJ1WYcTJ07w1FNP2VSXvJmAgADc3NxYs2YNrq6uODs707RpU4KCgggICOCHH34gIyMDg8HArl27yM3NrVCsoaGhaDQafvnlF4xGI3q9nujoaLy8vABLpck2bdqwc+dO3NzcaN++/W1fU6PRMG7cOKZOncrf/vY3+vTpg4+PD+fPnycpKYnXX38dg8FA8+bNWbZsGSUlJfj6+nLw4EGboiFXhYeHA/DTTz/RvXt3tFotHTp0sDbqQoiaS9pLaS+FELcnbaW0ldWd9HSLKufk5MTkyZPp0aMHmzZtYu7cueTm5jJhwoRS6yjejE6nY+LEiWg0Gr755hu++OILYmNj0el0/N///R+hoaEsXbqUn3/+mQYNGjBp0qQKxert7c348ePJycnhP//5D1988QVJSUk2x1wdanTPPfeg1+vL9bpt27bl7bffJjAwkOXLlzNnzhyOHDlis0TEiy++SJs2bfj999+ZN28eWq2W1157rdRrRUREMGrUKM6ePcv06dP54osvyMnJqdD5CiGqF2kvpb0UQtyetJXSVlZ3ilqZs/+FqIP27NnDJ598wpQpU2jevLmjwxFCiGpL2kshhLg9aStrH+npFuIurVu3joCAAKKiohwdihBCVGvSXgohxO1JW1n7yJxuISpo27ZtnD17ln379vHUU09JpUchhLgJaS+FEOL2pK2svSTpFqKCvvjiC1xcXOjXrx+DBw92dDhCCFFtSXsphBC3J21l7SVzuoUQQgghhBBCCDuROd1CCCGEEEIIIYSdSNIthBBCCCGEEELYiSTdQgghhBBCCCGEnUjSLYQQQgghhBBC2Ikk3UIIIYQQQgghhJ1I0i2EEEIIIYQQQtiJJN1CCCGEEEIIIYSdSNIthBBCCCGEEELYiSTdQgghhBBCCCGEnUjSLYQQQgghhBBC2Ikk3UIIIYQQQgghhJ1I0i2EEEIIIYQQQtiJJN1CCCGEEEIIIYSdSNIthBBCCCGEEELYic7RAVRnmZmZmEwmR4chhKhEOp0OHx8fR4dRq0hbKUTtI21l5ZO2Uojap7xtpSTdt2AymSguLnZ0GEIIUa1JWymEELcnbaUQdZcMLxdCCCGEEEIIIexEkm4hhBBCCCGEEMJOqtXw8tWrV7N69WrS0tIACA4O5sEHH6Rdu3YAFBUVMXfuXLZv305xcTFt2rRh3LhxeHt7W18jPT2db775hqNHj+Li4kLv3r157LHH0Gq1jjglIYQQQgjhILGxsSxbtozTp0+TmZnJq6++SufOna37VVVl4cKFrFu3jry8PKKiohg3bhyBgYHWY3Jzc5k9ezYxMTEoikKXLl14+umncXFxccQpCSFqoGrV0+3r68tjjz3GRx99xIcffkh0dDQff/wx586dA2DOnDnExMTw8ssvM2XKFDIzM/n000+t3282m/nwww8xmUy89957TJw4kY0bN7JgwQJHnZIQQgghhHCQwsJCQkNDeeaZZ8rc/8svv7By5UrGjx/PBx98gLOzM++//z5FRUXWY7788kvOnTvHG2+8wd///neOHTvGzJkzq+oUhBC1QLVKujt27Ej79u0JDAwkKCiIRx99FBcXF06ePInRaGT9+vU8+eSTREdHEx4ezoQJEzhx4gRxcXEAHDx4kKSkJP785z8TGhpKu3btGDVqFL///rtUixRCCCGEqGPatWvHI488YtO7fZWqqqxYsYKRI0fSqVMnQkJCmDRpEpmZmezZsweApKQkDhw4wHPPPUfTpk2Jiopi7NixbN++nYyMjKo+HSFEDVWthpdfz2w2s2PHDgoLC4mMjCQhIYGSkhJatWplPaZhw4b4+fkRFxdHZGQkcXFxNG7c2Ga4edu2bfn22285d+4cYWFhZb5XcXGxTTVJRVFwdXW1Pq4r5s+fT2JiIq+88ooMxxdCiJvYtWsXv/32GxMmTKBBgwaODkfYmdls5vLly3h5eTk6FFHJUlNTycrKonXr1tZtBoOBiIgI4uLi6N69O3Fxcbi5udGkSRPrMa1atUJRFOLj48tM5ivjunLWrFls27btjs/J2dkZna7aXt47nNlsJj8//46/z9PTk6lTp+Ls7FzpMamqyldffcWBAwdK7XNzc6v09xO28vLySm1r1qwZr7zySqX+LlW738rExERef/11iouLcXFx4dVXXyU4OJgzZ86g0+lK/fB5eXmRlZUFQFZWlk3CfXX/1X03s2TJEhYtWmR9HhYWxtSpU6lfv36lnFNNsXr1agBSUlLo2LGjg6MRQojq6euvvwZg0aJFTJo0ycHRCHv7/vvv2b59O2+88QahoaGODkdUoqvXhjfeULnx2tLT09Nmv1arxd3d/abXlpVxXZmcnFzuY69XWFhIYWFhhb5X3FxOTg7e3t6l8ozKUFJSwvnz58vcV1ZCKOwvISGB+vXrV2rdhmqXdAcFBfHJJ59gNBrZuXMn06dPZ8qUKXZ9zxEjRnDfffdZn1+9C5mWllYnh6VfvHixwo29ENWdTqerczfUhH2kp6c7OgRRBa72Nq5evZpnn33WwdGImqAyriv/7//+jwMHDpCbm0teXh5Go5Hc3FyMRqPN47y8vLtKsj0UGOt5++Oqq7VGOHoXS5/r9XoMBgNubm42X9dvMxgMtGjRgvz8/Ar1kpfH5MmT2bp1K4mJiSQmJlrrWd2MqtWDmw+qwdfyr5sPOBnsEluNVJSPYsyEvMxr/5pu/XvSsGFDGjduTEhICF27diUzM7Ncb1Xe68pql3TrdDrrcL3w8HBOnTrFihUr6NatGyaTiby8PJve7uzsbOtdJ29vb+Lj421eLzs727rvZvR6PXq9vsx9qqrexdnUTKqq1snzFkIIIW7GbDY7OgRRya5eG2ZnZ+Pj42Pdnp2dbR3V4O3tTU5Ojs33lZSUkJube9Nry8q4rtTpdHc86tBsNluT8ry8POtXWYl6UlISaWlp+GihvrbmTqX01apQbJkW0LRp0zIT5qv/uru7YzAYMBgMFRo2bM9rYxcXFwYMGGCzLT8/n3PnzlkT8cTERJKTkzGZTCglxZCTipKTei0+nTMYLAm46tsIfIJBU63Kd9mHaoasCyiXElHyMsGYiVJcUOahWq2WBg0a0KhRI0JCQmjcuDGNGzfGYCh9w6KyP+9ql3TfyGw2U1xcTHh4OFqtlsOHD9O1a1cALly4QHp6OpGRkQBERkayePFisrOzrUOFDh06hKurK8HBwQ47ByGEEEIIUb34+/vj7e3N4cOHrUm20WgkPj6eQYMGAZZry7y8PBISEggPDwfgyJEjqKpKRESEo0Ivk0ajwd3dHXd399seO3/+fNasWUNGCZwzqTTS1bzEO8esknCll7tBgwa88MILjg2okrm6uhIZGWnNc8Bywyc1NZXz589bvy5cuEBKSgqYCiEnBSUnBZKPoepdUP2boPo3Bfd6UNvqVOVloFyMR0mNRyky2uxSFAV/f3+CgoJo2LCh9SsgIMBhNQ+qVdI9b9482rZti5+fHwUFBWzdupXY2Fhef/11DAYD/fr1Y+7cudY7VbNnz7b5YWzTpg3BwcFMmzaN0aNHk5WVxfz58xk8ePBN7zgKIYQQQojaqaCgwJKQXJGamsqZM2dwd3fHz8+PoUOHsnjxYgIDA/H392f+/Pn4+PjQqVMnAIKDg2nbti0zZ85k/PjxmEwmZs+eTbdu3fD19XXUad21AQMGcOTIEZKTk/k2B7o4q3RyqRm93rlmlX2FsK0A8lRLL/cDDzzg6LCqhFarJTAwkMDAQJuREMXFxaSkpHD+/HkSEhLYs2cPOTk5KOePwvmjqAYf1ICmqP4R4FyDh6EXF1iS7IsnUXIvWTcbDAY6depEREQEDRs2pEGDBnYpenc3FLUajSP+97//zZEjR8jMzMRgMBASEsLw4cOtVSWLioqYO3cu27Ztw2Qy0aZNG8aNG2czvCctLY1vv/2Wo0eP4uzsTO/evRk9enSFqnGnpaXZVJ+s7a6uYTlx4kTat2/v4GiEsA+9Xi9zuitZXW0rGzVqxOTJkx0bjLC7q593p06deO655xwcTdWpLW3l0aNHy6wN1Lt3byZOnIiqqixcuJC1a9diNBqJiorimWeeISgoyHpsbm4us2bNIiYmBkVR6NKlC2PHjr3jIkvVra3Mz89n9uzZ7Nu3z7otVAednKGFE+irUc+oWVU5bYI9hXCsCEqubA8ODmbixIn4+/s7NL7qxmQyERsby/bt29m/f/91tQQUVJ+GlgS8Xghoq1X/a9nMJZCRhOZiHEpGIlxJXbVaLa1bt6Zbt260atXKYR2s5W0rq1XSXd1Ut8bR3iTpFnVBbbmQrE7qalspSXfdIEm3qCzVsa1UVZUjR46wceNGDh48aJ3H6gRE6CHKCZrpwU1T9Ql4kapyqhiOF8PxIkuv9lXh4eH07t2bLl26yGjW2zAajezZs4ft27fb1L5StXrUeiGo/k3Au2H1mv+tmiErGSUtASX9jE0RtJCQELp3707nzp3x8PBwYJAW5W0ra8DtDSGEEEIIIURlUxSFVq1a0apVKzIyMtiyZQtbt24lIyOD2GKILQYFaKxTaa639ID72nEIutGscqzY0pt9qhiuv0Xh6upKly5d6N27N40bN7ZbDLWNwWCgd+/e9O7dm4sXL7J9+3a2b99ORkYGSmo8pMaj6pxR64dZhp97Bjhm/reqQm66Zeh42mmU4muV4r28vOjatSvdunWrsXW6JOkWQgghhBCijvP19WX48OHcf//9JCYmcuDAAQ4cOEBiYiJnTXDWBKvyIUir0tIJWjqBXyUk4LlmlWNFcKQITpvg+nUC6tWrR9u2bWnbti2RkZEOK4JVWwQEBDBixAiGDx/OqVOn2L17N3v37rXM/04+DsnHUV08URs0tRRgc7l9Ub67VmS0FES7eNKyvNcVBoOBjh070qVLFyIjI9FUp574CpCfXCGEEEIIIQRg6f0OCQmx1la6dOkSBw8eZN++fRw/fpwLJSoX8mFNPjTQqnRzgTZOoL2D3lFVVUkwweZ8SDDB9XNdGzVqRIcOHWjbti3BwcHWdc5F5dFoNDRt2pSmTZvyyCOPcOLECXbu3MnevXspLMhBORMDZ2JQfYIxN2oNXoGV3/udk4rm3EGUS4lc/QnQ6/W0b9+eLl260LJly1p1k6X2nIkQQgghhKjRCgoKyM3NLXOfn59fFUcjwNLb3K9fP/r168fly5fZv38/MTExHIuNJaXEzOI82JAPvV1V2jqB7hbJmaqqxBfDhgJINF3bHhoaSocOHejQoQMBAQFVcFbiKq1WS4sWLWjRogWPPfYYMTExbNu2jRMnTqBkJqHNTEL1qI+5cVvwbXx3ybeqQtZ5NIkHUbKTrZubNGlC9+7d6dSpU5lrZtcGknQLIYQQQgiHKSoqYtGiRaxfv57Lly/f9LgFCxZUYVSiLB4eHvTq1YtevXqRm5vLli1b+P3338m8fJmlebCzAEa7q/iUMey8UFVZnAtHr0zU1uv19OrVi4EDB0rRvmrCxcWF7t270717d1JTU1mzZg1btmyh+HIa2qNrUD39MTftAW4VWC4vPxvNyW0oWRcAS7J/zz33MHjwYJvVAmorSbqFEEIIIYTDfPvtt2zatIlOnTrRvHlz3NzcHB2SKAd3d3eGDBlCv3792LRpE7/99hspubn8OwcedVcJ019LvDNLVH7MhZQS0Ol09O3bl3vvvddm2V9Rvfj7+zN69Gjuu+8+1q5dy7p16yjMSUW7bwnm4NaoIe1BU44lmVUzyrlDaBL3g7kEvV5P7969GTx4cI1e6/5OSdIthBBCCCEcZvfu3fTv359nn33W0aGICnB2dmbQoEF07NiRadOmcfbsWeZehuc8VQJ0CgWqypzLkG4GT09PJk6cSEREhKPDFuXk5eXFAw88QN++fZk3bx779+9Hc+4gak4q5hYDQO98828uKUZzbD1KxjkAWrRowZgxY+rkuuo1uwycEEIIIYSo0RRFISwszNFhiLvk6+vL3//+d6KioigGfsq1rLX9S54l4fbx8eHNN9+UhLuG8vX1ZdKkSTz//PO4uLigZCejObAMCvPK/obiQjQHl6NknEOn0/H000/z8ssv18mEGyTpFkIIIYQQDtSxY0cOHz7s6DBEJXBycuK5557D29ubdDNsyofDRZZq2c8//3ydGk5cW3Xs2JG///3v+Pj4oORnozm2AVSz7UGqiubEJpTcS3h4ePDXv/6VHj161OlK9JJ0CyGEEEIIh3nggQe4ePEiM2fOJCEhgZycHHJzc0t9iZrharE1gE0Flm3NmzenSZMmDoxKVKZGjRrx17/+1dLjnZOCcna/zX7lwlGUjER0Oh0vvfSSjG5A5nQLIUSNs2TJEnbv3s358+dxcnIiMjKSxx9/3Kb6Z1FREXPnzmX79u0UFxfTpk0bxo0bZ1O0Jj09nW+++YajR4/i4uJC7969eeyxx9Bqy1EYRQghKsmLL74IwJkzZ1i/fv1Nj5Pq5TVH27ZtWbZsmc1zUbsEBATwxBNP8PXXX6M5d4iSBpHg4gFF+Shn9gEwatQoQkJCHBxp9SBJtxBC1DCxsbEMHjyYJk2aUFJSwk8//cR7773HZ599houLCwBz5sxh3759vPzyyxgMBmbNmsWnn37Ku+++C4DZbObDDz/E29ub9957j8zMTKZNm4ZWq+Wxxx5z5OkJIeqYBx54oE4PO62NgoODcXZ2prCwEEB6uWupzp07s3nzZo4fP46SdBg1ohvKhViUkiIaNWpEnz59HB1itSFJtxBC1DCvv/66zfOJEycybtw4EhISaNGiBUajkfXr1/Piiy8SHR0NwIQJE3jppZeIi4sjMjKSgwcPkpSUxJtvvom3tzehoaGMGjWKH3/8kYcffhidrvSfh+LiYoqLi63PFUXB1dXV+rguqqvnXVfJ520fDz/8sKNDEJVMq9Xi4eFhTbrravGs2k5RFAYNGmRJujPOoaqqtVL5wIED0WhkJvNVknQLIUQNZzQaAcuaqQAJCQmUlJTQqlUr6zENGzbEz8/PmnTHxcXRuHFjm+Hmbdu25dtvv+XcuXNlVhJesmQJixYtsj4PCwtj6tSp1K9f305nVr3p9XoCAwMdHYaoIq6urvJ5V5GioiLAUpRL1FzX36S6OgpL1D7NmjVDq9VSUnAZjFmQmw5YlgcT10jSLYQQNZjZbOb777+nWbNmNG7cGICsrCx0Oh1ubm42x3p5eZGVlWU95vqE++r+q/vKMmLECO677z7r86sXVGlpaZhMpko4m5qluLiY5ORkR4chqkh+fn6d+rx1Ol2V3lBLT09n4cKF7N+/n5ycHMCypnO7du146KGH6uzNvdpCRonUXi4uLgQFBXHu3DmU5GMoWJYX8/HxcXRo1Yok3UIIUYPNmjWLc+fO8c4779j9vfR6PXq9vsx9qqra/f2ro7p63nWVfN72cf78ed566y3y8vJo3bo1DRs2BODChQts3ryZmJgY3n33XZtikaL6k0S77mjcuLEl6U47bX0ubEnSLYQQNdSsWbPYt28fU6ZMoV69etbt3t7emEwm8vLybHq7s7Ozrb3b3t7exMfH27xedna2dZ8QQlSVH3/8EUVR+Pjjj0tdrCcmJvLuu+/y448/8te//tVBEQohbiUgIAAApTgfkDn8ZZHZ7UIIUcOoqsqsWbPYvXs3b731Vqk/buHh4Wi1Wg4fPmzdduHCBdLT04mMjAQgMjKSxMREa6INcOjQIVxdXQkODq6aExFCCODYsWMMGTKkzN6xxo0bM3jwYGJjYx0QmRCiPPz8/G75XEhPtxBC1DizZs1i69at/O1vf8PV1dU6B9tgMODk5ITBYKBfv37MnTsXd3d3DAYDs2fPJjIy0pp0t2nThuDgYKZNm8bo0aPJyspi/vz5DB48+KZDyIUQwh5MJtMti6Y5OzvXyboRQtQUN46QkxFzpUnSLYQQNczq1asBmDx5ss32CRMmWNfEfPLJJ1EUhU8//RSTyUSbNm0YN26c9ViNRsPf//53vv32W9544w2cnZ3p3bs3o0aNqqrTEEIIwLISwvr16+nfvz8Gg8Fm39UlEMPDwx0UnRDidjw8PGyee3p6OiiS6kuSbiGEqGEWLlx422OcnJwYN26cTaJ9o/r16/OPf/yjMkMTQog79vDDD/P+++/zl7/8hT59+lgLpl24cIFNmzZx+fJlnnnmGQdHKYS4GVdX11s+F5J0CyGEEEIIB4qOjuYf//gH//3vf/nll19s9oWGhjJp0iSio6MdFJ0Q4nZ0Ot0tnwtJuoWosy5fvkxJSYnMuxFCCOFwrVu35uOPPyYrK4u0tDTAMhpH/kYJUf3dWAtGasOUJkm3EHWQqqq89dZbFBcX8+mnn+Ls7OzokIQQQgi8vb2rNNE2m80sXLiQLVu2kJWVha+vL7179+aBBx6wrjOtqioLFy5k3bp15OXlERUVxbhx4wgMDKyyOIWozm4shCg93aXJ/4gQdZCqquTk5ACQkZEhFw5CCCGqzKZNmwDo1asXiqJYn99O7969Kz2WpUuXsmbNGiZOnEhwcDAJCQnMmDEDg8HA0KFDAfjll19YuXIlEydOxN/fnwULFvD+++/z2Wef3bLquhB1hUZjuwq1dOaUJkm3EHWcqqqODkEIIUQdMmPGDAC6d++OTqezPr8deyTdcXFxdOzYkfbt2wPg7+/P1q1biY+PByx/I1esWMHIkSPp1KkTAJMmTWL8+PHs2bOH7t27l3rN4uJiiouLrc8VRbEWlrrae17X1NXzrqucnZ3lM7+BJN1CCCGEEKLKTJs2Dbg2BPXqc0eIjIxk3bp1XLhwgaCgIM6cOcOJEyd44oknAEhNTSUrK4vWrVtbv8dgMBAREUFcXFyZSfeSJUtYtGiR9XlYWBhTp06lfv369j+hakSr1Vofy4i6uqVhw4aODqHakaRbiDpO7kQKIYSoSjcmn45MRv/4xz+Sn5/PSy+9hEajwWw288gjj9CzZ08AsrKyAPDy8rL5Pi8vL+u+G40YMYL77rvP+vzq39m0tDRMJlPln0Q1VVJSYn2cnJzswEhEVatLn7dOpytXGyZJtxBCCCGEcJhJkybx1FNP0bFjxzL3x8TE8N1339mlR3zHjh1s3bqVF154gUaNGnHmzBm+//57fHx86NOnT4VeU6/X37R6c12d0lVXz7uuks+7NEm6hRBCCCGEw6SlpVFQUHDT/QUFBdZlxCrbf//7X4YPH24dJt64cWPS0tJYunQpffr0sVZSz87OxsfHx/p92dnZhIaG2iUmIUTto7n9IUIIIYQQQjjGqVOncHNzs8trFxYWlqq8rNForD11/v7+eHt7c/jwYet+o9FIfHw8kZGRdolJCFH7SE+3EEIIIYSoUitWrGDFihXW53PmzGH+/PmljjMajeTl5dGjRw+7xNGhQwcWL16Mn58fwcHBnDlzhuXLl9O3b1/AMh976NChLF68mMDAQPz9/Zk/fz4+Pj7WauZCCHE7knQLIYQQQogq5enpSXBwMGAZXu7r62szfBssCa+zszPh4eEMHjzYLnGMHTuWBQsW8O2335KdnY2vry8DBw7kwQcftB4zfPhwCgsLmTlzJkajkaioKF577TVZo1sIUW6SdAshhBBCiCrVo0cPa+/1lClTGDlyJK1ataryOFxdXXnqqad46qmnbnqMoiiMGjWKUaNGVV1gQohaRZJuIeo4qTAphBDCkd5++21HhyCEEHYlSbcQdZys0y2EEKI6MJlMXLhwAaPRiNlsLrW/RYsWDohKCCHuniTdQgghhBC3ITco7cdsNjNv3jxWr15NYWHhTY9bsGBBFUYlhBCV566S7uLiYk6fPk12djbNmjXD09OzsuISQlQRGV4uhBC3J22l/SxZsoRff/2VAQMGEBUVxbRp0xg9ejQGg4HVq1ejKAqjR492dJhCCFFhFV6ne8WKFTz77LO8+eab/POf/yQxMRGAnJwcnnnmGdavX19pQQohhBBCiNpp48aN3HPPPYwfP562bdsCEB4ezoABA/jggw8AOHLkiAMjFEKIu1OhpHvDhg3MmTOHtm3b8vzzz9vs8/T0pGXLlmzfvr1SAhRCCCGEELVXRkYG0dHRAOj1egCKiooA0Ol09OzZky1btjgsPiGEuFsVSrqXL19Ox44defHFF+nQoUOp/eHh4Zw7d+6ugxNCCCGEELWbu7s7BQUFALi4uODq6kpqaqrNMbm5uY4ITQghKkWF5nSnpKQwZMiQm+53d3eXxlEIUadlZWWRmpqKh4cHgYGBjg5HCCGqrbCwMOLj463PW7ZsyW+//UZoaCiqqrJy5UpCQ0MdF6AQQtylCiXdBoOBnJycm+5PSkrC29u7ojEJIaqQVOStXCaTienTp9tMsQkNDeWVV17B39/fgZEJIUT11L9/fzZt2kRxcTF6vZ5HH32Ut99+27p+t5ubG2PGjHFwlEIIUXEVSrrbtWvHunXrGDx4cKl9586dY926dfTt2/eugxNC2Mf1VXilIm/lWrVqFdu3byc8PJyWLVuSkpLCnj17mD59OlOmTHF0eEIIUe106tSJTp06WZ8HBwfz1VdfcfToUTQaDc2aNcPd3d2BEQohxN2pUNL9yCOP8Prrr/PKK69Y53Rv3LiR9evXs2vXLnx8fHjwwQcrNVBRdaTns/aTRNt+Nm3aRMuWLXnzzTetv0tLlixh/vz5ZGRk4Ovr6+AIhRCi+igqKuKnn36iZcuWdOzY0brdYDDYJOJCCFGTVSjp9vX15aOPPuKnn36yDqHcsmULLi4udO/endGjR1doze4lS5awe/duzp8/j5OTE5GRkTz++OMEBQVZjykqKmLu3Lls376d4uJi2rRpw7hx42yGs6enp/PNN99w9OhRXFxc6N27N4899hharbYip1vnSEImRMWlpqYyYMAAm5tX3bp1Y/78+aSmpkrSLYQQ13FycmLt2rUEBwc7OhQhhLCbCiXdAF5eXjz33HM899xz5OTkYDab8fT0RKOp8NLfxMbGMnjwYJo0aUJJSQk//fQT7733Hp999hkuLi4AzJkzh3379vHyyy9jMBiYNWsWn376Ke+++y4AZrOZDz/8EG9vb9577z0yMzOZNm0aWq2Wxx57rMKx1SXS0123yOdduQoKCnBzc7PZZjAYAMt878oQGxvLsmXLOH36NJmZmbz66qt07tzZun/69Ols2rTJ5nvatGnD66+/bn2em5vL7NmziYmJQVEUunTpwtNPP21ta4UQoqrIqjdCiNquQkn3jBkzGDhwIE2bNgUo1asdHx/P6tWrmTBhwh297vUXhAATJ05k3LhxJCQk0KJFC4xGI+vXr+fFF1+0ruc4YcIEXnrpJeLi4oiMjOTgwYMkJSXx5ptv4u3tTWhoKKNGjeLHH3/k4YcfRqcrfcrFxcUUFxdbnyuKgqurq/VxXVRXz7uuks+7ZiksLCQ0NJR+/frxz3/+s8xj2rZta9MG39j2ffnll2RmZvLGG29QUlLCjBkzmDlzJi+++KJdYxdCiBs9+eSTfPjhhzRq1Ig+ffrIyEQhRK1ToaR706ZNtG7d2pp03yg1NZVNmzbdcdJ9I6PRCGAtnpGQkEBJSQmtWrWyHtOwYUP8/PysSXdcXByNGze2GW7etm1bvv32W86dO0dYWFip91myZAmLFi2yPg8LC2Pq1KnUr1//ruKvqXx8fGSJo1ru6nqoAPXr15fPu5L95z//4Ztvvim1ferUqWWOBpozZ84dvX67du1o167dLY/R6XQ3XUUiKSmJAwcO8OGHH9KkSRMAxo4dy4cffsiYMWNkCLwQokrNmDEDjUbD119/zXfffYevry9OTk42xyiKwieffOKgCIUQ4u5UeHj5rWRkZJRqLO+U2Wzm+++/p1mzZjRu3BiwrHur0+lKDd308vIiKyvLesyNF5peXl7WfWUZMWIE9913n/X51V6/tLS0ShsOWpNkZWWRnJzs6DCEHV2fdKelpaHX6x0YTdXS6XR2vaHWu3dvu732nYiNjWXcuHG4ubkRHR3NI488goeHBwBxcXG4ublZE26AVq1aoSgK8fHxNkPVryejgmwpilInz7suk8/bPtzd3fHw8LCp4SOEELVJuZPuPXv2sGfPHuvztWvXcujQoVLHGY1GDh8+TERExF0FNmvWLM6dO8c777xzV69THnq9/qZJR10sKmY2m+vkedclZrPZ5rl83pXnbkf4VIa2bdvSpUsX/P39SUlJ4aeffuKDDz7g/fffR6PRkJWVVWpakFarxd3d/aY3J0FGBd1Ip9PJKJE6xNXVVT5vO5k8ebKjQxBCCLsqd9KdlJTEzp07rc9PnjxJQkKCzTGKouDs7Ezz5s154oknKhzUrFmz2LdvH1OmTKFevXrW7d7e3phMJvLy8mx6u7Ozs629297e3sTHx9u8XnZ2tnWfuD25k1/7yTrdtVv37t2tjxs3bkxISAh//vOfOXr0qM30nDslo4JsFRcXy6igOiQ/P79Ofd72HhUkhBB1SbmT7hEjRjBixAgARo0axfPPP0+PHj0qNRhVVZk9eza7d+9m8uTJ+Pv72+wPDw9Hq9Vy+PBhunbtCsCFCxdIT08nMjISgMjISBYvXkx2drZ1WPmhQ4dwdXWV5SjKSZIwIe6eyWRCo9HYzOHet28fsbGxFBQUEBoaSq9eve56Kk55BAQE4OHhQUpKCq1atcLb25ucnBybY0pKSsjNzb3lzUkZFVRaXT3vuko+b/uIjY0t13EtWrSwcyRCCGEfFZrTvWDBgsqOA7D0cG/dupW//e1vuLq6Woc5GgwGnJycMBgM9OvXj7lz5+Lu7o7BYGD27NlERkZak+42bdoQHBzMtGnTGD16NFlZWcyfP5/BgwfXqXmrQtzK9ReOMrKhchUVFTF9+nR2794NQM+ePXn22Wf54osvrNuuWr58Oe+8806pod6V7dKlS+Tm5uLj4wNYbk7m5eWRkJBAeHg4AEeOHEFV1bueGiSEEHdqypQp5TrOXtefQghhb3YppFZRq1evBkrP7ZkwYQJ9+vQBLMtKKIrCp59+islkok2bNowbN856rEaj4e9//zvffvstb7zxBs7OzvTu3ZtRo0ZV1WnUeJKE1X4yvNx+li9fzs6dO+nSpQve3t5s2rQJo9HIgQMHGDNmDNHR0ZjNZvbu3cvixYtZuHChTRtWHgUFBaSkpFifp6amcubMGdzd3XF3d+fnn3+2vv/Fixf573//S4MGDWjTpg0AwcHBtG3blpkzZzJ+/HhMJhOzZ8+mW7duUrn8DkhbKUTlePvtt0ttM5vNpKamsm7dOsxmM6NHj3ZAZEIIUTkqnHTv37+f5cuXc/r0aYxGY5kX7nd6R3LhwoW3PcbJyYlx48bd8iK1fv36/OMf/7ij9xbXSBJW+8lnbD9bt26lR48e/PnPfwYsvcpfffVVqfnQ4eHhpKens2/fvjt+j1OnTtn0DM2dOxewVE4fP348iYmJbNq0iby8PHx9fWndujWjRo2yGe3zwgsvMGvWLN555x0URaFLly6MHTu2oqddJ8nvkRCV41bDxvv06cPbb7/N0aNHiY6OrsKohBCi8lQo6d65cyf/+te/aNSoEd26dWPNmjXWwj179uwhMDCQTp06VWqgQojKc2P1clF50tLSGDp0qPV5VFQUAE2bNi11bGRkJFu2bLnj92jZsuUtb1K+/vrrt30Nd3d3XnzxxTt+byGEqEoajYZu3bqxdOlSu41azMjI4L///S8HDhygsLCQBg0aMGHCBOuyiqqqsnDhQtatW0deXh5RUVGMGzdOqtkLIcqtQkn30qVLiYiI4N133yU3N5c1a9bQr18/oqOjSU1N5fXXXy9VBE0IUX1cn3RLAl65ioqKcHFxsT53dna2+fd6zs7O8v8vhBC3kZubS15ent1e+80336Rly5a89tpreHp6kpycbLNKzi+//MLKlSuZOHEi/v7+LFiwgPfff5/PPvusSophCiFqvgol3UlJSTz22GNoNBq0Wi2AdbkYf39/Bg8ezC+//ELv3r0rL1IhRKUpKSmxPq6LSz0JURlkeLkQlSM9Pb3M7Xl5eRw7doxly5bRvHlzu7z3L7/8Qr169ZgwYYJ12/UdR6qqsmLFCkaOHGkdxTlp0iTGjx/Pnj17bJZoFEKIm6lQ0u3s7IxOZ/lWNzc3dDqdtdI4gJeXF6mpqZUSoBCi8l2faBcXFzswktpp06ZNxMXFAdf+f1etWlWqenldWvNXiJpIbqxUjYkTJ95yf9OmTRk/frxd3nvv3r20adOGzz77jNjYWHx9fRk0aBADBgwALIUqs7KyaN26tfV7DAYDERERxMXFlZl0FxcX2/xtVRQFV1dX6+O6qK6ed10ln3dpFUq6g4KCSEpKsj4PDQ1l8+bN9OzZk5KSErZu3Yqfn1+lBSmEqFyFhYXWx0VFRQ6MpHY6dOgQhw4dstm2Z88eB0UjKpOMDKlbrh8VJOzn+eefL7VNURTc3Nxo0KABwcHBdnvv1NRU1qxZw7BhwxgxYgSnTp3iu+++Q6fT0adPH2unkpeXl833eXl52XQ4XW/JkiUsWrTI+jwsLIypU6dSv359e51GtXS1gw6Q+e91jHzepVUo6e7UqRMrV65kzJgx6PV6Ro4cyccff8xTTz2FoigUFhaW2YCKmkHuTtV+1yfaknRXLllHtnbLz893dAiiCslIoKpxdVlYRzCbzTRp0oTHHnsMsCTIiYmJrFmzpsJx3bhaxdXrqrS0tDp14+76c5WRXXVLXfq8dTpduW6oVSjpvv/++7n//vutzzt06MDkyZPZtWsXGo2G9u3by7IONZgMp6v9pKdbiIoxGo3WxwUFBQ6MRFSF69tK6fW2n0mTJvHUU0/RsWPHMvfHxMTw3XffMW3atEp/bx8fn1I96cHBwezatQsAb29vALKzs/Hx8bEek52dTWhoaJmvqdfrbZZovF5dvcaqq+ddV8nnXdodJ93FxcUcPHiQ+vXrExISYt3evHlzuxW5EFVLerprv+svHqUnR4jyu76Csr2qKYvq4/qbLNc/FpUrLS3tljexCgoKSEtLs8t7N2vWjAsXLthsu3DhgrXnyt/fH29vbw4fPmxNso1GI/Hx8QwaNMguMdUWcj0pxDWaO/0GnU7HZ599xokTJ+wRj6gG5O5U7Xd90i2ftxDll5uba32cn59fp4aK1kVyk6V6OHXqlM0SXpVp2LBhnDx5ksWLF5OSksLWrVtZt24dgwcPBiyJ49ChQ1m8eDF79+4lMTGRadOm4ePjY61mLoQQt3PHPd2KohAYGMjly5ftEY8QogpI9XIhKiYnJ8fm+eXLl22GnIra5fre1+uHmou7t2LFClasWGF9PmfOHObPn1/qOKPRSF5eHj169LBLHBEREbz66qvMmzeP//3vf/j7+/Pkk0/Ss2dP6zHDhw+nsLCQmTNnYjQaiYqK4rXXXpM1uoUQ5VahOd0jRoxgzpw53HPPPQQFBVV2TMLBZDhQ7Xd9MSiZlypE+d24nnB6erok3bXY9UPKpae7cnl6elrnUqelpeHr61vqd0lRFJydnQkPD7f2PNtDhw4d6NChw033K4rCqFGjGDVqlN1iEELUbhVKuuPi4vDw8OCVV16hRYsW1K9fv9TdPkVRePrppyslSFG1ZLhx7ZeZmWl9nJGR4cBIhKhZUlJSSj1v2rSpg6IR9nb9yIa8vDxMJpPNMkii4nr06GHtvZ4yZQojR46kVatWDo5KCCHso0J/OX7//Xfr4yNHjtz0OEm6aybp6a79rk+0JekWovzOnz8PgJ8G0s3XnovaKTU11eZ5eno6DRo0cFA0tdfbb7/t6BCEEMKuKpR0yzq0tY/ZbLY+lp7u2u/6nu6srCzHBVIHJCUlsXHjRi5evEheXl6p3y9FUXjrrbccFJ24E0aj0br2aDtnWJMPCQkJDo5K2NONN1WSkpIk6bYjk8nEhQsXMBqNNtclV7Vo0cIBUQkhxN2TMVICkLWa65rrCyFKUUT72bx5MzNmzECr1RIUFIS7u3upY+QmV81x8uRJVFWlngZaO1mS7jNnzlBYWIizs7OjwxOVrKSkhNOnTwOgegag5Fzk1KlTN11LWlSc2Wxm3rx5rF69+pYF66TTRwhRU0nSLQCpYF2XqKpqUwwqMzNT5inayc8//0xYWBj/+Mc/8PT0dHQ44i6dOnUKgMY68NEqeCoqOSUlnDlzhmbNmjk4OlHZzpw5Q1FREarOCbVBM5Sci8TFxTk6rFppyZIl/PrrrwwYMICoqCimTZvG6NGjMRgMrF69GkVRGD16tKPDFEKICrvjdbpF7XR90i3rztZu6enp5OfnoyoKqkaLqqokJSU5OqxaKSMjg759+0rCXUtcrWHS+Mr9qUY62+2idrF+rt5BqD4NATh79qyMDrKDjRs3cs899zB+/Hjatm0LQHh4OAMGDOCDDz4A5PdMCFGzSdItANvh5dLrXbvFxsZaHrjXB2/Lkn9Hjx51YES1V0hIiBSqqyXOnDnD2bNn0QItrizW0erKiPKtW7fKzcpaRlVV9u7da3ns2xic3VDd66GqKjExMQ6OrvbJyMggOjoaAL1eD1y7LtHpdPTs2ZMtW7Y4LD4hhLhbknQLwDbRlqS7dtu9ezcAar3GqPVCrNtkbnHle+KJJ9iwYQMnTpxwdCjiLq1ZswaAlk7gprGs8NBcDx6KZVmpq79XonY4d+4cFy5cQFU0qH6WdlKt3wSAnTt3OjK0Wsnd3Z2CggIAXFxccHV1LVU5Pjc31xGhCSFEpZBJnAKwHVIuSXftlZSUxPHjx0FRUP2bgFaPemoHSUlJnDhxgqioKEeHWKv88ssvGAwG3nrrLYKDg/Hz80Ojsb3XqSgKf/vb3xwUoSiP9PR09lxJqru7XNuuVRS6uqisyYdVq1bRtWvXUp+vqJm2bt0KYLkxqbMMaVD9m8DpPZw8eZKUlBSpYl6JwsLCiI+Ptz5v2bIlv/32G6GhoaiqysqVKwkNDXVcgEIIcZcqdHUwadIk67CrssTExDBp0qQKByWq3tU7zMAtK4eKmu3ahWQouHiA3gU1oCkA27Ztc2BktVNiYiJFRUX4+flRUFBAUlISiYmJpb5E9bZ8+XJKzGbCddBQp9js6+wMzoplaSkZdlw7FBYWsmPHDgDUBpHXdji7Wed2b9682RGh1VoDBgzAZDJZb/o/+uijGI1G3n77bSZPnkx+fj5jxoxxcJRCCFFxFerpTktLs0nSblRQUEBaWlqFgxJVLy8vr8zHova4fi6i2T/i2nb/CEg+zv79+ykpKUGr1ToqxFpn+vTpjg5B3KXjx49bb1YNcC2931Wj0N1FZX2+ZTmjqKgoPDw8qjhKUZl27NiB0WhEdfEAn2CbfeagFmgzk9iyZQv3338/Li4uN3kVcSc6duxosxRbcHAwX331FUeOHEGr1dKsWbMyl1wUQoiawi7j4E6dOoWbm5s9XlrYiazbXPulpKSQkZGBqmjAJ+jaDk9/VJ0T+fn5JCQkOC5AIaqZ7Oxsvv76a1RVpZ0TNNYrZR7X3QX8NJbl92bNmoXZbK7iSEVlMZlMrFixAgA1qCUoN3zmvsGorp4YjUbWr1/vgAjrDoPBQOfOnenQoYMk3EKIGq/cPd0rVqyw/iECmDNnDvPnzy91nNFoJC8vjx49elROhKJKZGdnl/lY1B7W4ZDeQaDVX9uhaFB9G6OkxrN582aaNm3qmABrufz8fEvvWRkF6/z8/BwQkbgVk8nEv//9b7Kzs/HXwh9ucR/ZWVF4xF3lPzlw+PBhfv31V4YPH151wYpKs3XrVi5duoSqd0UNLKPGhaJBbdwO5cQmVq1aRZ8+fTAYDFUfaC2Tnp5Oenq6TV2RM2fOsHz5coqLi+nevTudO3d2YIRCCHF3yp10e3p6EhxsGWaVlpaGr68vPj4+NscoioKzszPh4eEMHjy4ciMVdpWVlWV9nJmZ6bhAhF2kpKRYe2XMQS1K7VeDWkBqPDt27KBfv36EhYVVdYi11urVq1m+fDkXL1686TELFiyowojE7ZSUlPDdd99x8uRJnBV4zB2cbuzxvEEDncJwN5X/5cGyZcvw9fWlZ8+eVRSxqAwFBQUsW7YMALVxW9CWfYmk+jdBPXeQvLwsVq1axciRI6swytpp9uzZFBYW8uabbwKWa5IpU6ZgMplwdXVl586dvPzyy3Tp0sXBkQohRMWUO+nu0aOHtfd6ypQpjBw5klatWtktMFG1rk+0MzIyUFUV5TYXmaJmKCwsZObMmZhMJlSfYPBtVPogT3/M9ZugSTvF119/zRtvvCFTRCrB6tWrmTVrFm3atKFv377Mnz+fYcOGodfr2bhxI97e3gwZMsTRYYrrFBcX8/XXX7Nv3z40wENu4KctX1vYzlkh2aSyvRC+//578vPzGTRokH0DFpVCVVV++OEHsrOzUV08yu7lvkrRYA7tiDZ2LStXrqR169ZERETc/HhxW6dOnbJpCzdv3kxRURGffvop/v7+fPDBB/z666+SdAshaqw7ntNdWFiIwWCw6RkVNd/162EWFhbKvO5awmw2891335GYmIiqd8HctEfpOYpXqBH3oDq7k5qayn/+8x9KSkqqONraZ9WqVbRp04bXXnuNAQMGANC+fXseffRR/vWvf5Gfny+/a9XIpUuX+Oijj9i3bx864FF3iHK6s5uPQwzXlhVbsGABc+bMkWUYa4ANGzZY1t9WFMzNeoPmNgUl64Vgrt8Es9nMf/7zHxkhdpdyc3Px8vKyPo+JiaFFixY0aNAAjUZD586dOX/+vAMjFEKIu3PHSbezszNHjhyRZaVqkZycHGvS7X7l+vLUqVMOjEhUBlVVWbJkCXv27LFcSDbvDy63KEajd8HcciBodMTGxvLjjz+WOf9YlN/Fixfp0KEDgLUqvMlkAixFgvr168fq1avv+HVjY2P56KOP+NOf/sTDDz/M7itrSF+lqioLFizg2WefZfTo0bz77rskJyfbHJObm8uXX37Jk08+yVNPPcW///3vW65KUdsdOXKEd955hzNnzuCqwBMe0PwOE26wTLO61xUGu4KCpcfuo48+khU9qrF9+/Yxb948AMyhHcGrHOtvKwpq0+6orl5kZmby+eefYzQa7Rxp7eXp6Wn9HcnLy+PkyZO0adPGut9sNkuBQiFEjVah6uVRUVHExcVVdizCQa5+lgFaiHKy3SZqJrPZzE8//WQtfmhu2hO8A2//je71KInqA8CmTZuYPXu2NUkUd85gMFhHDBgMBpycnEhPT7fud3V1rdCoocLCQkJDQ3nmmWfK3P/LL7+wcuVKxo8fzwcffICzszPvv/8+RUVF1mO+/PJLzp07xxtvvMHf//53jh07xsyZM+84lprOZDLxv//9j3/961/k5uYSpIUJnhB+k0rl5aEoCj1dFZ7wAFfFUhBqypQp7N27txIjF5UhLi7OWqHe3KAZanDr8n+zzglzq3tRnVxJSkpi2rRpMqqhglq1asXKlStZvnw506ZNQ1VVm8JpSUlJ1KtXz4ERCiHE3alQ0j127FiOHz/O/PnzuXTpUmXHJKrY1QQ7VGf5Ajhx4oQDIxJ3IzMzk3/961+sW7cOAHN4V9QGkeV/Ab9QzJG9QFHYvn07H3/8sfTSVVCjRo04e/as9XlkZCRr1qwhIyOD9PR01q5dS2BgOW6G3KBdu3Y88sgjZVbzVVWVFStWMHLkSDp16kRISAiTJk0iMzPTMuoBywXsgQMHeO6552jatClRUVGMHTuW7du3k5GRUfETrmEuXLjARx99ZL051dkZxnuCTznncN9OU73CBE9opLVUr//3v//Nd999Jz2i1URiYiJfffUVxcXFqL6NUZt2v+n0m5ty8cAcPRhVq+fEiRN8/fXXcqOyAh577DGCg4P54YcfOHToEGPGjMHf3x+w1FnYsWMH0dHRDo5SCCEqrtyF1K7317/+lZKSEpYsWcKSJUvQarXo9fpSx82ZM+euAxT2ZTKZrBfiEXoI1lmGRJ49e5aUlBQaNCjHMDtRbRw8eJDZs2eTm5sLGi3myF6o/k3u+HXUBpGUOLmiObaeU6dOMXnyZMaMGUPXrl3tEHXt1bNnT9asWUNxcTF6vZ6HHnqId999l+effx4AnU7HK6+8UqnvmZqaSlZWFq1bX+uxMxgMREREEBcXR/fu3YmLi8PNzY0mTa79bLRq1QpFUYiPj7/p0jzFxcU2PXmKouDq6mp9XFOUlJSwevVqlixZgslkwkWBP7pBdAWGk9+Oj1ZhnKfK2nzYWmBZkuro0aM8+eSTNp+RqFonT57k888/Jz8/H9UzAHPzfqBUqB8C3P0wtxiI9sgq9u3bx/Tp05kwYQJOTk6VG3Qt5u3tzbvvvovRaMTJyQmd7trlqaqqvPnmm7K0ohCiRqtQ0t2lS5cadYElbu7QoUPk5OTgpkCkHrSKQqRe5USxZS7iww8/7OgQRTlcHSJ7dX6w6l4Pc1RfMHhX/EV9G2HuMBLN8Y0U5Fzkm2++4fjx4zz66KM4OztXTuC1XN++fenbt6/1eVRUFJ999hkxMTFoNBpat25NUFBQpb7n1eHq1xcluvr86r6srCw8PT1t9mu1Wtzd3W853H3JkiUsWrTI+jwsLIypU6dSv379Som9Khw+fJgZM2Zw5swZAJrqLQm3l8Z+f9O0isJgAzTTqyzOg4wrc4C7d+/Os88+a+3RE1Vj586dfPrpZxQVFVoS7uhBN10erNx8gihpORBt7FoOHTrEV199xVtvvVXq90zcWllrnjs5OREaGlr1wQghRCWq0F+ZiRMnVnYcwkHWrl0LQAdny4UhQCdnOFEMW7Zs4f7778fFxcWRIYrbuHTpEv/5z39ISEgAwNwwGjWs0+2r75aHiwfmNsNQzu5Hk7ifLVu2cPr0aZ5//nkZBVFBAQEBDB061NFhVMiIESO47777rM+v3nxNS0ur9kNq09PTWbx4saVCNZa51vcaoL1T1fXSh+oVJnmprDXCzkLYtm0be3bvZuiwYQwaNEja2iqwbt065s2bh6qqqD7BmFsMuPuE+yrfRpS0GoLmyO8cPXqUF154gb/85S8EBARUzutXMZ1OV6NuqAkhRHVWSX9pRE108OBBTpw4gQboct21XqQe6mngktFonRsqqh9VVdm1axfz5s0jLy8PVeeEObI3+IVU7hspGtTQDpR4NUBzfANJSUm88847PPzww/Tq1QuNpoJDMuuQuLg4jh49SnZ2NoMHDyYwMJDCwkLOnz9PUFBQpSZb3t7eAGRnZ+Pj42Pdnp2dbe0t8vb2Jicnx+b7SkpKyM3NtX5/WfR6fZlTiYBqW+k+Ozub3377jY0bN1JSUoICdHSGga5gsGPv9s04KQpD3aC9s8qvRjhbXMzSpUtZt24df/jDH+jVq9dN/49FxZlMJn766Sc2btwIYCmaFtEdKrv98mqAue0f0BxZzcWLF3nvvfeYMGECUVG3WPdbVCtLly5l3rx5DB06lKeeegqAoqIi5s6dy/bt2ykuLqZNmzaMGzfulu2lEEJc766S7kuXLnH69GmMRmOZF1y9e/e+m5cXdpSbm8uPP/4IQDcX26GVGkVhsEFlXq5lneEOHToQElLJiZy4K2fPnmXp0qUcOnQIANXdz7IkmKuH/d7UpyHm9iPRHF9PYXYKP/zwA7t372bkyJFERETY731rMJPJxOeff26tmwDQsWNHAgMDURSF999/n2HDhlXqjS1/f3+8vb05fPiwNck2Go3Ex8czaNAgwFLQLS8vj4SEBMLDwwHLklmqqtaazzI/P5/ff/+d1atXW5e4DNfBYAM01Dl+elQDncI4D5XDRbA2HzIuX2bevHmsXr2aESNG0LlzZ7mhVUlyc3OZMWOGtUCoObQTaqPWd140rbzcfDG3vR9N7BryLqfx6aef8uijj9KvXz/7vJ+oNPHx8axZs6bUNc+cOXPYt28fL7/8MgaDgVmzZvHpp5/y7rvvOihSIURNU6Gku6ioiOnTp7Nr165b9m5I0l09FRcXM23aNC5duoS3Bvq6lj6muR6i9HC8uIQvv/yS119/HV9f36oPVlipqsqxY8dYtWoVR48etWxUNJhD2luWuamKC3RnA+bWQ1EuxKI5vZcTJ07w4Ycf0rRpU4YMGUKrVq0kUbjO/PnziYmJYfz48bRs2ZK//OUv1n1OTk507dqVPXv23HHSXVBQQEpKivV5amoqZ86cwd3dHT8/P4YOHcrixYsJDAzE39+f+fPn4+PjQ6dOnQAIDg6mbdu2zJw5k/Hjx2MymZg9ezbdunWr8b/nJpOJLVu28Msvv3D58mUAgrUw0ABN7mIZMHtQFIXWztDSSSWmEDbkW4bBf/PNN/z+++88+OCDtGjRQmqo3IXk5GS+/PJLUlNTUbV6zFF9oF4V3ER2NmBuPQzl5BZIPcWPP/5IcnIyjzzyCFptJUz9EZWuoKCAr776ij/96U8sXrzYut1oNLJ+/XpefPFFawX1CRMm8NJLLxEXF0dk5B2sDiKEqLMqlHT/9NNP7N69m0ceeYTIyEimTJnCxIkT8fb2ZsWKFWRmZsq872rKaDTy73//m5MnT+KswBh3cC7jgk5RFB5wU/nmMqRmZfHxxx/zl7/8RebxOkB+fj47duxgw4YNXLhw4cpWBXP9cNSQtmDwudW3Vz5Fg9owmhLfEJRz+9FcjOfkyZOcPHkSf39/+vTpQ48ePXBzc6vauKqhbdu2MWjQIAYMGGBNAK/XsGFD6xzjO3Hq1CmmTJlifT537lzAcqNz4sSJDB8+nMLCQmbOnInRaCQqKorXXnvNppryCy+8wKxZs3jnnXdQFIUuXbowduzYCpxl9XD58mU2btzIhg0byM7OBizTZAYZoIW+eldX1yoKnV2grbPKjgLYXGBZzuqzzz4jJCSEAQMG0LlzZ5uKzuLWVFVl586d/Pjjj5YK5c7umKMHg1sVtpdaHWqzPpgNvmjO7GH9+vWcP3+esWPHSiXuaujbb7+lXbt2tG7d2ibpTkhIoKSkhFatWlm3NWzYED8/v5sm3bVlpYfKVFfPu66Sz7u0Cv0F37lzJ3369OGPf/yj9ULS19eX6OhoWrduzZQpU/j9998ZP358pQYr7k56ejpffPEFFy5cwAl4zB0CbjHM0lWj8IS7yqzLlkJJ77//PhMnTpS5aVUkKyuL1atXs2nTJgoKCgBQNTrUBpGoDVvZdyh5ebh6oEb2oiSkA8r5IyjJJ0hNTWXhwoUsWbqUHt27c++999bpi8ucnBwaN2580/0ajcY69PlOtGzZkoULF950v6IojBo1ilGjRt30GHd3d1588cU7fu/qJi0tjRUrVrBjxw7rRa6HAr1dLUUhtTXoD7+TotDbFTo6q2zIh72Flqkks2bNYtGiRfTv359+/fpZL95F2TIzM/nhhx84ePAggKVCeYsB4OSA/zdFQW3chhKDJ9rjmzhx4gRvvfUWDz74IH369JGRQTfIz88nLS3NUqekjJGULVq0sMv7btu2jdOnT/Phhx+W2peVlYVOpyt1I/n6FSFuVBtWeqgM198oDAwMdGAkoqrJ511ahZLunJwc67y/qz0nV5MCsCwp9r///U+S7mrk4MGDfPvttxiNRjwUGOMBQeWY1+itVfiTp8p/L0OS0cg///lPRo4cyb333isXC3aSnp7OihUr2LZtm7UitOrqhRrUHDUgEnTVbO1XZzfU8C6oIe1RUk+hXIilOC+DDRs2sGnTJrp27cqwYcPq5CiJevXqcf78+ZvuP3HiRJ38f6kMmZmZLF++nC1btlBSUgJAkNZSoyLaCXQ1KNm+kZtG4T436OuqsqcQdhVYCsItXryY1atXM2zYMPr27SsF125QUFDA77//zqpVqygqKroy/aYdanCbqpl+cyt+YZR08EVzYguFOSn8+OOP1mU57ZVI1iSXL19m1qxZ7Nq1C7PZfNPjFixYUOnvnZ6ezvfff88bb7xRaWur1+SVHirT9eeanJzswEhEVatLn3d5V3qoUNLt5eVl7eF2dnbGzc3tumGvljuVRUVFFXlpUclKSkpYsmQJK1euBCxzGx9xtyTT5eWuUXjGU+WXPDhQpPK///2P+Ph4xo4di7u7u71Cr3OuJttbtmyxXnSongGYG7UB30b2K/pTWbR61MAo1AbNICsZzbkDmLMusH37dnbs2EGXLl34wx/+UKeSzB49erB8+XK6du1a6q7v2rVr2bFjB4899piDoquZsrKyWLVqFRs3brT2bEfooI8rhOhq15A2N41CH1fo4WIpuLYxHy7l5rJgwQJWr17NkCFDpNo5lgv7rVu3smzZMuvUAtXTH3PTHuBWjWoUuHpZlmC8EItyZi/nzp3j008/JTo6mpEjR9bpgqUzZ84kJiaGIUOGEBUVVaXXFgkJCWRnZ/N///d/1m1ms9laQ+X111/HZDKRl5dn09udnZ190+rlNXGlB3urq+ddV8nnXVqFku6IiAiOHz9ufd6hQwd+/fVXfHx8UFWV3377TQpLVAMZGRnMnDmT+Ph4AO5xtlTurUgPkP7KHO8QHfxmtPScT5kyhT/96U+1ptqxo6Smplp7tq3JtncQ5sbtwLsGDs9RFPAJwuwTBJfT0JzdDxmJ7Ny5k127dtG5c2fuu+8+goKCHB2p3Y0cOZKTJ0/y9ttv07BhQ8BSBTc3N5eMjAzatWtn0xsibi4zM5OVK1eyefNma7LdWGdZ+iusmhVIq2w6RaGdM7R2UtlfZCm4lpmZybx581ixYoU1+a6sXrqaoqSkhJ07d7Js2TLS09MBUF08MYd1Ar/Q6nmjUlFQG7ZE9W+CkrgfzYVjHDlyhCNHjtChQwf++Mc/1om28UYHDx5k2LBhPP7441X+3q1ateKf//ynzbZ///vfBAUFMXz4cPz8/NBqtRw+fJiuXbsCcOHCBdLT0+VaVwhRbhVKuocOHWqdP6fX6xk1ahRxcXFMmzYNgICAAJ5++ulKDVSUX2ZmJqtXr2bjxo0UFRXhrMAIN4h2ursLEEVR6OQCDXUqC3LhUkYGH330ER07dmTYsGE0atSoks6gbrh06RJLly5lx44d1juCqncQ5pD24FVLeoM96mOOHgSX09GcjYGMc+zatYvdu3fToUMHRo4cSUBAgKOjtBudTsdrr73Gli1b2LlzJ2azGZPJREhICI888gi9evWqVT2zlU1VVU6ePMn69evZFxNDyZWbUo100M8FIqp5gbTKplUUOjpD2yvVzjcXWHr+f/rpJ5YtW0aPHj3o27dvrZ83ajKZ2LlzJytWrODixYsAqE6uqI3aogZGgaYGVAfXu6A2uYeSoBYoZ/ahSTtFTEwM+/bto1OnTgwbNozg4GBHR1llnJ2dHfZz6+rqWqr2hrOzMx4eHtbt/fr1Y+7cubi7u2MwGJg9ezaRkZGSdAshyk1RK6n/32w2k5iYiEajoWHDhrViSYy0tDSb6pPVXXp6OitXrmTr1q3WeTSNtPCgO9S7g+Hk5VGgqvyaBwevm0XQpk0b7rvvPuu6v6Js+fn5/Pbbb6xZs+banG3fRpgbtQWv2puAApCbjibxAEr6GcBSSKxPnz4MHz68yoYT6vX6Wp+UVLXKbiuLi4vZsWMH69atIykpybo99Mow8ia1bBh5RZlUlf1Xku/MK9NgFUWhVatWDBw4kObNm9eq/6eioiK2bt3KypUrycjIAEDVOaM2aoMa1AK0Nbi6e14GmrP7rG0jWP6mDhs2jCZNmjgkpKpsK+fMmUNiYiJvvvlmlbzf7UyePJnQ0FCeeuopwPKzN3fuXGutlTZt2jBu3LibDi+/mZp2XXm3XnvtNeuNsVmzZjk4GmFvzzzzjPVxXfq8y9tWVlrSXRvVlMYxLS2N3377je3btll7ghrroI8LNLVzT1CKSWVTARwpgqs/SNHR0fzhD3+QYedlOHjwID/88AOZmZkAqF6BmMM7g0cdSwLzMtCc3oOScQ4ADw8PHnvsMTp16mT3JEGS7spXWW1lYWEhmzZt4vfff7dWBdYDbZyhizMElqP4Y11kVlXiimFXIZy87mMICwtj2LBhtGnTpkYXvszOzmb9+vVs3LiR3Nxc4ErPdsNWlp7t6lZc8m7kXkI5dwBN2mnrpoiICAYOHEj79u2r9HOsyrbyxIkTzJ49G09PTwYMGEC9evXKPNeaflO/plxXVhZJuusWSbpvrcJJt9FoZPXq1Rw9epTs7GyeffZZIiIiyM3NZePGjXTs2LHGF0yq7o3j+fPnWbVqlXXYKkD4lZ6gsCruCUovUdmUb+n5vlp3NCoqimHDhtW63paKSE1NZdGiRcTExACgunhgbtIVfBtXz3mHVSXzAppT21GMWYDlhs3DDz9snf9sD1WddB8/fpz169eTmppa5jI4iqLwySefVFk89nC3baWqqmzatIklS5ZYkypPBbq7QHtny/KFonzSS1R2FViWG7v6iQQHB/P444/TtGlTh8Z2p86cOcO6devYvXv3tVFBzu6ojVqjNogETQ3u2b4dYzbKuYNoUuNBtfxV9fPzo3///nTv3r3U8lX2UJVt5a2WN7yePaqXV6Xqfl1Z2STprlsk6b61Cv3FunTpEpMnTyY9PZ3AwEDOnz9vXTLM3d2dNWvWkJaWdsfzumNjY1m2bBmnT58mMzOTV199lc6dO1v3q6rKwoULWbduHXl5eURFRTFu3DibqsC5ubnMnj2bmJgYFEWhS5cuPP3007i4uFTkVKul+Ph4Vq5cyYEDB6zbmuqhrws0dlBBIT+twgPu0LfE0vO9v9CSbBw/fpyQkBCGDBlChw4danRvS0Xk5OSwYsUK1q9ff2VZIwVzcDRqSIeaPRSysvgEYW4/AiXxAJpzBzly5AhHjx6lV69e3Hffffj6VqPKwxWwfPlyfvjhB5ycnAgKCpJq/2XIyMjgu+++IzY2FgBfDfRygbbONXvZL0fx0yoMc4PerirbCyy930lJSUydOpVBgwYxYsSIal3tvLCwkD179rBx40ZOn77W26t6+mNu2Ar8QkCpA39HDF6ozXpREtoRJTkW5cIx0tPTWbBgAYuXLKFL58707duX0NBQR0daKZ5//nlHhyCEEHZVoav+H374gfz8fD755BM8PT1LrcfdqVMn9u3bd8evW1hYSGhoKP369StVSRLgl19+YeXKlUycOBF/f38WLFjA+++/z2effWat2vrll1+SmZnJG2+8QUlJCTNmzGDmzJm8+OKLFTnVaiM3N5ddu3axZcsWzp2zDMlVgOZ66OUKwdVk2KWvVmGEG/RxsVzw7S2Es2fP8p///AcfHx+6d+9Ojx49av3w3pycHFatWsX6DRsovrJ8nurTEHN4l+q1hE11oNGihnagJCACTcJuuHSWTZs2sW3bNnr27MnQoUNrbPK9bNkyoqKi+L//+z8MBoOjw6l24uPj+eKLLzAajeiAgQbo6mwpGCbujrtGYZABerqorDDC/iKV33//nePHj/PSSy/h4eHh6BBtZGRksH79ejZt2oTRaLRsVDSY64ehBrUET3/HBugozgbU0I6ojdqipMajXIilOC+DrVu3snXrVsLCwhg4cCAdO3as0bV0+vTp4+gQhBDCriqUdB86dMhaWfPqet3XCwgI4NKlS3f8uu3ataNdu3Zl7lNVlRUrVjBy5Eg6deoEwKRJkxg/fjx79uyhe/fuJCUlceDAAT788ENr4ZGxY8fy4YcfMmbMmJteuBcXF9sM91EUBVdXV+tjRzGbzcTGxrJ161b27dtnHV6nxdIL1MMF6ldygbTK4nOlt6WPq8rOAthZaKmqvnz5cpYvX05UVBQ9evSgQ4cOODs7OzrcSmM2m9m8eTM///wz+fn5AKge9S0VyX2luvstuXphbjnQssb32RhM2Sls2LCBbdu2MXLkSPr371/jLioLCwvp0aOHJNxliI2NZdq0aRQWFtLwSsHH6tqe1WSuGssopJZFKovzLDdBp06dyiuvvIKPj4+jwyMxMZHff/+d3bv3YDaXAFeGkAc1Rw2IBCdXB0dYTWh1qIFRqA2aQU4qSnIsmrTTnD59mq+//ppFixYxYMAAevXqZb1+qakyMzPJzs6mQYMGtWqUohCibqtQ0l1UVISnp+dN919NNipTamoqWVlZtG7d2rrNYDAQERFBaIefFQABAABJREFUXFwc3bt3Jy4uDjc3N5tKn61atUJRFOLj422Gql9vyZIlLFq0yPo8LCyMqVOnOqw39uLFi6xZs4Y1a9aQmppq3R6ohQ7O0NoJDDVkjqObRqG/AXq5qhwvgphCOGW6NvR83rx59OnTh8GDB9O0adMaPff7woULfP755xw5cgQA1b0e5tCO4BNct+dt3ynvQMze90HWBTRnYijKucj8+fOJiYnh5ZdfrlHDKVu2bEliYqKjw6h2jh07xpdffklxcTEROnjMA5zkd8SuopwUxmtVvrsMycnJfPLJJ/ztb3+74+rLlSUpKYmlS5eyf/9+6zbVqwHm4FaWG5R1YQh5RSgKeAWgegVQEt4VJfkYyoVYMjIyWLhwIcuXL2fo0KH069evxt3Q3rNnDz/++CPJyckAvPnmm0RHR5OTk8N7773Hgw8+eNPrOCGEqO4qlHQHBwdz7NgxBg4cWOb+PXv2VPqF8dVKtl5eXjbbvby8rPuysrJK3QzQarW4u7tbjynLiBEjuO+++6zPryZ+aWlp1t5lezObzRw8eJD169cTGxtrLbbkokAbJ0uyHVRNhpBXhF5RaOUMrZwhq0RlXxHsK4Qso5EVK1awYsUKGjVqRJ8+fejWrVuNuli4WgRqwYIFFBYWomp0qGEdLUvYyIVjxXkHYW4TiJISh3J6FydPnuTPf/4zI0aMYPDgwRWuD6DT6arshtrYsWN5//33WbZsGf369ZM53ViKY3311VcUFxcTpYdH3GXudlWpr1UY76Ey67Ll5u6nn37Ka6+9VqU9o5cuXWLx4sXs2rXryt85xTKEPLhV3VvF4W45uaKGtEdt1BrlYjxK0mGMxmwWLVrEmjVruP/+++nVq1eNqKWyd+9e/vnPfxIZGUmPHj34+eefrfs8PT3x9fVl48aNknQLIWqsCiXdQ4cOZfr06TRu3Jh77rkHsCSNKSkp/Pzzz8TFxfHKK69UaqD2pNfrb1pYxt4rquXm5rJlyxY2bNhgMyQ/XGdJtFs4WRLW2sRbq9DP1TLv+7TJ0vsdWwTnzp3jhx9+YNGiRfTo0YO+ffsSEFC9163Ozc3l+++/t/bWqF6BmJv1ApfqNV+yxlIU1MBmqL6N0JzcginjHD///DNHjx7lmWeecVgvXXn5+fkxYMAAfvjhB3788UecnJzKvACeM2eOA6JzjCVLllBYWEgTHYyShLvK+WgVxnqofJNjGZ2zZcsWBg0aZPf3NZlMrF27ll9++YWiq3Uu/MIwh7YHg+OHuddomqtDzyNRUk+hnIkhOzubH374gc2bN/PEE09U+xFC//vf/2jRogVvv/02ly9ftkm6ASIjI1mzZo2DohNCiLtXoaS7V69e1iqa8+fPB+CDDz5AVVU0Gg2PPvpopd+NvHpxnZ2dbTMPLTs72/rHxNvbm5ycHJvvKykpITc3t1pcnBuNRs6dO8fZs2dJTEzk7NmzJCcnWxN7VwU6OkMnZ0tBstpOoyg00UMTPRjNKgeKYFcBXMrPtw6vr1evHiEhITRu3Nj6b3X4LMHSYzd9+nQyMjIsBX/COqE2jJah5PbgbMDcchBKygk0p3YSGxvL5MmTef7552nWrJmjo7upBQsWsHjxYnx9fWnSpEmdn9t96dIl6/SLP7jVvhuKNYWvVqG3q8pyI2zevNnuSXd6ejrTpk2zFgFVPQMwN7kHPPzs+r51jqJBDWiKWj8cJfk4ypkYzp49y3vvvcewYcP44x//WG2ncCUmJvLkk0/edL+Xl1ep6zshhKhJKrxm0ciRI+nVqxc7d+4kJSUFVVUJCAigS5cudumd9Pf3x9vbm8OHD1uTbKPRSHx8vPWCITIykry8PBISEggPDwfgyJEjqKpKREREpcd0K2azmVOnTnHy5Elrgn39/OzrBWqhq4tlrnZdvQg1aBS6uUBXZ5X4YkvhtZPFlov0S5cu2VTD9/Lysibh4eHhNG/e3Fq9vqrs27ePmTNnYjKZUF09MTfvB+5yAWlXioIaGEWJVwM0x9Zz+XIG//znP3nyySfp0aOHo6Mr05o1a2jfvj1//etfa8QQT3vTarU4OTlRVFTEnkK411WttklAbVakqhwotDy299Dy5ORkPv30UzIzM1F1zqjhnS0F0uRztx+NFrVhS9T6YSindqFJO8Xy5cvJyclhzJgx1bItcnZ2ti49W5aLFy/K9BwhRI12VwsF+/n52cyFvlsFBQWkpKRYn6empnLmzBnc3d3x8/Nj6NChLF68mMDAQPz9/Zk/fz4+Pj7WaubBwcG0bduWmTNnMn78eEwmE7Nnz6Zbt25VsuSQyWTi+PHj7Nu3j/3795d5V9ZLA0FaCNJZ/g3UgWcNKYpWFTSKQqQTRDpBvlkluQSSTXChBC6YIN1sGd1w+PBhDh8+DFj+WEdHR9O+fXtat25t997E7OxsZs+ebUm46zXG3KwP6Ko26a/TDN6Y296PcnILpJ7iv//9L5GRkfj7V78lhUwmE+3bt6+WF7mO4O3tzdixY/nPf/7DtgI4WwwDDSpN9NIGVoUSVSWmEDbkw2XVUoz02Weftdv7mUwmPvvsM0vC7eqFufVQcHaz2/uJGzgZUJv3xewThCZuK5s3b8bPz49hw4Y5OrJSWrZsyaZNm8qMLSsri3Xr1tGhQwcHRCaEEJXjrpJusCTKubm5Ze7z87uznr9Tp04xZcoU6/O5c+cC0Lt3byZOnMjw4cMpLCxk5syZGI1GoqKieO2112x6OV944QVmzZrFO++8g6IodOnShbFjx1bgzMqvuLiY+fPns2vXLpvK7S4KROih4ZXkOkhbc6qOVweuGoVwDYRfN92+SFVJuS4JP2WC7MJCYmJiiImJQavVEh0dzZgxY+y2HM7mzZvJz89H1btgbjFAiqU5glaH2qwPak4axQU5rFu3jkcffdTRUZXSvn37WxadrIs6depEVlYWixcvJqmoiO8uQ7hOpYsLNNPLHG97yDOrHC6CHQVwyWzZ5uvry7hx4+xaVDA1NZWMjAxUjQ5zm/tk+S8HURs0w1xciOb0bmJjY6tl0v3oo4/y+uuv849//IOuXbsCcODAAY4cOWKdy/3ggw86MkQhhLgrFV4ybNGiRaxfv77MdbqvWrBgwR29bsuWLVm4cOFN9yuKwqhRoxg1atRNj3F3d+fFF1+8o/e9W2lpaWzcuNH63EWB4QZo7iQXkJXNSVForIfGVxJxVVU5Z4IleZBmtszhP3jwIO3ataNnz552iaFly5b8+uuvlBQXoJw7hNq4rV3eR9yaknICpSAHRVFo1aqVo8Mp00MPPcTnn3/Ot99+S79+/fDz8yuz17uuDZscOHAgnTt3Zvny5WzatIkEUwkJuZa6FtFOKu2coJEOGXp+F4pVlRPFcKAQ4orhSq6Nh4cH9913H717975pAdHKYl01RKuzfAnH0VtWBMnOznZwIGULCgrinXfe4fvvv7deO/76668AtGjRgmeeeaZajmYSt2bvYsRC1CQV+iv47bffsmnTJjp16kTz5s1xc6vbw8WCgoJ45pln+PXXX0lNTaVAhWVGaKgDX62jo6vdzMAvRkvCDZbhkgMGDLBW1beH8PBwxowZw/fff48mcT8l/k2kWnlVKy5AOb0bgAceeIDo6GgHB1S2v/zlL4Cl6N6tKu/e6Q3K2sDLy4vRo0czaNAgNm7cyK5du8jMzGRPIewpBG8NROlVopwgVCc3MMsj36wSVwzHiy2JduF117shISHcc8899OzZExcXlyqJJzw8HF9fXzIyMlBObkON7AEaSb6rXO4llNN7AKzT8aqjRo0a8eabb5Kbm2tTK+jGpWCFEKImqtBfv927d9O/f3+7zgWrabp160bTpk157733yM3NpVCFYrnBZ3dmwHgl4VYUhfHjx9O6dWu7v2+PHj1YtmyZ5WIy45xlTW5RZZSsCyimIlxdXatkuaOKeuCBB6S39jbq16/PQw89xAMPPMDx48fZsWMHMTExZBUWsrPQUlTRWYFIvUqU3jJlx02m6QCWXqRLZkuCfbwIzpiu9WgD+Pj4cM8993DPPfcQFBRU5fG5uLjwxBNP8Pnnn6NJjUe9nIa5WW/wlB7LKmE2o5w7iCZxP6hmGjZsyNChQx0d1W25u7tXefFbIYSwtwol3YqiEBYWVtmx1GhpaWlMnTqV3NxcDAo84g4BOrkwtDe9ojDeU2VeLqSUqEyfPp0///nPdu/5vHjx4pWlwhTUeiF2fS9RmurdEFWrJz8/n9OnT1fbC7SHH37Y0SHUGBqNhhYtWtCiRQsef/xxjh07xoEDBzh48CA5OTkcLoLDluWdCdSqluUGdRCit0w7qStyzSqnirF8mSDbbLs/KCiItm3b0qZNG8LDwx1exK9Vq1b8+c9/Zu7cuWRnZ6M9sAzVMwC1fjhq/TBwqtvL6FU6VYWcVJS0Uyjpp1GKLHVm2rZtyxNPPGH3KQUVtWnTplvuVxQFvV5PvXr1CAsLq7bnIYQQN1OhpLtjx44cPnxYigNdkZmZyccff0xmZibuCoz3hHp1YJ3t6sJXq/Csp8r3lyHRZGLatGm89NJLdl2/2dnZMj8OVYXcdMuFYx268He4vEtgLgGosqGyouo4OzvTtm1b2rZti9ls5vTp0xw4cIBDhw6RlJRkWdWgBLYCWqCxTiVcD2E6CK5lQ9GNZpWzJjh9Jcm+WGK7X6fTERERQZs2bWjTpo1dluy8W23btv1/9u47PKoqfeD4904mbRJSIAlpkEqAUELonYgICqwoVkDFAroru+vqz3VVLKBix5VV2HUVFFxAEAUbIk2QDhKkBVJIbyQhvWcy9/fHkDEhAUJIMknm/TxPHmbm3sy8k8ucue8957yH4OBgvvjiCw4cOIBSeB6l8DycO4jq7GlMwF19wV6m6TSJodqYaOcmo2THo1SUmDZ16tSJe++9l2HDhrXpUTfLli1r9L46nY7bbruNadOmtWBEQgjRvBqVdF9anfyOO+7gn//8Jx999BE33XSTxRcH+u2334y9nkCxCh8WgK9WpZsWumuNBYFkOGTzqlRV0vSQrIeUi/+WXhzOX1VVxS+//NKiSberqyv9+vXj5MmTWJ3ehurshSF4BDi0/NJ0Fq2sEM25Ayi5KYBxzqivr6+ZgxItSaPREBQURFBQEHfccQcFBQWcPXuWqKgooqKiyM3NJUEPCXrj/lqgm1YloFYSbt2Gk41LlRpUEi8m2QkXk+xLZyp169bNNCqgR48ev18EbMMcHR2ZM2cO06dP59dff+XIkSPEx8ejFGSgFGQAoNp1QnXxBhdv479S7bxhqgoluSh5aSj56VCQiWLQmzbb2dkRHh7OkCFD6NOnD1pt259H//bbb7N06VI6derEpEmT8PT0BIzrvP/000+UlJTwyCOPkJ+fz5YtW1izZk2bn14khBC1KWojSgteqVr4lbT34kDZ2dlUVVVddb/y8nJ27NhBTEwM586dq7NsWA1vK7jBHnpZS0Xe65GuV9lRBrFVdecugrHHx9/fn8DAQG688cZrXrLuWpWWlvLDDz+wfft29Ho9aLRUh94Inbu16OtarIJMNKe3oegr0Gg0REREcOutt9Kp07X1jllbW7foMkmWqLFtZXNTVZWsrCyioqKIjo4mOjqawsLCOvtoMV787GFt/Olq1bbaYL2qkqw3tmlxVcYe/Et5enrSs2dPevbsSWho6DX/n2+rcnJyOHLkCMePH+dcfDyG6rpvXnXojOrqg+riA86ell0BvbwIJS8N8tONNS2qyutsdnJyIjQ0lEGDBtGvX79mGX7dmm3lsmXLyMvLY/78+fW2qarK66+/TpcuXfjjH/+IwWDg5ZdfprS0lMWLF7dKfM3FXG2luTz33HNkZWUBsHz5cjNHI1raI488YrptSce7sW1lo77BpBjQldnZ2TFlyhSmTJmCwWAgIyODc+fOERcXR3x8PBkZGaRXw+pi8LWCm3QqQdby97wW2dUq20vhdK3vKhcXF4KCgggODiYoKIju3bu36jwvnU7HXXfdxQ033MCnn37K2bNnsTq9leq+N4OrT6vFYRGKsrE6+SMYqgkICGDOnDmmnhBhuRRFoWvXrnTt2pUbbrgBVVXJzMwkOjqas2fPEhMTQ0FBAfF6iNfDT2XQSYFga9WUhNubYRRSbrWxynhslbFHu/KS7V5eXqYku2fPnjg7O7d6jK3Bzc2NW265hVtuuYXy8nJiYmI4c+YMUVFRpKamopTkopTkQupJVEUDTl1RXb2NSXgnN1DMO1+9RVWVQ34GSn4aSl46Snndi0m2tramizC9e/fGx8enXZ+nHTlyhBkzZjS4TVEUBg8ezBdffMEf//hHNBoNw4YNY+3ata0cpRBCNF2jkm4pBtR4Go0GHx8ffHx8GDt2LACFhYVs27aN7du3k1pZyadFMMtRpbdN+/2CbE151Sr/LoRK1fjlO3ToUKZOnYqXl1ebOMlwc3PjySef5JNPPuHIkSNoYn7BEDQcXLtZds9MczBUQ14amvhDYKimb9++PP744+1iOK1ofYqi4OXlhZeXFxEREaYk/PTp05w6dYro6GiKKis5VgnHKo3zwXtYq/SzgV42YNuC7UmhQeVkJZyogLRLerOdnJzo06cPffv2pXfv3h02yb4SOzs7+vfvb1p9orCwkDNnznDmzBlOnz5tnMJlGop+FFVri9qlu7GQpatvx2hrywpRLiSi5CShFGZRe2KBxsqKoMBAevfuTWhoKAEBAe1i2HhjGQwG0tPTL7s9LS2tzprPWq0WGxub1ghNXIe2cI4mRFvRcVrsNszJyYk77riDCRMmsHbtWo4cOcJPpWBAxdMKXDWgkYapniKDSqYeDlQYE24/Pz8efvjhNjmHV6vV8uCDD5KQkEBOTg5WUTtQraxRu/gZK/R28pD5iY1VVQ5F2cbKuzlJKPoKwFgQaM6cOZJwN9L69evZsGFDnce8vb15//33AaisrGTVqlXs37+fqqoqwsLCmDNnDi4uLq0fbAupnYRPmDCBqqoqYmNjOX36NCdOnCA9PZ2zF9e1ti6BXjYqg20hUNs8J4t6VeV4JRyrgCT97ymUoiiEhITQt29f+vbti6+vr9mrjLc1Tk5ODBs2jGHDhpmmEdT0gp85c4bS0lKU87FwPhZVYwWuPqhd/FG7dAfrdlJcUVWh5AJKzsVEuzSvzmZvb2/69OlD7969CQkJwd6+436HDB48mJ9++glPT0/Gjx9vSqgrKyvZsWMH27ZtY+TIkab9Y2JiZLSTEKJdkaS7FTk7O/PAAw9w+vRpckpLWXuxPp0N4Kk1JuCeVuClNc47tJRlcKpVleyL1YjPV0OGHjKroeSSagOzZs1qkwl3DTs7O/7xj3+wY8cODh8+bFzDOysOsuIAUG0doZMbqqMbaic3cHRrPyeHLUVfCcU5KEU5UJyNUpSDUl5UZxdnZ2cGDx7MhAkTOsxc1tbSrVs3XnzxRdP92ondypUriYyM5KmnnkKn07F8+XIWL17Mq6++ao5QW4W1tbWpANldd91FWloahw8f5vDhw2RlZZmWJfO1grH2xnXBm3JBtEJV+bUc9pVDYa12rEePHgwdOpRBgwZZZG92U9WeRhAREUF1dTVxcXEcO3aMY8eOkZOTAxeSUS4kG4ehu/oYK6J38QNtG+wNLck1VhnPjkcp+33YuEajoWfPnoSHhzNgwAC6dOlixiBb10MPPcT58+f59NNP+fzzz00X//Lz89Hr9QQHB/PQQw8BxkTcxsaGKVOmmDFi0RiNKBslhMVoVCE1S9VSBS+SkpLYsWMHqamppKWlGYtwXUIBumiMQx772RgLsXWkYTq51SqnKiGq0phsN1A7yHSi1a1bN4YOHcrAgQNbPc6mMhgMxMfHc/jwYU6fPs358+cb/PJR7Z1RO3dD7dzNWChIY2WGaFuRaoCC8yh5KSi5KSgleQ3u5uHhQe/evRk6dCghISHN2gtoKYXU1q9fz5EjR3jnnXfqbSstLeWRRx7hiSeeYPjw4YBx+OaTTz7Ja6+9RkhISIPPWVVVVadNVBQFe3t7srOzG2zH2gtVVUlMTGTv3r3s3bvX9B7dNTDFAYIbWYOjWlU5VAE/l0HZxY+7i4sLN954I8OHD7eoJKq1qKpKamoqx44d49dffyU1NfX3bYoVdPbF0LUHdO4O5hxNUFGCcj4WJSsOpTTf9LC1tTX9+/dn4MCB9O/fHwcHB/PFeAmtVtuqbaWqqhw+fJjjx4+TnZ0NgLu7O2FhYQwZMqRDjAaRQmqiI5NCalcmPd1mUDNMGkCv13P+/HlSUlJISUkhNTWVlJQUCgoKyDHA3nLjj6sG+toY5x56a9tn8p13MdE+VVl/TqO9vT2+vr5069bN9K+Pj0+7HUqs0WgIDg4mODgYgLKyMpKTk0lMTDT9ZGVloZQVoKQVQNopVCtrcPHG4NnTWAG9A11kIT8dJeOMcYkbfd2yUW5ubvj5+eHv74+/vz9+fn5t6sSzPcvMzOSxxx7D2tqakJAQZs6ciZubG/Hx8VRXV9OvXz/Tvj4+Pri5uRETE3PZpHvjxo11hqwHBATw1ltvdYiLGN7e3owcOZJHH32Ub775hu+/+47skhI+K4J+NiqTddDpCkXXUvUq35T8Xn3cx8fHVGhR5p62LG9vb4YOHcpjjz1GcnIye/bsYffu3aSkpMCFJKwuJKFa26F27YHaNQQcXFsnMEM1XEhCkxljrDx+cYKBVqtl8ODBjB07lmHDhqHT6VonnjZOURTTlILWtHHjRg4fPkxaWho2NjaEhIRw33334e3tbdrHEqbjCCFalvR0X4E5r0gWFhYSExPDr7/+yvHjx6ms/D1RCdLCRB34tJPkO79aZWeZsXBR7TmNvXr1YsiQIYSGhuLm5tahevIbo7i4mLNnz3LixAlOnjxZZ6kj1cUbQ+AwcGznPWOl+WjiD6PkJpsecnR0pG/fvvTv398syx9ZSk/3sWPHKC8vx9vbm7y8PDZs2EBubi6LFy/m6NGjLFu2jDVr1tT5neeee44+ffpw3333NficHbWnuyGlpaVs2rSJHTt2oKoqDgo83Am6NtDuRlaobCwxtm86nY4777yTsWPHdoieufaqpgf8wIED7N+/v2776tQVg28/6NK9ZSqgV5aipJ8xXmistbRXSEgIo0aNYtCgQe0i0W7Nnu7XX3+dsWPHMnTo0Fa/SLVo0SJGjRpFUFAQ1dXVrF27lpSUFN577z3s7IxTwD7++GMiIyOZN2+eaTqORqO55uk40tMtOjLp6b4y6eluo5ycnBg8eDCDBw+moqKCkydPcuTIEY4dO8Y5fTX/LoQ+1iphtuCjBSelbQ0/LzOopFVDTCUcroCa0/GePXuahoo7OTmZNUZzc3R0NB1jg8FAcnIyhw4dYufOnejz07GK3Ghcp9YtwFiMTedi7pAbp6zwYhG0RJQi4xBBjUbD2LFjGTFiBIGBgZKMtILw8HDTbT8/P3r06MHjjz/OgQMHmnxSa21tfdll+Tra9Vt7e3tmzJjBiBEj+PTTT0lNTWVFETzcSa2TeB+rlXAPGTKEmTNnmtq2jvY3aW98fX256667uP322zl16hR79+7l+PETGArPYxV1HtWuE6pPH1TPXs1T/bwkDyX1JJqsOONUGozTC0aOHMmoUaPqFP6S/xt1nT9/ng8++AA7OzuGDBnC2LFj6devX6uc11y6Nvi8efOYM2cO8fHxhIaGUlpays6dO3niiSfo27cvAI8//jhPPvnkZUcGXe4CZc1tS2Sp79tSyfGuT5LudsDW1taUnOXk5PDNN99w4MABTleppnWrHRXw1qr4WBmTcG8tOLXS+rNlBpX0akjXG4eNp+khz1B3n549e3LHHXcQFBTUKjG1NxqNxjS8evz48Xz99df8+uuvGGrWqU06iqpzQXXqCp3cUTu5g87VvHMUwXhiWZpvLIRWlI1SeN4Y70WKohAWFsadd96Jl5eXGQMVDg4OeHt7k5mZSf/+/dHr9ZSUlNQZyl9QUCDDJS/h7+/PM888w+LFi0lKSmJtMcxzVrFWFDL1KpsuJtwRERHMmjVLLii1QVqtlgEDBjBgwADy8vL4+eef2bVrFyUlRSjnDqKmnjKOLHLzb9q0nqpylKRINOlnqBnPFRQUxE033cTAgQOxsurgtTqawZIlS4iLi2PPnj0cOHCAPXv24OLiwujRoxkzZgz+/v6tFktpaSlgvDAONGk6TkeeinMtai9rJ+cAlkWOd32SdLczbm5uPPLII0yaNIkdO3aQkJBAWloaxQYDMVUQU2vUUidFJdAahtiCXzMtgVMjp1rlcDlEV8EFQ8P7eHh44Ofnx6hRo+jbt69c9Wokd3d3HnvsMWbNmsWxY8c4evQoUVFRVJfmGwvwZEYDGJfJceyC6ugOTh7GYmwtXam3ugryUlEKzl+sOJ6DYqg7rLimAu/gwYMJDw+XKs1tRHl5OZmZmYwZM4bAwECsrKw4efKkqZBaeno6OTk5l53PbckcHBx46qmnePnll8nJz2dnGdxkr/J1ibEI5IABAyThbidcXV2ZPn06U6ZM4cCBA/zwww/k5uZidWaHcVpPyBiwa/yUF+V8LMq5g6alDcPDw7nlllvkAnMT1NRBmT17NidOnGDPnj1s376d77//Hl9fX8aOHcvo0aNbtCChwWDgs88+o2fPnnTv3h0wVlDXarX1ao04OzuTn5/f4PPcfvvtTJ061XS/5vynI07FuZLa7zUjI8OMkYjWZknHu7FTcSTpbqd8fX2ZPXs2YCzwkZKSQlJSkqlIV3p6OkUX14g9XmlcimyorXE4um0Tk99qVSWmCg6Ww7lLvjOkGFbzc3R0ZMyYMYwZM4bS0lKioqJITEwkISGBpKQkysrKoDALpTAL0k8bl8px8UZ1u7hWrU0zzRmsKke5kIxyIRHy0lAMdavg2dramo59QEAAvXv3lqW92oBVq1YxePBg3NzcyMvLY/369Wg0GkaPHo1Op2P8+PGsWrUKR0dHdDodK1asICQkRJLuy3B0dOT+++/ngw8+4FA5+Gohvdo4DP2BBx6QhLudsbW1JSIighEjRvDjjz/y448/os9PR3PsGwy9bwSXq/TSGAwo8QfRpEcBxmJuM2fOpHfv3q0Qfcem0WhMIxNKSkr473//y8GDB1mzZg1r166lT58+TJkypUVWNFm+fDkpKSm88sor1/U8ljQVp7Es9X1bKjne9UnS3QHY2NgQFBRU58p6RUUFSUlJ7N+/n0MHD5JZVcW3pbCtDEbbqQy3a3zybVBVTlQal8Gp6dVWFIV+/foxduxYevToYRqGJVqGTqczTTEA49X4rKwsUxJ++vRp41XFvFSUvFSIBdUtAEO3MOjk1rQXLclDSTmOJvsc1Go8PTw86NOnDwEBAQQEBODp6SkJRxuUm5vLkiVLKCoqwsnJiV69erFo0SLTfOPZs2ejKAqLFy9Gr9ebqvGKywsLC6Nr166cP3+etcXGx0aMGCGjOdoxW1tbbrvtNkaOHMm///1vkpOTsTq5mereNxqHmzdENaCJ2oaSmwLArbfeytSpU2UYeTM6e/Ysv/zyC4cOHaK4uJhu3boxduxYtFotP//8M2+99RbTp0/nnnvuabbXXL58OZGRkSxcuLBOb7qLi4tMxxFCXDdJujsoW1tbU6/VXXfdxb59+/j555/JyspiWxnsL4exF5Nvqysk31GVKttKIftisu3g4MCYMWOIiIiwuLlJbYlGo8HT0xNPT0/T8OCMjAwiIyM5duwYCQkJKDkJWOUkoLr6Ygga3vhCbOVFaOIPoeQkmh7q1q0b4eHhDBo0CB8fH5kq0A787W9/u+J2Gxsb5syZI4n2NVAUhcGDB/PDDz+YHqu5ECbaNw8PD5599lk+/fRTjhw5giZ6NwadS4PtppL4K0puCjY2NsydO7dFelwtUWpqKr/88gv79u0jJycHZ2dnxo0bx9ixY+vM6Z48eTIfffQRP/30U7Mk3aqqsmLFCg4fPsyCBQvw8PCos12m4wghmoMk3RbAwcGBiRMnMmHCBA4dOsS3335LVlYWP5ZBbBXc20nF7pIkyqCqbC0zrhEOxp7Wm2++mfHjx5sqcIq2xcvLiylTpjBlyhRSU1PZvHkzhw8fhrxUrI5uxOA/ENW33+WXyFFV4xI38YdN87QHDhzI5MmTCQgIaMV3IkTb1aNHD9NtKysr+Wx0ILa2tsydO5fCwkKio6PRnP0ZQ/htdYurFWSiSTkBwMMPPywJdzP5+9//TnJyMtbW1gwePJg5c+YQFhZ22VFUffr0YefOnc3y2suXL2fv3r0888wz2Nvbm+Zp63Q6bGxsZDqOEKJZSNJtQTQaDSNGjGDo0KHs27ePtWvXEldZySeF8FAnFYeL1c4Nqsr6Ejh1cWnwm2++mSlTprSLdUWFka+vL48++ii33XYbq1ev5tSpU2gSjmAovoDaK6J+4q2qKHH70GScBYyJxf3334+Pj0/rBy9EG1b7M+Hm5tbqawqLlmVlZcVjjz3G888/T3nxBZTseFSPi1O3VBVNwhEAxowZw5AhQ8wYacfi4ODAY489xvDhwxt1rjFkyBA+/PDDZnntrVu3ArBgwYI6jz/++ONEREQAMh1HCHH9JOm2QFZWVowdO5bu3bvzr3/9i8yCAr4qgfscVTSKwu5yY8JtZWXFQw89xIgRI8wdsmgiDw8P/va3v7F3714+//xzyI7HoCioPSPq9N4o5w6iyTiLoijcfffdTJgwQeZpC9GA2nM4ay+HIzoOZ2dnJk2axDfffIOSegLVPdDYXhaeRyk8j7W1NdOmTTN3mB3KpQnv1dja2jbbFLf169dfdR+ZjiOEuF5yVm3B/P39efLJJ9FqtcRUwZEKSNOr7Cwzbn/wwQcl4e4AFEVhzJgxzJs3D41GgybrHEpmzO875CSiST+Noig88sgjTJw4URJuIS6j9mdDaht0XOPHj0er1aIUX4DiHACUDONyjUOHDsXV1dWc4XU427Ztu+L2yspKli9f3krRCCFE85MzawvXrVs37rzzTgB2l8POMlAxDt0aOXKkeYMTzSosLIzp06cDoCQcAn0lGKrRxB0AjNMI5CKLEI0nSXfH5ejoSHh4OADKhSRQDSi5yYBxaLloXp988gmLFi0iNze33rYzZ87wf//3f+zYscMMkQkhRPOQpFsQERGBk5MThQaIrjI+duutt5o3KNEiJk2ahJeXF4q+EiXjLErWOZTKElxcXGS4pBBC1NKnTx8AlPx0KM5F0Vdgb29PYGCgmSPreP7yl78QHx/P//3f/7Fr1y7A2Lv92WefsXDhQmxsbHjttdfMG6QQQlwHmZAmTNVCayqB+vn54e3tbeaoREvQaDRMmDCBzz//HCU7HrS2gHEopbW1tZmjE0KItqNXr17GG0XZKHmpAAQHB8t63C1g9OjR9OnTh48++oh///vfHDhwgMzMTLKysrj11lu5++67pYaCEKJdk55uARhPJGoEBQWZMRLR0mqWuFGKc1Dy0wAYNGiQOUMSQog2x83NDRcXFxRVRUk7BSBLRLUgV1dXnn76aYKDg/ntt9/IzMxk1qxZzJw5UxJuIUS7J0m3AIxVrhu6LToeJycnfH19TfddXV3p2rWrGSMSQoi2R1EU01BypaockIvSLSkxMZFnn32W+Ph4Jk2ahK+vL6tXr+Z///sfer3e3OGJJpC6F0L8Ti4dCsC4REqN2kviiI6pW7dupKammm7LF6MQQtTn5+dHZGSk6X737t3NGE3HtX79ejZt2oS7uzsLFiygZ8+e6PV61q1bx/fff8+xY8eYN2+ezKcXQrRb0tMtALCzszPdlvlqHZ+bm1uDt4UQQvyu9lrQjo6O2NvbmzGajuurr75iwoQJvPPOO/Ts2RMArVbLrFmzeOWVV6iurmb+/PlmjlJcK1VVzR2CEG2G9HQLgDpFtKTXs+Pr1KmT6bajo6MZIxFCiLarc+fOpttdunQxYyQd24svvkjfvn0b3NajRw/eeecd1q5d28pRCSFE85GkWwDUKVIiVyY7vtq9NTqdzoyRCCFE2+Xq6mq6LVOvWk7thLu8vJycnBzAOBLLzs4Oa2trHnjgAXOFJ4QQ102SbgFI77alqZ1oy3BJIYRomJOTk+m2LKvYsuLi4li9ejVnz57FYDAAxmUue/XqxX333SdF7IQQ7Zok3UJYIFtb2wZvCyGE+J2NjY3ptowCazmxsbEsWLAArVbL+PHj8fHxASAtLY19+/bx8ssvs2DBgjrLmwohRHsiSbcQFqj2dALpvRFCiKuTEWEt54svvqBz5868+uqr9Ybx33XXXbz44ousXbuWF1980TwBCiHEdZLq5aIeObHo+Gon2rUTcCGEEA2T78aWExsby0033dTgvHkXFxcmTJhAbGxs6wcmhBDNRJJuUY8Moev4aifdtYdPCiGEEK1NURSqq6svu91gMMhFDyFEuyZJtxAWqPY8bkm6hRBCmFPPnj356aefyM7OrrctJyeHrVu30qtXLzNEJoQQzUPGlQphgWon2jKnWwghhDnNmDGDl19+mb/97W8MHToULy8vANLT0/n111+xsrJixowZZo5SCCGaTpJuISxQ7XncGo0MeBFCCGE+AQEBvP7666xdu5Zff/2VyspKwHiBeMCAAdx77734+vqaOUohhGg6SbqFsEC158bJHH4hhBDm5uvry9///ncMBgOFhYWAcZ10uTAshOgIJOkWwgJJQRohhBBtkUajabCKuRBCtGdy+VAICyRJtxBCCCGEEK1Dkm4hLJwk4EIIIYQQQrScDju8fMuWLXz33Xfk5+fj5+fHww8/THBwsLnDEqJNqL0eqszptmzSVgohRONIe3lt5KK+EL/rkD3d+/fvZ9WqVdx555289dZb+Pn5sWjRIgoKCswdWrsgjWTHl5GRYbrd0LqowjJIWylE4+n1enOHIMxI2kshxPXokEn3999/z4033sgNN9yAr68vc+fOxcbGhp9//tncobUL0vPZ8f3www+m25s3b5ZjbqGkrRTiysrLy023pZ20bNJeXjv5zAjxuw43vFyv1xMfH89tt91mekyj0dCvXz9iYmIa/J2qqiqqqqpM9xVFwd7e3nTb0iiKYpHv21LExMRw/Phx0/24uDiOHz9OeHi4GaMSrU3ayuunqqpFvm9LkpaWZrqdl5cnx9tCXWt7KW1lfZb6vi2VHO/6OlzSXVhYiMFgqLfchIuLC+np6Q3+zsaNG9mwYYPpfkBAAG+99Rbu7u4tGWqbY2dnR3l5Of3798fLy8vc4YgWsnfv3nqPZWRkMHnyZDNEI8xF2sqmc3d3Jzs7mwEDBkhb2cFlZmaabhsMBjneFupa20tpK43uvPNOli1bRkREhHx2LMCkSZP46aefGDFihBzvBnS4pLspbr/9dqZOnWq6X3N1Jjs726LmcL344osUFhai1WrrzPkVHcvgwYPRaDRUVlYCoNVqGThwoMUcc61Wa3EnPs1F2kqjZ555hpiYGMLDwy3mc2OpPDw8+Otf/0p+fj6hoaEWdbylrWw6aSuNBgwYwF//+ldCQkIs6rNjqW699VYCAgKkrbzcfq0QS6tycnJCo9GQn59f5/H8/Px6VyhrWFtbY21t3eA2S5qP4unpiaenp0W9Z0tka2vLiBEj6j0ux92ySFvZdJ07d2b48OGAZb1vS6QoCmFhYab7crwt07W2l9JWGllZWZk+P5b0vi2VnZ0dQ4YMAeR4N6TDFVLTarUEBgZy6tQp02MGg4FTp04REhJixsiEEKLtkLZSCCEaR9pLIcT16nA93QBTp05l6dKlBAYGEhwczObNm6moqCAiIsLcoQkhRJshbaUQQjSOtJdCiOvRIZPukSNHUlhYyPr168nPz8ff35/nn3/+skMmhRDCEklbKYQQjSPtpRDieiiqDLq/rOzs7DpLPggh2j9ra2spDtTMpK0UouORtrL5SVspRMfT2LayQ/Z0NxetVv48QnQ08rlufvI3FaLjkc9185O/qRAdT2M/19LTLYQQQgghhBBCtJAOV71cNF1ZWRn/+Mc/KCsrM3coohXI8RaiaeSzY1nkeAvRNPLZsSxyvK9Mkm5hoqoqCQkJsraehZDjLUTTyGfHssjxFqJp5LNjWeR4X5kk3UIIIYQQQgghRAuRpFsIIYQQQgghhGghknQLE2tra+68806sra3NHYpoBXK8hWga+exYFjneQjSNfHYsixzvK5Pq5UIIIYQQQgghRAuRnm4hhBBCCCGEEKKFSNIthBBCCCGEEEK0EEm6hRBCCCGEEEKIFiJJtxBCCCGEEEII0UIk6RZCCCGEEEIIIVqI1twBiLZhy5YtfPfdd+Tn5+Pn58fDDz9McHCwucMSLSAqKopvv/2WhIQE8vLyePrppxk6dKi5wxKiXZC20nJIWynE9ZH20jJIW9k40tMt2L9/P6tWreLOO+/krbfews/Pj0WLFlFQUGDu0EQLqKiowN/fn0ceecTcoQjRrkhbaVmkrRSi6aS9tBzSVjaOJN2C77//nhtvvJEbbrgBX19f5s6di42NDT///LO5QxMtIDw8nHvvvVeuQgpxjaSttCzSVgrRdNJeWg5pKxtHkm4Lp9friY+Pp1+/fqbHNBoN/fr1IyYmxoyRCSFE2yFtpRBCNI60l0LUJ0m3hSssLMRgMODi4lLncRcXF/Lz880SkxBCtDXSVgohRONIeylEfZJ0CyGEEEIIIYQQLUSSbgvn5OSERqOpd+UxPz+/3hVKIYSwVNJWCiFE40h7KUR9knRbOK1WS2BgIKdOnTI9ZjAYOHXqFCEhIWaMTAgh2g5pK4UQonGkvRSiPlmnWzB16lSWLl1KYGAgwcHBbN68mYqKCiIiIswdmmgB5eXlZGZmmu5nZWWRmJiIo6Mjbm5uZoxMiLZN2krLIm2lEE0n7aXlkLaycRRVVVVzByHMb8uWLXz77bfk5+fj7+/PQw89RI8ePcwdlmgBp0+fZuHChfUeHzduHPPmzTNDREK0H9JWWg5pK4W4PtJeWgZpKxtHkm4hhBBCCCGEEKKFyJxuIYQQQgghhBCihUjSLYQQQgghhBBCtBBJuoUQQgghhBBCiBYiSbcQQgghhBBCCNFCJOkWQgghhBBCCCFaiCTdQgghhBBCCCFEC5GkWwghhBBCCCGEaCGSdAuLtX79eu6+++46j82bN4+lS5eaKSIhhGibpL0UQoirk7ZSXI4k3aJdys3NZf369SQmJrbo66SmprJ+/XqysrJa9HWuR3R0NOvXr6ekpMTcoQgh2iBpL38n7aUQ4nKkrfydtJXNT5Ju0S7l5eWxYcOGZm8Y33//fR577DHT/dTUVDZs2EB2dnazvk5zio6OZsOGDdIwCiEaJO3l76S9FEJcjrSVv5O2svlpzR2AENeiuroaVVVb7Pmtra1b7LmFEKI1SXsphBBXJ22laA2K2pL/y0SHtH79ejZs2MD777/Phg0bOHr0KFqtlptuuol77rmHCxcusGLFCk6fPo2NjQ233norf/jDH+o8R0FBAWvWrCEyMpLS0lK8vb2ZMmUKERERpn2ysrL485//zH333YeVlRVbtmwhKyuLBx54gJUrV9aL6/HHHyciIoIzZ87w448/EhsbS0FBAc7OzgwbNoyZM2diY2NT732sX7/e9Ni8efMIDQ1l3rx57Nq1i2XLltV7nZdffpmff/6ZY8eO8dFHH6HV1r129dprr5Gdnc2SJUuu+HeMjY1lw4YNxMTEoNfr6dq1K+PHj2fy5MkAJCUl8f3333PmzBny8vLQ6XSEh4dz//3306lTpzrv4VIffvghHh4eV3x9IUTLk/ZS2kshxNVJWyltZUcnPd2iyd5//318fHyYNWsWkZGRfP311zg6OrJ9+3b69u3LrFmz2LNnD59//jlBQUGEhoYCUFlZyYIFC8jMzOTmm2/Gw8ODgwcPsmzZMkpLS00NQ41du3ZRVVXFjTfeiLW1NUOHDqWsrIz169czYcIEevXqBUDPnj0BOHDgABUVFUycOJFOnToRFxfHli1byM3N5amnnmr0++vduze33HILP/74I7fffjs+Pj4A+Pj4MHbsWH755ReOHz/OoEGDTL+Tn5/PqVOnuPPOO6/43CdOnODNN9/E1dWVW265BRcXF9LS0jh69Kjp/Z84cYKsrCwiIiJwcXEhNTWV7du3k5qayqJFi1AUhWHDhpGRkcG+ffuYPXu2qcF0cnJq9PsUQrQ8aS+lvRRCXJ20ldJWdlSSdIsmCw4O5tFHHwVgwoQJzJs3j88//5wZM2Zw2223ATBq1Cgee+wxfv75Z1PDuH37dtLS0vjLX/7CmDFjALjppptYsGABX3zxBTfccAP29vam17lw4QIffPBBnQ97eHg469evJyQkhLFjx9aJ67777qtz1XHChAl4enqydu1acnJycHNza9T769q1K7179+bHH3+kf//+9OnTx7TNycmJLl26sGfPnjoN4969e1FVtV5MtRkMBv773//i6urK22+/jYODg2lb7YEnkyZNqncVt0ePHixZsoSzZ8/Su3dv/Pz8CAgIYN++fQwZMkSuQArRRkl7Ke2lEOLqpK2UtrKjkkJqosnGjx9vuq3RaAgMDERV1TqPOzg44O3tXadC47Fjx3BxcWHUqFGmx7RaLbfccgvl5eVERUXVeZ1hw4Zd09W12o1ieXk5hYWFhISEoKoqCQkJ1/QeL0ej0TB69Gh+/fVXysrKTI/v3buXkJCQKzZQCQkJZGVlMXny5DqNIoCiKA2+j8rKSgoLC+nRo4fpOYQQ7Ye0l9JeCiGuTtpKaSs7KunpFk126VU9nU6HtbV1vUZMp9NRVFRkup+dnY2XlxcaTd1rPjVDbC6t5nitV9hycnJYt24dv/76a72qi6Wlpdf0XFcybtw4vvnmGw4fPsy4ceNIT08nPj6euXPnXvH3zp8/D0C3bt2uuF9xcTFffvkl+/fvp6CgoM625nwfQoiWJ+2ltJdCiKuTtlLayo5Kkm7RZJc2bJd77HrVvip3NQaDgVdffZXi4mKmTZuGj48Ptra25ObmsmzZsmatTunr60tgYCB79uxh3Lhx/PLLL2i1WkaMGNEsz//Pf/6T6Ohobr31Vvz9/bGzs8NgMPD6669jMBia5TWEEK1D2ktpL4UQVydtpbSVHZUk3aLVubu7k5SUhMFgqNOQpqenm7ZfTe2hMrUlJyeTkZHBvHnzGDdunOnxEydOXGfUDRs7diyrVq0iLy+Pffv2MXDgQBwdHa/4O127dgUgJSWF/v37N7hPcXExJ0+e5O67765TOCMjI6Pevpf7Wwgh2j9pL6W9FEJcnbSV0la2dTKnW7S68PBw8vPz2b9/v+mx6upqfvzxR+zs7ExFMa7E1tYWoN4Qn5qGtvZVR1VV2bx5c5NitbOza/B1aowePRpFUfj00085f/68qXjHlQQEBODh4cHmzZvrPW9N3A29D4Affvih3vPV/C1kWJAQHY+0l9JeCiGuTtpKaSvbOunpFq1uwoQJbNu2jWXLlhEfH29a1iE6OpoHH3ywTnXJy+natSsODg5s27YNe3t7bG1t6dGjB97e3nTt2pXPP/+c3NxcdDodhw4dori4uEmx+vv7o9Fo+OabbygtLcXa2pq+ffvi7OwMGCtNhoWFcfDgQRwcHBg4cOBVn1Oj0TBnzhzeeustnnnmGSIiInB1dSUtLY3U1FTmz5+PTqejd+/efPvtt1RXV9O5c2eOHz9ep2hIjcDAQADWrl3LqFGjsLKyYtCgQaZGXQjRfkl7Ke2lEOLqpK2UtrKtk55u0epsbGxYsGABo0ePZvfu3axatYri4mIef/zxeusoXo5Wq2XevHloNBo+/vhjlixZQlRUFFqtln/84x/4+/uzadMmvvzySzw9Pfnzn//cpFhdXFyYO3cuhYWF/Oc//2HJkiWkpqbW2admqNGIESOwtrZu1PMOGDCAl19+GS8vL77//ntWrlzJqVOn6iwR8cQTTxAWFsZPP/3EmjVrsLKy4vnnn6/3XMHBwdxzzz0kJSWxdOlSlixZQmFhYZPerxCibZH2UtpLIcTVSVspbWVbp6jNOftfCAt05MgR3nnnHRYuXEjv3r3NHY4QQrRZ0l4KIcTVSVvZ8UhPtxDXaceOHXTt2pVevXqZOxQhhGjTpL0UQoirk7ay45E53UI00b59+0hKSiIyMpIHH3xQKj0KIcRlSHsphBBXJ21lxyVJtxBNtGTJEuzs7Bg/fjyTJk0ydzhCCNFmSXsphBBXJ21lxyVzuoUQQgghhBBCiBYic7qFEEIIIYQQQogWIkm3EEIIIYQQQgjRQiTpFkIIIYQQQgghWogk3UIIIYQQQgghRAuRpFsIIYQQQgghhGghknQLIYQQQgghhBAtRJJuIYQQQgghhBCihUjSLYQQQgghhBBCtBBJuoUQQgghhBBCiBYiSbcQQgghhBBCCNFCJOkWQgghhBBCCCFaiCTdQgghhBBCCCFEC5GkWwghhBBCCCGEaCGSdAshhBBCCCGEEC1Ekm4hhBBCCCGEEKKFaM0dQFuWl5eHXq83dxhCiGak1WpxdXU1dxgdirSVQnQ80lY2P2krheh4GttWStJ9BXq9nqqqKnOHIYQQbZq0lUIIcXXSVgphuWR4uRBCCCGEEEII0UKkp1sIIdqZrVu3snXrVrKzswHw9fXlzjvvJDw8HIDKykpWrVrF/v37qaqqIiwsjDlz5uDi4mJ6jpycHD7++GNOnz6NnZ0d48aNY+bMmVhZWZnjLQkhhBBCdFiKqqqquYNoq7Kzs2UYkBAdjLW1Ne7u7uYO47r8+uuvaDQavLy8UFWV3bt38+233/L222/TrVs3Pv74YyIjI5k3bx46nY7ly5ej0Wh49dVXATAYDPz973/HxcWF+++/n7y8PD788ENuvPFGZs6cec3xSFspRMfTEdrKtkbaSiE6nsa2lTK8XAgh2pnBgwczcOBAvLy88Pb2ZsaMGdjZ2REbG0tpaSk7d+5k9uzZ9O3bl8DAQB5//HGio6OJiYkB4Pjx46SmpvKXv/wFf39/wsPDueeee/jpp5+kyI8QQgghRDOTpFuYHDp0iG+++QYZ/CBE+2EwGNi3bx8VFRWEhIQQHx9PdXU1/fr1M+3j4+ODm5ubKemOiYmhe/fudYabDxgwgLKyMlJSUi77WlVVVZSWlpp+ysrKTNsURbGYn6SkJNasWUNJSYnZY5Ef+WmpHyGuV1FREatXryYpKcncoQhhdjKnW5j897//BaBv374EBQWZORohxJUkJyczf/58qqqqsLOz4+mnn8bX15fExES0Wi0ODg519nd2diY/Px+A/Pz8Ogl3zfaabZezceNGNmzYYLofEBDAW2+9ZXFDUF944QXS09Pp1KkTjz32mLnDEUKINmnTpk3s2rWLM2fO8Nprr5k7HCHMSpJuUU9BQYG5QxBCXIW3tzfvvPMOpaWlHDx4kKVLl7Jw4cIWfc3bb7+dqVOnmu7X9IZlZ2db1LD09PR0AI4ePUpGRoaZoxGiZWi1Wou7oCaaV1RUFIC0k0IgSbcQQrRLWq0WT09PAAIDAzl37hybN29m5MiR6PV6SkpK6vR2FxQUmHq3XVxciIuLq/N8NRfbLu0Br83a2hpra+sGt1nqtBRLfd9CCHE1Mk1BiN+1qaQ7KiqKb7/9loSEBPLy8nj66acZOnQoAHq9ni+++IJjx46RlZWFTqejX79+zJw5k86dO5ueY968eaZldGrMnDmT2267rTXfihBCtCqDwUBVVRWBgYFYWVlx8uRJhg8fDhh7ZnNycggJCQEgJCSEr7/+moKCAtOw8hMnTmBvb4+vr6/Z3oMQQgghREfUppLuiooK/P39GT9+PO+++26dbZWVlSQkJHDHHXfg7+9PcXExn332GW+//TZvvvlmnX3vvvtuJkyYYLpvZ2fXKvELIURrWLNmDQMGDMDNzY3y8nL27t1LVFQU8+fPR6fTMX78eFatWoWjoyM6nY4VK1YQEhJiSrrDwsLw9fXlww8/ZNasWeTn5/PFF18wadKky/ZkCyGEEEKIpmlTSXd4eDjh4eENbtPpdLz44ot1Hnv44Yd5/vnnycnJwc3NzfS4vb39FYdIXqqqqqrOuomKomBvb2+6bWmkcqkQbVtBQQFLly4lLy8PnU6Hn58f8+fPp3///gDMnj0bRVFYvHgxer2esLAw5syZY/p9jUbDs88+yyeffMILL7yAra0t48aN45577jHXWxJCCCGE6LDaVNJ9rUpLS1EUBZ1OV+fxTZs28dVXX+Hm5sbo0aOZMmUKVlZWl30eqchbl6urK15eXuYOQwhxGX/605+uuN3GxoY5c+bUSbQv5e7uznPPPdfcoQkhRLu2adMm1qxZw+TJk3nwwQcBWLBggakoWI0JEybw6KOPmiFCIUR71G6T7srKSlavXs2oUaPqJN233HILAQEBODo6Eh0dzdq1a8nLy2P27NmXfS6pyFtXXl6eVJoUHZZU5BVCCNGQuLg4tm3bhp+fX71tN954Y53RQDY2Nq0ZmhCinWuXSbder+ef//wnQL2enNrJs5+fH1qtlo8//piZM2dedq6iVOStS1VVi3zfQgghhLBM5eXlfPDBBzz22GN8/fXX9bbb2tpe09RFIYSord0l3TUJd05ODi+99FK9oeWX6tGjB9XV1WRnZ+Pt7d1KUQohhBBCiPbik08+ITw8nP79+zeYdO/Zs4c9e/bg4uLCoEGDuOOOO7C1tW3wuaRWUH2W+r6FqNGuku6ahDszM5OXX36ZTp06XfV3EhMTURQFJyenVohQCCGEEEK0J/v27SMhIYE33nijwe2jR4/Gzc2Nzp07k5SUxOrVq0lPT+fpp59ucH+pFWSk1f6eZkitIGHp2lTSXV5eTmZmpul+VlYWiYmJODo64uLiwnvvvUdCQgL/+Mc/MBgM5OfnA+Do6IhWqyUmJobY2Fj69OmDvb09MTExrFy5kjFjxuDo6GimdyWEEEIIIdqinJwcPvvsM1544YXLztOuvQxt9+7dcXV15ZVXXiEzMxNPT896+0utIKPa71VqBYmOqrG1gtpU0n3u3DkWLlxour9q1SoAxo0bx1133cWvv/4KwDPPPFPn915++WX69OmDVqtl//79fPnll1RVVeHh4cGUKVPqNHxCCCGEEEIAxMfHU1BQwD/+8Q/TYwaDgTNnzrBlyxbWrFmDRqOp8zvBwcEAl026pVZQfZb6voWo0aaS7j59+rB+/frLbr/SNoDAwEAWLVrU3GEJIYQQwkIZDAZKSkoaNaVNtD/9+vXj3XffrfPYv//9b7y9vZk2bVq9hBuMUxfBuMSqEEI0RptKuoUQQggh2pJVq1axd+9eXnjhBfz9/c0djmhm9vb2dO/evc5jtra2dOrUie7du5OZmcnevXsZOHAgjo6OJCcns3LlSnr37t3g0mJCCNEQSbqFEEIIIS5jz549AGzdupVHH33UzNGI1qbVajl58iSbN2+moqKCLl26MGzYMKZPn27u0IQQ7Ygk3UIIIYQQV2EwGMwdgmglCxYsMN12c3OrU29ICCGaov5EFSGEEEIIIYQQQjQLSbqFEEIIIYQQQogWIkm3EEIIIYQQQgjRQpol6S4tLZW5TkIIIYQQQgghxCWanHSfO3eORYsWcd999/Hwww8TFRUFQGFhIW+//TanT59utiCFEEIIIYQQQoj2qElJd3R0NC+99BKZmZmMGTMGVVVN25ycnCgtLWXbtm3NFqQQQgghhBBCCNEeNSnpXrt2LT4+Prz33nvMmDGj3vY+ffoQFxd33cEJIYQQQgghhBDtWZOS7nPnzhEREYG1tTWKotTb3rlzZ/Lz8683NiGEEEIIIYQQol1rUtJtZWVVZ0j5pXJzc7Gzs2tyUEIIIYQQQgghREfQpKS7R48eHDx4sMFt5eXl7Nq1i9DQ0OsKTAghhBBCCCGEaO+alHTffffdxMfH88Ybb3Ds2DEAEhMT2bFjB88++yyFhYXccccdzRqoEEIIIYQQQgjR3mib8ks9evTgueee4+OPP2bp0qUAfP755wB07dqV5557Dj8/v+aLUgghhBBCCCGEaIealHQD9O3blyVLlpCYmEhGRgaqqtK1a1cCAwMbLK4mhBBCCCGEEEJYmiYl3bt376Z37954eHjg7++Pv79/ne1ZWVmcOXOGcePGNUeMQgghhBBCCCHaqPLycmJjYwkKCkKn05k7nDanSXO6ly1bRkxMzGW3x8XFsWzZsiYHJYQQQgghhBCifVi9ejXvv/8+H3/8sblDaZOalHRfTXl5OVZWVi3x1EIIIYQQQggh2pD9+/cDcOLECTNH0jY1enh5UlISiYmJpvtnzpyhurq63n4lJSVs27YNLy+vZglQCCGEEEIIIYRorxqddB8+fJgNGzaY7m/fvp3t27c3uK9Op+PPf/7z9UcnhBBCCCGEEEK0Y41OuidMmMCgQYNQVZXnn3+eu+++m/Dw8Hr72dnZ0bVr1yYNL4+KiuLbb78lISGBvLw8nn76aYYOHWrarqoq69evZ8eOHZSUlNCrVy/mzJlTp1e9uLiYFStWcPToURRFYdiwYTz00EPY2dldczxCCCGEEKJtiYmJ4fTp0xQUFDBp0iS8vLyoqKggLS0Nb29vOedrI1RVNXcIQrQZjU66XV1dcXV1BeDll1/Gx8cHZ2fnZg2moqICf39/xo8fz7vvvltv+zfffMOPP/7IvHnz8PDwYN26dSxatIj33nsPGxsbAP71r3+Rl5fHCy+8QHV1NcuWLeOjjz7iiSeeaNZYhRBCCCFE69Hr9bz//vscOXLE9NjgwYPx8vJCURQWLVrElClTmD59uhmjFEKI+ppUSC00NLTZE26A8PBw7r333jq92zVUVWXz5s1Mnz6dIUOG4Ofnx5///Gfy8vJMjW9qaiq//fYbf/zjH+nRowe9evXi4YcfZv/+/eTm5l72dauqqigtLTX9lJWVmbYpimIxP5b4ni35R1VVVFU1exyt/SOEEKJ9+uKLLzh69Chz587l/fffr7PNxsaG4cOH10nIhRCirWjSOt0A+fn57Ny5k/j4eMrKyjAYDHW2K4rCSy+9dN0B1sjKyiI/P5/+/fubHtPpdAQHBxMTE8OoUaOIiYnBwcGBoKAg0z79+vVDURTi4uIaTOYBNm7cWGe+ekBAAG+99Rbu7u7NFn970rlzZymE18GpqsrTTz9NcXExy5Ytk9UGhBBCtHn79u1j4sSJTJgwgaKionrbfXx8OHjwoBkiE0KIK2tS0p2UlMSCBQuorKzE29ub5ORkfH19KS0tJTc3l65du9KlS5dmDTQ/Px+gXg+7s7OzaVt+fj5OTk51tltZWeHo6GjapyG33347U6dONd2v6Q3Lzs5Gr9dff/DtTG5uLhkZGeYOQ7Qgg8FAVFQUAL/99hve3t5mjqj1aLVai72gJoQQ7VlhYSHdu3e/7HaNRkNFRcV1vcamTZtYs2YNkydP5sEHHwSgsrKSVatWsX//fqqqqggLC2POnDm4uLhc12sJISxHk5LuNWvWYGdnxzvvvIONjQ1z587loYceom/fvhw4cIBPPvmEv/71r80da4uxtrbG2tq6wW2WWASiZtix6LhqH1853kIIIdqDLl26kJaWdtnt0dHReHp6Nvn54+Li2LZtG35+fnUeX7lyJZGRkTz11FPodDqWL1/O4sWLefXVV5v8WkIIy9KkOd1nz57lpptuws3NDY3G+BQ1w8tHjBjB6NGj+fzzz5svSjBdTSwoKKjzeEFBgWmbi4sLhYWFdbZXV1dTXFwsVyOFEK2msrKS/fv3s2nTJrZv305eXp65QxJCiHZv9OjRbN++nZiYmHrbtm/fzoEDBxg7dmyTnru8vJwPPviAxx57DAcHB9PjpaWl7Ny5k9mzZ9O3b18CAwN5/PHHiY6ObjAOkFpBDdVQMXcs8tOyP5dOMy4rKzN7TK3101hN6ulWVdU0zFun06HRaCguLjZt7969Ozt37mzKU1+Wh4cHLi4unDx5En9/f8DYEMbFxTFx4kQAQkJCKCkpIT4+nsDAQABOnTqFqqoEBwc3azxCCNGQgoICXnjhBbKyskyPrVy5kr///e91alIIIYS4NtOnTyc2Nta0ig4Y29fi4mJyc3MJDw+vM13wWnzyySeEh4fTv39/vv76a9Pj8fHxVFdX069fP9NjPj4+uLm5ERMTQ0hISL3nklpBRrXrxUitoI4tMTGxzv3S0tI6NbZEE5NuDw8P0wmlRqPBw8ODkydPMnLkSMA4vKf2VcLGKi8vJzMz03Q/KyuLxMREHB0dcXNzY/LkyXz99dd4eXnh4eHBF198gaurK0OGDAHA19eXAQMG8NFHHzF37lz0ej0rVqxg5MiRdO7cuSlvVQghrslXX31FdnY2U6ZMoW/fvmRmZvLVV1/x8ccf88EHH5g7PCGEaLe0Wi3PP/88e/bs4eDBgxgMBvR6PX5+ftx7772MHTv2mnqeauzbt4+EhATeeOONetvy8/PRarX1zmtr1xS6lNQKMqqurjbdllpBHdvWrVvr3XdzczNTNK2rsbWCmpR09+/fn4MHDzJjxgwAbrrpJj7//HOysrJQVZXTp0/zhz/84Zqf99y5cyxcuNB0f9WqVQCMGzeOefPmMW3aNCoqKvjoo48oLS2lV69ePP/886Y1ugH++te/snz5cl555RUURWHYsGE8/PDDTXmbQghxzY4fP87YsWN54IEHTI+5uLiwZMkS0tPTLaponRBCNJfKykrWrl1Lnz59GDt2bJOHkV8qJyeHzz77jBdeeKHO+eT1kFpB9Vnq+7YE+fn5/LhlCwAG9wA02Qns2rWL8ePH07VrVzNH13Y0KemePn06o0ePRq/Xo9VqmTJlChUVFRw6dAiNRsMdd9zB9OnTr/l5+/Tpw/r16y+7XVEU7rnnHu65557L7uPo6MgTTzxxza8thBDNIScnh2nTptV5rFevXoDxi0mSbiGEuHY2NjZs374dX1/fZn3e+Ph4CgoK+Mc//mF6zGAwcObMGbZs2cL8+fPR6/WUlJTU6e2uXVNINOzSeb6iY/ryyy8pLytD7eSO2usGVH0l+rw01q5dyxNPPNGk0Scd0TUn3aqqotFo8PX1Ras1/rqiKNxxxx3ccccdzR6gEKJlSWPYvPR6fb3ekpoeDzkBEUKIpgsMDCQlJaVZn7Nfv368++67dR7797//jbe3N9OmTcPNzQ0rKytOnjzJ8OHDAUhPTycnJ6fB+dzid7WHlxsMBlPxZdFxnD17loMHDwJgCB4JigZD8Eisfv2KkydPEhkZyaBBg8wcZdtwzUm3Xq/n4YcfZsaMGfV6c4QQQhjrUcTHx5vul5aWAsY5bTqdrt7+NYUfhRBCXN7s2bN544036NatGxEREXUKdTWVvb19vbW/bW1t6dSpk+nx8ePHs2rVKhwdHdHpdKxYsYKQkBBJuq+gtLS0zpz3mJgY06gv0TFcuHCBlStXAmDw6gWdLs5rtnfG4NsfTcpvrF69Gh8fn+tayq+juOak29raGhcXl8vOVRHtn/R8CnF91q1bx7p16+o9/sknn1x2fyGEEFe2bNkyNBoN//3vf/n000/p3LlzvZFFiqLwzjvvNOvrzp49G0VRWLx4MXq9nrCwMObMmdOsr9HR/PDDD3XmcW/atIlnnnlGers7AIPBwNGjR/n8888pKSlBtdGhBgyps4/afQBqTgIFBQW88sorzJw5k+HDh5tGSVuiJr3ziIgIdu/ezcSJEy36j9dRSbELIZruT3/6k7lDEEKIDsnR0ZFOnTq1eG2MBQsW1LlvY2PDnDlzJNFuBFVV+eWXX/jpp58AmKqDrWUQGxvLmjVruOeee6Tjrp0qKytj79697Nixg+zsbABURzcMvW8ErW3dna20GPpPQXN2JxUFmXz66ads2rSJ8ePHM3bsWBwdHc3wDsyrSRlz9+7dOXLkCE899RQRERG4u7s3WPFx2LBh1x2gaH3S0y1E00VERJg7BCGE6JAuTYZF25Kdnc26des4duwYAINsYbidgrWisrEEfv75Z2JjY3nggQcIDAyU8812oLKykhMnTnD48GFOnjxJZWUlAKrWFtWrN6pfOGguM83DVoeh/2SUlBMoaafIy8vjq6++4ptvvqFv374MGTKEAQMGYGdn14rvyHyalHQvWbLEdPtKwyJlyGT7JD3dQgghhBQ/FOJqioqKOHLkCIcOHSIuLg4AK+Amexh5MZcaZKvgcDHxTk1N5fXXX8fT05Nhw4YxbNgwWVaqDTEYDKSnpxMTE0N0dDQnT56koqLCtF3VuaB690HtGgxWjRixoGiMQ819+6FknUNJP42++AK//fYbv/32G9bW1vTp04devXrRs2dPfH19O+wUhCYl3S+//HJzxyGEEB1GZWUl0dHRWFlZ0bNnT6ysrCgqKmLTpk2cOXOG8vJy/P39mTZtGn5+ftf8/Bs3buTw4cOkpaVhY2NDSEgI9913X50hl5WVlaxatYr9+/dTVVVlmoNYe4mbnJwcPv74Y06fPo2dnR3jxo1j5syZzVKcSIiOoPbJpjC/qKioRu0XGhrawpFYJoPBQFZWFsnJyaSkpJCYmEj02bNUX7w4pQABWrhFB17aur3YvWwU/qJV2VIKpyohMzOTb775hm+++QZ/f3+CgoLo1q0b3bt3x9vbW4agt5KqqiqSk5M5d+4cMTExxMbGUlxcXGcf1dYR1T0Q1T0QHLtAU0YoaKxQPUNQPUOgJBclOx4lK56q8kJTAg7GwoY9evQgJCSE4OBgunfvjq2t7ZWfu51oUtItjZkQQjTswoULvPTSS+Tk5ADg5eXF/Pnzef3110lPT0en02EwGEhLS+PIkSO8+uqr+Pv7X9NrREVFMWnSJIKCgqiurmbt2rW89tprvPfee6ZhWitXriQyMpKnnnoKnU7H8uXLWbx4Ma+++ipgPHl64403cHFx4bXXXiMvL48PP/wQKysrZs6c2ax/k46k9hI4ouOrnXRLr7f5LVy4sFH7yUjL66OqKiUlJXUS7OTkZFJTU03Di2vztoIwG+hnC06ayydkjhqFOx3hD6pKVCWcqIS4KkhMTCQxMdG0n5WVFV5eXnTr1s2UiHt5eeHk5NRhe0FbQ00vdmJiIgkJCSQkJJCamlrve03VaMHJA9XZC9XVGzp5NC3RvhyHzqgOnVH9BkHxBZS8VJSCTCg8T1lZGSdOnODEiRMAaDQafHx88Pf3JyAggICAAHx8fNpl54BUQRNCiGb01VdfUVRUxMMPP4yzszNffvklb775JuXl5bzxxhum5cFOnTrF4sWL2bBhA08//fQ1vcb8+fPr3J83bx5z5swhPj6e0NBQSktL2blzJ0888QR9+/YF4PHHH+fJJ58kJiaGkJAQjh8/TmpqKi+++CIuLi74+/tzzz33sHr1au6++24pknkZZWVlptsyFafjKy8vN92ufeyFeTQ00rKm93XHjh0YDAZmzZplhsjaF4PBQEFBARcuXLjsz+VGeVgDnlbgpTX+G2AN7lbXlpDZKgrhthBuC8UGldgqyKyGDD1kVENZdTWpqamkpqZy4MAB0+9ptVo6d+5Mly5dGvxxdXWV765a8vLyiI+PJyEhgfj4eBITExs8rqq1HXRyR3X2RHX2MvZmX26ednNSFOjkhtrJDRVANUBxLkpBhjEJL8rGUFlKSkoKKSkp7NmzBzAWNvTz8yMgIIDAwEACAgLo0qVLm68RIP8zhRCiGZ04cYKJEycyadIkwFht99VXX+XBBx+ssx533759uemmm9ixY8d1v2bNOuA11UDj4+Oprq6mX79+pn18fHxwc3MzJd0xMTF07969znDzAQMG8Mknn5CSkkJAQEC916mqqqKqqsp0X1EU7O3tTbctQe1hd2VlZRbzvi1VSUlJndtyvM3rSiMtIyIiePnllzl9+rTpYqOlMhgM5Ofnk5OTU+fnwoUL5Obmkpubi16vv+rzdFLAUwteVsYfTy100YCmGT8HjhpjAl5DVVUK1d8T8Ew9pFdDvgH0ej1ZWVlkZWU1+FyKouDi4mJKwt3c3OjSpQvu7u6mxzpqUq7X60lOTiY2Npa4uDgSEhLIy8urt5+q0V5MdN1RO7kb19a2dWzenuymUjS/J+G+F89fKkqgKBvl4g9F2VRWVhIbG0tsbKzpV52cnAgICCA4OJgePXrg7+/f5qYodMz/eUIIYSa5ubn4+vqa7tfcbmiJG29v7zon9U1hMBj47LPP6NmzJ927dwcgPz8frVaLg4NDnX2dnZ3Jz8837VM74a7ZXrOtIRs3bmTDhg2m+wEBAbz11lu4u7tf13toTy5cuGC6XVRUhKenpyRiHVhSUpLpdllZGV5eXmaMRlyJRqNh5MiRbNq0iXvuucfc4bQog8FAYWFhnWQ6OzubCxcumO5fbSqMBuikAZdLf6x+v21thrZNURScFXC2gV61Hq9WVQoNxuS7zs/FhLzAAHpVJS8vj7y8PFNRt0uf28XFBTc3twZ/XF1d282w5YqKCs6dO0dsbCwxMTHEx8fXG/qvooCD68Xk2gPVyR10Lsbktr2wdQBbB1Q3/4u94SqU5aMUZl9MxrOgJJfCwkKOHz/O8ePHAbC2tiYgIIAePXrQo0cPgoODTZ0E5iJJtxBCNKPq6uo6V9JrvsAb+iK3srK67iHKy5cvJyUlhVdeeeW6nqcxbr/9dqZOnWq6X5NsZmdnN6rXpCOoPe+wsrKSxMREi1nuxBKlpqaabhcUFJCRkWHGaFqXVqttdxfUiouLr/tCZltUVVXFuXPnOHv2LNHR0SQkJNQZddQQDeCsAVcNuFrVT66dNGDVji4YWikKrlbG99IQg6pSotZNxPMNkFfzbzVU1UrKa/eS1qiZP1xTSTskJKTexWtzqUmya/8fqDcXW2sLTl1RnbuidvKATm6NqzDenigK6FxRda7gGWJMxKv1xrnhRVmmueFVVeXExMQQExMDGI+tv78/ISEh9OrVyyxJuCTdQgjRTi1fvpzIyEgWLlxIly5dTI+7uLig1+spKSmpc8JQUFBg6t12cXGp1xNQUFBg2tYQa2vryw7XspT5zYWFhfXud5TKqqK+2tMJKioqqKqq6rDDU9uDmgKVlyopKeHMmTN8++239O7du5WjahlZWVkcOHCA6Ohozp07V+/CpoIxqXa5JLF2vfjj1MzDwNs6jaLQSTH23ndr4COqXkzK8y4m5bm1kvGa5LzaYDDNH962bRuKotCtWzd69uzJ4MGDCQ4ObrX3U1RUZBoqHhcXR2JiYv0k28YB1dkTnD1RnbuCzrVtDBNvbVZacL54scG338Xe8AJTAq4UZGIoLyI+Pp74+Hi2bNmCRqPBz8+P4OBg08/lzn2aS5O+Ofbv38/gwYOxsbFp7niEEKLdW7NmDZs2bQJ+r3j80Ucf1UvOauZiXytVVVmxYgWHDx9mwYIFeHh41NkeGBiIlZUVJ0+eZPjw4QCkp6eTk5NDSEgIACEhIXz99dcUFBSYhpWfOHECe3v7OsPjRV01FyZq5Ofnt7veQNF4ly6dU1JSYvq8iNY3b968K27v0aMHc+fObaVoWtbixYvrXGSwAXrZGJfk8reGzu2sp9rcFEXBUQHHyyTlhovD11P0kKCHs5VQqKokJyeTnJzM9u3befvtt+ncuXOLxRgbG8uePXuIi4vj/Pnz9barNg6oLl7g4mUseGbXyTKT7KtRFNC5oOpcwKuXsTe8vBilIAPyM1AKMjCUF5kquG/btg0ANzc3goODGTFiRIvUhWhS0r1kyRLs7e0ZNmwYY8aMsfiCFUIIUaN379715vhe7iS9U6dOdO3a9ZpfY/ny5ezdu5dnnnkGe3t70xxsnU6HjY0NOp2O8ePHs2rVKhwdHdHpdKxYsYKQkBBT0h0WFoavry8ffvghs2bNIj8/ny+++IJJkya1ueIjbUl6enqd+xkZGfTo0cNM0YiWdmkhory8PEm6zehPf/pTvccURcHBwQFPT88OdcHwhhtu4PvvvzdVza8ELlSD7uLXS5kVeGhV7CTpum56VSW7Gs5f/LlQDcW1Bm9ZWVkxbNgwnJycWiyGmJgY3nnnnTpLE6o6F1SnrheHjHtKkn097BxR7XpA1x6/J+GFmVBwHqXwPJTkmmokHDx4kL/+9a+EhYU1awhNSrpfeeUV9uzZw8GDB9m1axedO3dm9OjRjBkzxlTIRwghLNGCBQta/DW2bt3a4Gs9/vjjREREADB79mwURWHx4sXo9XrCwsKYM2eOaV+NRsOzzz7LJ598wgsvvICtrS3jxo3r8AWIrlfNnG5PK+MSN4mJiYwdO9a8QYkWc2mV5KysLPz9/c0TjDC1b5bg5ptvZvz48Rw/fpz9+/dz6tQp0qoNpF1SH81Fo9LVijo/7lbSC94QVVXJMxjb7poE+7weLhjA0MD+AQEBjBw5kiFDhtCpU6cWi6u6upr//Oc/poTb0DUE1X+QsYiYaBl2jqh2weARbEzCq8pRko6hST8NwMcff8y7777brDVbmpR09+zZk549e/LQQw/x22+/sWfPHrZs2cK3335L9+7dGTt2LKNHj8bV1bXZAhVCCGG0fv36q+5jY2PDnDlz6iTal3J3d+e5555rztA6tLy8PHJyclCAUXbwVQkNFuMRHYOqqqaRDaqjG0pxDmlpaWaOyrL9+c9/5sEHH2Tw4MENbj969CiffvopH374YStH1jJsbGwYMmQIQ4YMoaCggNOnT5OamkpaWhqpqank5+ebCoZF16qrZg34aFW6aTH9dNJYXhJerqqk6Y1Dxmt+Si9TfkSn0+Hj44Ovry8+Pj707t0bT0/PVolTo9Hg4eFhmr6kOR+DmpOA2tkXXHxQXX2MvdyieVWUoOSlQX4aSm4Kiv736u8tsbzcdT2blZUVgwYNYtCgQZSXl3P48GF27drF//73P9asWUNoaCjjxo1j5MiRUnikHZHlb4QQor5z584Bxp6kHhdH4Kenp1NaWopOpzNjZKIlZGVlUVpaiqpoUD2CUYpz6lSvF60vOzub8vLyy24vLy8nOzu7FSNqPc7OzowcObLOY8XFxaSlpZmS8Jp/y8vLSdRDYq3aay4aYxLup4Vga+N62x3tfK/YoBJXZZyTnaqHrGq4NMfWarV4eXnh6+trSrB9fHxwdXU1299DURT+8Y9/kJSUxOHDhzly5Ai5ubko2QmQnQCAau+E6uKD6uoLrj7G4mHi2hiqIT8dJTcVJT8NpTS/zmZnZ2cGDx7M0KFDCQwMRKNp3qXVmu2IJScnExcXR3JyMmBcf7a4uJilS5eydu1annjiCXr16nWVZxFtgaVUIRZCiGtRk3R304KjRsFVYxyqGB8fL7VNOiDTKAZHN+N8Soz/BwwGQ7OfjInmce7cuTazxFNrcHR0NI0+rWEwGMjIyCA+Pp5z584RHx9Peno6+QaV/Eo4ebEzz0UDQdYqPawhUAu6dtgTXqWqJOrhXBXEVRmHjV+qS5cuBAYGEhQURFBQEN26dWuTdUsURcHf3x9/f3/uvPNOEhISOHnyJGfOnCE+Ph5DWSFKWSFknEHVaKGzr3Ht6s7dQSuFrS+rugpyU1FyElFyk1Gqfx8SoigKfn5+hIaG0rdvX3r06NGibft1Jd3p6ens3buXvXv3cv78eZycnBg9ejRjx44lMDAQMDaA//nPf/j4449ZvHhxswQtWlZHu/IphBDNoSYJ87v4zemnhbxKYwEcSbo7nujoaABjtWDHzqhWNpSVlZGcnCzzulvR5s2b2bx5s+n+ypUr+eKLL+rtV1paSklJCaNHj27N8NqcmrWmfXx8GDNmDABlZWUkJCRw7tw5zpw5Q1xcHPnV1RytgKMVxuXHumtV+ttAXxtwaMMJeJWqEl0FJyogpgr0l2zv1q0boaGhBAcHExgY2OLLQLUEjUZjukhw2223UVpaSkxMDKdPn+b48eNcuHABchJRchJNI3FU337gINN6TcoKUFJPoZyPQTH8fjXGxcWFsLAwQkND6dWrF46Ojq0WUpOS7s2bN7Nnzx7i4+OxtrZm0KBBPPjggwwYMKDeFYKgoCCmTJnCf/7zn2YJWLQ86ekWQoi68vPzTUOLAy52kgRYw2+VxqXWpk+fbr7gRLNTVZWzZ88ab7t4gaIBZ0/ITebs2bOSdLciJycnU1Xy7OxsOnfuXK9mkKIo2NraEhgYyKRJk8wRZptmb29PaGgooaGh/OEPf6CiooLo6GiioqI4ffo06enpJOkhSQ8/lEKwtTEBD7UBmzbQEVOtqsTrjYl2VCVU1Nrm6upKaGgoffr0oXfv3i1aYdxcdDodAwYMYMCAAcycOZPk5GSOHj1KZGQkGRkZKOdj4HwMquvF3m8XH7C3wDng5cUo+ekoF5JQLiSZHnZ3d2fQoEEMHDiQgIAAs41UalLSvXLlSnr27MncuXMZOXLkVeeyBQUFcccddzQpwEvNmzevwfk6EydOZM6cOSxYsICoqKg62yZMmMCjjz7aLK8vREcjF1mEuLpDhw6hqsY5kc4Xe4F6W8M3QEpKCqmpqR1quSJLl5WVRW5uLqqiASfjsn6qixdKbjJnzpzh5ptvNnOElmP06NGm3uuFCxcyffp0+vXrZ+ao2jdbW1v69+9P//79AcjNzeXIkSMcOnSIpKQkYqqMvcjWJdDbRiXMxjgPvDUroquqSlo1HK8wDomvvYRX586dGTZsGMOGDcPX19eiRmjWDIn28/Nj+vTpnDt3jp9++onIyEjIS0XJSwVAteuE6uINLt7GZcdsHTrecmMVJVCUhZKXbky2ywrqbO7fvz+TJk2iZ8+ebeL/yDUn3aqq8uabb+Lj44ONTePmEHTr1o1u3bpdc3ANeeONN+qsYZecnMxrr73GiBEjTI/deOONdZa9aWycQgjRnLKyskhOTr5spd1ff/2V7t274+Hh0cqRiWthMBjYuXMnAOG1vk50GoVe1ipRVbBjxw5mz55tpghFcztz5ozxhpMHWBmHNqgu3oBxOkFVVVWbnBfa0b388svmDqFD6ty5M5MmTWLSpElkZGRw6NAhDh06RFZWFicq4UQlOCjQ10alnw1014KmhZKY7GqVk5XGXu2cWut4OTo6MnjwYIYPH05QUJDUVbgoKCiIxx9/nOzsbPbv38+ZM2c4Fx+PobwIJTMaMi9Ok7G2M9ancOyC6ugGndzA1rF9JOKqakywiy+gFOegFOdAcQ5KZVmd3RRFISAggN69ezN8+HC8vb3NFHDDrjnp1uv1PPfcc8ycOZNbb721JWK6okuHjWzatImuXbsSGhpqeszW1rZdzuEQQnQsq1atoqys7LJJ908//YSDgwN/+9vfWjcwcU0iIyPJyclBp8AA27rbRtpBVBXs37+f6dOnt+harqL1nDhxAsC4VE8Nh86oNvZUVpYRGxtb57xDtC69Xm9aOaB2R0wNOTZN5+XlxW233ca0adNISEjgwIEDHDlyhKKiIg5VwKEKcNZAv4sJuLfV9dcCyruYaJ+shIxaxdBsbGwYMGAAw4cPp0+fPrIS0hW4u7szbdo0pk2bRllZGTExMZw5c4azZ8+SlpaGoaq8Tk84gKq1BeeuqM5exouKDp3bRhKuqlCab+y9LsiAgkyUqvqrFiiKgpeXF7169aJ379706tWrTa8kcs3/e62trXFxcWkT//H1ej179uxhypQpdT7we/bsYc+ePbi4uDBo0CDuuOMObG1tL/s8VVVVVFXVrWZnb29vum1pNBqNRb5vS1L7+CqKIse7hcTGxjJ58uTLbu/Xrx8//PBDK0YkrpWqqmzbtg2AIbb15zf6acHHCtL0enbt2sUf/vAHc4QpmlFZWZlpmpraufvvGxQFtXM3lMwYjh49KomdGRgMBtasWcPWrVupqKi47H7r1q1rxag6JkVRCAwMJDAwkHvuuYczZ85w+PBhIiMjKSgvZ2857C039nrfYKcSbH3t58yZepVd5XC68velvaw0GkL79GHo0KGEh4ebzsdF49nb2xMWFkZYWBhgzHNSUlJISkoy/aSlpVGtr4ALySgXjCtPGZNwT1RXH1S3ALBpxb99VTlKTpLxwkBBRr0kW6PR4O3tbRpa7+fnR7du3a6Y37U1TcqcIyIi2L17NxMnTjRr8n348GFKSkqIiIgwPTZ69Gjc3Nzo3LkzSUlJrF69mvT0dJ5++unLPs/GjRvZsGGD6X5AQABvvfUW7u7uLRl+m+Xi4oKXl5e5wxAtqHbPgLu7uxzvFlJcXHzFEwY7OzuKi4tbMSJxrU6cOEFcXBxWwDC7+tsVRWGkncqXJcaRCxEREdLb3c4dPXqUqqoqVHtnY89PLapbIGTG8Ouvv3LPPffI9LVWtnHjRr777jsmTJhAr169+PDDD5k1axY6nY6tW7eiKAqzZs26pufcunUrW7duNdUL8vX15c477yQ8PBxAagVhXNu6X79+9OvXjwceeICTJ09y+PBhjh07RrJez8pi48XHiTqVIOurJ97Z1SrbSo2jhGr06tWLoUOHMmjQoFatKG0JrK2tTRdQatQk4tHR0URHRxMTE2O8kFVThCzuAKqLN6pHIKqbP2hbILmtrkLJSULJPgd5aSjq7+emNjY2BAcHm5bE8/Pza/ftbZMy5u7du3PkyBGeeuopIiIicHd3b/APMWzYsOsO8Ep+/vlnBgwYQOfOv38pTpgwoU6crq6uvPLKK2RmZuLp6dng89x+++1MnTrVdL/mSl12djZ6/aWLEXR8+fn5ZGRkmDsM0YJqJ93Z2dkWNTdRq9W22gU1Nzc3zp49y8SJExvcfubMmTrtl2hbysrKTEsTjbADp8sso9PPxtjjk3Fx/zlz5sjokXbKYDCwZcsWAFTPkPpDLV29UW0dKS4uZs+ePdx4441miNJy7dq1ixEjRjB37lyKiooACAwMpG/fvkRERDB//nxOnTplKhDWGJ07d2bmzJl4eXmhqiq7d+/m7bff5u233zbVI5JaQb+ztrZm4MCBDBw4kPz8fH766Sd2/fwzaVVVfFoEA21UbtGBfQPtZbWqsq8cdpYZl/pSFIXBgwczdepUKUTZymon4rfccgt6vZ7kZGOhyMjISBITE1Hy01Dy01Bj96O6+aF2DQFXb+NqDk2lqsbh4udjULITUAy/51m+vr4MHDiQ0NBQ/P39O9y5aZOS7iVLlphuX2kIT0sO78nOzubEiRNX7MEGCA4OBrhi0m1tbX3ZA2uJlZ0NBoNFvm9LUvv4qqoqx7uFjBo1iq+++org4GBuvvlmU+GXmhP7mnnAou0xGAwsX76crKwsnDQQcYVRdhpF4Q86lY+L4ODBgwQHB3PDDTe0XrCi2Rw5coSMjAxUrQ2qV+/6Oyga1G79UeL2s3nzZsaMGWPRCVhry83NZdq0aQCm87bKykrAeEF1zJgx/PDDD8ycObPRz3lpzY0ZM2awdetWYmNjTUm31ApqmIuLC/fccw+33HIL3333HTt37iSyEuKq4IFOKp7a3xPvUoPK58WQcjHH6tu3L/fcc0+bK3ZlqbRarSkJnzJlCufPnzdVtE9PT0fJjofseFQbB1Tv3qjeoaC9hravugolIxol/TRKeZHpYQ8PD4YNG8bQoUM7/P+FJiXdbaF65M8//4yzszMDBw684n4166peuqajEEK0tNtvv53o6GhWrlzJxo0bTV8o6enpFBYWEhoaKkl3G7Vt2zaOHTuGFTDTEeyu0nPd3Vphor3KT2Wwdu1aAgICZC3ndqa6uppvvvkGANW332VPKFXPnqgpx8nPz2fXrl2XHckimp+joyPl5ca5nnZ2dtjb25OVlVVnn+uZsmMwGDhw4AAVFRWEhISYHpdaQVfm7OzMfffdx9ChQ/n00085f/48K4rgoU4qXlqFUoPKp0XGImn29vbce++9jB49ukP+LToKT09P/vCHPzB16lSSkpLYu3cvBw8epLS0BCXxV9SUE6g+oai+/a+cfFfrUdJOGX+qfv/sDh06lNGjRxMUFGQx/w+alHSbu3iIwWBg165djBs3DisrK9PjmZmZ7N27l4EDB+Lo6EhycjIrV66kd+/e+Pn5mTFiIYQlsra2Zv78+ezevZtDhw5x/vx5wLjEx/Dhwxk7dqwse9IGJSQk8NVXXwEwWQe+2sadEIy2M/biRFVV89///pcXXnihTVdSFXXt3buX8+fPo1rboXr3ufyOGivU7uEosXv54YcfGDNmjBR7aiUBAQHExcWZ7vfp04cffvgBf39/VFXlxx9/bNLFruTkZObPn09VVRV2dnY8/fTTpuHOUiuo8by8vBg0aBDz588nJiaG1cXwN2eVb0qMCbeLiwtvvvmmnJO3M97e3owYMYLKykp++eUX1q9fT0pKCkryb6jn4zD0igDnBkYTF+WgOfuzaf1sT09P7rrrLsaPH4+dXQNFUjq4666Clpqaaio+4e7u3ipzMk6ePElOTk694XtarZaTJ0+yefNmKioq6NKlC8OGDZOeJCGE2Wg0Gm644QYZbtxOREdH88G//kV1dTW9rWHoNdSOURSF2xxUUgvg/PnzvP322zz55JM4Ozu3XMCiWWRlZZmSJLX7gKsOm1Q9Q1BTT1JcXMD//vc/mcffSm688UZ2795tWid9xowZvPzyy6YRmA4ODtx///3X/Lze3t688847lJaWcvDgQZYuXcrChQvx9fWVWkFN8Ne//pX58+eTX1DAtjI4fbHT/4knnsDGxkbqBrVjffr04eWXXyYyMpL169eTk5OD1fHvMfQej+r+e6E2clOxOv0TqCrOzs7cfffdDB06FCsrK/Ly8sz3BlpAY2sFNTnpPnLkCKtWrao3rMfDw4PZs2dfdl3a5hAWFsb69evrPe7m5sbChQtb7HWFEEJ0XIcPH2bFihVUVVXhp4U7HK59KKhOo3B/J5WVRZCSksLrr7/OX//6V3x8fK7+y8IsiouL+eCDDygtLUXt5N7wXO5LKRoMPUZjdXIzBw8exNvbmylTprR8sBZuyJAhDBkyxHTf19eXDz74gNOnT6PRaOjZs2eTKl9rtVpTAh0YGMi5c+fYvHlzgxXKpVbQ1dnb23PTTTexYcMG9l1c+WnAgAF0797dIt5/R6coCoMGDSI0NJT//e9/HDx4ECVuP6qrr/GCpaEaTdw+UFXCwsJ4+OGHTZ9LSz7+TUq6IyMjWbx4Me7u7syYMcPUu52amsqOHTt49913efbZZxkwYEBzxiqEaCa1Gz3pnWk+CxcuRFEU5s+fj5WVVaMuAiqKwksvvdQK0YnLMRgMbNy4kc2bNwPQyxrucQTrJn42vLQKc51UPiuCnJwcFi1axJw5c65ag0S0vqKiIt59913S09NRbXQYQieAxurqvwjg4oUhcDiacwf4+uuvURSFyZMnt2zAFqyyspK1a9fSp0+fOh07Op2uTiLeHAwGQ5052bVJraDG6devX50h9tdSUV60D/b29jz00ENERUVRWFgIRdng6gOl+SjlRdjY2PDoo49a5FDyhjQp6f7qq6/w8/Nj4cKFdf6QgwcP5uabb+all17iyy+/lKRbiDbKkq80tqRL/66qql71ooYcC/MqLi7m448/5tSpUwCMsYOb7I0Vya9HFyuFPzqpfFEMCRUVLF26lD/84Q/ceuutMo+/jSgrK+Of//wnqampqDb2GPpPBluHa3oO1acPBn0FmqRIvvrqK2xtbWUZsRZiY2PD9u3bm30a45o1axgwYABubm6Ul5ezd+9eoqKimD9/vtQKug6XVqLu6JWpLVVZWRklJSXGO3ZOF/819mpXVlZSVFQkSfdFTUq6k5OTmTFjRoN/RDs7OyIiIli7du11ByfMQ3o+LYskfc1nwYIFV7wv2paUlBSWLl1qXKseuM0Bwmybr/1z0Cg82Enlx1I4WAHfffcdiYmJzJkzp0lDYEXzqaio4IMPPiApKQnV2g5D/ymgc2nSc6l+AzEAmqRI1qxZg729PSNHjmzWeIVRYGAgKSkpzfqcBQUFLF26lLy8PHQ6HX5+fsyfP5/+/fuTk5MjtYKaSKPRYG9vT1lZGYAUleygtmzZQnV1NapjF1OyjdYW1cUHJT+NH374gQcffNCsMbYVTUq6ra2tr7gkQ3FxcYdb0NySSBImhOjo9u3bx+eff05VVRWuGuOyYF6NrFJ+LawUhakO4KM1VvA9efIkr776Ko8//rj0lJlJRUUF//rXv4iOjka1ssbQ9+YmJ9w11O7hGKoq0KSfZsWKFaiqyqhRo5onYGEye/Zs3njjDbp160ZERESdFWya6k9/+tNlt0mtoOsjSXfHVzPdQvUKhVqddgbv3ljlp5m2iyYm3X379mXz5s0MGDCgzjqGALGxsfz4448yd6Mdk57ujq/2MZbj3XxycnKa9Htubm7NHIm4nOLiYtatW8f+/fsB6GENdzkYC6C1pHBbBU8rlTXFxv8nb7zxBrfffjsTJkxolsRBNE5eXh4ffvghiYmJvyfcnZrh86coqEHDMajVaDLOsmLFCvLz85k8ebK0sc1o2bJlaDQa/vvf//Lpp5/SuXNnbGzqVppXFIV33nnHTBGKy5HRPR1TzXFVsmJRPYLASmsspJYZAxhXFBBGTUq677vvPubPn8+LL75IcHCwaZ5Geno6cXFxODs7M2vWrGYNVLQe6enu+GofYznezWfevHlN+r1169Y1cyTiUqqqcuDAAdatW0dxcTEKEGEHNzTD/O3G8tIqPO6k8mUJxFRVsX79eg4ePMgDDzxAQEBAq8RgyZKTk1myZAn5+fmoWlsMfSeBk0fzvYCioAaPwqCxQpN2mq+//pqMjAwefPBBtNrrXqFVYDzB79Spk8wPbidqX3CSEbAd0+TJkzl16hTlBZkosXtRe0WgJBxGyU3G2tqaW2+91dwhthlN+hbw8PDg3XffZePGjfz222+mHgN3d3cmT57MbbfdJuuSCiEszpWGKQrzyc7OZtWqVURFRQHgYQXTdOBn3fo9kPYahfscVSIrYEuZMRFctGgREyZM4LbbbpOCMy3k7NmzfPDhh5SXlaHqXDD0mQj2Ts3/QoqCGjQCg70zmnMHOHDgAEVFRTz++OPY2l7Dou+iQVIno32RUTwdn5+fH0888QRvv/02mqw4DJ27oUk3ftc+9thj9OzZ08wRth1NvvTq7OwsE+OFEKKWiIgIc4cgatHr9Wzfvp1vNm2isqoKLcae7VF2oDXjkF+NojDYDnrZqGwuhROVKtu2bSMyMpJZs2bRv39/GZLcjCIjI/noo4/Q6/Wozp7GhFtrc/VfvA6qdyjVdp2witrBqVOnePfdd3niiSdkiK0QosMJCQlh8ODBHDlyBM3ZnwEIDQ0lPDzczJG1LU1at2ThwoWcPHnysttPnTolhSeEaCfk5L71VFZWUllZae4wOjxVVTl69CgvvvgiX375JZVVVQRo4S/OMM5eMWvCXZujRuFuR4UHHMFFAxcuXOBf//oX7733HqmpqeYOr91TVZUdO3awbNkyY8LdxQ9Dv5tbPOE26dyN6v6TUbW2xMfH8+abb3L+/PnWee0OrLS0lE2bNrFo0SKeeeYZ4uLiAGO9hu+//57MzEwzRyiE5enbt2+d+3369DFTJG1Xk3q6o6KirrgOZWFhoWkYn2h/JAnr+GROd+vJyclh/fr1HDt2jMLCQgCcnJwIDw/nrrvuwt3d3cwRdhyqqnLmzBm+/fZbYmNjAXBU4CYdDLRpu21biI3CX6xVfi6DA+XG79gFCxYwcuRIpkyZQteuXc0dYrtTVFTEZ599xm+//QaAwbMnao9RoLTyGulOHhgGTEVzYgsZGRksXLiQGTNmMHr06Db7/7Etu3DhAgsWLCAnJwcvLy/S0tIoLy8HjPO9t23bRnZ2Ng899JCZIxXCsgQFBV3xvriO4eVXkpmZib29fUs8tWgFkoR1fHKMW0daWhovvfQSJSUl9O/fHx8fH8BYdPKXX37h6NGjvPrqq1IU6Dqpqsrx48f5/vvvSUhIAIxfbqPtYIw92LaD5MZWUbhZB0NsVbaWwukqlX379rF//36GDh3K5MmT8fX1NXeY7cLx48dZuXIlBQUFoGgwBAxB9elbZzmbVqVzxRB+K5qzu6goyOCzzz7jxIkT3H///Tg5tcC88g7s888/p6ysjHfeeQcnJyfmzp1bZ/uQIUOIjIw0U3RCWC5PT8869/39/c0TSBvW6KR7165d7N6923T/66+/ZseOHfX2Ky0tJSkpScbxC9GGSdLdOlavXo2iKLz99tt07969zrbk5GReffVVVq9ezd///nczRdj+xcXFsW7dOuLj4wHjl9oQWxhtD84tvAxYS+hipTCjE6ToVXaVQXSVyqFDhzh8+DAjRozg9ttvp3PnzuYOs00qKytj7dq17Nu3DwDV3hlD7xvAsQ0syWfrgKH/LSipJ9EkHiUyMpKYmBjuv/9+Bg8ebO7o2o0TJ04wZcoUfH19KSoqqre9a9euXLhwwQyRiYbIuYbluHTkjlSrr6/RSXdlZaVpaCQYv9wu/QMrioKtrS033XQTd955Z/NFKVqVDHkTonmcOXOGqVOn1ku4Abp3786kSZP44YcfzBBZ+5eTk8OGDRs4cuQIADbAMDtjkTTHdphsX6qbVuH+TpBxMfk+XaWyf/9+fj1yhEk338zNN98slc5riYmJ4ZNPPjElXAafvqj+g41rxrYViga1WxjVrr5oondTXJzLv//9b0aOHMmMGTPQ6XTmjrDNq6ysvOLogLKyslaMRlyNnE8K8btGfxtNnDiRiRMnAsa1aB966CG5OttByZXJjq/2F6F8KbYcvV6Pjc3lizbZ2tqi1+tbMaL2r6ysjM2bN7N161b0ej0KMNAWJthDpw6QbF/KS2vs+U7Vq/xYCklVVXz33Xf88ssv3HHHHYwYMQKNppXnKbchFRUVbNy4ke3bt6OqKqqtI4ZeEeDsedXfNRvHLhjCp6EkRaJJOcH+/fs5e/YsDzzwAP369TN3dG2ar68vZ86c4aabbmpw+5EjR2RYqxCiTWrSJeClS5c2dxxCiFZUO9GWiywtJyAggJ07d3LjjTfW68UqLS1l586dBAYGmim69kWv17Nnzx6+/fZb06irQC3cojMmph2dr1ZhTieV01XwUynkFRSwYsUKduzYwR133EFoaKjFXUCLiopi5cqV5OTkAGDoGoIaNLz1qpNfD40VasAQqjt3QxO9m9zcXN5//31GjBjBvffeK0uLXcbkyZNZunQp3bt3Z8SIEQAYDAYyMzP58ssviYmJ4f/+7//MHKUQQtR33eOuysrKKC0tbfDE3c2tDcyjEkIIM7n77rtZtGgRf/vb34iIiDAVTEtPT2f37t0UFRXxyCOPmDnKtq26upoDBw7w3XffmZKrLhq4WQe9rC1rpIaiKPS1gV7WKgfKYVc5JCUl8d577xESEsL06dPp0aOHucNsceXl5WzYsIGffzauB6vaOmDoMRo6dzNzZE3g7Ilh0HSUxKNo0k5x4MABoqKimD17NmFhYeaOrs0ZO3YsOTk5rFu3ji+++AKA119/HVVV0Wg0zJgxg6FDh5o5SiGEqK/JSffWrVv5/vvvr7jm5Lp165r69EKIFlRdXW3uECxC3759ee655/jf//7HN998U2ebv78/f/7zn+utbSl+l5KSwvLly0lJSQGgkwLj7GGwLW1mrW1z0CoKY+wh3FbllzI4XGGc0/zmm28ybNgwZs6c2WF7Ss+dO8cnn3xCVlYWAAavXqgBQ9tH7/blWFmjBg2n2j0QTfRuCgoK+Ne//sWYMWO49957Ze7+JaZPn87YsWM5ePAgmZmZqKpK165dGTZsmCyvJ4Ros5qUdG/dupXly5cTFhbGDTfcwBdffMGUKVOwtrZm165duLi4cMsttzR3rKKVWFLPkaUyGAym23K8W1b//v15++23yc/PJzs7GwB3d3dcXFzMG1gbVlVVxZYtW/ju22+pNhiwV2CcHQy1Axv5/2riqFGY7ACj7I3F1o5WwKFDhzhz5gz3338/4eHhHebzrdfr2bx5M9999x0GgwHVxgFDzzHg2oGWUXPywDDwdpTEX9GknWLPnj1ER0czd+5cmYZyCTc3N6ZOnWruMIQQotGalHRv2bKFsLAwnn/+eYqKivjiiy8YOHAgffv2Zdq0aTz77LMNLuUg2geZ4ytE89iwYQNDhw6le/fuuLi41Eu0U1JSOHTokKz2cJHBYODQoUNs3LjRVIW6tzVMc+gYFclbirNGYZoDDLJV+aoYsgsLWbp0KT179uTOO+9s9wlbXFwcq1atIi0tDQCDexBqj5GgtTVzZC3ASmvs9e7SHc3Z3WRlZfH6669zww03cPvtt0uF84uSk5M5duyY6UKmh4cHAwYMaHClCCGEaAualHSfP3+eSZMmAWBlZQVgqsCr0+kYP348W7du5Q9/+EMzhSmEaClykaXlfPnll3h6el72RDAlJYUvv/xSkm4gNjaW1atX1xlKPkkHYTYyGqOxfLUKjzur/FwG+8shOjqaRYsWMWjQIO699952t753aWkpGzZsYPfu3QCoWlvUoBGoXYPNHFkrcPE2zvU+dwBNVhw7d+7k6NGjzJo1i0GDBpk7OrOpqqriv//9L7/88gvwe9ugqiqrV69mzJgx/PGPf0SrbUNLxQkhBE1MunU6nWlOqE6nw8bGxlTgBsDe3p78/PxmCVAI0fwkiWkbiouLLf7ksLy8nK+//pqdO3eiqip2CoyxgxEylLxJrBWFiToYaquyswyOVcLRo0eJiori7rvvZsyYMe3i8//bb7/x+eefm84lDF1DUAOHgrUFzW+2tkXtFUF11x5o4vZRUFDAsmXLGDhwIPfddx/Ozs7mjrDVrV69ml9++YWJEydyyy230LVrVxRFITMzk82bN7Nt2zYcHR158MEHzR2qEELU0aSzvW7dupGUlGS6HxISwrZt2xg4cCAGg4Ht27fj5eXVbEHWWL9+PRs2bKjzmLe3N++//z4AlZWVrFq1iv3791NVVUVYWBhz5syRuZPXqD2ckInrU7t3W45384qKiiIqKsp0/9ChQ2RmZtbbr6SkhP3791v0cMjs7Gzee+89U1GsgTbGquQ6GUp+3VysFKY7wki9yqYSSC0rY+XKlZw4cYLHHnsMa2trc4fYoMrKStatW8euXbsAUO2cMISMBhdv8wZmTq4+xl7vpN/QpB4nMjKS2NhYHnnkEYtb13vPnj2MGTOm3qoP3t7ezJkzh7KyMvbs2SNJtxCizWlS0j1mzBi2bdtGVVUV1tbW3HXXXbz66qv86U9/Mj6pVtti6yR269aNF1980XRfo9GYbq9cuZLIyEieeuopdDody5cvZ/Hixbz66qstEktHJcONO77a1cvleDev06dP17k4ePjwYQ4fPtzgvr6+vjz88MOtFVqbcv78ed555x3y8vJw1sDtDhBsLcl2c/PUKjzqZFxibFsZHDt2jA8//JB58+ZhY9O2Kn6npqby8ccfk5qaCoDBtx+q3yCwsuzRIABotKgBg6l2D0ATvZuiIuO63pMmTeL2229vsxdRmpteryckJOSy23v27MnRo0dbMSIhhGicJn2T3XDDDdxwww2m+7169eK9997j6NGjaDQa+vfvb1qPtrlpNJoGe65LS0vZuXMnTzzxhGkJnscff5wnn3ySmJiYKzbSQliamhoMULeSubh+06ZN4+abb0ZVVebOncvcuXMZNmxYnX0URcHGxqbNJT2tpaysjPfff5+8vDzcNfCQEzhJ73aL0SgKo+zBU6vyvyI4deoUq1atYs6cOeYODTC2Qdu2bePrr79Gr9ejWtth6BkBnTtQZfLm4tgFQ/itKOcOock4w08//cTp06eZM2cO3bq1w3XKr1FYWBi//fYbEydObHD7b7/9Rv/+/Vs5KiGEuLprTrorKyvZvn07/v7+hIaGmh7v2rUrkydPbtbgGpKZmWkaGhcSEsLMmTNxc3MjPj6e6urqOkOtfHx8cHNzu2rSXVVVRVVVlem+oijY29ubblsaRVEs8n1bktpJd1VVlRzvZlQ7mf7www9xcnLC1rYDVlm+DmvXriUrKwtnDTziJJXJW0uQtcJ9nVQ+K4IDBw7Qt29fhg8fbtaYcnNzWb58OWfPngVA7dwNQ8gYsJEq3Zel0aL2GEW1qy+a2D2kpqby2muvMX36dG666aY6IwA7mnvvvZd//vOfvPvuu0yaNAlPT08AMjIy+Omnn8jOzubJJ5+kuLi4zu911HXrhRDtxzUn3TY2NqxevZqHHnqoTtLdGnr06MHjjz+Ot7c3eXl5bNiwgZdeeonFixeTn5+PVqvFwcGhzu84Oztftajbxo0b6wwHDQgI4K233sLd3b0l3kab5+rq2iJz8kXbUV5ebrrdqVMnOd4tpKE2pKKign379qHX6wkPD7e4dubw4cPs27cPBbhLlgJrdUHWChF2Kj+Xw/8+/5ygoCCz/R88cuQIq1atorS0FDRaDEHDUT17glwEbBw3PwxOHmhi9qDPTWb9+vWcOHGCRx55pN1Vqm+sJ598EjAuGXbkyJEr7lPbunXrWjQuIYS4miYNL+/evbtpbcTWFB4ebrrt5+dnSsIPHDhwXcM0b7/9dqZOnWq6X9Prl52dXadH0FLk5eWRkZFh7jBEC0pPTzfdzszMtKjET6vVttr7/fe//01cXByLFy8GjCMM5s+fb1oWS6fT8dJLLxEQENAq8ZhbSUkJq1atAmCcHfjLHG6ziLCHc3pILi9n1apVLVaD5XIqKipYu3Yte/bsAUDt5I6hVwTYW1417utmY4+hz00omdFozh3k7NmzLFy4kIceeogBAwaYO7pmd8cddzT7yKytW7eydetW03mtr68vd955p+mcU4r0CiGaQ5OS7nvvvZd//etf9OnTx6xzZxwcHPD29iYzM5P+/fuj1+spKSmp09tdUFBw1YbR2tr6skVILKXIVO33qaqqxbxvS1X7YpJer5fj3UJOnz7NmDFjTPf37t1LSkoKf/nLX/D392fx4sV8+eWXPPPMM2aMsvVkZGRQVlaGgwI32Js7GstlpShM0an8uxDOnTvXqq+dlJTExx9/bLqwa+gWZiyW1oGHRLc4RUH16kW1sxeaszspLr7ABx98wPjx47nrrrs6VO2Iu+++u9mfs3PnzsycORMvLy9UVWX37t28/fbbvP3223Tr1k2K9F4HmbomxO+alHRv2bIFR0dHFi1ahIeHBx4eHvUadUVRWvxEsry8nMzMTMaMGUNgYCBWVlacPHnSNEctPT2dnJwcKaLWCJJ0WRb5Imwd+fn5dXrVDx8+TGBgIKNHjwbgxhtv5NtvvzVXeK3Ozs64xnKlCoUGcLUyc0AWLOfiAgY1x6SlGQwGtm7dytdff011dTWqjc5YLM3VgpcCa246ZwwDbkVJOIIm7RQ7d+7kzJkzPPbYYxZRZK2pBg8eXOf+jBkz2Lp1K7GxsXTp0kWK9F4HObcU4ndNSrqTk5MBcHNzw2AwNLgGbUuc1K9atYrBgwfj5uZGXl4e69evR6PRMHr0aHQ6HePHj2fVqlU4Ojqi0+lYsWIFISEh0ig2Qu2eT0nIOr7ahXbkeLccW1tb43xVjMu0RUVFcfPNN5u229nZmbZbAm9vb3x9fUlNTWVlEcxxUmVOtxkkVKlsLDHeHjp0aIu/XklJCcuXL+f48eMAqG7+GHqMBuvWSfgtisYKNWi4schazG4yMjJYtOh17r//PkaNGmXu6JpFeXk5hw4d4vz585SUlNRL7BRF4aGHHmrScxsMBg4cOEBFRQUhISFNLtIrBXrrs9T3bankeNfXpKR76dKlzR1Ho+Tm5rJkyRKKiopwcnKiV69eLFq0CCcnJwBmz56NoigsXrwYvV5vmncjrq520i1XJju+srIy0+3aRdVE8woMDGTHjh306dOHX3/9lbKysjq9KufPn8fZ+drnsUZFRfHtt9+SkJBAXl4eTz/9dJ3kSVVV1q9fz44dOygpKaFXr17MmTOnTsG84uJiVqxYwdGjR1EUhWHDhvHQQw+1aM+nRqPhiSee4I033iAnN5f/FML9jipdtfLl3FpOVKh8XQJ6jMsv3XXXXS36ekVFRbz55pvGi/OKFYbgEVIsrTV09sUw6A40Z3dRlZfKihUryMnJYdq0aeaO7LqcPHmS995776oXK6816U5OTmb+/PlUVVVhZ2fH008/ja+vL4mJiU0q0isFeo202t/TDCnYalnkeNfXpKTbXP72t79dcbuNjQ1z5syRRLsJaifacnWq48vLyzPdvlp1f9F09957L4sWLeLZZ58FYNiwYQQHB5u2Hz58mJ49e17z81ZUVODv78/48eN59913623/5ptv+PHHH5k3bx4eHh6sW7eORYsW8d5775mmAv3rX/8iLy+PF154gerqapYtW8ZHH33EE0880cR32zidO3fm6aef5v333ycrK4v/FsGN9ipDbMFa2p4WU2hQ2VUGhyuM9wcMGMCjjz6KlVXLjfHX6/UsXbqUzMxMVBsHDH1ugk5uLfZ64hLWdhj6TkJJikSTfIxvv/2Wrl27mn2ZuOuxfPly7OzsePLJJwkODkana56l5by9vXnnnXcoLS3l4MGDLF26lIULFzb5+aRAr1Ht9yoFei2LJR3vxhbobVTSnZOTAxiHk9e+fzU1+4u279JCaqJjq5105+bmmjGSji0oKIj333+f6OhoHBwc6iyzWFJSwqRJk5q09GJ4eHid1RxqU1WVzZs3M336dIYMGQLAn//8Z+bOncuRI0cYNWoUqamp/Pbbb7zxxhsEBQUB8PDDD/PGG29w//33X3a5oeYaMunp6ckLL7zAhx9+SExMDJtLYU8ZjLNXGSTJd7MqMqjsuZhs15z+Tpo0ibvuuqvF13OOi4sjNjYW1coaQ7+bwcG1RV9PNEBRUP0HYTDo0aSeZPPmzYwYMcLcUTVZTk4Os2bNavYivlqt1rTmd2BgIOfOnWPz5s2MHDmySUV6pUCvUe3vBUt630KOd0MalXTPmzcPgNWrV6PVak33r0bWRWw/qqurTbflg9Lx1R6aZ0lzilubXq/HycnJlPzW5uDgwOTJk5v9NbOyssjPz69zUqrT6QgODiYmJoZRo0YRExODg4ODKeEG6NevH4qiEBcXd9l5vs09ZHLx4sVs27aNL774gqysLL4vha2l0MNapbcN9LQGe5nzfc3yqlWiqiCqEpL1UNOih4aG8sADDxAWFtYqcZiWFrWyBluHK+8sWpbOeMHD2tq6XQ/79PPza5XvLIPBQFVVlRTpFUI0m0Yl3X/6058ATMPQau6LjqOystJ0u3ZPluiYSkpKTLcl6W45c+fOZfjw4YwdO5bevXu3ymvWTBe4dK547TmI+fn5ploYNaysrHB0dLzidIOWGDI5YMAA+vTpw969e9m8eTMXLlzgdBWcrgIrIEBrTMBDrMHVShLwhhhUlYxqiK6CM5WQUV13e3BwMNOmTSM0NBRFUVpt2J+9vT329vaUlZWiOf4dhtAJshZ3a1NV4xrecfsA44Wyxh7/xg6ZbE2zZs1iyZIlDBgwoM5Fw+uxZs0aBgwYgJubG+Xl5ezdu5eoqCjmz58vRXqFEM2mUUl3RETEFe+L9q92Ya3at0XHdOHChQZvi+Y1fPhwDh06xM6dO3Fzc2PMmDGMHj0aX19fc4fWJC01ZFKr1RIREcG4ceNISkoiMjKSyMhIMjIyiNND3MV83l2jEnIxAffTgtaCh6GXGVTiqoyJdmwVlNT68yuKQkhIiGkaQu2pXq05ksnBwYG///3vLFmyhIKCPKx+3YChawhq93Cwc2y1OCySqsKFZDRJR1FKjFOIhg0bxj333NOuR7OFhoYye/ZsXnjhBXx8fOjSpUu9aRLXumRtQUEBS5cuJS8vD51Oh5+fH/PnzzeNFpIivUKI5nDdhdRUVaWwsBAAJycnKcLVTtXu3Zae7o6toqKChIQE0/20tHQKCwvr9XyK6/fYY4/xyCOPEBkZyZ49e/juu+/YuHEjAQEBjB07lpEjR15xXmBT1DxfQUEBrq6/z6EtKCjA39/ftE9Nu12jurqa4uLiZo/nWiiKgr+/P/7+/kyfPp3MzEwiIyM5ceIE586dI9tgILsc9pWDDRBorRJsDcHW0EXTsYtAVqsq6dXGBDuuClJqDRsH4/J0oaGhhIWFMWDAADp16mS2WGurSWBWrVrFqVOn0GRGw/lYDG7+qB7B4OoLLTy33KJUlKBkx6OcjzUl23Z2dkyZMoVbbrml3X9GDh48yAcffIDBYODChQsNdhJc63u82uhNKdIrhGgOTU66U1NTWbduHcePH6eiwlgO1dbW1rQESffu3ZstSNHyag8vrzmeomM6efIkFRUVqHZOoLXBUJxDZGSkjGBpIVqtlqFDhzJ06FBTZdy9e/eyatUqPv/8c/r378+YMWMYOnSoqbL49fDw8MDFxYWTJ0+akuzS0lLi4uKYOHEiAP/f3p2HR1Xf/f9/nslM9o0ACQlbCAlhX8Im+yrIohXF3dalqHeltXettddPv23Rqr3pKnW5a71pFa0KoogbCijIDrLvCVuAQEL2hOyZzPn9MTAmJmEJmUwyeT2uKxcz55yZeU8mOeR1PluPHj0oLi7m+PHjxMXFAbB//35M06wxu7qndejQgenTpzN9+nSKi4s5ePAg+/btY9++fRQWFnK4Eg5fuEYYboF4m0mCDbpZIbCFjwU3TZM8Bxy7ELKP2aHsew2UMTEx9OvXj/79+xMfH19jeZ7mpG3btvziF7/gyJEjfPTRRxw+fBhL1nHIOo5p9cNsH4fZvhuERoHFfbOpe63yYozcNIysYxj5Z12b/fz8mDRpElOnTiU42Dt6FrzzzjvExMTwy1/+kpiYGE+XIyJyxRr0P/ShQ4d44YUXME2TIUOGuE58Z8+eZfv27ezevZunnnqqycYwyrWrPsa3+m3xPocOHQLAjOgEVj+MomwOHTqk0N0ELo4P7Nq1K8uXL2fr1q3s3r2b3bt34+/vz+TJk7ntttsuu1Z2WVmZc93jCzIzM0lNTSU4OJh27doxffp0PvzwQ6Kjo4mMjOS9996jTZs2rgndOnXqxMCBA3nttdd46KGHsNvt/Otf/2LkyJH1zlzuaUFBQQwdOpShQ4ficDg4ffo0Bw4c4MCBAxw5coT8qiq2l8P2C9cM21pMYqzQyQdirM4vv2bcylfkMEmzwxk7nKly/lv8vZAdGBhIr1696NOnD3369GlxK4QkJCTwq1/9itTUVDZv3sy2bdsoLCzESD8E6YcwLT4QFo0ZHoPZpiMERWg977rYK6AgHSPvLEb+GYyS/Bq74+Pjue666xg6dKjXhO2L8vLyuPfeexW4RaTFaVDofvPNNwkLC2PevHm1/tPPzs7md7/7HYsWLeIPf/hDoxQp7ld9YpXqf8yLd8nOzmbDhg0AmBFdwOYHp3axY8cO0tLSWuxY45YgMzOT9evXs2HDBs6ePUtISAhTp05l3LhxWK1WVq9ezYoVKzh37hxPPPHEJZ/r2LFjNdaQXbRoEQDjxo1j7ty5/OAHP6C8vJzXXnuNkpISevbsyVNPPVWjJf2xxx5j4cKFPPvssxiGwfDhw3nwwQfd8+YbmcVioWvXrnTt2pXp06dTVlZGSkqKK4Snp6eT44CcCth34TEG0N7HpKMPdLJ6dmI2s1pX8bN2SKuCQkft43x8fIiLi3OF7NjYWLcv89UULg4huP322zl06BBbt25l//79ziEPeWkYeWlwAkybvzOEh3XADOvQekO4vQIKz2EUZGAUpENhFka1wQWGYdClSxcGDx7M8OHDW9zFmKvRvXv3K162VkSkOWlQ6D59+jR33HFHnSf2du3aMWXKFN5///1rLk6azqlTp+q8Ld5l9erV2O12zLBoaNPRuYZru1jITuXLL7/kxz/+sadL9Crnz59n06ZNrF+/niNHjmC1Whk8eDD33HMPgwYNcq0IAfDjH/+Ytm3b8sEHH1z2efv06cOSJUvq3W8YBnfccQd33HFHvccEBwfz85///OreUDPl7+9P//79XRMfFRUVkZqaysmTJzlx4gSpqank5eWRWQWZVbDrwmiaaB/nzOi9bNDBx71jwu2mSardObv4ocraIdswDKKjo12BtFu3bnTq1KlRhhw0Vz4+PvTt25e+fftimiZnzpzh0KFDHDx4kOTkZMrLyyD7BEa2cw4K0+oLoc4AboZHQ3A77wzh9nLIT/8uZBfl1gjZ4BxG0rt3b3r16kXPnj29rkW7Pg8++CDz58+nW7dujBw50tPliIhcsQaF7vbt219yeRi73U7btm0bXJQ0vYKCAtftwsJCHA6HV7SoyHfOnj3L2rVrAXB07u/6Y9XRqT8+2als2bKFCRMmuMb4yrV7+OGHcTgc9OjRgzlz5jBy5EiCgupfr7hz586a0K4RBAcHu8LcRfn5+aSmppKamsrhw4c5evQo6VUm6aXwdalzTPggX5Pr/CGoEceDZ9hNNpXBwcqaY7L9/Pzo06cP8fHxxMbG0qVLFwICAhrtdVsawzDo1KkTnTp14vrrr8dut3PixAlSUlJISUnhyJEjzvlGck9h5DovDJs2f8w2nSCis7M7uu3SwzKaLdOE4lyM3NMYuWnOVu06QnZCQgI9evSgZ8+eXt2afSl///vfqaqqYsGCBbz22mv1zl7+pz/9yUMViojUrUGhe/bs2bz55pskJSW5Juq56MSJE3zxxRfcd999jVGfNJHc3FzXbdM0yc/Pb7ZjO+XqZWVl8fLLL1NZWen847RNtW7koZE42sdB1nFeffVVHn/8cY2XaySzZs1i7NixdOjQ4YqOHzx4MIMHD3ZzVa1TeHg4AwcOZODAgYCzF8KePXvYtWsXBw4cIL+ykjVlsL4MBvuZjPKHiAZ2PzcvtGqvL4OUaotBhIaGMnDgQAYNGkSvXr3qXX5NnBMQJiQkkJCQwIwZM6iqquLUqVOkpKSQnJxMcnIyZWVlGJlHIfMoYGCGtMdsF4vZPq75L0lmOqAgAyPzOEbuKYyKkhq7O3ToQM+ePV3rQVdfiaA1Cw4OJiQkhOjoaE+XIlegJS9PJ9LYGhS6U1JSCAsL49e//jWJiYmuPyjT09NJSUmhS5curqvTFxmGwQMPPNA4VUujKiwsJC8vD4AwCxQ4IDU1VaHbS2RkZPDHP/6RgoICTL9gHD3G1uqSacaPwizKIS8vjz/84Q/88pe/rHVBTa7e7bff7ukSpB4hISGMHj2a0aNHU15ezp49e/jyyy9JTU1lazlsK3eG78kBEHwVLd9n7CYrSiD1QmcwwzAYPHgwkyZNIj4+Xj2IGsjHx4du3brRrVs3pk6dit1u5+jRo+zbt4/9+/eTlpaGcT4T43wmnNiGGRqFGdkds1038G0mPQhME85nOoN29nGMiu+Wu/L19aVXr1707duXfv360b59ew8W2nzNmzfP0yWIiDRIg0L3l19+6bp98YpzdadOnapzXLBCd/O0atUqAGJ8oIsVtpQ7x/4OGjSoxa/p2doVFBTwl7/8xRm4g9rg6HsD+NXRvdnmh2PgjVgOrKSkMJMXX3yRp59+Wn/4XaPU1FTS0tIYPXq0a9vu3btZtmwZlZWVjB49munTp3uwQgFnV+9hw4YxdOhQkpOTWbFiBfv372d7Oewth3EBzpZv6yXOh+cdJl+WwO4L48WtViujR49mypQpREVFNdE7aT2sVis9e/akZ8+e3HbbbeTm5rJnzx62bdvGkSNHnF20C8/Bsc2YEV1wdOgBbTp7Zk3w8mKMc0cxziVjlBa6NgcGBjJ48GCGDBlCYmKiej6IiHixBoXuxYsXN3Yd4iEVFRV89dVXAEwIgGgf+LbceTHlxIkTGt/bwq1YsYLc3FzMgDAc/aZfusXH5o+j7w1Y9n7G+fM5fPzxx5pY7Rq9/fbb+Pr6ukJ3ZmYmf/7znwkJCaFNmza8+eab+Pr6MnnyZA9XKuBslb4Y5I4cOcJ7771Hamoqq0qda2XfHWwSUEerd7rdZNF5OH+hJ+V1113Hrbfeqt5CTSgiIoIJEyYwYcIEcnNz2b59O1u3biU1NRUj5yQ+OSedY8CjemDG9HZ/93PThLw0LGcPOsdpXxij7evrS1JSEsOGDaNPnz7Ndm315qykpISVK1dy4MABCgoKePjhh4mPj6eoqIi1a9cyZMiQKx7SIyLSVHS2b+UOHTpEeXk5YRboaXP+0dnL12R/hbNFTqG7ZSovL+ezzz7j66+/BsARN+zKulhafXF0H4nPnk/YvHkzgYGB3Hzzza16gqdrcfLkSW688UbX/W+++QaLxcL8+fMJDQ3lb3/7G6tWrVLoboYSEhJ4+umn2bJlC2+//TYnyst5/Tw8EGISUi14H680ebsIKkyIiYnhgQce0HnTwyIiIpgyZQpTpkzh7NmzbNiwgc2bNzvXBE/bC2f24WgXh9mpL4Q0cm+eKjtG5lGMM/trrJ+dkJDAqFGjGDJkiM6n1yAnJ4d58+aRnZ1NdHQ0Z86coaysDHCO9161ahVZWVnqWdlMqLekyHcaFLpLS0spLi6uMXtmbm4uq1atorKykuuuu474+PhGK1LcZ8+ePcB3gfvi7Yuh+5ZbbvFkedIAGRkZ/P3vf+fcuXMAzjGNEZ2v/AlCI3F0SMSSkczq1avZsWMHP/vZz+jataubKvZeJSUlhISEuO7v2rWL/v37u2Yo79+/P7t37/ZQdXI5FouFkSNH0rlzZxYsWEBmXh7LiuGHwSaGYVDsMFl8IXD37NmTuXPnEhgY6OmypZqYmBhuv/12brnlFvbt28fq1as5fPgwlqxjkHXM2fU8bjgEhl3bC5mmM2yf+NY1KZq/vz9jxoxh/PjxanltJG+99RalpaX86U9/IjQ0lIceeqjG/qFDh7Jz504PVSciUr8Ghe7XXnuNrKwsnn/+ecD5h+XTTz9Nbm4uhmGwYsUKnnrqKfr06dOoxUrjOnr0KDt27AAgsdpQsh42MIAzZ86wadMmRowYoauVzZxpmpw6dYp9+/axcuVKiouLMX2DcMSPgLZdr24tW8PA7DGGqvbdsBzZRF5eHvPnz2fKlCn079+f2NhYTQZ1hcLDwzlz5gwAeXl5HD9+nPHjx7v2l5WV6XerBejcuTOPP/44zzzzDCmVdnZXwCA/+LwEii+0cP/3f/+3xuQ2Y1arlUGDBjFo0CBOnTrFqlWr2LJlC47cU/jkpeHo2Aez62DwacCfReezsRzdiHE+C3C2tF9//fWMGTNGrdqNbO/evcyYMYNOnTpx/vz5WvujoqLIycnxQGUiIpfWoNCdnJxcozvk+vXrycvL4/e//z2dO3fm2Wef5cMPP1TobqZKSkr44IMP+OabbzBNkzYW6Fbtb8VAi0GfC13MFy5cyObNm7n33ns1GVAzdOjQIbZs2cK+fftqrLVuhrTH0WfKtc3a26YTjqSbsRxcTXn+WT755BM++eQTQkJC6Nu3L0OHDmXAgAGN8C6819ChQ1mxYgUVFRUcPXoUm83GsGHDXPtPnjyp36sWIiYmhhtvvJFly5axrhS6Wk32Xpg07cEHH1TgbkG6dOnCj3/8Y6ZPn86SJUvYu3cvlrR9mHlncfSeBAGhV/ZEpomRfhjLsc1gOvD392fmzJlMnjxZPw9uUlFR4eopVJfS0tJ690nT05JhIt9pUHNVYWFhjQlitm/f7lpPMiAggHHjxpGamtpYNUojqqio4M9//jNr167FNE2SfOG/QsH2vda22UEwOcB5VebgwYM8//zzZGZmeqZoqcU0TZYvX86f//xnNmzY4Jyd3GLFbNsVR8JoHP1nNM4yOVZfHH1vwJE4DrNdN0wfG+fPn2fz5s38/e9/57333sPhcFz763ipO++8k+HDh7N+/XoKCgp49NFHCQ8PB5wXv7Zs2UL//v09W6RcsYkTJ+Ln50eWAz4odk6N1bt3b7p16+bp0qQBoqOj+fnPf85jjz1GSEgIRnEOll0fQeEV/F9nmhjHNmM5uhFMBwMHDuSFF15g2rRpCtxu1KlTJw4dOlTv/m+//VbLXYpIs9Sglu6goCDy8/MBZ4g7fPgws2bNcu23WCxUVFQ0SoHSeEzT5I033uDkyZMEGnBXMHSz1d211WoYjA+Afr7OMYtni4t56aWXeOqpp9RdzoNyc3PZvHkzmzZtIiMjAwBHVAJmZDyEdQCLT+O/qMWCGZWAGZUADodzKZ6s41jSD7Fq1Sp27drFyJEjGTlypJYY+x5/f38ee+yxevf94x//wNfXt4mrkoYKDAwkKSmJzZs3c/LCOtwjRozwbFFyzQYMGMBvf/tb/vd//5fjx49j2bcCR//p9U+ydjFwnz2IYRjccsst3HDDDRp20wSmT5/OK6+8QpcuXVy/ew6Hg4yMDN5//31SUlL45S9/6eEqRURqa1Do7tGjBytXrqRjx47s3r2biooKhg4d6tqfnp6upVKaoWXLlrF161YswJ2XCNzVtfUxuDfE5H8L4OzZs7z66qv8/Oc/1zInTSw7O5t3332XPXv2uLprmRYrZvcRmNGJTVeIxQLh0Zjh0VSFR2NJ2UB2djYff/wxH3/8Mb179+buu+8mOjq66WpqoSwWiybdaoF69+7N5s2ba9yXli8iIoInnniCv/3tbxw5cgTLgVU4Bt8CNv9axxoZya7Aff/997uWBBT3Gzt2LNnZ2SxevJj33nsPgBdeeAHTNLFYLNx11101hvCIiDQXDUpO9957L8899xx/+ctfAJg5cyadOztnR3Y4HGzZssUtYz2XLVvGtm3bOHPmDL6+vvTo0YN7772XmJgY1zHz5s3j4MGDNR43efJkHn744UavpyWorKzkwIEDbN68me3btwNwUxDEXUHgvijU4gzeCwudXc3/+Mc/MmbMGJKSkggKCnJX6YIzbH/77bd88sknlJeXA2CGdXCuNdsuFqwebCVtH4cjogtGTipGxhGM/DMcPHiQefPmMX36dK677jqNVxavU/3/m6CgINdwAWn5/Pz8+PnPf85zzz1HRkYGxtHNmL0m1Dyo7DyWY1sAuOWWWxS4m1h2djYzZ85k7NixbNmyhYyMDEzTJCoqiuHDhxMeHk52dnaN1XXEczRRqMh3GhS6O3TowIsvvkhaWhqBgYFERka69pWXl/Pggw+6ZXmhgwcPMnXqVLp3705VVRXvvvsuzz33HH/961/x9//uavSkSZO44447XPdbW/fNqqoqkpOT2bp1Kzt37qSkpMS1b1IADPG7+pNgR6vBncEm/ymCY8eOcezYMd566y369evHsGHDGDBgQI3PQBrGNE1OnjzJ7t272b17N6dPn/5uX2gUjh6jIbCNByv8Hh8rZmS8s3t76XksRzdiz0tztXxHR0czcOBABg4cSPfu3fUfsLR41YdQhIVd4zJT0uwEBATw0EMP8fvf/x5L1jGquibVWE7MSNsPDjsJCQnccMMNHqy0dZo7dy4/+9nPGD16NDNnzqy1f9OmTSxYsIDFixd7oDoRkfo1uI+w1Wqtc7KKgICAGl3NG9PTTz9d4/7cuXOZM2cOx48fr9HFz8/Pr9W1PpSXl3PgwAF27drFnj17KC4udu0LMaCfLwzwc4bnhurha/DfYSZ7KmBfBZyrqnKFQ6vVSp8+fRg0aBADBw6ssTaxXF5eXp5rrHZ6enq1PQZmaBRmVDxmh8SrW/qrqQWE4Og7FSPzGMa5FChIJz3d+bVixQrat2/vGvutVghpqaoPCdAYXu8UGxvLgAED2LNnD0b6QczuF8btV9md5zbgxhtv1OffDNntdn0uItIsNTh0l5SUsHLlSg4cOEBBQQEPP/ww8fHxFBUVsXbtWoYMGUKHDh0as9Y6awAIDg6usX39+vWsX7+e8PBwBg8ezK233oqfn1+9z1NZWUllZaXrvmEYrsnCmnvL3P79+1mzZg0HDhyoMXldoAG9faG/L8RawdJI76ONj3OCtfEBcM7uXDJnXwXk2u3s2bPH+UeKYZCQkMCIESMYM2aM/gOsR0FBATt37mT79u0cPny42lhtH4jojNm2K2ZE5zrHFDZbhuG8QBAVD/ZyjNw0yDmFkXuKrKwsli9fzvLly+nRoweDBw9m8ODBmv9BWpTq/yc09/8fpOHGjRvn/P8s8zhm3HAwLBg5JzGqKmnXrp3G8jehkpKSGj32zp8/T3Z2dq3jiouL2bRpU6trdBGRlqFBoTsnJ4d58+aRnZ1NdHQ0Z86coaysDHAG4FWrVpGVlcUDDzzQqMVW53A4eOONN0hMTKRLly6u7aNHj6Zdu3ZERERw8uRJ/vOf/3D27FmeeOKJep9r2bJlLF261HW/W7duzJ8/v1nPxFxcXMxrr73GqlWrXNvCLdDbBr18oYsVfNz8B2GU1eB6K0wOMDlXBYcq4VAFnK0ySUlJISUlhe3bt/P444/XGAfZ2iUnJ/N///d/HDhwoMYalmZoB8wOCZjtunl2rHZjsfphRnaHyO6YVXaM7FSMcykY+WddPx/vvvsuiYmJPPDAA1rzW0SajT59+hAYGOgMewXnIDwaI/sEAMOGDdMFlyb02Wef1fgb7Y033uCNN96o9/jqwwtFRJqLBoXut956i9LSUv70pz8RGhrKQw89VGP/0KFD2blzZ6MUWJ+FCxdy+vRpnn322RrbJ0+e7LrdpUsX2rRpw7PPPktGRka9Le+zZs2qMTbo4n+mWVlZ2O12N1TfMPn5+aSkpJCcnMyuXbvIz8/HAIb7wWA/6ODjmZYXwzDoYIUOVpgQAHlVJvsrYE0ZHDhwgJ/85CckJSWRmJhIjx496NChQ6v9g6WkpIRnn32W3NxcAMyQ9s71r9vFQkCoZ4tzJx/rdy3gZUXOydeyUjEKM0hOTubZZ5/lhRdeIDTU/d8Dq9XarC+oiYjnWa1WBg4cyKZNmzByTmKGRkJuGgBDhgzxcHWty8U5Y0zT5D//+Q+jRo2iW7duNY4xDAM/Pz/i4uLo3r27hyoVEalfg0L33r17mTFjBp06deL8+fO19kdFRZGTk3PNxdVn4cKF7Ny5k2eeeYa2bdte8tj4+HiAS4Zum82GzWarc1/1lsimZJomOTk5HDlyhOTkZFJSUjh37lyNYyIscEsQxF7FTORNoY2PwZgA6Otr8mExnKioYMuWLWzZ4pzxNSwsjB49eri+YmJivLYLenFxseszTE5O5tSpU5imiWn1w5F0M/i3wrHv/sGYHftiduwL5SVYdn9MSUkRv/jFL+jYsSOJiYmuCzSaG0BEPKVv377O0F14DrMoB8NhJzg4uEbvOnG/i38rgHP+muHDhzfqZ6CVcUSkKTQodFdUVFyyRaq0tLTBBV2KaZr861//Ytu2bcybN6/GrOn1SU1NBaBNm2Y04/P3OBwOMjMzOXnyJKdOneLUqVOcPHmyxmRoAAbO1uxYK3SzQYINbM24xbiNj8EDISapdjheCal2SLM7xzJ/++23fPvtt4BzdvlOnTrRtWtXunTpQteuXYmJian3QkhLYJomn376KR9//DEOh6PmPv9QzK5JrTNwf59fII74EVhOfAsl+aSlpZGWlsZXX32FYRhMmTKF2bNne+1FGRFpvuLi4pw3inIwzme6trXWnlrNwW233dboz6mVcdzHUw1XIs1Rg0J3p06dOHToENdff32d+7/99ts6Zza/VgsXLmTDhg08+eSTBAQEkJ+fDzhnk/X19SUjI4MNGzaQlJREcHAwp06d4s0336RXr15uWcKsoUpLS9m7dy9Hjx7l1KlTnD592rUGc3UWINoHYm3QzQpdrRBgaVn/2VsMgzgbxF3Iz5WmSZrdGcBPVMJpu/MizvHjxzl+/LjrcT4+PsTExNClSxfi4uIYMGBAs75wUlpayrlz58jIyCAjI4Pjx49z4MABAMyAMMywaAiPxgzrAH5a27yGtl1xtO0KFSVQkIFRkIGRnw4leXz55ZccP37cNSzh4lf1GaRFRNyhbdu2+Pr6OicpzXUu36j5SbyPO1bGackT9LpLa33frZU+79oaFLqnT5/OK6+8QpcuXRgxwrmUhsPhICMjg/fff5+UlBR++ctfNmqhACtXrgSc3Xyqe/TRRxk/fjxWq5V9+/bx+eefU15eTtu2bRk+fDi33HJLo9dytS4G7W+//ZZ9+/bVGituw9mKHW11Bu0YK0T6NO+W7IawGQbdbM6W+gkB4DBNsh2Qbof0Kjh74d/SqipOnz7N6dOn2bhxI2+//Tbx8fEMHTqUpKQkjwbwyspK1q9fT1pamitkFxQU1HGkgSN+JGZMryavsUXyDYT2cZjt4zABI/MoluR1HDlyhCNHjtQ4NDQ0lKioKDp06EDHjh0ZM2aM1okXkUZlsVjo0KEDp06dwsg7A0B0dLSHqxJ3a4yVcVriBL3uYLV+FzP0u9O66POurUGhe+zYsWRnZ7N48WLee+89AF544QVM08RisXDXXXcxbNiwRi0UYMmSJZfc365dO5555plGf91rYZomb731Fhs3bqwRtNtaINHmDNcxVmhnabxlvVoSi2EQ6eO8wHBx7mrTNMl3fBfCj1XC6SrTFb7effddevXqxSOPPFLrP8Wm8NVXX/H+++/X2m4aFgiJxAwMg4AwzDYxEKz1qBvKjIynKqgtRl4alBZglBTA+SwMh53CwkIKCwtdYbygoIDZs2d7uGIR8TYxMTGcOnWqxn3xXo21Mk5LmaDX3aq/1/T0dA9WIk2tNX3eVzpBb4PX6b7lllsYO3YsW7ZsISMjA9M0iYqKYvjw4URFRTX0ab1OUVER33zzDeAM1n18oa+v52YabwkMw6CND7Txca41PhnIrzI5UAn7K+C03eTgwYMcOXKEQYMGNXl9Q4YM4ciRIxw6dKjGsADDdOCITsSMSmjymrxWUBvMIGevBjPnFD4HVtbYfXHSm1GjRnmiOhHxct8P2Wq98W6NtTJOc5yg1xOq/53bmt636POuy1WH7vLycn77298yadIkpkyZUuNKnnzHNE2OHj3KunXrXNseC2udrdmNIdzHYJQPjPKHfxSYpFXBqlWrcDgcDBgwoEYXJndr164dP/vZz7Db7Zw8eZKNGze6LqxQkAHtu4Mm/mpcpgPjfJbr7uDBg5k8eTJxcXFN+tmLSOtSfcLW0NBQ17hc8T6NvTKOiEh1V/3Xqp+fH5mZmWqlrcf58+dZu3YtmzZtIjMz07W9m1WBu7F0t0FaFa5luIKCghg+fDgTJ05s0lYIq9VK9+7dMQyDdevWOYdXZCRjZp/AbNsVM3aIJk27VpVlGCe2O9f1rixzbR4zZoxrCRkREXepPn9Ic57MUxrOW1fGEZHmpUFNRAMHDmTPnj31zl7eGtntdtauXcvy5ctdk3D44uxKPsjPOfO4NI7rAw0G+JnsKofd5XC+uJivv/6atWvXMnHiRH7wgx806ezWcXFxPProo7zyyisAGPYKjHNHcFismAnq9nwtjDMHsGQcrrHtgQceoF+/fh6qSERak5CQkDpvi/fwlpVxRKR5a1AUvPXWW/nb3/7GSy+9xPXXX09kZGSd6xV6YpIrT8jLy+Ovf/0rZ8+eBZxLfSX5wUj/1jtBmrtF+hhMCTAZ4Q87ymFjGZQ5HKxevZotW7bw6KOPkpiY2GT1fPjhh7U3Wn3hfBYEtQGLrrpcFUcVlOSBxafWrg8++IBRo0apt42IuF31C7j1zVQtLVtLXhlHRFqOBiWBi8uBpaWlsWHDhnqPW7x4ccOqamH279/vCtwADmB7ufPLAoRaTMIt1Pzycf4bZvG+ZcEaS5VpUuiA/O9/VUHBhdt1zQFaVFTExo0bmzR09+7du9ZMjZbTe+D0HkwMzPbdMBNGO4O41K/KjnFsM8a5Iximo85D+vTpo8AtIk2i+hhunXe8U0tcGael0GRaIt9pcEu3/vP5zsiRI/Hz8+Ps2bPk5OSQk5NDbm4uubm5VFVVucJiXQygncWk44WlwzpeWKvbt5V9f6tMk8wqOHNhmbAzdsiogqrLPM4wDMLCwmjbtq3rq127dgwfPrxJ6r7o7rvv5s477+TcuXOcOnWqxldRURFG1nHMohzM9nHgF4zpHwz+Ic4x33W05rYKDgeUF0P5eYyyIig7j5FzCqM4B3C2MHXp0sX11blzZ6Kjo/HxaaXfLxFpctUnatTfPSIi0lANCt233357Y9fRovn4+NS5LrnD4aCgoMAVxOv6Ki8vJ8sBWRWwu8L5OANo72PS0Qc6Wp3jwoMt3vWfvd002VvhDNcXA3ZdrdY+Pj60bduWiIiIWsG6bdu2tGnTptnMXm2xWIiOjiY6OtoV+k3T5NixY/zv//4v+fn5GKd21XiMCeAbCP7BmH4hcCGMm6FRzm7p3qC0ACM/HcqKoLwIo+w8lBdBeQkGta+CBwcH8/DDD9O7d2/9kSsizYZa7UREpKGaR1rxUhaLhTZt2tCmTRvX8hLVmaZJYWEhJ0+eJDU1ldTUVA4fPkx5eTmZVZBZBbsqYF8FPBTqgTfgRl+VwvqymtsMw6BHjx5069aN2NhYunbtSrt27bC04OW3DMMgPj6e3/72t2zevJnMzMwaF10qKiqgogQqSjDIrP5AHN1HYsb08lzxjcDIPIYlZZ1zjHYdrFZrjQsp7dq1Y8SIEURERDRxpSIiIiIi7qHQ7UEXu0b369ePjIwMMjIyKC8vr3kMEGuFCtP0mi7ndtPZnd4GVFbbbpom6enpxMTEMHDgQGw2m6dKbHRhYWHccMMNNbaZpsn58+ddATw7O5ucnBxOnz7NkSNHsBzdiHlyB/iHYgaEgH+osxU8wPkvvoHg6Z8J04TKUig9j1FWCGXnobTQ2ZpdVohRUQpAt27dXBdRqvdUCAkJadEXVUSk9VDPGxERaSiF7magqqqq3knnTOCbMueXDZNACwQazq8gCwQZEFjt30DDeTvIAgEG+Lj5jwSHaVJmQrEJJY7v/WtCscP5b/V95Zd4vsLCQtasWcPQoUObdCI0TzAMg9DQUEJDQ+nWrZtru2mafPbZZyxf/jGOyjLnWtXnM2s93rT4OEN4YBuI6IzZtgvY/N1bdGU5Rl4a5JzCKMl1hm1HXQMDnAzDYOrUqdx6660K1yIiIiLSKil0NwNWq5Unn3ySw4cPU1RUxPnz5ykqKnJ9nT9/HrvdTiXOWbsLruK5QwyTrjboZoU4m3MJs2u5Wl/oMDlRCcftkFoJuQ7qGJV7eYZhEBISQnBwMMHBwTVud+zYkYSEhAbX2NIZhsHMmTOZNGkSmZmZZGVlkZmZSXZ2tut+Tk7OhWW18jFK8iH7BGBghkZitu2C2aYTBEVce0u4aUJpPkZuGkbOKSjIqDUO2zAM2rRpQ2RkJO3bt6d9+/au25GRkU26ZrqIiIiISHOj0N1MJCYm1tuya5omZWVlNUJ4Xf9W319cXOzsvmzC/grnF0CwAd1sJt2s0NMXQi8zQVuFaXK44ruQnV3PLOwBAQH1huiQkJAa94ODgwkMDFTL52UEBATQtWtXunbtWmuf3W4nJyeHrKwsjh49yu7duzl9+jRG4TmMwnNw4ltMWwBmmxho0wmzTUdnd/QrUVmGkXcG8s5g5KVhVJTU2H2x+39CQgKRkZG0bdvWq4YCiIiIiIg0JoXuFsAwDAICAggICKB9+/ZX9BiHw0FxcTEZGRkcPnyYw4cPc+zYMYoqK9l3YXK2L0vh9iCTRN+6g3dWlcnb5yGnWtA2DIMuXbrQs2dPEhMT6dKlCyEhIc1mBvHWwmq1EhUVRVRUFH379uXmm28mJyeHPXv2sHfvXpKTk6moKMXIPAaZx5wTs0X1wOwyyDlDel0qSjBO7caSfhiqrZFttVrp0aMH/fv3Z8CAAURGRjbRuxQRERERafmUlLyUxWJxtTAnJCRw4403UllZyfHjxzl8+DA7d+4kLS2Nt4tgSoDJKH+wVOuKnFxh8n4xlJkQHh7O0KFD6dmzJz169FB34Waqbdu2TJw4kYkTJ1JZWcmxY8c4cOAABw4c4OTJk1gykuHcERxdB2N27l+j67lx9iDG8W2u8dmdOnWiT58+9OnTh4SEBHx9fT31tkRERKQF0uSDIt9R6G5FbDabqxv7jBkzePvtt1m/fj1fljq7j98SZBJgwMoS2HRhtrP4+Hjmzp1LaKiXrVnm5Ww2Gz179qRnz57ceuutHD16lA8//JDk5GQsqd/iqCzFjBsOhoFxaheW1B0AxMXFMWvWLHr37u3hdyAiIiItmda2F/mOQncrZbVaue+++4iNjeW9997jSGUlfy9w/kCcv3COnDhxIrfffrvG63qB+Ph4fvWrX/HVV1/x7rvvYjmzH0dIe0ybnytw33TTTdx00026Mi0iIiLXzM/Pz9MliDQbmsmqFTMMg/Hjx/Ob3/yGDh06UGo6A7e/vz+PPfYY99xzjwK3FzEMg8mTJ3PTTTc57x/fiuXoZsB5geUHP/iBAreIiIg0ittvvx3DMLj55ps9XYqIxyl0Cx07dmTSpEmu+wMHDmTAgAEerEjcafr06QQFBWFUlGCUFmC1Wpk1a5anyxIREREv0rt3b/7+979z4403eroUEY9T6BbAGbzrui3ex2az0adPH9d9TY4nIiIi7qC/L0ScFLoFgJCQkDpvi3fq3LlznbdFRERERKRxKXQLAMHB363dHBAQ4MFKpClERUXVeVtEROpmt9s9XYKIiLRQXjt7+RdffMEnn3xCfn4+Xbt25cEHHyQ+Pt7TZTVb1bv/WCy6FuPtqqqq6rwtrY/OlQ3ncDg8XYK4WVpamut2Tk6OBysREZGWzCvT1aZNm1i0aBGzZ89m/vz5dO3aleeff56CggJPl9ZsnTx50nX72LFjHqxE3KmoqIiVK1fyxhtvuLYtXryYzz77TL8frZDOlVev+rqzavn0fsuXL3fdPnXqFIcPH/ZgNSIi0lJ5ZUv3p59+yqRJk5gwYQIADz30EDt37mTNmjV1LltQWVlJZWWl675hGK4u1q1hCaWVK1fy3nvvue5/8cUXnD59mv/+7//Gx8fHg5VJYzl37hz/7//9vzpbte12Ox9++CEffvghAM8++yydOnVq6hLFA3SuvHrVL0qeO3eOyspKfH19PViRuEt2djY7d+6ssW316tX06tXLQxWJiEhL5XWh2263c/z48Rp/MFosFvr160dKSkqdj1m2bBlLly513e/WrRvz58+nffv27i7X4woLC1m8eHGt7QcOHODs2bMMGzbMA1VJY3vppZeuuBv5G2+8wSuvvOLmisTTdK5smM8++6zG/ZycHJKSkjxUjbjTjh07am3bs2cPUVFRGoYlIvI9SUlJ7Ny5k4SEBE+X0ix5XeguLCzE4XAQHh5eY3t4eDhnz56t8zGzZs1i5syZrvsXW2yysrK8vvugaZrMmjWL7du306FDBwDS09NJTEykbdu2pKene7hCaQwTJ04kNTUVm81GbGxsncekpaVRUFDA9OnTvfpzt1qtrSok1kfnyoYZOHAgGRkZVFZWEhISQkREhFf/vrRmcXFxjB07lrKyMte2hIQEzp0758Gqmo7OlSJyNe666y7atm3r6j0nNXld6G4Im82GzWarc1/18XveasaMGcyYMaPOfa3h/bcGvXv35s9//vMVH6/PXerS2s+VADExMTz44IM1trWW997ahIeHc99999Xars/buyxbtoxt27Zx5swZfH196dGjB/feey8xMTGuYyoqKli0aBGbNm2isrKSAQMGMGfOnFoXLUVas4iICO68805Pl9FseV3/qNDQUCwWC/n5+TW25+fn6+QoInKBzpUiInDw4EGmTp3K888/75r75LnnnqvRw+HNN99kx44dPP744zzzzDPk5eXxl7/8xYNVi0hL43Wh22q1EhcXx/79+13bHA4H+/fvp0ePHh6sTESk+dC5UkQEnn76acaPH0/nzp2JjY1l7ty5ZGdnc/z4cQBKSkr4+uuvue++++jbty9xcXE8+uijJCcn1zv/hYjI93ll9/KZM2fyyiuvEBcXR3x8PJ9//jnl5eWMHz/e06WJiDQbOleKiNRUUlICQHBwMADHjx+nqqqKfv36uY7p2LEj7dq1IyUlpc6LlFrpQUS+zytD98iRIyksLGTJkiXk5+cTGxvLU089pS6TIiLV6FwpIvIdh8PBG2+8QWJiIl26dAGcQ26sVitBQUE1jg0LC6s1POcirfQgIt/nlaEb4IYbbuCGG264puewWr322yPSaun3uiadK0WkLq3x93rhwoWcPn2aZ5999pqep76VHvLy8lrNSg8irYXVaqVNmzaXP64JammxruQbKCLS2ulcKSIt3cKFC9m5cyfPPPMMbdu2dW0PDw/HbrdTXFxco7W7oKCg3l5B9a30oHOlSOvldROpScOVlpby61//mtLSUk+XIk1An7dIw+h3p3XR5+3dTNNk4cKFbNu2jd/+9rdERkbW2B8XF4ePjw/79u1zbTt79izZ2dmadPIy9LvTuujzvjS1dIuLaZqcOHFCa5C2Evq8RRpGvzutiz5v77Zw4UI2bNjAk08+SUBAgGucdmBgIL6+vgQGBjJx4kQWLVpEcHAwgYGB/Otf/6JHjx4K3Zeh353WRZ/3pSl0i4iIiEirtHLlSgDmzZtXY/ujjz7qWsnhvvvuwzAM/vKXv2C32xkwYABz5sxp4kpFpCVT6BYRERGRVmnJkiWXPcbX15c5c+YoaItIg2lMt7jYbDZmz55d5+Qf4n30eYs0jH53Whd93iINo9+d1kWf96UZpjrei4iIiIiIiLiFWrpFRERERERE3EShW0RERERERMRNFLpFRERERERE3EShW0RERERERMRNFLpFRERERERE3ETrdAsAX3zxBZ988gn5+fl07dqVBx98kPj4eE+XJW5w8OBBPv74Y06cOEFeXh5PPPEEw4YN83RZIi2CzpWth86VItdG58vWQefKK6OWbmHTpk0sWrSI2bNnM3/+fLp27crzzz9PQUGBp0sTNygvLyc2NpYf//jHni5FpEXRubJ10blSpOF0vmw9dK68MgrdwqeffsqkSZOYMGECnTp14qGHHsLX15c1a9Z4ujRxg0GDBnHnnXfqKqTIVdK5snXRuVKk4XS+bD10rrwyCt2tnN1u5/jx4/Tr18+1zWKx0K9fP1JSUjxYmYhI86FzpYjIldH5UqQ2he5WrrCwEIfDQXh4eI3t4eHh5Ofne6QmEZHmRudKEZEro/OlSG0K3SIiIiIiIiJuotDdyoWGhmKxWGpdeczPz691hVJEpLXSuVJE5MrofClSm0J3K2e1WomLi2P//v2ubQ6Hg/3799OjRw8PViYi0nzoXCkicmV0vhSpTet0CzNnzuSVV14hLi6O+Ph4Pv/8c8rLyxk/frynSxM3KCsrIyMjw3U/MzOT1NRUgoODadeunQcrE2nedK5sXXSuFGk4nS9bD50rr4xhmqbp6SLE87744gs+/vhj8vPziY2N5YEHHiAhIcHTZYkbHDhwgGeeeabW9nHjxjF37lwPVCTScuhc2XroXClybXS+bB10rrwyCt0iIiIiIiIibqIx3SIiIiIiIiJuotAtIiIiIiIi4iYK3SIiIiIiIiJuotAtIiIiIiIi4iYK3SIiIiIiIiJuotAtIiIiIiIi4iYK3SIiIiIiIiJuotAtIiIiIiIi4iYK3dJqLVmyhNtvv73Gtrlz5/LKK694qCIRkeZJ50sRkcvTuVLqo9AtLVJubi5LliwhNTXVra+TlpbGkiVLyMzMdOvrXIvk5GSWLFlCcXGxp0sRkWZI58vv6HwpIvXRufI7Olc2PoVuaZHy8vJYunRpo58YX3zxRR555BHX/bS0NJYuXUpWVlajvk5jSk5OZunSpToxikiddL78js6XIlIfnSu/o3Nl47N6ugCRq1FVVYVpmm57fpvN5rbnFhFpSjpfiohcns6V0hQM050/ZeKVlixZwtKlS3nxxRdZunQpO3bswGq1cv3113PHHXeQk5PDv/71Lw4cOICvry833XQTN954Y43nKCgo4J133mHnzp2UlJQQExPDjBkzGD9+vOuYzMxMfvrTn3Lvvffi4+PDF198QWZmJj/60Y948803a9X16KOPMn78eA4dOsSKFSs4cuQIBQUFhIWFMXz4cO6++258fX1rvY8lS5a4ts2dO5fevXszd+5c1q5dy6uvvlrrdX73u9+xZs0adu3axWuvvYbVWvPa1XPPPUdWVhYLFiy45PfxyJEjLF26lJSUFOx2O1FRUUycOJHp06cDcPLkST799FMOHTpEXl4egYGBDBo0iB/+8IeEhITUeA/f9/LLLxMZGXnJ1xcR99P5UudLEbk8nSt1rvR2aumWBnvxxRfp2LEj99xzDzt37uTDDz8kODiY1atX07dvX+655x7Wr1/PW2+9Rffu3enduzcAFRUVzJs3j4yMDG644QYiIyPZsmULr776KiUlJa4Tw0Vr166lsrKSSZMmYbPZGDZsGKWlpSxZsoTJkyfTs2dPABITEwHYvHkz5eXlTJkyhZCQEI4ePcoXX3xBbm4ujz/++BW/v169ejFt2jRWrFjBrFmz6NixIwAdO3Zk7NixrFu3jj179jB48GDXY/Lz89m/fz+zZ8++5HPv3buX//mf/6FNmzZMmzaN8PBwzpw5w44dO1zvf+/evWRmZjJ+/HjCw8NJS0tj9erVpKWl8fzzz2MYBsOHDyc9PZ2NGzdy3333uU6YoaGhV/w+RcT9dL7U+VJELk/nSp0rvZVCtzRYfHw8Dz/8MACTJ09m7ty5vPXWW9x1113cfPPNAIwaNYpHHnmENWvWuE6Mq1ev5syZM/zsZz9jzJgxAFx//fXMmzeP9957jwkTJhAQEOB6nZycHF566aUav+yDBg1iyZIl9OjRg7Fjx9ao6957761x1XHy5Ml06NCBd999l+zsbNq1a3dF7y8qKopevXqxYsUK+vfvT58+fVz7QkNDadu2LevXr69xYtywYQOmadaqqTqHw8E///lP2rRpwx//+EeCgoJc+6p3PJk6dWqtq7gJCQksWLCAw4cP06tXL7p27Uq3bt3YuHEjQ4cO1RVIkWZK50udL0Xk8nSu1LnSW2kiNWmwiRMnum5bLBbi4uIwTbPG9qCgIGJiYmrM0Lhr1y7Cw8MZNWqUa5vVamXatGmUlZVx8ODBGq8zfPjwq7q6Vv2kWFZWRmFhIT169MA0TU6cOHFV77E+FouF0aNHs337dkpLS13bN2zYQI8ePS55gjpx4gSZmZlMnz69xkkRwDCMOt9HRUUFhYWFJCQkuJ5DRFoOnS91vhSRy9O5UudKb6WWbmmw71/VCwwMxGaz1TqJBQYGcv78edf9rKwsoqOjsVhqXvO52MXm+7M5Xu0VtuzsbBYvXsz27dtrzbpYUlJyVc91KePGjWP58uVs27aNcePGcfbsWY4fP85DDz10ycedO3cOgM6dO1/yuKKiIt5//302bdpEQUFBjX2N+T5ExP10vtT5UkQuT+dKnSu9lUK3NNj3T2z1bbtW1a/KXY7D4eD3v/89RUVF/OAHP6Bjx474+fmRm5vLq6++2qizU3bq1Im4uDjWr1/PuHHjWLduHVarlREjRjTK8//tb38jOTmZm266idjYWPz9/XE4HLzwwgs4HI5GeQ0RaRo6X+p8KSKXp3OlzpXeSqFbmlz79u05efIkDoejxon07Nmzrv2XU72rTHWnTp0iPT2duXPnMm7cONf2vXv3XmPVdRs7diyLFi0iLy+PjRs3kpSURHBw8CUfExUVBcDp06fp379/nccUFRWxb98+br/99hoTZ6Snp9c6tr7vhYi0fDpf6nwpIpenc6XOlc2dxnRLkxs0aBD5+fls2rTJta2qqooVK1bg7+/vmhTjUvz8/ABqdfG5eKKtftXRNE0+//zzBtXq7+9f5+tcNHr0aAzD4N///jfnzp1zTd5xKd26dSMyMpLPP/+81vNerLuu9wHw2Wef1Xq+i98LdQsS8T46X+p8KSKXp3OlzpXNnVq6pclNnjyZVatW8eqrr3L8+HHXsg7Jycncf//9NWaXrE9UVBRBQUGsWrWKgIAA/Pz8SEhIICYmhqioKN566y1yc3MJDAxk69atFBUVNajW2NhYLBYLy5cvp6SkBJvNRt++fQkLCwOcM00OGDCALVu2EBQURFJS0mWf02KxMGfOHObPn8+TTz7J+PHjadOmDWfOnCEtLY2nn36awMBAevXqxccff0xVVRURERHs2bOnxqQhF8XFxQHw7rvvMmrUKHx8fBg8eLDrpC4iLZfOlzpfisjl6Vypc2Vzp5ZuaXK+vr7MmzeP0aNH880337Bo0SKKiop49NFHa62jWB+r1crcuXOxWCy8/vrrLFiwgIMHD2K1Wvn1r39NbGwsH330Ee+//z4dOnTgpz/9aYNqDQ8P56GHHqKwsJB//OMfLFiwgLS0tBrHXOxqNGLECGw22xU978CBA/nd735HdHQ0n376KW+++Sb79++vsUTEz3/+cwYMGMCXX37JO++8g4+PD0899VSt54qPj+eOO+7g5MmTvPLKKyxYsIDCwsIGvV8RaV50vtT5UkQuT+dKnSubO8NszNH/Iq3Qt99+y5/+9CeeeeYZevXq5elyRESaLZ0vRUQuT+dK76OWbpFr9NVXXxEVFUXPnj09XYqISLOm86WIyOXpXOl9NKZbpIE2btzIyZMn2blzJ/fff79mehQRqYfOlyIil6dzpfdS6BZpoAULFuDv78/EiROZOnWqp8sREWm2dL4UEbk8nSu9l8Z0i4iIiIiIiLiJxnSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibKHSLiIiIiIiIuIlCt4iIiIiIiIibWD1dQHOWl5eH3W73dBki0oisVitt2rTxdBkiIiIi0koodF+C3W6nsrLS02WIiIiIiIhIC6Xu5SIiIiIiIiJuotAtIiIiIiIi4ibNunv53LlzycrKqrV9ypQpzJkzp87HfPbZZ6xcuZLs7GxCQ0MZPnw4d999N76+vu4uV0RERERERKSGZh26//CHP+BwOFz3T506xXPPPceIESPqPH7Dhg288847/OQnP6FHjx6kp6fz6quvYhgG9913X1OVLSIiIiIiIgI089AdGhpa4/5HH31EVFQUvXv3rvP45ORkEhMTGT16NACRkZGMGjWKI0eOXPJ1Kisra0yYZhgGAQEBrtutxZkzZygsLKRXr16eLkVERERERMQrNOvQXZ3dbmf9+vXMmDGj3iCcmJjI+vXrOXr0KPHx8Zw7d45du3YxZsyYSz73smXLWLp0qet+t27dmD9/Pu3bt2/U99DcPfbYYxQVFbFw4UJiYmI8XY6IiIiIiEiL12JC97Zt2yguLmb8+PH1HjN69GgKCwv5zW9+A0BVVRXXX389t9xyyyWfe9asWcycOdN1/2Koz8rKalXrdBcVFQGwe/fuVtXCL62L1WptdRfURERERMRzWkzoXrNmDQMHDiQiIqLeYw4cOMCyZcuYM2cOCQkJZGRk8O9//5ulS5cye/bseh9ns9mw2Wx17jNN85prb2kcDkerfN+tzcXP2cfHx9OliIiIiIh4rRaxZFhWVhZ79+5l0qRJlzxu8eLFjB07lkmTJtGlSxeGDRvGXXfdxUcffVRjQjaR1s40TV544QV+85vftKreHCIiIiIiTa1FhO41a9YQFhZGUlLSJY8rLy+v1S3aYmkRb1GkSdntdk6cOMG5c+fqXJZPREREREQaR7PvXu5wOFi7di3jxo2r1Q325ZdfJiIigrvvvhuAwYMH89lnn9GtWzdX9/LFixczePBghW+RaqoPH9BQAhERERER92n2oXvfvn1kZ2czYcKEWvuys7NrtGzfeuutGIbBe++9R25uLqGhoQwePJi77rqrKUtu8TSJWuuiz1tERERExH2afegeMGAAS5YsqXPfvHnzatz38fHhtttu47bbbmuCyryXWj5bF33eIiIiIiLuoz7XIiIiIiIiIm6i0C3Syql7uYiIiIiI+yh0i4iIiIiIiLiJQrdIK6TWbRERERGRpqHQLbUokHk/TZ4mIiIiItI0FLqlFgUy76d1ukVEREREmoZCt9Silu7WRZ+3iIiIiIj7KHRLLWr5bF30eYuIiIiIuI9Ct0grVD1oq6VbRERERMR9FLqlFoUw76cx3SIiIiIiTUOhW2pRCBMREREREWkcCt0irZC6l4uIiIiINA2FbpFWSN3LRURERESahkK3SCuklm4RERERkaah0C21KIR5P7V0i4iIiIg0DYVuqUUhzPs5HA5PlyAiIiIi0ioodIu0QlVVVa7bdrvdg5WIiIiIiHg3hW6pRd3LvV9lZaXrdkVFhQcrERERERHxbgrdAtTsbqzu5d6vrKzMdbu8vNyDlYiIiIiIeDeFbgE0xre1KS0trfO2iIiIiIg0LoVuAWqO8VX3cu9XXFxc520REREREWlcCt0C1Azd6l7u/YqKily3FbpFRERERNzH6ukCLmXu3LlkZWXV2j5lyhTmzJlT52OKi4t599132bZtG0VFRbRv35777ruPpKQkd5fbolXvXq6Wbu9XPXQXFhZ6sBIREREREe/WrEP3H/7whxph8NSpUzz33HOMGDGizuPtdjvPPfccoaGhPP7440RERJCdnU1gYGBTldxiVW/p1vhu71dQUOC6rdAtIiIiIuI+zTp0h4aG1rj/0UcfERUVRe/eves8/uuvv6aoqIjf//73WK3OtxYZGen2Or1B9WWjqi8nJd4pPz+/ztsiIiIiItK4mnXors5ut7N+/XpmzJhRb/fnHTt2kJCQwMKFC9m+fTuhoaGMGjWKm2++GYul/uHrlZWVNYKmYRgEBAS4brcG1UN3eXl5q3nfrVVubm6N2/q8RURERETco8WE7m3btlFcXMz48ePrPebcuXNkZWUxevRo/r//7/8jIyOD//u//6Oqqorbbrut3sctW7aMpUuXuu5369aN+fPn0759+8Z8C81aXl6e67bNZiM6OtqD1Yg7mabJuXPnXPdzcnJo27Ytvr6+HqxKRERERMQ7tZjQvWbNGgYOHEhERES9x5imSWhoKI888ggWi4W4uDhyc3P5+OOPLxm6Z82axcyZM133L7b6ZWVlYbfbG+9NNGOnT5923T537hzp6ekerEbcKTs7m5KSEkzDAMMHh8POjh07iI2N9XRpTcJqtbaqC2oiIiIi4lktInRnZWWxd+9ennjiiUseFx4ejtVqrdGVvGPHjuTn52O3213jvL/PZrNhs9nq3Ndals+qPpt1UVFRq3nfrdGRI0ecN4LbgdUP8tI4cuQIXbt29WxhIiIiIiJeqEWs071mzRrCwsIuu+xXYmIiGRkZNWbfTk9Pp02bNvUGbnGqPoO1ZrP2bvv27QPADOuAGR5dY5uIiIiIiDSuZh+6HQ4Ha9euZdy4cfj4+NTY9/LLL/POO++47k+ZMoWioiLeeOMNzp49y86dO1m2bBlTp05t6rJbnOrrode1Nrp4h/Lycvbs2QOA2bYrZltn6/bhw4c5f/68J0sTEREREfFKzT5079u3j+zsbCZMmFBrX3Z2do0JwNq1a8fTTz/NsWPH+NWvfsW///1vpk2bxs0339yEFbdM1SfWyszM1FrdXmrr1q2UlpZi+odAaCQEhmMGt3WtDiAiIiIiIo3LMDV4t15ZWVmtYs1q0zT55S9/SUFBgWvb//zP/2iyKS9TUVHBb37zG7Kzs3HEDcPs1B8AIyMFS8o6QkJCeOGFFwgMDPRwpe5ls9n0sy0iIiIiTabZt3SL+6Wnp1NQUIAViL7Qg//w4cMerUka36effkp2djambxBmdC/XdjMyHjMwnPPnz/PBBx94sEIREREREe+j0C3s2LEDgFgr9LqwVPP27ds9WJE0tt27d/PZZ58BYHYfDj7VZuu3WHB0HwHA2rVr2bhxoydKFBERERHxSgrdrZzD4WDDhg0ADPCD/hdC94EDB8jJyfFgZdJY9u3bxz/+8RoAjpjemO3jah/UpiOOLoMAePPNN9m2bVtTligiIiIi4rUUulu5nTt3kp2dTYABfXyhnY9BN6tznPeqVas8XZ5cA9M02bBhA3//+9+prKzAjOiMGXdd/cd3TcIR2Z2qqir++c9/smrVKq3XLiIiIiJyjRS6W7GKigo+/PBDAIb7ga9hADDG37l/7dq1ZGRkeKo8uQYlJSX885//5N///jcOhwNH++44el8Plkv8yhsGZuI4HNG9ME2T9957j5deeknrtouIiIiIXAOF7lbKNE3ef/99zp07R4gBo/y/25dgg+5WqKysZOHCha1iBndv4XA42LRpE7/97W+dXcQNA0fXwZg9x186cF9kWDDjR+Lofh0YFvbs2cNvf/tb1q5dS1VVldvrFxERERHxNloy7BK8ecmwTz/9lGXLlgHww2BI9DVq7M+rMnm5EMpNGDBgAI8++ihWq9UTpcoVSk5OZsmSJaSmpgJg+ofg6DnBuR53QxTlYDm8FqMkD4COHTty22230bdvXwzDuMyDmy8tGSYiIiIiTUmh+xK8MXSXl5fz7rvvsn79egCmB8JI/7oD1PFKk0XnwQ4kJCTw8MMPExER0YTVyuWYpsnevXv5/PPPOXr0qHObjw2z80DMjn3A5xovlDgcGOkHMU7uwrCXA9C1a1emTZvG4MGDsVxJ63kzo9AtIiIiIk1JofsSvC10p6amsnDhQs6ePYsBTA6AcQGXbrFMrjBZXAwVJgQHB3PvvfcyZMiQFt3S6Q0qKyvZtm0bK1euJC0tzbnRsODo0AOzaxL4BjbyC5ZhnN6DcfYQhsMOQFRUFFOmTGHEiBH4+fk17uu5kUK3iIiIiDQlhe5L8JbQXVxczIcffsg333yDaZoEG3BbMHS3XVlwzqkyWVwEZy8M6e3Tpw933303HTp0cGPVUpeCggLWrl3LmjVrOH/+PHChZTu6J2bHfuDXyGH7+yrLMM4cwDh7AMNeAUBgYCDjxo1j4sSJLaInhEK3iIiIiDQlhe5LaOmh+/z583z11Vd89dVXlJSUADDAF6YFQrDl6lqq7abJN6WwvszZ3dzHx4cRI0Zwww03EB0d7YbqpbqTJ0+yevVqtm3bht3ubGk2fYMwY3pjRvcEWxO3NNsrMDJSnOG7zBn+LRYLgwcP5vrrr6d79+5NW89VUOgWERERkaak0H0JLTV0Z2VlsWrVKtavW0fFhfojfWBmIMRdYet2fXKqTD4rgZQL3xbDMBg0aBBTp04lPj7+WkuXahwOB7t372bVqlWkpKS4tpshkZgd+2C263ZlM5K7k+mAnNNYzuzHKEh3be7WrRvXX389gwcPbnYT8Cl0i4iIiEhTUui+hJYUuk3TJCUlhVWrVrF7924ufqwxPjAuAHrZwNKI47BPVZqsL4ND1b49cXFxXH/99SQlJTW7oNWSlJeXs3HjRlatWkVmZqZzo2HgaBfnnBytobORu1tRDsaZA1gyjzrDOBAREcHkyZMZM2YMgYFu7vp+hRS6RURERKQpKXRfQksI3fn5+Wzbto1NmzZx+vRp1/YEG4z2hzgrbp30LLPKZEMp7KmAi6s4t2nThhEjRjBixAhiYmLc9treJj8/n6+//pq1a9dSXFwMgGn1c47XjukNfkEervAKVZRgpB/GOHsQo7IMAH9/f8aOHcukSZNo166dR8tT6BYRERGRpqTQfQnNNXSXlJSwe/duNm/ezKFDh1yt2lZgoB+M9IdIn6adXbzIYbKtHLaWQXG1n6jOnTszYsQIhg4d2iIm2fKE06dPs3LlSrZu3UpVlfPShekfgtmxL2aHHuBj83CFDeSwY5w7inFmP0ZJPvDduO8pU6YQFxfnkbIUukVERESkKSl0X0JzCt3nz59n165d7Ny5k4MHD7rCGUBnKwz0hX6+EHiVE6Q1tkrTJLkSdpc7x307qu2Li4sjKSmJpKQkoqKiPFZjc+BwONi/fz8rV67k0KFDru1maBSOTn2hbVcwWt4a2HUyTchLw5K2DyP/rGtzfHw8U6ZMYdCgQU263rdCt4iIiIg0JYXuS/B06M7Ly2Pnzp3s2LGDlJQUqn9U7S3Q3w/6+0LbJm7VvlIlDpP9Fc6u56fsUP0HrWPHjgwePJjBgwfTsWPHVrPud0VFBZs2bWLVqlVkZGRc2GrgaB/rXPKruY7XbixFORhn9mPJPOYa992uXTvXuG9/f3+3l6DQLSIiIiJNSaH7EjwRurOzs9mxYwc7duzg2LFjNfbF+EBvX+dXU3cfv1bnHSaHKuBgBRy312wBj4qKYsiQIQwePJguXbp4ZQAvKipizZo1fPXVV7XX147pDf4hHq6wiZWXOMd8px/CsJcDzvW+J0yYwKRJkwgLC3PbSyt0i4iIiEhTUui+hKYK3SUlJXz77bds2rSJo0ePurYbOLuO9/GF3jZo08KCdn1KHSaHK+FABRytdK77fVFUVBQjR45kxIgRtG3b1mM1NpaCggK++OILvvnmG8rLneHS9Av+bry21dfDFXpYlR3j3BGMM/swSgsBsFqtjB49mhkzZrhlHgCFbhERERFpSgrdl+DO0G232zl48CCbNm1i165d2O3O6GkAsReDti+EeniMtruVmybJFc4AnlIJF7/bhmGQmJjIyJEjSUpKIiAgwKN1Xq3CwkJWrFjBmrVrqayoAMAMisDs3B+zXZzn19dubkwH5JzCcnoPxvkswBm+x4wZw/Tp0xs1fCt0i4iIiEhTUui+hMYO3Q6Hg2PHjrFlyxa2b99OUVGRa1+kDwzyhQF+3h+061NumhyogF3lcKJa87fNZmPAgAEMHz6cfv36YbM139m8KyoqWLlyJZ9//vl3Ldsh7XF0TYI2ncALu843KtOEgnQsJ3dhFKQDzvA9depUpk2b1igXXxS6RURERKQpKXRfQmOF7qysLDZu3MimTZvIyclxbQ8ynDOOD/Jzjtf2xrHMDZVXZbK7AvaUQ3a1AeCBgYEMHTqU0aNH061bt2b1Pdu+fTtLlixxfcYK29co/yyWkzsxCpwTzoWFhXHrrbcycuTIa/rcFbpFREREpCkpdF/CtYTuiooKvv32WzZu3EhycrJrux/ObuP9/SDOCj4KY5dkmibpVc4Z0PeWw/lqP63R0dGMHj2akSNHEhoa6rEai4qK+M9//sO2bdsAMH2DMOOGYrbvrrB9rUzT2e38+FaMMueY7wEDBnDfffc1eLI1hW4RERERaUrNOnTPnTuXrKysWtunTJnCnDlzLvnYjRs3smDBAoYMGcKTTz7ZoNdvSOg2TdPV4pmbmws4x2l3t0KSH/TyBZuCWIM4TJMTdthZ7pwF/eIn4+fnx8yZM7n++uubvOv5iRMnePnll8nPzwfDwNFpAGaXgeBjbdI6vJ6jyrnUWOoOMB0EBwfzX//1X/Tq1euqn0qhW0RERESaUrMO3YWFhTgc3/UtPnXqFM899xy/+93v6NOnT72Py8zM5Le//S1RUVEEBQU1WejOzs7mX//6l6tlO9SAYf4w0BfCvWTm8eaizGGyrwK2lUN6lXNbZGQk999/P4mJiU1Sw8GDB3n55ZcpLy/HDAjDkTjO+9fZ9rTiXCyHv8EozsFqtfLII4+QlJR0VU+h0C0iIiIiTalZT6EcGhpKeHi462vnzp1ERUXRu3fveh/jcDh46aWXuP3224mMvLIAVFlZSUlJieurtLTUtc8wjCv6OnPmDC+88ALJyclYgQn+8N/hMD7AUOB2A3+LwVB/g5+Ewq1BEGw4L7b89a9/ZceOHVf8uTX068yZMyxYsMAZuMNjcCTdrMDdFIIicAy6CbNtV+x2O//7v//LkSNHruqzExERERFpSi2mD6zdbmf9+vXMmDHjkn84L126lNDQUCZOnMihQ4eu6LmXLVvG0qVLXfe7devG/Pnzr7g17Pz58/zxj3+kqKiIKB+4N9h71tRu7iyGwSA/6O1r8kERHKx0BrE//vGP9O3b1y2vWVVVxfz587Hb7ZhtOuLoMwUsPm55LamDxQdH70kYh9ZA9gn+85//8PLLL+Pr28rXPBcRERGRZqnFhO5t27ZRXFzM+PHj6z3m8OHDfP311/zxj3+8queeNWsWM2fOdN2/GOqzsrJc62dfyt69eykqKiLMAnNCIKCVLvnlSX6GwZ3BJm8XQUqlyTfffEPbtm3d8lqHDh0iOTkZ08eGo8dYBW5PMCyYCaMxCzI4ffo0X375JUOGDLmih1qtVnUvFxEREZEm06y7l1e3Zs0aBg4cSERERJ37S0tLeemll3jkkUeueiZrm81GYGCg66v6WsCmaV72Kz8/H4AoHwVuT7IYBl0uXEbKz8+/os+uIV8nTpwAwIzoBH5BHnzHrZzND7NdVwCOHz9+xZ+fiIiIiEhTahEt3VlZWezdu5cnnnii3mPOnTtHVlYW8+fPd227+Af2nXfeyYsvvkiHDh3cUl9xcTEAfsrbHnfxMygpKXHbaxQVFTlv2AIufaC4n28g8N3voIiIiIhIc9MiQveaNWsICwu75CzFMTEx/PnPf66x7b333qOsrIz777+fdu3aua2+i+sFH6iAveUm/ZW+PSLdbrLmwhx47ly3+2LXZKO0ELWbelhpAYDbhhKIiIiIiFyrZh+6HQ4Ha9euZdy4cfj41Bw7+/LLLxMREcHdd9+Nr68vXbp0qbE/KMjZ9ff72xvb8OHDOXjwIJs2bWJJMRyuNJkcABGaTK1JlDlM1pXBpjKwA7GxscyaNcttr9e9e3fnjYJ0sFeAVRN4eYTDgZGbBlT7TEREREREmplmH7r37dtHdnY2EyZMqLUvOzu7WSwBZLFYeOCBBwgKCmL16tXsrTA5UAHD/EzGBECoxnm7Rblpsr0MvimDkgtNzr179+YnP/kJgYGBbnvdTp060aFDBzIyMjAyUjA7uWeWdLk0I+sYhr2c0NDQJlubXURERETkahmmZhaqV1ZWFpWVlVf1mJMnT7J06VIOHjwIgA8wwBfGBEB7tXw3imKHyeYy2FoOpRd+eqOjo5k9ezYDBgxokgsx33zzDYsWLcK0+eMYchvY/Nz+mlJNlR3Ljg8wys5z6623Mn369Ct+qM1m0+zlIiIiItJkFLovoSGh+6L9+/fz2WefkZKSAoAB9LDBCH/obqVZtNC3NBl2ky3lsLvc2Y0cIDIykmnTpjFq1Khaww/cyW6387vf/Y6MjAzMdrE4ek0CfaZNxkjZgCXjMGFhYfzhD3/Az+/KL3oodIuIiIhIU1LovoRrCd0XHT16lBUrVrB7927XtvYWuM4fBviBv4LaJVWZJsmVsLkMTlRbMj02NpZp06aRlJSExeKZle9OnDjBCy+8gMPhwNFtKGbnAR6po7Ux0pOxHFmPYRg8/vjj9O7d+6oer9AtIiIiIk3pmkP31q1br/oxw4cPv5aXbDKNEbovysjI4Ouvv2bDhg2Ul5cDYAP6+sIQP+ii1u8asqtMdpTDrnIouvATarFYGDRoEJMnTyYhIaFZfL+++uor3nnnHQAcieMxo+I9XJGXyz2Nz4GVYJrcdNNN/OAHP7jqp1DoFhEREZGmdM2h+4477rjqxyxevPhaXrLJNGbovqi0tJQNGzbwzTffkJ6e7tre3uIM3wP9IKiVTrxWaZocrIBvyyG1Wqt2aGgoo0ePZvz48c1yaaj33nuPVatWgWFQ1WsytOvq6ZK8U/5ZfPZ/CY4qRo4cyYMPPtigCy8K3SIiIiLSlK45dF+cMOyi4uJi/vznP/PDH/6QuLi4Oh9ztd1BPcUdofsi0zQ5duwY69at49tvv6WiogJwTrzW50Lrd6wVLM2gNdfdMqucs5DvqvhuYjTDMOjXrx9jxoyhf//+WK3Nd6J9h8PBwoUL2bJlCxgWqnpNUvBubPln8dm/Ehx2BgwYwKOPPtrgnwmFbhERERFpSo0+pvv8+fPMmTOH3/zmN/Tt27KXUnJn6K6utLSUrVu3sm7dOk6ePOnaHm5xznw+0M/7Zj4vcpjsrXBOina26rvtERERjBkzhtGjRxMREeG5Aq9SVVUV//znP9m+fTsYBo6EMZgdeni6LO+QnYrPoa/BdNCnTx9+9rOfYbPZGvx0Ct0iIiIi0pSab/NhKxIQEMD48eMZP348qamprFu3jq1bt5JfVsY3F9ahjvExSfKDQX7g10Jbvx2myaFK2F4OxyrBcWG7j8VCv/79GTduHH379vXYxGjXwsfHh4cffhg/Pz82btyIJWUdjtICzNjBYLS899MsmCbG6b1YUr8FICkpiYcffviaAreIiIiISFNT6G5mYmNjiY2N5Y477mDPnj1s2bKF/fv2cbbKwdkSWF0KQ/xMrvOD8BbS+l3mcE6Ktrkc8h3fbY+Li+O6665j2LBhhISEeK7ARuLj48P9999PaGgoK1aswHJ6D2ZRDo6e48Hm7+nyWpaqSozkdViyTwAwbtw47rnnniZdFk5EREREpDEodDdTfn5+DBs2jGHDhnH+/Hm2bt3K119/zblz59hQBpvKoJfN5Dp/59jv5jCT9/dlV5lsKYOd5VBxYVtwcDBjx45l9OjRREVFebQ+d7BYLMyePZvOnTvz73+/QWVeGpadH+HoPQlC1KX5ihTnYTm4GqO0AB8fH+6++27Gjx/v6apERERERBpEobsFCAkJYfLkyUycOJF9+/axatUqDh06xIFKOFAJHXxghL/JQF/w8XD4Nk2To3bnRYEj1YbDx8TEMHnyZK677jr8/Pw8V2ATGT58ODExMbz66qtkZmbis/sTHPGjMKMTPV1a85Z1HJ/kdeCwEx4ezk9+8hPi47UMm4iIiIi0XNc8kdr8+fNr3K+qqmLPnj0kJCTU2WXYMAyefPLJa3nJJtNUE6k1RFpaGl9//TWbN22i4kKN7SwwNRB62jzT8p1uN1lRAscvLPdlGAb9+/dn8uTJ9OrVq1m2xrtbSUkJCxcuZPfu3QA4ontidh8BFnWTrsF0YJzYjiVtLwA9e/bkkUceITQ0tNFfShOpiYiIiEhTuubQPXfu3Kt7QcPg5ZdfvpaXbDLNOXRfVFRUxPr16/niiy8oKioCIM4Ks4KgTRON+S43nWF7RzmYgNVqZdy4cUyePJnIyMgmqaE5czgcfP7553z00UeYpokZ3A5HrwkQEObp0pqH8mIsh9dgFGQAcMMNN3DLLbe4bfy2QreIiIiINKVGXzLMm7SE0H1RSUkJK1asYOXKldjtdvwM+EEg9Pdzb/BOs5u8XwQ5FyZIGzZsGLfeeivt2rVz6+u2RPv27eP//u//KCoqwvSxYXYfgRmVAK2wBwAApgnZqViObMCwl+Pn58cDDzzA0KFD3fqyCt0iIiIi0pTcErpPnTrFrl27yMrKAiAyMpKBAwfSpUuXxn4pt2pJofuirKwsXn/9dY4dOwbAED+YGQjWRg52pmmytRxWlEAVzvW158yZQ2KixixfSm5uLq+//jopKSkAmKEdcCSMhKCWsyZ5oygtwHJ0M0ZeGgBdu3blkUceaZLJ9RS6RURERKQpNWrorqys5J///Cfr1q1zPvmFoHfxJcaMGcN//dd/YbW2jPnbWmLoBue4+k8++YRPP/0U0zTp6AO3B0PbRupuXuow+aQE9l6YkjwpKYn777+foKCgRnl+b1dVVcWqVatYvnw5FRUVYBg4OvTE7DII/AI9XZ57VZZhnN6D5cxBMKuwWq1MmzaNGTNmNNn62wrdIiIiItKUGjV0v/HGG6xYsYIpU6Ywbdo0oqKiMAyDjIwMPv/8c1atWsW0adO4//77G+sl3aqlhu6L9u3bx+uvv05xcTFWYIw/jA0AWwNbvU3TZHcFfFECxeZ3y2NNmTKlVU6Sdq1ycnJ477332LlzJwCmxQezY1/MzgPA6uvh6hpZVSXGmf0Yp/diVDl/p3r37s29997b5EvHKXSLiIiISFNq1ND94x//mEGDBvHTn/60zv0vvfQSu3fvZuHChY31km7V0kM3QHZ2NosWLeLAgQOAc4bze0Og3VW2epeZJkuKIOXCtyM6Opr77ruPhISExi651UlOTmbp0qUcP34cANPmj9k1CTO6JxgWD1d3jUwT49wRjNTtGBUlAHTu3Jlbb72Vvn37euRijUK3iIiIiDSlRu3nbbfb6dGjR737ExMT2bFjR2O+pFxGu3bt+MUvfsGOHTt49913yc7P5/VC+FGISUfrlQWeIofJm+chvQp8bTZuvOkmpkyZ0mKGCTR3iYmJPPXUU+zevZsPPviA9PR0jKObMM8exJEwBsKatiW40RTlYElZh1GUAzh/Fm+55RaGDh2KxdLCLyaIiIiIiFyhRk1NAwYMYPfu3UyZMqXO/bt376Z///6N+ZJyBQzDYMiQISQkJLBgwQJOnjzJovPw32EmAZZLB2/TNHmvyBm4Q0JC+O///m9iY2ObpvBWxDAMBg0aRL9+/Vi3bh3Lly+nqCgfn72f4ogditmpX8uZ5dw0MdIPYzm2BcwqAgICmDlzJpMmTWqycdsiIiIiIs1Fo3YvP3v2LH/729+Iiopi6tSpdOjQAYD09HS+/PJLMjMz+cUvfkFoaGiNxwUHBzdWCY3KG7qXf19paSkvvPACZ8+e5To/mBl06SC3t9xkSbGzhft38+a5PlNxr5KSEt5++222bt0KgCMyATNxbIsI3saxLVjO7AecF+IeeOABQkJCPFzVd9S9XERERESaUqOG7jvuuKNBj1u8eHFjldCovDF0Axw8eJC//OUv+AC/CIPwesZ3O0yTBQXONbhvvvlmbrzxxqYttJUzTZNvvvmG//znPzgcDhxdkzC7Jnm6rEsyzhzAcmwzALNnz2bq1KnNriu5QreIiIiINKVG7V5+6623ahbrFqB3794kJiaSnJzMpjKYXs9KXwcrnYE7MDCQ66+/vmmLFAzDYPz48RiGwaJFi7Cc3ElVWDSER3u6tLoV5WA5vgVwngumTZvm4YJERERERDyvUUP37bff3phPx9y5c8nKyqq1fcqUKcyZM6fW9tWrV7Nu3TpOnz4NQFxcHHfddRfx8fGNWpc3mD59OsnJyewoh4mBJv51XCzZWOb8d9KkSfj7+zdxhXLRuHHjSE1NZd26dViObMAx+Baw+Hi6rJpMB5YjG8A0SUpKUuAWEREREbmgWU8//Yc//AGHw+G6f+rUKZ577jlGjBhR5/EHDx5k1KhRJCYmYrPZWL58Oc899xx//etfiYiIaKqyW4Q+ffoQExPD2bNn2VEOo76XqU/bTU7bwWq1MmHCBM8UKS633XYbu3fvprCwAOPkLsxuQzxdUg3GmQMY57PwDwjg7rvvVo8XEREREZELmnXo/v6Eax999BFRUVH07t27zuMfe+yxGvf/67/+i61bt7Jv3z7GjRtX7+tUVlbWGLttGAYBAQGu297IMAwmT57MokWL2FIGI/xMLNXe6+YLrdzDhw8nPDzcM0WKS1BQED/84Q955ZVXsKTtoaptZwhtJkuJFedhSd0OwB23364LXCIiIiIi1TTr0F2d3W5n/fr1zJgx44qDcHl5OXa7/bKzoy9btoylS5e67nfr1o358+d7/WRLt9xyC++//z55paWkV0HHCz8NdtPkcIXz9m233UZ0dDMdQ9zKzJw5kwMHDrB27VosB7/CkTQLfAM8W5S9AsvB1eCoYvDgwdxxxx1ee6FKRERERKQhWkzo3rZtG8XFxYwfP/6KH/Of//yHiIgI+vXrd8njZs2axcyZM133L4aGrKws7HZ7g+ptKXr16sXOnTtJqfwudJ+yQwUQFhZGSEgI6enpHq1RvnPbbbeRnJxMeno6lkNf4eg3zXPju00Ty+G1GKUFRERE8KMf/YiMjAzP1HIVrFar119QExEREZHmo8WE7jVr1jBw4MAr7rr60UcfsXHjRubNm4evr+8lj7XZbNhstjr3NeKKas3SxdCdWglcaDQ9caGnfc+ePQHv/x60JP7+/sydO5fnnn+esoIMjGObMRNGe6QWI3UHRu4prFYrjz76KMHBwfpZERERERH5nua1gG49srKy2Lt3L5MmTbqi4z/++GM++ugj/t//+3907drVzdW1bD169ACcrduVFwLTsQuN+4mJiZ4qSy4hOjqahx96CMMwsKQfxshIafoick5iOb0bgPvvv59u3bo1fQ0iIiIiIi1Aiwjda9asISwsjKSkpMseu3z5cj744AOeeuopunfv3gTVtWwdO3YkIiKCSuB4JZQ4nLOWA5ftli+eM2DAAG666SYALEc3QnFu07146Xksh78BnMvJ1beagIiIiIiItIDQ7XA4WLt2LePGjcPHp+bY1Zdffpl33nnHdf+jjz5i8eLF/OQnPyEyMpL8/Hzy8/MpKytr6rJbDMMw6NWrFwCn7ZBmBxPo0KGDZqFu5mbOnEnfvn3BUYXl4FdQVXn5B10rRxWWw19jVFUQFxfH7bff7v7XFBERERFpwZr9mO59+/aRnZ1d51rR2dnZNWZKXrVqFXa7nb/+9a81jps9e7bCwSXExsayceNG0qvAduHbqW75zZ/FYmHOnDnMmzeP/Px8jKObMBPrXxqvMRip2zHOZxEYGMgjjzyC1drsTyEiIiIiIh5lmJr5qF5ZWVk11u/2Vvv27ePFF18kygc6W2F7Odx4443cfPPNni5NrkBycjJ/+tOfME0TR+I4zKgE97xQzil8DqwE4Kc//SmDBg1yz+u4mc1m0+zlIiIiItJkmn33cnG/i93ICxxQ6HBua9OmjQcrkquRmJjID37wAwAsRzZCSX7jv0hZEZZk5zjuyZMnt9jALSIiIiLS1BS6xRW6y0zIqqq5TVqGGTNmOMfmO+xYDn0FVY24vrzpwHJ4DYa9nNjYWG677bbGe24RERERES+n0C0EBAQQGBgIQN6Flu62bdt6sCK5WhaLhYceeoiQkBCM4jyM41sb7bmNk7swCs/hHxCgcdwiIiIiIldJoVuA2iFbobvlCQsLY86cOQBY0g9Bzslrf9KCDCyndgPwox/+kMjIyGt/ThERERGRVkShW4Ca3cmDg4Px8/PzYDXSUH379mXKlCkAWFLWQ0Vpw5+sqhLL4bWAyciRIxk+fHij1CgiIiIi0poodAsAoaGhdd6WlueWW26hY8eOGJVl19TN3EjdgVFeRNu2bbn77rsbsUIRERERkdZDoVsA57jui/z9/T1YiVwrm83G/fffj2EYWDKPQv7Zq3+SohwsZw4A8KMf/ajGz4eIiIiIiFw5hW4BnEHtIl9fXw9WIo0hLi6OcePGAWA58S2Y5lU93nLiW8Bk6NCh9O3b1w0VioiIiIi0DgrdAtQM3dVvS8t100034efnh3E+C3JPX/kDCzMx8tKwWCzccsst7itQRERERKQVUOgWoGbQ1pJQ3iEsLIzx48cDYEnbd8WPs6TtBWDEiBGarVxERERE5BopdAtQc0z3xTW7peWbPHkyFosFoyAdSvIu/4DyEoxs51JjF2dBFxERERGRhlPoFgCCgoJctxW6vUdERAT9+/cHwMhIuezxxrkjgEl8fDydOnVyc3UiIiIiIt5PoVuAmqG7+m1p+UaNGgWAkXXishOqGdnHARg5cqTb6xIRERERaQ0UugWo2b1cy0N5l759++Lr64tRXnTpLublxRhFORiGQVJSUtMVKCIiIiLixRS6Bai5TJiWDPMuvr6+dO/eHQCjIKPe4y7u69y5MyEhIU1Sm4iIiIiIt1PoFgB8fHxctzV7ufeJi4tz3ijKrf+g4tyax4qIiIiIyDVT6BYALBZLnbfFO8TExABglOTXe8zFfdHR0U1QkYiIiIhI66B0JQAYhlHnbfEOUVFRzhtlhfUfVOrc16FDhyaoSERERESkdVDoFqBm9/Lqt8U7XAzdRkUJ2CtqH2A6XIE8MjKyKUsTEREREfFqCt0CgM1mc91W93LvExgYSHh4uPNOcR0zmJeex3BU4evrS7t27Zq0NhERERERb6Z0JYCCdmvQuXNnAIzinFr7jKJsADp27KifBRERERGRRqS/rgXQOO7WoEuXLs4bFwJ2DUXOIN61a9cmrEhERERExPs167Wh5s6dS1ZWVq3tU6ZMYc6cOXU+ZvPmzSxevJisrCw6dOjAPffcQ1JSkrtLbfEUur3fxdBtFOdhfm+fcWG5sIut4SIiIiIi0jiadej+wx/+gMPhcN0/deoUzz33HCNGjKjz+OTkZBYsWMDdd99NUlISGzZs4E9/+hPz58//rpVPLksB3DtdXDaMknwwTaj+OV9YLqxjx45NXpeIiIiIiDdr1t3LQ0NDCQ8Pd33t3LmTqKgoevfuXefxn3/+OQMHDuSmm26iU6dO3HnnncTFxfHFF180ceUtT/WgbZrfbwcVb9C+fXsAjKpKqCz7boejCsqLaxwjIiIiIiKNo1m3dFdnt9tZv349M2bMqLclNiUlhZkzZ9bYNmDAAL799ttLPndlZSWVlZWu+4ZhEBAQ4LrdGnx/ne7W8r5bE19fX8LDw8nPz4fyIvB1/oxTXoyBidVqJTw8XJ+9iIiIiEgjajGhe9u2bRQXFzN+/Ph6j8nPzycsLKzGtrCwMGfIuIRly5axdOlS1/1u3boxf/78VtXqV15e7rodERFBdHS0B6sRd+nQoYPz96GsCEIu/HyXFwHOtbxdXdBFRERERKRRtJjQvWbNGgYOHEhERESjP/esWbNqtJBfbOnLysrCbrc3+us1R9XfZ25uLunp6R6sRtzl4lrdRlmhazI1o7QQgDZt2rSKz91qtbaqC2oiIiIi4lktInRnZWWxd+9ennjiiUseFx4eTkFBQY1tBQUFrqBRH5vNhs1mq3Nfaxnf/P0uxa3lfbc2kZGRzhsXJk4DoNT5OxMVFaXPXURERESkkTXridQuWrNmDWFhYZdd+qtHjx7s27evxra9e/eSkJDgzvK8gsXy3Y+Cgpf36tSpE/DdEmEARpHztmYuFxERERFpfM0+dDscDtauXcu4cePw8fGpse/ll1/mnXfecd2fPn06e/bs4ZNPPuHMmTMsWbKEY8eOccMNNzR12SLNkmsd7uJ8cDicS4cV59TcJyIiIiIijabZdy/ft28f2dnZTJgwoda+7OzsGt2iExMTeeyxx3jvvfd49913iY6O5le/+pXW6L5Kmr3ae7Vv356AgABKS0uhJA9s/hiVZVgsFlcruIiIiIiINJ5mH7oHDBjAkiVL6tw3b968WttGjBjBiBEj3FyVd1P3cu9lGAZdunQhOTkZoygH0+YPQExMDL6+vh6uTkRERETE+zT77uUi0ri+62Kei3Gha7lauUVERERE3KPZt3RL01P3cu92cS1uoyQP0+ps6dYkaiIiIiIi7qHQLbWoe7l369Chg/NGaSGGraLmNhERERERaVQK3VKLWrq9m2ut7rIisJcDzgnWRERERESk8WlMt9Silm7vFhYWho+PDwYmht3Z0t22bVsPVyUiIiIi4p0UukVaGYvFQlhYmOu+n58fgYGBHqxIRERERMR7KXRLLepe7v3Cw8PrvC0iIiIiIo1LoVtqUfdy7xcaGuq6HRIS4sFKRERERES8m0K3SCtUvTt5UFCQBysREREREfFuCt1Si7qXez8/P786b4uIiIiISONS6JZa1L3c+4gZNUsAAA/ISURBVNlstjpvi4iIiIhI41LoFmmFfHx8XLctFp0GRERERETcRX9ti7RC1YcQKHSLiIiIiLiP/toWaYWqh26N4RcRERERcR+FbqlFIcz7VW/dVku3iIiIiIj76K9tqUUTqXk/jekWEREREWka+mtbpBWqHrqtVqsHKxERERER8W4K3VKLupd7Py0ZJiIiIiLSNBS6pZZ27dp5ugRxM4VuEREREZGmoX6l4vLkk0+Sk5ND586dPV2KuJlCt4iIiIhI01DoFpfExERPlyBNpPo4bo3pFhERERFxH3UvF2mFNHu5iIiIiEjT0F/bIq2Q1ukWEREREWkazb5faW5uLm+//Ta7d++mvLycDh068Oijj9K9e/d6H7N+/Xo+/vhj0tPTCQwMZODAgfzwhz8kJCSkCSsXab6qz1Cv2epFRERERNynWYfuoqIifvOb39CnTx+eeuopQkNDSU9PJygoqN7HHD58mJdffpn77ruPIUOGkJuby+uvv85rr73GE0880YTVizRfWqdbRERERKRpNOu/tpcvX07btm159NFHXdsiIyMv+ZiUlBQiIyOZPn266/jJkyezfPnyeh9TWVlJZWWl675hGAQEBLhui3gbX19f122bzaafcxERERERN2nWoXv79u0MGDCAv/71rxw8eJCIiAimTJnC5MmT631Mjx49ePfdd9m5cyeDBg2ioKCALVu2MGjQoHofs2zZMpYuXeq6361bN+bPn0/79u0b9f2INBeFhYWu2zExMURHR3uwGhERERER79WsQ3dmZiarVq1ixowZzJo1i2PHjvHvf/8bq9XK+PHj63xMz549eeyxx3jxxReprKykqqqKwYMH8+Mf/7je15k1axYzZ8503b/Y6peVlYXdbm/U9yTSHAQEBNCzZ08qKiqIiIggPT3d0yU1GavVqgtqIiIiItJkmnXodjgcdO/enbvvvhtwtkCfOnWKVatW1Ru609LSeOONN5g9ezYDBgwgLy+Pt99+m9dff52f/OQndT7GZrNhs9nq3GeaZqO8F5HmxGq18qtf/cp1Xz/nIiIiIiLu0azXCmrTpg2dOnWqsa1Tp05kZ2fX+5hly5aRmJjITTfdRNeuXRk4cCBz5sxhzZo15OXlubtkEREREREREZdmHboTExM5e/ZsjW1nz569ZNfQ8vLyWpNCXVyHWK15IiIiIiIi0pSadeieMWMGR44c4cMPPyQjI4MNGzbw1VdfMXXqVNcx77zzDi+//LLr/pAhQ9i2bRsrV67k3LlzHD58mH//+9/Ex8cTERHhibchIiIiIiIirVSzHtMdHx/PE088wTvvvMMHH3xAZGQk9913H2PGjHEdk5eXV6O7+fjx4yktLeWLL75g0aJFBAUF0adPH+69915PvAURERERERFpxQxTfa7rlZWVVWP9bhFp+Ww2m2YvFxEREZEm06xbuj3NatW3R8Tb6PdaRERERJqSWrpFRERERERE3KRZT6QmTau0tJRf//rXlJaWeroUaQL6vEVERERE3E+hW1xM0+TEiRNaWq2V0OctIiIiIuJ+Ct0iIiIiIiIibqLQLSIiIiIiIuImCt3iYrPZmD17NjabzdOlSBPQ5y0iIiIi4n6avVxERERERETETdTSLSIiIiIiIuImCt0iIiIiIiIibqLQLSIiIiIiIuImCt0iIiIiIiIibmL1dAHSPHzxxRd88skn5Ofn07VrVx588EHi4+M9XZa4wcGDB/n44485ceIEeXl5PPHEEwwbNszTZYmIiIiIeCW1dAubNm1i0aJFzJ49m/nz59O1a1eef/55CgoKPF2auEF5eTmxsbH8+Mc/9nQpIiIiIiJeT6Fb+PTTT5k0aRITJkygU6dOPPTQQ/j6+rJmzRpPlyZuMGjQIO688061bouIiIiINAGF7lbObrdz/Phx+vXr59pmsVjo168fKSkpHqxMRERERESk5VPobuUKCwtxOByEh4fX2B4eHk5+fr5HahIREREREfEWCt0iIiIiIiIibqLQ3cqFhoZisVhqtWrn5+fXav0WERERERGRq6PQ3cpZrVbi4uLYv3+/a5vD4WD//v306NHDg5WJiIiIiIi0fFqnW5g5cyavvPIKcXFxxMfH8/nnn1NeXs748eM9XZq4QVlZGRkZGa77mZmZpKamEhwcTLt27TxYmYiIiIiI9zFM0zQ9XYR43hdffMHHH39Mfn4+sbGxPPDAAyQkJHi6LHGDAwcO8Mwzz9TaPm7cOObOneuBikREREREvJdCt4iIiIiIiIibaEy3iIiIiIiIiJsodIuIiIiIiIi4iUK3iIiIiIiIiJsodIuIiIiIiIi4iUK3iIiIiIiIiJsodIuIiIiIiIi4iUK3iIiIiIiIiJsodIuIiIiIiIi4iUK3tFpLlizh9ttvr7Ft7ty5vPLKKx6qSEREREREvI1Ct7RIubm5LFmyhNTUVLe+TlpaGkuWLCEzM9Otr3MtkpOTWbJkCcXFxZ4uRUREREREvkehW1qkvLw8li5d2uih+8UXX+SRRx5x3U9LS2Pp0qVkZWU16us0puTkZJYuXarQLSIiIiLSDFk9XYDI1aiqqsI0Tbc9v81mc9tzi4iIiIhI62OY7kww4pWWLFnC0qVLefHFF1m6dCk7duzAarVy/fXXc8cdd5CTk8O//vUvDhw4gK+vLzfddBM33nhjjecoKCjgnXfeYefOnZSUlBATE8OMGTMYP36865jMzEx++tOfcu+99+Lj48MXX3xBZmYmP/rRj3jzzTdr1fXoo48yfvx4Dh06xIoVKzhy5AgFBQWEhYUxfPhw7r77bnx9fWu9jyVLlri2zZ07l969ezN37lzWrl3Lq6++Wut1fve737FmzRp27drFa6+9htVa89rVc889R1ZWFgsWLLjk9/HIkSMsXbqUlJQU7HY7UVFRTJw4kenTpwNw8uRJPv30Uw4dOkReXh6BgYEMGjSIH/7wh4SEhNR4D9/38ssvExkZecnXFxERERER91NLtzTYiy++SMeOHbnnnnvYuXMnH374IcHBwaxevZq+fftyzz33sH79et566y26d+9O7969AaioqGDevHlkZGRwww03EBkZyZYtW3j11VcpKSlxhc6L1q5dS2VlJZMmTcJmszFs2DBKS0tZsmQJkydPpmfPngAkJiYCsHnzZsrLy5kyZQohISEcPXqUL774gtzcXB5//PErfn+9evVi2rRprFixglmzZtGxY0cAOnbsyNixY1m3bh179uxh8ODBrsfk5+ezf/9+Zs+efcnn3rt3L//zP/9DmzZtmDZtGuHh4Zw5c4YdO3a43v/evXvJzMxk/PjxhIeHk5aWxurVq0lLS+P555/HMAyGDx9Oeno6Gzdu5L777nOF8dDQ0Ct+nyIiIiIi4j4K3dJg8fHxPPzwwwBMnjyZuXPn8tZbb3HXXXdx8803AzBq1CgeeeQR1qxZ4wrdq1ev5syZM/zsZz9jzJgxAFx//fXMmzeP9957jwkTJhAQEOB6nZycHF566aUaQXLQoEEsWbKEHj16MHbs2Bp13XvvvTVatCdPnkyHDh149913yc7Opl27dlf0/qKioujVqxcrVqygf//+9OnTx7UvNDSUtm3bsn79+hqhe8OGDZimWaum6hwOB//85z9p06YNf/zjHwkKCnLtq97xZOrUqbV6CCQkJLBgwQIOHz5Mr1696Nq1K926dWPjxo0MHTpUrdsiIiIiIs2MJlKTBps4caLrtsViIS4uDtM0a2wPCgoiJiamxuzfu3btIjw8nFGjRrm2Wa1Wpk2bRllZGQcPHqzxOsOHD7+qltvqgbusrIzCwkJ69OiBaZqcOHHiqt5jfSwWC6NHj2b79u2Ulpa6tm/YsIEePXpcMvyeOHGCzMxMpk+fXiNwAxiGUef7qKiooLCwkISEBNdziIiIiIhI86eWbmmw77cYBwYGYrPZagXkwMBAzp8/77qflZVFdHQ0FkvNaz4Xu29/f6bwq229zc7OZvHixWzfvr3WjN4lJSVX9VyXMm7cOJYvX862bdsYN24cZ8+e5fjx4zz00EOXfNy5c+cA6Ny58yWPKyoq4v3332fTpk0UFBTU2NeY70NERERERNxHoVsa7Puhub5t16p6i+/lOBwOfv/731NUVMQPfvADOnbsiJ+fH7m5ubz66quNOvN5p06diIuLY/369YwbN45169ZhtVoZMWJEozz/3/72N5KTk7npppuIjY3F398fh8PBCy+8gMPhaJTXEBERERER91LolibXvn17Tp48icPhqBHSz54969p/OdW7YVd36tQp0tPTmTt3LuPGjXNt37t37zVWXbexY8eyaNEi8vLy2LhxI0lJSQQHB1/yMVFRUQCcPn2a/v3713lMUVER+/bt4/bbb68xKVt6enqtY+v7XoiIiIiIiOdpTLc0uUGDBpGfn8+mTZtc26qqqlixYgX+/v6uCdcuxc/PD6BW9/GLIb56i7Zpmnz++ecNqtXf37/O17lo9OjRGIbBv//9b86dO+eaGO5SunXrRmRkJJ9//nmt571Yd13vA+Czzz6r9XwXvxfqci4iIiIi0vyopVua3OTJk1m1ahWvvvoqx48fdy0ZlpyczP33319j5vL6REVFERQUxKpVqwgICMDPz4+EhARiYmKIiorirbfeIjc3l8DAQLZu3UpRUVGDao2NjcVisbB8+XJKSkqw2Wz07duXsLAwwDmL+YABA9iyZQtBQUEkJSVd9jktFgtz5sxh/vz5PPnkk4wfP542bdpw5swZ0tLSePrppwkMDKRXr158/PHHVFVVERERwZ49e2pMSHdRXFwcAO+++y6jRo3Cx8eHwYMHuy4YiIiIiIiI56ilW5qcr68v8+bNY/To0XzzzTcsWrSIoqIiHn300VprdNfHarUyd+5cLBYLr7/+OgsWLODgwYNYrVZ+/etfExsby0cffcT7779Phw4d+OlPf9qgWsPDw3nooYcoLCzkH//4BwsWLCAtLa3GMRe7sY8YMQKbzXZFzztw4EB+97vfER0dzaeffsqbb77J/v37ayw/9vOf/5wBAwbw5Zdf8s477+Dj48NTTz1V67ni4+O54447OHnyJK+88goLFiygsLCwQe9XREREREQal2E25sxSIq3Qt99+y5/+9CeeeeYZevXq5elyRERERESkGVFLt8g1+uqrr4iKiqJnz56eLkVERERERJoZjekWaaCNGzdy8uRJdu7cyf33369ZxEVEREREpBaFbpEGWrBgAf7+/kycOJGpU6d6uhwREREREWmGNKZbRERERERExE00pltERERERETETRS6RURERERERNxEoVtERERERETETRS6RURERERERNxEoVtERERERETETRS6RURERERERNxEoVtERERERETETRS6RURERERERNzk/wdSXU+aOH6kLAAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig = plt.figure(figsize=(10, 10))\n",
-    "for i, variable in enumerate(variables, start=1):\n",
-    "    ax = plt.subplot(4, 3, i)\n",
-    "    ep.pl.violin(\n",
-    "        adata,\n",
-    "        keys=variable,\n",
-    "        groupby=\"mortality_cat\",\n",
-    "        ax=ax,\n",
-    "        show=False,\n",
-    "        stripplot=False,\n",
-    "    )\n",
-    "fig.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Aggregate data by hour\n",
-    "\n",
-    "As mentioned before, the dataset contains information regarding the first 2 days in the ICU. Every observation is associated with a time stamp, indicating the number of hours elapsed between ICU admission and the time when the observation was collected (e.g., 0.63 hours).\n",
-    "To allow for ease of comparison, individual data is condensed into hourly observations by selecting the median value of the available observations within each hour. First, the 'floor' operator is applied in order to categorize the hours in 48 bins (hour 0, hour 1, ..., hour 47). Then, the 'groupby' function with the 'median' operator is applied in order to get the median heart rate for each hour of each ICU stay:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1;35m2023-02-04 23:58:52,006\u001b[0m - \u001b[1;34mroot\u001b[0m \u001b[0;37mINFO - Added `['hour', 'icustay']` columns to `X`.\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "adata.obs[\"hour\"] = np.floor(adata[:, \"hours\"].X)\n",
-    "# data goes until h = 48, change 48 to 47\n",
-    "adata.obs[\"hour\"][adata.obs[\"hour\"] == 48] = 47\n",
-    "\n",
-    "\n",
-    "data_median_hour = (\n",
-    "    ep.ad.anndata_to_df(adata, obs_cols=[\"hour\", \"icustay\"])\n",
-    "    .groupby([\"icustay\", \"hour\"])[variables_mort]\n",
-    "    .median()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The 'groupby' will create as many indexes as groups defined. In order to facilitate the next operations, a single index is desirable. In the next example, the second index (column 'hour') is excluded and kept as a DataFrame column. Note that the first index corresponds to level 0 and second index to level 1. Therefore, in order to exclude the second index and keep it as a column, 'level' should be set to 1 and 'drop' to False."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_median_hour = data_median_hour.reset_index(level=(1), drop=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The next example shows the vital signs for a specific ICU stay (ID = 267387). Consecutive hourly observations are connected by line. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "vitals = [\n",
-    "    \"diastolic BP\",\n",
-    "    \"heart rate\",\n",
-    "    \"mean BP\",\n",
-    "    \"oxygen saturation\",\n",
-    "    \"respiratory rate\",\n",
-    "    \"systolic BP\",\n",
-    "    \"temperature\",\n",
-    "]\n",
-    "ICUstayID = 267387\n",
-    "\n",
-    "fig, ax = plt.subplots(figsize=(20, 6))\n",
-    "\n",
-    "# scatter plot\n",
-    "for col in vitals:\n",
-    "    ax.scatter(\n",
-    "        data_median_hour.loc[ICUstayID, \"hour\"], data_median_hour.loc[ICUstayID, col]\n",
-    "    )\n",
-    "    plt.legend(\n",
-    "        vitals, loc=9, bbox_to_anchor=(0.5, -0.1), ncol=len(vitals), prop={\"size\": 14}\n",
-    "    )\n",
-    "    plt.xticks(np.arange(0, 49, step=1))\n",
-    "    plt.xlabel(\"Hours since ICU admission\")\n",
-    "\n",
-    "# connect consecutive points by line\n",
-    "for col in vitals:\n",
-    "    ax.plot(\n",
-    "        data_median_hour.loc[ICUstayID, \"hour\"], data_median_hour.loc[ICUstayID, col]\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Select minimum number of observations\n",
-    "\n",
-    "We decided to keep all time-variant variables available. However, and as you can see in the previous example, since not all variables have an hourly sampling rate, a lot of information is missing (coded as NaN). In order to train ML algorithms it is important to decide how to handle the missing information. Two options are: to replace the missing information with some value or to exclude the missing information. In this work, we will avoid introducing bias resultant from replacing missing values with estimated values (which is not the same as saying that this is not a good option in some situations). Instead, we will focus on a complete case analysis, i.e., we will include in our analysis only those patients who have complete information.\n",
-    "\n",
-    "Depending on how we will create the feature set, complete information can have different meanings. For example, if we want to use one observation for every hour, complete information is to have no missing\n",
-    "data for every t=0 to t=47, which would lead to the exclusion of the majority of data. In order to reduce the size of the feature space, one common approach is to use only some portions of the time series. This is the strategy that will be followed in this work. Summary statistics, including the mean, maximum, minimum and standard deviation will be used to extract relevant information from the time series. In this case, it is important to define the minimum length of the time series before starting to select portions of it. One possible approach is to use all patients who have at least one observation per variable. Since, the summary statistics have little meaning if only one observation is available, a threshold of two observations will be used. \n",
-    "\n",
-    "In the following function, setting 'min_num_meas = 2' means that we are selecting ICU stays where each variable was recorded at least once at two different hours. Again, we are using the 'groupby' function to aggregate data by ICU stay, and the 'count' operator to count the number of observations for each variable. We then excluded ICU stays where some variable was recorded less than 2 times. Later on this chapter we will show how to extract features from the time series, in order to reduce the size of the feature space."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of ICU stays: 2410\n",
-      "Number of features: 11\n"
-     ]
-    }
-   ],
-   "source": [
-    "min_num_meas = 2\n",
-    "\n",
-    "\n",
-    "def extr_min_num_meas(data_median_hour, min_num_meas):\n",
-    "    \"\"\"Select ICU stays where there are at least 'min_num_meas' observations\n",
-    "    and print the resulting DataFrame size\"\"\"\n",
-    "    data_count = data_median_hour.groupby([\"icustay\"])[variables_mort].count()\n",
-    "\n",
-    "    for col in data_count:\n",
-    "        data_count[col] = data_count[col].apply(\n",
-    "            lambda x: np.nan if x < min_num_meas else x\n",
-    "        )\n",
-    "\n",
-    "    data_count = data_count.dropna(axis=0, how=\"any\")\n",
-    "    print(f\"Number of ICU stays: {str(data_count.shape[0])}\")\n",
-    "    print(f\"Number of features: {str(data_count.shape[1])}\")\n",
-    "    unique_stays = data_count.index.unique()\n",
-    "\n",
-    "    data_median_hour = data_median_hour.loc[unique_stays]\n",
-    "\n",
-    "    return data_median_hour\n",
-    "\n",
-    "\n",
-    "data_median_hour = extr_min_num_meas(data_median_hour, min_num_meas)"
+    "# **The following are from original ml_usecases.ipynb**"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It is always important to keep track of the size of data while making decisions about inclusion/exclusion criteria. We started with a database of around 60,000 ICU stays, imported a fraction of those that satisfied some criteria, in a total of 41,496 ICU stays, and are now looking at 2,410 ICU stays.\n",
+    "It is always important to keep track of the size of data while making decisions about inclusion/exclusion criteria. We started with a database of around 60,000 ICU stays, imported a fraction of those that satisfied some criteria, in a total of 57,874 ICU stays, and are now looking at 6,859 ICU stays.\n",
     "\n",
     "## Exploratory (preprocessed-)data analysis\n",
     "\n",