diff --git a/fiora/GNN/GNNModules.py b/fiora/GNN/GNNModules.py index bbf0ccd..311962f 100644 --- a/fiora/GNN/GNNModules.py +++ b/fiora/GNN/GNNModules.py @@ -240,7 +240,7 @@ def get_graph_embedding(self, batch): return pooling_func(X, batch["batch"]) - def forward(self, batch, with_RT=False, with_CCS=False): + def forward(self, batch, with_RT=True, with_CCS=True): # Embed node features batch["node_embedding"] = self.node_embedding(batch["x"]) diff --git a/fiora/GNN/Trainer.py b/fiora/GNN/Trainer.py index 21b2e77..2f1bb26 100644 --- a/fiora/GNN/Trainer.py +++ b/fiora/GNN/Trainer.py @@ -2,14 +2,15 @@ import torch import numpy as np from torch.utils.data import DataLoader, Dataset -from torchmetrics import Accuracy, MetricTracker, MetricCollection, Precision, Recall, PrecisionRecallCurve, MeanSquaredError, MeanAbsoluteError, R2Score +from torchmetrics import Accuracy, MetricTracker, MetricCollection, Precision, Recall, PrecisionRecallCurve, MeanSquaredError, MeanAbsoluteError, R2Score, PearsonCorrCoef from sklearn.model_selection import train_test_split from typing import Literal, List, Dict, Any class Trainer(ABC): def __init__(self, data: Any, train_val_split: float=0.8, split_by_group: bool=False, only_training: bool=False, - train_keys: List[int]=[], val_keys: List[int]=[], seed: int=42, num_workers: int=0, device: str="cpu") -> None: + train_keys: List[int]=[], val_keys: List[int]=[], test_keys: List[int]=[], seed: int=42, num_workers: int=0, device: str="cpu") -> None: + self.only_training = only_training self.num_workers = num_workers @@ -19,7 +20,8 @@ def __init__(self, data: Any, train_val_split: float=0.8, split_by_group: bool=F self.training_data = data self.validation_data = Dataset() elif split_by_group: - self._split_by_group(data, train_val_split, train_keys, val_keys, seed) + self._split_by_group(data, train_val_split, train_keys, val_keys, test_keys, seed) + else: train_size = int(len(data) * train_val_split) self.training_data, self.validation_data = torch.utils.data.random_split( @@ -27,21 +29,23 @@ def __init__(self, data: Any, train_val_split: float=0.8, split_by_group: bool=F generator=torch.Generator().manual_seed(seed) ) - - def _split_by_group(self, data, train_val_split: float, train_keys: List[int], val_keys: List[int], seed: int): + def _split_by_group(self, data, train_val_split: float, train_keys: List[int], val_keys: List[int], test_keys: List[int], seed: int): group_ids = [getattr(x, "group_id") for x in data] keys = np.unique(group_ids) - if len(train_keys) > 0 and len(val_keys) > 0: - self.train_keys, self.val_keys = train_keys, val_keys - print("Using pre-set train/validation keys") + if len(train_keys) > 0 and len(val_keys) > 0 and len(test_keys) > 0: + self.train_keys, self.val_keys, self.test_keys = train_keys, val_keys, test_keys + print("Using pre-set train/validation/test keys") else: self.train_keys, self.val_keys = train_test_split( keys, test_size=1 - train_val_split, random_state=seed ) train_ids = np.where([group_id in self.train_keys for group_id in group_ids])[0] val_ids = np.where([group_id in self.val_keys for group_id in group_ids])[0] + test_ids = np.where([group_id in self.test_keys for group_id in group_ids])[0] self.training_data = torch.utils.data.Subset(data, train_ids) self.validation_data = torch.utils.data.Subset(data, val_ids) + self.test_data = torch.utils.data.Subset(data, test_ids) + def _get_default_metrics(self, problem_type: Literal["classification", "regression", "softmax_regression"]): metrics = { @@ -53,7 +57,9 @@ def _get_default_metrics(self, problem_type: Literal["classification", "regressi }) if problem_type=="classification" else MetricCollection( { 'mse': MeanSquaredError(), - 'mae': MeanAbsoluteError() + 'mae': MeanAbsoluteError(), + 'r2' : R2Score(), + 'pearson' : PearsonCorrCoef() })).to(self.device) for data_split in ["train", "val", "masked_val", "test"] } diff --git a/fiora/MOL/Metabolite.py b/fiora/MOL/Metabolite.py index a61df46..6faa641 100644 --- a/fiora/MOL/Metabolite.py +++ b/fiora/MOL/Metabolite.py @@ -45,6 +45,10 @@ def __init__(self, SMILES: str|None, InChI: str|None=None, id: int|None=None) -> self.morganFingerCountOnes = self.morganFinger.GetNumOnBits() self.id = id self.loss_weight = 1.0 + self.precursor_positive = None + self.ring_count = None + self.presence_rare_elements = None + self.elem_distr_vec = None def __repr__(self): return f"" @@ -71,6 +75,22 @@ def __lt__(self, __o: object) -> bool: # TODO not tested!s return False return False + # Setter for Precursor Adduct + def set_precursor_positive(self, precursor_adduct): + self.precursor_positive = (precursor_adduct == "[M+H]+") + + # Setter for Ring Count + def set_ring_count(self, ring_count): + self.ring_count = ring_count + + # Setter for Presence of Rare Elements + def set_presence_rare_elements(self, presence_rare_elem): + self.presence_rare_elements = presence_rare_elem + + # Setter for Elem Distribution Vector + def set_elem_distr_vec(self, elem_distr_vec): + self.elem_distr_vec = elem_distr_vec + def get_id(self): return self.id @@ -108,7 +128,51 @@ def draw(self, ax=plt): # class-specific functions def create_molecular_structure_graph(self): self.Graph = mol_to_graph(self.MOL) + + def calc_element_distribution(self): + element_distribution = {} + total_elements = len(self.node_elements) + + for elem in self.node_elements: + if elem in element_distribution: + element_distribution[elem] += 1 + else: + element_distribution[elem] = 1 + + # Convert counts to ratios + for elem in element_distribution: + element_distribution[elem] /= total_elements + + return element_distribution + def calc_abs_elem_distr(self): + element_distribution = {} + + for elem in self.node_elements: + if elem in element_distribution: + element_distribution[elem] += 1 + else: + element_distribution[elem] = 1 + + return element_distribution + + def calc_abs_elem_distr_vec(self, all_unique_elements): + """Calculate the absolute element distribution vector with fixed length, for a metabolite.""" + # Create a mapping of elements to indices, e.g. {"C": 0, "H": 1, "N": 2, "O": 3, "S": 4} + element_to_index = {element: i for i, element in enumerate(all_unique_elements)} + + # Initialize a zero vector of fixed length + element_vector = np.zeros(len(all_unique_elements), dtype=int) + + # Count occurrences of each element + unique_elements, counts = np.unique(self.node_elements, return_counts=True) + + # Fill the vector using the mapping + for element, count in zip(unique_elements, counts): + element_vector[element_to_index[element]] = count + + return element_vector + def compute_graph_attributes(self, node_encoder: AtomFeatureEncoder|None = None, bond_encoder: BondFeatureEncoder|None = None) -> None: @@ -135,6 +199,7 @@ def compute_graph_attributes(self, node_encoder: AtomFeatureEncoder|None = None, # Lists self.atoms_in_order = [self.Graph.nodes[atom]['atom'] for atom in self.Graph.nodes()] self.node_elements = [self.Graph.nodes[atom]['atom'].GetSymbol() for atom in self.Graph.nodes()] + self.element_distribution = self.calc_element_distribution() self.edge_bond_names = [self.Graph[u][v]['bond_type'].name for u,v in self.edges_as_tuples] if bond_encoder: self.edge_bond_types = torch.tensor([bond_encoder.number_mapper["bond_type"][bond_name] for bond_name in self.edge_bond_names], dtype=torch.long) @@ -337,7 +402,35 @@ def match_fragments_to_peaks(self, mz_fragments, int_list=None, mode_mapper=None 'ms_num_all_peaks': len(mz_fragments) } - def as_geometric_data(self, with_labels=True): + def as_geometric_data(self, with_labels=True, ccs_only=False): + if ccs_only: + return Data( + x=self.node_features, + edge_index=self.edges.t().contiguous(), + edge_type=self.edge_bond_types, + edge_attr=self.bond_features, + static_graph_features=self.setup_features, + static_edge_features=self.setup_features_per_edge, + static_rt_features = self.rt_setup_features, + weight = self.ExactMolWeight, + precursor_positive = self.precursor_positive, + ring_count = self.ring_count, + presence_rare_elements = self.presence_rare_elements, + elem_distr_vec = self.elem_distr_vec, + + # masks and groups + validation_mask=self.is_edge_not_in_ring.bool(), + group_id=self.id, + + # additional information + is_node_aromatic=self.is_node_aromatic, + is_edge_aromatic=self.is_edge_aromatic, + + ccs = self.ccs, + ccs_mask = self.ccs_mask, + + smiles = self.SMILES + ) if with_labels: return Data( x=self.node_features, diff --git a/fiora/MOL/constants.py b/fiora/MOL/constants.py index df86352..b092263 100644 --- a/fiora/MOL/constants.py +++ b/fiora/MOL/constants.py @@ -34,7 +34,7 @@ "[M-3H]-": -1 * Descriptors.ExactMolWt(h_2) - 1 * Chem.Descriptors.ExactMolWt(h_plus), } - +RARE_ELEMENTS = ['Br', 'Cl', 'F', 'I', 'S'] PPM = 1/1000000 DEFAULT_PPM = 100 * PPM diff --git a/fiora/MS/SimulationFramework.py b/fiora/MS/SimulationFramework.py index 4c3bdd1..07ff0b7 100644 --- a/fiora/MS/SimulationFramework.py +++ b/fiora/MS/SimulationFramework.py @@ -43,11 +43,12 @@ def pred_all(self, df: pd.DataFrame, model: torch.nn.Module|None=None, attr_name for i,d in df.iterrows(): metabolite = d["Metabolite"] prediction = self.predict_metabolite_property(metabolite, model=model, as_batch=as_batch) - if self.with_RT: - setattr(metabolite, attr_name + "_pred", prediction["fragment_probs"]) + if self.with_RT: setattr(metabolite, "RT_pred", prediction["rt"].squeeze()) - else: - setattr(metabolite, attr_name + "_pred", prediction["fragment_probs"]) + if self.with_CCS: + setattr(metabolite, "CCS_pred", prediction["ccs"].squeeze()) + setattr(metabolite, attr_name + "_pred", prediction["fragment_probs"]) + return diff --git a/notebooks/ccs_test.ipynb b/notebooks/ccs_test.ipynb new file mode 100644 index 0000000..e32c74b --- /dev/null +++ b/notebooks/ccs_test.ipynb @@ -0,0 +1,21476 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Train CCS Predicting Models, Predict CCS Values of Metabolites, Compare Them

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Import Data

" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set plot fonts globally\n", + "\n", + "mpl.rcParams['font.size'] = 14\n", + "\n", + "mpl.rcParams['axes.titlesize'] = 16 # Title font size\n", + "mpl.rcParams['axes.labelsize'] = 14 # Axis label font size\n", + "mpl.rcParams['xtick.labelsize'] = 10 # X-axis tick label font size\n", + "mpl.rcParams['ytick.labelsize'] = 10 # Y-axis tick label font size\n", + "mpl.rcParams['legend.fontsize'] = 11 # Legend font size\n", + "mpl.rcParams['figure.titlesize'] = 18 # Figure title font size" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Molecule NameMolecular FormulaMETLIN IDPrecursor AdductCCS1CCS2CCS3CCS_AVG% CVm/z...m/z.1DimerDimer.1dimer lineCCSm/z.2pubCheminchismilesInChIKEY
03-[3-(2,3-dihydroindol-1-yl)propyl]-1-[(4-fluo...C19H22FN3O1181481.0328.1820[M+H]176.63176.63176.63176.630.0328.1820...328.1820209.886594MonomerNaN135.050.025345055InChI=1S/C19H22FN3O/c20-17-8-6-15(7-9-17)14-22...O=C(NCc1ccc(cc1)F)NCCCN1CCc2c1cccc2DWYWDNMZIWKHFM-UHFFFAOYSA-N
13-{[1,1'-biphenyl]-4-ylmethylidene}-6-fluoro-2...C22H15FO3S1191359.0379.0799[M+H]192.26192.26192.26192.260.0379.0799...379.0799223.588309MonomerNaN310.0700.0NaNInChI=1S/C22H15FO3S/c23-19-10-11-21-20(13-19)2...Fc1ccc2c(c1)C(=O)C(=Cc1ccc(cc1)c1ccccc1)CS2(=O)=OMFNGEIZTLYGVQK-UHFFFAOYSA-N
21-{[3-(4-methoxyphenyl)-1,2,4-oxadiazol-5-yl]m...C25H28N4O31228206.0433.2234[M+H]211.12211.12211.12211.120.0433.2234...433.2234238.163739MonomerNaNNaNNaN17541371InChI=1S/C25H28N4O3/c1-31-21-10-8-19(9-11-21)2...COc1ccc(cc1)c1noc(n1)CN1CCN(CC1)C(=O)C1(CCC1)c...YPHGAJRHIVSPSX-UHFFFAOYSA-N
33-[2-oxo-2-(4-phenylmethanesulfonylpiperazin-1...C22H30N4O5S1176932.0463.2010[M+H]204.22204.22204.22204.220.0463.2010...463.2010246.233709MonomerNaNNaNNaN16295966InChI=1S/C22H30N4O5S/c27-19(16-26-20(28)22(23-...O=C(N1CCN(CC1)S(=O)(=O)Cc1ccccc1)CN1C(=O)NC2(C...ALHVXFHLDXYEII-UHFFFAOYSA-N
42-{[1,1'-biphenyl]-2-ylamino}-1-(morpholin-4-y...C18H20N2O21183857.0297.1598[M+H]174.47174.47174.47174.470.0297.1598...297.1598201.535418MonomerNaNNaNNaN17463671InChI=1S/C18H20N2O2/c21-18(20-10-12-22-13-11-2...O=C(N1CCOCC1)CNc1ccccc1c1ccccc1YWINZXNEVGTFAX-UHFFFAOYSA-N
..................................................................
65283NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN...NaNNaNNaNNaNNaNNaN------XKTJEHXBSIDWRH-UHFFFAOYSA-N
65284NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN...NaNNaN3825NaNNaNNaN------XKTJEHXBSIDWRH-UHFFFAOYSA-N
65285NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN...NaNNaN61457NaNNaNNaN------XKTJEHXBSIDWRH-UHFFFAOYSA-N
65286NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN...NaNNaNNaNNaNNaNNaN------XKTJEHXBSIDWRH-UHFFFAOYSA-N
65287NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN...NaNNaN65282NaNNaNNaN------XKTJEHXBSIDWRH-UHFFFAOYSA-N
\n", + "

65288 rows × 21 columns

\n", + "
" + ], + "text/plain": [ + " Molecule Name Molecular Formula \\\n", + "0 3-[3-(2,3-dihydroindol-1-yl)propyl]-1-[(4-fluo... C19H22FN3O \n", + "1 3-{[1,1'-biphenyl]-4-ylmethylidene}-6-fluoro-2... C22H15FO3S \n", + "2 1-{[3-(4-methoxyphenyl)-1,2,4-oxadiazol-5-yl]m... C25H28N4O3 \n", + "3 3-[2-oxo-2-(4-phenylmethanesulfonylpiperazin-1... C22H30N4O5S \n", + "4 2-{[1,1'-biphenyl]-2-ylamino}-1-(morpholin-4-y... C18H20N2O2 \n", + "... ... ... \n", + "65283 NaN NaN \n", + "65284 NaN NaN \n", + "65285 NaN NaN \n", + "65286 NaN NaN \n", + "65287 NaN NaN \n", + "\n", + " METLIN ID Precursor Adduct CCS1 CCS2 CCS3 CCS_AVG % CV \\\n", + "0 1181481.0 328.1820[M+H] 176.63 176.63 176.63 176.63 0.0 \n", + "1 1191359.0 379.0799[M+H] 192.26 192.26 192.26 192.26 0.0 \n", + "2 1228206.0 433.2234[M+H] 211.12 211.12 211.12 211.12 0.0 \n", + "3 1176932.0 463.2010[M+H] 204.22 204.22 204.22 204.22 0.0 \n", + "4 1183857.0 297.1598[M+H] 174.47 174.47 174.47 174.47 0.0 \n", + "... ... ... ... ... ... ... ... \n", + "65283 NaN NaN NaN NaN NaN NaN NaN \n", + "65284 NaN NaN NaN NaN NaN NaN NaN \n", + "65285 NaN NaN NaN NaN NaN NaN NaN \n", + "65286 NaN NaN NaN NaN NaN NaN NaN \n", + "65287 NaN NaN NaN NaN NaN NaN NaN \n", + "\n", + " m/z ... m/z.1 Dimer Dimer.1 dimer line CCS m/z.2 \\\n", + "0 328.1820 ... 328.1820 209.886594 Monomer NaN 135.0 50.0 \n", + "1 379.0799 ... 379.0799 223.588309 Monomer NaN 310.0 700.0 \n", + "2 433.2234 ... 433.2234 238.163739 Monomer NaN NaN NaN \n", + "3 463.2010 ... 463.2010 246.233709 Monomer NaN NaN NaN \n", + "4 297.1598 ... 297.1598 201.535418 Monomer NaN NaN NaN \n", + "... ... ... ... ... ... ... ... ... \n", + "65283 NaN ... NaN NaN NaN NaN NaN NaN \n", + "65284 NaN ... NaN NaN 3825 NaN NaN NaN \n", + "65285 NaN ... NaN NaN 61457 NaN NaN NaN \n", + "65286 NaN ... NaN NaN NaN NaN NaN NaN \n", + "65287 NaN ... NaN NaN 65282 NaN NaN NaN \n", + "\n", + " pubChem inchi \\\n", + "0 25345055 InChI=1S/C19H22FN3O/c20-17-8-6-15(7-9-17)14-22... \n", + "1 NaN InChI=1S/C22H15FO3S/c23-19-10-11-21-20(13-19)2... \n", + "2 17541371 InChI=1S/C25H28N4O3/c1-31-21-10-8-19(9-11-21)2... \n", + "3 16295966 InChI=1S/C22H30N4O5S/c27-19(16-26-20(28)22(23-... \n", + "4 17463671 InChI=1S/C18H20N2O2/c21-18(20-10-12-22-13-11-2... \n", + "... ... ... \n", + "65283 -- -- \n", + "65284 -- -- \n", + "65285 -- -- \n", + "65286 -- -- \n", + "65287 -- -- \n", + "\n", + " smiles \\\n", + "0 O=C(NCc1ccc(cc1)F)NCCCN1CCc2c1cccc2 \n", + "1 Fc1ccc2c(c1)C(=O)C(=Cc1ccc(cc1)c1ccccc1)CS2(=O)=O \n", + "2 COc1ccc(cc1)c1noc(n1)CN1CCN(CC1)C(=O)C1(CCC1)c... \n", + "3 O=C(N1CCN(CC1)S(=O)(=O)Cc1ccccc1)CN1C(=O)NC2(C... \n", + "4 O=C(N1CCOCC1)CNc1ccccc1c1ccccc1 \n", + "... ... \n", + "65283 -- \n", + "65284 -- \n", + "65285 -- \n", + "65286 -- \n", + "65287 -- \n", + "\n", + " InChIKEY \n", + "0 DWYWDNMZIWKHFM-UHFFFAOYSA-N \n", + "1 MFNGEIZTLYGVQK-UHFFFAOYSA-N \n", + "2 YPHGAJRHIVSPSX-UHFFFAOYSA-N \n", + "3 ALHVXFHLDXYEII-UHFFFAOYSA-N \n", + "4 YWINZXNEVGTFAX-UHFFFAOYSA-N \n", + "... ... \n", + "65283 XKTJEHXBSIDWRH-UHFFFAOYSA-N \n", + "65284 XKTJEHXBSIDWRH-UHFFFAOYSA-N \n", + "65285 XKTJEHXBSIDWRH-UHFFFAOYSA-N \n", + "65286 XKTJEHXBSIDWRH-UHFFFAOYSA-N \n", + "65287 XKTJEHXBSIDWRH-UHFFFAOYSA-N \n", + "\n", + "[65288 rows x 21 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccs_df = pd.read_csv('/home/lbarbut/data/ccs/METLIN_IMS_all plot CV %3C2% _dimers.csv')\n", + "ccs_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Debug Mode" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "debug_mode = False\n", + "if debug_mode:\n", + " # Shuffle, because all first 1000 rows have precursor [M+H]+\n", + " ccs_df = ccs_df.sample(frac=1, random_state=42).reset_index(drop=True)\n", + "\n", + " # Keep only the first 1000 rows\n", + " ccs_df = ccs_df.iloc[:1000]\n", + "\n", + " # Reset the index (optional)\n", + " ccs_df = ccs_df.reset_index(drop=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Data Preprocessing

" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# drop NaN Precusor Adduct rows\n", + "ccs_df = ccs_df.dropna(subset=['Precursor Adduct'])\n", + "\n", + "# remove the m/z number before the Precursor Adduct since the info is also in m/z column\n", + "ccs_df.loc[:, 'Precursor Adduct'] = ccs_df['Precursor Adduct'].str.replace(r'[0-9.]+', '', regex=True)\n", + "\n", + "# remove [M+Na] rows\n", + "ccs_df = ccs_df[ccs_df['Precursor Adduct'] != '[M+Na]']\n", + "\n", + "# change [M+H] to [M+H]+ and [M-H] to [M-H]-\n", + "ccs_df[\"Precursor Adduct\"] = ccs_df[\"Precursor Adduct\"].replace({\n", + " \"[M+H]\": \"[M+H]+\",\n", + " \"[M-H]\": \"[M-H]-\"\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precursor Adduct\n", + "[M+H]+ 28136\n", + "[M-H]- 19697\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "print(ccs_df['Precursor Adduct'].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from rdkit import Chem" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def is_valid_smiles(smiles):\n", + " try:\n", + " return Chem.MolFromSmiles(smiles) is not None # True if valid, False if invalid\n", + " except Exception:\n", + " return False\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "\n", + "# Apply validation\n", + "ccs_df[\"smiles_is_valid\"] = ccs_df[\"smiles\"].apply(is_valid_smiles)\n", + "\n", + "invalid_smiles = ccs_df.loc[~ccs_df[\"smiles_is_valid\"], \"smiles\"] # Select invalid SMILES\n", + "# print(\"Invalid SMILES strings:\")\n", + "# print(invalid_smiles.tolist())\n", + "\n", + "# Filter out invalid SMILES, afterwards drop the is_valid column\n", + "ccs_df = ccs_df[ccs_df[\"smiles_is_valid\"]].drop(columns=[\"smiles_is_valid\"]).reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(44407, 21)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# drop NaN CCS_AVG rows\n", + "ccs_df = ccs_df.dropna(subset=['CCS_AVG'])\n", + "ccs_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "ccs_df[\"Instrument_type\"] = \"timsTOF\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "ccs_df['CE'] = -1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Use Fiora To Predict CCS Values of Metabolites

" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "# Create Metabolite column by Creating Molecular Graphs of Metabolites\n", + "\n", + "from fiora.MOL.Metabolite import Metabolite\n", + "from fiora.GNN.AtomFeatureEncoder import AtomFeatureEncoder\n", + "from fiora.GNN.BondFeatureEncoder import BondFeatureEncoder\n", + "from fiora.GNN.SetupFeatureEncoder import SetupFeatureEncoder\n", + "\n", + "CE_upper_limit = 100.0\n", + "weight_upper_limit = 1000.0\n", + "\n", + "ccs_df[\"Metabolite\"] = ccs_df[\"smiles\"].apply(Metabolite)\n", + "ccs_df[\"Metabolite\"].apply(lambda x: x.create_molecular_structure_graph())\n", + "\n", + "node_encoder = AtomFeatureEncoder(feature_list=[\"symbol\", \"num_hydrogen\", \"ring_type\"])\n", + "bond_encoder = BondFeatureEncoder(feature_list=[\"bond_type\", \"ring_type\"])\n", + "setup_encoder = SetupFeatureEncoder(feature_list=[\"collision_energy\", \"molecular_weight\", \"precursor_mode\", \"instrument\"])\n", + "rt_encoder = SetupFeatureEncoder(feature_list=[\"molecular_weight\", \"precursor_mode\", \"instrument\"])\n", + "\n", + "setup_encoder.normalize_features[\"collision_energy\"][\"max\"] = CE_upper_limit \n", + "setup_encoder.normalize_features[\"molecular_weight\"][\"max\"] = weight_upper_limit \n", + "rt_encoder.normalize_features[\"molecular_weight\"][\"max\"] = weight_upper_limit \n", + "\n", + "ccs_df[\"Metabolite\"].apply(lambda x: x.compute_graph_attributes(node_encoder, bond_encoder))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique smiles: 27334\n", + "Dataframe stats: 44407 spectra covering 27326 unique structures\n" + ] + } + ], + "source": [ + "# Assign unique Metabolite identifiers\n", + "print(\"Unique smiles: \" + str(len(ccs_df[\"smiles\"].unique())))\n", + "\n", + "metabolite_id_map = {}\n", + "for metabolite in ccs_df[\"Metabolite\"]:\n", + " is_new = True\n", + " for id, other in metabolite_id_map.items():\n", + " if metabolite == other:\n", + " metabolite.set_id(id)\n", + " is_new = False\n", + " break\n", + " if is_new:\n", + " new_id = len(metabolite_id_map)\n", + " metabolite.id = new_id\n", + " metabolite_id_map[new_id] = metabolite\n", + "\n", + "ccs_df[\"group_id\"] = ccs_df[\"Metabolite\"].apply(lambda x: x.get_id())\n", + "ccs_df[\"num_per_group\"] = ccs_df[\"group_id\"].map(ccs_df[\"group_id\"].value_counts())\n", + "\n", + "for i, data in ccs_df.iterrows():\n", + " data[\"Metabolite\"].set_loss_weight(1.0 / data[\"num_per_group\"])\n", + "ccs_df[\"loss_weight\"] = ccs_df[\"Metabolite\"].apply(lambda x: x.loss_weight)\n", + "\n", + "def print_df_stats(df):\n", + " num_spectra = df.shape[0]\n", + " num_ids = len(df[\"group_id\"].unique())\n", + " \n", + " print(f\"Dataframe stats: {num_spectra} spectra covering {num_ids} unique structures\")\n", + "\n", + "print_df_stats(ccs_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 None\n", + "1 None\n", + "2 None\n", + "3 None\n", + "4 None\n", + " ... \n", + "44402 None\n", + "44403 None\n", + "44404 None\n", + "44405 None\n", + "44406 None\n", + "Length: 44407, dtype: object" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_id(x[\"group_id\"]), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot histogram of CCS_AVG column\n", + "\n", + "plt.hist(ccs_df['CCS_AVG'], bins=30, edgecolor='black')\n", + "plt.xlabel('Average CCS Value')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Histogram of Average CCS Values')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Predict CCS Values
" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn.init as init\n", + "import torch.nn as nn\n", + "from fiora.GNN.GNNModules import GNNCompiler\n", + "from fiora.MS.SimulationFramework import SimulationFramework\n", + "from contextlib import contextmanager\n", + "from torch.func import functional_call" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "LoRa" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def _freeze_as_leaf_(module):\n", + " for name, p in list(module._parameters.items()):\n", + " if p is None: continue\n", + " module._parameters[name] = nn.Parameter(p.detach(), requires_grad=False)\n", + " for child in module.children():\n", + " _freeze_as_leaf_(child)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a wrapper class to add trainable LoRA-like deltas to a frozen model\n", + "class FinetuneFioraWrapper(nn.Module):\n", + " def __init__(self, base_model):\n", + " super().__init__()\n", + " self.model = base_model\n", + " _freeze_as_leaf_(self.model) # sets all base params to leaf, requires_grad=False\n", + " \n", + " # Pass through model_params for compatibility with PropertyTrainer\n", + " self.model_params = base_model.model_params\n", + "\n", + " # Create trainable deltas (same shape as each base parameter)\n", + " self.deltas = nn.ParameterList([\n", + " nn.Parameter(torch.zeros_like(p, device=p.device, dtype=p.dtype, requires_grad=True))\n", + " for p in self.model.parameters()\n", + " ])\n", + "\n", + " def parameters(self, recurse: bool = True):\n", + " \"\"\"Override to return only the trainable deltas\"\"\"\n", + " return self.deltas\n", + "\n", + " def named_parameters(self, prefix: str = '', recurse: bool = True):\n", + " \"\"\"Override to return only the trainable deltas\"\"\"\n", + " base_names = [n for n, _ in self.model.named_parameters()]\n", + " return [(f\"{prefix}delta.{n}\", d) for n, d in zip(base_names, self.deltas)]\n", + " @contextmanager\n", + " def apply_deltas(self):\n", + " # clone original weights\n", + " originals = [p.detach().clone() for p in self.model.parameters()]\n", + " # add deltas to original params\n", + " for p, d in zip(self.model.parameters(), self.deltas):\n", + " p.add_(d)\n", + " yield\n", + " with torch.no_grad():\n", + " # restore each p.data back to its original value\n", + " for p, o in zip(self.model.parameters(), originals):\n", + " p.data.copy_(o)\n", + "\n", + " def forward(self, *args, **kwargs):\n", + " # Build a mapping from *base* param name -> *effective* param tensor\n", + " perturbed = {\n", + " name: p + d\n", + " for (name, p), d in zip(self.model.named_parameters(), self.deltas) # p here is frozen and wont get grads, self.model is the base_model\n", + " }\n", + " # Call the frozen backbone *statelessly* with those effective params\n", + " return functional_call(self.model, perturbed, args=args, kwargs=kwargs) # temporarily use perturbed weights just for this forward, after this backbone (self.model) still holds the original frozen tensors\n", + " \n", + " def save(self, path: str):\n", + " \"\"\"\n", + " Called by PropertyTrainer when it wants to checkpoint.\n", + " \"\"\"\n", + " # just dump the state dict\n", + " torch.save(self.model.state_dict(), path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded from state dict without errors.\n", + "CCS_module.dense_layers.0.weight: requires gradients\n", + "CCS_module.dense_layers.0.bias: requires gradients\n", + "CCS_module.dense_layers.1.weight: requires gradients\n", + "CCS_module.dense_layers.1.bias: requires gradients\n", + "CCS_module.output_layer.weight: requires gradients\n", + "CCS_module.output_layer.bias: requires gradients\n" + ] + } + ], + "source": [ + "# Load best model\n", + "\n", + "dev=\"cuda:0\"\n", + "#MODEL_PATH = f\"{home}/data/metabolites/pretrained_models/pre_package/v0.0.1_merged_depth6_Jan24.pt\"\n", + "MODEL_PATH = \"/home/lbarbut/models/ccs_models/v0.0.1_merged_depth6_Aug24_sqrt+CCS+RT_drop3.pt\" # New sqrt model (improved)\n", + "\n", + "try:\n", + " base_model= GNNCompiler.load_from_state_dict(MODEL_PATH)\n", + " print(\"Model loaded from state dict without errors.\")\n", + "except:\n", + " raise NameError(\"Error: Failed loading from state dict.\")\n", + " \n", + "\n", + "base_model.eval()\n", + "base_model = base_model.to(dev)\n", + "\n", + "base_model.model_params\n", + "\n", + "spectral_modules = [\"node_embedding\", \"edge_embedding\", \"GNN_module\", \"edge_module\", \"precursor_module\", \"RT_module\"]\n", + "# for module in spectral_modules:\n", + "# base_model.freeze_submodule(module)\n", + "\n", + "for name, param in base_model.named_parameters():\n", + " if param.requires_grad:print(f\"{name}: requires gradients\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Reset and randomize model weights\n", + "\n", + "def reset_weights_and_xavier_init(model: torch.nn.Module):\n", + " for name, module in model.named_modules():\n", + " if hasattr(module, 'reset_parameters'):\n", + " try:\n", + " module.reset_parameters()\n", + " print(f\"Reset: {name} ({module.__class__.__name__})\")\n", + " except Exception as e:\n", + " print(f\"Failed to reset: {name} ({module.__class__.__name__}) — {e}\")\n", + "\n", + " if isinstance(module, torch.nn.Linear):\n", + " init.xavier_uniform_(module.weight)\n", + " print(f\"Xavier initialized: {name}.weight\")\n", + " if module.bias is not None:\n", + " init.zeros_(module.bias)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "#reset_weights_and_xavier_init(base_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check model content:\n", + "GNNCompiler(\n", + " (node_embedding): FeatureEmbedding(\n", + " (embeddings): ModuleList(\n", + " (0): Embedding(10, 100)\n", + " (1-2): 2 x Embedding(5, 100)\n", + " )\n", + " )\n", + " (edge_embedding): FeatureEmbedding(\n", + " (embeddings): ModuleList(\n", + " (0): Embedding(4, 150)\n", + " (1): Embedding(5, 150)\n", + " )\n", + " )\n", + " (GNN_module): GNN(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (graph_layers): ModuleList(\n", + " (0-5): 6 x RGCNConv(300, 300, num_relations=4)\n", + " )\n", + " )\n", + " (edge_module): EdgePredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=909, out_features=909, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=909, out_features=10, bias=True)\n", + " )\n", + " (precursor_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=309, out_features=309, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=309, out_features=1, bias=True)\n", + " )\n", + " (RT_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=308, out_features=308, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=308, out_features=1, bias=True)\n", + " )\n", + " (CCS_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=308, out_features=308, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=308, out_features=1, bias=True)\n", + " )\n", + " (softmax): Softmax(dim=0)\n", + ")\n", + "=========================\n", + " -> GNNCompiler\n", + "node_embedding -> FeatureEmbedding\n", + "node_embedding.embeddings -> ModuleList\n", + "node_embedding.embeddings.0 -> Embedding\n", + "node_embedding.embeddings.1 -> Embedding\n", + "node_embedding.embeddings.2 -> Embedding\n", + "edge_embedding -> FeatureEmbedding\n", + "edge_embedding.embeddings -> ModuleList\n", + "edge_embedding.embeddings.0 -> Embedding\n", + "edge_embedding.embeddings.1 -> Embedding\n", + "GNN_module -> GNN\n", + "GNN_module.activation -> ELU\n", + "GNN_module.input_dropout -> Dropout\n", + "GNN_module.latent_dropout -> Dropout\n", + "GNN_module.graph_layers -> ModuleList\n", + "GNN_module.graph_layers.0 -> RGCNConv\n", + "GNN_module.graph_layers.0.aggr_module -> MeanAggregation\n", + "GNN_module.graph_layers.1 -> RGCNConv\n", + "GNN_module.graph_layers.1.aggr_module -> MeanAggregation\n", + "GNN_module.graph_layers.2 -> RGCNConv\n", + "GNN_module.graph_layers.2.aggr_module -> MeanAggregation\n", + "GNN_module.graph_layers.3 -> RGCNConv\n", + "GNN_module.graph_layers.3.aggr_module -> MeanAggregation\n", + "GNN_module.graph_layers.4 -> RGCNConv\n", + "GNN_module.graph_layers.4.aggr_module -> MeanAggregation\n", + "GNN_module.graph_layers.5 -> RGCNConv\n", + "GNN_module.graph_layers.5.aggr_module -> MeanAggregation\n", + "edge_module -> EdgePredictor\n", + "edge_module.activation -> ELU\n", + "edge_module.input_dropout -> Dropout\n", + "edge_module.latent_dropout -> Dropout\n", + "edge_module.dense_layers -> ModuleList\n", + "edge_module.dense_layers.0 -> Linear\n", + "edge_module.dense_layers.1 -> Linear\n", + "edge_module.output_layer -> Linear\n", + "precursor_module -> GraphPredictor\n", + "precursor_module.activation -> ELU\n", + "precursor_module.input_dropout -> Dropout\n", + "precursor_module.latent_dropout -> Dropout\n", + "precursor_module.dense_layers -> ModuleList\n", + "precursor_module.dense_layers.0 -> Linear\n", + "precursor_module.dense_layers.1 -> Linear\n", + "precursor_module.output_layer -> Linear\n", + "RT_module -> GraphPredictor\n", + "RT_module.activation -> ELU\n", + "RT_module.input_dropout -> Dropout\n", + "RT_module.latent_dropout -> Dropout\n", + "RT_module.dense_layers -> ModuleList\n", + "RT_module.dense_layers.0 -> Linear\n", + "RT_module.dense_layers.1 -> Linear\n", + "RT_module.output_layer -> Linear\n", + "CCS_module -> GraphPredictor\n", + "CCS_module.activation -> ELU\n", + "CCS_module.input_dropout -> Dropout\n", + "CCS_module.latent_dropout -> Dropout\n", + "CCS_module.dense_layers -> ModuleList\n", + "CCS_module.dense_layers.0 -> Linear\n", + "CCS_module.dense_layers.1 -> Linear\n", + "CCS_module.output_layer -> Linear\n", + "softmax -> Softmax\n", + "=========================\n", + "node_embedding.embeddings.0.weight | shape: torch.Size([10, 100]) | requires_grad: False\n", + "node_embedding.embeddings.1.weight | shape: torch.Size([5, 100]) | requires_grad: False\n", + "node_embedding.embeddings.2.weight | shape: torch.Size([5, 100]) | requires_grad: False\n", + "edge_embedding.embeddings.0.weight | shape: torch.Size([4, 150]) | requires_grad: False\n", + "edge_embedding.embeddings.1.weight | shape: torch.Size([5, 150]) | requires_grad: False\n", + "GNN_module.graph_layers.0.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.0.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.0.bias | shape: torch.Size([300]) | requires_grad: False\n", + "GNN_module.graph_layers.1.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.1.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.1.bias | shape: torch.Size([300]) | requires_grad: False\n", + "GNN_module.graph_layers.2.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.2.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.2.bias | shape: torch.Size([300]) | requires_grad: False\n", + "GNN_module.graph_layers.3.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.3.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.3.bias | shape: torch.Size([300]) | requires_grad: False\n", + "GNN_module.graph_layers.4.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.4.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.4.bias | shape: torch.Size([300]) | requires_grad: False\n", + "GNN_module.graph_layers.5.weight | shape: torch.Size([4, 300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.5.root | shape: torch.Size([300, 300]) | requires_grad: False\n", + "GNN_module.graph_layers.5.bias | shape: torch.Size([300]) | requires_grad: False\n", + "edge_module.dense_layers.0.weight | shape: torch.Size([909, 909]) | requires_grad: False\n", + "edge_module.dense_layers.0.bias | shape: torch.Size([909]) | requires_grad: False\n", + "edge_module.dense_layers.1.weight | shape: torch.Size([909, 909]) | requires_grad: False\n", + "edge_module.dense_layers.1.bias | shape: torch.Size([909]) | requires_grad: False\n", + "edge_module.output_layer.weight | shape: torch.Size([10, 909]) | requires_grad: False\n", + "edge_module.output_layer.bias | shape: torch.Size([10]) | requires_grad: False\n", + "precursor_module.dense_layers.0.weight | shape: torch.Size([309, 309]) | requires_grad: False\n", + "precursor_module.dense_layers.0.bias | shape: torch.Size([309]) | requires_grad: False\n", + "precursor_module.dense_layers.1.weight | shape: torch.Size([309, 309]) | requires_grad: False\n", + "precursor_module.dense_layers.1.bias | shape: torch.Size([309]) | requires_grad: False\n", + "precursor_module.output_layer.weight | shape: torch.Size([1, 309]) | requires_grad: False\n", + "precursor_module.output_layer.bias | shape: torch.Size([1]) | requires_grad: False\n", + "RT_module.dense_layers.0.weight | shape: torch.Size([308, 308]) | requires_grad: False\n", + "RT_module.dense_layers.0.bias | shape: torch.Size([308]) | requires_grad: False\n", + "RT_module.dense_layers.1.weight | shape: torch.Size([308, 308]) | requires_grad: False\n", + "RT_module.dense_layers.1.bias | shape: torch.Size([308]) | requires_grad: False\n", + "RT_module.output_layer.weight | shape: torch.Size([1, 308]) | requires_grad: False\n", + "RT_module.output_layer.bias | shape: torch.Size([1]) | requires_grad: False\n", + "CCS_module.dense_layers.0.weight | shape: torch.Size([308, 308]) | requires_grad: True\n", + "CCS_module.dense_layers.0.bias | shape: torch.Size([308]) | requires_grad: True\n", + "CCS_module.dense_layers.1.weight | shape: torch.Size([308, 308]) | requires_grad: True\n", + "CCS_module.dense_layers.1.bias | shape: torch.Size([308]) | requires_grad: True\n", + "CCS_module.output_layer.weight | shape: torch.Size([1, 308]) | requires_grad: True\n", + "CCS_module.output_layer.bias | shape: torch.Size([1]) | requires_grad: True\n", + "Checked Model\n" + ] + } + ], + "source": [ + "# Check model content\n", + "\n", + "print(\"Check model content:\")\n", + "print(base_model)\n", + "print(\"=========================\")\n", + "for name, module in base_model.named_modules():\n", + " print(name, \"->\", module.__class__.__name__)\n", + "print(\"=========================\")\n", + "for name, param in base_model.named_parameters():\n", + " print(f\"{name} | shape: {param.shape} | requires_grad: {param.requires_grad}\")\n", + "\n", + "print(\"Checked Model\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "node_embedding.embeddings.0.weight: does not require gradients (frozen)\n", + "node_embedding.embeddings.1.weight: does not require gradients (frozen)\n", + "node_embedding.embeddings.2.weight: does not require gradients (frozen)\n", + "edge_embedding.embeddings.0.weight: does not require gradients (frozen)\n", + "edge_embedding.embeddings.1.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.0.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.0.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.0.bias: does not require gradients (frozen)\n", + "GNN_module.graph_layers.1.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.1.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.1.bias: does not require gradients (frozen)\n", + "GNN_module.graph_layers.2.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.2.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.2.bias: does not require gradients (frozen)\n", + "GNN_module.graph_layers.3.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.3.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.3.bias: does not require gradients (frozen)\n", + "GNN_module.graph_layers.4.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.4.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.4.bias: does not require gradients (frozen)\n", + "GNN_module.graph_layers.5.weight: does not require gradients (frozen)\n", + "GNN_module.graph_layers.5.root: does not require gradients (frozen)\n", + "GNN_module.graph_layers.5.bias: does not require gradients (frozen)\n", + "edge_module.dense_layers.0.weight: does not require gradients (frozen)\n", + "edge_module.dense_layers.0.bias: does not require gradients (frozen)\n", + "edge_module.dense_layers.1.weight: does not require gradients (frozen)\n", + "edge_module.dense_layers.1.bias: does not require gradients (frozen)\n", + "edge_module.output_layer.weight: does not require gradients (frozen)\n", + "edge_module.output_layer.bias: does not require gradients (frozen)\n", + "precursor_module.dense_layers.0.weight: does not require gradients (frozen)\n", + "precursor_module.dense_layers.0.bias: does not require gradients (frozen)\n", + "precursor_module.dense_layers.1.weight: does not require gradients (frozen)\n", + "precursor_module.dense_layers.1.bias: does not require gradients (frozen)\n", + "precursor_module.output_layer.weight: does not require gradients (frozen)\n", + "precursor_module.output_layer.bias: does not require gradients (frozen)\n", + "RT_module.dense_layers.0.weight: does not require gradients (frozen)\n", + "RT_module.dense_layers.0.bias: does not require gradients (frozen)\n", + "RT_module.dense_layers.1.weight: does not require gradients (frozen)\n", + "RT_module.dense_layers.1.bias: does not require gradients (frozen)\n", + "RT_module.output_layer.weight: does not require gradients (frozen)\n", + "RT_module.output_layer.bias: does not require gradients (frozen)\n", + "CCS_module.dense_layers.0.weight: requires gradients\n", + "CCS_module.dense_layers.0.bias: requires gradients\n", + "CCS_module.dense_layers.1.weight: requires gradients\n", + "CCS_module.dense_layers.1.bias: requires gradients\n", + "CCS_module.output_layer.weight: requires gradients\n", + "CCS_module.output_layer.bias: requires gradients\n" + ] + } + ], + "source": [ + "for name, param in base_model.named_parameters():\n", + " if param.requires_grad:\n", + " print(f\"{name}: requires gradients\")\n", + " else:\n", + " print(f\"{name}: does not require gradients (frozen)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Include Metadata
" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def count_rings(smiles):\n", + " mol = Chem.MolFromSmiles(smiles) # Convert SMILES to RDKit molecule\n", + " if mol is None:\n", + " return 0\n", + " return len(Chem.GetSSSR(mol)) # Get ring count\n", + "\n", + "ccs_df[\"ring_count\"] = ccs_df[\"smiles\"].apply(count_rings)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "import fiora.MOL.constants\n", + "\n", + "# Do rare elements (usually heavier) cause worse predictions?\n", + "\n", + "def rare_element_included_smiles(smiles):\n", + " rare_elements = fiora.MOL.constants.RARE_ELEMENTS\n", + " \n", + " return any(re.search(rf'\\b{elem}\\b', smiles) for elem in rare_elements)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Collect all unique elements across all metabolites in the DataFrame\n", + "\n", + "metabolite_series = ccs_df['Metabolite']\n", + "all_unique_elements_set = set()\n", + "for metabolite in metabolite_series:\n", + " elements = metabolite.node_elements\n", + " all_unique_elements_set.update(elements)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "ccs_df['rare_element_included'] = ccs_df[\"smiles\"].apply(lambda x: rare_element_included_smiles(x))\n", + "ccs_df['abs_elem_distr_vec'] = ccs_df[\"Metabolite\"].apply(lambda x: Metabolite.calc_abs_elem_distr_vec(x, all_unique_elements_set))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "metadata_key = { \"collision_energy\": \"CE\", \n", + " \"instrument\": \"Instrument_type\",\n", + " \"precursor_mz\": \"m/z\", \n", + " 'precursor_mode': \"Precursor Adduct\",\n", + " \"ccs\": \"CCS_AVG\"\n", + " }\n", + "\n", + "ccs_df[\"summary\"] = ccs_df.apply(lambda x: {key: x[name] for key, name in metadata_key.items()}, axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].add_metadata(x[\"summary\"], setup_encoder, rt_encoder), axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_loss_weight(x[\"loss_weight\"]), axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_precursor_positive(x[\"Precursor Adduct\"]), axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_ring_count(x[\"ring_count\"]), axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_presence_rare_elements(x[\"rare_element_included\"]), axis=1)\n", + "ccs_df.apply(lambda x: x[\"Metabolite\"].set_elem_distr_vec(x[\"abs_elem_distr_vec\"]), axis=1)\n", + "\n", + "ccs_df[\"geo_data\"] = ccs_df[\"Metabolite\"].apply(lambda x: x.as_geometric_data(with_labels=False, ccs_only=True).to(dev)).values" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_molecular_weight(summary_dict):\n", + " \"\"\"\n", + " Extracts the 'molecular_weight' value from a dictionary.\n", + "\n", + " Args:\n", + " summary_dict (dict): A dictionary containing molecular weight information.\n", + "\n", + " Returns:\n", + " float: The molecular weight, or None if the key is not found.\n", + " \"\"\"\n", + " if isinstance(summary_dict, dict): # Check if the input is a dictionary\n", + " return summary_dict.get('molecular_weight') # Use .get() to avoid KeyError\n", + " else:\n", + " return None \n", + "\n", + "ccs_df[\"weights\"] = ccs_df[\"summary\"].apply(extract_molecular_weight)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "weights = [item.weight for item in ccs_df[\"geo_data\"]]\n", + "\n", + "ccs_df[\"weights\"] = weights\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 [M+H]+\n", + "1 [M+H]+\n", + "2 [M+H]+\n", + "3 [M+H]+\n", + "4 [M+H]+\n", + " ... \n", + "44402 [M-H]-\n", + "44403 [M-H]-\n", + "44404 [M-H]-\n", + "44405 [M-H]-\n", + "44406 [M-H]-\n", + "Name: Precursor Adduct, Length: 44407, dtype: object" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccs_df[\"Precursor Adduct\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Molecule Name', 'Molecular Formula', 'METLIN ID', 'Precursor Adduct',\n", + " 'CCS1', 'CCS2', 'CCS3', 'CCS_AVG', '% CV', 'm/z', 'Adduct', 'm/z.1',\n", + " 'Dimer', 'Dimer.1', 'dimer line', 'CCS', 'm/z.2', 'pubChem', 'inchi',\n", + " 'smiles', 'InChIKEY', 'Instrument_type', 'CE', 'Metabolite', 'group_id',\n", + " 'num_per_group', 'loss_weight', 'ring_count', 'rare_element_included',\n", + " 'abs_elem_distr_vec', 'summary', 'geo_data', 'weights'],\n", + " dtype='object')" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccs_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAJ3CAYAAAB4GatyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUxf/A8ff1XHrvpBJ677333qSjCHbsvSLqV1F/ig0RK0gHRYo0QUrovZdQ0hPSe7vLlf39ceTCcReKoqDO63nyQHZnZ2c3C9nPzcxnZJIkSQiCIAiCIAiCIAh/ivxON0AQBEEQBEEQBOHfQARXgiAIgiAIgiAIt4EIrgRBEARBEARBEG4DEVwJgiAIgiAIgiDcBiK4EgRBEARBEARBuA1EcCUIgiAIgiAIgnAbiOBKEARBEARBEAThNhDBlSAIgiAIgiAIwm0ggitBEARBEARBEITbQARXgiAI/zLx8fHIZDLkcjk5OTkOyyxatAiZTIZMJmPRokUOy+Tk5CCXy5HJZMTHx//h9syYMQOZTMaMGTP+cB1X27FjBzKZjG7dut2W+v5tysrK+Pzzz+nXrx/BwcFoNBpcXV2pW7cuEydOZM2aNZjN5hqPP3DgAI8++igNGzbE09MTtVqNv78/Xbt25X//+x8pKSkOj1u9ejVDhgwhODgYtVqNh4cHtWvXpl+/frzzzjucOXPmr7pkQRCEu4byTjdAEARBuL2io6OpVasWqampxMbGMmrUKLsy27dvt/59x44dTJw40a7Mjh07kCSJWrVqER0d/Ze2+e8ik8kAkCTpDrfkr7F582YmTpxITk4OSqWSli1b0rlzZ4xGI/Hx8SxevJjFixfTunVrDh48aHNseXk5DzzwAEuXLgUgMDCQTp064eHhQW5uLgcPHmTnzp288847LF++nGHDhgFgMpmYNGmS9biGDRvSpk0btFotKSkp7Ny5k99++42ioiI++uijv/V+CIIg/N1EcCUIgvAv1L17dxYsWMD27dsdBlc7duzAz88PjUbDjh07HNZRtb179+5/qi2PP/44Y8eOxdfX90/VI1zf+vXrGTp0KCaTiSlTpjBz5kz8/f1tyqSkpPDee++xYsUKm+0Gg4G+ffuye/dugoKCmDt3LkOGDLEpYzQaWbVqFa+++ipJSUnW7XPnzmXp0qW4ubmxZs0au+elvLycdevWYTAYbu8FC4Ig3IVEcCUIgvAvdHVwda3U1FQSEhIYNWoUGo2GxYsXk5qaSq1atWzKVR37Z4MrX19fEVj9xfLy8pg4cSImk4knn3ySzz77zGG5sLAw5s6dy/jx4222v/POO+zevRtPT0/27NlDZGSk3bFKpZJ77rmH/v37c/HiRev2ZcuWAZYg2tGz4uzszOjRo//M5QmCIPxjiDlXgiAI/0JVL7nnzp0jKyvLZl9Vj1S3bt3o2rWrzbYqWVlZnDt3zqauKpcvX+bZZ5+lfv36ODs74+bmRuvWrZk9ezZGo9GuLdebcyVJEj/88AOtWrXC2dkZHx8f+vfvz969e29qbpXBYOCDDz6gYcOGaLVafHx8GDFihLXt17ahStV8s6qvq3tiHPn666+RyWT069evxjJ5eXloNBrUarXNXLcjR44wZswYQkNDUavVuLu7ExUVxciRI1mzZs11z3uzZs+eTWFhIf7+/nz44Yc3LN+lSxfr30tKSqzB2PTp0x0GVldzdXWlefPm1u+rnq9re8kEQRD+i0RwJQiC8C8UHh5ufUm+NnCq+r5r167W4OraHq6qMpGRkYSHh1u379y5k0aNGvHJJ5+g0+no3bs3HTt2JD4+nieeeIKBAwfe0vCvadOmMXXqVI4dO0abNm3o06cPqampdOnShXXr1l33WIPBwIABA3j77bcJCwtj4MCBuLi4sGrVKjp06GATMDVr1oz77rvP+v19991n8+Xq6nrdc40dOxatVsuWLVtIT093WGbJkiVUVlYyePBg/Pz8ANi6dSvt27dnxYoV+Pr6MnToUHr16oWfnx/r169n3rx5N3mnrq8qSBszZgwajeaWjt2+fTvFxcXIZDLuvffeWz53WFgYAPPnz6eoqOiWjxcEQfhXkQRBEIR/pSlTpkiA9PDDD9tsj4qKkvz8/CSz2SxJkiQFBgZKkZGRNmUeeeQRCZCmTJli3ZaRkSH5+PhIMplMmjNnjmQymaz7cnNzpR49ekiA9NZbb9nU9eabb0qA9Oabb9psX7NmjQRIrq6u0p49e2z2ffzxxxIgAVLXrl1t9m3fvt26r3nz5lJGRoZ1X0VFhdS3b18JkB566CG7e1J13B8xYcIECZBmzpzpcH/z5s0lQPr111+t27p37y4B0qJFi+zKFxYWSvv27ftDbbmawWCQ5HK5BEgLFiy45ePfeOMNCZCioqL+0PlXrVplva8eHh7SxIkTpTlz5kj79++X9Hr9H6pTEAThn0r0XAmCIPxLVQ3nu7pXKiUlhYSEBLp06WIdJte1a1cSExNJTk62lnM03+rTTz8lLy+PadOm8eijjyKXV/8K8fHxYcGCBahUKmbPnn1T2fiqhqI98cQTdOjQwWbfs88+S+vWra97vEwmY968eQQGBlq3OTk58dZbbwHw+++/37ANt2LKlCmApYfmWidOnODYsWMEBgbaDB2sGjI3YMAAu2M8PDxo167dn25XXl6eNbX6HxmaVzWE8Y8O6xs2bBjff/89Pj4+FBUVsWjRIh577DHatWuHh4cHI0eO5NChQ3+obkEQhH8aEVwJgiD8S1UFRhcuXCAjIwOwHRJY5dp5V5mZmZw/f96mDrBkowPL0DNHQkJCiImJIScnxybhgSNGo5G9e/cCMGHCBIdlrk26cK2wsDCaNm1qt71+/foANQ7f+6O6d+9OREQE58+fZ9++fTb7qob33XvvvSiV1bmi2rRpA1iucffu3Q7npP0bTJkyhZSUFJYvX84jjzxCq1atUKvV6HQ6fvnlF9q3b8933313p5spCILwlxPBlSAIwr9UVbAD1T1RVyezqHJtcFX1Z0xMDCEhIdZyCQkJAHTu3NkuIUTV19mzZwFqXLy4Sm5uLjqdDoCIiAiHZWraXqVqrs+13N3dAdDr9dc9/lbJZDImT54MYDNXymAwsHjxYgDuv/9+m2NmzpxJixYt2LhxI507d8bd3Z1OnTrx+uuv2yXd+KN8fHysvYjZ2dm3fHzV/LA/cuzVqrICfvXVVxw6dIj8/Hx++uknYmJiMJlMTJs2jbS0tD91DkEQhLudSMUuCILwL9a9e3cuXrzI9u3bGT9+PDt27MDHx4dGjRpZyzRo0AA/Pz9rAFZTCvaqoWejRo3CxcXluuf18fH5022/OrufI1cPS/y7TJ48mbfeeosVK1bw2WefodVq+fXXX8nNzaVdu3bUq1fPpnxgYCCHDx8mNjaW33//nT179nDgwAH27NnDe++9x8yZM3nppZf+VJuUSiVNmjTh+PHjHDp0iEmTJt3S8S1btgQgMTGRvLy82/KzA3BxcWHUqFG0b9+eOnXqUF5ezsaNG3nwwQdvS/2CIAh3I9FzJQiC8C929byrlJQUEhMTbeZbVenSpQvJyckkJSXVuHhw1TpYL730EvPnz7/u17VBxrV8fHysWe2unut1tRulR78TwsPD6dGjB0VFRfzyyy9A9RysqjlZ16pKJ/+///2P7du3k5+fz1dffYVMJuPVV18lPj7+T7dr6NChACxfvvyWe+y6d++Om5sbkiSxYMGCP92Wa4WEhNCgQQPA0mMpCILwbyaCK0EQhH+xquF/8fHxLFq0yGbb1aqGBi5evJgLFy44LNe/f38AVqxY8afbpVKpaN++PWBJYe7I0qVL//R5HJ0X+FNzn65ObJGVlcXGjRvRarU1zkW7lpOTE4888ghNmjTBbDZz8uTJP9yWKk888QQeHh5kZ2ffVE/Yrl27rH93d3fnySefBODtt98mMTHxuseWlpZy7Ngx6/c3Sl5iMpms899CQ0Nv2DZBEIR/MhFcCYIg/IsFBgZaEzx8/PHHwPWDq1mzZgGWpBBXZ+EDeOGFF/D09GTWrFl8/PHHVFZW2tWTmJhoDeJupOqF/vPPP2f//v02+z777DMOHDhwU/XciqqX+zNnzvzhOkaMGIGnpyfbtm3j3XffxWg0MnLkSOtcr6t99NFHpKSk2G2Pi4uzJv24eh2x9PR06tWrR7169W4pIUdVtka5XM5nn33GAw884HAOVXp6Oo8//jjDhg2z2T59+nQ6dOhAYWEhnTp14tdff7U71mQysWrVKlq2bElsbKx1+6BBg/jggw+4fPmy3TGFhYU8+uijZGRk4O7ubg3QBUEQ/rXucCp4QRAE4S/22GOPWdch8vb2tq5vdTWz2Sx5e3tbyz322GMO64qNjZV8fX0lQPL395d69OghTZgwQRo0aJAUHR0tAVLbtm1tjqlpnStJkqSHHnpIAiSFQiF169ZNGjdunNSoUSNJoVBIzzzzjARIvXv3tjmmap2ra9e/uho1rGf1/PPPS4Dk6+srjR49Wpo6dao0depUKTc3t8a6HKlaB6zqa9u2bQ7LeXh4SIBUr149afjw4dL48eOlbt26SUqlUgKke++916Z8YmKitc7ExMRbapMkSdKGDRusPx+lUim1a9dOGjNmjDRy5EipWbNmkkwmkwCpXbt2dseWlJRIo0ePtp4/KChIGjRokDR+/Hipb9++1udDo9FIq1evth7XtGlTCZBkMplUv359adiwYdLYsWOlbt26SS4uLhIgabVam2MEQRD+rURCC0EQhH+57t27M2fOHACH863AMi+oc+fOrFmzxnqMI126dOHMmTPMnj2b9evXc+jQIfR6Pf7+/oSFhTFx4kRGjhx5022bO3curVu35quvvmL//v04OTnRpk0b5syZY51z5evre4tXXLN33nkHuVzOL7/8wurVq629b6+//votJXKYMmUKc+fOBSxZDR31BgJ8+eWXbN26lUOHDhEbG0tZWRmBgYH07t2bhx56yDpX6nbp378/iYmJfPfdd2zYsIFTp05x9OhRlEoloaGhTJgwgbFjxzpcd8vV1ZXly5fzzDPPMG/ePHbt2sXOnTspLy/H09OTRo0a0bdvX+677z6bLJIrV65ky5YtbNu2jbNnz7Jr1y4KCwtxdXWlXr169OzZk8cee8ymh04QBOHfSiZJN7HSoyAIgiD8zaZMmcK8efP4+OOPefbZZ+90cwRBEAThhsScK0EQBOGOOXPmDGVlZTbbzGYz3377LfPnz8fJyYlx48bdodYJgiAIwq0RwwIFQRCEO+b//u//WLFiBc2bNyckJISysjLOnj1LUlISCoWCOXPmEBQUdKebKQiCIAg3RQRXgiAIwh0zZswYiouLOXLkCMePH8doNOLv78+YMWN4+umnadeu3Z1uoiAIgiDcNDHnShAEQRAEQRAE4TYQc64EQRAEQRAEQRBuAxFcCYIgCIIgCIIg3AZizlUNzGYzly9fxs3NzeGaMIIgCIIgCIIg/DdIkkRJSQnBwcHI5TX3T4ngqgaXL1+mVq1ad7oZgiAIgiAIgiDcJVJTUwkNDa1xvwiuauDm5gZYbqC7u/sdbo3wRxgMBjZv3kyfPn1QqVR3ujnCXUY8H0JNxLMhXI94PoSaiGfj3624uJhatWpZY4SaiOCqBlVDAd3d3UVw9Q9lMBhwdnbG3d1d/Ccn2BHPh1AT8WwI1yOeD6Em4tn4b7jRdCGR0EIQBEEQBEEQBOE2EMGVIAiCIAiCIAjCbSCCK0EQBEEQBEEQhNtAzLkSBEEQBEEQ/jSTyYTBYLjTzbhjDAYDSqUSnU6HyWS6080RboFKpUKhUNyWukRwJQiCIAiCIPxhkiSRmZlJYWHhnW7KHSVJEoGBgaSmpoo1Uv+BPD09CQwM/NM/OxFcCYIgCIIgCH9YVWDl7++Ps7PzfzawMJvNlJaW4urqet1FZoW7iyRJlJeXk52dDUBQUNCfqk8EV4IgCIIgCMIfYjKZrIGVj4/PnW7OHWU2m6msrMTJyUkEV/8wWq0WgOzsbPz9/f/UEEHxkxcEQRAEQRD+kKo5Vs7Ozne4JYLw51Q9w3923qAIrgRBEARBEIQ/5b86FFD497hdz/BdF1zNnDmT1q1b4+bmhr+/P8OGDeP8+fM2ZTIzM5k0aRKBgYG4uLjQokULVq5caVMmPz+fCRMm4O7ujqenJ1OnTqW0tPTvvBRBEARBEARBEP5D7rrgKjY2lmnTprF//362bNmCwWCgT58+lJWVWcvce++9nD9/nrVr13Lq1ClGjBjB6NGjOXbsmLXMhAkTOHPmDFu2bGHdunXs3LmThx566E5ckiAIgiAIgiAI/wF3XXC1adMmJk+eTMOGDWnatCnz588nJSWFI0eOWMvs3buXJ554gjZt2hAVFcXrr7+Op6entcy5c+fYtGkT3333HW3btqVTp0588cUXLFu2jMuXL9+pSxMEQRAEQRCEf4UZM2Ygk8nYsWPHTZVPSkpCJpMxefLkv7Rdd9pdny2wqKgIAG9vb+u2Dh06sHz5cgYOHIinpycrVqxAp9PRrVs3APbt24enpyetWrWyHtOrVy/kcjkHDhxg+PDhdufR6/Xo9Xrr98XFxYBlUtt/eUG8f7Kqn5v4+QmOiOdDqIl4NoTrEc+HLYPBgCRJmM1mzGaz3f6kpCSio6NttqlUKgICAujUqRMvvfQSTZo0+bua+5eSJMn6p6N7cTcpKysjJCSEkpISHn30UWbPnn3LdVRdb00/+2tVlfk7709UVBQACQkJNyxrNpuRJAmDweAwW+DN/pu/q4Mrs9nM008/TceOHWnUqJF1+4oVKxgzZgw+Pj4olUqcnZ1ZtWoVtWvXBixzsvz9/W3qUiqVeHt7k5mZ6fBcM2fO5K233rLbvnnzZpEB5x9uy5Ytd7oJwl1MPB9CTcSzIVyPeD4slEolgYGBlJaWUllZabe/ar57ZGQko0ePBiwv9ocOHWLZsmWsWrWK1atX065du7+13X+lkpKSO92EG1q8eDElJSXIZDKWLFnC9OnTcXJyuqU6qjolysvLrZ0S11P1LBgMhpsqfztUBXE3c77KykoqKirYuXMnRqPRbn95eflNnfOuDq6mTZvG6dOn2b17t832N954g8LCQn7//Xd8fX1ZvXo1o0ePZteuXTRu3PgPneuVV17h2WeftX5fXFxMrVq16NOnD+7u7n/qOoQ7w2AwsGXLFnr37o1KpbrTzRHuMuL5EGoing3hesTzYUun05Gamoqrq6vDl3NXV1cAYmJieO+992z2vfHGG7z33nu8//77bNu27W9p719JkiRKSkpwc3O767MnLl26FKVSybRp0/jss8/4/fffGT9+/C3VodFoAEsK85t5V656FlQq1d/2bl213tjNnE+n06HVaunSpYvDZ/mmA0LpLjVt2jQpNDRUSkhIsNl+6dIlCZBOnz5ts71nz57Sww8/LEmSJH3//feSp6enzX6DwSApFArpl19+uanzFxUVSYBUVFT0J65CuJMqKyul1atXS5WVlXe6KcJdSDwfQk3EsyFcj3g+bFVUVEhnz56VKioqHO5PTEyUAKlv3752+zIzMyVAcnZ2tm4DpK5du0ppaWnSpEmTpICAAEkmk0nbt2+3lomNjZUGDRok+fj4SGq1Wqpdu7b02muvSWVlZQ7bEBsbKw0dOlTy9/eX1Gq1FBoaKg0fPlzatWuXtcx9990nAVJiYqLd8W+++aYE2LRh+/btEiC9+eab0p49e6TevXtLHh4eEiCZTCZJkiRp27ZtUr9+/aSgoCBJrVZL/v7+UqdOnaSvv/7a7hy7d++WBgwYIHl5eUkajUaqW7euNH36dIfXdDP36Hri4uIkQBo0aJCUnJwsyWQyqUePHjWWT0lJkcaOHSt5eXlJLi4uUpcuXaTY2FiH90WSJMloNErvv/++FB0dLWk0Gik6Olp67733pPj4eAmQ7rvvPofX40h4eLgUHh5ut12v10uzZs2SWrVqJbm6ukouLi5S/fr1pWeeeUbKz8+3PneOvt58802H57rRs3yzscFd13MlSRJPPPEEq1atYseOHURGRtrsr+qSu3bla4VCYe36a9++PYWFhRw5coSWLVsCsG3bNsxmM23btv0brkIQBEEQBEG4Gdf28uTl5dG+fXu8vb0ZO3YsOp3O2vPw1VdfMW3aNDw9PRk8eDD+/v4cPnyYd999l+3bt7N9+3bUarW1rs8++4xnnnkGrVbL8OHDCQsLIz09nd27d/Pzzz/TqVOnP9X2vXv38t5779G9e3cefPBB4uPjAVi/fj2DBw/G09OToUOHEhQURE5ODidOnGDhwoU2Gax/+uknxo0bh0ajYcyYMfj7+7N582befvttfvvtN3bs2GHXk3K9e3Qj33//PWDJvh0WFka3bt3Yvn07iYmJdu/dGRkZtG/fnvT0dPr27UuLFi04d+4cvXv3pnv37g7rf+ihh/jhhx+IjIxk2rRp6HQ6Zs2axd69e2/6vl5PRUUFvXv3Zs+ePcTExHD//fej0Wi4ePEiX3/9Nffeey8RERG8+eabfPrppwA8/fTT1uOrcjT8Za4bet0Bjz76qOTh4SHt2LFDysjIsH6Vl5dLkmT5xKh27dpS586dpQMHDkiXLl2SPvroI0kmk0nr16+31tOvXz+pefPm0oEDB6Tdu3dLMTEx0rhx4266HaLn6p9PfLooXM+/6fnIK9VLJ1MLpA83xUkf/xYnnU4vlArK9He6Wf9Y/6ZnQ7j9xPNh68/0XE2fPl0CpO7du1u3caV34f7775eMRqNN+TNnzkhKpVJq2rSplJuba7Nv5syZEiB99NFH1m3Hjx+X5HK5FBwcbNcjZTabpfT0dOv3f7TnCpB++OEHSZIkyWQySQUFBZLJZJJGjBghAdLx48ft6ru67UVFRZKHh4ek0WikEydOWLebTCZpzJgxEiC9/fbbNsdf7x7diMFgkAICAiRPT0/rz+yHH36QAOn111+3K191X/73v//ZbP/666+t7XB0X5o2bSqVlpZat6elpUm+vr63pefqueeekwBp0qRJdtdfWFgolZSUXPf4mtyunqu7LhX7V199RVFREd26dSMoKMj6tXz5csAyTnPDhg34+fkxePBgmjRpwoIFC/jxxx8ZMGCAtZ7FixdTr149evbsyYABA+jUqRPffPPNnbosQRCEv0RuqZ531p1l8Ow9fLn9Ep9vu8TAz3fz0eYL5JXqb1zBbVRpNJFWUM6Z9CIuZZdQUGY/uT2zWEdcRjFxGcVkFlVYs00JgvDvdunSJWbMmMGMGTN44YUX6NKlC2+//TZOTk68++67NmXVajUffvihXca2r7/+GqPRyBdffIGPj4/NvhdffBE/Pz+WLl1qU95sNvO///2PiIgIm/IymYzg4OA/fV0tWrTg/vvvr3G/Vqu123Z129esWUNRURFTpkyxyZool8v58MMPUSqVzJ8/366Omu7Rjaxbt46srCzuuecea2/YqFGjcHZ2Zv78+TZZ/CorK1m+fDn+/v4899xzNvU88MADxMTE2NW/YMECAKZPn46Li4t1e0hICE899dQttdURo9HIN998g4eHB5999pnd9Xt4eFjndt0pd+WwwBuJiYlh5cqV1y3j7e3NkiVLblezBEEQ7kpHkgtYdSzdbvui/cn0axRIp9qav6UdBWV6VhxO47OtFymvNAHQPMyTT0Y3I8LXhUqjiaMphTy34gTphRUABHk48X+jmtAqwhsn1a29INwOWcU6ckv16I1mfF01+Lmq0arvul+LgvCvEB8fb83KXJWKffz48bz88st2ycgiIyPx9fW1q2P//v0A/Pbbb2zdutVuv0qlIi4uzvr9wYMHAejTp89tu45rtW7d2uH2sWPH8ssvv9CuXTvGjx9Pz5496dy5s911HTt2DHA8VC0sLIyoqCguXLhgTZRRpaZ7dCPfffcdYBkSWMXNzY1hw4axZMkSfvvtN/r37w/A+fPn0el09OjRw25Yolwup2PHjly8eNFm+4kTJwDo3Lmz3bkdbbtVcXFxlJSU0KtXL7y8vP50fX8F8VtEEAThH6qowsA3O2teu+P7XQm0CPPE+S8OGCRJ4rezWczcGGez/VhKIeO/3c/KRztQVmlk0vcHMJiqP0DLKNJx37xDbHiyM3UD3a6t9i9jMkucvVzMwwsPc7lIB4BKIePRrrWZ3DECN/XdneVLEP6J+vbty6ZNm26qbEBAgMPt+fn5AHY9XTUpKipCJpMRFBR0c438A2pq6z333MPq1auZNWsWc+fO5csvv0Qmk9G9e3c+/vhjmjVrBlRnoKupnqCgIC5cuEBxcbFNcFVT+eu5fPkymzZtIioqym6u2b333suSJUv44YcfrMFV1Vqz1y5vdL02FBUVIZfLHQZ+f6TNjuoHS0/Y3equGxYoCIIg3ByjyUxRRc2LGhaWG2yCmb9KVrGOWZsvONx3uUjH+awSfj6c5rAtJrPENzvj0RlMt3ze3BI98dmlJOSUkl9280MgMworGPvNPmtgBWAwSXy+7SLb47JvuR2CINxeNaUxr0rYUFxcjCRJNX5V8fT0RJIkMjIybnjOqkRpjtY3qnqhv5W2AgwdOpTY2FgKCgrYuHEjDzzwADt27KBfv34UFhbaXFNWVpbDOqrWZ702WcUfSfU+f/58TCYTCQkJyGQym69+/foBsHbtWnJzcwHLEDuA7GzH/y86arOHhwdms9lax43KV12Lo/sO9vfe09MTgPR0+xEbdwsRXAmCIPxDuWuV9Kjn+BNFgN4NAnDV/PUDFPRGM9klNQc3p9KKyLnO/K9T6UWU6R3/Yq2SW6LnYGIeb6w+xcJ9SRxIyGPst/vpOSuWHh/Hct8Phzh7uRiT+cbB5N6EPMoqHQdzn/x+4bptFQThzqnK+Fw1PPBG2rRpA8DmzZtvWLZqiJmjl/aqoXt/lJubG/369eObb75h8uTJZGVlceDAAQCaN28OwI4dO+yOS01NJT4+nqioKJteqz9CkiR++OEHACZPnszUqVPtvjp06EBlZSULFy4EoE6dOjg5OXH48GF0Op1NfWaz2WH2v6ZNmwKwa9cuu32OtoHl3ju670lJSdYgtErdunVxd3fn0KFDFBQU3PC6FQoFJtOtf3j3Z4jgShAE4R9KpVAwoW0Y7k72AZS3i5rBTYNRyP/6IW4qhdxhG6oEe2qvO6cq3Nvluvuzi3U8u+I4o7/ez09H0gjzdmbi9we4lF1qLXMqvYhRc/eSVmBZrqMqucbeS7nEXsgmJa+M8kpLAHcmveZPodMKKjAaRZINQbgbPfbYYyiVSp544glSUlLs9hcWFtoEQo888ggKhYLXX3+d5ORkm7KSJHH58mXr91Vzp65NHvHzzz8TGxt7y23duXOnw5f6ql6gqjlMQ4cOxcPDg3nz5nHmzBmb9r300ksYjUYmT558y+e/VmxsLPHx8XTp0oV58+bx3Xff2X1VBV9Vqdo1Gg2jR48mOzubjz/+2Ka+7777jgsX7EcsTJo0CYC3336bsrIy6/b09HQ+++wzh21r3bo1SUlJNve5srKSZ5991q6sUqnk4YcfpqioiKeeesruHhcVFVFaWv27wdvbm9zcXLvg8K8k5lwJgiD8g9XycmbVYx35YFMcv5/LQiaT0b9RIM/3qUstb2dySvQYzWa0KgWezmpyS/SkF1ZwKCkfH1cNLcO98HfT/KmEEv5uGh7oHMWsLfa/aN2dlNQLdKOWt5bFB+xfhgAe7R6Ny3V62Ladz2bnRcsQk8FNgvnpiOMhhuWVJlYeSePhLlFsPZ/Diz+fQGcw0yjEnYltw4n2cyXIQ0PjEI8azxXm7YxSKeZcCcLdqFGjRsyZM4dHH32UunXrMmDAAKKjoykpKSEhIYHY2FgmT57M3LlzAWjcuDGffvopTz75JA0bNmTYsGGEh4eTmZnJzp07GThwoHUdpKFDhxIdHc38+fNJTU2lefPmnDt3jm3btjFgwAA2bNhwS2198sknuXz5Mp06dSIiIgKZTMbu3bs5ePAg7dq1s855cnd359tvv2XcuHG0bduWMWPG4Ofnx++//86RI0do06YNL7zwwp++d1UB0/UyG9atW5cOHTqwd+9eDhw4QNu2bXn//ffZunUrr7/+Ort377belw0bNtCnTx+7XsHu3btz//33M2/ePBo3bszw4cPR6/UsX76cdu3asW7dOrvzPvvss2zevJkBAwYwbtw4nJ2d2bJlC56eng7ny7399tvs37+fhQsXsn//fvr3749GoyEhIYFNmzaxe/du65y2Hj16cPjwYfr370/nzp1Rq9V06dKFLl26/Im7eX0iuBIEQfgHk8tlRPu7MmtMU4oqjMgAD60KncHEL0fTmL3tEhlFOhqFuPNC37ocSMzj483V2Z1UChlzJrSkc4xvjQFWeaWRjEIdv564TGpBOd3r+dMizAuVQsb5zBJ+P5vF4KbBJOWG8MtVmQu71vHjmd51+Co2Hn83DR+MbMz0NWfQGy2pfjVKOTOGNCTGr+a0uXmlen7YnWj9PtrPlaWHHAdpAPsS8hjWIoSnlh1DkmBi2zAaBLvz2daLZBTpkMtg8QNtcXdSUqyzH4r4XJ86+Ln+PRkWBUG4dQ8++CDNmjVj1qxZ7Ny5k19//RUPDw/CwsJ45plnuO+++2zKP/744zRq1IiPP/6YjRs3Ulpair+/P23btmX06NHWclqtlt9//51nnnmGrVu3sn//ftq1a8fOnTtZt27dLQdXr7zyCr/88gtHjhzht99+Q6VSERERwQcffMBjjz1mk0L8nnvuITAwkJkzZ/LLL79QXl5OREQEb7zxBi+99JJdpr5bVVRUxMqVK3FxcWHUqFHXLXv//fezd+9evv/+e9q2bUtQUBB79+7lxRdf5LfffmPnzp20bNmSLVu2sG3bNodDLr/99lvq1KnDt99+y+zZswkNDeXZZ59l9OjRDoOrPn36sGLFCt5++20WLlyIt7c399xzD++99x6NGjWyK+/k5MSWLVuYPXs2ixYt4ttvv0WhUBAWFsYjjzxik3b/jTfeoKCggHXr1rFr1y5MJhNvvvnmXxpcySSxyIhDxcXFeHh4UFRUdNMrXgt3F4PBwIYNGxgwYAAqlepON0e4y/ybn49inYGPN5/nx73JdvveH9mYzWeyGFxbRRNvI3KziWyjlvDwaAK9XOzKZ5foyCnRcyq9iNXH0tmfYMnWFeThxCejm/HggsOU6I2EeGgZ27YWPev5k12ix99Nw66LuZzLKKG2vyv1gtw4mpzPgMbBXMouxSxJNAn1INTL+bq9ZlnFOoZ/uceafOLhLlEcTSngUJJlrL27k5IBDbzxdZJxJLOSAHctbSO9eWXVaaJ8XXisezTP/3QSsPRK9azvT5C7Ew1DPHh11SmS8yzDCDVKOU/3imFs6zBc1bLrPxsGHeiLQaEGrect/WyEf75/8/8df4ROpyMxMZHIyMg/HQT805nNZoqLi3F3d7cmyBD+OW70LN9sbCB6rgRBEP5lckv0DgMrgPXH0/m6nxbnXx+F7LMARLr4ouv1Pmj7gpPlF0aZ3kBKfjmJOeUcTytkW1wW/RoFMaZ1GC/8dIKMIh1f70zghX51CfHUklZQQUWlCblchlwmY8RXe9EZqhejdNMo+WRsM7JLdMz49TRyZKye1pHzmSWsPpaOySwxuFkwkb4u+F7Vc+TprKJHPX8WXRlSuPbEZZ7tXYdDSQW80CWA4WHl+J35ElVeFkWR3dE0HcXbuwsBGN82jLmxCagVct4a2hBvZyUuhgIUsgpMBg3zJrdGbzRTaTTj7aLG302DRqXAYLDPwFhpNFFaocOjIg35/i+RJe8GF3/o9CyEtAQXH7tjbqj4MmSegrj14BoAjUaCewg4OZ64XqIzUFFpQqtW4OYkXuoFQRDuRiK4EgRB+Je5kFVa4743urjjvKifpeelSlkuTmseAK/1ENGJvFI9W85l8e3ORHJLdLSJ8uHlfvX45Vg6cRnFPN6jNp/+fhEXjQJXjZJHFh2xzoHyc9Pw/sY4m8AKoERv5H/rzvLx6KYo5XLeH9GYL7Zd4qcjadYyC/Yn06u+PzNHNMHPzRJgaZQKHugcxdoTlzGaJTKLdWQU6fhmdB3a5a7E/eeZ1uM9kvfC0Tm8NH49G06rCPbUcim7lJnDG9PSW4d/8no8zywAQzkVUf3Ib/owzj4RBHo4X/d+puSX88vRNMbXykPx01AwXskmmBcPS+7B3P4JDB2fQ+N6CwtaFqXBopGQc9XaYDs/hAEfQdOxoKkOsEp0Bi5klfDZ1ktcyiqhdoAbT/WoTUygG+5/UZBlNFkyQOaU6DGZJfzdNfi5WoJPQRAEoWYiuBIEQfiX0aodD0dpEuqB3+XttoHV1X5/C/3opXy8NYOfDqfyYtcA+oS7oy5ORjKX06RbKK9syaVRiAdalZyRLUKZ8uMhqgaXy2Tg6qSsMZV5Ul45aoWcNwbUR6WQ2wRW1iacy2ZIQh5DmgZbt7lqlCx5sB1JuWVo1QqScsvoEKDHde1Mu+OpKMB9xxs81OZ1Kgwmavu50C3EhN/6R1BmHKm+RyfmE3J+NQUTfyNXEYGvq+PhTCn55Qz/cg/Pd/bFf8fL1YHVVeT7vkDfcDx6hSvu2psIdox62P2ZbWBVZcPzENXVGlxVmkxsOZvFsytOWItcLtKx80IOs0Y3ZVDTINSK2xvw6Awm9sXn8dTyYxRXWOalOankvDGoAYObBN/cNQqCIPxHieBKEAThXybazxUnldyu9yjcW4tXzsGaD8w+g6mynGUHU1gyLpIWp95FvfeqyceuAXx+zzLWZ+kZ0DiInRdzuHrWrlwmw2A029d7lVK9EX8PJ8orTchkWI9vVsuTcW3CcNUocdEoyC3V4+uqIa2gnMcWH+VkWnX69CFNgpisPlpdqUIF9QaBXz3QFSI7s5rJfdx5e1cez/Wpizb/qE1gZaUrxPng51xoMR2N0sduqF2l0cSCvUnklVXSzBfYcbzG66pM2EO+qtZNBR6GkmxUxxfWXCBuA3SqA0BOsZ7pa844LDZ9zRnaRnoT4nX9nrdblVZQwQMLDtusGaYzmHlt1Wlq+7vSNvIPDIEUBEH4jxCz7QRBEP4i2SU6LmWXkpBbSkFZ5d92Xn83DbPHtbBb46rCaMbkW7/mAz1qkV1uZmBDX5qkLkJ98ZqsTqVZuCwbQd8wI25OSrKKbdcNMZklnNQKVArHqcyd1QqKK4zE55QRn1NK1xg/AKZ2imR48xC2x2Wz6/xlftiTwJtrTpOSX8brq0/bBFYAF3NKKau4cu5abWHcclA5w5lVkHUWek7HWaXk2b51aR/lhcf5n2q8ZM2F9XjJSskttf/5ZBTpaR3hzYgWITecnC7JlKw+nobJVHNwqTeYOJpcQEJWMRgqaq6sPN/619zSSkprWGC5VG902O4/w2gys2h/co2LMX/2+0WKK+znpAmCIAgWoudKEAThNqswmDiWXMArV2WjaxLqwYejmlDH3w25XIbZLFFWaUStkN/2eSxqpYJOMb5sfqYLa45d5lJOCR1r+9K1jh9ykyfs/gjM9i/spe2eI65Yw+QmWpzXza/h4gpQ5cXxUOfuxF7MYcOpTJvd605kcG/7CL6/Kn16lYe7RrPyWBr1A93RG00MbR5CdomedhHuRKsLGF66GffcY5QG1ScvegTfbItjYOMgdpzPsannUnYpRYHtcXcPgU7PwLLxYLwSbOXEQWIsdHoW/05PU2hywqTQogxoBO2nWYbbmU2gUMLxpZB2iJxSA3K5JWCoNJqIy7AMmxz4xS4kFAxoHISLpy9SrXbIUvfb3xOZjLKAlpzbU4LRLFHTKL3E3DJGf72PV7oHElOrPfLUfY4L1u1n/euNFoG+3YtEVxrNnM8qqXF/Ym4ZFQaTGBooCIJQAxFcCYIg3GYJOaVM/P4AV3/4fzKtiNFz97H+yc7IZLDhVAZbz2Xj46pmSsdIwrydKas0ciAhH7MEbSK98XNT46FV/6E2OKkURPu58myfOpjNEvIrL+Hl5cHIRi1Fu2Zq9dwrmZzS1o+zsawO3s5yXGRGqCyrsW5d5kWe3ePFO0Mb4euqtuk9WX08nZf61eXje5rw5fZ4kvLKqO3vypSOkdR2MzCqlgJ/RQZypRMyeSn9xgZh0BfgvrC3tTfHld9wPTSbZ4cv4YQyGC9nFQXl1b0lBpPE+iSJh/q9jzz2g+rA6mq7ZyE1GY2uUotr20ehKNEyn6k027Jf6QSdnsbcbAJf7ivklYG1AEjIKWP8t/t5t5WlWKXJzOrj6STnl7Fs2MdofuwHetvgo6jja8w/UU6PeoE1BsqlOgNfbr/E4KbBGFSulHR7G4/F/e2D3NA24B1t/dbHRY2Pi5o8Bz2fVftuJ41STpMQD/bF59lsd9UoGdkihF4NAqioNFFYXomn8+09tyAIwr+BCK4EQRBuo1K9gU9/v4CjUVXFOiO/nrzM4aR8tsVV98ZsOJXJA50iMUsSP+xJsm5/oFMkj3WPxlurBJMBlBpL1ggHSnQGiioMIIG7VmXTsyC/qncjtdhEiqkBzSftQFaUgmQoR+5bm0qNN375EmqFHE+NB7j4QVmOo1Oh921I3J4SPt1ykYVT2/L2r2fZl2B5GQ/3caaWtzMqhYzxbcMIdHcirbCCIGUJDRMWo63bE7a+A5ePAaBVOaPt8CR0fRl+f7P6JGYj3hseptX9O2gS6knsBdu2fLgzi6lPxiC/Uo8jsvMbCTy/AWnwZ/DLg7bJKIw62PE+snHL8HJxwsdVTYnOwP9tPo/BwQ/vWEohm7PD6TU1FuPRJbil78LgEkhBkwfZW+TN8bhCHuwVUGNbSnVGRrYMZeWRNNacuIzJ4MPUyb+j2j4DRdJOcPJAavMwspaTwa26ngB3Jz4b24zJ8w5hvKpdSrmMT8c2w9/99q4rpFDIGdO6FvP2JFFpMiOXwePda9O/cRCp+eXoDCb2xueyPyGPR7vVJsbfFaVCzDAQBEGoIoIrQRCE26hMb+J4SlGN+w8k5BPoYftC3DLci3pBbsT4udKvURDnMor5dmcCeYWFaAsvwc5FkHcewjpgajiCDPxJLtDh6awiwF1DUYWRmRvOsTXO0ivTJcaPl/vXI9DDCa9rehcyinQsOZzBg+ezcVLJUcmVlOgv4eem4eN7mvL4kqN8f19LfDu/hHLT8/YX4B3FJVMAheUprD+dwbQetendwJ8X+9VFkiQyi/R8uvUCT/aMYWtcNvvi84j2c2F5p0y04S1hzTQoyaiuz1AOse9D77ehVhtIvSrhRkUBFfmXebBzHXZfyrWZB9SzXgD5OomawxlAJgevCGQnVzjM8gcg2/E+/xu9FI2zmoyiCvZeynNYDmDTmWwkAqjb5AmS/UdTy8+LfcllJOeVMbVzZE1xL2azxNnMEh748ZA16D6XUcL3+9XMG/c52vYVIJMTHRWFQmH7a1kul9E6wptNT3dhyYFkzmWUUD/IjfFtw6nlpb3twwIBwp0q2Pd4AxYeyycs0I+DifkM/HyXte21vLW8PaQRz644zuxxLYj2d73tbRAEQfinEsGVIAjCbaRWyAnw0NSYjjzA3YnC8uohXg91iSLQ3YlLWaV4OqvZeykXncHE7LGNqFeyD6fvBoJ0JUnCpa0ods9CMXwlL/9aQVpBBYumtuWxxUctvVZXxF7I4UhyAfMmt6aWt7NNMGcwmdl+3hKE6QxmdFjqzinRs+Z4Op3r+DFi7n72PNEf724lOO39GCot62aZwjuT3OkDnl1uCY6c1QrkctCqlfxv/TlMZome9f15tndd3ll/hi/HtyC3pBIvWQm+hz+HhsNsA6ur7Z8D3V+zDa4Ak6GSbRezeGtwQ/LK9CTnlWOSzPRvFMzmhMtMDG2NLO2QfX0yGQQ0gKxTkHep5h9Y3iU0kuVnJZfJ8HRWkV/qOIGEv5uGjCId7aK8Kfb2Y8Q3B6kwmAD4cV8yvq5qlj/U3i7YyCrR8dLPJ+16M/PLKhm/4BwfjW5KuLczCpkcitItwzUVGsvCxE4eaFQKavu78uqA+uiMJpyUipvqLao0mqxrVcllMvzcNPi7aWo+tjQHEmNR7PkUn7IcngrvSKnvM6w5UmzT9tT8Cp776QTvDG3E1zvjeWtIQ7Rq8TohCIIAIrgSBEG4rbxc1DzRI4aHFzpI/Q30aRjAtMWWNOKNQzwI8dSSkFuGi1rBAz8etpYbV1eG09pHqgOrKpVlBG17iuc7fsPPcXq2xWXbBFZVSvVG1hxPJ9LPhTGtauF6Jc34lrNZNbZ90+lMFkxtw6HEfD7cmcuIpmNoMXUYOTk5GBUatqWY+HJJmnXto/dHNObVX05xNKXQWsfx1EKi/VxYcH8b3lp3lsNJBXw/MhRUTpB7oeYbV5IJGnfbbUoNhUpfVh5N56N7mvDjviQah3owsW0Ec3fE46SWM37gJyjm9bWfI9bhSTj3q2Wx3rAONZ/XNwaS98KlrfjF9OGJHjG8tfakw6LDW4Sw8XQGlUaJhxcesQZWVXJLK3lq+TG+mtCSogoDSoUMbxc1+WWVNQbbZZUm3DRKotyMcHI5bHkdynItwWF0Txj4MXhFWG6HQo7rTQ7BK9EZ+O1MFtPXnKa80tJOD62KT0Y3pX1tX7TXzg0rz4ffZ8DxRdZNstMrcTu3lg9GrWVErhOXi6rntuWXVVKsM3A+s4QSnVEEV4IgCFeIgdKCINwdzCYoTIX47XDyJ8g6A2U1D9G6m7WO8ObBa4aJqRQyPrqnCeczS9BfWQtqXJtazNudSKfavszZEW8t66xW4GvMtAyZcyTnPI29TDSr5UEzX4kdk4PZO9GNHZODmdErCBe15cX5YFI+ZXojaYUV1vWnZDWNXbuyL7tYz7vDG2Mym/H3dCNT5seXZzX0/jGdmdszrYFVhI8zBpNkE1hVic8pY8PpTJ7qEUOv+gHkGp2p9IgEz7Cab5rWC4y26cmLOrzCN0dKqDSaKdYZuZhdyi9H0xn3zX4mtQ/n7SGNUAQ0gEd2Q8enIaYv9HkPpvwGWh84ugBS9kN4B1BpHZ+3zUOWYYkbnkP+XXdGhFdYU8Rf7ameMWQX65naKZLsEj35NaTWP51ezPmsEgZ9sZt+n+7inrn7qLzB2l/eLmqcUnfD6kcsgRVYFgC79DssGArFl697vCMXskp4/qcT1sAKoKjCwAMLDpOW7+C5KsmwCaysTAYCd73K4+287Xal5pcT7uP8h+Zc5ZXquZhVwvnMYjKLHSQkEYT/mG7duiGTyZDJZPzvf/8DYMaMGchkMkJCQjCb7f8f6dixIzKZjMmTJ/+pc0+ePJlGjRrd1L64uDhrO2UyGbm5uX/q3P9G4qMmQRDuPJMR0o/AkntAd9V8pdp9YOgX4BZ459r2B5jMZsK9nZk3uTXxOaVolAqCPJ1wUsppGOzB7G2XqDCY8HRWE+bjTOyVYXpVlHIZMuP11y+Sy8yMr6fEf/tLKBJ3WLdPiuhCrymzeGhNJm5OSop1Rsr1JjKKKgjzcWFUy1CWH0p1WGffhgFsPJ3Jros5fD2pFTIkHl98jGf71KVhiAff707kcmEFDYM9mD64Pp/+frHG9q05fhkZlvlCkYEeFHqPxV+fAk4etj/jK6R2jyFdPolc6wXekWS3fI5VOUGsO5fFtO61Ka4wEOjuRGaxDqNZIvZ8NmHezhxOKkAm09K55UNock4iP/ojJMVCnf4wdDZseBF2fQQjvoWNL0FxuuWEahfo/Bxkn4PCFMu2slxUW17lkXb/R+r5TCa0CcdJo7LMeTqTyYm0QjrWblHjulNVrg6mkvPKSc4rZ1iTAPpHKVEpZPwWr2f16Tz0RjMuagWRmlLY8qbjysrzLcP1jDpLNkWZAlIPgK4Q6vSz/Ntw8rA5pFRn5POtjodCmiVYsC+Z6YPro7o6Z3zS7pov6PIxmnWwD8ojfF1oGuqB9y1kLDSZJeIyi3n+pxOcy7BkXQz10vLe8Ma0ivDCWfSACf9hHTt25KOPPqJWrVrWbSqVitzcXHbu3Em3bt2s25OTk9m3bx+urn/vnMeIiAj27dvH+vXrrUGgYEv8LyYIwq3Tl1oyyZXnWXoEnP3Azf+P11ecDouG2w/turQZ9s2BHq+D8p+R9lmSJDacyuTNtWeQySDI3QmDWSKnRI9MBtuf68qGpzrz/a4ElHIZ7loVJde8rBfrjJS6hoFcYenRu5ZbIEqtB/47XrAJrAAUSTsJ2vEc/zfoc8xOnny4MY5mtTyZs+MSM0c0JtLXhf4NA9l4xnZ9Kj83DUObhfDAj4epNJlJzS/HP8yTJ3vVQSaDwnIDr/SvT4SvM0q5DNO1wxXt7oPlz+lrT7P+iU4UqkPQKmW4jpqH7OqkFjIZxiYTMTaZRHJeGT4N7yNfB2/vLKSel5Ed9wURkLIcU3Y2/fv24aIsggM5KhRyOb0/2YnJLDFvVC0Ua95AnnzVvbjwmyVBxuBPYdXDVLR+HPnEtSgrcpGb9Mj0xZaerYubbe9fwlZUzSzBX1xWMeUGWHviMuE+zrSJ8EatkBPm7YxMVn2NNj8ajRLzVTs8nVU0di9loP8mVHsWglFP+9oDeWzyo0xdm8sTPWLQyCqhwH5dMNwCYegc2PY2xG+1nNAtCLo8bwkIv2wDPadDq6mg9bQeVm4wkpBbWuPPJi6zGJ3BbBtcKTU1lkcmQ5LZ9k4FujsR4uFEnUD3Gg5yLK2gnNFz91F2VY9aWkEFk+cdZO3jnWgU4nGdowXhr1VUXkluqWXIq7tWha+LGo+/cckBT09P2rVrZ7NNrVbTq1cvli5dahNcLVu2jIYNG6KoaWG9K5KSkoiMjCQxMZGIiIg/3UYnJyfatWtHXFzcDctGREQwY8aMP92z9k8jgitBEG5NaTbsmgWHvq1eo8e3DoxZBH51/1id6UdqXlfp8PfQ9kHwqOV4/10mp0TPt7sSAMu78NXzVCQJVhxO48V+9XhjcANKdEbOXC4mwN2JNcdth37NP1HOi22fx33fB3bnyOs6E7lRhyJhm8M2KJJicWlXwD3LLvH1pJYsPZCMq0ZFRpEOP1cNbw5pwJBmwczfm0RZpZHOtf1oE+nNq6tOUWmyBE2n0ovYei6LDaczUSvkfD6uGSn55by88iQleiNRvi5M6RTJnhqy6/VtGMCuizlIEmw6k0ns+Rxq+7vyYteGuI5fi7qygMryEgrUgbh5+OBelk6dPW8hyziBr3swX/d6H03uWZRLXgEsv6wCTyzA378hTUYuocVnZzGZJSJ8nGlkikN9dWBVJfUg5sZj0D1ylLe2ZbFiyXl61vPno4izeG5/2fEPUJKQXQkcU/LKmTUgkPDKeFyztqBxjUJRpCLQxZ/vR8ew9VIRv57Jp1hXHRw/1DWKnw6nWYOvb4YFE71pEuSct5bRnlpE+KX1rL9/K0aPAOS6LMt8s6p1x6r0eRfWPV3dswaWoHT9czD0S8t8sa1vQ3QP0Da3FnFRK6jj70Zqvu0wyyqNgj1wunbOVUQnaooYTVE92Z5SPa+vQZA7n4xpSoC70y2tdWU2S/x64rJNYGXdJ8Gnv1/gkzHNcHMSCxQLf7/LhRW8tPIkuy5WD3PrEuPL+yObEOxZw7Div8m4ceN47LHHmD17NiqV5d/HkiVLGD9+PMuXL7+jbRPsiTlXgiDcPJMJji+FA1/ZLn6aewF+HGRJHvBHFCbXvK+y1LLG0z+E6UovVU1SCyzzXTRKBb6uGsa1CSPQXUPMNRnmFh3NZbWyP8axyyGkBbj4IUX3pGTSb8zPjLB/Eb+G2lhCTomeDzbG8Vi3GNRKGaO/3kfX/9vB+xvjaBTiQdtIb7rE+HE8rZD75x8iraD6ZTzK14VLOZbej6a1PNAbzKw5fpmySsvPPSG3DK1aQZNQ+56GSF8Xmod5cSAxH4DiCiMalYKVR9N5aX0yqQTyU0YgS3OiKHQKxSnnBLLveyFL3GkZMph7ERf0KDe/Yle3PPsMmkNfMaCBDwCD67nhd+7HGu+D/PhicgxqdDInJMmSSbEkoLUlkIjqBgNnwbA50GoKqF0hsDGFZkt2xfnDA2mzfTwB6+/D5fAclCcWQn48Tnv+jx5Hp/G29CWb73HmmU7+hPs4897wRkR6Knm5vZY9E9w4MNmHZl4GUDgIQCoK0Bz6CheFCVz9oe0jtvvdgy0fOFwdWF1tz2fQcrLl74e+t+nhdNGoeLJnjMPDlHIZE9uFo7p2npRroCWYu5azD7L+7zO8XX3WPt6Rzc90YeHUNtQNdL/lRYR1RpP1mXDkZFqRzRwxQfi7FJVX2gVWADsv5vLyypMUlV9/mPZfbfDgwej1ejZvtvS0nz17lpMnTzJ27Njbeh6j0Wj3JTnqoheuS/RcCYJw80ozYM8nNezLtsxf8Qi99XpDWta8zyMUlHf2U8Nb4axR0jLci73xjnt0etazXZkp0MMJSTIzZ0ILFu1P5ucjaZQbTHSM9iU6rBaFgQ3QjGyBZNRRKXcisURBaEAZ3j6OeyWqVKrcgRIOJOaTmFfKisPVge/q45fJLdXTt2EQb6w5bX8NagUhXloScsp4t28ww6IkTBeW0LmRhpK+XVlwWsf3h3KZvvo0741ojM5gYunBVIxmM73rB1A/yJ2XV1Zn3Gse5smqY+l0r+vPkz1rk5xXjpermvzsUioLL6PZ/Lxtj0loq+vOAXI6uZAJAyby62lQy6lxDSsATHrOphfSNNSDbnX92Xwmk7hSF0Inb0B2fiPs/NAyzDWqK4xeQLnaG5neB7hEraSfLYFP8WVw8YXur8KK+6yp6RVA4NlVPN7rHe5/eBIlpeW4xq3AY8PM6ja5+MGQzyFxJxz42jb7Y9w6y7wv9yBoPRVz1mnk5zdY9vnUhsxTNV9X7oXq3tzSLMuHHfLq3qhof1dmj2/Oq6tOWZOQ+Llp+HRMM0K9HPx70rhCs4kQ3tHSK12cAXX6QN0ByD3DCAFCvJxrbs9NUCvkRPg4s6uGqXpBHk6U6Y2UVxrF3Cvhb5VbWmkXWFXZeTGX3NLKv3V44LWcnZ0ZOnQoy5YtY+DAgSxdupT27dsTGRlpV1aSJEym6g8pqv5uMpkwGqs/FFUoFDYJjs6cOWPtFbtWw4YNb6qdV9dfxWw222yXy+XI5f/uvh3xv5cgCDfPqIOKgpr3Z5+DmN63Xq9vDPhEQ168/b6eMywvn/8QHloVL/evx7Av99itaxTo7kSbSPusaxeyS3ls0VEmtAvn23tbAZaU5mWVRj7cFMfq45epNFmSH4xrG0ZtP1dyzG6ExvRBds2cIQBjZA9+T6n+5aoz2M+P2n0pj0e61ubBzpH8sCfJukCvn5uGd4c14vOtF/l6eC06XfoITexq63HewEs93iKqfw9e25jKU8uO8+noprw/sjHrTmSw43wOn1yV6KJpqAdBHk68OqAe9YPceWfdWQ4lWZ6hlmFeTKnrAUXXJNhQOYO+pOabXFmG5koc8XuijgmNR+HtaK0roLzeKFw8/fjf/MN4Oav5cUobQuT58OtrcPlodcG49RC/DfO9W6jrZiQXkEsmCO8EXV6w9J7GfmgNrK6m2Pom7vUH4Vp8HvnOGbY7y3Lgp8lw3zrL8L1D38OFTVeuU0tmSSUKmQ4PrT/76r9JZPPncco/h8wrHM+ic9Q4QE7rVT2Utv4QuzlTrhol/RoG0iLMi7zSSmQy8HFVE+juVHPGSK0HaJvBoM/AXGn5UOM62SVvlVIhZ0K7cBYdSHE4X21c2zDum3eQ1wY0oGd9f/veNUH4ixTrrj86ouQG+/8O48aNY/z48VRUVLBs2TKefPJJh+ViY2Pp3r273fbatWvbfL99+3abOVzR0dEsW7bM7ri33nqLxEQHc0IdcBScTZ06lalTp1q/f/PNN5kxY8ZN1fdPJYIrQRBuntLJ8lJXU4DlX/+P1esWBJNWw4bnLQkGJAmcfSyBVUyvP9raOybG35WlD7bj9dWnuZhdilwGveoH8NrA+nZj93UGIwv3JfN07zpE+blwubACM9Cxtg+f/n6R7edzrGXLKk38fCSNrye25FRuJXR8j2AJFJeqAyxjVC/Ot/kfs5ZYhloGuGvsstu1DPeiYbA7uy/l8GDnKCa2CyejSIezWoFKLuOp5cdRyuW0qDyM5vxqu+tTb3uTofd1IrVrFHNjE1Ao5IT7uNCrvj/7Eiw9dm4aJePbhtG/cRBxl4toHu7NyK/22rTlSEoBl4udqX3tCTJPQpPRcGSew/srRXTiSKblZedEWhGp3Tvj7R0F+Qm2BT1qkRzUj81nsxnUJBhXmZ66pKDMPY/s6sCqiqEC5z3vo4zoCfhcmVeogz2fwv0bLHMDHTbIDKkHkJ9Z5Xi/UQ/nN0DaIWg23hI4Ju+hsOF9PL42DW+XHN4b3pjvjxSxNz4Pf7cgyg0V/DymPbUVajA5GJLUfCKc+tkyfDCqm8PTKhVygj21tz5fRKG0fP0Fwryc+XRMM178+aR1SQK5DCZ3iCC3pJLU/Ape+OkEm57uQoijHjZB+Au432Ce390wD7Bv376oVCqmT59OYmIio0ePdliuZcuWHDpU/WFTRkYGQ4YMYe3atQQFVX9QWbeu7RxpJycnWrVqZVefj4/PTQdXV58XYMiQITz00EMMGjTIui04OPim6vonE8GVIAg3zzUIOj4Dv093sM//jwdXYFkDacR3UJ5reRnVuFuypcmvnwnpTiivNJJbWoneYMJFoyTATYPiqk/ZtWolbaN8WPpQO0p0BhRyOd7OalydlGQUVZBRqCO/rJIwH2e8nFWMahmKs1pJVrEOma4IhUxCrfSwCawAFHIZs0Y3swZtTio5T3d8mdFdZoCumCKzli3JZj5dkmydu/JSv3r8uDcJgDBvZ2YMacjx1AIOJubjoVWTlFdGqJczge5OKOUykIG/m4aZfYPwWvt8jfdAfWwe7eq/zrFkL5qEeJBdrONCVikPd4milrczTko5yw6lUFheydmMEs5nlzpMYb4/Q6J2cAvbXqSyXDBWQnBzuHzM9gC5koJOM4g2hhLjX8LF7FKmrrrM8rHLCEtdherkUpDMlNQdRUb0aCb/nE5huYEFk1vQoHg3qp0/g1PNGe7kFzejqDfUwQ+95rlCgGVY3vXWo8qLB9cA2PACDJuLsVJHQkAfDm+xvLQ81i2agU2C2Hkx15oE5Z2dRXw6fDFea+6zXfOsdi8Iao65JAvDpHXk4Yu3wWSfpOIu5KxR0rdhIA2C3DmaUkil0Uyol5ZNZzL5YY8l6UeJ3khWsU4EV8LfxtdVTZcYX3Y6GBrYJcYXX9c7n61WpVIxcuRIZs2aRc+ePQkICHBYzs3NzSZISkpKAqBx48a3JVvg9VwbnKnVaiIiIhwGbf9mIrgSBOHmKRSWT95Ls+Dg1/bZAv/IfKurOblf98X3r3A8tZB9CYV4uKjoEuNHgLvmuvM9Mooq+HjzBdYcT8dgkvDQqniqVwzDmgXj7WI7NMvXVYOvq2WbJEmcyyhm8ryDZBVXzxHqXtefNwfVpzg3jQb6A/jGLQTJhF42jjWTOnL/L5etC9b2qu/PtnNZXMy2DE3TGcy8vyOTD2Ph/ZFNKK4w8MORRCoMJhqFuPN8n7oEuGt4qEsU8/Yk8mTPOjy34gQ5pdXn/+1MJve2tyQ4+HFvEi/2q8tTvepwISOFWuU1Lw6prshi/6Vs3h3emLisYqYtPobxytDCnvX9CfXS0jnGj6eWHWdcm1o1ZhX8fF8evcfMImDlcNse0c2vY5i8CePJlWiP/wC6IkwRXTD1fIvnNpWSUHCGe9uHE+ypRSmXkadQMTe7Dx1b9EEmg7UX9WzbmWAdftbAvQK3lc9BcAtQudR4XahdwKQHrklNnp8AgY1rngdVq02NPW14hELL+wEzNBiK5B1JXPdvmbSoevjkNzsTeG1gfUK9tKQVVBDo7sRzHbyQGfJg3FKkkizMBj2mwKbIndxJLdSzUBbG0s8vYpYuMKldOA93jcbP7Top1e8STioFlSYz7204h0ohI7fUvmfOLCbRC38jD2c1749swssrT9oEWF1ifPlgZJM7Ot/qag888ADZ2dk8+OCDd7opwnWI4EoQhFvj6meZ2N/mIUsvk0prmbTv+ifWuboDsq8EOBO/P4DeZJlXIpPB/41sQv/GQbho7P97zCvV8/Sy4zYZz4oqDLz961nMZonJHSJQKuQUlldiMkt4OqtRyC11ZxTpmPDdAWugVCUlvxyNPocGux5Hebl6SIUm/ShNfWP4ceQCBi+w9G70aRDIjLVn7NplluDFn0/y6oB6TB/cALMkEeHjwlPLjhGfU0aAu4bXBtTnXEaRTWBVZcG+ZL67rxUL9iUR5evKG6tP8UDbQAxhnVGdczzUrSKyH/uOljC0lcSTS49bAyuAdlE+7LmYS6B7CUUVBkp0RmuQafdzKNHz0TEZL4zfjOrSZrwy96D3iCQr+h6+2F5Mgb4P9/YairNKzv60SrpIEZzNPkxWsZ531p2z3CulnFmjm/HTsQx+OmZ/DpVChrIizxK8peyF1lMsKf4daTwazm8Cl2uG3Bz6DgZ+DMsm2A/T6/QMuAUhdX8N2aIRtvv860Pvd2Dza5B9FgCZkye1urzJQ20a88luywLSkX4uSMD397Vi4b5kpjZWEPnrPdYMnDIXPxRqF4wN72G10zCeX2ebYfO73YmYJYkX+9X7R/RgeV/5t+EosHJSyQl0d7oDrRL+y4I9tXwxrjm5pZWU6Ay4Oanwdf1717m6kTZt2rB69eo73QzhBkRwJQjCrdO4Wr68I+50S/4Qk8nMz0dSibhmuyTB8z+fpFmYF7WvSY0OkFmsswmsYvxdebmTJ7Vd9SjIwVioZG+uhlm/X0JnMDG4SRDDmocS4qUlPqfULrACGNYsGG3GIZvAyir3IrUyNtEmoi0HkwpRK+WUG2pOVX0xq5R98fko5NAuypv4HEvCg6xiPU8tP87XE1vi6ayisNx2cnaAuwaVXMavT3REIZfzaLfaxJ7PoWe75/C6sN4+mHALxKl2Rz4M0GA0S9a5M9b7a5YI83HmXIYlKcWm05m8MagB289nO2x32ygfBi88T6B7Mz69ZyLvbrrIjt0Z1oDt9+olonD38qFOgJtN75/eaEattCzum5Jffm31DGkajMFkRAtgqICUA9D2YUv2vquY/RtAoxHw43DLnK+rFaZg1pdTOnkH6oNf4nR5P5JrIHR+Fllwc3ByxxzcHF3vj3CJnVGd+KL3O7DyAdAVVtelK8Rj8zOMH7qYtb6uTOtRm4wiHUNn76FEZ+SzUXUJP/WR7dIGZTlQloNm9//Rdmw/1Aq5dU2yKov2pzC5YyRh3ree1a+wvJLsEj1HUwpwUStpGuqJn7sG7V8UqPm7O/HBiMY8tOiIXXKLGYMb/iN64IR/Hw/nuyuYEv6ZRHAlCMJ/Tk5pJUsOpvBqY8f7N5zKcLhOUHx2daa4TlEefNzBSMCWCdXZ7py9adjtA5r4h7HgSCFxmSUs3J/Cz4+2J73Acer0ej5yPE8sqrGtnnHLGVa/KweT4FhKAZ1r+7LjQo7Dsh1r+1JUYaBuoBtJeWV8NrYZ764/R3aJHkmChfuTGdkilO93V09OjvCxzMPaHpfNhHbhPLn0mDUoyi7yYP59G1FueRVSD1jmv8X0hdYPIPv1KWL6zSRF5cVj3aL5Kjbe+pK8LS6bYc1CSLuypldeWSUJuaU82i2ar3bYZoSc0DaMrGI9WcV6Qjy1mGVKtsZlO8wmB+DnqsFJaZtFrl2UN1qVnLkTW/DE0uPE51T/nHrV9+fJnjEUFl/G3dXfsmTA3s+h41OWoawXN4O+FEP94RS418NLbbbLvAeAWyBxihiGf53CsEaTad5oKnkV0E0bTUNnTwAUzt6kR45A5teRKFU+CkyWxYOvDqyuvpb9M/l0yAJmH8jktzNZ1dsVZchP/+T4BgAeyZtoWquHNetilUqTmdI/kNUst0TP+xvj+PlodTCnlMv46J6m9G4Q4LAX989SyGV0rO3Lusc78cW2S5zLLCbS14UnetSmjr8bmn9A75sg3G6SJGE0Gq1p0mfMmHHDzHrHjx+/7v6IiIgbrlU1f/78W9pnNBoxm+2z0F6rar7Xf40IrgRB+M8xSxJF13kJzS7WOdzu72YZqiSXwbvd3AlY0ct2jaXyfHw2PMhjo9fz6zkVBeUGMot1/Lg3iVEtazmsMzG37Aatlegc48uHbpaFal2dlOxLyLPrLWpWy4NwH2f+t/4cR9ZaXrpDPLX836gmPLHsGMUVRs5lFNO7ge0k6Bf71eOb2Hge6Vab9acyGFHfhTodPUgrNvHTuQoktQtE94T2j1sOSDsIP90P+iLksR+g6vgu2SV6Xupbj/c3xQFwMDGfqZ0iCfdx5ttdCRhMEt/tSmT+5Na0ifDmUnYJMpmMmABXYs/n8PnWi4xqGcqDnSM5c7mIrnX82HHePoB0UsmJ8HWhTZQPY9qEUaIz4qFVcTq9iFd+OcXLA+oxuWMEET7OyIAgTy1IMPKrvQR7aPi+9xf4rRlvWXB3z2eWlO9R3TB3f50ygxz/DQ+AQo1h2Fy4cOXnKldiajCMlKbP8NAvWUT7uZJeKrEnuYi0ggo2xpezYEob63w7Xw9XPtyXjlZS8VRrdzzSjlBjMvPss0R6Km0CKwCFDDDX/HzKjRUoHaQpl8ksyVRu1bbz2TaBFYDRLPHMiuNsfroLMQFut1znzXDWKGkY4sHHo5tSXmlEq1Li6iReS4T/rg0bNqBSqXjnnXd4/fXX73RzHIqLi6N+/T+RvOo/QPwvJgjCf46zWkGLWp6A4yQLPeo5nj8W7uOMj4uaxiFu+Fz6ucbFa/0Oz2JS81f5fI/lpXn1sctMahdObX9XLl3V+wWw7Hg+9/e+F1VirMO6KptM5I0tGWQVV/JM7zrklupY8mBb5sYmsPtiLq5OSia2DaNhsAcTvztAWWX1sMH0wgq+2ZXA2NZhfLMzgWBPLUUV1S/toV5ackv1DG8RipeiggmBafjsfx/5kXPgGcbAXu+jTDsAp3+2LHar1IB3FIz8FtIPw57P8elm4OcjaXx8T1P83TRkl+jx0KrYd+Eyj3cJZ8kDbZky/zBeLmqOphTy4W9xRPu5Ui/QDVeNklbh3nSra0nhXlJhwEWt5N0hdVm834kNZ/NIyiu/8jPx4/k+9dAbTET5unA8tZAVh1LJKtHjrFaw/tGWBClLUBSlIXP1QXLxpxQZDy0+QW5pJbmllUw/5slrY7fic3YB2rzTmP3qI2/7CHK1C56/jLYsymuogI0vQvQ7MPwbJL9oTpZ6MmdnCvOH+eGVsRttSRIlTVqTpq3HE+uyKNEZrcGVt4uGF/vVJSm3nF9SCpjk1xCVRy1LwguzERJ2gK7I8gPwiqBQb//p766UShpH9ECZuNXhM1EW2Y8zh4rstveq73/LWc1ySvTM3eFgfTksw2RXHE7ltYENbqnOW+WiUf4lvWOC8E/y9ddfU1JiGTUQEhJyh1tTs4iICJuU656enneuMXcp8b+ZIAj/OZ7Oap7vW4/UE3vs9kX5utAg2MPhcYEeTiyY0obfjifgmnuixvoVueeoE13dsyCTgUap4MfJrdl0NpMQT2fMkoTOYMJsNiOFxSCFtEaWfs28K5/a6OsMYZS7ml2XcqioNPHhb+f56eF2vDmoAUUVBpQKGUXlBkZ/s99hW/ZcyuO+9hF8g2UtoQZB7mQW6Yi9kEPnGF/SCsoZ2iSAunnbUMZvgY5PWHp2FEo8c48iufhDn3dg7ROWIXVVYvrA8LmYTJZgbu3xdIY2DyZAVcGQ4FJ8z3yOfF0ePnX6c/zJfhSatGSbXDiWWkhOiY5fT2bg66ahc4wfR1MKcFLJiXbRodBdwGXrfF406niqzxgy3JuQKXlxOr2IMV/vo+RKOvc2EV7MndSStIIKutRSoj27DHVhkmVdtKNroaIAzzr9eb9nI0YvKyOvrJKNcYVsvVhMv/pjiQ6Q07ZuCO0Cgi3p3ts/ASn7QeMGbR+HC5Ww6iFkftH4DV7Ge63K8Fsx1Dr/zJm5BLgHs+yen6xJSwAKy/UUlFdyMbuUekFuKLwGgYsHXNpmCU4HfWrJPLj9XejyEpcN9tkxfziSx6ixrxOcttcS7F0tpg/OAbXxcomjWFed2r5FmCdvD2l0y+vxGM1mskscf0gAkJJfgclsRiEXC/oKwl/p2nWn7lY1rYclVBPBlSAI/0kx/q6kAvUD3TmeXoJaIWdY82Ce6lWHQA/Hmcr0RjOBHhomdaqDaU89FAk7HJYze0aSUlw9xn1Uy1C8XdXklOg5nlLIexviMJkl/Fw1vNCvLuVqPzzHLMQUvx3Fke/BbKK43mgSfbpy/zcXcVYr+HBUE/JL9Xw0uglOaiXeLmqqEt8vP5Ry3Ws1miWe6x1D1zq+eDlrmD7YEpg5KeSkFVYQripEKcMyTG7lVEuPnFwBDUYg6/oC/NDXfuHoi5vBM4zLDZoCkF9u4P4WXvidXIHqp0+sxWSJO1Hs+QSfSavx1ifwZb8ALlVGUG60vKz/b/1ZjqYU8vGAEJy2vY82bqX1WM2FTYQHNMZ92CLGrj9nc/qDSQU8sfQYPz3cHqfsfajz4iw9T0vHVp/71M9Ee0exbMwSBv6YRKXJTKXJzNrTllTLb3v70c4/HdY8AVlXpVg/+AM0/Qaajofj8wh2qkS+brJ9Yo/iy4TufgXjyB8xmpxIK6jgQGIeyXnl1Alwo65LGfw8BTKuSmF4cgU0HgVjl0FoS4IrtTip5OgM1T1YheUGHt9Sytfjf8fn+Gzk8VvByRPaPQYxfXBz9WfFw15kFunIKdET4qXF302DTw0ZGWtiNJkxmCQ+H9ccg8lMbome73cnknDVUNXudf1EYCUIgnALRHAlCMJ/UlW66m/ubYnOJEMhAx9XjcM01kaTmZT8cr7dmcCe+DwC3TX8OOQ+tIe+Acl+WFdOy2eYv84SjIR6aZnQNoyC8koe+PEQZ68kiwDIKdXz4s8nUY5uyvDmIRTXHcklp3YcS8lnwykdx1OTAMgvg0cWHeHDkU2ZtvgYyx9qh7dL9fCvhjX0tAF0r+NHq3Avovxc+GJbPDqDiWHNQoj2d6Gg3MBzP51g7bggSNoJRxdUH2g2WbbVH2QfWFU5vgRD1P0AdKrtg3tlDqq9n9iXK82GHTOROfuiPL2S6B4z+Cq3KT8eLeCV/vWoG+BGB48stNtW2h0qyzqFNm4l7aPasy/Bth1pBRVUFOeh2vMRdHoaFt9jf+78BMLPfsWwxhNZcbx6HlefBgEMaOCFtP//kGXVsHZVnT6QcQTyE6uz/11DnrQTlb6AY/kyJn1/gIYhHkR5qzlrNNK7cDPyDAe54U/9DK2mgosv/k4mvpnUiqk/HsJgqg7IM4oNVLhHIh80C8oLLD1YFzfD6kcgsAkBLe8jIDAMank6bvsNlFQY2HIuixlrz1h7wGp5a3ljYAPmxsZzNKUQX1c1nWN8/1D9giAI/1Xi4yhBEP7TvJzVhHk7E+LlXOP6QOezSuj/2S6WHkolJb+cg0kFvPh7IaXDF4LTVYGNUoOhz/vsLQsm2FPLjCENWfFwe0K8nEnOLbcJrK72waY4sor16CrNPPJzPO9tz+J4qu2cmuIKI5nFOlw0Cp5efpy8q9ar8nJW2SWqaBflzbzJrWkb7cP7m+LYEZdDx9q+HEkuYOy3+3l62XEqzWbGtQmzZLU7sRQUamgwFDo+DU3HgWcYZNuvq2VlKEdm1OPprGJc2zBU8ZtrLnt+A0R1A30xqo3PMiE0B2eNghdWnuShzmH4n19c46Hakwv4pK8PMgeZIQz6CuQaN0jeV+Px6tPLeLGDh/X4US1DmdAmFC/9ZWRH59fc5uS9mHq9RVFhfs1lAKOhgk82n+XXiaF8F7WT9w0f8mJMBi4nf6zxGOnQ92A2olYoaBflze/PduXNwQ2Y3CGCrye15JdHOxDm4wIKJ8i7BHPawm+vQOJO2Dcb5rS3DGO8iYxdjpzJKObZFSdshham5lfw1LLjPNkzhs4xvtZnVxAEQbh5oudKEAQBLL0rZpMlWFJXv1AWllcyfc0Zu+x8v54tILvMg/lTd6HVZ4PJAO4hqFz96W1S0b2ZGQ+tCplMhsFo5kRaYY2nzirWU6I3oFHKyXOwFlaVlLwyAtycOJxcQH5ZpXUYmM5o5onutakX6MaCfcmE+zhzb/sIHl54xGYtJHetks/GNOe1VafYE5/HljNZbDidwfhQZ+QRnaH9NDizytJj5RluSWKhdoHYDx03yMUXSeXM52PDOJJUwABTzXN3MJu4Ojry2T+Th1t9yltbdWTkFRNpdJyqHgCjDl99CmOb+7H0qG0WwUq5FpNPHRQ19CxZjtfjbcrlrd4hrIkrZ0rHCPzJR5EfX2OPFICkLyNNWw+ZhydeNRVy9Uem0jKvTzlKXSq4usDp0yiLEsFgv+ZWFVllqSUwkoNaqSDcx4X7O0baFyzJsAzVNBttt5uN8MtUeHgnuNtOfi8stzxDnjWs11NYXslHm8873FdhMHE6vYi5E1uKJBOCIAh/gOi5EgThv600G44uhB8HwTddkH59GkPWeVJyisgu1lFWaeRIsuNhcQeSi1l63gyhrSG8A3iFg0qLq5MST2c1sivBRE6pzmYY37U0SjkKmQy1QoH/dRZPjfJzJaPIkia+KmjSGUycSC1k6Jw9ZBbp+PbeVnx8T1Ne+eWU3SKzxRVG3t8Yx+QrL/GrjqXTr2EQZUpPaD7JMl/p2CJIP2oJspaOhfwkaD7RYXsqO73EwVwN0xYf5csdl6iM7lNj24nqBulHqr/PiSPGW8VP4yNombYAaveq+diYPihPLGVSI9u5cK4aJfkmNYb6wyCsXc3Hh7VDnrSD8Q1UfHNvSyoMJioLMyHtEIR3qvEwqd4AHl95iU1JZnT1Rjou02M6yg3PopzXu/r+DfoEClMsKexrUFR3FGb5TSSfKM+1LCDsSFkulFbvyyiqYPGBZO774SD3/XCQZYdSyCyyD1p1BhMXshz3ogKcSCtCrRSvB4IgCH+E+N9TEIT/tk2vwNrHLYu9lmYjO7Uc1bddUOZf5MGFh0nNr6BDtE+NhysVNa5iBECl0cTPR9KJ9HXBRe142OHgpsGo5HIC3DU806uOwzI+Lmq8XdSkF1bgrlVaeyVS8svRG81IEvx0JI2J3x3gfFaJTcr1q53PKiHS19IzV6Y34qSSY0YGW6Zbet+utelFpI5PY4roWr1N44ahxwwya/Xj52PplOiNGEwSxepATA2G29ehcrb0ih1bWL3NKxI/NzUND76EZs//gZM7BDSyP9bZBxoMg3NrcDZX9wR5u6j5cnwLPvrtAnsLvDB6RTsOsORKy4LBR35EmbAdNyeFZRFmk87Sng6Pg8JxkKP3qkNppYkPYrM4WOc5ijpPB5crc5D86mK+ZyGyzJOW9OpVss/BLw9BWAdoMtqSiOIaZt/65Hs1I6tYx8m0QpLyyijT17CuldnkeHsVybI/s6iCyfMO8tqq05xIK+JEWhEvrzzFlB8Pk1lku26bWqkgzLvm4X71A91QOVhHSxAEQbgx0ecvCMJ/U1WK60YjoclwOL0S4tZZFvcx6gjY9zb9ot7k3u8PsnBqGw4l5dskHKjSsfb1J/xnF+tpEuqBzmBixSPt+elQKj/uT0a6UlXLcC+GNw9h+/ks+jcOpm+jALJLdMzZEW8dihjj78prA+vz1q9nAXi1f30C3DSU6g189Nt57mkVikYpR280Uy/QDdUNsrtVXUfHGF+OpxYyPkIBRak13id9wWUyen6FprIAXUUZRZKWr4+Ws3f7OT4c2ZSvY+PpWNuXozlyevR8j8rwPngdn2tJhBHeAZqMgW3vQHn13KX8TtMJ0Eqo2j4ALcZD3Hro9gpcPgqnfwGjDuoNgrr9YeMLIJnw8/ZizoRwTGZL+yXMnEovYvqmSt4cWJ8eQ+eiOP0THP7+yrk7QduHYf9XUJoFMhlymZwLmaWU1vIFfbFl35hFsG8OJO2ypGJvPB6M8Mz6dAY1CeKLbZe4d0USHaLa83D33ng6ySxz9fa9bkkyca2KAsiPh+Q9cM88zKdXIo9bD0onihtOICV8JAVGTx6eFUt5pQm5DIY3D+GlfvXwd78mU6WLn6VNegc9TWpXcLGsyfb7uWzOZ9oPcTx7uZjdl3IZ1TLUus3bRc2zveoy5cdDduVVChnDW9y9a+wIgiDc7URwJQjCf09xBmz/AOgOqx4CpQJa3GdZg2jd0yBJKJJi6dBSxQcmM7+evMyQpsGsPJpuU82zvWPwq2EYnyRJXMgq4YEFlt4vAIVcxvg2Yax6rAN7L+UR5edKZlEFaoWML7bF0zDEk5bhXjzcNZphzUPIK61EkiTOZ5Xwyi+ncNEo+e6+VrQK90KpkFNeVknjUA8kYNlD7aioNGGUJOTIkMvAbB8L4qFVYTJLuDspGdwkmKk/HuKDTsHXvV1ms5m1F8r4ZEuydZtMBs1rebHu5GVeHVgfXxc1Sw+l8s76dOZM6Edm0yZ0CdPgai5Bvny8Ze4QgEJFxcAv0bp44LR+mmUxYicPaDbeknkx/Si0nmpJrhHYGH4cDGYjpqhe7EyXSCkv49PfL6IzmPlyfAvAkjXQw1nF5eJiQiO7IYvpc2XB3u2w6uHqbIfRPZHJZDQJdWf+iXxeafM0bvv+DzJPWYY+tp4KLn6YVR5w6BKvtVWjcHfmbIYf+aUG0ov03Pezpa5tD9Z2HFhVyT5n6XVaPonsSTs5F/wglUaJJWd1RBkktKo8yq8s+GyWYOXRdJRyGW8OaYizuvpXs97JD3Ov99Gun2Z3ioreM1Fo/Sgrq2TZddLxLzmQQu8GAXhoq3voWoR78kr/eny8+YJ1+Kins4rZ41oQ4qmt+boEQfhLdOvWjdhYy2Ly77zzDq+//jozZszgrbfeIjg4mNTUVOTXfHDWsWNH9u7dy3333cf8+fOvW39ERASDBg1i9uzZN9w3d+5cHn30UQAaNmzI6dOnb8MV/neI4EoQhH+0CoORUp0RJ5Xi5hZQLc+3BFCXdkDT7pZtlWWwfw60fgAa32NZi0ihwoyMPg0CaBPpTeNgD3rW92flkTTaRHrTu34gPq5q3Gs45+VCHWO/2U9BefVwL5NZYuH+ZPzcNJjMZg4l5TOqZShvrT1NTqmeE2mFNAnxIDmvjLk7EtifmEe7SG/u6xDB0gfb4apR4uumIaOogh3H0ll1LB0nlZxwb2cuZpdyPqOYBsEexPi7Mq5NGIsP2L9wP969NvE5pfwwuTWvrTqNwSRRInfHxT0Yii/bX4hSg8wrnO+XXrRu6lXHk9c6uuGduhnnonhMuZ0waNtzPrOE/LJKHl18lOf71GFPvgoPJ3ea3bsRp4ocZIYycPHDqTwX2cJBWLvvdEWWHqT0o9BoBGx8CWRyGLMQzEbMwc0p7vV/FKUp+XDTKWvQ6O+uIdrPhcH1PGlacRDNxqctPVQA3lHQ+23wrQOpByyLBLsFYDZLtI/yYfy2SzTqOZC+/Wvjc+gjOPwDRHVHiv0AedJ+aPoNtTZOQjHwI77t6IQx9QgVrqGU+jYn3eyFj1ulJZtiYQ1BjVc4ZJ3G3OkZSmRubEopw91JxTN9ItlwKoM5O+LtDll5NJ3Hutcm3Kf6V3NWuYlll+tw76i1+B3+GEX+RUzeMeS0epYliS7cE23GVXPrQ/g8ndXc2z6cAY2DyCzWoVbI8XPTEODuZLMosiD8p1QUWOY46ootH/q4+IK2xnQ2t13Hjh356KOPqFWrlnWbSqUiNzeXnTt30q1bN+v25ORk9u3bh6ur621vx4gRI2jWrBnvvPMOycnJNz5AsCGCK0EQbo6xEkozLb94ZArLcCW3ILhDC4zqDSaS8sr5KvYSJ1KLCPZw4vEetakf5F5jljTA0v4Lm0DuYKHgYwth5PdwcgWV9Ybh6uWPv1s2b609i1mSGNQkmJf71+eXY+l8ueMSI1uGEuPvip+bfV1nLxfZBFZXm7cnka8mtCQlv5w1x9LZn2jpDYnyceFcZjH3zN1HvUA3utTxo1RnZMJ3B+hVP4DHe9Sm3GDk6WUnOJpiOcZFraBPw0BMZom4rBIuZJcyoHEgkztEEOnrwsL9yaTml1M30I2netbB20XFqqPppBVU0L2eHxnFFXy4u4h3B3yBdsVouzk+ZT3eI8vkbk3Z3T7CnZktivBb/6AlbbtfNKrUnTjteo8vRq3gUs8ofM35qMqSkBnK8PCvR2VFKc4/3WtJztBjuiXtu+SgWy31ALR7FDRuSBGd0al9UTwQS6rRg2d+SedkWnV6+kFNgqgb4MrPj3TAvfAMiu/G29aZnwArH0CatAqz0YAisBHIVahKUolR6dj6SCOeXJvCfF0Qj7b6lvbhbgTsfBlZwo7qZ2PQZ8g3vwR58agBNeCh0uI5+ifeinXh5VbP4P37M/bXoXSCWu0gsCnyWm2Icfbmg1DL8L3dF3P4ZmeCw+eiToCbdchjlbzSSubsy2HFKTUTm00nurachCIzC1cXkFuaTY9mMdTydmZs6zBeT3f86fL4tmE2vVZVtGoltbyV1LrO/CtB+M8oSoc1j0PCtupt0T1hyBfg8fcMlfX09KRdO9u5o2q1ml69erF06VKb4GrZsmU0bNgQhcLxXN4/w9/fH39/f/z8/ERw9QeI4EoQhBvTFcGZNfDby5ZeHrAEVyO/h7D2oLxOMPMXOZ5ayITvDmC88jKamFvGnvg8XupXl3vbR9ScRro43fF2AKPeMjTNPRhD55d5dMk5LmWXWXcv3J/MptOZfHRPEybPP8TKo+l0ru3Lx6Ob2s2VOX+dbGwF5Qa8XdSWHqorL9palYLaAa7M3HCOLye04OzlYg4n5ePtomHWmGYcSMgjOb+cz7Zc5OUBdZm15QKXsst4Z2hDvtudyMm0ImQyGNwkGC9nDan55XSt40eDIHd8XTUo5DJkMon9CfmkFVbgk13Kve3DGdUylEqTRK4iHL8pscj3fYY6+yQmzwh0bZ/mkhTKmeQyQjy1pBdW8GYPf/z0mTDkc9jzBRSnQVBTGPwZrqd+pF6TSTgvH1I9v2rA/6E9+E31sECvcMg+W/PPIP0o5ph+xDd5jqk/ZVJhKOHj0SGcSrcEVg2CXPligB8RpceR7fgJWVBTZB4h4N8Asq5Zk8uow3B+Cz+oxzFem4/brreRxa3DTTLjFtCIRb0/5Ly8DpfLwE1ZhOzSFtvjD/8Aedf0MBkqcPl5HOMHb2RXUUv6tJ6G9vBX1YtJO/tY5nD51bX8/RrervbDSIc29OSpNu54ZOzC89QuiO4G3tHgFmDN2pdbWsmnu7PsjtVc2d+rvj+L9rsRl2n73DUKdqfTDeYFCsJ/XkWBfWAFEL8V1j4Bo77/W3uwrjVu3Dgee+wxZs+ejUpl+aBkyZIljB8/nuXLl9+xdgmOieBKEIQbyzwFvz5hu60sBxaPhEf3g2/tv7U52cU6Xlx50hpYXe2jzRcY0Dio5uBK633duk1uoSQNWUXsJYVNYFUlp1TPzou5dI3xY8eFHHZdymX7+Wz6NwrC/aregfpB7jWew9dVzan0Ipw1Sl7sW5cvtl1i/v2tMRjNjGkdxnMrTpBz1SLBRrOZ+ztGYjKbeWd4Q5AsCRC8XTQEeTiRVaxDJoOZIxpzJr2Yp5YdQ280I5dB7/oBTGwXziOLjmA0SwxtFszzfepSqjdQUWlGLpPx/E/H6VHPn8ScSu5p+gaRbSXyKhWklsoJdFdz9nIGT/eKoZ5zMXUqjkPSbnDzhw7T4MDXlmQg59YiH/EtzpX5Nokr8KgFudVDCpEkS3Y+R5kJAZNHGAeCJvLo0mRrxsNjKQUsmtqWC1klTAgvQr2wryUZRRUnDxjxLWx62dJjdRV1xmGGdB2L+7JhtoF11mm0SwYTNGYjU1YXsXm0Gy7XNiZhu+MfoL6ECCmdEv+W7HaZSsfm9+JUloZMJgeFCpnKucYsf36uGuoHuXHuyoLSwxp6Mb1uKt7LHqkO0HZ+AMEtYOxifF28rYHttcK8nfG5kuI/0EPL/Ptbs+N8DssOpSLD0mPVOcaPQA8HvbSCIFQry7EPrKrEb7Xsv4PB1eDBg5k6dSqbN29m4MCBnD17lpMnT7J69epbCq4kScJoNN64oPCniOBKEITrqyiEbe863mcywPFFlqFef+PwwMIKA8l5jhdoNZklzmeWEO5jeVUu1xvJLtFzIDGPMr2Je+r64OYVCUUZdsdKUd2ocAujXK5iw6mae1d2nM9haLNgdlzIQSGXkZhTRkJuGWqFDH8XFd4U0inAxKs9QvhyX7ZdWvRHu0WTkl/GF9susfbxTgxpFkyguxPphRXM35tkE1i9PrA+WcV6xn+735o9sH6QGy/3q8fra04jSfB/o5qy8VQGZy8Xs3B/9RAOswS/nc0ip7SSp3vVIT6nlD4NAwAJZ5WSSzml+LtpqO3niqdWxfHUItafyuSRtr5MrCenQcpynCoyaRozCHVYK+QrH4WME9UXIldahswYdZaAa9v/LEHO1YzXLCx88TeoP8QSkF1LJifVqx3jf7hkszn2Qg6T24XSzrcCxfx7bQMrsPSsbnwJOjwB65+13RXSAdfsw457LM0m/A+8z+4nv0FTWWi/39HQxSvU+nxe2XCKx9p4ISXMR35uueXfQ9Viv3X6wuAvwC3A5jg/Nw1fT2rFo4uOcDajmKfauuG99KrAqsrlo7B3NgG9ZvD1pJaM/WY/pfrqlyJ3JyVzJ7a06TEN9NAytk0Y/RoFAjUvIiwIwjV0xX9u/1/M2dmZoUOHsmzZMgYOHMjSpUtp3749kZEOFh6/jjlz5jBnzpy/qJVCFRFcCYJwfYYKyL9U8/6Mk5Y1g+R/37yNG023V16ZkF+iM7DuRAavrj5lfU/+freWtWMX4r7qXtuDAhohG/IFrp5+RGuNaGtYkwrAWa2gbqAbTUM9eLBzFHvjc5k6/xDzR4XidGIZ8pM/otGX8GB0d4ZNeJVntpaxJ7EYtULO+LZhyGUyfFw1dK3jz5rj6UzpFMnBxHz83DTsOJ9tPU/rCC/0RjPf7rLtjTmXUcLzP5/kzUENeHzpMT7afJ4Zgxsy7tv9Dtt7LqOY90c05mRaIc+tOMGHo5pwJLmAX09koDOY6FbXjxbhXmQWVmDQlfCI1yE8l79mPd7p3K+WHqjBn8LySWC4EtiajZZgZsS3luAq71J1cFFFpbUkp6gKHk7/Yhk2l3nStkdLJsM09Cs+PWDp0Ynxd+Xpdh4095fj56pCfmE1Co8gKKxh/H9BIrgF2m6TySirNxqvve84PgaQpe7HWZdjub66A+D8huqdLr5QkubwuHzXGIymYrp75+ISO9++wIXfIH47NBtrtyvM25kfp7ShVGcg5OIi+8CqytH50P4xGgSFsOmpzuxPzOfM5SKahHrQOsK7xqx+IqgShFvkVPNIg5va/zcYN24c48ePp6KigmXLlvHkk086LHd1z5RMJrOZkzV69GheeOEFu2OGDBlyU224Xt1CNRFcCYJwfSot+MRAabbj/UFNQfH3DjvyclET4+/KxWz7dX1UChm1A9wASC+s4JVVp2z2pxdWMHR5DsvGrIATZy09L361wSOUEqUXZUU6zJLE8OYh7LqY6/D8I1uEsPFUJs/0rsPSgyn8diaL+feE0WDHwyiyqnt2ZBe34J+4k3lTthJbGAPA+pOZzN97FrVCzlcTW+DmpGTidweIzylj3RMdbdKnj25diw83nnfYhpwSPSV6IwHuGk6mFSEhWXu2rvVkz9q8seY0BxLz+WRMM2ZtuWAdlgaWLHW/n8tm+cPtcC5OxHPJa/aVFKXC0QXQeJTlzyqGCst8BWcfKM+z71W68Bs0HQfHF1dv2/sF9HwTTJWQsg80HhDZBUwmRjR0x1OrYFrtPPx2PWOZ8yRXQr2B0PUlS8BT5vjnYhPYqV0o6z+bVRf1jHcJpsbQ38XXkg7e2RsGfoyEDC5utexr+yj8bn8vTFG92JmhpFcdD/zPzKqpZtj/JcT0Bhf7uVe+rhp8XTVw3H4elVVlGZhNyOUyQr2dGeXtbLNelSAIt4mLnyV5RfxW+33RPS3777C+ffuiUqmYPn06iYmJjB492q5MUlKSTW9WeHg4SUlJ1u/9/Pxo1aqV3XFq9Y0/kLlR3UI1EVwJgnB9Wk/o/hrMH2C/T6GCZhP+9oyBvq4aPrqnKWO+2YfOYBtQvD20EX6ull8UKw45Xhg3raCCKStTmVYb0oP7kV9hxJQDX2w7xpnLRQR5OvHWkEb0aRDA5rO2L7/torxx06pYfTydIc2C+e1MFv5uGurJUmwCKyujHuW2t8iq9Savb6xO211pMlNQXslvZzKJz7HM7UrIKadlmCftQjWMrKshSJFMh5FuxJX48daOfFLyLT1GSrkMd62K5Lxygj20ZBXr0SgVDte2Uspl1PZ344NN5wnzdqZUZ7QJrKoUVRjYcjaLx7R7a77xceth1A+2wRVYAiqVMwQE2ieAODLPkvzCI8Sy6K1PtCXlen4iRPewZOg6txZ2z0IhmWnXcDRtm45Hs2RcdR1mI5xdA1mnoe/78MsD9m1TajD51SdnyDIkhYpcZQCnirQU6I3k1x6F86EvHV9Tswlw9EcIaUWRewzbI1+nYZMX4FIKlZG9kE1pi/LQt3B6Bahc0De/n7xGU3nr6zimtPZDUXqd4UL6YpBuML8hugfsriFAC2oKaruZYIIg3G5aL8sHbWufsA2wqrIF3sH5VlVUKhUjR45k1qxZ9OzZk4CAALsywcHBHDpUvTi4RuN4HcY/4q+s+99GBFeCINxYYGMY+qVlXkvlld4iV39LtkDPsDvSpIbB7mx7thsJuaUYTBIqhZxAD8s6PVq1EqPZ7DAJQJX80koAnl9xnLHtInlh5Unr0MG8skrGfL2Pb+9txaiWoWw8nYHRJNGtrj8VBhOv/nIKZ7WC/DLLfKJGIR54Jy+o6VTIE7bRq+sHvH7NdpNZYn9CnvX7j36L49cpdVHvnIl22SKQJEKAEM9w6g+dxyObVQxuFkyEjzPZxXqi/FxpGeaFzmhCqZAx7/7WLNyXzLa4bGuQ5eWsJrtYB0DLcC92XsypsZ2HkwowR5ZQ40APsxGHgzJ9YqCiANOIbzFo/XEKaFiduU/jBqU5UKc/7PkMtkyvPm7LG5beqOBmkGb5pa0OrA/bptufA670YiksSwCU2M6ZK2vzFMdytTy8WoZJMqAzWALZORNasPR8Kc8NnIV8w/O2Q/Bq9wKvCEg7DEiU6oz8345M5g2zfEqtXjEWpcyEofF4TI8cJk8nw8UrgEuZFeiNZnxcNZj9ByBP2uW4vTH9wMmzprtp6fHzDIPAJpZhkleTyaDvTEvP2t+lJMsyf02usLxMOl8/+Ysg/Kt4hFiyAlrXuXK39FjdBYFVlQceeIDs7GwefPBBh/vVarXDnqnb4a+s+99GBFeCINyYkzs0GQ2RXS2/eORXrXMluzMLjpZVmjiWWsDMjXGkFVSgVSkY26YWj3SJxs1JhVIup1f9AH4743jYVYswTyCLNwY34OHFJ+xyFxjNElN/PMSSB9rRIcqHjGId72+MsyabUMhl1kWLdQYTBo0nNQ6sULshd9C71yTUk/RCnfX7V/vF4Hx6EapTC20LFiYTvGYUC+/dxr0/p3PiqvWeIn1deGdYI+79/iDllSbGtq7FJ2Oa8dyKExjNEh7OSqL9LYtMGk1mnJQ19zJeLqxAH94NFTUkMAltZZ9GvcEwyxysMQtRHPoOU9dXoMlYSw+V2WjJmpe0yzIn6+xq+zpjP4Cxi+HYIssQQ59o+0DjammHod/7sPk1KEoDj1rkt32e0rCeTF8WT1mlbZa+TaczCfNyxRDZE834FZY5WwY9eEdAThysmWYJcLTeyM3w44hAwteN41z025YAzqxDtet9VGd/RjFsBZ7urtSXKZnYthbD3c8jd48ARwswO3lAu0dA6eDT3bJcSzC562PLNQ/82LJw9Ykllu8DG1uuMbhpzffhdjJUWO7ruqct8+bAsk7X4M8sKeXv0L9xQfjbab3uqmDqWm3atGH16tV3uhnCDdyZ1T+vY+bMmbRu3Ro3Nzf8/f0ZNmwY58/bzznYt28fPXr0wMXFBXd3d7p06UJFRfWn1Pn5+UyYMAF3d3c8PT2ZOnUqpaX28zMEQbhJCjV41oKQFpbhSu7Bd+ylS5IkdsRlM23JMdIKLP/uKwwm5u1J4unlx8i7EgB1iPbB383+5VYhlzGxfThgGQ6XWayzKwOWIXZ5ZXou5ZSxPyHfJoufySxRUF5JqJeWw0kF5EcNrbG95U0nU6rwZM6EFnw1sQXDmoUwvk0t3J2U+F4Zwji+TRhNPHWoDtQwfK08H3PGKbu2JuaW8eaaM0zrXptSvZGfj6ZxOKmApQ+2ZcXD7flyfEsqjSYC3Z3YdSmXPg0DHdcP9KofwJEiVyqjetvvVKgw93rHstAvWJJH9JwObR60BAaLR8Hpny3zhA59Z5lLlX0WTq0AzwhLVsmaxG2w9CKBJVBz8qi5rKufJfjq9iqlDx/i9ICVJIcO5ZVN6STk2qfOLyivZHy7MI5lGTFpfS2LYUsmy5DWqrlbQ78E9yB8XBSEJq+yLJZ9rbxL+GZbhkz6uTkxvas3PrGvwoYXYMhsaDLGsniwXAn1BsGU38Az3L6eikLLMMClYy0BVtZp+HGQpcfowR3w1AmYtBoiOlmGUf4dci/CgiHVgRVA6n6Y1w8KU2o+ThAEQbBz1wVXsbGxTJs2jf3797NlyxYMBgN9+vShrKz6l+a+ffvo168fffr04eDBgxw6dIjHH3/c5pPhCRMmcObMGbZs2cK6devYuXMnDz300J24JEEQbrOsYh3vbjjncN++hHwyiiwBSIiXMysebk/vBv5cSSBIgyB3vp7YkgX7LFnnXJ1UDuupolbKOZlWSO8G9uPbv9x+ifdHNMbDWcWy82aKOl078A/M/o0xtpzCw0tO8Njiozy97DiuGgXTutcmyMOJz8Y049GukTzQORIvjWR5ya6BLO8CvesH0Ku+PzH+LrzeM5Ct94XwXV81I6PMrHqoFa8PrE8tb2c0KgUapYxhc/Ywfc0ZZo5ojEohJ62gnCFNg+3qbhDkTotwTx78OZlDTd6ioNt7liFzGjfMdQaQPW4zh42RmLq+DPf8CN1egYubYf5AS4Y9swnkChQaV+j8rKUn5OwacA+B6O7gdJ0hZuW5oLmSjev0Smg1xXE5uQLCOkDyXvROPmQQiMYziBWHU9lzKc/hIUOaBmMsL6JeziYU3/eA316xDEdcfA+SoQLDIwfQBbYkKbeMgtwsnM6vqrGZypNLQW+Zr6Y2FENplqX3bNk4QIKhsy2ZE10DLNkLHc1FLMuGfdcE0CaDJTBdOdUyx+rvHAqoL4Ht7zrOWFhRYJs9URCEv1TVOlTSlaEUM2bMuGHHwPHjx5k/f/4N605KSmL27Nk3te/adgi35q4bFrhp0yab7+fPn4+/vz9HjhyhS5cuADzzzDM8+eSTvPzyy9ZydevWtf793LlzbNq0iUOHDlnHh/4/e2cZHdXZteFr3CfuDoEQ3N2Ka3FvKTVa2lL3t+721ZU6roVSpBR39+AE4q6TZFy+HwciZEKBtpS251orC3L8nJnMPPvZe9/3J598wqBBg3jvvfcID689sBAREfnnUG5zkVdmq3N9UlYpTSOE7EdsoI4Pxrai2GzH5fbgwcNH687QvWEQFOSikctICDFwKre2yINaISXIoCbHZKNBsJ7mEUaOZFYJGKQXWTBZHLw6rAk2p5tkzRga3dkfxfHFeMyFlMQOwh3UmHmHrZy5YEhsc7qZvTuNUouDUW0iCTWqCffVMvrLnXwyOJguF1X3vKCObIEhRY5cpuGDfr7oVz+IZPsFAQqljvj2D5Gs7M8bqwRPpy71A3h/bAsemHuQV1Yc55mBjZBJJTSP8mV8uyjm703D4nAztHkYTreHxxYexu5yM2l+Cl3qt+aR3vMxKEGp82PY14cxWbPZf388AUsGejXJ9Qz9BMnW94TytovknYCji2DCfJg7rraaIEB0JzgmBDUeD0iajoL0PZC6vWobqRwGv4/HZSOv22u8u8fO4qNb6VQvgFeGNWHpwcxa4ibBBhU9GwYiyz2K76baqn+S/d9TFt6DJIOR277fy0u9Q7lNdpkmbbkai8NDRkkZYU4JlXklp03I3h1ZWLVt4lDvx0jfU/fxc5PAUlqnMlm5zUGFzYVaIcNHc/lJgSvGVl7Z7+aV5A1CsOutvFFERORPZdWqVSgUCl599VWee672ZN314quvvmLatGkANGnS5G+7jn8qN1xwdSmlpcIsrr+/MOuZl5fH7t27mTRpEp07dyY5OZlGjRrx+uuv07VrV0DIbPn6+tZovOvTpw9SqZTdu3czYsSIWuex2WzYbFWDNZNJGAA4HA4cDket7UVufC6+buLr9+9DhhutQijN80aARlbjdVfJINQgDEbP51cQalAwc/s5pifAkv2pvDE8kakz91Nur1J2k0rguYEJSD1Ovru1FX56BZ9PbMW2M/ks3JeOyw29E4OI8Vcz8osd+GoUNAjW07dxCInxD6CWS7E63GTlWtidnI9KVvNaK6w2PC4HO8+aeOvXkwDMOFBGo7aPYNz2Wu2bMoRxyBLMd1uT+XpEFOrFt+IsPg/SCzL4ThfqHe/Ts5uB7vWbk1ZkJc5Xit1i5ssJLfj1WC4vLTuCQibFqFEwvn0kEUYl/ZqGUlxu46mfkrA5nKhk8Fr/CPqFWlAf+wypzYQjcQSrb2/Kh7vL+HhnEU8N+AjFr4/XvD7fGJx+DZD/8igu6SXS/HYb7PgCWkyGfd/UXKcPhtje4HDi6PQYJf7NkeadJaDhYGh3L+QeFaTaA+LxnFlHir4dkxamYbIK13ogtYAVh9KZfUcbPl2fzM7zhcilEvo3CeWRPg1Q4EB9dCaOS6/p4mM9+BU+XZuhlHpYdrKCgc2moN8qPP9L93G3vostp7L5aEs2E5sbGBfZEbIO1T6oUgc+seDts0eiqHrNvOFy19rPYneSUmjmi01nOZFdRrifmnu716dxuBEfzR/0tPJIwBgD1tollQD41AcX4BE/Ry8ifrfUxOFw4PF4cLvduN11eLb9R7iY6bn4PK6GL774grIyYZIvIiLib32WI0aMoHXr1gBoNJr/zOvqdrvxeDw4HA6vHl5X+jcv8dzAOT+3283NN99MSUkJ27ZtA2DXrl106tQJf39/3nvvPVq2bMnMmTP5/PPPSUpKokGDBrzxxhv8+OOPtXq1goODefnllyuj8eq89NJLvPzyy7WWz507F632+pmjioiIiIiIiIj8U5DL5YSGhhIVFXVFfkkiIjcqdrud9PR0cnJyahgmX8RsNjNx4kRKS0sxGus2lr6hM1f3338/SUlJlYEVUBk933PPPdx+++0AtGrVivXr1/Pdd9/x5ptvXtO5nnnmGR599NHK300mE1FRUfTr1++yD1DkxsXhcLB27Vr69u2LQvEnldCI3DBkl1iZNmc/Z/Or6tHVcilf3tqGlpG+yGU1+11KzHYOpBXz4PxDAHSM9WFkcBELsvzYn2FCIoHbOsYwuHk4i/alY7I6ebxfAqE+VVkGj8eDxeFCLpWivKC653C5+HxjMl9vO0+Un5ZnBjbi801n6d8klDBfDQUmG2uO5XBXtzje/e00KYUV+GoUPNo3Ab1azqMLD9W6t5FNA5jYVEuYyoJLqibNqubhX9IpKLeREGLgm8aH8dtRh6If4Bk7C8nCW2ssc0R1Zl+zlzCrAvi/Nad4ZmAi0+YeAOD7Ke0AQc6+sSQV5awhXo/r7Hg/x+vfjd0txWZ3MXtPGj5qGafzzOhVMj6L2Yxh78feL0oqg9vXwJk1gnQ7QNoOocfKVgY+UaQOnsvQH07z0biWrDiSTe9oKXFG0KhV7M+X8cZv57G5as+gKqQSXh/RjCh/Dc0ifMkz2Xh4wUGOZJbSLtaXj2J2Ydz1rvd7ShzG8ebPccusI7g9oFXIeH9gKKacNPpW/IRCKoHEwYIQxfqXhf4owBXSnBOdP0AucRNctA+/vD1IAhsIYhbGCFDULqNzudx4HGbkRxfCukvk5lVGuPUnCGpUY3GuycqEr3d5LYOVSyWseKArkf5/cALQXABbP4QDP1Qtk8ph0LuQMEj02roE8bulJlarlfT0dPR6PWr19TWUv9HweDyUlZVhMBiQiCqb/zisVisajYbu3bt7fS9frGr7PW7Y4OqBBx6oFKKIjKxypA8LCwOgcePGNbZPTEwkLU1QNQoNDSUvL6/GeqfTSVFREaGh3pWyVCqVV0M0hUIhfnj+wxFfw38n0UEKvr+jI+cLKjiUXkKYr4ZWUb6E+ahrBVaphRXM2ZVKVqkVm0uCWiHl9i71KT1TxP4MEzaX8CX41bY0Fh3MYfG9nQg2qtCrqt43GUVmVh/LYcPJPLrWD6Bfk1BUChk6pYxbu9TnaFYFfRqHcDrfzKi2sXy//Txn88uJ8dcyuVMs2WUObutSn9dXHkepUOBCghspUqkci6Nm/9K8w0XMO1zEyzc34Xi2CafLSmapHZCQXebA7RuLwu1d4VAoSQuF0TMERby8E7DrcxSpG0hMHMuzx+J5ZUQL5uxOIzbQyIT2UQQYNGw7U0CPhCDUu+cjq+PYikPfY/Ibxl1LM5nQPoqbW0Xz4PyDAKjkUpy9+6PY/Y7362o4GMqzYNOr3tcXnyFUbcfmkvDwoiSeHZSIVKNgWVoxDYL16A0KTHYP3ny2WscEcKbATNMof0osLnanlrA3zQRI2JZcSnGPgQQc+ASsJTV3lCkoaDmN1CIbsyY0ZNWpUhYfKeLe5Zm80x6ye7xHfftJwbS4rKaCoCJ7D9Gm/dyyLw6PJ55H+w6qU4mxxGwntdDMrF2pFJbbebT7QBLvaIt8z1dgyoR6N0Gz0eATXUsEo9xuIb3E7vW+bS5IK7URF3IZdcUrwScMej8DHe8UDJ7lasF7TBcMSrFyoy7E7xYBl8uFRCJBIpF4tZz4L3ExASA+i38mF9/Hdf1tX+nf+w0XXHk8HqZPn87SpUvZtGkTcXFxNdbHxsYSHh5eq+Tv9OnTDBw4EIBOnTpRUlLC/v37adOmDQAbNmzA7XbToUOH63MjIiK/h6UYzEXCTLjaR5C2Fme6ropgo5pgo5oO9QJqLHe53BRbHEglEjweDx+tPcnwBA3yKB1ZJT7UDzaw9FAWvbxMyBdV2Nl4Kp87usRWLkvOL2f0Fzsoszr5YFwLdCp5pUFxgF6JTinjg7HNUdnyMJfbSDeZaRaq4XxBBSmFZl5ZcZw7usQytm0UrwxvikImoXGYkVVHcxjRKoK5e2rLXWuVMsJ81Hy+6SyP9UtgyQFBpCK/zEapIZ5QjZ/wHrpITBeI6SwY0h5eALsuKD+Ft4YRX8Hy6QQd+55moW9gUCuY2r0eZ/PK+WxjMm//eorGYUZ6NQpG4riMMpXDikomweX2MHtXGhG+Gno2DGLT6Xz8dUrs2jDMLaagPfzDJTfjD+3vgeLUuo8NmGwSnh6YyBurTvDcsiR8NAp6NAykQ5w/dpeHKH8N6UU1jaGlErijaxzn88v5anMyQ1uEM2d3zed5/8oClt6yEtWaJ5ClXxAACWlCae93UMjlDEl5A2XBcVr41efucQ/wzTEJkEeA0gmrX6oVWF0k4MQshjZ8i3c256JXef86LbXY+X57Ch+tP1O5bOOpPBoE65l/5/8RoJaAQutdWRCQSi//maCQ/UkDOI2v8BPY8M85nsh/hosDTrPZjEaj+ZuvRkTk2jGbzcCVB1F1ccMFV/fffz9z587l559/xmAwkJMjfKn5+Pig0WiQSCQ88cQTvPjii7Ro0YKWLVvy448/cvLkSRYvXgwIWawBAwZw99138+WXX+JwOHjggQcYP368qBQocmNQeBZ+eVgwVwWhjGjgO4JJr9rwt17aP52MYjOL9mWw4kgWIUY1nw4O5q3QjSh3LASJjG8TJ+JoOIQpC1PpVc/7MTaezGNi+2g0Shk5pRZe+eUYxWYHTw1IIMxHwxurTnAgrQQQBvffjqlPNAeQb3wFXVk2QQoNjZrdwq2T7mD8vFRsTjczd6Yyuk0kjy08DAiZnheHNKZjPX9SCyvYnlylEGhUy3lndAs+35RMrsmGBEgMM3AiW2h2lspkMHIGLH9Q2GHIB4L0+ek1cG6j4Lk04itY8QhkHRD+7f0C7P4KlQzKrE5WHslidrUgZH9aMffM3s/KQaORHpnv9bnY6g9gV5aL53uH0SFMjkRqYVjjehzNiyLcT8u+vDI6dHgcWeObUez5DKmlGOK6Q1w3WPMs7hEzkHa8X8jWnP4VnFUZMldMN34+YyW5zMmK6V1ZfjiLzGIzUzrH8uSSo5SaHbw3pjkL92Xw2/EcHC4PTSOMPDWgEXKphBKLg4X7MvDTKmvJB5/KLWdHWSPOR71G144yJB43WTYVrexZBM4bwkUHaUX+ScJOr+T+AZ+zNVePTiXzLlF+EY8LqQRiArSVRs2XkltqqxFYXeRMXjlv/3aOl4c1QXOZGW4/rYK4QB3nvXh4aRQyov9oSaCIyB9EJpPh6+tbWTGk1Wr/syVxbrcbu92O1WoVM1f/IDweD2azmby8PHx9fb2KWVwNN1xw9cUXXwDQs2fPGsu///57pkyZAsDDDz+M1WrlkUceoaioiBYtWrB27Vrq169fuf2cOXN44IEH6N27N1KplFGjRvHxx3X0AoiIXE9KMgRvoOqz4aZMWDAJpqyA2G5/37X9w8koNjPqix3kmoT+lE8GB+O/aAQUp1Ru45f3HJ6T83mr3wzOn63pKdWpfgCT2kdj0Mg5V1COj1pBrsnCljMFKGQSujcI4rFFhzmZUyXb3iHOj1bmbcjXPVZ1IIcF7YGvaVp4mlf6vsJTqzNxuj0UVtiRSyU43R5sTjfPLkti0b0dGdYqnLu71yOn1EqwUU2ATslzy5I4milc36srjvP+uJZsO1PAnvNF+BQcgr3vCAFTWEuYN66m2WvGPojuCAPfhuXTL6yTUNJoIufyFHRRy2tky9rE+NI+XIUDGaVGf3zD2yLP2lfz4Sr1lHZ4lIkOG8Fbn0O6fSdIZbgThuBu+xR3Lz5DrslGUYWd90Y1J6jV/5GWV0r/JiGYy0sJG/41soOzkeYcFMx1x/4oSJcnLQF9MJld32DGvBwmtI8m0k/Ds4MScbs95JisnM0Tsmn3zN7PiFaRrL6nJWGKMtwVxbgU2ZwuUzPvwv1sO1vA0ObhlcHvRTweD69vqPqbmz8uCr9V91QGVtUxbHoBEt8HjR+0vEUolfNCUcPxZBSpmHVnY0KM3ntNfj2WQ8d6/jQMMVBmdbLueC5lNqFRetmhLB7u2xCNsu6v4iCDmg/GtWD8jF01pOYlEnhvTHOvJtkiItebiy0Xl7Zk/NfweDxYLJbKZIDIPwtfX98624euhhsuuLpS8cKnn366hs/Vpfj7+zN37tw614uI/G2k76qzzIjfnodJS0AX4H3930VJBmTuF649KAHq9QRjJMhunI8Qh8vF7J2plYFVp3p+RKSvqBFYXUSSm0Q982HOo0MmlVDPT8fApqEEGlQ8u/QoJqsw+A3zUfPu6OZ0jAugSbgBuUzC9F4NUMolnMuv4Jtt53mwnQ7ftW94vSZF6mb69nCzq2U4607k4fGA65LPuDm70nhhSGMKym0czSzly83J/N/YljzcpwFWhxulXEJKoZnnlx2lSbgPn01qje/RnUL289hPkH24ZmB1kbRd0GIC+ERBaToUp1IUM5pRUb7km6xE+WuZ1MqfEY10qDJ3YjyxAJcmgIryeygc+CWqU8vxTfoBbGVY6/WnoNUDKCUyQhcOAn0otJkCSJCe30zk0hHMGr+KdVlKmkb4oJBJUcml7Eqz8s2+Yh5qWITqmxHgsgvXlroDjszHM+xz3M3Gk6+px6ZMOfOnxhHqo6qUF5dKJcilEsJ91GSVWmkaquN/nbXotjyL5MSyysCofURrlkz4lDHzsziWZeL+m+JJCNFzKreqxPFkThktIn04nCEErBFKc51+YtirlUYmDIA9X0F+zVJ0ghLQNh3EE9rQOj2nPB4P3RsEYnW4OJBWjL9OyVujmnMovYSvt57DcUH29/doGu7Drw91Z/H+DPanFVMvQMetnWOI9teilP+xGVYRkT8DiURCWFgYwcHB/2mJeofDwZYtW+jevbvYj/cPQ6FQ/OGM1UVunJGRiMh/hXOb6l6XfQiclrrX/x0UnIEfBkF5tRlJuRom/wyR7QQVuBuA4goHyw5lVf4+NF6Fz4nFdW6vOrYQ/G7nk/GtSC22UT9Yz23f1TR4zS61cueP+1j+QBeW7M9k6CfbsV9Qq2scZuT/xrQg1JVW9yAdkOadwEfbknfGNEetkNZKlKQUmrE63ehUcr7clMyj/Rrya1I2M3cK5YQAjUIN/N/Ylng88PWWZJ5NaI4SBCGE3V/W/VBOrRbK8g7NwRXWiiKJHx+vPc17g0JZ3KOAoBPvQ7oTGg6EdnciW/EIxhPLkLZ/mFU+Y9G060X7GF++P1CC44iNpzzfwaD3wO2EkyuF4KbjfaDUoc/YSojvIO6dvZ+MYgtqhZTx7aJ5orMR3exxVYHVRTweJKueQDZtB6F+MUyO9n4LQQYV03s3YPmBVGYMNKDf8RYcX1pzo8wD1Ft7F6/0+ZL7f87ghZ+TmH1XB3YmF7JoXwYePATqlbw3pgW3fLubXJONK5nGyyuzEeEfAbcsFe73wI/Cita3QaPBqH0iqJWvqiiE8hwoOI1TE4i7wo91Jwo5fSHQW3U0h2k96jOuXRTZpVYM6t8fgMllUmIDdTzStyFWhwulXFpnr1WZ1UGuycpvx3IxWR30TgwhNkBHkJjhErkOyGSyP22A+k9EJpPhdDpRq9VicPUfRgyuRESuNwHxda8zhAsSyDcKFYWw9J6agRUIvTLzxsO928An0vu+fwNyWVUZhsvD5Z+lRBgA3Df3ALd1qc9vx71nE1vH+LHhZB5bz+bz4ZAwIg1STDYPXx0088Tiw/w2JRok0jp7c6xKf5YdyuSHHSnc1jmWu7vV4+ut5yrXJ4Qa2HO+kK7xgXxzW1uOZpby9dbzNY5xMqeMh+YfYt5dHejXJJQUt4KmPpHweyGCRCJsowvinCSasV/t5NtRUQT/Nh1p6paq7VJ3CBLgN38CC25Bv+dDOk4YRq8fcwj3LeHVYU2QluegVNwE+78Ttr9I8nqIaI2657NsOpJORrEwOWB1uPlhRwpPtAjznlkDIUNUmgZ+MZe5BQn9GofQJ9SCwZwMST953zDvOC18LChkEjrVC2DpgUymdo9jWMtwPB7w1ymRSCQsu68Lx7JNoDaBLggq8msfSyXYb5zOMRHhrwefCGh/NzQdKazXBngXnzFlw7L74NwGABRAa10gM4fO5fZfPZzIEfqmvticzA+3tyPUR42xjqyXN2RSCbo6hDMATBYH8/em88aqE5XLvtl6nsd7x3BnSx0Kt11Q/9OHwX94ACwiIiLyVyJ224mIXG8Sh9Y96O/6COhDru/1XA5zoVAO6A1Lcd2D5r8BX42Cm1tUCdb8dNJCUaNJdW5va1HlAxXhqyE5r7ZgAMCo1hFoXWXM7pjFoD230XxxN7quH86nsdt4Z0AYaVYtzgYDvZ9E7UO2IpISs1Am8+OOFNrH+aO64JGllEkZ3CyMV1YcZ09KEYF6FV9vOe/1UHGBOg6klzDl+73cvSyL1CELcJdkCu+nukgYDIXJWCcuQ+ITwecTW9NSerZmYHWR/JNCiWGUoKjqm7GRJuFG0orMPPXTEeLDA8FmqhlYXSTzAJ7Cs+g0Qh5HJZfSNT6QPonBKH6vbM1xwb/JYa5Sz0SQL0/OL2dXciElFgf+uduF7Je7trHjReTlWbSN8WNsuyjGt4siQK/GX6ciQK+q7H8I89XQJzGE6Jj6uIZ/WTvzKpFQ1FMo81x2KAu321O5HF2g8OMtsHJYYcu7lYFVJRUFhP48jjd61yz1TS+yEB/kXQSjFk4rlGZCaQZY6/ZZySyx1AisVHIpCybGclvZNyi+aA+ftYMvu8Luz6Gi4MrOLSIiIiJyVdxAU+QiIv8RjBEwfh4smgyOaiWALSZA42E3lhy7q7ZxaQ0uM9C7HIXlNtKLzKxKykEhkzCoWRjhPhr8dMprOh6AzeWma3wgq5NyOF9QwcH0UlJ69MQ3uCnSvKQa23piu3FcGg8kA4JRa0yAlvzy2vcb5aMiwbwX39VPVC00F+Gz7TU6ND7D4aZPU9z9FYKKk4UA5SJKPbk3z+XF9cU1jrcjuYDW0X6kF5t5ZmAiX21JpqjCQZSflvRii9drAJjYPpqXfzkGCOWKw+dlMb3zGCY1M6A6uQqKawZlnrgeOCLaUxjcjWd/y2PjqS082C2CAUWz6n6IJ5ZDszGQvhu1xMk7o5qTUWIh0k9LhaNMEJ+oA8mRBQTX68CDXYIYEy/B/9xSFDYT8oqhMPJrWPmYEJxVR64C32hBgGP7x0JvWFQHnG3v5Jt9Nj7dLEi3d2sQyNfBJ5A16CFMTNQRYPmGxvHKsHh81AqCfbwLTBSU2ygst1FidhDr3xb3hPX4HfkGdeEx7H4NKGg2lc8O2mmvLUCrkF35n2N5Lhya7X2dpZgweyoBOhWFFUJ5pMvjruXH5pWSdNj2IRyeIwRZ8X2g7ysQ0LBWz+Oifek1fn/mphCaHXge5bl1Na6F354Dpw06Pwjya/+bExERERGpjRhciYj8UUzZglFr6nahvCmuu1DeV9egRaEWBCHu2y0Mxq0mCGsO+mBBnexGQuMHat/a5qsXuVyJYx3kl1l5YdkxVh+rKsP7bGMyt3aM4ZG+DfDXXVtviEouY82xHJ7on0BaoZmNp/KYcdDCK8NmY8zZifroXCFL0e4uLMGt+N/3p3mggbDvTwcyeXpgI/alFtc6brymHN/tr3s9p/r4App2fYQ5Z5U07PgNjZT5BJqOUygPId/QiOc2FHMks6zGPh4PPNqvIadzyvhg3WnO5pXTJExQkiuusNM1PoD+TcLw1ylJLzazYG865wsqUMqlFJurGsWLzQ5eWZfNF7uK+G7kHBJKtqI8thDkKspb3Ik9vD07cuU8MPdg5T42h/Py0uJuV2W5pCu+H/fNOUB6sYX6wTo+GBYH7ss0qrsctAjTUD9zGcYFb1UtPzILQlvAiC8FRczqTWfDvxKk41c/WbUs6wDy/d9xy8ifWO6vJa3ITGqhGVOTNqhPr4Gmo+DIgtrnD2mC2j+CBvq6rQzSisxMm72fY1lCkNczIYiEED0F9tuIj5KSYvKwfE4hbreT9u1hVNvIK1f8ctqEnzqQl6Xjq21cGVx1rh/4+8cszYSZN0NRVRkpZ9ZCyja4Z0sNTyqPx0NeWdX5pRLoFQHKrevwyrb3oflYIbgVEREREfnTEIMrEZE/QkkqzBxec/AjU8LEhYKpa10BllwpBGKX6TW5IdCHCbPkvzxYe13r20AfdNWH3HWuqEZgdZFZu1IZ1CyUTvWvLbhSyqWMaxfNoI+30iTcSPs4fxxON8+vL2R8+940GNAHmUyKW67F7faQEGIAhMAnx2QlKauUx/o15LONZyslr/20CnSe8rqDS0BalMzMnVruvymeMrc/xsCmLD+cxZIDQsmkTCphcLMw+jcR5F2j/TV8s+08P1cT37i/Vzwnsk2E+ajpnRjCl5uTySyx0DBEz7Se9TmVU4ayjixHfrmNoTNTWHbfWMp0vQj105FpVuBrV/BbUs1s1rrkcu7qPI6gukRVGg2Gc5uwJY5m8VkPyRe8lU5kl5FskhOWMBaf9D1ed61oPI4IZQXGHW/VXplzWJAz7/YEHF0oDOhbT8ETnIjky7tqb++0EbrxMR7t/CUPrzCTVmQm29CU4B0vQ/83hAzOieWVgZonsh3ukd8g0wd7vy+goMzG1Jn7asjobzmdz60dY3hjVT5LDlcpBKouVApelYeUUif0YtUhbmILaEyuSfD1mtg+6sok1NN21vxsuYjDApvfhaEfCudF6E0b1CyMFUeyAfDRKFCaLmPabK+45syziIiIiEjdiMGViMi1YiuDNf+rPfhx2WH+BCEzdaMHT7+HTAaJNwuDxnUvCvLf+mDo8gg0Gw1qn6s6XInZXkPM4VK+3XaeVtG+qBXX9tEUHaDlg3EteXrJEY5lmRjULJReiSE8vOAwpRYh62LUyHl2YCLTbqrP2f1VAc43W8/Tt3EIn05ojVGjwO3xUFxhp8CSz+UkO6QqA79N8qekIo/TZQo+2VHO9F4NWHU0B6fbzQdjW7IjuZBHFx7C5nSjV8mZ0D6aN0c24+N1Z3hqYCPSCs10jg9kzu40FuytKu06nVvOk4uP8NzgROoH6WgYoq9UnatOsEGFUaPkh51mVh45i8PlwVer4PbOsTw1IIG3fxVkxJPzKziraY5/aEtkOYdqHsQ3Bur3xhrYjI22BF5anlFj9dKDGbTv0xsCGwgKktXxi0XWYiwBOz6q+0Ht/x5GfgMqvVBCt+VtJB2m1d1DlX+Spn5VWbbpK/OZM2IBkVueQBLRCibMB5cDtz6UPAJQq8Lxrfvs5JXbagRWAG4PPL7oMK8Ma4rb7WHZoSwMahmT2kWSc2wnftqrKJkzhELPp2HVE7VWuYMbc94ZSHxwCff2qE/bWD98f+/YLudlyzA5uxaspZXBFUCraF9iA7SkFJox2124tb9j6aDQXH69iIiIiMhVIwZXIiLXSkWBIM/sDYcFco/984MrAK0fJA6BqHZC2ZNUIYhuXIP7vMPlpsxatyBBidmBw+XhCtSpvaJXyRnUNJS2sX6kFVagVykY8fl23NUq0UwWJ88sPcqCu9sBkBBi4EhW+YV1DkJ81BzLKOHppUKf1gt9wpgS2QFpxu7aJ9T4oXKUwpyb0QLhxgjaDvyEdC0sntaJU9ll/HIkmzXVMnXlNidfbz3HHV1i+XBCS/B4aBJhxO5ws/CSnpmLfLLhLO1i/Xh6YCIPzz9Y6cMFoJBJ+Oa2tjy55Aj7UqrKGkvMDj5Yd4aHejegR8MgNp8WVPHuXprJD6M/p2n5TtSHfwC3E3PiWOwNh7LuvBWjbwLTFtQWMVHJZRRIA8jvM5OG+b8hPzQLPG4czSYIgXZxKjLrZUQS7OVgLoC1Lwi/64LA46p7e6C6GmJakZkRC5z8NOUbXOWFhChdyBVy5KdWEVCagbTNFJDUB62/1yMVlnkv2Ss2O5g+7yBrH+nOgGahyCQSPG4Xq479zqVdilQGTUYJQdHmt4TARyIRZO4HvE0jeTA/JEhrBVUWhxOb3Y1WJUcpr/Y3JZEK4hl1ofapLOG8SJiPhjl3deCzjcksOZDBObsv4YYwKMuuvX/93qC9gtJEEREREZGrQgyuRESuFZf98v0r/zY1rj9BxdBHo6BXoyC+3eZdmW9A01D0l5GavhJUChlRflqCDSr+tzSpRmB1EY8HftyeSj8jvDa8KTa3YFZrVMuRSaS8tOJ45baf7iyk9/j/I+aXsWCqynSh0MDQj2Hre1XLTJnoF43BOH4dA+fm8/3t7WoEVtWZvSuNMW2j+HTjGZpH+BKoV9XywLpIqUUIOrOKzXw4vhXHs0o5kV1Gg2A9rWN8KTY7agRW1fl+x3leG9a0MrgqtzmZtCCNH28fzsn4lsglElacsbFrzWlGt4nAmVF1vRIJyCQSnG4PY9tGMn3uIcx2J3PuvJMzql6YLA5sEg3Ddn+P/tQSIXNzZKH3m4jrAZn7qn6vyBcMjqUyodfrUgLiOVla870QZFCxMc1FS18l0avvRZZ7GLgge3t4NrSfKlyDl4xNsLHuMjy5VIJSLkV1QdnQ4e16rgRdgHANiUMF8Q65BnSBSNVGLg1jyq0OUgrNfLXlHOcLymke4cvtXWKJ9teiUsiEyYu2d8CBmd7P1XGakEW+hAg/LS8MbcwDveKRScAVtgjZ7OE1P4+CGgklhZqryzyLiIiIiPw+YnAlInKtqAyC8p8p0/v6iJbX9XL+CSjlMiZ3imXRvowa2RcQBs4DmoZeuYDA72C2uTiZU3dPSUphBRhh/Ne7CDJqcbncvDSsKYF6VWXPFUBRhZ339zt5ZeIqPNlHUWTvg8B4tCHxSNa9KMiXV8ftIuDI1wxtcidpRXUbQttdbtIKzajlMjKKzSSGGfHVKipl2y+l2Gxnz/ki7oryZUCTULo3DOLbredZfCCDKZ1j6zyPyeKsoUonl0p4Z3RzPtpwlp3JQn9Qk3Ajd3SJZUrnWJ766QgJIQam9qiHXiXH6nAR7qOhuMJOalEFX09uy6Rv95BVKvQPrb89Gv3GT4WJBqkcQpoIWdvqyFVC0LHkzprLkxbjuul5ZOtfqrlcpsDU70M+WllauahTPX+m9Yxn7q7zDA9dXxlY1WDPDJxNx0CEXy0lviC9mjYxvuxPLam126jWEX+eya5MDr5Rl93E5nDx2/FcHl1YdQ9JmSYW7ktn1p3t6XRR7MI3Fro/CVveqXmA2O7QeHidyqJqhYxw3wslf8amMHWzUMpZkgbBiUIJqOEGsnwQERER+RchBlciIteKIQwGvAkLJ9deF99HUAz8j1Fhc1JstuPxgFEtx8dLX0mUn5al93Xh3TWn+O14DjKphJtbhPNQ7wZE+l2ZgECuyUqpxYFMKsFPq/CqMKhRymgUaiQp03uAFRugA0pxuT2kFprp1iCQ+CA9dlfNbGSkn4ZBzcJo+8kBgvQ6ovwHMtpoYMzqaZBzxOux1flHiI8HvUrmdf1FtCoZY9pEkZxfzsH0El4e2gSby80bq07UCLKahBs5m1fO8iPZtIzxw2JzMrKZH+MSZExqGkZUgJIGoyNJK3Xy9X4TaUXmyn2lEuEexraNol6QjkahBpwuD+PbRaFXyrmlYwzJBeVsOpnHO2tOMb1XA3w1Cm77fi/5F0rp5FIJt3aKYc1D3cgqtVYq3hlUcrTlqVUZ3F+fgZFfwdn1QgbLXo4nvjeebk8gXfu8UCpXDZe5mOL6I9CFtUW180Okpgyc4e1wdbyfDZlqvrglEIvdhVYlR6OQkV1iYXxjNT5b6sjmAJ5937OuNJJ2sf4EGqrk2P31Sj6Z0JqnlxxlyxkhiyeTShjeMpxH+yWgVV6/r8P8chvPLj1aa7nT7eGxhYdZen8XQoxqoSS30/3QZAQcWyr0eTa+WVDpvIx4Rw0kEsHo+wYy+xYRERH5NyMGVyIi14pEAnE9BWXA3/4nzAyrjMIMffu7L98v8S8ktbCCd349xa/HcnC5PbSP9ePFm5vQMNiAoloviVQqoX6wnvfGNsdkaQyAn06B5gpELMw2J7vPF/G/pUcrMydNI4y8N6YFDYMNSKVVM/lqhYy7usbx04GMWqWBEgkMaxmO5ZxQ5qeSS3l6YCNiA3UUlttIDDNwIlsQP7ilYwwfrTsjlOWVWskqtdIiVIXHLw5JHcGVxy+OfKsUhclWKTBwKW1j/NAp5Uz5YQ9tY/zxUUtZeSQLtwc+GteSe2cfwOJw4adV8ET/BJ5aIpzrSGohr3TTotv0BGHGCAhvASu/IKzgDPjXo3+fx1leEM5rG4Tyvv6NQ9h2toDCChsNgvXM3JlKswgfejYMZHrveKbNPkBmSVWGbcWRbG7pGMOIVhHM2CKIj/SKNzKhgYewzNWEWkpYN7EFW3OVvLEpFxTVAmJrCcybAA36Qf/XQa7GHNQcu9wHQ5s7kZemC0a4Sh0Vzafg6TiNxUctdAkNpGHfN1BIXEisJtzmIvrERCLRq3B4YN2JXD5cdwaNQsasMVE1/eEuQeEoZ01SNjuSC3lqQCP01Rr4KuxOOtbzZ3LnGGwON0q5lJxSC9fbWS6j2FIjO1qdrFIrxWa7EFwBaHyFn5DG1+36RERERESuHTG4EhH5I2h8oGF/CG8pDPikCmFGWXaNigz/UDKLzYz5cmcNn509KcWM/HwHKx/sSnxwbe8hvUqBXnV1z+lMXjl3/Li3Rm9SUqaJsV/uZOWD3Yi6RDo7OkDLV7e25YnFhyszQUaNnBeHNGFbcgFtJNCzQRBTb2pA2AXT2QC9ik8mtGL8jF0UlNuJ9tdyPLtm9svlBtrcBid+9n6hrSejOCPh841neWtUc55cfIScCzLcAPUCdbw1qjmr9p1m1Vh/As8sQG3OprB9PzJ92zD/WA4v3dwYk9VJbICWV1ccJ9dkQ62Q8mQHNcZZfSGqA0S0hiXVpMyzDxG8/BbGdH+JY806cbrQwRMDGrH9bAET20eRX2bnqQEJOF0ezuSVsfVMQWVgJZFUWVDN3pXK15Pb8uOOFPo19OGlxCwCFg0Hl/AMtcDoev2IG/kyORIXYSpjlUGwxw2nfxUCrfZTsTtcWBwV+DUfTbK+FRZzGRa3jNlJVqbZDQwPTSfUUwAbZsPpNQBoAPTBWMcuYE1+ID4aZeXr/+muAp6r1x/1sfleH31uvRHs31hKZrGFO7vVqwyuskstTPx6d2U2rjpn88p5ZlAiasXlM43Xi7p670REREREbnzE4EpE5M/gTxB7+Cez6XR+jcDqIjanm082nOXNEc3Q/kGhCpPFwXu/nSLST8OkDjFEXSghPJljIsJPQ3aphQqbE1+tktALgZJWKeemhCBWPdiNgnIbTpeHrFILB1KLaRnhC1kQ6adlynd7eXt0cwY1CwMgPtjA8ge6kpRZip+udmljkMaDJGOfkJ1Z/6rguwQgV8NN/0OSsZdA9QCySq38b9lRPhrfErvTzem8MuKD9RRX2HGYS5ms243vgqcrjxtwcgUBxnCMQxeRLdHy3M/HSM6vkl4f0zyQ4IMfC8p7rSfD8ge8PiufHW/y8p07WXpexuqkbDrVCySlsIIwXzUahYx8m40ofy0rjmQztkUAd7bSY3AW4ZEqSbZoeHVzMQdSi5hzVwcaKvIwfjO4lniL8txvNA5vz0cVfYkc9DVBy2+pDL4Y+DbYyuHXZ/Arz8XPEAY9n0YaeBND5gjZwnaxfvg68wk98aMgz34hsKqkPA/13BHUG7KCqUtzeW9MC6bN3s+iw4XcM+UBos6uqgroLuAObkqyvAHpRYLHWFG5/UL5J6QUVHgNrADm703nrm71agXnlZiLBcW9s2uFKLR+HzCGXbPpd4SvBpVcis1ZO3sValTjfzUS8CIiIleN2+2pUekgIvJnIgZXIiIifwirw8XaY7l1rt9xtpAyq/OqgiuPx0OuyUpBuR23x0OAXoUECNQrGdcuis82nuVEdhk3JQQyoX0Mr6w4TkaxkIEJ81Hz7ujmtI31R62QIZdJCffVEO6r4d01JzmVU8aE9tGkFZThD3Sq749areTTDWfoEOdPgF7o35IAerWcAJ2SDnH+7D5fVHl9SQUuzIZ8tOX7YOxMYZAtlV0oV/PgLEzlRLIwcI7y05JfbmPH2UKGNA9j6qx9hBjULBkfiu+mZ2rfvCmLiH1vY+vyTo3ACqB3rBL5ht+EXyQSoQfHG04bFYXpvPxLBUaNghCjmicWH+Hj8a14flkSm88U8OnEVrzUJ5Qh9tUYFn0gqF8CEYYwZg38hp9zpaw4ks2jutV1qmL6HPyS7jf149kDBt6YvAXf5F9Q6HzwlKQh2flZ1YZl2fDLQ8R0f5Lxrfoy/2A+0f5a9KZkaNgPlk/3fh/WEsIsyUgkembvSmVEqwhm707jnpVFfDVmFRFHPkV6ejUoNJia3kpq9CjuXZhWubtGWZWJSr/w/oj21zKmbSRhPmoyS6ws2pdORrEFm7MOhcCKAtj0Fuz9utrC56HDNOj++DWV/wYbVLwyrAlPLanZdyWTSnh3TPPLKhuKiIhcG263h8wSCxtO5rHzXCEJIQaGtwwn3FcjKHSKiPxJiMGViIjIH0Iuk1xWac1Xq0Auu/IZQrvTxYG0Eh6cd7AyG2ZQyZl9d3uGtgjnrh/34faAUiblts5x3PXjPpzVmqqyS63c9v1eVj3YjYTQqnJEp9uNQSWna4Mg7pm1H5nEzTvt4f55BxnUPIJnByVycSLzfEE5E2bsJspfw4iW4Tw7KJHJ3+2pNCJec6KA9+67HeaNFIKq356D9As+WBIpsmZjub9TF3o2ieJ8QQWPLTyMw+VmcucY/HRKtCoZ2oxtddZ/Kc6sJLr3K/RODGbjyTzcHqFHq3mUHyj1YCkWfJAug1uqxO2poMTsQKuU06V+IEmZpWw+I0hyZxSZmag7hWHT2zV3LMsmdOkYJt6xlac2lKPSWKB+L8H491IVwIoCWkQYCQqP5eM96ZzN7843Q4PQreng9Zqk2z/kf3eP56cjhZwrKEdtzQWtL9i9S/MDKEwpBOjasP5kHp9MaMXs3Wkczy6n749mtj7yFinx0ykyO5l7zMKWTecqH2lsgJYAfVUGqH6Qnvt61ic2UMePO1I4X1BBvSAdD/dpQGqhGU1dg6usQ5cEVhfY/QU0HAD1e9Z57XWhUsgY1CyMhiEGvtyczPmCCppF+DC1e31iArR/mmKmiIhIFadyyxj75U7KbIJS7a9JOXy28Szf3taOzvUDavQGi4j8EcTgSkRE5A8hl0q5tVMMi/ZneF1/T/d6ldmgKyGj2MKt3+7G4aoKPMpsTvacK+a3YzmV4hRDmofya1JOjcDqIi63hxlbknl9RLPKPhq5VEqXBoEcOX2en2+JpsLuJjv1PPd0r0fjCH9WHs1m8f4M7upajxlbk3lrVDP2nC9i9bFcskutLLqnE6uPZZNWaKZXo2DkllMwcT78/ADkJlWd3ONGcmQ+wTI137pv5bvdVVm9cquTLya1QSYF6dnaRr2VuF3klFaQEGzgmYGJpBeZOZBWzNFSJe1a3oF288tgLgLfaEFe+1J0gaTb9EAxcYE68susDG8VzmsrT1RuEqupwJixCRr0hcz9wvEu4jCjzN7PEx1bIDfFg7UAYrtC7xdh6/9VBZIRrcmugNXJOVgdLu7qWg+HKRncdRhFu+zonSWsf6wHHqsJmc0DpWmCoXBFvtddbIFNyCq14LrkdY700yJTavEPjeWBb3aRa6oq+QvUK5kxuS3B1dQCo/w0qBUynlxcJUKSlGni8UVH+N+gRPy9lH9iK4ftH3m/F4Cdn0BkO1Dp6t6mDgxqBa2i/fhgXEssdhc6lfyG6fkSEfm3UVBu46H5BysDq4s43R4emHuAXx/uToSf5m+6OpF/G2JwJSIiUpOKQrAUAR5Q+4E+6Hd3iQnQ8UT/BN5dc6rG8oFNQ+mRcIWS0QhB0aJ9GTUCq4uE+arZlyYY5arkQtbquWVJtba7yNHMUipszqoBq91CoiyTZgFnIP0QjhNryI57gXGNFPT79hAVdqEsbETrCEa3ieKBuQcqvbj2phRxJq+C5wY34kiGiVJTCfIjnwqqkLner0FxZA5jRt3Jd7urlpVYHDz03R5u6xTLA4271f0BHN6anRkOZDIFLy8/xqDmYfSrr6WBuhB5fHc8Z1oj2fkp9H8Dfrq7pnqeTEnegK94Y1MJAA/0iifSV4PF4aoU9Xh7UBR9I5xQoBPEVwa8Lcikr31eOJYhFGVANHELB9c0n1VoYMQMYZucI9j7v0u+RYtW6aJv4xDcHg8K1eUHKG65Gp1KhrLgFJLik8Lz6zgN1r9Se2P/epxxhlJiTqNNjF+lb5mPRsGnE1rhr1fhr1ex7L4unM4r43ROOfEhehJCDFU+TxewOd18tvGs12t6f+1phrUMReOxgkwJF/UDXTawFNZ9MxUFwjZcfXB1Ea1Sfl1l4EVE/osUV9g5nVvudV2ZzUlGiVkMrkT+NMRPdJHrR0WB8GMtAa0/aAOFf0VuDNwuyDsu9L9kHRSWBTeGoR9DWAuQ191k76NRcGvHGAY0CWXjqTwsdhc3NQom3Fft1YOqLmxOF0cyS7yuq7C58NMqKaqwM6xlBIfTS4j003A0s9Tr9tH+uqrAylyEJ3038q3/d8FItTH0eRGSPQT+Np1vR3/A+LnnkEgEsYEnFh2pDKzu6hZH+1h/tp8t5L3fTtOxfgBNw42QqRVkxevC5UDlrgp6Wkf7cTzLRIXdxeebk+kW2YC2CUNQnFpRcz+pHEvft9i/V8qkDsGUmB0UFRYQU74J9ZaXhbLAAW+CVIYn5yhM/gXPuc1Isw/gDmqMO3EodruaJkGlTOoYS0GZjd+O5fBI34Y0DjNyXwd/+pfMRfbNp1XnPDATYjrDsM9g8R3Q4V4kvz5VM7ACIaha8RCM/Aa3PhRP1lG6lPxG5/A2nHBHMXVZNq/2DqSvbwyUpNZ+JgHx2JR+JKdm0GbHG5B/HEZ9I5QFdn8Cdn9Z2Ufmie3O+S5v8diCbFRyKU8NaMS6E4KwRcd6/kRUC57CfDWE+Wro0bDuQL6w3OZVQKJBsI4vhgThf+grOLcejOHQdqqwUmUUxCsuLYes3LmvsI2IiMgNjbcKh+pY7XX0XIqIXANicCVyfShJEwZtGXurltXvDTd/Aj4Rf991iVRRkgbf9a/Z/5J3HH4YBPdug6CEy+5u1CgwahTUD9Zf8yWoZFIahxnZfrZ2tuCXw1mMbxfF55uSualREM/+dJS3RzVndVKO12Pd1TUOnUoO9go8+39Esv6lqpXluZCyE1rMQCqV0EJbgK9WwcT20RSW22kZquSl7lEE6xVkW+U8uLxKMGPZoSz6Ng7msxbDUSovo+omlWOXaVHKpAxvFc4tHWJ4YN7BytW3zT/LzulvIQ3vht/hr8BciCuqE/buz1CiiaV1dCkvLk8i2KDi6V4qdN+9LOxoLxcCYEMYkog2uBrdjETtAwot0vRdSLe9R6RUzkuDPmZeqYaG4SFEB2h5ctER7r+pPr0NaSh+/bT29abugHo9IaINBDWC7MPe78tchFumRPrjYFSW4srFzX2imD9mPtN/LabJwG8JXzpamEi5iNafzH4zcLiNmM35SAtOCmp/CydDi/HQfBwkDgW7GSSwtzyIp3/OoFN9f6b3akBMgJb2cZdMxjisUJYjlCmaCyC6I/hEeTXYlctq91P465R8P8SHyJ8G1bzWpJ+hxQxB5KPt7bD/+1rKhKh9oNUtIBO/RkVEbnR8NAoCdMpKA/TqSCUQG3jt2WcRkUsRu/dE/noqCmDRlJqBFUDyelj1BFi8Zx5EriMuJxyc5V1YwGWH7R9f1rj1z0ImkzK+XTTySyRyo/219G0cwqBmYXw3pR3R/lqaRviw/mQezw1ORFWtEVkll/Li0MZkmyw43W6cZXlINr5W90lbT0Z2biPdGwTSsX4ATXQlPO38ghZLbyLsx4603nInPw2VM7CRb+Uua4/nkWVsgcdhrTPodDcfh7+vL4fujeA1n+U0PPQG8wd4+GxYJCq5FLvLw85cGbcnNWVjl5mU3bGNHc3fZMzSMsZ8e4BTuWU83i8BP50S6eE5tU9Qlg0Fp5Gl70K6+nE4ughStgoiGS4Hql+mcXOci2+3niNIr+JIZikKqQfFge/rfhZHFkDLSTg1l1fAk5ak1u6rKk0nauuT3Jyg4/ZVZpJuXkn+gK9wdnkM8/DvSRvzK49ttlNhc5Fa6gK/WGE/pxX2/wDfD4SvusP3A+DsehLiopl7d0feGtmcBiEGlPJL+pEcVji3ET5rC0unwppn4etesOh2MGXXuuYAvbKW8MrUdv6EbX++ZmBVnfI88I2BO9dCvV6CQqNEAvF9hGW+MZd9TiIiIjcGIUY1L93cxOu6aT3qE+Ct51JE5BoRp9xE/noq8oWGeW+cXgXmfMGMV+Tvw14hDMzrIn2nUK6l+JNr0t1uqMgTShKVOtD4Eumn4fvb2/HgvIMUmx00CTfyWL8EXltxnBeXC+VZBpWc6b3jyTXZ2H62kE8mtKLC7sLj8WBQK9CrZCw7mEXH2AD8Cs8jr0tgAUCuxaMLJMKtIV5Vin7eyJolbdmHCV48nPdvW0u6yUhSlpDBuGVBKktva0/AiG+Q/vJAjUyPO/FmnN2exv/QTORb36lcHr7/K4KiujBz7LuMm5uCSiHjUHopAcOaMmrO4Ro9ATN3prLmWA4L7mqHurQf1O8iBCJHFsDZ9cJGzccKWZU6MCTN5q5uTyC7EKwWlVmQ2Yrr3B6rCXN0D84V2miq9hH6sC5FIhEyQ15k4GVp2+nZScrrG8oZMrOcaP8Q3h7VlycWH+bFoT68ONCfMI2NXyxyito/hv/Pt9Y+vlQOzcfho1Hic7m3W1kWLJgkvHeqk7oNdn8Fvf5Xw8w71Kjmi0mtmfTN7srywO5RcmS7LvO+z9gDIQ0huBGM+aEqCNP4gVosBxQR+acgk0romRDEgqkdeWfNKU5km4jw1fBwnwZ0qh9YaTYuIvJnIAZXIn895ss0hHs8dXv1iPy12MqFwLcsRxCtMF6mPNMQDvI/2XunLAeSlsDOT4XriOoIfV9BFdSIzvUDWXnB+FejkDHi8x2UV1N5KrM5eWPVSf5vbAt+O57D1Fn7K6W044P1jGoTSe/EYCZ8s5PlQ6Wo67oGAIkEc/RNNC7ywadwh/deIbcL5aaX+XzUl4yfeYKsUiv55Xa258iZv9fMV8NnYvCU4baZKXTrsKsCkOWmEF4tsLqIIn07DePWM7R5V4rNNr6c1JpjWSavzdYv9Qom7MR3SHZ9JMiva/ygzRRIHCb0Pmn8hQxWHShMqTgdNoxqoeRld1oZQxsMR3epYe8F7PX6sitPwcw9eXzV8wVUvz5W+1G0vg3pmbV1nlPmqlLtyyuzUmy20zZCTWt1Dv4HvkGSe4zHAhORRjwM3Z+E7R9UmQ+rffEM/j8kyisoLT27oXZgdZF93whiI9VKjiUSCS0iffntke6sOpLN4cxSQvS/M6C6eF0gTACJk0AiIv9YDGoFHeoF8O1tbbE4XChkUgKvQslWRORKEYMrkb8e3WXU5iRSsSH876A8H7a9D3u+EgaoKiMM/wKOLfW+fddHhR6TPwlnWT6yXx5CcvrXqoUpW+Gb3jBlJbKYzpXGvzN3ptQIrKrz3bbz3NoxljdWncDhctO/SSgjW0ew+VQejYJULBkdgN5TIohA2L0rRdm1Iby2pZjxXULQ7v/V6zYAsrSdFBYXc/9N8fxvWRJdGwRyML2EXecKuX2Jiw5x/pzOlfJw3yiOZ5QwMtNLKd8F/I58w3u33IxEKgGphOfX184m3domiO4F81Dt+7xqoaUYtn0ArW6F1rdB4Vk8EW2RnPEeLJVE9KTMISVQJ+XBXvGsO5GLoldH8IuD4vM1N1bqcHR6iNfnnyez2EJO/wFEjglCtuFlKEwGQyimdg+hSeyP9PM23m9M7UuhqyrdNK5dNCeyinmucQEBs26rNCNWZB2Ao/Ng0mKIXSyU38lV4HYi2fW54B3WZESdzw8Qsq1SmfcAy1bmVQ5eIZcSE6Bj2k3xuN0epJZCQaylrv6yKO9+XSIiIv9cfLVKfP+E45gsDgor7JgsDoxqOQF6FZp/0ag612SluMKO2wN+OgWhRrXowXeF/IveBiI3LNpAiOkCqdtrr2s8wmvzuchfiNstBFG7qg3abSYhuOn5DGx+u3IQjEQC3R6H8JZ/yqktDhdphRUElafgf9pLIONxw6rHYfLPlUH5vpSiWpvJpRKi/bVY7S461vPn80mtiQnQciyzlAhfDYOah5HoPovP7CHCAHnAm/DLQ1X3BZUljp8nyVlytAClOoPWxijqdBrSBpBf7iDIoEKjkDK5YwwPzBUEKkxWJ2qlnPUn89ieXMBvD3VBca72dVdiM6Ey50BxKjgtPJ8QStugCJ5YlVm5yS1NNegWzfC+/+G5eG5dRq5Th6ER6M6urXlvAEM+xCe8NcMPfYTkdBaPxHXnkYk3Idn7FQx+H8/xZUiSFoPThiN+AJZuz7L0vJyCMjvvj23Jo7+cZ0CTpoyf8AvJ2UUUWtx8vr+cvuYS7m48CtmxxbUuy9LtWb4+ZEEpkzK6TSRNw43EKIoJXPNQ7evzuGHJnTDoPVj+gBAkXQyIDs2BhgNBcUnO0WG9YGacBFo/GD9PEOLY8XHN4wc3BqW27ucPSKUS0AXCkA/guwFCb+GlXIENgYiIyH+PnFILL/x8jLUncvF4hK/KAU1C+d/Ahn/PBZmyIPuI8N2uC4AWEwRxH43vVR/K7nRxKL2URxceqhRyCjaoeHtUczrU8xetI64A8QmJ/PXoAmDkDFj+oCBiAcInUeJw6P86qAx/6+X95yjPga3v1l6++0toNgambobCM8JgN6I16IL/lP4St9vD7nOFvLfmFDMb76t7w9xjYDVVBldNwn1YflgoffNRy7mzWxxNwn04mVOGVinD4xGUBFVyKY/1a8hLvxynV7ScjmeeFsq6UrYJ5XQTF8Cp1VCcijuyLblRQ+HYOb7ZnQ1IWHk0m+fuGoVu+/teL6u05VS+PVzBLR3dzLi1LR+sO0OZzUmzCB/u61kfq9NFz4ZBbD6Tz7c70ngifhj6kyu932O9myBlu/A6GCPQt72d4WEKjrcN5Pt9gvy5zl1atxmv24XNo+CUO4oIOURO+An1r49C0Tlh9dBPkeBCMqN75S6SkyuEZ3rrT7D4TiQhTWDIB7hDmlGuCCG5VEJ8iJuF93Ri06lcjmWVUmK2M6hZe746lMPqY4Iq4+F0CWMefBGDfwOUe78Q+pB8oqDzdFRqI+/3D2B/xziWH87iySVH2HqLX02D4upYioWMldNWc7lcI2S1q2OvgLPrYMldNQOhZqNh8Puw4uGqZQPevHzGvDqhzQQ1zK3/JwRq+iDo9Agke0Dte2XHEBH5F5JXZiW1wMzOc4UEG1R0qh9AiFH9nze7LjXbeeano2w8VWV87vHA6qQcJG4X/a939XBpJsweBflVJvHs/EwwfW97x1UHWOnFFiZ9s6uG32RemY07f9zLiundaBwuVhv9HmJwJXJ98ImE0d8KyoG2MqHETBd0fZrCS9Ih56Aw4x3doU6p5qvCVi4IMeSfEkxHA+JBH1J7pv1GxOUQyrC8cXSR8Hz6vPjnnUsiA6mUXJOVxxcdxkejxK28TEAtlQmiBhcY0CSUzafzmNwpjjAfNbN2pbL5dAGd6gdQYXPyzNKjDG8Zgb9OwebTBaw/kcejbSJgc5XsOSd+gdO/CvL/PpGUGxvywKpibq8m9hYToGNPkZYugz9Gueoh4dvyAva43pwIGsDuted5vL+a27/fi9vj4ZMJrUgvMvPxhjPYHG56JgQxpUssb60+gaVNO/T+9SoDnkoUGkHCe+GtggJj4VlY8z8UrSfzQMfplcGVW3r591K+TQZSGPLVflY+2I2UTj8SpbHjkcqJD9Qg/bJT7Z0q8uG356H3C7DgFji2FGlgQ+wjl7DxlJnlh7MoNjvo1SiY76a0Y+HedHQqOa8Mb8pNicHM2HKO4go723Nk3JQwDGVgLMjVQl/lgZlIsw+h94nCr98ClhwQsnDSa6kiaT+1tq+aKVNQHb00A3Z0MYQ2F8r77OWCIXJEHWWL3pApBcXHIR8Kn00yBSgMkLyqcpNSi4OCMhvHskrRqeQkhBgINqpqKxiKiPxLyC61MHXmPo5mVlkQyKUSvpjUmm4Ng/7TAVZBhb1GYFWd9afy6N/+Ol6M0w67vqgZWFVezMs4G/Sn2KmppZRaFw6Xm9m7UmsEVhdxe+CzjWd5d3RztCoxfLgc4tMRuX5o/ISf64Xzwuz2jB7gqOZRE90RRn8vmIVeC+Yi2PM1bH6raqAnV8HNn0HCQFBdu8/TdUGuFMQrTJne1/8ZJYClGXB+K5z4GXQh0PZ2ZPIwCsrtFJTbKQ3pQKBEWnugDNDoZqFc6wIBBiW3d6nHpxvOMLZdFP2bhHA0s5T1J/JQyKQMaxFOiFFFYpiBRxcKvTMepEJ2tFqAhMshBFiA3acpdldNufHbu8Ty/OrTTO/ant5TdiA5vxmZ3URFRFd2Fep4ZkEqfRKDySw2Y3O6eHNEM77bdp6D6SWVxzhXUMGKI9l8MK4l6zMraD1gDlHHZqA5Ph+cVjzxfZF0mAab3qgte39wFn7tpjKkWSjlNhceXaDgN5V/svYzCqjP0RIlB4oKaBLuwyfrz3BH1zimLTiMv07B/HZH6xZ7OLcJ+r5S9XvBacymIj7bVPV+WH44iw0n81hwT0d8tUKQM7ZtFL0SgnG6PQTILMh/ul+QQr+U0nQa2o8z686elNucaHwtwmSKN+VBtU/t7FyzscJ9X8rhBd7fLyBIuU9aLPzt6UO8b/N7KLVVpYSOKiGLgjIb7/12ivl70yuXqeRSPpnQim4NgyqFVERE/i3YnC4+35RcI7ACwYj33jkH2PBYD2IC/ru+UKUWx+9vdL0w58OBH+pcbTu4iDdMw2kT40e/xiEEGy8/aWexuziSUbc9zrGsUirsTjG4+h1EnyuRfy/lF8xlL+2lSNsFOz6tXYp0pWTuFwbH1Qd6Thssvdu70tyNhiFMkKn2hjYAwq9i1t8bxalCD8uye4UyvAM/wIweBJyYxbSOQqnWZ3vLKOr7kRAAVccnCvq+JMiyXyC/zMa02fvp3ySUaH8tr644wcfrz3Isy8Sh9BLeXH2S77en4HB6KLcKA/XfUuw46/WtfW2hzaHRYBSN+uO+EHgZlHKeGdiIpMxSMootPL3iHGtz9SyW9OOe893pu6CMZ9ZkM6RFGGPaRFFhc7H+kR7o1fIagdVF8spsrD2eS2qhmcE/pvCcZQKHh6/Hev9h6PsaLLmjtucbgMeDp+AsoT5qJraPJsWiwT7qRzCE1txOF0RG/295fXMRUokEj0cwNv5841k+HNeC10c0Rerw4ldWnUsCGqu7dnqp3Obku20pWBxV2wYaVIT6qFG4zEjSdtZ5eOXZ1czdnca02Qe4/5csyvu9X/u1Vhlg/Hwh6zvwXWg1GaasggFv1O518nigKLnu+ynLETJo1xpYXYb1J/NqBFYANqebe2fvJ6vkr/d+ExG53hSU21m0L93rOpfbw87kyygA/wcwqm+gwMLj8e5PeQGZvZRis53nliXx+OLDFJRdftyjVsiodxlD5ZgAHRrFDXT/NyhicCXy7yVtV93r9n8vlPVdLZZi2FJbXhsQPuT2flNTvvlGpeEAoR67um9VUCNhcOsbeU2HNFkd5BYW49zwBpTW/mKWbXyVWxorkUsl/JRUzHtpDUkbv5HyDo/gbDoO2/BvSeq/kEyCcbrcFFfYqbA5WX8yD6fbQ4NgPdvPFpBWZK517EPpJeSX2+jRUBiU/7C/kKyOz1f13dTrCbf8BP1fx9NmCsZTi1jeIwuAT8c1YdvZAr7bngIIL+OzS4+SVWrh1eFNmHVHez6d2AqpRMID8w7wv2VJON3uyrI3b6xOyibER4PD5eFsoQ1/tQTJkQVI7OXCe6gOXEo9aUUW1Eop8/dmMHZxIUmDllIxZiHWm14hd+hs9vdfyi0/l5BZYqFdrD9JmaWoFVKOZZuY9O1uHphzEE+0l5LAiwQ2rDGx4IrrwcZU771d60/mUmr2sk4qh8ShQu+YF9l0jzGSgU1DeWpAAs8MacouaSuyx/2Kq9HNwvl7vySIluyZIZT6Ja+D1rdCaFPvvVISCdTvU/c9hbf+XQGLa6Gg3M5nG896Xee+0OsnIvJvw+V2Y3XUkSVGmED6L+OvU9EhznsVTqd6Adf3YlQGqN+rztXFMQM4diEDueW09+/P6ijlUu7oGldrLuwiD/SKR38jBZc3KOITEvn3YsoC6lDucZjBdRlj2bpw2oTm0booTBYyZdXMS29ItAHQ8X5oOhoshcKsvzbgmnvRTBYH8/ak0c6vgpDjS+rcLiRnA88NHsGc3WnMPVTIwiMS2scN4K5u9Vh5JIukzAJeHxHK3N1pbDqdj79Oybi2UTw9oBFI4LdjuXUe+/vt53l6YCJLD2Visji5dVkhXw39mfCK4xjVCuG12/gakswDAEikamgxg3oVB1BJapYIejzQMtKXtEILkX4a7pm9n4JyIQPaOMxIXpkN6WUkaY1qBQn+Mj4YEkGvGCU+C0cKflQ6HwhvBVkHa++k1JEtj2Rkaz/u+GEfTreQWRvyYwlBehWj2/TD4FbwzppTgFCml5RZwnNDEgkyqEgtMFMvSEvnADMed7nw2iZdougnkUL/N2HLe8LvukBKer7JjB9rvqcNKjmj20bSNT6QMqsDuVRC4MWa/fJ8KE0TmqRVRqFhOv8kbHqzMpvrbj6Ohug5klHCyM93oFXKebh3A8YO/gyd1CFk7r7pXVW2WXgWTq+BoZ8Ixsjeehfr9RDKRSsKLrknCfR56S8pOXa53OSarHWuP5fvXd5fROSfjFYhp0GwnjN53t/fHev5X9frcbs95JZZsdhdKOVSgg1/b7+jv07J++Na8fD8g+xNqZos6xDnz6vDmnJg+4brdzFqH6HMO2VrrWocZ1gbTjjCyC+vmuz89VgOrWMu/1kZ7a/lkwmteHLxEcx2obxcJZfy/JDGJISIAmRXghhcifx7ie4ASXVkCQLir22mW6kXBsd19SvFdBaUzv4JKFTgFy38XCXlVgcF5XZySq3oVMKX3JurT/LzpKjLZu7sFSaSbRXc3b0ejUIN/Hwwi471/Vl1NJt1J/L4eHxL7vhhLyZrVeC79UwBY9pE0ijs8h/qHg+czCrl0wmtmbM7jfUnchk2O40tU1ti3PuO8HpfCKyq47f6Pp4btwaTQ4paLuV0bhlj20YRHaClwubC6nDx2cTWFJntlbHAh+vPcFfXeqy5oKBXnbHN/XmukwrdnueRFRyH9How+D2hRHLbBzDiSyFbUz2DJZVhGjyDw6Uavtx6Bqfbg0YhY1zLAIY0UCMBVieX0zI+jt6JwUzqEMPZvDIaBBt477dTHMsyEaRXsXSMP/rDSyCuuyCrH9NZkNwvz8MT0QZu+h/OsnwUCjVlfd7FFnsTSeU+lJhTKi8l3EfNmyOb8f2OFH7ckYLbIxgzvzqsCe2DXMh+fRKOL6u69n3fQtNR0O9V+O05GPIxCv8Y6sk0TOkSx4QOMWgUMkIMKmQyqTA58cv0mv1wF/n1SajfE3y9vCd9o+D21fDLI5C67cKLFwuD/g9CEi/73rhW1EopzSJ92Jfi/XOkWwNRql3k30egQcWLQxtzy7d7aq1rGm4k9jJlY382RRU2Vh3N4YO1pymssKNRyJjUIZq7u9cj5Hf6h/5KInw1fHVrGwrK7ZSY7fhplQToVRiUf4MPVEADuHsTbHhVUGRWGTE1n8L5qFFMn1+zVUF7BT2iOpWcfo1DaPlId7JKLLjdEOEniGL8l4VMrgYxuBL59+JfD9jvfV3/N6+tP0Olhx5PwalVtZvrlTpoPg6k/+5q24JyGx+vP8PsXam4PXBTQjBhPkJWY1emg6Yx3ZClbvW6b3F0H5YtzGTWrlRaRfny+oimfLP1PD8dzOTOrnF8u+18jcDqIov2ZzC2XRRDWoTx8XrvZVqj20QSaFDxyIJDDG4exqoHu5FRbEZdvBca9ofl073fkNtJZMk+BjfrQXK+EPj5ahTkltlwON3465SsP5HHp5vO8nCfBvRrHIqPRhB56JkQxKZqqlFto314tlEuxplTqoKH/FNCYDXwbSGwWP2UYNicfxJP9mFcAQnYG43gs/1WWsapOJ5tIjZAy48jggjd/wGqn38Gj5tmDYZg1T7LTQ0DWXc8hwFNw/hxZwrHsoSSj2kd/YlwZwnKffPGC+/PJqPg5k9B649VomZDpoK8sgBOSB/n2IEKJqvUaJQOxraNYuGFHovnhzbmqSVHyTFZ8dcpUcmlnC+o4LllSfzarxhZ9cDqIklLBNPfBw8L1gtKPUog0s/LBIalsG61SodFeEbegisQSgrHzxZEZdxOYdb20p40oMRsp7DCTpnViY9GQYBOiVFz9dlkH42Spwc0YvSXtfvLAnRKOte/ziVAIiLXiZbRfsy+sz0v/3KcM3nlqBVSxrSJ5L6e8QQbrk9Q43C5WLw/gzdWVYn6WBwuvtl2ntQiM++Mao6fTnmZI/y1+OtU+OtqqvA5HH9DW4BcCSGNYcRXuKxlnM4t561tRWzZdK7WHNbAZrU/L72hlMuI9NN6/wwX+V3E4Erk38vF4KnZGEiaL2RU/GJhwFuCYuC1EhAPk5bALw9W9RYFJwoDZp+oP3zZNzJut4flh7OYubNqNkynkmGyCAHRjL1F3Dz2RcIyB9cqUbDH9WFPsZ4ym6BEdDC9hL0pxQxrGc6uc4W0ifHju+3n6zz3plN5DG0ezorD2ZwrqNnA2y7Wj8RwI5nFFuZP7YhcJsVXo2D2rlSaBhWBn49QCloH5sIMlp/PJqPYTJ/EEF765Tj7U4VshU4pY1rP+sy+swOL9mVwJrcMo1rG0kOZ9G4UwoCmoaw+moPN6eL9AUH4zr/Ve1Zmw2sw7HNBgn3eeAhrQWnv93hih4Rdm1P44pY2+GgUSCTw9bAQYpYOrVECpzz1M8q0LfQcs5oXlqczuHk4G09WBSn94vVITu+Cw/OqznlsifCjD0Y2fhGvry6kR8Mg+jeLoEcjN0q5BJVcxrQe9RjZOoLtZwsoKLeREKTk2+HBBJjPI7GXYw1IpNCpQbHztTqfIfu+h3GzaoiReOd3Jh8u9be6lN9RHc0qsfDUkiNsPSM8u4vmni8ObUKoz9UPChPDjHx7W1ueX5ZEVqlQItg+1o83RzYnQhx4iPxL0avkdG0QxLypHTHbncikUgL1SlTXsRwvz2SrczJt7fFcCvrb/tbg6oZDbUSmNqJ3m0kuyKz1NTS9V/w1fQaKXD1icCXy76f/G9DzCXA7hLI+LzPdV4VSC/G94K61QmmXRCYM9v6od9Y/gLwyK59f0uBfUG5jbNsoVhzNprDCzqMbrbw3dg1BBz5EmbYF1L4Ut5jKcZ/uPLUorca+a47l0DU+kPHtf780McpPw8kcE08OaMTZvHLWn8hFLpMwqFkYRo2Ckgo7/1t6lMwSK80ifHhxSGPGtY/CarJB8U7Byyj/lNdjV4R14Nyecp4f0phnlx6tdKUHqLC7eO+307w8tDEZxWZWHs0mIcRIkEHF8z8nEe6j5qZGwchlUqTmwroNc21lgKdKIj7nKIUuDWuPp9E62heLw8XB9BLu7hpDcMry2r1FAJZifE7Oo3fDQZRaHLirfXn6K12w/0fv5y7PQ2ZKJ1Dvy5GMUvLKbGQWWziZU0aLSB8+HN+SB+cd5K5ucdgtZt5vU0zA0jFCJukC4SO/u3APdWArZd+5PAy+gtHoRQn3Wmj9BRsEkxcxCKX+2i0SEEqIHllwkN3nq8r4Lpp7yqQS3hzZDIP66jJYOpWc3okhNI3wwWRxIJdJ8dMq6r4/kSvD7RIsG1K2Qk4SRLaBqAs+hJfpZxS5vgTqVcCVeST92ZisTsptdfdGpxSaaSD2ANUiyl/Lwns6sfNcISuPZBOgV3JLhxhiArSVVRcify1icCXy70ehAe1fYFZsCBN+/kM4XJ5KYYeLBOhUhBjUxAZoSSk0szPFRN/ZFUxo+QC3jH6O5EIrn+wu5XBGSq3jeYAck5UOcQFkl1jo3iCIzae9mzO2iPJj+ryDnM0rp0WkD90bBuF0uZm9K43k/HLGto2icbgPmSVWjmaWMvqrnSy6pxM+xlDsZ1JRdn0Ult5T+xqCEjlhD0EqycXjoUZgVZ1PNyXzRP8EnvnpKMNaRqBWyCqbvufsFoLGu363TKxq0Gjv8jgmmR8aZQYP9m7A/XMO0DMhiBf6hOOzfE2dRzCkrKVrw2G4PR70Knnl4MPpdILNVOd+kpJUPh6ciDFtHfrCo5TFtaQ4pDMlyhBMFgd5ZTa2nM7n434++P8wpZZPliJpIe74Pki9+W4BJbGDeG9zNrvOH+fubnFM6xmPv7dZZUMYjPgKZo2oKQkvkcCwT8Fw7XLqBeX2GoFVdVYezeaxfglXHVxdJMSo/lt7PP5VeDyQfRh+HCoYPwPsRpikmrJKKHH6K7GVCZMXLpsgymIIEwO6GxC1/PJZbH/dDS4c9TcS7qthVOtIhjYPRyZB6HcVuW6IT1tEROSKUcqlhF9SVmB1uthwKo+Xbm7C6DaRqORSzHYXxwtcFEj9OVaq4nAdpoT9GodwKK2YphFGRrWO5PkhiRi8mBOObhOJ1eGioNzGmDaRPNynIZF+WhqGGnm8f0M61vOnsMJWy3/kicWHscqMFLV+AKdMA8O/hID6wkqZMPAvv/lbHl6VTbivhuTLqL/ll9nQq+S43B4eWXCI8/nlfDapNVO71cNfp0SjkGFW+HqXEoeq/qD6vcgbOpP50kG8vjaNzye2wWp3subhbjzcpyEemQqP5jJBmtqIyQ7LDmYypXNM5eLzJsnlFfMCE4j9eTj+G59CeWQ2ARseJ/6n/sQ4z1U+N6fbgyF5hXcD4jO/IW3Qz/s59CHkRQ1k14XA5uut5zmTW0eWSyIRMhTTdkC7uyGyLbScBPdshQb9Kl+Xa6HoksC/Oh4PlFn/ATYJ/wXKsmH+hKrA6iKWYlh0W909eX8GJWmwbBp80ho+6wAzesLRhWAp+evOKXJN+OtVdI33/lkYpFcR7vMPEY/6G1HKpWJg9TcgZq5ERESumBCjmsf6JfDYosOVy3acLWRs2yimztzPgKahvDemBTKphKTMUu6ddYDvprRj2aEszl/SJ9U80gdfrZLuDYOJ8NUgl0kxahQsvb8LM3emsC+lGB+tghGtIiiusLP0YCYvDm1MUqaJu2buw3WhJk6rlPHi0CboVDKOZJTiq1VQYhYG0cVmB2fzy7l3dhLd4oN5uJM/9UfMB7edDJMHks+xu1CFyeKkoNxGuG/dX9YGlRyHSxAxsTndvLryBOo1pxjaIowvJrUm2KAiraiC0AGf4LN0Us0ARSKBvq/gObIIc5en+b89EhYczKJHfR86B1pQ2IqRpKwXSqR8owUPsi7TYd3Lgml1Nezt7+fsUSndGwbQKyEYo0bBpxvP8sHuMr5o9wCaLa/WvnhjuGAsXHKJ/5itjKBVd2OcvJp+jUOQSEBaXIdZr8cNq5/COnk1iu3vITvxMyDBmjiKnBbTuXNpTeXEb7edp0WUD2pvhpNylVCmOeBNwQBToRGW/UG8ZsouIJGAQfRnuTymbEEQxeMSrBkMYSD9C3psyvME42dvFJwWruGvKLM2ZcPskVBwptq15MJPU2HMj9Bk+J9/TpFrxkej4M2Rzbntuz01+mx9NAq+v72d2D8kcsMiftOIiIhcFb0aBfPswEZ8uP4MZrsLi8NFakEFd3eP47ONySyvZqzaMsqXMB81s+5sz+qkHJYdzEQuFfqkwnzULNmfyVujmpFdaqXE7CBAr2Th3jQySyz0Sgymwubk/d9Ok2Oy0jTcSIc4f77dVlP0wmx38cxPR/hlelc2nszj/bEtMNtcPLboMDaHCz+tEqVMSrSPDKXHRm6JgwK7nC/2lzEmuEqaNrvUSqBehVEjrxToqM6tnWJYe7zmgNDqdLPmeC5DW0Qw6OOtfHlLG6wRnXDcuhG/I98gy00C/zjBu+nIQiRJS9Dt/45Hxq6i3BbAG20qUJWchZ/vqznY3Pp/MPh9uOk52PmpIK8LWBqN5JSsES/eHIOfVolEIuGOLnEMbhZOhd0Jyjg8jhIke74SghWHBYIa4Rn5NZJ547y/oMUpyCyFvDqsKZ9vOktxYGcCmed9W6WGxSdt9Or+DkG9XuJEThkLjpWz+Mc0bM6a6pmFFXbsTg+XrcKTKQS/rD+JAL2SVtG+HEwrqbWuX+MQAqopexVV2MkqsbD2eC46pYwRTYz4yazIZTJQ/vmeWTc0Ljtk7IMld1XZTGj9YciHUL+3oJJ6rbjdUJ4jCMrIVELQdBlxGQCcdXuL1cKUDU6LkPHUh1zeY7DwbM3AqjprXxCEjv5oT67In0qUv5Z5UzuSUljB8SwTMf5aEkKNhPuqkYilnCI3KGJwJSIiclX46ZRM6RLLoOZhlJgdqORS/HVK5DIpg5uFs/RgJiargyHNw2gYYiD4Qp/KrR2i6dc4hKwSC2mFZqL8tbwxsilzd6fy1Zbz2F1uhreMwOJwsv5EHutP1CwN6tsklM83ec+quD2wcG86heV27vhhH/0bh7Dsvs7M3ZOGy+1m+W31iDv6MaqlC8FlJ0EXSEL7p9heEoKPVsGkDtEsO5jJR+tP89nE1jy68DD5ZVVqh0OahzGidQQ2hxurw82GCyp9vRuFMKVLLC//coyeCcH461RMnXuUYrOd5SNvxVe7QhBuWHR71YDS7SRo52u80vtdfE6thpwjtWfxPW5Y/QSMm4O7x9M4AxuTHz2QLXla3lxwnjWPRFUOLOQyKRF+GqGHJG0fxHaF5mMESXNtABhCkNjMQjlUHeQWmzhYUMT0XvFoLXrYEQQVtXvf8jo+z5o9Nvq31eHR+LJk6wnm7PfeI3dTQtDv9kz82QToVXw6oRUPzj9UqfZ48VpeurlJpRx7fpmN11eeYNmhTDrHGXnvJi2+q59BnrJRCCTaTAX+4r6fG4niNJg5TAiyLmIugoWT4e4NENHm2o5rLoITK2Djq0K2SqGFtndCmylCRsxb+alCK7xvr+TYyRth3YuCaqvKCB3ugXZ31R0gpdf2baqkJPX3gz6Rv4WL/Y4d4kTrg+uKxyNkkfGAJuDvsZkxFwmTLTKlYCL/D0EMrkRERK6aKg+Mmst9NAoah3sXD1Er5cQEyIkJ0NEhzkOFzcGu84V8vyMV+4Vyu7P5ZQxoEsaaY7m19g/SK8ksqSk2MSAxgLtbaTFI7Cg1Uvbk+7HtbAFrjufSOzGESR1jyMnKoOGhx5Cm7ajasaIAn83PQ4sZfLXpLG6pgo8ntCLaX8uJ7FLeG90clVxGfrmQzSqssJNdYuFYponRbaK4r2c8Ro2ctcdzuXfWfqb3bkBxhY2cUguHM0rp2TAIddJcOPS912chK03BUJwk9Bvt+Mj7Q3Y5oDgFh/0Ue+o/RE5OJgmBcj4dGo5SesmMraUEtrwrzLwfnAWnf632okTChPmCXUDeidrnUWgolhiZPu8gK6Z3Zfc5NwNGLiVs81NI0rYL2xgjKOz+GivyA3lteH2CLvjc3N4ljsX7M6iw1xwk+2kVNI3wISnLROuY65sFivDT8vXkNhSWV/O50itrqPvtSyli2aFMfDQK3rtJS/jCgVXWAeYi2P4htJghlIz5RV7X67/uuFxwYGbNwKo6m96C0d+B6ipV2VxOOLIAfn1a+F1lhLZ3QFR7IZN120rY9Rmc+KXmfj2f+X0PQrcLTiyHXx6qWmYzCX8DeSfh5o+FzNulXM4wXam7fNZL5IbG5XJjcbpQyaUoZKLR7R/GlAUnV8L+HwThoRYTodko4fvkemAphZxDsP4VQeXXLxZ6PA0xnb3/bd9giMGViIjIX06eyYrd5UYhk+LxQFpRBadyygk0KFlwT0c2n8rjnTWnOZ9fQZMII/46JUUVNQd7qYVmEsOM7EwuBOCL4VF0Na3AsPJzQf1LriKs2STqTbybSfNTOVdQTv1gHZ2CbDUDq0t4ppsv2QRxJq+co5mltI31w+50c+ePe5FJJZTZnHg8oJBJ+GxiaxbvT6fY7GBcuyhaRPqSGGbA7nSzeH8moRcarC0OFw51AHV2BBhChZl8v0jvnlgXsZejMmXRMjoTw/HpQpbLEIrL/gi2xGGofAW1SndZLtKKfDi3qWZgBYLc9awRMG4OfNev1ilKOz7Jl/sr8HhgxpZztI7yZY/Jn8SbvsSPMrRyN2apnvM2A2pXBX7VgpQofy0/P9CFzBIrZRYHvx3PxeZ0MbF9NC/9chy1Qso7FwLVQL3qsj1RfybezD0vUmK2M2PLOQBubxNA8K43a3myVZJ/6t8fXDktkHWg7vV5J4S+uKsNrsqyYdObwv+1/jDya9jxiRC4ghDMdLxfKDtc8bAweOr1PNTv9fv9d2XZsO4l7+tO/gK9nvM+AItsL/T3OSy117W9A3TXrlQp8vdgd7nILLawYG86h9JLqB+oZ3LnGKL8tWiV4hD3mjBlwdxxwvfNRda9APu/hykr/voAy+WEU6tg2b1Vy3KOwoJJ0OsF6DhNsMS5gRHfeSIiIn8ZRRU2Np7M5/21p8kssRDuo+aubvVwuj28sUrIovhpFfx4ezs61Q/kXH4FxRV2ltzbiWPZJlYeyWbz6XyCDCq6NgikW4NAdiYXMrpFIN2LFqPbUy3r47ShOvgdLcpyWD31XRYfL+fF5cf4vtU5gkAwp219GyQMAIcVJAo44yREaedIoZXXV57A4nDxwbiWvLbieK1sjMPl4X/LknhqQAKPLzrC3pRibu0YwwtDGvPs0iRMVscFTxjYn1pMcc/BGHa95/W5mKN6oojuANkHwL8eFJ3z/gBDmuBBimHdk1VfdGU5yNY8hSN9PwU3vUqRW0do8naMiTfX/DKqTkU+2Mtxjp6JfMNLwvkCG1DQ/klWmOJZcSwbgJSCCkKNal785ThNwo082LsB98yqEtT44fZ2laV1JouDXecKeW3lCdKKzKjkUka1iWRK61jumb2/sqwyo9jCtNkH6NkwiLdGNf/bm9CdLg8lFgd6lZxRzXyQV0yGtpMh/6QweKjuv3VyJTTs/fdd7PVAroagRoKYijf844SA5GqxlYL1gkpo7xdhzf+EZ3wRewVseQf6vgKPnQIkVy7Dby0VlAXrIv8kBDeqvdwQLhjAzx0jnP8i9W4SAj256AH0T+NIeimTvtld2fO561wRc/em8cWk1vRKDEYpZrGunvNbawZWFyk+D0cXQ+cH/9oSwfKcqoz3pWx+U8igKWP/uvP/CYj6jCIiIn8JVoeL2bvSeGzR4cpyvqxSK6+sOE6uycqwloJZbN/GoexLLWb8jF28v/Y0epWc1Uk5LNmfiUEl54fb2/Pa8KbM3pkKEvhgbAvubqVDd+Arr+dVnF2FzlHEF5uTSS+y4NQGC1JxN38ilD7NnyjIPS++AwApHpoYzLw7ujkgqA8WXsiaGVRybuscy2cTW/PZxNYMbR5WI3Mza1cqSCQ8M6gRM+9oT71AHVH+GpxuDz8ctVNy01s1Ly6wIZ6xs1A16ofUVoYnvDX0ecm7x06jIZBzFEl4S0jfXWu1+vhC1LZC7p29H6tHLhzD24z8BdzFafzqasu+XvM4MGo7y1p+zYRtIby0LrtymwYhhkqfr2NZJg6kFtP5gnfXfT3r0yLSt3LbHckFTJ21n7QioU/F5nQzd3car6w4zv03xVduJ71wb5tO5/PRutNY7HWbgl4PjBo5w1qGs/KWCCJ2vii8FxbeCqdXw6D3IK5H1cZ/otjGDYtMLvQpSeoYDvR4SrARuFrkFwIypV4oCazDH42t7wtlR1fjbyb/nQC9rrIhuUKwAbhvF0xcCMM+h3u3wqhvwBgmlOJaTeCsW9Jf5MYh12Tl4QWHaonpeDzwxKLDFFfYyTVZyTVZcbi89PeJ1MZWBgdn1r3+8LwLfVh/IeZCsJZ4X+dyCP3ENzhi5kpEROQvIb/Mxmcbz3pdN2tnKp9Nas2647n0bRzM3TP3o1XKeHNkM55YfJhcU1WZ1sL9GdzXsz4BehWv/HKcTye2IsqWf1lFMU9pBjqlnFKLg2xFNGFNx0DuMTg0p/bGi+8gYvS3bCyT0SrKF/eFMr34YD0vDGnMDztSmLUzBQ/Qo0EQI1pH0ijUwMkcwcdp7fEc1h7P43i2ifhgPZ9PbM30eQf5bl8hnratmDJhE4Hpv6FWa5BGd0CyaDKyiwIWEimege8imfwLbHgNsvYL/SatJ0NAQ1zGcGRrnqnzPi3ph7HaQygPbEWw7QSofev8UnIHJfDqnBO8MbIZd8/ch/uSakS5VMKQ5mFMnVmVqfr5UBZf3NIaH42CIL0Kw4WsVa7JymsrvfRvAYfSS5javR46pYwmET4cqeZxtuRAJvfdFE+U/9/31aOUy5jWUonqhyFCT9VFMg8Igdb4eZB9TFjWeMTfc5HXG78YGD9XMNm+mG2Sq6H/GxDS9NqOqQ2Aer2gNK3uzCwI79fqWaQrOnagcOxzG2qvU/uCX1zd+8rkgt2Bb7X+K6cN8k/D3m+FPo+gRGg/VShVvMHLj/7LFFfYvZq+BxtUvDO6Od9tS2HZoUw8HhjeKoLJnWKI9BNfz8sjAcllsn1S2V9vuC39ne+HP8G2469GDK5ERET+Eooq7LVmFC9id7nRq+Tc3CKcZQeFMqzhLSOYszutRmB1kc83JfPD7e0Y2CyU0V/uZOm4EOpf5twutS9WRwkAz20oYsX4R5B+29f7xqYMFOVZ3BTlh1wWgQQJOpWM5wcn8uD8g5WeWSBkXw6kFfPpxNZ8suEMPhoF/jplZUB2Nq+cqbP2892UdlTYnGSXWinT61C0nY7EnoP22+7CzOBFPG4kqx7DOegDrENnoJI4cDrslNpAZ/ChvKKCsIs+VxIpNOgLDfoLX3Ap23CpfLA63Xx9sIL/NVKhb3cXbPVSihgQj8MYQ375IZYcyODtUc15+9eTFFww3Q0xqnh2UCI/7EjB7nLjpxWESWQSCaE+asIuMeussDm9DmoucjLHRGK4kft61uexhVWeaHaXG6vj759BVqZsrBlYXcTlEEoDm4wAN2AMv+7X9reg0EB8X7h3u1CS43YKJXT6EFBcYxmnxheGfgiLpwhZobqQq34/E1Xr2D4w9ANB4bA4pWq5QitkpK7mdfN4IH0XzBop3DdA2i448COMmy38vcnEodKNiLuOftXXRzTjuWVJNT6jZmw5xy+Hs1h8b2dBXVXEOyo9tLsTzm/2vr7NlCtT8/wjaAPrLpfX+P0j7BKu+RNj48aNrF+/nu3bt5ORkUFBQQFarZagoCCaNWtGjx49GDJkCKGhN/5DEBERuTymCgtlZgu5FlDKZKgVMvx1ijpFAwAU8svPbtmcLoa3iuDN1UK5UJf4QB6cf7DO7Q9nlOB2g8niZH2qm9iY7shSt9Te0DeGUxU6nG6hJ+N4djk2hz8ae3mdx5aUpBKXtAT/zk/z9IZC3hrRjC1nCmoEVhcxWZ1sO1vAmDZR7D5fiF6l4KE+DXh95QmyS624PR6+3JSMTiWjbawfTpebxxcd4cMmZ9FWD6yqId/8OgekbZi8OAOASR2iGdhMSZxOijumK9KCk0IJU/J62PyWEAQ07I9feDy+mizmHSrETx3GA+0T0LgcSPbOqCwR9MR2RTLsc1yaYPokhrDqaA6ZxRaeGZSIUS3HR6MgtdDMjC3nOF9QwVcjomiuzsOY/jMStQ8qqxGnIhy5tqo0TCGTopBJcLi8D24i/bQ83jeAF5YfqyyxBDCq5WhVf3MPhNOG5NSquten7YJbV8CeM6D2rnz5r0QmB98o4efPwi8Gxs0Fa7Ego1xRUHubVpN/Xx3Q67Fj4fbVguhIxl6hNyyyPRgjrs74uCxbMBF2X1Ku6nHDsmlCwPlnPpN/Ew4L2M1Cdu9a+vL+IH46JUF6FfnlVRNyraP9SMos9Tr5k11qZcWRLO7uVg/ppYqrIlVEtYeYLpC6vebykKZCufpfnbkyhMCo7+DHwTWz2jIFjP4B9Dd+XHFVwVVFRQUff/wxX3/9NampqXguzBqo1Wr8/f2xWCwkJSVx5MgR5syZg0KhYOjQoTzyyCN06dLlL7kBERGRPxe324NEguCjZC7CmXcK/d5vMNpL0de/mXP61ty+LIfYAC2vDGtCgxADclntfo0AnYpof21lT051Iv00ZJVYCDWqSQwzcCi9RDgnMK1TCCMTlKidZTjkOjaku/hoWwFOl4fjWSYAPt2ZT+9Jb1PffHvNXg5DKNax83hxds2sRFqFlASlHuoKsALqw+a30dsqiPd5HIlUwt6UIq+bSiVgtbuIDdSiV8tJzi9n/Ylc5t+aAOV5KApPIdW5cfnGsS3XxQvLj6FWyNCU1GFeClBRgO+FOLVRiIGp3erx8YYzbDiZx/KJbxHlTIc1z0BhNZ+vw/NRnfmNb0espM/3KXy+K58fDhTxbJ8J9Jk0AR+plawKCSqfYCL9wtEDzw5K5GBaCYczSiszSh+Ma8nXW89xJq+cn26pR7MdDyHPrNbjte1NLL1ew9RkPL5+gUilEgINSm5uEcGSAxm1bkUllxIboGXsV7tqrZvWsz7Bhr9X0AKp/PKZDV3gf6PX6nphDBNmmicvhzmjawqGNBwA3R+79uyYMVz4qX/TtV+fubC2z9xFrKVChlMMrmpiNwtZhe0fQ94xQRCly0PC56hSd10uweX2YFQpeGNkU6bO2l8puto+zo9Np/Lq3O/nQ1mMaRt52YnB/zyGMBj9reALt/cbwfqg9WSI6379svlhzeHeHYL6Z/puIbBrNgZ8ov4RmeQrvsIvv/ySl19+mdzcXJo3b86rr75Kp06daNu2LQZDlUSrx+PhzJkz7N69m99++42ff/6ZpUuXMmzYMP7v//6PuLjL1EKLiIj8beSUWjiUXlrp//NY1yACD3yEfPcXldv4nFlLK79Y5oydz6AfzjPyi52seqgbcYG1v1BDjGo+ndiKW77ZjclaNStsUMl56eYmvLbiOA1DDdzfM54l+zM5nWti+ZR46h/+P1QLFgozx0BMbA+6T3qbEkUQa48LQZPJ6mTM/Ey+Hvkj9RVF2HNP4jJGkeIO4de9Hm7rFMvrq05UfuF+vKeMj9rdjXz7B7Vv3BghqAdaipGdXcPw8f+jRKXGR1Pb80ajkPHh+JbsOlfInT/so8zmpEWkD9+NjsZn09PITy6v2ljtw9Cx81go85BZbMHcqjl1iln7RKJUafhwXEuahhvZk1LEkgOZDG8ZQb4ygvDSQ8iqB1YXMRcRfHImAxNHsOJYAWa7i+dXn0MyrCm/HClh17kiOtazMOPWIIwaBaE+Khbe24ktp/PZeDKPYKOKhiF6vpvSjl1n84jPnFszsLp43xueozCkM8UuDfWD9WgUch7r15AT2aUcz67KxqnkUr69rR1Rflp6JgSx+XQ+Ho/w3O7pUY+xbaNQeAnErytSmWBku/8H7+s7PwS6oOt6Sf96JBIIaQJ3rQdTJlQUCpknffDf71nj8V66fMXrfw/Xhez3v8VDy+0SLB8WTKyykchNgmNLYMyPkDD4Lx38Ol1uMkssLDmQyd7zRQxsGspP0zrz+aZkTmSbCDWqUSvqzlxG+qnRuUxgsoNUCfog3G6PmMm6FEMYNB4mWCV43Nc/iy+VgX8sdJ4O7vuuLht9A3DFfwHTp09nwoQJPPnkkzRtWneDq0QioWHDhjRs2JBbb70Vi8XCnDlzePPNN5k1axYvvPDCn3LhIiIifx7ZJRZu+34Pp3OFzI5GIWN6ohlptcCqkuIUIk98y6DGY1ieVMB328/z/ODGKOVVg+asEgu7zhXir1Xw0YRWJOeVcy6/grggHbEBOt7/7TQphWYahxlxudx8PKElGXmFJJyYgezY/Bqnk6VsJt5xP2n9v6d/k5BKIYmiCjsT553ni0mteWmnjRKzHZM1HYCbW4Tz7W3t2JdSRH6ZjVbRvhRG3UGAuQj5oVk1B0yD34cVDwj/97jxU8ETq05wa6dYtp6pWcb09MBGfLU5mQNpJZXLAnUylIdn1gysAKylqOaN4tVR6+j/QyrZ2gRC9MGCv9UlmDo9xezjNnw1Hsx2F4v3Z9A1PpDWMb6s3H+O1mVL6nztdMkrub3vbWSYnET7axnWMpyfD2Wx65yQecsptWJzusgqcfLB2tMsO5RJo1AjHev5069xCJG+Gny0SkY2VCKd8V2d5/E7+xPfqG7jrm5x6FQKwn01/HBHe1ILzRxILSbUR03raD9CfFQoZTI+Ht+KwgobFrsbo1pOsFGFUn6DfEH6xghiDWuerbm8yUihr03kr+FipulGQhsgBHhmL5lqhfba+zvKciD7sNC7JZFB29uF2Xd98B+73uuJ1SSUcpoyhV4cfQgggZ/vq+3P5/HA8ukwrc1V+yA5XW7yymw4XG5UchkhRpVQOeGFEzlljP1yJxaHC61SRkKogXBfDQ/cFI+PRkGgXkGIUc3u87Vfz6ntA3m0mRnVwvGCwJFPFOWdHueosiUlEiOtonwrvQpFLqDS/91X8I8LrOAqgqtjx47RsGHDqz6BRqPhrrvu4vbbbyctLe2q9xcREflrcbjczN6VWhlYAbSL9SPg3E917qM9No9xAyazPAl2nC2s4fGUUWxm4d40eieGYFArWHkkm2WHMgnz0bD7fBHJ+VXnGdcuildWHue5wY3pGaxB9qUXNT9AmrmfQIoZ3qoBm08XcCi9BBDkv3edL6JPYjDfbU+p3H754SySMkuZc1cHDqQVs+poDrvOwcPdnyWmw73ICk+DRAlnHPDLQ2ASgjJ8Y8hzqDiQVsKzgzTc0jGa2buEzy2jWk6ATlkjsAK4q6UOw5oZdTxcCwGF+6kfFMNDq/OZM3wxkevuE2Z6ARRayjo+xgpLM2bvSuPzSa05l19OqcXO1O6NeHThIYY3C8Ql11Ln14tCi49WTfs4f3JNVu6fewCroyp4bB3th1wi4ddDZ1BLHBjUCo5mlnI0s5Svt57n80mtGdQsDCmeKqU4L6isBVilbkotTnQqYRY+2KAm2KCmXWzt7INRo6j0xLrh0PgIZS4N+sO5jeAwC+pzxnDQBYCjdq+dyD8Au1no0VD7CrLrV4IhDIZ+BAsn1w4YBr5zbf1gZdmw+M6aPSsnlgvvt5s/uTrZ+cthrxCu+a8YAJfnwaa3YP93Vc/FGI5n7CwkxgjvPmPWUjzleUiuIrjKK7Myb3ca3247j8nqJMSo4rF+CfRJDKllOl5QZuOxhYewOFz4ahV8OK4ls3elMnWWoH7qq1XweL8EbmoUTM+EIDadyq/ct0OsLw9En0c9555qBzyN/pepNG03nQ+tN/PemtPMurM94b5igCXyx7ji4OpaAqvqyGQysSRQROQGpLDcztw9NSc+5DIp0stIneOyoZAJM4v+OgXKC6VeQobEQuf4IN769RS7zhXy7eS2/HIki21na2aBBjYNRS6T8MzARHQqGRWmYtSXNpVXw16UAdr6PNqnAVanm18OZ6GUS2kZ5UuQXkn/JqHM35NOmc3B4GZhtIv1J8xXwwCjmh4Ng0Hi5olFR+kSLmFs1nwk5zZCixmCOtrFZ9HtFfYWKPl8YitCjGoe7ZvApA4xrDueS4hBzdn82j1besXlgxJ9RRoTO3Qn2l/DKacEydB5KO3FSJxWNL5BPL0mj5XHsmgR6YOvRkFSlomO9QJwuNyY7S7Wniph+pDbCDu90uvxi5rejknqy6ydu7FcosQXF6Dlzd6+yA5/za3nV+JS+XHfzXewrjCM538T/K1eX3mCNjF+hKgMQk392XVezyON78200o1oLd1BFS6oNnmjPA9PWQ4cWQDmIjwJA3EFN8OkCiPg7+63qo7KIPwExv/+tiI3NhWFUJICu7+CkjQIawVtbhMk2RW/01sjlQmlT3dvhC3vQd5x8K8PPZ4QJNmvRfY5eWNtMQCAM2sgcx80Gnz1x6xOWQ5k7IN93wpCHK1uhdiulVlBp8tNuc2JSiFFo7iGEj23Cw7NE45fHVMWktkjYdhnsOAWr7u63J4rHliWWhy8ueoESw9W9eHlmmw8ufgIzw1O5LbOMSiqmQCXWByVk4BPDWjEm6tOcipXqGSIC9QxpXMsQQYV2cUWXh3WhNRCC3P3pOLxwJt9/DHOvNXrdRj2fcbE8eP4dm8+P2w/z+P9E26cLLvIP5IbrivszTff5KeffuLkyZNoNBo6d+7M22+/TUJCQq1tPR4PgwYN4tdff2Xp0qUMHz68cl1aWhrTpk1j48aN6PV6brvtNt58803k8hvulkVE/lY8Hk+tQfmh9BLM7YehOvSD131cDQcRFhKCVJrGtJ71KzMUZRYHUomESd/sqlSSe2ThYV4b3pTiCjtrT+SikksZ0yaKcF81cqmED9efoVOcP2PjfQS58Tp6HMzKIJYezOKmhGB+3HAGlUJGmdXJU4uPUGZzEqBX8uOUdszfm06oj5qVR7MZ3DwMm8NNicWOWi7j4b4NWLgnnZJeb6MJWwwXY6XQZuR1foEvThs5kp/JjDENCNB7QKnEX6ckMUyoN5+9K7XWdWWUeWjmF1slCa3xE4xoZXJI24WsXjf8i9zsP5PB9jQrp3LKGNUmgqndm3Igt4y0EiffTWnH4fQSMootWG1OBnSIpviCyl5+uY2dZREMTByL5sTCmq9dVEckCQNJyargs0mteHfNKU5c6IFqHGbgp/HhqH7oW1mKKAPCTq9kROt7KO8xlrc355JZYsFsd4HRCH1eFiR4XZdkbgIbIJV4MG54GjYAnaZDt0dqS/KW5+E5NBfJuhcrF0kOz0USnIh+zByyXOHirLDIn4vVBKdWCiVpF0nbKWRcbl0GMZ2872crE8yC1UZBhCG8FYz4SsgGKbVC4H0tmAthTx2ZbBACwLju1378shxB3bC6VPb5LRDaHM+E+aQ5fVm4N51tZwsINaq5u3s94oP1+GqVdR+z1jlyYceH3tdZS4XMXPXPvIuofbCqArjSPFpBua1GYFWdD9edYWDTUCKq+VK5LpjzGVRy9Cp5ZWDVLtaPu7rV481VJ0gpFASUQo1q3h/bgvfGtEAplyLPO1a3+a3Hja48FYNKwfy96dzRNU4sDxT5Q/zhSCMnJ4f9+/dTUlKCqw4H7MmTJ1/x8TZv3sz9999Pu3btcDqdPPvss/Tr14/jx4+j09Vsmv/www//n72zDo/i4Lr4b303snFPIAR3d4ciLYViRYvUW+p9a2/d9a270pYiLW2hQHF3dycEEuLuWd/vjxtbspuila85z5OnZWZ2dnZ2duaee889160u1263M2zYMMLDw9m6dStpaWlMnToVjUbDq6++enEfsA51qA12K5RkSaZP4yWSon8YjAYNA5uF8fuhtMpluSUWrAGtsdXvjTpxk+sLtD6kdfgPX2zL4Kfbu9MgtOp3WWZ18P6aUy4W3QVlVu6bu49GoT68P74dhWYr76w4ya7EPLy1Km7sFEPXhsF8eyCBO5qPQn3UTX9RaAsOFOjZdDKbVpF+rDmeVWOTnGIL7645Rf1AL4x6Da2j/Ph4bTw/7UmufCg3DPHm9TFtKFRpeCqpO9cHZnHwhpWcyrMzf0sZL/U3cn/qKgJ+ex60PtBtBkS0reyT6NUoGKUClwG8H+wspEv3JwladhcMfFbcjE4uk2tj0EuofEIYsfcVVGVZ5LYZRsrA3ty+MB0FCm7r3YCHBjXhvjl7KbFUSV3eW3WSV0a1RqdWYrY5eHRZKrYhM+jVYjKhJ+eidJgxt5xISUAzBnx2nEh/A88Nb8FNXevTItKIj15NuMGJfsXDbnu8fPZ+zvXjb+S9LVJxrKhCEtwE+61rUKx8CuXZTWKv3GostBghA2YrsO1DaHotxJ7nAluc4UKsKqDIPIZ2xyecbnAf/l7ReGnrklx1uAJw2MXNb+mjNdfZTLD4Ppj8KwRUGxhckgPpB2HL+1CaLXLQTtPBP1bkdZcrsXM6ax1wjs0EjsswyUje7X4GUfpB7MeW8vjBlmxPEMneAQpYcTSDR4c0ZWr3+vjqL1AqaTe770Erh6MoA6VPmCu5UijIGfg2RfhfMLlKyqnpJFuBYrONgjIrUdUK5P5eGqIDDHhr1cRnSmZMqYD7BjTm9u93u8xVTC80cdPXO1h8Xy9aRvqBsvbP7tQYsDos2OzOGurQOtThYnHJTziTycTtt9/OvHnzcHi4UTidThQKxUWRq+XLl7v8+9tvvyU0NJQ9e/bQp0+fyuX79+/n7bffZvfu3UREuA4oXLlyJUePHmX13rdAFAABAABJREFU6tWEhYXRrl07XnrpJR5//HGef/55tNqLyODUoQ6eUJgGu76GXV9INi+yvTTJh7UGtfYfMUUcwFun5uHBTVh3IlMqGEBskBeL4m2MHfYJiuNL8Tv4FZiLKIsdRFbbO5mxNJfDqcVM7FqPoGqWtjaHg22n3WcHdWolx9ILeWT+wcplJRY73249y4mMIgY1DyOt2VNEWopRxa+oemF4G84M/Ixn56UyqGUYa455ttk9lJzPy9fWJz8/HbVNzYaTWZXECuB0VgkzftjLt7d0ZmN8Ltd3gUk/ncOBkuXTY2m4eIyrVfTptdB6HAx9FbxDCDPqeG98ex74cV/lA/hYWhEry5ox/uZlKHd8Dqufr3r90d9QRnYQm+L50wg8s5FAvxh+GPsTI35IZFLXejy/6Agl5ec9v9TKWytO8PjQZuxNyuWJa5vxwuKj2B1OHluWip9BQ69GdzClWz0+23CG9vUthBn1HE8v4p45+/hwYnuiAgxid55/Do4u8HiuApKW0yZ6II1DfSv75VBrUUW2pWz0d6jMBWjzTsKBeTBvUs1q1raPIaqDy3wb55GFePLcUhyYQ9sOd5JTbMEr8P8vucosNHEur4xjaYVE+etpEmYkwk9f50Z2pVGaC6fWgM7LM5nJPiUztignV2X5sPldSQ5UIP2QyN9uWwWhLS7/uAwBkpBY+5L79W3GS8/fpcBSAru+9LhavW8m1zX5kO3nzV7938oTXNc64sLJlVovvWhFaW5XlwS3pbj+cIL2fow29xiWgCZkt72Lb48ruaXJhUt/3TmyVofuPNe/MKOe10e35pH5Bwgzyj2rT5MQ1hzPrCRWYUYdKoWCtEITDid8uCaet8e1xds7SL7fzKNu3shIuiIUkzWJwS3CLvw81aEOHnDJT7gnnniC2bNn06RJEyZOnEh0dPRVkdwVFEgvQ2BgVcN0aWkpkyZN4uOPP3Y7pHjbtm20bt2asLCqptEhQ4Zw9913c+TIEdq3b1/jNWazGbO5ahBdYaHM07FarVjrmpv/kaj43q7K91eSBQtmwLlt8m+lHtKPwfejYdSXEpSHtYJGAy7aOemvQKSvht/u7sZnG0+z8UQW9QN0OOw2zpYZeflQCya0+gyDWsGWZCuLvzuHxeFAp4Jt8Zk0DhHZRonZis1qI9hLRV5ZzXM+uXMUH685iU5VMy2492w207pFc++i07w89HW8OjyBzpKHTWNkb46KN39KodhkoWs9P46lFbrdx42tA7mntYPAlQ8QnHkE/KNZPeJ+Cr1iOZxh4ZPdRRxJK6SwzERhiYku9YxAHjqlk6HNAwg9/DXW4lz5LqvjyCLoeCto/VEroEOML0vu6c7a4xnklFjp2iCQpmG+FGTvwefY0pqvTz8KGcehXk9I3gNFWYQd+ZphzW6kpMxMRkEJ1efqxmcUcPesnfRvGsqD1zTmmyntmb0ziZS8MhqG+DCqbTg/bDvLttOZdI/zR+G0o1M5KTGZyS4spUt9P6xWK3arDZVCI3Od3EAJNA/z5o4+sahwYK1mgqE2GMFhxrryecg9A6hqOjaZCsFcSvXHiLOsGMX5n78CdgdOh50ykwWr9e8dvFzqvSOtwMSM2Xs4lVnVm2fUq/lqaieahRvrCNaVgsMBR3+Hze/DwGdq/uaqw2arMijJT4UdX9bc3maDpU/BmC9B/8fE5w+vjxZjYc8PNclJQAOIu+bSDVOsVnAoPH9epxI1Drf3xz0JWUT7XWBiWR8Eff4Lyx6ruc4nFEdoK8Z8E8+AxrcS10DJmUIHa37N56NJHQg0KC/4dxPirSbSqHEZNF6B9jH+GLWKGvtqG+XLl1M6UFBmIdigokGggZPp+dzYyo/bOvjiU3AShcNKWUALfj5hYkV8PgUlJrS+/jDic5gz1rVHVqkmZ8jnvLUlDz+dgocHNkSncl5y3HBV4446/OW40O9V4XReWgE0MjKSwMBA9uzZg053dTL0DoeDESNGkJ+fz+bNmyuX33nnndjtdr766itA7N+r91zdcccdJCYmsmJFVfa7tLQUb29vli5dyrXXXlvjvZ5//nleeOGFGsvnzJmDl5dXjeV1qEMd6lCHOtShDnWoQx3+Hago7hQUFGA0ep79dcmlpvz8fCZNmnTViBXAPffcw+HDh12I1aJFi1i7di379u27ou/13//+l4cffrjy34WFhcTExDB48OBaT2Ad/r6wWq2sWrWKQYMGodFc4Uz5to9h/Wue14/6vKpHJa4/jPwYdH/ddeR0OknJL+PXPSmsP5mF0aBmeo9YWkf7E+TtPpuZV2rhdGYxn6w/zc6zNfX3CgUsuKsnjcJEYX8srZBxX2xj3u3deGnxUQ6nFbps/8OtXZg2c5eLTK86nh/eks83nCa/1MpzI1qiUSnw99Kw7ngWyXmltIvxZ2jLCHwNKr7depYvN52hXbQ/ozpE0S/STtD8kVBcsxcLlQZGfwnzp5M3+APu2h3B+M71yC4qIboknhV5odzUxovOK0eJ7MYd2k6E697idGYxoz7dgsMJLSOM3N3Jl3AvB74GPVGpK2DzOzXlcyASm653VkkGVVpOjl5OmS6UO2ftodhS0yVRo1Tw+/29sdgcTP1mJ7mlrtndBwc25kR6EcuOVLkdvjiiJaM7SKU0IbMYfeEZIn+7ESyuLofmRteR2eNZYqL+oKqadxa+GVrj9XgFwvSlLlXZzCIz6qJkAlY+gCJtv+v2Kg32yb9wzBlHyyg/jzNs/i64lHtHUk4pwz7a5LFfY+b0zm4t6/+VKEqHQ/Nh/xzp72l6HXS+A/xj5MbyR8g5DV/0lWrq9GUQvwo2viW/s3YTIbiJ/JYDG0JA/aqh0Lu/gVW1zNq8eyv416vqpbVbRfZ63myqC74+7FYoK793GoKuzHDdonT4cQpkHXNd7lePxGu/Y9h3CW5ftvjeXm6HvdcKmwVKMsFULFJ3S5FYsPtGgk8wGC7/enY4nKQXmjicUsDZnBJaRhppFOpLmPGP5YUOh5OsIjMBxSfRfn+d220so79D23RgzRVOJ3an9Bc7nE6MejWGK9ALelXjjjr85ahQtf0RLvlKatq0KRkZGZf68j/Evffey5IlS9i4cSPR0VUP8LVr13L69Gn8/f1dth8zZgy9e/dm/fr1hIeHs3PnTpf1FcfqTkYIoNPp3BJFjUZT9wP5h+OSvsPiDMiOhxPLwOAPzYfLg7tiSrlPEDg86PxVGlA6q9afXg6WQnnNX4SErGJGfrqdwrKqIH5Lwn7GdojmyWHNa8wTAQj106BSqfjvsJZM/HIHBedJ/R4Z3IS0IgteBgt6jQovvZb7BjZlzfEcHhzSHJvdydrjGfh7aRnUIgw/g4Z+zcJZeii9xnvp1Eq6NQrlQEoRv+5NYc6uZCZ3rc+0b/dWkrEVx7L5cP0ZfryjO3f0bczIDvXYeDKbd9ecpusNvmgqZlWdD4cJzHmgVhO67UUe6juPfJWWcKUCSiA8wAedMQhV02tRHvjB/T7ajQONht3nCimzKXikdygTg+MJ2voyFCSDWo+j7SSUYz6DX26XuUnV0bA3JG+vvCaszYah8Q3mvTVnub1vY15ffrzGW97cKw69Vkv9ED3zZ/Ri3fFM1p3IItyop3+zUNYez2DhwQwo73IyaFT0aBxWea17e+l48LdS3hn7G8FHvsErcR3o/clqcwf7lK2IUAf88e8iOA5uWQIrn4bTa8TNsen1cM1zEOQ6WkOvdXDP8ny+Gfkp+oPfo9z3ncy9ie2Do/8zrM4w0rOl3z+q5/Vi7h1WFJhsnolBXpm97lkC0tM4bzxkHqlatuszOPKT2KEHxFYuTi8o41RmMYdTCmgQ7EOrKCORfgaUOgMoHOLyl7YbwprD9EVCZDb9Dza8KgmATreBcQJUnPdG/WCFh/t2g75yjy7JgKTtsOppkfUFxsHgl6F+T3kWVMMfXh8aDeivsPIlMAYmzYbji2H3THDaoc0EaDsea4kRFIkuxg4Ad/eNI9zf++KvP40GDA3kWTh3nJDaCsT1h5GfXJGh0PVDtNQPubTkY7QKnJu+QuHheazZ8Q7EdQWvmqMjNECk7urcj+pix/+fuNDv9JLJ1aOPPspdd91FfHw8jRpduTkhTqeT++67jwULFrB+/foas7GeeOIJbrvtNpdlrVu35t1332X48OEAdO/enVdeeYXMzExCQyXjtGrVKoxGIy1aXIGG1Tr8/0ZhGvw8XR6wFVj7kphVtL9JNPmxvSRr6nDjkNl8BJxaVfVvp9OjvfifgRKzlTeWn3AhVhX4eW8y03vGuiVXAEE+evwNGhbM6MGSg6lsS8glxEfLtO6xeOvULD6YxvOLj2K22RnYLJThbSOZuyOJCH8DTpwk5ZVxMqOYzzacZvkDfXhiaDMSs0s4Um4XDqBVKfl8Skd8dCru7BvHrb0aoFAoGPnxlhpVrlKLnQfm7WPu7V1ZcSSdt1aclBWKP+iTUGlkHkxBMu3DNfxvdx7R/lpCgNk7E8kotvDuoIfRnlpW0663yRAIknuc2WanfYwfkwJPELjsnqptbCaUe76RgHHAU7Diqap1hgBoOQpm3yj/1vtT1vMxJs88RFaxmXpB3rx9Y1u+2XKG+Mxi6gd5MbV7LHmlFjKLTIT56YkO8GJK91jGd65HqcXGx+vi+XFXFZkM9tHy5dRORPhVZXtDfXX0bBzKwJnxDGsxnp5tJlNohTlbivDS5vPN9AuYXahUQWhzGDsTTPmAQj6PG0e1IB8dN3aOptX7B3ig71humjgRrUrBsRwHj85L4/3xcRgN/xxidbHw1asx6tUUmtzPamsYchUGvf5dYTULSSlKl2vIJwx8wqVyc26nK7GqQGkubP8UBr0Iah1ns0u46esdJOeVVW7iq1Mz5/ZutAoNwdlmAspDP4J3MKx+FgY8I/ftitJhaS5sfFPc9cZ8IdUrnzAZI1Dd0AIgto8MDN70DiRtkcrMtW9C4maxTp83SX4DLUddWGXtasMvCrrcCS3HAE4ZiaBU0djHwbIHevPN5jNsP5NLiK+OGf0a0irS79IHehelweyxkHfGdXnCOlj5jAxgvhpDjC8UdjOK/JojMipRlC5VSDfkqg51uFq4ZHIVHR3NkCFD6NKlCw8++CAdOnTwKJ+r7vL3R7jnnnuYM2cOv/32G76+vqSnS5bbz88Pg8FAeHi42+pTvXr1KonY4MGDadGiBVOmTOHNN98kPT2dp59+mnvuueeqyhjr8P8Adjvs+8GVWFVgxZOSrdP7gW84jPkafr7FlTgFNxYJWfUBi+GtL6hJ+mohv8zGqqM1q0UVWH44nVZRno+v1OrgsZ8P0iLSyI0doykos5JaUMZnGxI4klpVIp+z8xzLDqfz/oT23PrdLoa3jaRlhJFP1p/m3XFtQQFnc0p5clgLwow6TmYUkZhTStNwI7/tTyG/1MqDP+5Hp1byzrh2FJvdB6kJ2SVkl1j4cG185bJjBRoaBMZBrhtJjNYHVDpxFFNpUWt03NwjhKTsYnLz4KupnTA7FCw4a+a6qSvxPjIX5fHFoPXB2fUuFNGdsdvMZOYW0iLCSHOfUgLLCmHiXJH9KNVwbJEMzT23A0e/J1EGNABzAfZmI1B0vhXl+tfBLxpb42uxdbqdyT+mkFUsBjpfbz5Dg2Av3hvfHqUC1E4rmrIsrD4mwtUacBhBKZbpWrUSrVrLAwMbc1O3+qTkleGlUxPmqyPM6OpIp1WrmNK9PnaHk682J7DwkAOFAgY0DeWlka0I8b2Ie6HeWFW1rQV9GgczpEU4765L5N11VcsfuqYxsRcrSbpMZBWZsNqdaFVKgi/ms14iwnz1PDioCS8urulG1qtREKHGv/GzJ/8cnN0s1cngJtBytATw1ZwgLxhl+XDkV7lfWsuJkSEAxnwFMV1h/2yR3gU3EWOBlN1VhOjob9DrQfJVQTzy8wEXYgVQZLZxy7e7WHRvT8L6PYE96yQqU6EQpvWv4laTmbAWClKEXBn8oddD0HgQbHlPJG49H5RjiV8lBkXJu+V1xxZB/yeh1Rg4/AusfArqdbsilZorAoUCfEJcFqlVSuJCfHh2eEuKTFa0amWtznep+WUk5pSQkm+icagPkf56Qs4f9F2YWpNYVeDoAhjw9F9LrjReENvb/dBmgMh2cl11vlWqmReJ3BIzGYVmjqYWEuSjpVGoD+FGPWqV8vKOuw7/r3HJ5Kpfv34oFAqcTifPP/98rRp6T/Ov3OHTTz+t3H91zJw5k+nTp1/QPlQqFUuWLOHuu++me/fueHt7M23aNF588cULPo46/EtRkgk7P/e8/sBcGPySBB2Nh8C9u0U6WJgK0R3BboEFd1RZAyvVMOwdya7+hWgY6oMSBWeyS7DYXatof2RgplQo0KiVfL8tke+3JRITaODOPg1diFUF8kqtLD6YytCW4fy6N4Uvp3Zi5vROnMku5br3N1XKVby1Kl4Z1Zogby23fLsLgIHNwzBoVCgUYLHVfs+w2ByYqrnbvbk5jx4jP8H/p1FVAR2IjG3Iq5VDPU3Nb+Tdbfk0i9Gy50wWnVWg1yi55evdNAnzpV29tvxcNpKRA8cQp8nHsPk1+PV2VFoffNtOJ7b9nYT4qGHRfEjZK++h0kKHqfI9L3mIorRTHOwzF6vVzPIECx3OGYlo9gw5UWWsT7KS9msGT1zbgn1JeRxILiAu2JsR7SJZcSidQfWdxJ38Ct3BWXIN+YRB/6eh+fUugYGPXoOPXkP9oNoJS7CPjvsHNmZC5xgKTTYMWhXBPlr3AVdRhsz9sZklE+4TetHBdYivnldGtWJGv4asO56FXqukf9NQwoz6S8+cXyRyS8xsic/hnVUnOZtTQsMQHx4Z0pRuDQIvbpDqRUKtUjKyXSRalZJ3V50kp8SCTq1kXMdo7h3YmEDvvym5yj4FM6+V7H4FNrwO42ZBo2sufqRExmFY8pDrsrI8mDMO7t4G3e6B3NOQuk9myPV9DPZ8C8d/FwtwFOSWWNh9Ns/t7rOKzaQVmoioF0XxqG8pzk0lzFeLYskJz8d0dosE2SCzCOP6QlRHkX8f/EmqssFNoN+Tcq/e+D84uhA2vAET5gq5KkyVwcP/AGjVSoJ8av/ejqcVMuXrnZVJHoAWkUa+nNqJqOqDvgs9J+Zw2D33qf5ZUKqg7QTY9lHN3lClGtpPgfnToNWoiyZXGYUmHv/5IOtPVv02vLUqvpnemQ71AtCo6whWHdzjksnVs88+e1Waki/FvNDda+rXr8/SpUuvxCHV4d8Ep8PVpvV8FFfrM9R6QVBD6HGv/LskG+JXS0CsUEK97tDvv9JU/RehxGzDbLUzvlMMxWYbraL82H8un0/WxVcOwh3Syn0fYgW8dWpm9G3I9oQcnE7oVD+QjSezJHGqVVNmtWOrJt9bdzyTBwY2YfHBNHKKTcQEevPiEtdsfonFzkM/7WfB3T0Z2S6SQS3CCfLR8snkDqw/mUWjMB/USoXLfisQ5K3F36Dhjj5xlFnsrDyaztmcUhZn1uOaSWvxO/ULXul7pJG92TDYNxvObsIe3o6EVvfx7Q9nsW1P48vJ7SiKT+TzDQn8Z1BT5u85x+qjGRxOLeIe/2MYVlcZ3GApxmfXR3g16o1y+eOuwzPtFtj1lWTAGw/GpAvh4aUpZBVJ0NKneTQP/HaS/NKqnrXJX+3gpm71+N+NbTiWVsiIjzbz8uBImm1/Hs3Z9VX7Ls6AxffhsFtQdrwZVOfZoV8AtGol0YGe+z5sNjtkHkX989Sqyp9aB70fgU63XHRiINBbR6C3jtbR/hd9rJeLUouNH7Yn8eHaU+jUKpxOiM8s5q5Ze3j2+hbc1K0eWvXFn8MLRaC3jkld6jGwWSilFjs6jZJgHx16zdV7z8tCaR4sftCVWIEEzT/fDPfskt/RhaIsH9Z5MPpx2IVEmYtg36yq5QolXP+u/I5i+4B3KKai2klMYXn/p94/jBSrNw5TGpFKtUh/3cGdJKwkCxbeBX0eFRlvdrnEWOsDfR8XFcLGtyA/UfptizOkAv7/AGkFZUz9xpVYARxNLeS53w7z7vh2VQkY/xjPO1Lr/tqqFQi58wqBm36F5Y8LaQf5/vo/BTs+k23Om8dqtTsoMdvQqpVuh5pb7TKDsTqxAnl2Tf1mJ6sf7ktMLffVvxymQolJ8hJA6yuVaN+ImiM16nBVcMnk6vnnn7+Ch1GHOvxNoPOVrGb1nqnqaDnS82u9gyWD1ugakYvpfC/8wVOSBWUFIv8yBMjfZaKozMqv+1J4fvERF7XM9W0iePGGVjy98DATu8QQ6edanbA7nKTml7ElPptj6YU0C/OldbQ/C+7uwffbE3E6nExo7ctTXVVoi1NxGAI4UeLDs2uzSc4rQ6dWYSt/kLWK9GNPUj5fT+uE2eZAp1ayJzGPb7eepdRiJ7fETGSAgUfmH6DMakepgGuah+GlUXNXv4Z8VE36V4Hnhrdg99lcdiTkYDRo+M/gphSUWdl6No/DaRpS8q9hUMNRDG9uRJW6C3tQB8rG3sqhYn8enZtUWT1bejid3nrYFJ/N2M6xDG0Zzq6zedzf2Rv/Va/UPKF6f5TmQldiVR17ZsL175KlbERWkfQANAvzpcRidyFWFfhhexK39GzAA/P2o1Qo6BVmQ7N+vdtdK9e9TFmDQRhCLiLQvQDklVhw5CcR9MNwqS5UwGaGda+IG2C7SVf0Pa8m8kvNdAosY8MkXxSmQsy+MSw6ZeH9LZm8teIEg1uGER1wdQMipVJBhP8lyOn+CpTlSl+RO9jMMnD1YsiVzSRVKU/IPCqznqI7gV8MFKZID9bSR2Dyz1I9UirxM2jw1qoqh2ufj4qgVq1S0jTcSFkxOJrfgPLILzU3Vqok0VVxiHYHRcXFGDe/j6rng/DrHa7XvqUYVpX3EoU2B5UeWt8oRhvnuQb+U5GabyKzyOx23ZrjmeQUW6rIlW+4VPlS9tTcuPPt0kv3V6AoQySlu76SpOjgV8R4qs8jIg8tTIG1L0NOvBAtvT8gz7dzuaXM25XE1tM5hBv13N4njsahPi6V7awiC7O2ue/lMtsc7E7M/fuSq+IsqT7v/rpKKusVCBPmyXd5JVwr61Ar6s5wHepQHXojDHwBEtbXtNQObgwR7f54HxeT6beZIe0ALHkQMsqbvOv3gmFvQ0jTy2qeTsor5blFNRvHlxxMo2uDQObf1Y24YB8CqplZOJ1ODqcUMOnL7S6BjZ9Bw3vj29E5NoBrop0Erv8vqpNVleEo//o0HfU9k37LY2jLcFYdzWBE2wh8DRo2ncpizfHMynt878bBfDixPUsOpLAnKY9P1lUFYw4nrDyaQVaxmUcHN6VFhJFP1sdzLreMZuG+PHBNY1YdSWfm1qqH3qZT2YxoG0nzcF/axQRw63e72ByfS769MbvORpFTEsK5jWUUnyfpScgqpnd5UnZvUh7Xtgrnkw2neapLSE1TCwDfMM/ECsBUgM0/jhcW5aJRKRjeJpJ7+jdi1KceegGAIpONjEIzkX56tHm1yJrK8kjPykKvCb1igbvD4SQhu5jGmbtdg8vqWPcKNBwgAdbfHQ4HwUUniVwz3qXCfEeL8bQb+wDT5p8lt8Ry1cnVPwqOPxiIaS6uff350HhBSLOaw3MrENIcWo+BUytFjhjbWypHm96RgDCuHwChRh0PXtOEV5Yeq7GLG9pFEnyeAY/BxwiDnofUva79QQoFjP6q8vq12hzsPZdHWU4y/TKPQnBDz9f+1g9gxEdSaTu+RCoiSpUk33z+/oPha0N2sXtiBRKLV/a7Wkrk+dT/Sdj+CZxeKxuotNDpVuj5AGj+2DL9cuBwyBiRNccz2X02l5YRRqa1MWD4fQaKhPVVG+6bBVYTrDmv/UOpguvfB18hxiczihjz6VZKy59vBylg5dEMHhvSlCnd61eSSqvd4bHvF2T0wt8STiccWSCkszpKc2HWDTBju4sjZx2uDi6bXJWUlLBw4UL2799PYWEhRqORdu3aMXLkSLy9/9wG5jrU4YoguDHctkakImc3Sd9J+5tE9nWlm5lzE+Db61yJXOJmmDkU7thwcVnjarDbHR6zbgCzdyQx+7auNXT5GYUm7pi1u0bGuKDMysu/H+XFYY0I2vM2ypPnSW7zE4laPIEPrvuVTEUA6YUmxnWK4dWlx1h9LNNl002nsrHZnbxwQ0tGfuyeeOxLyscJbDudzaAW4YQZdYT46Fi8P4W5u5JrbL/oQCrz7uiGEvhmemee+OUQGYVmDFo1x+LdECUqst8SWIX66pi17SxOJziUOgnKzpcbF2e6zHWqAa03TkMAb9zYGI1KSZCPlowCUw2Xxt6NApna2oC3Vkm43oqvTk2x2YbDK8TDjgGFEjMakrOKrwi5yiw0se9cPodTCmhp3e95w4JkkWv9E1CYjHb2DTVkvfqjP9LeP5b+jfujrWtCd4XOT67pgpq/KQAi2lzc/vRGCcQT1tVcp9JC+8k156ap9TD6C7BX/U40KhVjOkbja1DzzsqTZBaZ8dWpuaVXA27qVg8/d71z/vXg5t8h7aAoD/yiZH6Wd3Bl72BBcTG+pjTa+BdJ7+zBeZ4/S85puS/PGVe17OwmsWYfO8vz6/4BiAnwfA/x1qrQVvQS5SbAnBtB4w2dbobOt1WZ+IQ0/1MqecfSChn/xfZKonMgOZ8xPvl4VSdWIPK/wS/jHP0lim0fC8GP6QJ9n6h0e80rsfDkgkOVxKo63lp5gutaR1SSK4NGRb1AL5Jy3ZOoJmG+5JWYCfi79VIWp8Pmt92vs5ZBwgboGPunHtK/EZdFrn755RfuuOMO8vPzXfqeFAoF/v7+fPnll4wePfqyD7IOdfhTodZKo/X4HyRrqVDKA/piG7v/COYS0fS7GzpblgdHFkLP+y+pemV1OEkv8DDPBcgptmCz1+xnyi62kFFYM6sZ6qvjutYRdAi0oNzvYRZUURpNddn8eNDOHX3iSCswsfKo+1l42xJyKDHb3D7kKpBZZGLjySymdI/FqNdgNGj4eW+Kx+2XHU7jZEYxFpuD72/pgt3hoMhsY5WbY1AoYFjrCMoSZH/9m4ZiK5cLLjtjo2HcYNSnV7i+qCxPAkHfcLH3PQ/Ozrej8Ysgrtp1EuSjY1jrCH4/lIZBo2L2+Ho0Sl2EcdM3YC7EGTeANVMf5cHVxVj9wkQO6iaTbm00hN9PWwkMLKZ341pI2AUgo9DEjNl72ZOYR1ywN1N7tMRj7tkYKTb2/wSk7vPYL+m793PuGzbC48iBfy2MEXDd2zB3fM117afUDJ4tJRJY13YvDGkuTqq//6fcvh+5jkZ9AZvfq2k6YDPB0kdh+u8uiwO9tYzvFEO/JiGYrA60aiUhvjo0tRFkYxQ4gfwkOLZYZGEN+sqcKt9IfI//SvCapyXIDGsFrWqJT/xiIOdUzeW5CeJ4SDdxl/0HzjLy1qnpHhfEtoSaiacp3etzOrOYJoFq2PKBJJksxbD1Q/mrQNtJ0it3FStXmUUm7pu7z6WCNKSxkdDjH7p/wcqnUTQeTMI1XxBs9MLXGICimjQ/v8zKvqR89BolY9sE0S1SQ4HZyayDxRxPL2JPYm6lq2moUc9/r23G3bP31nibBsHelFnt7E7MZ1CLsCv7oS8Xdpvb51MlMmtWg+tw5XHJ5Grr1q1MmDABlUrFbbfdRv/+/YmIiCA9PZ1169bx3XffMWHCBDZs2ED37t3/eId1qMPfDQb/GkMjrygsRZC0zfP6hLXQ5TYZlHmR0GtU9G8WWqMZtwKdGwTgo6/58y+z1iQ7w1pHMLxtJF9uSmB4pIYmtVQytEXJPDe8Jx+vP03TMF+3zsgV0KiUqJSKGrOsKhDhZ+CpYS34evMZdpzJ5dPJHegWF4TD6WR/Un6N6prdIeN09yTmUVBmJS7EG22ZlbfGtuG5RUcqiZyPTs1jQ5uy4kgGfQzwyOCmGA1qBrYIo2mEkdxSMxktXiIqP951aKbGi0KvelhHzydo8bQq8weFAkercSi7zagRdBoNGp4b3gJ/g4b+MdBm24OoU3ZUrlec+J3Q06v5YspKfj6n4toRcwhbOB7MVU6MzpDmnO38HN/8kMjnU2M9n9ALxNrjmexJFAKXkF1CVkB7QnRGl/esRN8n/rqeiotFds3+vEqY8mkWqsdgvLoSpn8kYnvCzcth9XNCUH0joPfD0HRYVe9n/jmR8h1bBPoA6HonhDQRV8nzofeFFiPFtrwkS8iYV7Akqg7/XLWdSiNjKxoPFrMLuwUSt4m9uG8kaL1QKBSE+11EpbYgBb4d5ioNTFgH8ybA8A/RLf9P1fKMwzDwWZEynj/0G6D7vWKG4x0sVu8hTUXGrdHD2e1gRWZ56cvVBU6nfIYrnYQDCZZtZjlnPuGVoxkuFWqlglt6xRJm1PP7oVSsdidGvZop3WMJ9tFitjuESLubR1aBzCNgLbmq5CqvxEJCtqsboUaJZ+MSgLwz7Ewq5o1NiSy5vzdR1b8OJ3Su58u7g/wI3v8x+u0bwRDAiO53c0jfidTzdtu1QSAvjWzFB6tPkVVsRqmAvk1Cmd6jPg//dIB6gV50jg24qi6kFw21Voy2qj+7qiOmy597PP9SXDK5evXVV9HpdGzZsoW2bdu6rBs/fjwzZsygR48evPrqqyxevPiyD7QOdfh/B5VWnAULU92vN0ZfljvVwOahfLDmFDklrmRIo1LwwMDGmG0OzuYUsOlUNnqNkt6NQgjx0bm49MUFezO4ZRh3z96D0wlFPWPEqMODJbEzSCRxqXlltI2ufbaX3eFgUIswlh+umWULN+qJ8NOz4WQmu87m8sKgcLobztE/cgl2u5387texMdObp1elVZKzno2CWLA3mTCjDi+titu+383us3n0aRzMu+Pa4a1TodOo0KuVLD+cjpdWXJP6Nwllxuy97Cq3fp7WvT5to2NJG/kLPsUJ6DP24QyIJde/NYsSQKfT0XnIPEJVRfhQRrEmCK+AcLx83dv8hhr1PDO8Oer0/ajT99XcwGbGe+OLFAU9xe37bLwyYimhpafQFCVjCm6NKqgBd8w5g9GgoWHI5Umtc0vMNeSij6zM4ZvRvxC+7FbJ+AOoNDi6P4Cy2bC/x9DUC0FEW8/rfMPR68t7rfLPSW9O6n4xLIjpJtK4ywxY/7HQ+UL97jBxnlR0lGrpL6xAXqJYtRdWqxofXQDdZki/lDt7a5Vazmk1Ga3tXGpVwKHSytyr47/D/OkSLKu00Ga89PjlJ0N0FyjLgeSdMncwpJmsM0aDWiNOaKU5QmgMAUI6kra7n8nUcjTOjW9R40re+KZIEn9/WGS/ID06Xe6UaltRqlTc1rwo14dPOBScg7C2oERMiGxmuaYOzIWMQxDVCVqPBb96l28cUJoDJ1fCupdFuukTKi6eLUfXmHF1MQj01rL2eCYalYIPJrbH6RSjj1/3pbAlPps1/+kHGsRgJMMDwQpuIsT0KsJarq7QqZWMaBVEy2AlZqeWnIibCDqz0XVjrQ8E1Kew5WR+P2khr9TKsbRCF1t5fy81nwz2JmTe4KpxKUVp+C67j+7Nrsc++FWXXWrUSk6kFfL4tU3x0qpRKxVsS8jhnjlSTTNoVVjPG23yl8MnDK55wXXWZgW8QyC6859/TP9CXPIvf9u2bYwfP74GsapAmzZtGDduHL/99tslH1wd6vD/Gl6B0Ps/7m+CAF3vuKyHc3SAF/Pv6s6Li4+y4VQWTie0jDTy8shWBHppeO63wyw+6Np4/sWUjtzeuwGfbkhApVTw+NCmFJpsPDOsBRtOZvH1/lKadpyBz9Y3ar5hSDM2ZRnIz0llQLMQdp/No2+TEDa4qZ51rBfA9oRcxnaMJrPQzN6kKilcuFHPN9M7UWqxMXtHEm8Pi2JI2ud4bZpTuY337o8Z2XQUfsMfYsZvyQxpGYbJ6uClka1oHOrDzrO5ZJbLGzeeymbjqWxUSgUvjmjJxC71aBZhxGGzsXz5WaZ8s4O0IisGjYoPJ7Unv9TCkPc2Ync4CfTWEhPQjabhvvRs5MOrK/a7fI5WkUY+nxJLsNFDkGEphuJM9InbJBgc951UBza9Ldn6cigS1tKz3Qu8vTGd4bOKCDMaCfBqR2p+GZ0bZDGiXRQ3tIsk4mKy+G7gcFLplliBo2nFTFjk4Jm+P9AmwIoOCxq/MHR+4aD7B/XNhjYXWVihG+lo/6dQGCMg64T0OJZkV63T+cK0JULO/ilE8mrAHUmylsnMJ3fndPsn4iSp0sp8QFOhuKP6hNdwSc0uNpNfZqCR1lsqIt1mwIF5cKJa76bdIqYENpNYaxsjan5Xaj3cuVH+u/1T2P2VyKr1/jDoRWqyp3L4RqBwR7qSd8O6V2H4h1JxKs0GnVH6UsyFMmNu/xwY8BQk7xKi2WoMBDaFU1b5nIlbYfbYqmrKyRXy+562+PKqBFYz7Pke1jxftaw4E5Y9JlXzAc9csg26QavmvgGNufW7XczfU9Vvp1Ep+GJKJ8KNOlCrpM/4yIKaO1AooMf9lzZk+iIQ4K1lRKtAHuuiJ/jQl+hP7sNmrIej4f04BjyLcu2LouwY+JyQiqxjGPxCebKnLy/bbZzKKOKa5lWJggBlGc4tz1cRq+of6fgSVO1vkuqgn/RWe2vVRPjpeWT+QQCMejUKhYJisw2dWskj/WMIsqZDlknInU/EVT0fF4zYXnD9e1KNrpBKR7STREJt1vp1uGK45MittLSUsLDataZhYWGUlv5NHVXqUIe/A+p1hy53VA65BaTHa+gbYll8mYgL8eGDie3JL7PicDgxGtQEeuv4ZW9yDWIFcMesPaz5T19aRBoJ9Nax9ngmvx9MQ6mAa1tH0LNRMDuLfejaxYT33s8rH1KOBn0pGvwuh486mLXjGJ/d1JF315zk8aHNsdodbD1dpe3vWC+At8e1ZeQnW7DYHDwwsDF394sjJd9EsLeWhqE+fLo+nqGtIvDSqOluSMbryJwax2o4sYDuTW/gi5u6ERngxYJ9yfy0K5kis43mEb78Z3ATNp7M4pfyPi27w8m7q08yoHkoEX4GrA6JxHJLLSgVCt6f0A4vrYrbvz9YKWfMLbGQW2LhQHIBoUY9XRsEsuNMbuUxHE4tJKfEQpQ7BzpTERz5RQaqOqsRmhY3wLB3YfH9Vcs0XoCSTvXFDCQ5r6yy9y2ryMyEzjFXxMgiwKDhhraRvLP6pMvyszml3PprKS+PbMXglmH4eOtQ/tF06b8b/KIkoF1wpwTCIAFPn8dk3llJllRJqgfrIFXYeRPFxOZKG9b801GaC4d+9Lz+8K9ybnNOS1AaGAvHfhfJc6NrwL8+GCMoLDXhVGpw9H8G5YonoH4P2PKeh33+AhPmiERQXU1yFt0Z+j0Bh+aLLbhfDIyfLeTn6EJYfL+YGQQ3qZpZVYH8JKm0uFMJZB4VF7y8MyIhrOiBveETCUSbD5cEmK1aL6pXODR9U37XP99cU6ZmM8HPt8Ctq4QkXgpK0mGjmyQWyPOi612XNWMq0t/Adzd34UxOCTsTcgn3k/tbuJ++ahZcUCMY8w0seaBKraAzwogPRXp2lRHmq+ONbjYMc66pPMfqzKMQvxzH0DdxjJ+LUqsXV9Pk3YAU3Jqr9bw/YhbJRqPrDs2FKM6veFWD4uwmqRB2nA4qDUqlguHtojiVlsOdHbwJKEvG6bBRaozDz0tH0M43USz/RY7NEICz9yPQcuxVOhsXAUOA9Ew2vkZm2al1Is31diPjrcNVwSWTq9jYWFatWsWrr77qcZs1a9YQGxt7qW9Rhzr8/4d3sAw67HwbnNshWeCYLuAdesWGMxoNYgZRgexiM59v8DyL5osNp7l3QGNu/Gwb6YVVGb6vN59h9bEMPpjQni+yxjJo1Fjqe9tQaAwklHpRVOJFmJ+Jt29si9Xu4JtpnXl/TTxdGgRyW+84rHYHUf4GQo06jHoNb4xpw4zZe3lt2XE0KgX+Xlq6NQjkJt/6jGgXhV6tZPa0loStucvjsQbs/4wOw3ty74KjbE+oIj3H0op4YN5+/ndjGw4mF3Aqs7j8s1swWWvKOPo0CSGtoIzksyaPfWI/7jrHQ9c0diFXAEm5pbRxNzA3PxEWP1Bz+dHfRDoU1kr6PgB7uymUavxpEw3XB0US4afn7ZUnOJlRTI+GQQT7Xpk+DpVKyZiOUczZmeTy3YI0aQ9sFkqo7z+4LymoIUz6SQiUzSQ9kz7h0oeQeUwCaXcoTJWqwKWSK4dd9pF9QubvhLeSfXlfnvnIXw+ne8OdCpiLYdtHErgZI4VoVGDjW2ImMfITorIOoFtyD3SYCjd8DLZaHCidDqliFSZLkFiQLA59vR6CH6e49kftmyWmCmW5cGYjik3/k/dY+bTrPg/+CKO/FJLlFyNOchUETKWFJoPFFbBaNZmtH8qx/jzdlVhBlVGH3eLZyr3gnMj6LpVcleZJ5dAdnA4oSiNPH0VuiQWTxY7RoCHUqEN3EUOyQ4368qSRh6Bb5wMtRsgzqThDKlbeoWLq8ycY3ahLM1H/fq/bHivlqqdw3rMLx9YPUZYTq0rYTAQvugm/u7YD1U1ZFCJ79dSzpdKKEUqzYZX3ghhvO/9rmYj6l/urKl5DX8e56VcU53ZWvbYsD8XKp8rzaH+D6pBKLde639/gWP6FuGRyNW7cOF566SWmTZvGa6+9RmRk1UMpLS2N//73v+zZs4dnnnnmihxoHerw/xYVxhkhTf+Ut7PZneSVeA6YAr21LNyXUiP4BkjMKWXL6WzqhQZyuMSBxceXxMxSlh9OZ8WRqt6pIG8tn97Ukcld6qHVKFErFfjo1C4Vnr5NQlj7n75sic8ms9BM90ZBRPkb+HxDAnN3JmFzOHmsbxgzPDjAAWAqxG6zuBCr6vhobTz3D2yMyeogwFuDSqlA7aYiM7xNJBtOZqIq77tRKGBk62BubmPACzMmhY45R0wY9TUDikh3FSWnE/Z+7/m4980Se/9VhyG4CQmNb2b6zAOVvW5Gg5r3xrfnzeXHmdilXu0OaReJqAAvfr67O7O3J7FwfwoqpYJxnWIY2zH6nzP8tjZ4BbqXuLmRArnAnanBhcBukx6uH8a4moLE9pKA/p9cDdP7QdNrpTfKHWJ7wO+PwA0fwdwJNdcn74SCZHQ/3ySEYMv7UpEf9Vnt76vSisxzx+fy7653wapna35HTgeseBJGfQ5nNorsM6Zrzf01HCDfQ+9HpOrV6BoZubHra+g+Q1wMK4hVaHNZX2F0Uer+3gLgtHueFwXUbrzwR/gDYwybysAd3++u7BXVa5Tc2achU7vXJ8igEJJfmCLnyBgl/VoagyQe8pPkO1Vpofn1YiDi5WFwvUojFby/Qk5Wlut5tqDdiiL7JIrjS9yvt5nRpO6B4LiqZV6BOJuPQHHkV/evqddN5KbV3a/zElEvvKNqG7UO/GNciVU1KLZ+KFXNOvyrccnk6vHHH2f58uXMmjWLH3/8kUaNGhEWFkZGRgbx8fFYLBa6dOnC448/fiWPtw51+OehLF8ynzojaP/64NWoV9MtLtCtLBCkiuNu+HAF1hzLpF2MP5mFJsKMOg6nFLgQK4CcEgu3fLuLt8e15a4f9tC3SQgz+jVEr1URVD4XRK9RUT/Im/pB0tdjstiZufUMs7ZXGS5sTbYyOXYIfqk17XABShsMZr97Q0RA5G5xId68t+qUNEPbYeZmG49f25SmIUL0VEoFeo2KgykF3NyjAb/tT+GbsfXpnD4H79++keyxSstzbSaTFXA/GpWistG6XqCXS8N0JRw2KEjyfGAlWTiDm1I2ehYnVY24eW5SJbECKCyz8exvh/nu5i5XZehtdIAXDw9uwvSesSgQMqz6/z4DyivIszOcUiUueZeColSYNaqmxfjZzbDxbRjyylUftHrVoPOFgc9LD9L5n6/hAKnWRbaVuVLu0GyYDDOtLovNOwMpuyG8NaQfknPfeIjM1DIXSzBdkCxEoIKsGiMhx4MbpKVEfqMaL0lS6f3hnp3lQ2XLZN9egeIiWH04uNYHJv8k9+eiNOnduf496R87ukgqHH/U/G+3SbB9fmULhJhezED58+EVLGYaZTlwbAkkVpsJ6BvB3hwNu85WyRxNVgfvrzlFxwgdvZUHUCy8u+o7U+tgyGvQZKiQ0aMLq/a1/lXocR/0eth9UuIvxQVIk92d+woUucpAixxaTF0eJyRpa0278u73QPwaaDhQ5rWBVG0rCH4FfMIg94xcty1HQfMRQsYUClElHFt2AZ/ryiOz0MTJzGJWHc0gwEvDda0jiPDTV87tqsOfi0t+mnp5ebFx40aef/55oqOjOXr0KOvWrePo0aNER0fzwgsvsGHDBgyGvz6YrEMd/hKU5kL8aunnmDkUfn8IMo/XLon5E+ClU3P/wMZuB6qG+OiIDjBUDZF0A51aic3hZPHBNPy8tCzc534AabHZRlqBiSh/A+tPZPHwTwc8VszO5ZZyJqeEzzcmuCzffDqXzNjh7oMUQwA5TSaQVuS5Chfqq6O+poD/NT7Eo7nP8XTxq7zXPp3M1HOk5ksl471xbTmZUUiwt44gHy33946k67mv8d71sQRnah20HouucX8irYksvzmO5hG+NAzx4btbOhPmzt5bpZFAxgPs0V1ZlB/LXkMPRs46Q15pzc+QnFeG2eZAdZV6nzQqJWHlsqD/98QKwDtM+q/cocudly7hSztUk3hUYP8PEqz/kxHUUEwkOt0qEqOwlnDd/8QRb/VzoPX1LI0zRrsnRZvfFUezptfB5J+F2B5dJGYvbSdAbG8hWhWobaYDiDxPqYZu94jde8IG6HgzdLxVKjaL7nUlViDf2c+3yGsHPit9kDs+k+Hx53YImVEoJYj2AIs2QMwU3GHoG5c2xsDhkB62NS/Byidh+2dSURn/g5BdnS/mG2fz39XZNV6qUytppM1GMX+q6zVpM4sjYvYJGVJ/PrZ+KOv+bjAEiCTUHVTlluMGDxU3EMfJaigoszJqXipFExfjvOZ5SRC0GgPjvpf97Zsl14LOV15gM0HueRJ6U4FII0d9Ltf+r3fA/GnyX70/DH//kj/upSKtoIxbvt3FTV/t4LutZ3lv9SkGv7uRn/ckU2SqRdZbh6uGy3qi6nQ6nn32WeLj4ykoKODcuXMUFBQQHx/PM888g073N5tcXYc6VEdZHqQfhrWvwIqnIWlHlR3v5cJUCFs/EqlQ4lZxdzowFz7vBWn7r8x7XACKTFbSCsrIKnKVRNUP9uKXGT3oWF8eTEoFDG0Zzvy7uhMT6M207rEe9zmsdQRrjslg3j2JeQT7eM7Kp+aXEewj94HkvDKOpdWcpZScV8qPu5LIK7GQ74Zk3LU4i8LJy3C0HicBlFKFvcVoSqeu4KEVucQEeqFR1SQgCgX8Mrk+AfPHELzmYakknF5D2O/T6HfyZUz5krns2SiYcZ1jeHxoM175/Si3d/DBcLBc0qf3g3GzJAD75VaUs0bS8PfxLB5UxG+3taZBcC19cQ0Hug/YlSoyOz3CM8sSKfyDB1+Z9SJlRWUFcq1lnZCqwh8Fpf8maHTQcSqM/KzKItwnFK59U7L2l9rjWHDO8zqb6a9LppTlQ/YpOL5Urv2CZNeeoj+C3Sb3SLtZqkjNR8A1z0PPh3CGtpTry2GD9IMS/LtDYbIYSZyPkmxY/gTOvo/DT9Ng99fSD5e4RcwjNr8tBiXjZsnrLcVSMXAHpVp+Z82Hy3FueAOWPQrfDAZzgfRHeRqcWpQurz+2GHCKZLA6ji6ETrd4PEWF6iBxTLzpV4jqKJWfet1h+lKp2l2K22veGfiyP+z7rlzClyjug5vehmlLsN25hUUZwZzOKqnx0mubBxF0eKbn333iNjmn476HCbOl17fCNGT7Z7VXgf5EFJutnM0u4WSpN7YRnwjxOR/Xvilyx8Evu99JWGsIdDWFUiDPpG6fJXAy4gZK290ihGjZ41iyEiiatkZMPCqg9qopMzUVQEB9OLEM9syskhvbTHIdn9lwyZ/7UmC1O5i1LZHDqTWfrS8sPkpawR/IoetwVXCZQxiq4Ovri6+v75XaXR3qcHVRmivZus3vVC3b9iE0GiRNzL4eHuQXiuJM2PJOzeV2q7jETV0kgd1VgslqJym3hCMphRi0ahxOJzq1gjbR/oT46tGqVLSO8uPraZ0oNFlRoCDAW4OPTiQEfZqE0Dk2oFLPX4HejYNRKIQoARg0KvwMnmUHjUJ9WLC3ysZ5b1IePRoGsf9cPlvis4kO9KJDvQB6NQ4hJb8Mfy9NDYI1uWt9HluTS5jhdoaPvB+FQsHSU2Vs/SmTRwY3Yda2RD6c2J575uxzGUh8Y/tIIs786jZzrj29guDWtxAPaNUqogx6grx1fDypIyUFJ/Cu6JUY9BKsecF11kveWdQ/TcJn0o84fIeQUWQit8SC0yn9amFGvVSb/GPgluWw/AmpYDqdENaSjN6v8vxWC4UmGxqVAp1aWcMeHUSuWEFMLwi5Z2DJwzJ8GkRKNfR1iOtfJXP5t8MrCNpNhLh+QpivxFDWyHae1/mGg/bqzgJyi+JM6VE6MLdqmd5fZllFd6496LeXS1r3fCeBfYO+Yr6SfhBWSQ+1AoRU9H5EjCt8QiEgtmZ/zIkVOKcvRnFovqs0EGR48JqX3A+vPvgTjs53QM5plMPekXl/1/0P5k+tSRyGvSeuhK3HSrVr7EzY9aUktVY/C/2eqv1cWcvAEAj7fqi5bu/3Iusc+oZUtfITpSer1+OQAIHmcxDUEhoNhMj2EmBrDLVWU9ILTCTnlZJWYKJ+kBcRfnpCKkxkrKVife+uzzR1H5RkcdwRiwP3cwZjjEp0WR7kk8Pelu9n9liRUipVMij6xm/hl1vFht5uvTpDkC8C6QUmXl16jCUHU3E4oW8jP96ZspaAw9+iTNktxKbH/dIzpzFIb+O478XEJD8JVBqcrcZh6fME21KVGLQ5RAd4Eearw89Lw6AW4aw4ks6QL4/Rs2EQU1tPxStiGhuTLNyoicG3+m9DpZLe2O2fuPZsWsvAU9/W4V+hzeCre5KqIbvYzA/VpPTnY8nBNB4eVBeb/9m4YuSqDnX4RyH3tCuxqkD8Kji5HDpOu7z9p+71nD3MPCYPzwskV4VlVtILTaw8kk6x2cbA5mHEBnkTUouDXEJWMaezSvhq8xmOpBbiq1MztlM03joNKqWSQG/JBPp7ad1Olw8z6nlnXDuOpBbwy94UlAoFYztG46NTMX2m2FwrFdApNoAyq52dZ2s2fUcHGNCqlGQVV2VDY4O8efTnA6w9XtUoFeqr46lhzVm4L4XJXevz8bqq4CDYR4u/l4bl5T1d351nCrX1dA5Gg5oWEUbW/qcv609kkZpfRo9GQXQOsqKe5SZgKkfA8XlgGIWz/HvSa1R0qB+APbM8MDIESGDsaYjm8v+Sc2MLRnx9svIzBnhpeHNMG3o2CsZLp66yMi7LxW6zsT/LwYNLkjmXmw/A4gNpTOlen6821ZzBM71H7IWTq4IU+O56qU5UoDAVfpoKUxaI/OWvhqVUHMfMhdLf4hUChtoHTV81XKqDmzsENHBxfnTBwOcuvZfrUuGww/65rsQKpIIzayTcs0OIkCdkHYMfRktFwDdMrM8PzYfWN0pS6Meb5DvcP0ekahovWPa4yKQO/ijnI64fKNU4tT6YFDos43/Db9G0KnMIvT+O1uNQftnX42HY49djazwUg1YtZhXBTeX9dn0j59q/HvR7Uo5l5tAqaaLeHwa9IMmFQz8Lwa2t107vB04PFb2wVqJoCGkqM+oUSpEXLn8aoh5FlX0CfALBP/qC+pVOZxYz9ZudpORXuQC2iPDly6mdxOynLA88GTQAzv1z2BbagIgAL4K8tTUGxJ/MtWMJa4c2aZvrC5uPkIr2to+rljnscGwRFKdD3yfEUVP71861Kyyz8sLiIyyrNlh+Q3wB3c4U8tg1tzF14hPoDN6uw4sN/jLeIqYLWEqwombJaRtPvHukMmllNKj5amon2scE8PjQpuw8k0NeqZUtp/PYclqum1t7NXDvlOpfH6b/DgvvkkowCDn19Hw/P4lwleF0QpHZhkqpoF/jQBoFqEkucrD6RA5mm4Pc4r9HNfLfhgsmV3FxcSgUClavXk2DBg2Ii/Oggz0PCoWC06c92z7XoQ61oiy/PMumFjJyJYZ82m2w80vP67d/LA5Zl1NZqkWnD1zw5ygsszJ3ZxKvLTteueyzDQl0jwvkvQnt3fb75JVYOJ1Vwn1z91UuKzLbmLnlLIdTCnh9TJtKcuUJGYUmHpl/gHO5pXRvGITDCU8tOESPhsE8MLAxb644wXPDW6JSKhjSIowO9QLIKjKhVavYEp/N0dQC7u7XiMd+Pli5T41KQfMI3xpmGWUWO3aHk02nshnaMpxJXerx0+5z2BxOejQMZnW5BNEdlh5K4+NJHTBoVYT46pnWQ4KDrCITdlNWrTIohUMqZEdTC2ldL6iyt0nlEyJSEIcN0g56fD25CWTm5LqQx7xSK3f8sIcl9/WiZWQ5cdAbQW9EBdQ3mHnoGi8+XneajvX8GdUhCn8vLfUDvfhwbTyZRWbCjDru7teQ69tE4q27wFt06j5XYlUdK5+WoPhymusvF0UZUuHYM1POq0IhlYth71RJ9KrD4RAi5rCJbMnnb2xp7hsGk+bBymfh2G9yzXkHC7FqMvTS7lk2c6UE9qJRnAFb36u5PLqzEI2MI57JVUkOLLoPBr8irmnVjWQSt8gg0uHvSa8S4DizCes1L6PKOYXSNxJFtxkoji2BA3MgtjcKjQHDjs/RthhJ8dRVqC1FlJjMGH180JTV4kQDaBQO1N5GMaIY+Cz8cosErm0nQJMhYMqTEtrP010DXVM+LHkQJsyFE8vl+dH3MVj9fI33cHa+HYVSLVKujtOlMhUQK3Kwvo/KRmW50lujUIsawVwCg16GowXSR3vzEiFX1VGWJ5K+wlRJ0viEkoU/t363y4VYARxNK+KJXw7y0eQO+KEU8xN31TwArQ+5pTbm7T7J/25sy1MLDpFaTfalUqlRdr4F9n4tldkKtBoDC+92v89zO6HXf3CEtUD5Fw/RzimxsCcpj1u6hOGjgc3nzOxNysdqd/LKigQGtoohztPAdt8IHA4n3289w0tLXPvHCstsTPl6J6se7ktciA+L7u3F4gOprD6WQaC3ltt6xdEk3NdtohGVGqI7wbTf5VpwOv50AlUbfHRqbu8Rw+RmCoJO/ohP1n7K/BuTM+Um3tttYXDLS+j7q8Nl44LJlcPhQFHth3f+vz3BWaf5r8OlwFoGWcdh9Qtwbrs0kPa8X3T1nrT3FwqHrWZzc3WU5V9cb4I7RHaQLKe7m3Bkh9qbcKshOa/MhVhVYFtCLov2p3JrrwY1hr0WlFl5r3xIrF6jJNLPQJHZRlaRmV1n8ygotVTN9TEXVc3jqSYdW3U0o3Ke0y/VZH0L96fwxZSOfHdLZ9YdzyQ2yIsP1sazJ1GyfwqF9GQ9PawF02buJLtYHvA6tZJPb+rIR2trSlaKzDYMWhXeWhVP/3aYcZ1i+GxKR8xWB1EBej5d7zk5Y3M48dapyC+1EuKrx2S1sycxj8d/OUiPWCOvtRyDatsHbl+b2XAspMMt3+7itwf6ElPhyucVKJPslz5Su8mBxoDJUVNO5nTCJ+tO89bYNlK9qoZgHx2jO0TTPS6IBftSmPrNTqx2Jx3qBfDe2Oa0DzSjKUlHpcxEYVOBPdx9v8H5OOumSb0CGUc8z8v5M2AthU3/E6lWBZxOOLkCym6V3o8K4uewSx/MkQUyZLYkC0KaSRUlustfV+n6I/jFyGDVgc9Kj5LWVypWFys3LEgRw4HDv8g9otNt0rR/ES5uTksJiur24bG9oOcDEkQXpYPVDIVpch89//hMeULsijNciVUF0vbLMYa3htwzOMLbURDUgcDYXiiTd4jkueKZv+dbqdwOfR3Vj5PxDm1F/IDPCdbr0HzVG7rcLn2J8avdf5CoDihOrxUVgVpfdc/e/qn8t+0EMQhyF2M4nVK56zBFqjFaX3EC3PyuECjfcOh8OwrvYJy+EShGfyWkRuMFeYnQdqLIxPfPqbJTD20BIz+V3qe0fUCcXK/xq1ykobaCVFTLHnW1CA+Mw2/cXBdH0OrYFJ9DTrEFv8AQ6DBNEhHu0HEaQQlaTmeV8PziI9x/TWP8DVqKzVaCvHU4nQ6UWpvIPxc/UNUPqFTXOmrAZiklwxlMlMct/hz4OQpYdK2N0CNvoLQUcnOz60gfcA23LcwgJb+M/LLae1SzisxunxeTOoQwrbWBoPxDYPUhxjuEO/s2ZHK3+mhVSgzaC0hi+IZVtQsUZ3muVoe3uZCPesVgNGh4tHUpmh9GVPbMGdhE9IFveWb419jDW/+px1MHwQWTq7Nnz9b67zrU4YoiZa/InCrISX4i/P4fOLMZrn9beicuFRo9tBjl/qGuUEKH6RdMfjzCJ0T6XZad506m9YERH9R6/CVmG0UmGwaNip92e26W/2bLGW5oF0noedUrq91Bar6Jp4c1JzrAi1OZRQR5awny0bHsYCpNSISvJssMFBBG1H4qDHgafELJLjIzc8tZj++7YF8KPjoVzSP8eHPFCY6kFhIX7I2vXs3ZnFKWHExDr1Ey/67u7DqTh7+XhuYRRhxOJxtP1XS4Avh60xneHteOe+fs5cdd5/hxl3zux4Y0YUTbSFYccV+9GtY6gq83neGm7vUBOJNdwtRvduKjUzO2SxwpzsnUOzxfrJarwRbVmVPKOOAsJeWELKa65XlALIz4SDLQa19yzQKXw9R6Mj8cdk9ajqcXUmq11yBXFTiWXsSbK6qyq90i1TTPXIph/tNV2n6tD4z8RGbu/JFcpzaZl1fQpVVArhSKMiXQdodz2yWQ9wqS33jWCTgwz7WfIeu49ImM/koy8JfTH3WpKMoQUwWlWoigu+9D53N5g7/zz8H35fKtChyYV26T/Z+qOUR2m/x2z+2QHpPozmL6YIygLC8NffIecVjLTZBKU+fbYP7N0O8JIUWJWyHjoJxL/3oii4NyO2m1XG/HFnk+zqML4IZPQKlCte41Qk/cC5N+dCVWFciJF6lgy1EoDswjsugghtIUISzmQhj8kphInO822H6KJAy2vAd9HnV/vwxsWG5E4QE58fLZFSrQeYvt+6AXxShDoYZ1L0P8ahSTfhJy/O31ci2O+Qb2z645py7zKMybJMTlx5uhwbPQZrz0OiJGCcmZubQ99hbq86V9uQlo547h9UFzueknubdpVUqCfbQUm20UmmyUWuxSJel4s1ivZ51nwtHpVhSBDRjiZeCj9fEk5pTyxC+HUCulb9NXr2HTbfVRfnWtnK8+j1Sdt8A4z8k+IEsRzNydSTx0TZNanUOLzVayi8V4yFsnYzX+SAVxwSjNwX/rayj3V533gKTtBPh+yqwxv3Dtd0n4/kEl3+ZwVCb0KvDhiBgG5M/H++dPqwZihzRFNW4Wfpc6W9InBMbPEsOq6r/XoIZCwLd5HmVyxVGUjmbhHTXNSJwO/JbfBzO2A5dxX6rDJaGu56oOfz8UZ4ptrLsHwdEFrg+NS0XDfvJAre701W6yzK3IPQ07PxcjAGMUeF/Ce2l9oM0ECXy2fyLv06CvZET967l9icVm50x2Ke+vOcn2hFxGt4+q4fJXHYVlVuxusrZatZIPJrbj8w0J7E6sClq8tCq23t0Yn+8HugYzTifs/U6Oq+dD2J1OSi2uLnV6jZLhbSJpEu6Lr05NSl4pMYEGgg0KVk6vT0DOHjQl6ZSGdeKYOZz/LE/nvgGNGde5avBkRqGJ4W3CGBqrwlujYHOylbn7ciix2NmdmMcro7xYcn8vFu9PJSXfRPe4QPy8tBSUWWkf48++c/kuxxTiq2NAs1Du+mEP9w1sTKnZxsfr4rE7nDwwsBFvLj9OeqGJmaN+JSzhF4zxv4FKR37r6TgbD+ahT4/yfHvZ16l0N1bavuHS6D5xLsyd6EKwnFGdyW47g8Wfu7cvbhjig0HjntDklVh4d9XJyn8HeGmY2qiMgJ8fcd3QUiwWv3dtEfvr2tBkMKx8yv3Q0h73X36193JgLnRLTitRnCEB8MzrYNSnnhvFVz4pQ2uNf2J+3VIMZ3dLkiQ3QchVqzEw4JkrO1TVahaDneqBWgW2fgitxwm5stskW37kVzmn8auF/Ac1xDbpVwpzsjBsfR+63yv30O73yH+HvS0k5/Taqv1ufhf6Pw0tRkgfU0mG9K60uAGStno+VodDzstv96DITRDCVluP6dHfpBJ8YB7eh38Q06BWY8Sh8dhimL4EDv0KCeukQtf5diGwOfEynDhphyyvbpjR9S6xa886IUYb7hDcTCpeG14Xe3YAynuOgpsI0Tq9Rp4li+6R6xDEKGHJg+73WZgiVX91OaFodA1Ocx55xWYmfrmdj68NQndwtvvXFiQTp84m2EfL7b3jiAvxJjGnlEBvLVq1kkDvcmMgvyiY8iuc2wUH58l8xM63QGAj8Aoi2uDkl7t78OrSY6w9nonN4aRTtB8fjm6Ievnd8vwszpTKVQW63omz2fUo3JFmYxTxZn92nc2jzGbHxwO5yiw08daKE/yyN5mKAlyH+v7MHN8EP1uO9CrbTCLZ9Iu5eBlyXqILsapEURoRBz/l/r53EvQHPahatYq4YG8SssVJsXtcAH3MG/DeeZ56IeuEJG9vX+delnwhCIwTV8iCJKl2BsSWJyuCgD+RXJXmSGLKHSzFIhf/KwZA/8txyeRqwIABTJ8+nalTp3rc5ocffuCbb75h7dq1HrepQx1qwFwo2WpPSNoG4a0u7z38oqVJddM7cHAudJgqc3Bmj3XdruVouPaNS+u/MvhBVAdxH7SZQOMj7kMecDy9iDGfbq0cULvmeCbTesTy+6F0t9v3ahQsTn12m4v7V6C3lnUnMl2IFYC/QYMleb/nmTRbP4S2E/A1hHNNizBmbZMbdve4IO7u15Cfdp9j5uYzBPvqmNSlHvX9NfyvSzEh80dVBs/+QHhoK+aO/wqLzU52kZncEgs2h4OGhmLerbcV9Y4vwFRAj9j+3DzlYR5aXYS3XoefQcOD8/ZhsYuRBQp4a8UJ0grKeH10a67JK2PxgVRMVjv9m4VyY8donv3tMHf3a0ior45Ck42DyeKy1S4mgBeXSOZ38Mwz9Gt8DUNaXofFAT/tK+WlekZKrVXSzzYxHuRmai3E9oF7d0Pybmn+ju6CIqA+JcV67E731+mM/o089kuZbQ7O5VVJdCa1CyRk3+vu39/pFBnUsHeqAjp3MEbBpJ/gx8muEsAWI8Ud76+sXGl9as2aY4wSCaZa455cVKA4U6zm/0xylbIP5lS7JzhsQlJS98K0xVfOrKIsR6olnnDwJxmyW3BO+oPO7RBC2vk2qTwteRjlyv/i3fk+qbCYi2Ruk0YP/rESYJ128xxe9zKENhMJXYPekHtWJHQdb5Hr3R3ajJcKQLPrZYaXbwTU7wU3lhs+nFgqZKaiSmC3yHKQKnlYCyFwO7+CBr1g3hSxzG7QR4LBxfeJeYZXkATpTa+DpO0iuzQXycBiryDY9z10uwuO/FKT2CkU0H6yWMFXEqtqyD4JZzdBoyFybCnVJJB2q+eeJ4CcU2IQY0FkgTGd2ZaQS2JOKTp8ak0keJWm8O74oXy75QzWknw6RWgoMDuYf8BM/UAvwo0GkXkbI6HlDdL7q1S5/H4VCgUNQ3x4b3w78kutOJHB8P6mFCGL7rD3e7htDfaiDFTJO6qWGyNJuX42Ty3MoXejYHQe5huWWSRxNX+Pa1/nkAY61Ds/he1vVy1c/5p8v9e+dXGuu+6+p3IYjs3ntrsfR/cHVbIQXx1PXNuMO2aJpf6Mjt74rX3P/cbFmTKK5VLJFYgxjjHC1a7d+ifPlfqjFgZ3Cbc6XHVcMrlav349/fr1q3WbxMRENmz4cz3/6/D/AEq1PBw9ZUIvR3pTHQH14drXpdm5OENmi5yPI7+KTKb95Et/H7XuD+1t80osPLfoSCWxApG4BXtrqR/kRWKOq16+d5w/Hw71R7v9PZHVRLYvl/nEUFhm49dqfVIVCPHVoc3zYNMLYMrHajHx8bZ4hrQI47f9Kfho1dzcM5bbvtuNxS7BcWqBiYPJh9h+dyNCFk+tEUwoMw/T8PAHZPV5mYlf7uNUZjGfjYymyZEnUJ+ryohrT/xG1OkVzLp5DZmGBtjsTo6mFVFokofByPZRnM6SitL98/bTOsqPa1uFo1Ep2XU2j3m7znFLrwa0jwlAp1GhszmICjCQlFvq0tvgdMK6k7msqyoWkV9qJcKoB0oI9tbROqqWXh61FgLqU6CLwO6UBmKtWkmM1sZnN3Xk0fkHKo/ZW6vipZGtaBjiWcZn0ChpEubDzjNCcusbFagSayEV2SfKhxnXEliodRIcz9ghiYmyPIhoKxWri+jXqRUlOYBTAtuLaXz3CRG3sqMLa64LbizB7ZmN4vL2R5bxF9J/diWx5gX3y7NPSb/PRZCrvBILuaUWyix2/AwaQo06dOryoNnpdLV6Ph/WUqmazJsk5KkCiVsksBv2P5S/3Yu271MyADW8tVipd5gCrUZ7lmWCzMGatljI3ZFfhHR0myH248sfd922zQQhQbtnQvp+qT5lHIW5E4SQqLRyHxo7E365TT5TRDsZigs4O0xHofWRnq8OU2DrB5CXIH/VicHhX2DSfPm81dUFAbEw8UcxaWk5ErZ9AsM/ENv5iqSRIUAk2ZnH3PeNVeDIApl5dv4AaIVSqkWeCFZwYwhqBsdLITAOp0KNpVySVezUiWTUUnMGFYBvZDPOJeXwRk8I2Poiqr3bwCuIrm3v4FSekTRvrbgGVqCW37yvXoOvvtoYjFK752em3l9s6kd+gr2sAEXeGZw+oTi9w3BadBi0hdzSKxaNh+RfVpGZuTtdJepGvZrh0WV4//x2zRcc/U1IcdsJHo+/Buy1kACn3SPxOx9d44J4c2wbXl16jACtQ4xFPL1l+mGscdeg1/yDRVxeQdIbXOLGIEal9aiUqcPVxVW9okpKStBoPM/AqUMd3MIQBI2HwsllNdcplBDjYWDlpUBjEPnXxjc9b7P1fWg86KrOpSoyWdmXlF9j+fOLj/C/G9uy7HA6C/elYLY5GNcxilc6laH5omdVQHZiqZgGTFkIvm0xWWtWCVILTJiCWng+CJ9QDqab+Xj9WVYdy+CjiR0oKLPwwdpTlcSqAjGBBlSpezwOndQe/Zm85jM4lVlM0zBfevjnuRCrSthMqNc+z6Lg/7I3w8EHE9vz6frT7DiTS6nF5jL36lBKAYdSqua/PHt9C3aczqFjfSEPRoOG+wY0YtvpHLx1KjQqhQtZrY5Aby3WcgI2c3pnIv0NHk9LVpGZbaez+WJTAgVlVvo2CeG2XnHEBHoxoGkoyx7oTVaxBYfTSaivjlBfHVq150qRn5eWRwY3Y9znYpd8PNeBNbglmhwPxh0R7S9sVpJKSCAB9f9424tBYWr5wMxvpfrUbpJUxPwusIKk84Whr0rwW33AZnAT6V+pIGqmfKmaaH1qBrwgxgyXItG9HNRWQU87IIF2xhGpcIU0hqhOkgk/r1KYlFvKf37aXzk3TqdWclffhkztXl+kTno/qVJ46iHqMA2OLnIlVhU4t0MqPQGxWKw2tN1mwM4vRKbVfrKcT0/VahAHtN1fizS4AqfXCHEaP1tkdU6nSPH860sSym4plw9uk4p3BewWqYIVZ0Dvh2H96/LflU+Le6DOB3Z9LRV9r0CRvblDzwdhwR01BzTnnZXlN3wMs2+UXsqiVJmBpdbJcTqsENEBdn9ZuxzVK1ju/SXZcv4rZksd+VWkiZvdkAbfCDkHq18G73Gg1KD8dhiDO83g7WF9+Xp/Ga93uBOf7W7GfIQ0w+4TwbioRNSzhldVHApT8d/0PG0bbCI36H0IuIDfujvofeU3lX3SdXlIUxj8Coplj6KK6gQhTeQ7KEgGaynRfjEsH/0lTvMJOJoGEa1FxWEphJIcnHYzQWp/+jf2Z8XxKqOUQc2CCDn6qefj2fqhJCYvVB7YaozI8d2h+UghiBcAP4OGMe2jRNlhzZLrrLrBSzVkezVk5upT3NKzQY3e5QuFze7AYnOg16hqmEv9KfCNgOHvi2rhfHI96KXaTZnqcNVwUZ3BSUlJlX8A+fn5Lssq/s6cOcPGjRv55ZdfiI2NvRrHXYf/z9CXB2PussI3fHzlSY7DJgGkJ5RkX/XSulKhwN19ObvYwh3f72FwyzDWPdKPLY/355VrQtD8enPNTLfNDPOnE0wuUW7IQlaRmSR1rEhO3MDa6zHe3JoPwMmMYu6YtZsgHx2HU2pmcH11GlSlmZ4/kN2CymFjeo9YnhvRAt2p3z1uqkpYTfdoLWuOZ3LH93u4s29DArw0LNyXysTO7rNuWpWSuBBvujcKJrvYzLrjmRxNLSA2yJsXRrQgo8DE2I7u5R6DW4Rh1Kv5YkpHABrUUmXKLTHz/KLD3D9vP4dTCjmXW8YP25MY9sEmErKK0aiVRAV40S7Gnw71AogO8KqVWFWgeYQv709oh7+Xhp8O5JLd/j731SCVBrrcJv/9K1CYCnPGS99O+kHp91nxJHw/3LP1uzsYo2RY6YwdMnfrzk0wbYk0gOv9hZSAOLQNf79mhco3QioUl2s0c7HQeRi+6R0ss5y+HgRzxsGG18Se/LOecp6qBTkZhSZeX3qMNmF6JncKI9yox2xz8P6aU/yyNxm73SHV+AHPujfKiO0t/VbVyc/5OLYYWozgWIEKc/MxcGqlLD+6UBJI9Xt6fm2DfpC8q+byze8IUR/5KXS/D+p1hyUPVBGWVmMkSHeH02vF3XHaEiEwN34nZG3+LSJ3W/aoJMo8JGcIqC+VJ3dIOyAkv8KkJmm7DMH97R4hhdmncJZm4+g6A2eb8e73oVCK1Pb7EeL+1+P+qnWnVkGbG8VYojpJDmkKN/0sBham8nuiOR+K0/Fe/yyDzKuwOZxsCxxNaae7Xa/h2F4w8UfUZVmoV/7XrZRLe2YNvmaRgOeXWojPLGbdiUz2J+WRVlBW5bxsLZP3Pz+Q9gmTz6Q4L6y75nn49XYhvLG9ZCZZ9skq98CCcyhmjUSJQyplu7+Va3jmdfBpdxRf9MP7q168GbuHJ/tXyfz8tKAx1ea6m3dxz83AOBlqfD70/tD/CUm+ZMeL8Yu9dumdSqUk0t+Ad1CUXHfu4BVEmqExn21I4PVlxykyXZycr9hk5WhqIU8tOMxt3+/m43XxJOWW4PDgCHnVoFRCXF/pH2tyrSR36veSanTb8X/NEPM6XFzlKjY2ttJ+XaFQ8P777/P+++973N7pdPLWWx4sRetQh9oQGAe3rYazW6SC5R8rEgO/6Cs/6FCtg2bDqgKS8xHbW2QiVxH+3lWT48+Hxe6gQZB3VXUlPb6G+10lijPQmXP577XNuLfanKsKfLynlA5TFqH+9TaxVQYJvno8iKN+L54x2vhYr2TZsVxMVgdFJvcPx8ScEsrCOnr+QAGxlKAj0l/Ph2vi+TLGB4/CSLWeikKbxe7gq00JfDixPYUmG7FB3iRkFbPiaJVboJdWxetj2uCrV/P2yhMcqkb+mob58sXUjmhVSuoFeWHQqJi36xylFpGV3NAuioldYvhgbTyZBSWM+4OWgOS8Mrc9byUWO68tO8b7E9q7SnMuEL56DcNaR9A5NpC8UgtorDjGz0W5+L4qeYcxSgaz+l/hStTF4MxG94YBOafhyEIxTLhQiaBXoPyFNqu5/Pp34OvBYheuNog9e8peCQgb9JU5M5fTG3GpaD8FtrqpQnS9Swjn+UkZc5GQrdvXS2WvOJOQwmQ+bH0ald6IE3igiYY9JdE8sCSVj9ed5vo2kfLbDmoId2wUo4lTK4TYdb1LKkQKVe2zdZwOHA0Hk5rvj1deAS0pD/COLIBmI6DXQ7LP88mMX7TMaHJXEQO5J+aeFRMhU4FrT5zTKQG6T6gca0GKa8KnNEcsxbOOy/182DtCrLNPVlXTGg4UK/Man8fzRwXAUuZa4Ww/RYwU9s+RSl72SWzdHkDrEyZVspTz5IEtRsGJ38WavihdrNSv+58Qq043y7DlpsNgwhw5ZwZ/0PnB7HHSBzboZdiX6jIHz7jrfe4YNoQxc5OY2H40U8ZMIlBVRlBAgFi+l+WjLkgScugBunObyAtpw5MLD7sM0g036lh2e0v8i+NRbP9Ezl3z4fJXXfYV3QluXwurX4SUXVCvhyRByvLkGqg+DqE6bCaR8qUfhGtekM9fUckDsBTjt/4pRg/7hh9DgjmdVcyeVBO5rQYRmLDO/T7j+ss5u1D4hMD174qMddvHIstsOgw6TpX7wsqnpAKl84Uud0KXO2rt6XI6nSiUKukRLEiBXV9UkdrAOFKHfs1/FotkcOH+FO6/pvEF38vLLDaWHk53meO49XQOn29MYN7tnS/8M18paH1I9WpKXo+3sZcVo9QaCPAPIUyrq3Ot+4twUed96tSpKBQKnE4n33//PW3btqVdu3Y1tlOpVAQGBjJgwACGDh16pY61Dv82+EVL5qXNuCszPLg2NBwoGdai8wJplUYsjK9Un5cH+Og0PHldM/Ym5ZFVVBUAhRl1PDakGaG+1ahJbdp0ALuV3k1CeH98O15ZeozMIjMqpYLrWoXzxHXNUfsb4KZfpCJnKpBm+gM/otvwGq00Bl7v9SytQjqz8ZyFlt5FbLsljFKbgj1ZKt7ZkkN6oYkSi519RUYio7ugSN5Z4xBK+79EqTaED9bsxWJzkNdnGD473ASpQGmrScw9LFnUdjH+DGweir+XVLJeXnKUZ65vwQPXNGFXYi56tQo/gwabw86by12JFcCJjCLunbOPb2/uTLCPN7f2imVIy3CKzTZ0ahVatZLfD6ayYF8KOpWTcWHyoPQkX17pwQIeYN2JLArLrJdErgDU5dnVStIcNATu2CBBqUIhsiXjFTJMuBSYCmuvluyfLQmPKzGcOKQF3LUZtnwIiZskKB/4vBjX6C8iQLtScJQTmSZDoH4XycDv+0GkdiqN3C/Wvuz+tcWZIlVzOuCnKShTq5IcioAGhA57m4EnP+GD4TO4a2EyZZbygE+pguBGEuSbnpaMtHf54HSHA9pOgtXPuX/PtpNQRrRiQLgX5lI99obXoEo/KFb++36QBMrURXLMZzfJZ2gxCmfvh1H8MLrm/nzDpZdDpYVz20TW1/s/rtt4BcL4H+Q+UpYrkrTcM7DuFQnWvUOkIrTiv0LK5twoMtDDP0tPls0qhhSJm6tMWIKbwJBXpVrhyQRFqQKcsq9Vz0o1M6wF/HhT1XnOPIb2yAKcY75Ccc2LUpk7MAesJpGqdbxZhg9XYNPbMrdoxIfw/Q0S2O/+Wv4q0P1ece08tRLObgVixQm24nw57DTyczC9eyyN/Z1YVAbsIQ04WGRj9d507vZai29wtPQUe6joKPR+/LwvxYVYAdzS0R/dljdR7P+mamHSNrGqv2WFkFeQ7zmyvVSJrSUyt6tiHIh/vZr28tWRfVKI+JkNrsSqGoJ3vM49Xb7g4d+LOZBcQP7QAQS6e25qDDJbTetZbu0WvmHQeqwYhjjsUnXZ+oHISytgLhIJfEEKXPeGy/2h1GIjLd/Egn3JnMkuoW/TUHo2DCJqwDOUdbiNvKxU7Co9Rwt0vLQgh+Q8ue4cTigotcIFqo6zii08teBQjeXFZhvPLjzMtD/ZnO9kRhHjP99GXmlV9U2vUTL7tm60j/H/a+SK/3JcFLn69ttvK/9/w4YN3Hzzzdx///2eX1CHOlwJ/BlT4/1j4OZl8rA+/rs81KM6SaAT2PDqvz9QP8ibhTN6suFkFvEZBdzSRktoaTyqwt9RZLaTZm7fsKo5O+6apjUG8AnFz6BhRLtIusYFUmy2o1XLTBUvbflP3jtYHqDfXe/al2Atw2/df5l243wmhxXj/9NNlXr1huGt6THmfab/XkR8ZglnygxYRs/EvukdvA7PkQApMI7sns9RENCRknwbxWYJIuafcnBbt0cwbv+f6/EGNSS5+e2s/OEsb49rS2p+Gd9tTeTdVafoFBvAK6Na882WM1htDt6f0B6L3Y7NAVabo3LI8fk4lFJATomFIB8dUQHeFJTZWH8ii9xSC8sOp1FY5hrY5JRYMHq7DwK0tcx8UV3OdemwS1XGZhEpTsXAWb+oC+9lutpQKGpKjFzWK4Er9NtUa6R/6bo3q4wRDP5XZt8XC7sFKhIG398ADpMEqf2fgm53SzBXS5M8IK6Gm9+H1POqx3lnYNljaLvNoL0yiQZBvug0551jraFmUKpUStC597uajooR7aBhf9D74Qv4avxh0AsioVrycJVN86mV0rvV+TY513YLCnORSK2Td4krpV+MzJUqzZHqeHgrkQSueV7s5yvGV9TrLlWrBXe63odie8GYr2D5k+LUt/1jGP2l9IPYrXDoZ6k8rHlB7q0rn5K+rn2zpJJ+3Vswf7ok1FqNlu3PR7ubxLHx8M8wdbE4peYmSJXpzAYx8rCZwOlAsexxIZVx/cX4w2aS3sH4VTWlp6YCMQfyZGSxb5Yc36mVcOw3CH9AhkYbfKQXTKnFx9uXxxscQb/7UzhahKnhdZTWv4FzeWacziwoOClGD+4s0RUKTNG9mDtb2i58dGqmdAhiWCMdTQIUaBPqCUHKT6p6TXGmEI/r33OVfxn8qgZuhzSX/xamiitjxTDm8xEYB5Ft5fx5Qs4pBjYO4KNJYeg1KvYWWKg3bSnqdS/LOXHYxfCkx31SNe04TYjnxaLChCcvETa/536bQ/Og7yOV5MpktbPueBb3zt1bqZj8/VA6wT5afrqzO1ZnGEN+OAEUud2dJ3dXdziWVuixn/dIWiH8ieQqp9jM/XP3uRArAJPVwe3f72bJfb1q7Smuw9XBJVcMz5w5cyWPow51+OsRGCfuUWW58pDQ+105p7ULPQQfLW0ifbg+KAXj3BslS1cOZ2hLFJN+BJ9wGPwyLHmo5g4GPi/NyIh0N9xPbqoZhSZOZRSTVWwmJsBAhJ8e44F5Hhu+fba9IQFJ9Ubg9ENELxzDd+NWcKjEj51nctiTq2elfQqTbrydUG8VZU4tZ80+nEoupkVElZTygy1ZaHsPZeS4awg5OQ+dORdzs1EcUjThzh+TuW9AYxbvT2X9ySrHo/Unsth8KpuPJ3fg+UVHyCgy0SbaH4DDKe4zqxWorp+Pzyzm0w0ezCIAk8Wz3GpwyzDeWX3S7bphbSII8LoE97riLDj0k/S0lGSDbwSOvk+QX38wa5LshPnqaRjqQ4RR/9dmHHW+0OlWGebqDh2nX/nfh0Yvf38l8s+JS12rj6qWWUuFCEz6EX68Bwa/4tl4Q6EQgnzcgzlFTjz4hhO29zueGPSGa1X6fBRlyG9UpRaZ6LTFIt/aP0cqOJ1ugcaDqyqcNisk74Dtn8n8qurzb0qypUID0i8W0Ra2lMv6Y7rCuFlCPn6+xZVghDSDUV/gdFhQXPOcEKqeD8BP02r2fZ7dLNWncd+KW2BugvR9NR8hDoDFmULe8hPBN0ruL8uegPrd4Pr3YcsHImHb9ZX0eun95bNaSyWh1H6K9JUcXQTXvgn7fxDSYzML2W96nVRtfrlVSF9JliQxZo2UoD+2DwTFCckY+Zm4PpbliiNnTnxNA43qMBXI3Cyo+txl+XBmbXk/U2+Uq59Bf7yqv1SffohG+7/msdGLKCnpi3HxJBk+m5sgRDS0hfQSHZqPud3N7MvXSR+nv4HZY0KJ2vkqmp+XSbIvoq1U9fZ8K/PNKnDkVyF5Hnpr7M2Ho1r3shiN9H/KvcW+snx49PLHZdajJ/jHsikhn/sWp6BSKHjxhpYo9X5ybC1ukGs/dR8suKtq/tK1b1668qMsz7OLptMphDGoESA9xQ/9uB+nE4K8tdzcMZAOERryy+zM3JLAjP6NaRlp5EhqTfLcKTaAoIsYhmy11SLR/ZORU2LheLp7wphbYiGj0FRHrv4CXDK5Onr0KKtXr2bixImEhNR0I8nMzGTevHkMGjSI5s2bX9ZB1qEOfxp0PlddAlgbknNLseWnYPx9gguxAlBkHhF5zg0fy/ytgAaw9kXpfwlsCAOegsiOoHEN1k5nFjP9252cy62af/TkkDjuqOi5coec0zJU+XyU5WFM38rnexuz71wBzSKM9Gkeydq0Yj7fcJq8UisKhczg6tYgkAg/PWkF8nD836ZMPt6uolfjKYR6axgfWJ+xH2/BoFERF+LDG8trDuS1OZx8si6el0e2wmS188by45RZ7AxuGcYLI1ry6tJjmN086KqTnriQ2r9Pb51nA4pwPz23927Al5tck0khPjoeHtQEr4vIdgJih7zpf7Djs6plRWkolzyApsfjbM0awIJDORgNambd0pXWUX5/LcGq113cOc9td10e2hKaXffnVJX/bBz80bPL3Ma3ZBD4gTnSb7bhjZrbtJ38x3PFyvLAqaBHXIB7A5TSXDi9TgYE550RE5o+j8lsqa53iyW6QlGT3Balyqy+RoPEKn7ER2Jvr1RB6n7Y/Y0EvUnbxPWxAud2iMlEtxlCrPT+UjksSpeeqV1firwu85hUgjKPew56D/4ossmKCtvhX4UotRwl+935uRC9whSxVc86JpVBrQ8klNuxO+wSoDcfIdJGhRJ8I8UqfvYYkcLtm+VqMe90wPElcm57/wfWvCjLbRYx7ej9kFSYsnJlW41OiOiZjXL/7H6vVPSdTojqKNK9E0vFLMRukQpMhVyu0+2QjgyQLUqTvsgGveU8no+SbEL3vk9C+8cID2mO4uBP0mO44S04MA98QnB2v49k/x7E+Pjw9pBA4gK1eM0e4dpbm3ZAqnoT5ghBMuVXnSsPyCwy8eMeExNv+IHgpbfL8Nx+T0hfX0X/nSFAZjnu+Ex60/o9JQqI6vPyylHW81HCvX3Zemcj/B256BTnUJaFyrG5k6wenCf9epf6TNX8ASmo1gt9NK0Qi93BiBb+PNlZScj251Ht3Qk+oXRvdxd6ezCf3tSRW7/dRX6ZlVBfHekFJkKNOt4d146AiyBXLaP8PE6LiQ3yBmqZk3aFYfkDoldq8Xx91OHq4ZLJ1euvv86aNWu499573a4PCgrirbfeYt++fcycOfOSD7AOdfi3wGp38POeZKaHn6t6cJ6PY4vE/SmwgUiBItrKQ1BjqBlo2e2Y81NQ5GTz8XXBzD5s4tdD2VjtTtbFFzAlth0GTyYewY1F0+4GhpRthBpbAwXEBHiRnFfK68uqLKudTth0KpuXfxfDhylf76gkQGVWOxtOZPH2uLZsO53Nont6svNMDkdSPVei+jQJYevpHL7eXEVwvt16lu5xgbw1tg33z9vvsv3gFmEuWchwo552MX7sP+ehj8DX80PV30vLjH6NGNQijG82nyG/zEqPhsH0ahSM0wlmqx2dxnMgXWyykllkZuOpLErMdm5tCfqdX1RtoFBKxrjVaHw1XjzdIohtiSWkF5qY8s0Olt3fh6iAvzDraIyQSkDSVnGGc9pFWhbXz6Pr5JVGbomZIpMNlVJBoJf24gntxcBmrjJ6cYec0yJL2/iWBOBDXpFZS4UpEqT2uE+qK9ZS6Wvy5GrmHYKj1Rh8jf7uj+HAXHFlDG8t7omGACFIyTuFKLizpLeUSvA/8jMhAkq19NukyEBV6nWD0V/A74+A3VwjeUPmMTBGw9hvwW6SCmtgA5GhrX9dSEvL0VI58zRPCaRi5KwW0NlMImk+vqSqcgbS+7X9E5jym8zJmjjPdb9Oh1S9KuajDXxO3r9+T6li7Z/j/v0Tt0DP++W35R0CPsES4M8ZV+WQB7Ju1OdyXCeXyd8NH8u6n6eDSifSxIlzheh1u0d6lmK6SI9XerpIKR3lJHPPTHG0NOXXqPbqTiwkqOsjMlexLA9mXltFikz5KBbfT1zr8dDpZhS7XpN7gjvTIodNbPbbTqhK0DS91qXvyOl0klFoxmS1sfRQOm+vS2RTfSP/vX4Z4Y50vLx9Md56PYqcU3KN2kzyOSquk41v4LzpFxTzp0ulEUCpxtn9XvR+YXQq2QkLH6uqbqq0cr57/8f1+wX5jKZLJxo2fRDqqI5Vx1YdfjE4vEMrLa+LTTZig7x4ur2Z0J/GVPXr5ScRsP5JHBnbqTf8A5ZObwCZx3Bm7UcR1gJncAO0gRfnqBfso+Xuvg35ZL2rIkKlVPDc8BZkHd3u4ZVXHgFeGnx06koJfnUoFRD9Vz4//sW45KfUpk2bGDhwIEqle02+SqVi4MCBbNy48ZIPrg51+DfBYrOTWlCGyliLxbnT4er45UmWVZINh+aj2/AGcWV5oNbRuOUkJky6gwlzE9mekENG3xHE7njfvR1y17tFBuUGxf5Nycq0MLBZKA6nkxBfHQ2CvTmT7doDtvFUNvcOaMjCe3qy7HA6R8qt0vs0DubLTWfYHJ/NHb0t3DegMfP3urf1NurVNA83MmNOzWGg2xJy6d8slA71/NmblI9KqWB4mwieuLY5ftUqV8G+Oj6Z3JGXlhxl7fEMNCoVTqeTu/rEQskJ94MzS7Ilw2+34G8IwE/njdGgIdSoZ/2JLN5ZdRKVUsHX0zrRq1Ewaje9WYVlVn7afY6XfxdLaZVSweggPREVD32NlwS7iVvEHtlUQGB0ZxaPfYUPDxn5flcmpzKL/lpyBUKwWo2BRoMBx59mMGGy2jmSWshziw5zOKUQtVLBsDYRPDK4KTEXGQxdMJRqqcrFb3C/Prix9BIBrHtVnOj6PFruhBgkVT6VWoL4TrfBDjdzgOL6QV4iyubXu3+P4gwxhWg9VipA61+r6rOJ6SJEJayl62tKskQKuPWDqqpbcBMY+poQrJzTYlm+4C5xZEvbLzK96ghtLpLMX291lQNHdZTrtCQLSjLlcwY3gk0ezqF/fdeBpmEthQydH3iD/M7WvgjXPCdBfkxX99UfkHWrn5ffy6RaqosgpEDvB8Pelvf4bYYrsao4Z2teEEfG1c/LsmWPCTmtGOq8f46ctwlzpBIX3UXksD9Og5gnXPfndIh5xw2fVJErpVqcaFvcQLDejqLUKtU2N9UmxaEfod1EIZGb3Zv/AOKc12Kk/L/OKFLw8pEBJSYb2xJyeGrhIR4e1LQyIbUzsZBRiYV4a1X4GUr4ZVgJEQtvk2M+nyif20mKIxDdxJUEk4/CWgpqPYrd3wAOWHSP6/HbLbDxf1Jh9It2HdGgUFyWEiTD5oW9/wfUWzLRtdfMK5C0Yd8BAVRY/rSN8eOB7gGEbrzTrRGKMu0AFJxD88Mo155JY6T07gU3cn8QFVXW1H1iMBPeCl+fCG7r3YCO9QP4aG08GYUm2tXz574BjYnx07LGg/nm1UCoUc9jQ5vy7G9Haqyb3iP2ouSOdbhyuGRylZ6eTkxM7V17UVFRpKV5sIyuQx3q4AK9WkWUvwFzYC0yWq+gP35Y2a3iEFZdpmEzYzgwk1aFiTwz4BmeXpnGU+sK+G7yQtQLbq2ylNb6YBv0ChZtIF7uZn+pNOTXG0zLYgVd4wKZPnMnvnoN745ry8M/HSCnxDXgWX0si11ncvH30nBnn4Zsis/i5m93UTEK5ERGMakFZcQFe7uVWfRtEsLyozWt0Cswb+c5vpneiVKLHW+dmmAfndvG5Ag/PU8Na86tvRpQUGYlJtCLAL2SrevPkyI6nSKD+vV2SBc3KIUhgLA+LxCua84HW6qCRrvDyYM/7mfp/b3datqT80oriVXF9g51NVJwzfMSDJ8rN09oNwlFy1GE5B3g+SbB3N6uGSmepFd/BfQeZj5dJcRnFjPu823Yyy8Wm8PJb/tT2ZOYx/w7uxNxNfoIzMVSEd7pYX5Tn0dh8QNV/07ZK39KFczYLsTKbpWERe+HhUBv/1gCdaUKmt8gWX7vMPeVv+JM+dN6SwD90xTXH8W5nWJCc8sKcRD0DpKh60cWwpZ3xca+gnRkn5RBriM/EwndyRVC3ArThKhsPM9cpv/TkLBBzBFApIP750jV4OBP0OV2CeK1vmIA5G5gLUg/1p4qtYpz0Esozm7xfM5PrZL3zjgk5/fHm2pKDlvfKP/NOVW+UwcedVkgFbgpC+V8hbX0bECSdgD6Pl71b0sJ4HR1KsxNkHtCZHupOhWnyzJ34Y+5SKqCar3sY/QXEL8GfrsXpbVU7PZ7PiSENWW3yBSrz/NK3ilSzNpcQr2DwWnH0ulOFF3vRB0UW2krczKziNu+l54qH526xv24xGKnxGInhXpE6Ixuh0vb6/Vi6clStqUW8/6EthhLk+GjjtBooFxDnmSIu7+Rilr166rx4MsaYptRZGbGTxm8c+0cGihS0eYcw+oXR6quAY8uzuGdcWYiyvuKg310dIlQwWoPg797PQg/Ta15LRSmSqXypgViB++yLg0W3g3V7eY1XjBpHoH1ujOweRgd6wdgtjnw0anx1qmxWi9uXtblQqNSMqJtJKG+Ot5cfoKE7BLCjXruH9iIIS3D8blEN9s6XB4umVx5e3uTmVlLhh3pu9Lr/+Lm5DrU4R8ClUrJuE4x7DoeT0S9XqiT3BgJDHjGdbiyqVAyshov6a0AeThv+l/N1wKaM2vp0/VpVEoFe5KLyA7oS/hta6Akm1KTmTJtIG9szqdnjIZrOtyJ974vq4IMnRHr2O/JIJis4lQemLcfu8NJbomFj9bFM7FrPT5aG+/yfm2j/WgY4o3DCb/tT2Foq3A+pUpK0al+AMsOpZGUV8bDg5rw9krXYC3UqCMh67yMczUUmWwYtGpigz0TTofDydG0Qm75dheZ5Tb34UY99/ZrQA26UHBOJDvVg46yPPxX3M+UG+bwW5AXiTlVx5NfaiWryFyDXDmdTubsSOJ8nCz1IsovRiQ13iFVxKr3IyL5mTMenA6UQIxSTcTg16BsfJXz178EhWVW3lh+vJJYVUdyXhl7k/IYdjXIlVoLCetF3lXdlE/rI9IypQa63AXrXqqS/On9YMw30hOUfRJ2fiUzhvxjxS2tyWAhWz5h8hv1CRf3v+oozZOKzJoXpIrT7iaRajmdYrTT8wEJqu02OcaMo1IJctplQK/WS/5rKpC5UxlHhPxkHZfeI62XkPnSHOm9Sjzv3lK/l0gJd34OG14X4tJwoFimr/ivyJH7PSH9SQGxMn9w5Gc4t7yH4sTvEnD7hkPfctv19EMQ3hrnoJdwhLREmbzLs6+k0wE4pfLW5xGR4R2YJ78N7yCxoFdppGJYIVM7u0X6ytzJmoMayT5nj4OJs+Xc1oYa0k0FNQZtnVolMkFjpFtC4ro/i1SsBjwl5LZ6JS7nNCy6F0Z9IddEve5SDV39gnxXhkDpURv8Mux0P5PK3OUeNtKVxfnN2fp5Aj/fFU5ssDeFZVbeWlGVLIrPKqZNtB8Hk13l0MNbBhLorcU5fjaKOTe6uj36xZDc+w0+mZtKs3BfVEqFDA53OuS5k3fW8+fOS5RruwL1e8Gwdy+r0q1VKUkvNDHpxyQCvDSE+3Ugu9hCVpHcW7VqJdjtUJKBv8OG0d9bvv+c+Jo78wmT/kV3SD8Epdmu5Mpmkd/g+XO8rKUw+0a4ZycExOJ/KaZGVxj+XlqGtoqgY/0ALHYnaqWCUF9d5VzaOvz5uGRy1aFDBxYuXMhbb72Fv79/jfV5eXksWLCADh06XM7x1aEO/ypEBxjIjo7hZOg7NAj4FMOROZWBmb3/M2REDmDLvlR6RGkJtySi2vCGOF0FN5EMbGhzCbDO76eoBm3BGQK8/LixYzSBPnpQR4IxklcXHKZnYy9+2necn/bBnV3HMmHiFPSFZ0HrRboiFJsyjPFf7qqxz11n87i9d1zlv720Kj6b3JESi5Xtp3PZFJ9FlwaB+Bo0TO5aj1nbk/DSqhjWJoJ7Zu/lWHoRk7rU46tpnVhzLIPcEivd4gLpUM+fUxnFrDvhPpHTv2kIRn3tt7G0AhOTvtxOocmGTq3k2etboFYpWX8sjaF+sOFEJm3qBRFq1MOZTa7BU2CckKD8REJ2vMbdnT/gieWuZM/uJntuczhJL6xZdXpxfS7Nhn9DxI7XqvoIfEIhpAn8eofrxg4b6uWPQnRH+fsXocRsY6cHq32AVUczGNbmKvR8aQzS77LsSYh4SGzFFeXf777vxda6y+3Q8gaRP6m0UmXwiZBKxHfDqypHKXvFyW3IK3JdnVoJ03+vWbGyW2W73x+W9y/Okl7KnZ9Lz9WAp2HpY+K8plDK/LMOU6XHZdWzMs9o4/9cLdobD5ZjXf9aFXk4uUJMJTpMleOpgFIt7/H9DVXuh06nONKl7JFzMHusfF6/KPj5Zrm/aL1RtJ0oVurGSHFZRAFxfaDVKMg4iuLYEpQqDc5Gg1Csf839Oa/XXRJC6QelcmgqlGRRx+mShDi3C9rcKBWECuyZKcSvLE9s5EEqg/2flu8vdR9c+5oE9mqD5yqXzogLkdIZ3UvlvAKF7MX1kR5XT7PdlGoIbyP9bQENPEsc170sQ32XPCT9dKO/gCX/kXOx7DEhs9e+Ke591Y7F3GQ4mZEDSUlWsPhIAk4nfLj2FC+PakWpxc7har2rP+5M4slhzbl3TtU4gEf6hHGT1w78574oFb0xX0FeIo6SbAqCO3CSery4NI/7ewQzqpk33sXnROpXQazC27g6FVaDM6Q5zgb9UE5dJETGO8R9b+BFIMhHS4ivjqwiM3mlVhe78dggLxoaSnBs/gxl+WBlZWhznP2fQnFmo0v1FKXKswFLBc438CjJdJ1zVh02MyRuk0TD3wghvnXFjL8LLplc3XPPPYwaNYr+/fvz/vvv06dPn8p1GzZs4IEHHiAvL8+j4UUd6lCHmtCqVXSODSSj0IvcoOcI6PkAaoeFMoWeh5dmsGb+fvo09Geg9Syq5TOqXlhwDk6vEVeumC61SmacXkFM6hLB1O6xkvkrR9MIH/KrPbw+35HF5zvAaNBisVkwWZP4ZLLngbEVJCPQW8u3N3fmWFohW0/nYNRreG10GzacyGTylzv4/pYuHEwu4OVRrQn11REX6sOx9CLm7Ezil73J9GgYjK9ezdydSexNyuOJoc2ICTS4uB2CELi7+jXEoK39NnYopYBCkzT7vjSyFQv2prAtIQedysnQLnDP3H20qxfE51M64p+4VV5U0UuTe0aCyvY3gcZAc7W3y74NGpVbK22NSsmQluGsPuZKCs9kl/DgOi3fjn0P/anfJZvfagzsm+35A2z7SPoZ/sg56/8RlEoFAV5anDjpXN8fmxO2ns6pnFHWtUGAGK6U94PgEwrqWizNq6M4o2rUgtb1+8RulQrU4FfgULa4AWaWDwvtdCtEd5IqkDbWNbAqSpd+Jnd9QGteghtnygDi3/8jbnvVM+RF6WJOMPwDOSZLsSRJfCOg/5Pwy+3gsErVOryV2LP7x8hxTpwnw3mr97mAEDlDALQeJ8OeK3Bkgdi3q7Qw6Sd5r+Cm0gfkzla+LE+kgk2uk/3Nm1iVuLGUiGX6rq+EDI7+SioDhWlCPmL7wNGFKL4dBndvw9lyNIojv7ruX2OQKs2Kp4WYBDeW92zQV+5hPqFSpfv5ZtfBtpYSsVsf9o7My0o/KFK7ze9K9a8CXkFimNF2onsDjB73VZ0fhQIGvQi73FSM2k0Wkua0w44voO8T4M7vp/d/hBjF9pJKlCfkJ8mxVZzjVc/JbzzzmFjf7/0ebl4Ok37CkX2aEpOZ/LDubEjX8PxnxxjdIZop3erz/bZElhxM45EhTdGqlET6GSgsk+8ntcDE6qOZvD2uLR+uOYXZ5uDGyGz8Fz4p75uyB+ZOhMA4lD5hlMaO5vXluXw51ED4psdRbpaqujOqE4rr34NNb0m/4O6v3ToJZnV5FHQxhIY09vy5LxJhvno+ndyByV/tcHGF9dKqWHBzc9RLH0J5cqkQxd6Pgm8IiqI0kTCm7qsyp3E6sAc0ROVpMLVK68YQyur+N1GB/KQqM6k61OE8XDK5uuGGG3jooYd499136d+/PzqdjvDwcNLT0zGbzTidTh599FFGjhx5BQ+3DnX4/4+K+VRpBTD++2Sm92jAmyuOk1EokraHuhkJXPKE+xcvfVR6PxoPlkz1+fAJIyCyEfc0j0R3ngV0n8YhnM6q+TCpCGj1GiVKDzKDmEAD9QK9eHNMa9rXC+DOWXtIqGZwMWt7Ig8MbMwN7SL5enMCX07tJJUi4M4+cSw9lCbuezZHZZVKoYC3x7UjKsCLubd34/MNp5m/Jxmr3cnAZqE8OqQp9S7A2OBMtnymBsHelFnsbEuoOURzx5lcDpzLp29oM6kW9HpY5vS4SGaiaTT+FwK8NJUZ1Gevb+FxTlGPhsGEG/UuFawgby2vD/TDMH8yDH6pvBIR5N4ZrAIFSZIp/Rc9xEN8dPw4uQG67GOEnv4Yu0pP5ujxbMwJRaVUMIZV8MXr0j+h8YLOt4qVdm0DS4syxBlu20dVAXy/J8SGW60VkrPrayE6Vgu0/UICNq0eAuqJ5MkrwP2+S3M9S45sJpmHpC2Xrp5PwMyFMPR1WPpIVfVp4lyZXZR9Snp4xs4UidLal6qdpOZSnTmfWFXgyK/yuv3nEfeD8yVI/vkWIae3roYz6z2ft6RtItezlsk5coe0A9IPNa/c3j26i8xkaj8FBr2EojAF58Dn5L604zORJ9bvCT3uhVOrYcCTco2bisSNUG8UaWP2SZEzVidWleetSM6puQg03vK6Q/NdtynNkd9PdBcx2tj9tUgLAxpAv/+KPPPkMpEedr1TrNfPn+vW4/5y18LfxLmx7QTQBkBKgkjfMvfLvns9LH1j69+QYcs97vN8TpVqXAZwZ5Y7IFgKpVqOE1L3YD25hqPd/seTK1KJX5NbSTDm7znHN9M6M2t7okj3gCAfHfcPbMyM2VXmPwv3p3A0rYBbejbg2kY6ghdPr3ksuQmQm0DAyR/54vqJhMwe6HLfU6Tslp6kCXPEPn70l7Dymarr3SuQ3H6vs60ojMGGK+Tk6XBAcRpKm5kOATo2PtKH3w6mczC5gPb1AhjUPBRfcwLKkgypBpdky/GoDJKgKEjGOeYrWPcapd5R5DQcxbFUDX1a34Th4Pc136/7vZXzISuh8ZLv4vyh3RUIaiiVx47ThRD/VUPP6/C3xGX9Et5++2369+/PJ598wq5du0hOTsbf358BAwZwzz33cO21116p46xDHf5VMNvsfLr+NCczitFplJXECiBEWeQ65LM6LMWiHb/ubZHpVDy0QTJzN/2CPjDa7XyiCD89JWYbvRoFszm+ZgP4lG71ySismbFUKODBa5rw2M8HeeiaJszccsaFWFXg/TWn+GZ6Z2bM3uPSS9MwxIcPJrTnqQWHKitMRr2a18e0oWGwVBaiA7x4+voWzOjfCKcTjAaxn60NVrudnGIL/ZuFVlp5/37IM4l5b/Upeo2/DpUxEhbf70qsAAqSMSx/iMf6vs7ik2U8eE1jmoUb3c8pAqICDPx0V3feXH6cZYfTsTucvHt9FA1W3y59DBXWzWc3QUQb9+YAADHda1ZYLheWMjDlgUIl1YG/mTZfWZxOvTV3o0jeDc2uR9m4P1HKfG6McqJI34dqWbXqhLVUelvyEuV8uiNAJVmw+D7XhMPRhRJM37ZGZG2/3Qfx5T08ynJ5zYI7YOwXUkmqFbVYk4P0DI37TkjIzi+EWIS1Ar9IyZqv+K9rELf9Uxj0MpxeL4H/oZ/lOqkOSzFkHMMj7Fb3WXpbmVRVxn4jZgtFqeVVlFPu9+MVBLoAyPcQZFZ/vwqk7pFqelmeSOBKslDU7wn9nhTS5bDL9f7t9WJdHtq8vPJ1VohU7mmRyF1T/j1PWSif9/jvMoDbYZeZXKH/x95Zx0lVv1/8PR3b3Ust3d3dnRKChAIGtn7tVuwuLBSlRJAGaZDu7oaFXbY7p35/PDvMzO7MEqLf+O15vfalTN07996Zec7nnOc8tR2x7yuedL9fhkBRFcPqQpdXhLjZ1cLwejBkOuSniIWy7mCZvXVhk/TXVW4rx8g+PmHhJOkjKi5ZMOn2GuRdg8T9cpzsxyArXtRFtc59Gmvt/nB2rettCiXkJMv77vIiFpWB3JhuFKblE+Wr4USi41zabHA1s4BAo5be9cIJLEmEa1U1iAc7VuXbzeevhwbFpxegUSu5kpJJSIbnc2jU69CdnF32ew+EWJ9cia32ABTHlmDq+yno/UjLK+ZSoZEv9+Ty+sAoDJo7QK7yUuV63/IB5KWiNAYR1u4pJjcZDh2qXX9Y8bGLohTOGeGqMEU1FdfB9i/I7/Ee988/z86t17DabEwfdj/NvCPw2f+NXGfGQApbPQENRqDXyuJVkdlCsdmK0SsUVY+3HAsGzgiuLoskh+bKX4+pQrL+jTMyK/Cfhb/8SejXrx/9+nmIlK1ABSpQLrILTKTlFZOcU4iPTkOwt5ZQXz2pOcX8tjceb53axaoHYFO4H3/ggEJ+2O9ZLH0aycfBL1b6enyjPBbSWrWKGmE+vDOkPl9sOMOiA1cxWWx4aVWMblXpukr07tD6fPvneZKyC2kQ7cf9HapxLCGLKZ3jqBbixcNz3c/HAth9IY3mlQMptlixWm0olQq8dGp61wunSaw/yTlFKFAQ6qsj1EfnEnGuU6uuJ0PdCIlZBczYdpHZuy6TV2ymReVAHu9Wg6x8k8deniKzlTx9OL7GINcoaicoL2/nrn4G+raog6/hxilMsYFG3hvagOd618JqsxFVdF6IFchKeExrsZspSv5durleY4BmE6Q4vxOwWmSFd8sncGa1pL+1vB/qDHQNSvl3wmaDk8tRpJ4WBefEclj+OJjyUY/+3X2kN4gdq8tL7slV5mX3Sq6lWPqWur/uIFalsep5UT7KS3AzBIpakRVf9j6VVqx3P3R1qFbbPhW1Y9xSMBXKcFdnXNgspKNqB7Ef/tC17Ovmp0o/jCdovdyTq7huMoz8ym5RW5Y9Cm0fl8hxd2j5oBBxY5Bnu7HWS8iBHR2eEeXsxDLHbSeWwak/YOwSSNgPO75wzPOLbSNkd/MH8m+VBlrcL5bDI/PluKm0Yu+7dzUotUJcUs9AQCUoSPc8G9BmlfO74klR4exQKEVdOvq7EEAQ66YhQHqm2j0lhXWek7U3v2Q7CduAdjBzIAz+SmL5A+bCgC9ExTi2EM5txDb0JxQLxruqlSG1ZIDzb2Mdt+n9xK7657vy7w06VIO+IWDPD7S8doS6je7jZLPhjP710nX1yqBVSQprx2rXXQiBXloe6hzHyOaxnEzKoaDYgkGr4pcdF1HV9KZRSC0UuU7vxwmW8MaoNr/n/hgCXNqGrd0T5Ncdyf7EIh76/iB5xRY61wrllf71bspFcEMU58OOr1yj6PPT4PhCmS1WXFm+E33CUQdWgZ96lCWDV/fBsUUoFAp0hWnEZ+RjLmGa9y64RNcaXZjUqx++agvBAX68sj4V9ZWrvNLPjyuZBfy49QLXsgvpWCOEexq1wPeuGShWvyCpgkoV1Ogt38kLJ4v9td4wUZcLMirIVQWu42+cxliBCvwHw2YTK1ZRTonfOsiRtvcPITmnkKkrTrD0UML1eqVykJHvxzXDqFFRaLJispgI93NtUo0vMhLjFeI6S8YOY6Aj+tYnTP5iWtz0PqlVSrx0KmICjXw9ugnFZhs2m42lhxL4brOsej7erTrzJrfCYrNh1KjQa1S0rhaIXqPmQmoehSbPE+Nziyx0rhnC5+vPMKJ5DI1i/dGqVKhVSqICjEQF/PUf6KTsQib+vJdjCQ51b9eFdO6ZvotZE1uy4khimYhigEGNI/E2Gt2v3DpBbS26KWJlh1dJRC8A50uRtrUvSnKYKR/u+gXWlVjBQFbaB3wpRfidQvo5+K6zY6U3L0VmbB1fIsNjfcLKffo/grxUUQp6vw+rX3RV9Ipzy++DSL8AITXL3u6OWNmRdVn6Mzwh+6oQmZRToPOSXiefCNfEP98IGPglzBpSNqq62+tynIf+IAV99lVJxsu4ACv+JZY7dzg4R0hvbor0WwXXEPKtUMLhX0XFyUsWBcxO2J3RZJwkzzmjUlu5vvNSJBWx1YOiFpkLJO68tK2u5QNwZZdYpDRGaDBSVupLo82jQpxASE94fVGCSsNqlnPaYrLMg9r2mRCeGj1lyK8dzSfJNWkfIAxCUPb/LN/Z7Z6Aaa2FlPR8R4rb0jOW7MhPlSTGUb/CoXnyGQiuLu9F5y39XAChdWSxIe2MvBdzsQRp7PjK9fUyL8tr6pFjmXJKFLTkE0K8Vj8PDe/mROXRKL2CCZ+wBb/La4WYRTWRxyyc7Nq31O5J6bOyw1wkAR7DfoRf78Z71yc0uLafqT3e4OmVVzFqVcSFePPLfS2JKpWa6aPX4KPXgMJG/y+2UWiy8tbgeqgUkN7iXwRdcDN7VK2jOLg2Ou8wPC7deYeiPLoQCwYqR3Vi0UPt8DWoMWhVsr07gbxkId3O6PWOHI8lDwnB8YuBTs+jCKnl+bv62CIY8j3qxAO81r8rE2ZI6InNButOpbHuVBrVQrx5sFMwfxxPYUSzGObvu8L7TmmLey5m8N0WNcsf7k7sxJZC8jIuyufmt7Hy+YpuJmNPzq6FxCPyWfa9g9/XFfivxY2WwG+IRYsWMXz4cBo0aEBcnGMI28mTJ3n//fe5etXzKnYFKvBvQUGm2A6+7wxftYAvmsCi+8VW9A+h2Gzlu83nWXIwwWUh+GJaPmN+2IXFaqN6qDcWq40Tidm0qeZIXXp3ayYpPb4q8e07QamCId9j8w4jPa+I9DzpfXSHQpOF+PR8zibncDUjH5PFQYhMFhuzdl5i0i/7mDJnPw/PPcCa40nX7997MQMfvYYIPwN+Ri06jQq9Rk16XjFqJbSs4mGwMdCmahBxoT4sPpjAPdN3k5Bx5+c4nU7KcSFWdpitNj5bd5qJ7aqUuS/K30DfBpEolQopvDxB7wd6/9vfOe9S5MVqkWvv2hEp9O76BR7YKn1zY5dIMaa6Q2tgRbmwYap7cnJpu6RO/ifAZpHFjsLsslbJGyl4noZql2erNBc7wgXcQaGU74aZA+GHbvBte0mos5hdHxfTCu7fKkV7cA0ZunzPYohqBkumSEE2b4z0dfWcKoXZubUyuLc0fCLEZrT6BSG8xxaLijJ/HCx+QIr5Li/DhrekB6aKI1AKtU7ISeN7ZOhpQBUhYL3elWj41S84HmtXSle/IGR+4nrpRer6KkzaKN8xG9+WmXmmfCFbnV9wHC+/aBnUG1obqrSTxYCIRqJMeULiQbnWf7tHZoFFNStLbqt2hBNL3D//+GIhUzarkDVsQkDbebAFqnVwfKn0mKm1EjGPQsIvTv0B1bvD6PkSLBPVRI7TgC9FAYlpVfb1gqq5hqdkXHREkNuskJeKNTeZM+lWLmSYmHMkT5IjL26RhYOCTPkeUSiE0A38Usha6chvc6H0h/X/DPp/hjakGq1Di/DWqfjq7ibUjvApQ6ycYVRamT4kim0PVkdvzmHqypN8c0JHeq+vXb/D/KJJGjyfHw4WYG5VTp9YgxGw4wt81z5FzPJRBJgSOZ+Se0N79i0hP81VvW90txzfda85ZjFmxcOSh1DY0y/dwa4U6rxpWimAT0Y0IqSkN1apgO51wnilX22mrjiBQgG964fzwZqy33/ZBWaeW3iULE2wRPHPGyNqalw3UTgX3AvnNkjE/vFF8t1gH69Rgf/XuO1PhdVqZdSoUSxYsAAAg8FAQYFjJSYgIIAXX3wRi8XC888//9f3tAIVuFO4uBUWTnT822aV3ouUkzB+Zfn2nzuE5JxCZu10T+aSsou4mlnAW4PqMeK7nXy54SxfjGpMuJ+e5YcSOXw1h6lHg3jj3i14H5mJMumwFE/N7iVDF8HinfH8tjcepULBiOYx9KgTRriTnS4pu5CvN53l193xFJmt+OjU3N+xKiNbxBLsrcNHr6ZZpUCP/Untqwej1zjWZfKLzRxLyObN5cdJyCzg/aEN2H85A5PFldg1reRPdICBcT/txmK1YbHaWHYogUe6uiczyTmFZOabsNnA36ghzPfmYmbXORHB0th5IZ13hjSg0Gxl6YF4IJfJ7asysmVlR6HiFSpWj6MLyr5Al5f+mn3OK0Sa4J3nDFnNotQU50Of9+98f5UdhVlynXvCkQWuRfq/C4YASWc8u77sfVf2ShJb6dABEOLqG+X+NWv0EvufO1RqI0qLxuA2BY3qPeDCn45/56cJ0Xpop2tioEYv1qX+nwqR1RhEnfq2vauVLvW0hKWMmCkR5xYzjFsmg34P/ybqycg5Yh3s9qooOs5BEsUl0es93oLqPSF+J0Q3FwUn/ZyQwRPLZLs1ekLzeyW5b8WTjvj/EtgCq6KY/KcU+ko1ZFwWhSogRnrAdnwpD7RaYO3LMgS5+SSo1V/UhMQDsH+mg0xFNJJ9vlqOEqhQAgp5/p7pcnytpeywpkLPA4JtVpldNeALeZ2gahKhnnQUOr8o+2wPwIhpKUEFTe6RbR361fE6UU0hqLr8zR1VQtRKEFYXhn4vxNsZfjFynOoOhlOFol7ENBUCW6WD7IdKi7L1g3RJjycrJJS40BqYUoagmT9GSHlEQ+kXi20t73vhJCnO3aEoR669q/ugUhsivVRseKItfl5Gj72eAGTGE7T1I0IOzQVzIX0rd6TZXS/z1KZCHk2tzON9lhOqzMGo15Fs8eaxFddoEF3MgcIIGrV7Ft3WUvbAFpNEFcwt+W5NPU3gmQVEVbubS2l6ogKMaFR/ea1eEhmdUXuAEBp32P4ZDJsuKlVp+ETIsavSAV+DhkGNImkQ7cfJxBzUKgVbz6Ty4Oz95BdbqBbizbGEbI+X2/ZzaWTmm/AzBIilM+Wk2FOdbZ122KwSTFP1tVt51xX4H8Rtfxo++eQT5s+fz/33309GRgZPP+1qbQgLC6N9+/asWLHiL+9kBSpwx5CTJEWCO6SfLz8+9w6i0GQp1z53KS2f+tF+zJ7YkkpBRqbM2Y9GpWDmxBasfKw9/+rTEGNELZQ93hS7S4+pJGpiGfb9fl5fdpwTiaLevLLkGON/2kNilhSNmfnFvLLkKD9vd3j3LTYbB+Mz2XYmhSKTBaNWzaNd41Ary/Zm+Rk09Kkf4TKc8FB8JsO/3cHhK1mk5hbzw9YLfHtPMzpWD0arUhLirWNK52pM6RzHiO92uswqOXw1C7PF9TiYzFb2X8pgxLc7GfTVNracSeHIlSzm7bnM1jOpJGQWYHUeLmu1SMFZYscK8PI81NFLq0avUfFIlzhmTWwJwEOdqrnaEQ3+0OttKdTsK7x+MaIQ1Bv215QkryAY/I0U+/ZjqFTJ0NiuL/99xApke+pyCOrfue1bgVonK8Puho/umS4KRWBV19sNATB6QdkZUnb4REDX18re7hct59knUgiNqtS1E1BFLGylY7xNBXCulNJgh8ZQErVuE2XJXdVmypcV79qDIOUEzBoKhiCxiN41Qx7TaLQQrbyy4TKAhF60niKr+qmnZYVfrYftn8PheUJiguKgcnsh86X7weJ6oLCYxWL4U2+Y1kaGI4fVBbXRdbveYRL04Bcl9qy5I+HofCGzSqWDZCYelIG7dQZI5HvN3mXVxriuYtMDIclB1aSPxRk3itXXGoUsr3lJyF1wdTlH147A2GUyUHnkHElFnD1USF/L+x2Jm0q1HJvo5tLP50ysQJIKjy4UkmxHVBMJTCnMcRD/uoNFRTu+WBZjLu+A+/+EzR/jrdMQocwgPGM/Sq8gbA/ugP5fyHFd9az0w147UpbAOSOgsqjKBRlwcgWKn/sQWniRjPwi9lxI5/Wlx3h96TH2XkwnMbNkYSDrKvwyAOW+n67PdlJd/JPIBX35sIsXB6/mMmzOZTrMyqD9zymczPPiTHIuPeuGM+7XMyTUnsCVMVsp6PWphKqMLrGKbpzqsmuKowuIytiJtSCbBfuukFVQehjzbcAYLKovyPeVuajsubHDKxh8omD4L/LXdIIsDAC0fVQ+2yVOAYVCgb9Bww9bz3P/zH3M3HmJ/GL5vVAqbpznY7OBzSuYwj6fizpekOF+7AJIQEwF/t/jtquEGTNm0Lx5c77++msAt5Og4+LiKshVBf6zYMr3HK0K0tRdrfPfvhsGjQpvnZrcIvc/HNVCvTFq1bSNC2bOxFbkmyyolQqCvXUus6lACSofbDYbq49f4VxKWQ/6yWs5bDmTyvBmMWQXmtnp1PfzYMdqNIr1Z92JJNYcT0anUdEoJoDKQV7Mu781zy88zOkkKTBaVgngrUH1iQ5wrC6m5Rbx6tJjLvXj9nNpHEvIZljTaF4ZUJcTCdnM2X2ZrzaWXZ1tGO3nEloBEJ+Rz6jvpbn+y7ubMG3TOfZfdgz29TdqmHlvC+qG6lFmX4Z9v8icm4iG0GQswxuFMnPHJR5rE0S7SAVKSxEZNi++2ptLXJg/Qd4a1Crl9Qj10tsH5Ee53VNS4FqKrzdR/2VkXoaN70rAQdPxstLpHytFgpdnO+UdgTFIFKGdX7u/v+GIv3f7VivkXiuZTaUTK5Unm593mKgCzoNAQfpVFj8Aw2cKmb52WIhWaB0ppjxVSXpfaUKP6wx7Z8h+1B4IVdoLsUo/B5d2wohZUljnpkMxYpFbdL97K6VzEqc7FOfJ/rndHz+5BhqMlN7P4T+L9dArROY0JR509DiN+lXUi+gWgE2uob0/yveYxSQDaK/shflj5Rz3eh/6fwk2M+z+Xnp3vMNF6Uo7C3++L4pX73dhycMOogPy3mcNkdcMr+cIsOj/qQy3zbjoeKy5SM5fozFyfEJqCcE4/KtYEm022e7IObK/p/6QZMqWDzr6nAz+QtC0XtB4rAxqBiGLkY3d98JFNREFyD7s+8BMmes1+DvY8Tns+1Hmdjlj2aNQZxAM/lb2KT9FEv/id3su3o8tlCJ9wiq5XpVqOR6nVgqha9gWNk2FS04pjknHJPp++Ew4vQrl3BF424twvT+2Ph9iG/4LltTzWAOqo0s8LDZL5wHJdsS0FEJschpabi7CtvoFDtX7kPvnn71+80/bLzKgYQQv9qlNWPwu979x5iJC937C3Y0f5budEmqhUiqw2mw80a06m8+kolUr0Rr90PgEoIisCmufkz5Qd8EoNivKnARCQ7J5fuE5ovwNdKgRUvZxtwKfUDl2P/cVEurp+6F6d/l+WP64fFaUalG5Jq7DZjGD3heFd5iL5TbIW8cXoxozZc5+DsU7ov1DfXR0qRnK+6vc26IbRPvha9CQlF3EW1vhuSFLiSy+8Nd7airwP43bJldnz55lypQp5T4mKCiItLSyM2UqUIF/G1QaWQ22D8IsjYB/phk11FfHpA5V+WRt2fjtKsFGKgU5lJRgD3OUnJGZb2L+XjdJZUDtCB/CfHWsPX6Ni6n5vDGwLsVmK1czCsgoMHH/TIdVaMWRRGqGezNjfAuaVgpgzqRWZBeYZKirQYOf0XVlP7fIfJ18OSOrwMT0rReoFGikaogX28+V/R7QqZX0b+iqNJgsFmbvuiwDL5tFs/xwgguxsr/Xd1YeZ2aXIpgzzFEcXfgTdk0jfPTvbJ5cDcPSySi3SCNzZZ0vn7Z9FkX94WhU5dhpnKFSyUr9nUJ2IswcLAUuiK3FjrFLZJX9ZpCXKr0YOYlSjPuES9F6I6h1onScXlWm+LK0fIhiYxR/2yStvFTpG/rzXQlT0HpLGlzLye5Jq0IBgVUkOnvDG673BVSVkA/fCInKtsNcJEqDWuc+tcvgD4ZGMnjWZnEUbukXJI3PbiULrQ2GUAhsLq/jLjgGpPgtD2qdEL7sUivZhgAJt9j6qRT9IApF309g9hCH0mXKF6JwdS/0fk8WfpQqIWFdXpbzaDVJUmFgVQnOCKkpq//pZ6UfpES5IPmE9PS0fxoe3CFqSNZVV2LljC0fyeu1uF8ITsIBV2LV5SWxiM106nlRKCUau+FoIUdxXcXaeOAXIT61+sl7X/Gk41g3u0+I1a5vILalhO/s/1nCLHq/L71qzn13ITWh80uutm6Qfbm8XciofXCsM2w2sY+d+gMe2CK/AVlXoZxocpm7lQ2/9JeBy/PGilrS6TmwKsAKxO8p+7ysK6JkpZx0VTcKM1Esvh/FqHnkeFdiS5I3PWoPQnt4tlgct34in0uNURZ1qnWSAdKloLiwmfCmZVWTpYcSua9dZcKcQ0BKQXNpI+26P01JsDwDGkYSF+LN1jNpLD54lce7VifcV4/KvuAU19VBeEujVj84vwlFVDsA3l99knpRftdj4W8bobVg0iaxeep8y6ZwGgKg+UTpQbSHx1jNQoav7EHR4y3pixo0TRROJ0QHGPlxXHPScotJzysmyFtLkLcOpQLGtanEz9tdrfo6tZK3BtUj0EvLmaQclh9LZc1JJRvvq06UJxuxf+W/9v4r8D+B2yZXBoOBrCw3g/2ccOnSJfz9/W93ExWowJ2Hdxg0nwxb3cQ5q3WSpvUPQKNSMbplLLmFJmZsv4jJYkOtVPBSv9q0rhrEofgs/A35RAUYCPfVS9DCDeBuwG/1UG+e6lGTR+YeuD4MGKB2uA9vDa7H0Gk7yjzn1LVcZu28xOPdaxBsUBOsyJZ5SEYvKYoKs6X4NQaiVirQqpQUW9ysbAJatZL60f5MHVyPqStOXLdihPvq+fLuxkSWilbPLxZLIECXWqE8Otd978Yjzb1RLbqn7KqzxYRy4US8er0LV50Kn6JsvDe8CP6hEDCcfwuSjzuIVWmsfgHuWVJiJysHWVfh9/tcI6VDaom6EVg2qKMM/KKxjl2G6cJ2dCd+x6z1JanWPay55sWOJZd4a7APoT4319t20zAXSRLaeqfZVMW58hnMvAx9P5CCqTQM/jIcuGZvKYwLs2Q+UHB1V0JmNkHmRdj1rRwXn0ho97j0P7l7XaWS6454c7GoO85DapNPgPICBN4ntq3YVmVjyo1BHslVZn4xhSYLOrWRgPb/gjl3uT6g8wuw9lXXhL/mk4RElrYQ6v2g4zMQvwsOzZH+rBo9SpS4eyXJ7sRSuQb6fgQrn4GBX0hSn51YOWPrR1Czl/QbnVjqdv8BScCzFIsFqtursMopBMM3Uv42vOX6HJtVotTvngeXdwlhGjZd+plWPCV22LkjHY+v3E7SEL9pD8U5MuA3oLIES9QeINdNl5fFqpmfJvbBrCuiJLoblXByhVg8Y9uUTfizo85A2Ue1Qa6riAaej0FwdVFE7lsvlrjiHPlb/ACMXwsHy7F/HVkgA5JLp1RaLXB6Fd4qI3Xq3E9yPkTv+EqU15YPyO+TWi/v77dx7lU1lRaLzf3vwdrjKTTwCsHjr4Xen9xi+a6O8NMzoW1lnl1wmP3xmbStFsyolrEOYgUQ0xJbVFMUV/dJj1j9YUJMM+Mhsgns+IqMtvIdfjY5lyKTxd1Wbx3+MfIHonzO6OuY7dhotHzWS6dygpCwnERRpuePl2vRK9jlIUHeOoK8yy5YPtqlOu3jQvh60zlSc4toVTWQ+ztWI7bEMm7QqJg2MIo6fiZ0tiLMfT5GvaSU4qjSQr+P4YgHK28F/t/gtslV48aNWb16NYWFhej1ZX+M09PTWbVqFR06/Ac0SFegAnaoNLJafu2I61wbrZf0FPh46Nn4G+CrV3Nf2yqMbB5LTpGJAKOWD1af4rWlDrtRoJeWH8c3p36UH6pyCFaAl5a7W8Ty/KIjLrdP6RzHswsOuxArgDBfPYsOeE7y3HQ6hSea6+HIr1LYaoyyWugVLIllVjPUu4uIjs8ytnUlfth6ocxrqJQKWlcLws+g4a6m0XSqEUpqbhFqlYIgLy1hvvoydmK9WklMoJED8ZlYrZQJxbAjVpfvuRclN7ls74wd69+QxvM7YfG7VbiLQLYj6Zj7VVBnFGTBiidciRXICvmvo2Ds0ptSsC6bA3jgz3AaRT1DfrGNTQvSyC4UJbdxjD+TO1ZzvdYsZilW8lIARUmvQ4SoKDeDnCTY8qH7+47Oh07PuidBUKI2+QtR8oSkI9IzZCcTSUfls931VemX8jR7JidRFgrOrPL82ufWQ9snIGmSo7gLqwdDp0vxl5cqRZ4hgILiYiw5KWRk5XIi3cqWqwrebBWCuu3jEi9ttcgCjk9E2ej06Gaw5sWy2+/7EWx6Vx6v94MGwyGwmlwvldoJiWw4UopypQo6PyfDb68dKftaIOQt+WRJYl05oyfUOnnsxreFDKo0sqCi94f6w+HAbM/PPfir9BbaLdhB1SSwQecr87RMebKIlXNNYqxjmkv/GYg6ZggQhdM52l3vL2Ty4lbPSqLWKOEeKq2kzJXuk/ONksS7BfeKFbf+XUIgo5pIml9pdH4J1rwsBKveEJkLZz+Gl7YCVcs+xw6F0nMgR8ZFVD4RhBnMpNmM0gsYVlvIpFoH5/8Ua7oHu2JRnWEsOlnAgHrB9IvTYbPZWHi6mLUnU9l5Pg3rgHtQ7fnB7XNzG09kR5KKx7tVp16UHw/M3Mdbg0WZCfHRE2hKgsPbRdkMqQU1eqEY9hO2/FQUZ9bAlo8l2TC2DYQ3wNLpBX47Lp+72EAjGhfL+h1CWD14YJuc28TDQvB+6uX58fG7IbSuqIe5yWXIlScEeevoVieMZpUDMFls+OilPxcAq5XIorNE75ngUP2bjMc6fiW2fb+gyjiHNaoZyuYTwTsCjqz7a++5Av/1uG1y9eijjzJ48GCGDh3Kt99+63LfuXPnuPfee8nKyuLRRx/9yztZgQrcUfiEw+Bp8uN+7bCsQofWFmJ1p2Kvb4BrWQV8v+UCc3dfJr/Ywj0tY/Ezall+2DWhLz2vmDE/7GLV4+2JvsEMqM61QqgT6cvxkhhyg0aFUoHbmU5atZK8IverjBqVgi97B6H+qbv8ONmx5CEpinpMFWvPoTkoL/zJM+NWsfGUN+dSHPZApQI+G9Hoel+TVq0iKsBAVICh9OZcoNOomNS+CksPJVBkthDopSXdzf5ju8EKqafCJive/Yr+7cBilgK9OEdWwr2CZVXXvn2bzXUWUnkDX3W+NyYreSme5zUlnxBr1E2Qqw0nkzl5LYeT18paY7/bcp7BTaIc6ZJFuVL4Ln3EMaTVEACDvhGSqi3/mgTkeeXNDsu8VH78fXnIS5F9c3dON7wpfTalyZWpUAboLpkiZMVdcIYdOh9RGwd8DijEfucbIUTpwGzpXyvOw1azD/q6g1EsexTv5ONUCa5Bpy5TUZ/eI9fIqHlSpHuFuO/VUuukx8hcJDY4q1mOSX6aEKtafaHJWAn0OL5UlCPvMOkzNOXLNhQqCKgGBTew4iuV0hfU4w3ZJ3dFfJ3BjmTJhIPQ7TXZTnaCFK4nl5V9jh05V8GvZJEqJ0lsimnn5PqM3ynbPPybqIVh9US1MwZCVgJUai2Kln+s9AeeWiWKXW6SzNfq9LxEmrtD/btE0Ug/J4rXkO/FXliUDTX6CMlLPQODvoKEQ5B4SGxvPd6W+V6H5sp7DKklamHGBWg6VtRipVri4Wv2LSGyBihvjETDEZ4juUNqQdo5ErNNKLFiu7gFxfrX5D6FUlQ7na9YOEsvSvjHkt/qKSYUmAg7/hNeWxaCQkmb2sNJnDCajYkaCAiShQVnpRgwx7YjtXJ/tLlFbD6dwqydlxhQN5CcjFQahkViNF2D6d1dkynXvgKT/0Sx8W0460QYzm+Ei5ux3LOcpQvke+SJ7jUIdqMI/WUolRAQK38NSpIzjUHuZ5qBXEsZJYt9udfKX5hxA3+jm4W5rHiUP/dzVbj3z0B55Ddyhi8gx6caoUGBKDVaMN2BYI8K/NfjtivJgQMH8uyzz/Lee+9RqVIlvLwkaSo0NJS0tDRsNhsvv/wyXbp0uWM7W4EK3DF4BctfeL2/9DIWq42UnCKsNhs6tdKt3aA0UnIKeXD2fg5czrx+W9PKgby82M0gUKSv6VB85g3JVbifgR/HNWfbuVR+3X0ZP4MGDxSDQ1cyebZXLbfqVd86QUSe+MGVWNlxaZsUPd5hUvBkX0V7cRPz7h/BsYQstpxOJcxXT7c6YYT56jBob/0rpnKwF+8Nrc+i/Ve5t20VPnQzfyRfEyB9O+6CBnQ+4OmdGwNlZf+vIi9NCrJN7wh5UCilB6H7m1Lw7/1RUsQa3S0FpE+4FHJKlXs7S4tJNyZGpvKHG5N/c/2t8Rn5Hu/LyDfh4vBMPydBCc5ktSBDlLIHtkqy3I2gKZ9Q/6W5YQUZ7gfogtjUEvZDUCmFIeM8zBwkceJVOkkP19WH3L9G7QGw7iVRFQd/IwV6cZ4EENjVFkCx8yshASVDX0k9jfG3u+Tfp1bJvhycBafXlBA1JzSdACig7hAp7qObCaHLz5DHh9SSVLq5oxzBArlJYo9r84icmx1fChnzi5WeoIhG7nuPFAq5HtPPiR2y78eihjpfk6G1Zbjwjz0kLa5KO1Es7DbCBsNlNpWn+PDIJmIrBCF/gVWFyKh1DntlaG2ZN+UXDSE1QGGD2LZCCLZ+XLIwoZZtDZomxzvjogR41OorFkBnVO8hdjq77Xb9G1KA1+glnz29txDw8xulV82OtS9Dv0+h5UNiQU07J2R/49uO12o6QRYU2j8Nyx4T5ULrD3U/hyod4VypBY/AqlC1CxS5+bxqDFC1ExaVjqvZZtrufxJF/HbH/TarKC4KpZzHqKZwcjkUZpJbtQ9njY2obdAR8Gs/IdQl8NnzBT5nllLpnmWojAHQ7D7M1XuhOLkMCrOx1uzLgbxA7vnhNMUWK+/0jKRHcD4Bhz9AcTgDcjtDtS4w5AdRWe2LOCqNXCtn3SgxVgvaNc/zQPNPSbFG06pKObPi7iS8w6R3dJWHET9x3a7HpBfrQ7hwLYcgb+1fI34XtrgSKztM+fisfgzjuBWoNH+x16wC/1P4S8v077zzDl26dOHLL79k165dFBYWYrVa6dWrF48++ig9e/a8U/tZgQr8xyE5p5BF+6/y3ebzpOUVUzvChxf71KZhjH+5E+svpxe4ECsAo1ZFjofkQBA/+54LaUT4Sw+W24Q7INxPz9Am0fSoIxG0iVllV1dbVwticvuqGHUq6kf5cuSq68DdQTX06Da6mR1ix5m1omAdWyj/PrGY4AbD6VgjlI41biJY4Qbw0WsY2CiKtnHBZBWYMGiVfL7+LFkFJlRKBb3rhRMYFitN/kvchOr0ehcOznX/4m0e++uWQKtFrJKrnnXcZrNK8ZlxQYqxQyWWpKO/S8/OsBmijI6YLcNTnQdlVu4g5OpGA3J1vp6VBnAMMr0B2lQL4qdtF93eVzvCxzHDrDgftnziXgW0WWHH19Dvo/Lj3UEK09jWZe2MIBY5T/HpdwKl+xBNBbD1M+lv0fvBrMHQ50OZB+VOFQypIzHPftFy3ai0YiFzIlbXUZAhNre6Q0QZAplH1fdjuVYSD8ltRbnSW5RxUWLlLcXwXUdZLOj+hhRxuSlyXNo/JaR5rYfEth1fih20cjshA5mXhGwO/lZ6TlJOuD6+7RNiI63ZW1QdhVJUtYQDYveKbCIzvwoy4d41YsM6ONu1P+v4Uhj9m1gPsxMciibIe6jRE2Z9J0EEIAsgfT6Q1/GvJMmDuSmyvaim8j2Sckrsik3Hi9J0YbNc5xc2y9y5RmMk6GLdqzDhDxmJcHoVYIO47hKrPnOQ63vNT5NthtSS9MKLW12JFcgxXfYoTN4E698UG6jGIHOMur0m95uLJB7cntAIDqW00WhoPELuMxcJyQutLRbPnu9IcqI91TCgMvR4C9vxZZypPYWaygLUzsTKGccXi/q1+EGKOr/GhZAuPLbkImE+OXxbeZkLsbqOzEvozq3B7HcvR1KsPDr3GuF+7dGolFw4kMeYVmrGtq5MkxAr3ZN+RL3JyTp4eaf0vA36BurdJXbXq/skQOTKXvf7CJB4kCFDfDH7VcJ4GwtptwVFyULEuY2SEul8e5eXhXhbiiGiISsvWHh8+WZqhvnw9ZgmVAvxYBG2w2qFvGT5jtcaHXZl5/7d0kg9g6r0nLYK/L/HX/40dO/ene7du9+JfalABf5rkJFXzGtLj7HyiMNCcSIxhzHTd/PtPU3pWddzobv7QlmFwUunJtxXz7Vs91aTOpG+PDL3ALlFFmZMaE6jGH+PBAu4Tu7MVhtda4ey/oSoUE1iAxjVPIb7Z+5Dq1by8fCG7LuUwaIDV8krMtOuegj1ov1KBn16gFLputJtDJai/w4hM7+Y1NxiEjILCDBq6Fs/gn4NIskqMKHXKAny0uGlK4neDawq6lHaWRkG2vkFKaZCaskPonNfVqMxoiTdbK+QJ+Rcg01vu7/v2hFRx5xVtcs75Qe/xUSo2hke3itR0nmpQrx8o28cZAElReZoKTJLo0rHm3sNoF6kH1H+Bq7a5+I44cW+tR3qqymvbHHujORjQsDKI1eZ8SV2rudk1d85cc4QIDN0/spQZkOgkAF3PUYKpVjtnFGUKwS4Rg/pvQEJW+jyMjS8WyxnWi+oPRj2XZZeGE0p0nt4nuf9OfWHNLTbyVXycXmfScccj9n0jqTDbZwq+75ggnx+hn4Pf37gGMgLcvv4lQ6bU2nYbEJwNn8IaWcct3uHwT0LhQidWSPHuOX9kHpW7HcdnpFryVwoiYM2GyQdF6tVQBUJfej8ohSYzr1L3mEyj60wW3qgjIFCgja+LZbHXu/BH88KmW7/FCx9WJTiId/D0UUwaq6QnJxrEgiSfl4WIPJS4fwmISlDvoOgmlCjmyQjmgokiMIYKIpx1lWxJVdqKwX1qufEolpvqDwfZKGi1RSxCl7dJ3bgXd94Pm9HFwI2WcAY+r1YPuePu95PR7vHZV5YUbYof4V5UAAsmgzjFsvnujALTv8h57VaFzmPE/6Q261meS2dL8Udnyc1RU202YPiCmCzYtIGcGbAMmYdLeTXxUex2mB0/TAMp5d4ft6R38iNG8So7/dSaLISn+H4jH+w+hTfjmlCW+9E1Cvd9GTlJsvigFewLD4snCSEsTzrr1JNZoEVs8b0z5ErkIWOgV9D9hVZ6FAoRUU//BscmY81sinnO33Ba7+KM+NUUg6jv9/FoofaEGEfFl8aOUlyLe74Qo5FTEtZ7AirC+HlBJ8EVLkzbogK/E/hH/w0VKAC/ztIzilyIVbOeG3pMRpF+xPm577odG9PsDGxfRXeWlG2mI0OMOBn0BLso+NadjZjf9zNmic6uLUJZheaSMsp4kRiDgadirgQb6YOqkeVoAvM3nWZie2r8MyCwxRbrBRbrNw/ax9tqgXxSJfqhPjosNmsvLXxKu/XG4l215fu33z1nq6qTfNJd6xXLSm7kBcXHWHdCYclMTrAwE/jm1MjzMf1wXpfqNQGhs8SO5XW6OifiWwCkzdD9lUpbgIqCzkxlNNfc7Mozi3fgpd2VvpyUp2K3T3fSYHoHSL7Yh+6eivQeUnBq1DKbB+rWYrLWv2kqDXenC0nwt/A3MmteH3ZMTacTMZmgyh/A6/2r0PDaH/HAzVesnLtabB2aJ3yC6+sKzCjjyQC+kRI6hxA2nmxi0U09Dyb6npQhH/5A2W9goWo/NirbN9Vl1fknDtDpRXVY79TvLTVDDu/kqLZNwp8YyCoBnBZiIhGJSTO/l49haWAFPXOCw9ab7kGWz8sseQg/14yRdSl3d/LbbX6iX3QmVjZ981TgIMdpkIoKmVZyk2SGVYDvwK1FsIayHswBomt7uAcmQlVkCmLDXWHSPR6xgW5tqr3hNRTsnBi75czBopFb+XTrlH+PhFCkpOOyZyrPu+XzOKaLoQr8ZCcp/ZPSOS9c3BLUJzEtP82Vj5XlmK4uA2iGsOvo11V2nrDoMuLcGheyVDd5Y77TiwVApebDGfXyhBhQ4AMEM65JpbO8o5j9hUhVl1ekgAR5/laBRmi8vX5SCzHh+aCVzgENRJ1K36nbN+uTIIocMsfl+t7/jio1g3b4G9QeAVzLTWPp+bvYMEQfzzqKAoFlwr19PnFdbxGoQXp7/QEtYGTSQUeB9RvPpNKZ2M5/XInl8n5sKvoycflPdrnnZVCUc2BTNuTydqz8cy7vzVRnojL3wHvEPmLbCxkPzcJc7OJXKv/EFsSFLw796rLYONr2YWcTcl1T67y0mSRxbmX8NI2mN5NlOG4rhLq5DxzzI5Oz4NP2N/wBivw34w7Rq5MJhNff/01GzaIXaJ9+/Y8/PDDbpMEK1CB/3YcS/A8hiAxq5DsQhNB3loSswrZdjaVsym5NIkNoFGMP22qBaFWKjBbHT9W2YVm8orMPNG9BtO3nCe7UIqKFlUCebhzHAcuZ1z/bcsvtnA8IbsMucrIK+K3fVf4fvN5YgKMmKxWziXn8umIRjzerTr3tq3M2ZQ8l8HFNhtsO5vGtrNCFr67pynVIwKw1p8Ep5ZKkeSMGj2lSLFHIbd/WvpQ7gAKis18tu60C7ECuJJRwJjpu1g8pS0Rfm5+GA1+ZUmTUikzqm5lTlV+utiA9AEy48odrFY5aCqt6wwbZ3iHO6xAdhTn3ziE42bgEwY9p0Lbx2QVXestBELvc+PnOiE20MinIxqRnleMyWLFR68hzLfUd7XWKLa1E0vLFlYKpfQ9eFKtrFYpSO3XT04iLHpAinvfqJI476iyxConSaxZO76SYrt6L2h1v8yOcQ4HsSMvDQxBMPlPGThsj2Jv+5jMy7GHWeSmQmGG9MnFdYdd0+R2rxAZrms1i53OJ0KKtdwkuX9aS7CZhHx0fhECK0vi3N7p7t93g+Gg0kn/XG6y9CceWQD1Bouq0WCkHIO0M6I45ZVsp94QOT7ukHrK80BdlUauCXf9kQkHxH7qFQb7Z4gyp9ZJARnTHKotknl/y5+Q46JQSUy7X7SEAHgFS9HqFSKf+ZYPimJbekBtTqKQo9YPy/GPbSW3+0SIMtftDSFUv95dNhEz7Szs/hYal8RrqzSiKs4ZXvaaO7pAQiWqdJD5X+ENhFCbi2VAtEon12u312Xm3Z7vhVhFNBI7YmwrUcfsMAaJsuUbJUT/1ErZ59LH2SsYOj4nceD24jrjCgRNlkCkxnfDvhI1Wecr6vnZ9fJvSzHYbGTHdiW7yIC/ysS7q06SlF3EnhQ1UeGNUF47WObUWWv0YVuiUqK//U0orSYy8GXRaTMFTSZiSHDfI2hr+QBLT5T321SAwuDZfo7VUpJ0WELObDbIvAJ9P4Xlj7k+1j+WK42f4teZ8RSYLCw5cJX7SyeN/lPQ+4Lel8u2CLpM+9Pjw84k5dK+uhuFPyfBfUiLzSaLCeNXwLhlMG+0I/BDpZHrLa7bHXoTFfhfwi2Rq19++YWXXnqJn376ia5du16/3Wq10rt3bzZu3Iit5Atx+fLlzJ8/ny1btqDVVjT6VeB/C74GzzYAhQL0GhUH4zMZM32X0yriBUK8dcyd3Irp45pz7897sJQQrP2XMsksKKJvVS1rJ9Ygy6IloVDN3kuZPPrrAT66qyGnnNLdErKcihRzEeQkYriwk3G2JMaObsUFcxDr463U616T1ceuUS3Uh7hQbw6X6q8qjRAfHUqlgm4/HOObAb8SmbyJwHNLQGPE2nwSiqBqKA7Pg04vyMwh30hRF+4AUnOLWbDPfTx8UnYRl9Py3ZOrv4rcJIjfJrYhU4EkpTUaJYllpZF9FXZ/JwED7uxhhoCSwbOlYuJr9xfl4E5A63VzM61uAB+9ptzeQECUhWEzpC/F3tBtCBBLTnnqW2GmFOylkZ8mf/tmOKxeduQmw+KH4JxT8/zub+DwXJi4AYLjHLebTZB8FJY/KWqPUi0x30OnS4HsnBCYc036pDa9LfbBoDiIbCqqZ7OJ8Pu9roRBrYNBJeTJrxJQLIX9hT9luKlaJxa0o787nhNSCzr8S+LZ89OkEDMViF3ITsKbT4S9Pwmpimgo11CVTlLg+8W4XxUHUbeG/QhzRjji4O3o86F7m6gdBRlCvhqPk2PZeoooQ6ueF0IZWkfi3lU6yE+B4Jqi4OWlSG+gd7hYxDa8KeE/G6e63076eZkZFfWp9Ho52xiVarhrhoRgnN9Y9rmmQrEoxraR75K8FFFN3YXVbPtMBvp2f1PshYYAqDNAiPz2L4QwjV4g5PbcBlEcGoyEZY9D99ekh8tmleHFVTvK+Tj1h5y/do+7V6Qbj4Xtn7s/P0cXQusHoOfbcjxtViH55zfJEOS9M8hr+gB/atqiTcyheqg3B+IzGdMsjHNZNuJ7TSdm9USUiQ5CZ63ahbxu7zOiMBX94nuvB4fEaL2J6/Aiqqr9sFbpiPKCK4mw1eyDJaIJEQllU0DtyC40UxDXF83Oz90/oEZvCUKJaioku/3TULsfqPVYY1pSvH8O2twE0mK6c9mrHg/OT6SgZLbV7/uvMLxZzE0Nvf+7oNeo8NWrry9Olka1UC/3T7zkph/UjpRTUJiFNaIJxRPWocxLxWYqQOEbjs0Ygs54awtbFfj/gVsiV6tXryY3N5dOnTq53D5z5kw2bNhAVFQUb775Jt7e3nz66afs2LGDb7755pbi2N955x0WLlzIyZMnMRgMtGnThvfee4+aNWsCMj/r1VdfZc2aNVy+fJmQkBAGDRrEm2++iZ+fY/X68uXLPPjgg2zcuBFvb2/GjRvHO++8g1pd4YSswF9HrXAfdGolReay9osOJStjE3/ZW8aekZJbxFO/HeSHcc3Y8FRHtp5JJSm7kLENvfFP2ol664eQk0hweCN8WzzLshToVz+CbWdTXZSu+lH+8j+mQin65o1G7xSSUCOqJea2nzHkl7080KkaJ69lExfqTVyo54beIC8tBo2K538/QkpuEf1+uUijmIaMb9yBTpX06I/NRb/zK+k9qDNQiFV5s3JuEYUmi8dhxIDbHqE7gmVPwHmnxujkE6JM3LemLIFIOSm2qbt+kj6OS04N6cZAsdSse831OYYA6XdR/xcuMilVUhTft1bIlVIthat3ePlWUIWqfDufWle2ry/trCuxsqMwS6xaAz4TYgmQeQF+7CkLCyCF7ZYPhfg+sMVBrqxWOLEctAZHX9bh38SimHgYNk0tq8SYi2SVvvYnQjyUNgk5ODIfEvZC/F5Rkmr0kjAG7wioO1CUJ3vQgEojdlm/aFF+ru5z7fm58Cf80A2m7IE/npFthtaWa680chIBhQxTPbdB7Ge+EWIl9AoR+5k76Hzk2K1/XSyIjUbDyn+5vt/k4xLqMXym9EoVZAhJDK0jRX3aOVGr2z8t57Q8FOUJaS7dH2Y1S3/b8J/LkquOz4jdauYgUY4VCojrIY9dOKnssOCca2JT3PWNQ2Ha/rnsc7P7pLcxN1lIjkIlatvckbIP+3+BYT9JQEO1LtJT2GyCkN09P8istMHfSjjIxa2ObUY2lgRDTzizTsjImhclUCS0DoxZCBo9pkod+HBbDkvXJfFcnwACyWJxz2JCT36MsqCAtMShpPf5jqKCfJSF6Rj9Q/ELjsSnKAdm9Xcl08W5GNc9T453JBk9vkaRdITgU3NBoSS99mi04XV4YlE897Su5PG36b52VThZlEOjmgPQnlrqeqfOF9o+is1ixuYfi3LieumxK1GXC/2r8zl3c7Eon1Nbc7iQesnl6UqFAs/Ti/86sgtMFJgsGLUqj4tCoT46JrWvykdrT5e5L8RHR/XQEiJUkCkLYDmJYiWPairqZualMs9DocSmULE/PpP7Z54kLa8YpQIUikwmtiticoeqN5USXIH/X7iliW/79++nY8eOqEpZZmbNmoVCoWD27NmMHz+eYcOGsWbNGgIDA/n99989vJp7/Pnnn0yZMoWdO3eydu1aTCYTPXr0IC9PfN8JCQkkJCTw4YcfcvToUWbMmMGqVau47777rr+GxWKhb9++FBcXs337dn7++WdmzJjBK6+8ckv7UoEKeEKoj45vxjRFXcoCEeGn582BdUnKLiQz332C0KErWeQVWagU5MXoVpV4skM4wfu/QL3wXil2CjJQXdhI+G+9mdo0l9oRPvzolO5WN9KX2MASBScnUew2Ftdtqa/uotq5GfSuE8SXG87iq9dgtloJ9tYytIl7q9zDXeI4lZRDl9qOPpWcQjOt/dLx/7EN+u0fiQ/9z3fh65aycn+jwbe3AKNWhZfWcwFXNdjDquNfxcXNZW/LTYKd0xzFux1ZV0SJ+H2SrPKOnCM2vcHfSqRzcA1JDPMOlYjxJuNh0kb54f5vQ26yKBVfNoGvWsgMnI1vl9gib7BIZfCDFvd7vr/F/WUVzyMLPD/+xBJHKp2pELZ/WfbcgBSjB+eCpcSCmZcswSb2lemAytB0HHzfRfbRXcQ0OPqM1r4MCyeKStnsXghvKFbTNS/JZ7VKRxni++vdrgluFpPMwFIoRJVyF6bgFy3zts6tlyCGdk+635fwBoBNkvLid8rzCrOkl+fIfLEpukObRyRYI/287KvVUpZIgpzP7V9Ck3vEZrfhTVFow+rK/u/9UdSkgErlJ1p6h8h5cgdLsYSb2BMEAWJaSGG77jUHibLZZFjv6hckTKA0opqIStX1FRizREhhqweFVFfvDgXpssiRfVUSAk/94ejbOvWHqEoNRwgRnzdG7Ix7fxQrX80+QjDdXbfu+gKd77uyR5TIXu9AlfbSU7frW3I0wVzOUTC6VSzhqhx8Nr5E+NKRKE+vgHMbCFo9heClY8iwaOkwr5Az1kjZ//ObyqqUJfDZ9jbbzqbw5blQjtR7joN1nuW8VyP6/XSK9SeTmbbpHB8Pb0SIk4KkUyt5rGt1ziTlsPqCicxOb5Pb/3shFUHVJOF0+M+w/AkUP/eFP9+ThRSn923UqWkcG8Cqo9e4kFo2Zv7ulrEEed35BaSsAhPbz6Uy6Ze9DPxyGw/POcCByxku9nY71ColI1vEck/rSi72xKrBXsyd1JJIf4MQ9JVPw5dN4ed+8G17+P0+CaIJrFrmNanZh0yFH6N/2HV9ZqTVJmNYvt18ng0n3VhyK/D/Hrck4yQlJTFw4ECX26xWKzt27CA6OpoOHTpcv91oNNK3b1+WL19e+mXKxapVrlGpM2bMIDQ0lH379tGhQwfq1avnQtiqVavG1KlTGTNmDGazGbVazZo1azh+/Djr1q0jLCyMRo0a8eabb/Lss8/y2muvVdgUK/CXoVWraFMtiHVPdmTDqWQupeXTumoQDaP9iPA3cM7Njw+Av1HD72NrEJ5/itwtO8EQiLFSY5TOSV922GzoVz9NdLtZAKiVCvo2iODZXrUI8Snpdbm4xWM0t9fhXxjbbzTLjsIfRxNpFxeMv1HLUz1qUi3Em5+2XyQlp4gaYd5M7lCVo1ezeX3ZcX6d3IoF+65gsdp4uo0/YesnuO8v+uMZWQEOuDPEIdRXx+QOVflkXdljUSPM+4YDiG8ZVs8qGSCFa9vHXKPC7XOdTPlSeKu0QqSKcqTwnLxZCrUWk2X13Bh44zlP/4kwFwkh2P6F6+1n10pROnr+jedyVWojKWql1YqqnaBy27KPV5Wz+qvScH1ZvCjb8yBZkO21ngIqX+lzy00W2xeINW/jVLmerRbPw6btMBfJuQypJcV5QCV5X0q1KBQHZ4t9zdOQ5F3fwaCv3d9XvYeoaCCk59x6iX3fOFWsSGqd9Hq1fRQW3i8hCSuedFVLD8yUQJfQurD9M1mN968k7z8/TUjYXT+L0rV/luf3eWUXdHjK8e+dX0uUuFIp+6JQAEopwnd/V/b5tQeIUuQuLt6O4jzXAJTGY2HjW+4fm3JK+vn0/g5SrVCKRXHpI3BssaT6mXNlplTjsXKu+n8u5+PseujwtCwGOKPlA/DLAFdFLPW0qGQj58ix9Q6Tz639MfE7ZRvn1rvdVVv1bii2fOIYTRFYFfp/hjkvDd/Nr/JN1eqYavanKPUKquML3b7X2PglPNxxEMHeWjLzi/G7ssezCJR6mj41vOmV8S3GP5aCSktxw3v4uv8AxsyPJ6fQzMZTSbzStw46jRKbDSL89Xy18Ryrj0m/0M7zvjzXqzPNOkdgSNwtttnZw66HsSgPzpL+waodXTbdOMafNtUC2X4uHR+dGoUSsgvM1Ar3oXe9CBTlkdDbQKHJwqIDV3ltqSNt81p2IX+eTuGru5vQq154mR6vEB8dz/asyX3tqpCeV4xRoyLQW0uoj16ukR1flbUsZ1wQS3LPt4Vo2eEXDT3eYtWZHMJ89XSo6oPJqmDDmQxScmRx57P1Z+hYI4TQ0j2rFfh/jVsiV3l5edd7quw4ceIE+fn5DBgwoMzjo6KiyM4uv8fjRsjKEp9/YKDnfoWsrCx8fX2vW/527NhB/fr1CQtzJLj07NmTBx98kGPHjtG4ceMyr1FUVERRkWMl1L7fJpMJU8XE7f9K2M/b33X+lECUn5Z7WkSX2W6Mnw692uZSuykUsObe6vis/xeqS5uxazQWlQZLj6mgMsgMKWdkXaN5GKx+tC1atZIgLw0GrdrxnjITQenhS91iRauwoFPZyMgpoLC4GI1KiclkYue5JJ7sWg0fvYaEzHy+//MsF9Py0Klg97lkmsf6ciA+k2reRZgyE9xvwwYknwHvOzenaESzKIpNJmbuuERRiUWwVZVA3hhYD3+96o6eS5NZSKnJ0/FTGcBsBedtekdBeBNRAkCOQU5Jf1WPV0EfBFbAEOy0oX/g+6M4VwrrpONCREJqStCF5jZ/8DMTYPdP7s970klpctcFeH6+uRg0vjDga9mng7OFyDQeI/Y3fVDZ49JwDES3AJRS1GdcErtWTiLUHwMaP3mOTQk+UbKP7hBcG4oKoSBHXscQCpU6wO4fwScWUi/I+yrIAd9Yt2EQ9mvC1P4ZODwHNr7vuDOuOwz+UayHQXUh/ZLnz2BWyefT3f1KPVisjvuOLYf6o6HReCH0NqvEqKdegJQzYCqGBqMdvV4hNaHrq3Bwnticur0lx0XvCxvekuugyQRY/i8J94hs4nk/jYGg8XHcX2cYXD0gPU72L7F1U2HUr6D1kwCHomxZOKh3F8S2hNw0CKzp3loFEN1KPis5aXK96gIgL9PzPqVegIBqkkIYWEWUvcO/gzFUeq5WPudI6DP4S+hEQQbkZUCX10WtDKkPl3bLYyIaQeJRKMx3v83dM+T42oDhc+W6yLgkPXq1B8O1Y3Kccbo+Wk7BojByseFzRDWaiMVUjCEgDOWpP4RspZ0FnQ8arTfq+F0ev2sMxxcwdMhw+n+xheaVA/g4rj46T8cloAqqi1tQHZyJ/ROk2Pox1YNXsPW+7zClnkdjTSFXV8DRLAPPrb7GawPrselkIrqSH52zSVlEaXNRr34N0/Uh3BrXSPGd38t3ndN3SIBBxWdDa6LKT8Wceh6b1YwmJA6bMRhf4539fga4llHAx6uOo1OVXQR5c+lhGkR6E+4mlVengihfLVG+joV0k8kk6Z/7Zrk///lZ8p3V5Q1Jeo3rIsqeTyRN/M/xa4c0Qs5/j1Wh5ZGew9lfGMELqxNJyc6nqNiEyaRybIe/r+6owL8XN3teFbbSbKkcREdH06JFCxYudKy+TJ8+nUmTJvHhhx/y5JOutoYnn3yS2bNnk5SUdLObcIHVamXAgAFkZmaydetWt49JTU2ladOmjBkzhqlTpdl28uTJXLp0idWrHUMh8/Pz8fLyYuXKlfTu3bvM67z22mu8/vrrZW6fM2cORmM5ccMVqEAFKlCBClSgAhWoQAX+p5Gfn8/dd999XdTxhFtSrlq3bs2yZcs4efIktWrVwmaz8fPPP6NQKOjWrWwc5dGjR4mKuoUo5FKYMmUKR48e9UissrOz6du3L3Xq1OG111677e0APP/88y7kMDs7m5iYGHr06FHuAazAfy5MJhNr166le/fuaEoPAv0HkJZbzB9HE/lhywVS84rYMLkmofP6OWwupdHucTi3SdKa7IhsIl54gweVIDdJ5sG4mUWU2nc69/7pRV6xhVn3tSTCX1brrmQU8OLiI+y7lFHmOQBfjWpMhL+Bt1ee4L5GXrTfOdn9arRKIxHY7lL1nGCz2biaWcjiA1f483Qq/kY1E9pUoVakL4HGf59F9/r1UbAMzelSMbx+MZI65inK3a4UmQolBt0r7I7N+rplnN8kVj13uHeNxGrfKjIuw3cdPFpOGbtYgi6ckV0SyV168HC9YTI/yCsYjzi5UgayloYxAO5ZJhHomfHSM3NieUli3xBRwVY8Jfa3al3Ehrj25bKvM+ALUS5sNukbjGwkfVEaI+SnSo9P+nlp6m8wElNkU9ZeVND9zEto8kuULb8YCTtAIfaxri/L/xv94bfxYjVs84hYR3OTJNLfP1oUKJVO+lice7wM/jBmMfw+AdIvSECG1ltUmqqdwFIEOclymzFABvKmX5DPXbN7oTAHDpUM+G0+SexoO6dB1mV5X/WGSf/Pskcdg3ijmkqPk7N9r0Zv6PSsRJH/+b7YD9MvwoVNEmhSvYf0I6m0cg7Sz4kt8shvkoIZ103izNPOyX3BNcRWmHxCbH0NR0H9YdKH5Pw91Xyy2DbdxdrrfGDQN9LfWXcIBFeH+F0S9V57AKz10D/ddIIMF17/hhwHkGTG9k/D2Q1gLRYVVe9fYu9UQfweyL0mSmDvD0RximwKofXAlCNDipOPi/WgzmBofh+mwnzWnsig+5FHyWn/IsrK7fCfP7RsAEfVzmKt2/MjtH5IXssNTE3u5aWsAaw4LmmFTaN9+KAdhK6dArkl87lUGkzNH0TjGybhGe5QpZN8Z9mHWHuHYhvyPXMu+vLOWtd+u7f61aB32i/o9n/v/rV6viN9eM5IOg4/9nD/+Lt/k2N6B3HoSiajf9jl8f7fH2xDzdLzD8tD1lXZf3vyaWmMXuAYJQDyfbFvhvvvFCCp93TOejWhrVO8+7+77qjA34ubdePdUjXw+OOPs3DhQlq3bk3nzp05f/48hw8fpl27djRo4DrBOjc3l61btzJu3Lhb2cR1PPzwwyxfvpzNmzcTHR1d5v6cnBx69eqFj48PixYtcrmIw8PD2b17t8vj7epZeHi42+3pdDp0urKef41GU/EB+S/Hv+schgdoGNe2Gn0aRGOyWgm2pKDJdz94GJCZNzoDWEuGoer9YcDH4FtOb0tANNw9Gza+I8WOpRgCq5LS7g2mXwihSpiap3vUJDbEkRLo723l/o7VmfjLXkwWV+G6cYw/sSG+1Ajz4esxzSm22FCFfIxy5sCyhXbPN8EvAm5wbM+n5DJ42k6XgY6bzmQwumUsT/esScC/kWABaHq9jqbxMCkITfnY6g/HXL0X+YZw/Dy9N00AeJVji/unUJAJ2z50XDOlsfdbmc+kMbjGnt8IfuFQpx8c/tXNfTEQWMn1vFstcOw3SHIzi+nwLGg6Gvwj3G8rNwk2veH+PeQmymvqjTCjh+sg2D+nQlh9GP2rzBuKbi4JfO5eZ9W/JM5c6w15CTDzZSHIGiM0GQcjZwrJUmokkTDpFAAavRea5k9C5Y5gLpDwA1M+tJ4EXv5CAi5ug9HzoCBV+jk2vel6rPp9AmtfleCLJndLn1RcdylEk47CoC+F2GRdhbYPwp7psGCs9CfVHy62tGPrYMi3klB5ZY+ENyx6QN5rVBMIioWVTzi2W1QI+76DlMPQ6WlY/SIcnQeWAhj5c4nVrioEVBHCk3YKKrWCah2hWge4vAVUShj6nZCSlY9Lz1RoHUnm03pD7d7Su7J4suxP03vBv8TO2Oc9IYeGgJIZVyOg97uyCKDWCzFuMEjsoylHJT3RDkMADPwMgirBkGklpO0MRDWEyAbS9+fuHBsCIK6DhIs4G3Ku7oJF98F96+TcBURLsMnpVUKwOz8t/ZcaPZhzwJwHIVUg74osXPR6S64Jm00SPzdOFeth8ANoDF5oK7XCZ/+XqHPd2FTP/gENh0FhCmi1EF7b7RwtS8tJ9E3xomWNaObvjWf7pQwmFnnx411LiFDlYDMXUGwIIzHHRrWVIzx/3tVKuc9+f/Zl2PEpvTq8w96ECLIKzOw4l4bZaiM8KIDUkLupfGxW2bl8fjFQq4frZ9xcLN8nHrZt2/ohZ7XfsOpMPnWjfKkV7isBEn8BEf5eaNUactyEV0QHGAjxNd7ab3tAtETnry/rUiKwKoTEub7n3GTY/4PH9xx1+hcCB3V2uw8VteP/Jm72nN4SuWrbti3Tp0/nscceY/HixQA0bdqUWbPKNsr+/PPPFBYW0rNnz1vZBDabjUceeYRFixaxadMmqlQpO88lOzubnj17otPpWLp0aZlBxa1bt2bq1KkkJycTGiqF6dq1a/H19aVOndtYxa1ABW4TSqWCsBJPuCnbKMlf1w67faw1rjvKpCOg0WOt0hFFzT4obqAKAdJ02/cDitv/i+SMXAzevmQqAhgSbiUxq5APV5/klf71rnvTA4w6gry1fHtPM37adoGd59Pw1WsY2jSaDtWDCTDKl4efnfQYmsOD2yVR7Opeaepv+4T0cTg3qLtBbqGZGdsv8mqXEKr4q0nJs/D1vlwOxmcxe9dlxrSq9G8nV3iFQs1emGLakJVXyI/70lj4zRnCfC/zcJc4msYGEuj9HxqCYy6SKGlPyLwE2z6BhEOShhVS++YUNp2XxJXnJUv8tx0BlWV11znkA4T07Jvh+fX2TJd0OKWbbZtN0pviCfG7pSh2JlZ2JB0RchZWX+73NCuqMFMIwcHZrnOhTPkyUDg/FTo+L4Nnc5NAbQRlD2g1BfZPl/cW1QyajBUCteIp6TVq80hJrHeBzDxyHlILQoaWPiLHctEDEu3e7XWwmKVv6egC2Xb1XtDpefipr6uyvXEqxLSSII7U0xLpfu2oHH97LH3Te2WGV2kolPKeY1pCi0lwbJEMhD6xVCLJE/bLTCq7iqXWSyCEbxREtxTSue0zOf52JB+HBRNEpdgzHU6tgDaPCsn8bYwjPdQrGAZ9K4Eo3mGiPOl8JbDDapbI9Mwroqq1fQxaPSDKoTFI9mPTu5LqmHRCwk/WvizPazRazrU7NBgBu39wH1JSlC3vu/4wIZPOxfWxhdLr1+cD+K6jKJwZl2HhffJaO79yPLbNo/I+vKPBAraOz6PTG1GfWOx+n0CuidHzpVDv/5n01R6eB+ZCTLUGkt9gPC+vy2L54RMEeeuY0KYy3euE8c4fJ9mdpmdgo2ooAB0QrU8Xwu1p3ljt/pIq6YzTqwnt8Axfqj/DFBVLYffhnCr0JzrUm/dWxfPE0OWE7f8M3ZlloFRjbTAKZdtH5HfFGeZC92mTJVBkxXPowjU+WisLiKE+On6d3IqqTgt7t4owXz2fjWzEpJn7rs+EBEk//HREo7KDz28ElVpSJIuyZTHNnjga3QKGfCfBL06w2mwozR6GxQMKSxHGCv5UATe4ZR/L+PHjGTFiBEePHiUoKIiqVd1EVwJ9+/alXbt21K5d+5Zef8qUKcyZM4clS5bg4+PDtWvyQfXz88NgMJCdnU2PHj3Iz89n1qxZZGdnX5fpQkJCUKlU9OjRgzp16nDPPffw/vvvc+3aNV566SWmTJniVp2qQAX+CWh8QzB3n4p6Zv+ydwZWxRzWkOyorpxMTGfdqXSyL2UwtrUvVUK88StnaDGARaln+UU1SmUAH/5+iisZUuTUCPPmXz1rcjop26Xxt1qINxZrLoMbR/JolziKzFauZRVSPdTHkURoh1onlpk+H5Ss9hschd0NYCvI4NHoswTvmCrFoW8UzZs/zrYmrXhkaTwbTiRRO8AmFruCdCkGvULKt5D9TTiQZGLU93uv/4hfyy5k0i/7mNS+Co90qV7u4Og7iuK8EqJQKKEJ3hFQavzFdWi9xcKUedn9/RENxcpzZTdM7wEPbJXo5ZuBb6QM5c1NFpLgFSwDen3cqP82mygVnmAu8JzMp1JLQZ/tfoA0obVlrtaQ7yDhIByc4yAgXV+RVfdN70HHp8t/PxqDwy5VGkcXSGBCtc4S9V2QBUYkKjwvVQhs9lI4/YcMVW58DxRmyDysolxJ5DvqIUo+J1FIZVQzCKouas+59UIkek6FjIuOIt6dZTh+p5A4Q4Cck6odpfC1WcVmpvctS7DD6krow9m1kuppDBabV/o5ODRPLG5bP3V9jrkQFt8viZdNx8l+ORMrZ6x+QQjbtUNiO130gOv9eanw60gYOVf2sen4EhumHhKPSJpfnYHyfte/LlZH7zA5lvZjkHNNUgzN+WItPDBTzt+EVfKdVDqKP7i653MAYldNO+t++PeV3UKCqnSEBnfB2pfcX687v4JR88CqgJN5WMMbklkMxtIz25yhUMDmD0Up8wmH3h9Cl5cwBdelwGTGemIZr4VreKpJO2YfK+L91ad4oGNV+tYPp3GMv8tL6dQqsbRGNi6rgNUqIealA1psVpRZV+D4EjSAZteXNO3/OVm+HXi8e01sNhsJ7d4mrPPLqFVKtL4h7mfUaYxC1C+7H7hrCW9IncqRvNAngJk7LxKfXsAjcw/wy70tbnsOlFqlpHVcMKsea8+c3Zc5nZRDoxh/hjWNISrgNsN6vEOg47NyTRZkyvvyCpLPYynkKHxQ1xiI165P3b5UVs0R6BR6KnICK1Aat9UkYDAYaN68ebmPqVy58u28NNOmTQMoM6j4p59+Yvz48ezfv59du8SDGxcX5/KYCxcuULlyZVQqFcuXL+fBBx+kdevWeHl5MW7cON54w83cjApU4B+EIrIR5lELUK9+RlYBlSosNftj6/Y6CZYAhn29hdRcx0rZwgNX+VfPmoxtXcnj4ESAjHwTQT5aJvy0h+gAI68PqEuEnx6z1UaRyUqkn4GCYguGkjlSBq2aEB8dp5Ny+H7LBUJ9dIxsEXv9frfQ6G8tfc5ixnhuOT7OQ06zrxKw/l90bjKZB1rdxaDqahnie3yho5iJaCR9ZqUH+P6NSMkp4rnfj7isjtrx/ZYLjGoR+8+Qq+wEWPe6FIlWsxTUHf4lq/LuCKfOCzr+C04uvR6jfB1aL1FVdpZEgZvyYde30OPN8gf8OsMYKH+htW7wuACoNQD2/uD+/kajPc9I8g6TYbLLHit7n8YgBHHuSFltrtxOIri3fS7XR26y9NeAFNuGgLIWJ5CitjDTcw+ZzSaK1cLJ8jilHhreJb09/T+D3+4R0msxCVE8skCKZZ2PDNk155eZNeeC3GTo/rr0RzoTqEs7RAlUKMrG3jvj+CJACc3Gi4oT21YUnxPLRaFSqh3vzRgo6tiCCa69JWfWyAynu2bA8ifcbKTkOOz/GeoNL1elIO2sEN6GoyTR0R0sJonMj7LXClaYPVwUzGHTpbD1iRDyaTHJDDlnhNSS2PeUk6K0HZgpt298WwjOggmOc61QgCFQSHpeqvv9qdatfHX10BzZjkIJdYfCkXlliYrVIurcvtngezdKcwHT9hbzar3hqPe56R0D+QwufVT+P+eaKHxjFqLa9wO+u6Zdf1gg8HCb54nr2xeTxshdTWPw1iqk/+3USiGAUU1liHuHf8m+nVkjvXCNx0DqKVjzstjbmt8n1j6FUuymzsqwzYZi+RP4jf6dc/l5GIJiqBMZwg2hUksP1q5vhIg7Q6EkqdEj3DX9EDGBRl7sU4fZuy6x5Uwq6XnFf2nIrkGjonqYDy/1qU2RxYpOrSoTv37L0Bjk++MGzm6TTUVmzVF4HZsr3w9OsAbXJimwKbHcdCZcBf4f4d/Uge0ZNwov7NSp0w0fA1CpUiVWrlx5p3arAhW4I1AZfKFmd0zhK2U2klKDwiuYfPS8+dtBF2JlxwerT9G9dhg+4Z6Le6vNxqydl6kX5ccjXarz9soT1wc9+hs1PNerFhF++uvk6XJ6HiO+3UliluNHctauy7zYtzYjm8eUS+RuGjmJqEpbVErgdeAH7hs/gcADn8CxUoPGEw/CnOEwbpkU3v8AsgtMnPcwmwyksfqv2FtuCnkpMP9eiHdaGS7IEJXAZpMZPe4sfYFV4Z7FQk7sBXF4fZm3tWFqydBfDdTqJ83aOYlSGN9uTLs7qPXQ5mEhyaWb+iMaSjCLJygUsuqefBJ2f+uwqRmDYOBXsPp5hyXw7Hq4sAXGr5T9z7wiRfmplbKS3+9T+P1eV6Kp0kCPqeWTHxAVsDjX9bacRCm6m08S1ULrLSrQ6VXQ8n4pdI8tgsJs98+3I7SOEMLSylSfD+T8tn+q/AG9Kp0ou79PghGz4PwGsUTWGyzBGbX6wfHF8tjGY2H75+6b9nd/K4V49pWy99mRfgG0+vLVaVWJTdYeZOEJKSeF6F3eAadXi6Uu6bhExQ/6VuLTl7sh1aG1hcza34OzMnRxM7R/UiyWGqMce2OgqKutprgPRlEohJgcnV/2PjuK80XdWve69KL1fEds0DunuT7OXAAJ+8D3bijK5em2lUksmEzMmT/KKoi1B4gCWGogsG3TuyirdSqzC77b36H3PZ0ZujSdH7ddZF4/DSwY6rC7Hlskn7Wh0+HkcllwsVrEFXBxu4SLNBwFm95xhIdU7SxhSYFVHd8PVjOKlBPU88nlcFE4qblFBN8MAfKvDONXwKL7HYTNL4aULh/yzq5i8ootnLyWwyNz9/P92Gbsu5RBkfkG8wSdkF1o4lpmIcsOJ5CRV0zPeuHUCPMhzFePSqXEqCpHIfwbEOilZd0JI6YBiwg/Mwfv04tBqSGrzt1cju5Hhi2QGpr/uDK6Av8BqLgqKlCBfwM0fhGA+LsTMgvIKSxg48lkfPVqRjcOol6wksR8GzP2Z3Elo4DNZ1KI8tdjstrwd9OjZLPB8YRspg6ux0Oz95Nf7CguM/NNPLfwCJWDvWjlrSO/yMyMbRfQqpUoFTJt3o6pK07QpVbonSFXBRmeU5lsVvwLr6A8sdT9/SmnpFD5h8iV0s1vtp9Bw7imgTQKVVM92FL2AXca2YmuxMoZm9+HugNlNbo0NAao0gEm/CEFeE6S9PWtfEYKTt8oGPC5DF5d/oSQl3pDpeC6k+pgQGWYtBF2TIMTi0FtkFS7+sPK9DKUgblYLHj3LJJrRmMUe+jSh+HaEdfH6nxkFVmlkUCI+neJPfDYYgl7GL9ShvOmnhIbXu1+ot5Vbu/eTgWScKfzEZVq9QtQXGI56/+ZNLhbTGL9U6iEyDUYIUqJPaXRXAjNJrhXn8Lri6J2do3r7f6VRG1L2A/Y5Jx4UoGq95BjUZQj5zjrKlzeKf07fjGi5qWekoS+qKaw7VPPxzonUXo/nZMLnRHRAPb9Ao1GyjF2R0rrDRPVxCdcjl28h0S34BoyoLZSO7kOIxuLyqb1kteu2kkI8ca3RHFSqiQ1sel4URFBHu/8PWAMknS/rZ/I0Nc1L0jPTPP75Di3fliIsH0RVq2TXjJzoRxH5x5CZ8R1heNLxWKbeVlCNrq8LMT/5Ap5jMYg12ZRDgCK4wvxbTSCJ/7U8+3YlahOr0B5YokQ7YZ3Sz+dm2Q/xbVDsr+lofXGmH2OmYMa4EMBRlMG1BkgVkb7+zEXwsqnsA2djmLR/YBCrL693xNr7Yw+rosL5zfK52TA50IcG4+Rc2EMQnf+T/4siCS1cgSdaoZg0N6gJFSpIboZjF+JrSCdrPwi9qco+GBTFicSHYqxyWJj7u54hjaJwv8mm5KyC038tieet1Y40kZn7bpM3Uhfpo9rRrjfPz+MXalU0LFmCBN/vkgl/wH0aTEUsxV+O1GI9kouHwxz3xZTgQpUkKsKVODfiITMAkZ9v5Ov7m7CgDoBPNtCTfCeD9CcPQi+UQzo+ijrciqRUmRmxo6LrDuezJAmUXSrHUaEUxKTXqOkU80Q9lzMcCFWzvhwzSmmjW5CVoGJMF8Do5rHUjPch/Unkpi1y9Gzs+FkMrEBBjTqciyCNwNVWRLocrfOS1anPSHrKoUhDaSZW/MX9+UG8DdoaRzrz4HLmQAMrOvPc81VhOx+B/WxfVJEtn9aejK8b8JCcztIPe35vsIs6UcpDz7h8pef4RpV3fcjsSU59zTt+0lWvidtuGGU/k1DoRCC1eNNaP84oBSC5I65OsNiERtkWB0hUvG7pDitP0xS9XISJQpcY5Bhum2mwKrnXY+XV7DEmmdeEvtYUE1sze6Fq/tQzBkhlrnEQzD4OwmjyLjgeK5vlCgByx4VhWDId7C2JPFv49uQXTKGQKWBDs9K3LcpXwpwe+F9cgX0/RhaPSjWM1OBHI+qXeS27MSyPTyVWgtBAVHfavWTwr+0Ha/+XfJeSwp6inKE2F3dV/LceJg7Crq/IaqG1w2uz9Qz0Ok56fsqvU86H7FezhkBje4Wwr7hLbiw2aEohtSSYI/08xI80e0V9+RKrRPytGAi3Ldaer8yLgqxGjJd1JzlT8jrjS0hNVaz9D79Ns6h1tQdLNeD3frY9nHwjYYeb0u/1ojZQgCLcuRaaThSztH5jXLOwupKnPl3HYQgB1Urq7YZAkRlmjPc9fbNH0jK5OlVsoDR+hFRT9s+DrnIQOfgqnzVozfqZQ+jMAZBozHSm3RyJWxwk0oH0jOXX8q+qPeDodNR7ZpG2NkH5Ta75W/Al0Ku7ecr5xqFSiN7OvyKDbAYgmiu0OOz9eOy9mDfSAkn8QqFId/Dobmw/k0IiIU2j9JRa2TE7P2sfqID1UPLxprnF5tJzSnmbHIOKCAuxJtgnyAUumCmLN3DtrNpbt/iofhMPhregJCbtAQmZha6ECs7jiVk88uOSzzRvQaaf1i5AojwMzB9XAt2XUhjzp54NCol97WvRoNov7L9yRWoQAkqyFUFKvBvgtVqY8nBBC6l5aNUwGuNc/H/dYSjiMm5RujVcQxo+QTpDR9kwq8nOJecx4H4TH7cdpHZE1tej7r1M2q5u2Usn60743F7basFMW9PPB+tPe1SU01oW5nHu1Xn05LnpmQX8fv+q3SrHUawzy145W02KSjtMAZBWD1ZNS0NYyAKnzAox69eYIzgkTn7sdrgntaVqBvpS+jf9GMW4KXl3SENGDZtO2F+el5qmE/IvOGOc1GQAb/fB83uE5XE4H/nd6I8lU6pksL5ZhBaW0jA5vfEBnh1n/uwiLwUCYdo/y/PgRm3A7VWemlKw2ICa8lsKWfkJ4t1cOmjrvPUDs2VIIe7fnHY3Kp3LxtmoNIKadr1DRx0JNcq1r2MbdA3mAZ9j2b7J3IMDs2Du+dJ70vycQisBt6hYj20E4Qza6Hrq3CqwNFnodbD0B/gxDIp0i0mKfibTRBSteJJ+as7RPbFN1JULpVG1KTg6qKcXdzi2G+rxWEFPL9RttX1VSEdxxYLCandX4jXhpK+MpVG9iXlpASZKFXQYrLsCzhIX2wbuLzd/fkJjhP1bcRsITz2XqewenJtH1kAkzfJLK9L2ySIo+srkHhYrJhWC/w6SqLvh8+Q89LnQyE6dgLoGwm93oUtH0vwR1EO9H4fNrwp9lZzASycVEIas+BSE7Gt/fmeQ1lUKIRU1+4v56vrK6Dxkh633CQhI8Nni/K3/HFH/5XWCzq/JArevLuhz0dCTABWPgUDvxbV7tgiOY+1+0s0/B/Plu3JMxfKSIxxK4Rg7f9ZzmNYQziYCK0eQqHWYYj/U8JQNrwJJ5bIebpvPWx6qyzZAWwtH0ThnFoJQng3vl2iZJbAUizx/wqlXFtHHRbqjOw8xs632w0v89uoSrS4XIrk1ugp4StbPxGroD0Gf+QsUQaXPkKt9i8zsF475u2J54XetVE69TNlFxTz+/6rTF1xAnOJxUGjUvBKvzoMahxVbtR6iI+OqsHeN70wtvyw59TTWTsvMbZ1pX+LegUQ7qdnYKMoutcOQ6FQlN+bXIEKUEGuKlCBvw1FZgvpecXYbOBrUOOtc7VHpOcXs2CfFDa+5jT81z3tOtyzBN67P0PbdAznUxwqz4XUPJYcTGByh6rXm3srBRqpGuK+TyLAqKFWuC8Pzt5f5r6ftl3ko+ENCfHRkZJTRJNKATz520EupeXxWLca6Mv7cTQVSHF2ZL5Y+ap2EnuNX4woPEOnw4zern04aj2MmCMFeKN7YN+PZV83tDabEtSsOyHHZ8PJZDrVCOH9uxr8bQSreqg3Kx5rjykzkZDlw9yeC/ZOl9jov4NcBVYRBcZdQ37tgTdWJOwwBoq60+AuUUw8rZ6D9Ok0n/j3pjMWZEh/xu7vIC9N1J7qPcDfbnFUwKFf3Q+q3v6FzIM6t0EKzcs7RJ0bNE3mGVmKRY0oznMhVnYoFj8AA77C1us9FKmnpJhf+zLEthbbV9r5sts9uQKqlRoh0u4JKXKdLWXFubJ/Le8XS9/R3yXW+9hCmLRJ7GoZl6DfRzILq8PTQhwM/kJkTAWilhxfIoSu+SQhCXUGilpxehWsetb1s9PyQTlnp1fJgOiUphJiYO9Jq9FL5pp1e01i9K0WUSntEfHNJsh1FNFYiEPnF4WMKJSijOr9pHduRj/XYJBtnwjJ9asE0zsLKTmzRixrV/YLCfaJkKHACqX0lm16VwisT7gc42WPS1BN5hUhhXblMe2cjHdY/ID0THV8VsizxgAXt4olzjcSmoyXY7byabF/+kULsS3dY1ecJ2R5zCKZEaZQOEhfXqqEo1TvLu9dqYLQukKa3SnHcd1EDVs4yfF9cHwJ+ERB3DsS2V+lI3zTDnq8JZa5K3vl+Oz5QQIyFj3gUOEUCsxNJ2Gq1BmDs11QpREFOaHU97NCAbX6C6HzjZJr4/gSOLWKLFUA4OjlupxZTAvvUEdfn3eoKFa/3eM4PuZCWVC5shd6vQOLHsBnx/tMHtqT93fmYbJa0Skd3/dnknJ5fdlxl10yWWy8vOQYDaL9GNe6MvP3uu/fe6hTNRd3xY2Qnuc58jy3yIybrKF/HEZdRclcgZtDxZVSgQr8DbiSkc83m86xYP8VTBYbXWuF8kyvWlQJ9nJJOrL/rx957otLAJsVS+IRWlQOZ9cFR6H12954hjWNum5N8NZruKtpDD9suXB9ldGOXvXC+X2/5yb2hfuv0K9BBOdT8riYlkd+sYUft13k7paViAn0MMvKXAzn/5TVYfuP9/HFYrGZsEoS5kJrSbTz5R2iDITWkfQsvxjx73d6VgqPI049BVFNOd/pC1761XUlc9PpFA5dzqR7XTdR4HcASqWC2EAjNou5/KS0K/ukl+ROwzdKCsKZgyDfyWoT2USsdrpbCNTQ+8mfT4RD1XCHm4zUvynkpUNhuqTAab1KLIEa6cHa/J7jcefWy35N+EMIpcUkKoInXNgsCXMXt8q/c64JGRs0Dc6sk4L53HqPT9ds/UhsYutfEyWk1UMy8+jcRvdPUKqEmFBikVIopFdo0zvuH7/vZ0m/0/nKta3WCfHq8hrkp4BvDATVlAJ68kaJkz+/SZTdyEZCsE4sFVtiv08l/rwgXZSh+F1CrvxihMRV6SjKmcZLimhnq1jNPtJf9ssABzHS+UCXV+R5AVXkvCx+SKyK7tIZfSNlH0onLlotQjAmb5LP8/rXZd90vhIw0epBUcHcKaRtn5CUyqJsmbdmKYLiHMf9Wm9JPez2GiyZ4mpVtPcLrn8dqveEuSMc3zWxrWD/L26VIQC2fwbNJrqGYYCQpNOr5Q8kIKRqB9jxednXanE/zBtddqElr+TzaS0ShVKhkPlnnZ4X4gJw4Bextg75Tt67qQBTTFuWnLPy+8JEPh62jLCtr6C8shMMQdjy0nDJwFMoYcAXYpVd8pCQRrUeGo7CfM8Svt/iaqn+8WAe3Vs8jN/qkmTCxmOF/Ls7PqmnZdaabyRkJ+BryaRF5QiJere/xSIzX//pOaxk2p/nmDqoPm8MrMtrS4+5kJ+xrSvRokqgx+e6Q8+64cx2sqc7o21cMN63Q2yK8xzXst7/1r5DK1CBv4A7Tq6ys7PZtWsXer2edu3aoVAobvykClTgPwUWs/QwnFwuRVBMc1kN9ouRousmkJBZwMjvdl6fNQWw5ngS286msvzRdlQJli/4IC8tI1vE8uby4zfsSzErtWhUrp8lSc10vS06wMBPE5ozZfZ+sgvF4qJWKuhWO4zP1nu2DKbkFDGpfVXqR/nx7O8y5LjIbCW7oLx46WuwYHzZH++CDFj8IIz5XVQU/xj5azC87Gv4hEtiWsdnoCATi8bI6osWXph7lcz8stueseMibeKC8fobVxAV7gbdOqO0re2ObVgh4Qf3b5bV/OwE6Ufxi5JV6NuBzlvIhF25KI16d0k4wl9RrvJShABseq9spP6Q72D/T2Wfk5MoSYYDPpP3bfG8ao25qGz/3rGFUri2elAUAk/Dg9U66dmp3FaCLmxWSDoGNfsKoSudbAgQXFPsgldKYrh1fvK4FpOgcgfAJn1L+34S1dZcCMYQIcQLJoi1LLSOhC1kXhK1q94wUXJ/vVuea8fOaTBxPbSeAlcPSCpgVBMhjIZAGDlH3n9uiig5SpXMSbp2SLZvP9ahdaUPaEZv189jUQ788S8Yu0yuhZ/7Q5eXxGbpDtkJQpD8YuR70BmmfLku174iik6PN2HxFAmrsJpksPD+X6SnySu4ZJ+NUJDmsFwmHoRqXaW/bvTvMl8oqyTxMbgmTP5T+u/URiGXOh8ZwtxsvKhRzu/NN1KSBz0h7Zwcs4J0UblKR72D7KcpX8hSYDVX9co7XEhgeddmWH2ZQ9b9TVjzUllFuyhbQk/0fhT1/oQThUH8a/kebDYY8LuOB1u+Q8tWKhRKFTHabDudFzQeI6El9gh6kGtt309QmEusn+tsseOJ2Zz0bkmLhqNQHJor3yVbP/K87/E7pR8tOwFUWvo2cB0MXmiycNXpN6zM09MLUCoUDG0STccaIey/nEGhyUrzyoGE+OhQKxXkFJpuOhypZrgPdSN9OZbgmqyoUSl4vnftWx+FkXauxKZZEppUs6/YboOqudrXK1CBvwG3XaF8//33zJo1i8WLFxMQIMMCDh06RO/evUlKEp9669atWbNmDUbj31SMVKACdxJWq0Tv/jLQMcfj6AKZozNuuRQ9N4FtZ1NdiJUdecUWvv3zPK8NqIteo0KhUNCnfji/7r7M1SIDtcLrl01GA1BpsQXX5GC86yrisKbRBHq5Fp1KpYK4EC9+f7AN6XnFmCxWYgONBHpraX0hiMNX3Kf3Na0UwM7zaXzzp6tiU663PPWs2HTcIWG/FJvGm1i91PvKH5CRW8TH23a6JVYAxWYr1psYxfCXYAgU25i7YZkqDUQ2/Pu2rVBIIegXfedeM7Ix1BnkiOq2o1oXmZO1aJJc37dD4PJS4dgSKZrdRerPGw2dXhC7W2kcXwTdXxP1I647nFntfhuV25VVtqwWWZXOuCh9Qc0mOMIh7FDrRVE6NA9+6CZqWYvJcjx0vlLcZ16CJQ87ItSVaiFRKSeRyUPINRxeT/Z3/jghaJFNJJ1t9w/SL1WU7SjilGopWGcPlXECxiA59sU5rsQqoqH0ER2dL/1MnV8QIlHanlazt9jCVr8AldpCv48huqkoSQoF9HpPkgcPlKPi7PhCgh4GfS3HYdVz7h8HQj4Dq5QlVyDHSaWBPd8Jce36iiikGZfE1mbwl6RCcxHU6C3H0mZx2OWqdZXequ1fQqNREiDhPEuq3l3Q4SlJ7dv+mRy7Li/Kf1NLLQ5lXREF+dI29+8jpKYskJ1cKv1fCye5fl+ptNIHtu1zSSfs/6WkXF47LMEsrR+RfsWgOPmsgJxr5/2w2YTAhtSCwDjX1w+tAwWZ2AZNwxZaB1ORmRpe+XSKC2DjmQxScor4bncGhm7V8dVr8PU24hNQWa5pkPM+7x63b019fAEPTXqCrlUrM++kmVXHk4kJMJKt8kfR823MrR+F4jzUOj/3g6lBHAbp58EvGt+gSIwBrhY+b72axjH+nLyW4/bpTWL98dKp0KpVeOnUVAoSFTw5u5Cd59P4ZcdFTBYbQ5tE0aF6yA0tgmG+eqaPa8bP2y8xa+cl8orNtI0L5vnetYkLvUWFPeMSTO/munhyYqmo4Pf/+Y/OUKzA/0/cNrmaOXMmxcXF14kVwFNPPUVycjITJkwgKSmJlStXMm3aNJ566qk7srMVqIBHFGZJoVeQKaudXsGgKZt8VB5MWQlofrun7IDE4jyYPx7T+FVo/CPdP9m+GyYLKw4nerx/w8lknuju6GOK8DPwy30tOJ6YTaU+X2CY1a/MrJycnp+yN01LbpGj2To20MiQJtEuFsOcQhPrTyTz8uKj5BSZ0agUhPnoeW9YA8J89YxqEcvMnZfKpAnq1Ep614vgvp/3uNzePi6IoFLkzfW43CC97kZzhdwgwKhlUKNIPlzjPjnvrmZ3aAZXeTAGSAT3jz3L2qMGfPWPxcPfMXiHQptHpT/mzBohB3HdZUV/+ZOyMl+QcXvkKv0c+ITB6nnu7089I+RErS/7ubKa5RrJS5GhqBe3lFWgKreT+wsypJhvNFrS89QGMOWJpSyyiZyT4BquxKT1w7D3JwkviGzsCAywz14LrCor2aN/h5/7SAhE64clGCPxGNT6UAIBGo2E2cPEjmhHwn6YP16G2dYdIvbH7m9K5LzWWwiDX7QU34sfkN7DxQ85nu8bKT0/v08UQhTdQtLlAipJEEP6ObEHApz6Q973gzvBUgiFOXLcGo2R772re6UgL00+nJF2VoIu1r0m+2wMdK/agahWl9yEYSgUQiLUOhl8fGKZqGKGACEpv9/nmK0E0gN3aoX0HXV+WRTGgErwSz9JrVvykGt/od5fCNeMPq77dmyR9JeVxpm1Ek5ycJb775o2j4qynp8us9EmriuJ6D8t575aF7HNJR2V8/Zzbxi3EmJaCZnOuCSkbugPUpSfXSeBNsZAWPmCbKMgXQJktn8lqYn2kAqNEXP/z7FofNAtnoTi2mG8AfR+fNbuJeZENeHHfZm8P6wBLy85yqW0fCL99MwbNpOYP8YJ6TEXlzv0Wpt+ivqb3qHegC95o6Ea2+WtUHSJorxWHMkPQqUMoVbj+zDs8KBeVW4P+37GMmYRPqExZe7WqVXc177KdWu7M7QqJePbVEFbKlE2JaeQf80/zJ9nUq7ftvtCOtVCvJh5X8tyAzAAwv0MPNmjBmPbVMJmA2+d+tYVK4tFbMPuru/CTNg/U74LypsrV4EK/EXcNrk6ffo0AwcOvP7vtLQ0Nm7cyKRJk/jmm28AaNWqFbNnz64gVxX4e5GdKNHMJxY7bDKV20O/L2/6JTLzilGkJ+LnvIrq8oBLFGQmUaALKffLXq1U4FfOXA8fvQZVKUtChJ+BCD8Dqdk+qCZtwXx4PsarOyjyq0xBg/EUeEdz4VQOjWL8MVmsDGoURd8GEWV+qM4k5fL4vIPX/22y2LiSWcC4H3ez+vEOVAoysuCBNryw6AgH4zMBqBfly5sD6zFt41mXH9DaET68M7QBfm5mal1HaB3P9/lE3Fbog0qpYHDjaObsukxClmsxXi3Em/Zxf2PwgjOCa4g97/RqKaoCqkDTseAXK1aj/zZkXZEI8kptAIUoF859Xbdrk9k/C6p3K986lZ0gBXhOqUWHKh1lv2YOkplb964SReP8BlFDmk+GkBoShz1wmhCk4hxRcK6ULARovSVsIjtRbGrnNopl0FwkxfOWD+W9dXlJ4r2dFwTSz0sYwthl8MgBicbOThAVzGyBC8g2cxJciZUdFpOEXMS2EvtVqylCPIqyhTwVZEghZ7OJmuVMLts+Los2A76QBaHIxpKgdzBXBvzW6AV9P5HeL1OBDC4+PBd2fy8EVK2TFLhGd8P3XaRvK7i653lTQdUctridX0swxsapZR+n1stxczf8u8l4OYddXoLfxjpCIoKrSz+cM7GyoyBDzodCLSrlgnvFZmk1lw1uaTxa+pbcFcVn1ohq56xSWc3y+Rw5V3q17MmOen8he8V5EgRjT1zMz5TQHb2fOAR2TpOFhp5Txc6o9xeSVZwD33d2HWDcdIKck1XPlaiW78JFoChPyG/mJRmwW1wgvXHVe6JU61HP7Ov6Pouy8d33FcM7v0dYaD3eWH6cS2myoJCQVcjwBSn8OGQutVRXUZSo+R6h9YZe76BY9giKlFPXb1apdVQaMItXD/jwWvexaOO3oLqy2/W5Pd8BFPDAVlTlqOSxgUbmTGrFv+Yf4mLJflYN9uKDuxoSE1T2e/Do1WwXYmXHuZSyAUyeoFEpifgrqYBFWXD6D8/3n/5D7MR/Z4hPBf7f47bJVWZmJiEhjvSqLVskYnbIkCHXb2vXrh0//ugmCawCFbhTKMqR9K/jpWxDF7fIymjw/Tf1MgnZhfgXFOBXzmOycvPJ0xWUT65USsa2rsySg+5jZe9tV7lMvHliVgF/nk5h/t4rqJUKHu58L3ENJnE528R3f15iw6ld1Aj1oWvtULRqJQMaRRDm6/rjk1No8thTZbbamLP7Ms/3rkWor5bPRzai0GxFrVTgb9QQ6KXj9UH1mNihgKuZBVQN9iLCX3/jVD7vELFZ7f6u7H19PnQfx30TiAowMP+B1szbE8/CA1dRKRWMbB7LwEaRt5Q+9ZegUIjNqcUkSdxSaf67ffoRDaTotw9DdUZ4A7FC3ipsNiEMCqVYrDwRrMCqZRVAjUECDHKTYPR8OLoQfh4ItftKAENYXbHuWYolqMEvClJPSl+Lc+9Mca70VfT9CC7tkIK40/My08eOKh2l58yd0mq1yMDZHlPhp96OiHdjONR8H5RaUUg84fJ2mfkUWltUKPv7VChF5ag3GC5skjh2uzXOP1YI2W/jZN5WtS7Ss7TiScfi0OnVsPVTUU3i90qc+T6n3jVzkRAae+Li6VXSn3VorntrYJNxYn8ESUlsMVn6wI4ucDxG5wtDvpVjOGahDK5OPCwKXMsHJJL92EKxzRU5WcViWpUbKMLZdaIi5aXJrLGAyq5WQOfX2fm1+9fY95OoVLPvchxjpVoIz8Z3oNursv82m5Cug3Nk7lf1nqLqxe+U8zxshtjDCjOFnNbqI7H3J1dAx+fkev51lKsSZrNKSmjPtyXlMWG/kCq0ENscfnpR+nkS90OPNyQl8ewzKJtPdCVWje8R9TjlFIF5F+hftQqHY/WcTXZcl4lZhWy6kEftK28LYY5qIkOYSyOkpvTp7pshhNEZ5iJClo1lyuC1dPrmJH9M/A5jziUMlzZiMQTiXa8PKt+Imwp30KpVNK8cyG/3tyazwIQC8Ddq3M53KjJZmLnTQygTMG/PZYY1jSbkVsZ73A5UGiHQnqD3r1CtKvC347bJVVBQEImJjpXI9evXo1KpaNu27fXbbDYbJtOtW4MqUIGbRl6Ky+wPF1zdBze5OLX66DV6RwcQ6alI1HqRgS/L9l/lxb7lryhWDfZiUvsqfL/lgsvt7eOC6V7b1VKWmFXA2Om7OeP0A7vrwm6aVgpgVIsY1p+UVcBTSTmcSsrhsa5xBLhRkwqKLZxJcu+NBwjz0bHpdApTV5zgQmoeRq2KMa0qcW/bKoBDPbsl6P0kiCKqqagL2VelUO/2ujRT/wUyEhVg5NGu1RnTuhIKFAR6aW+44vm3QV3+MOT/CniHQs93xcblDI1R1JPbWcVVKEQ5OfwrNBjh2nhvR3B1sVZ1flEK/4IMUc8ajZZ0uVp9hSScXSePPzBLiEX/z4WgbHhTiFheihAYY7AUnVaTkB57f8rmDyU9sCBDEioLcxwBNEFxUtR7QuJhMBXCXTPEuleQ4ehTiW0F6W4UGTuMQWJ1+7aD6+wtmxX2fC/x3JFNpAju+6HMUho0TUIOMkuS0ZpPFEWndC9hUbaoS/0/k56x0rCaHGPiLMViuxv4Nax50VHU63jpsPQAAQAASURBVP1EaTq9yrX3ZvWLMPR7CZnJvCTERK2XAdQpp6TncOA0rgfmXDsovXmdX5ReKJf9MJcf8mIfbGwplv/PTRIluAxsZY+BHflpYtUcPV9CHi5sljj1M2vg6h75K42gqjLMV6GC6r2hzmBRJ6t1Ebtn2nlY9KBY+2oPEKJ1eJ5nO/Pe6UKYV78g13xIyaDf4TNlAeHgbAk2ObtOesuSnQbitn9KXnfO8OvvUa1Q8HjrZwnv3IN3NjqU0SKlHltkMxTbPoUhP8hn1nnosV+MKE/mIplX5g6mAoJzT+Oj92P03As82qU6v8friPDT80qLWAJ1t0ZwQn31hPqWv9hmw4a1nLx0i82GrZy5hncMOh8ZDeApxKfNo+WTrwpU4A7gtslVgwYNWLJkCU888QR6vZ45c+bQtm1bvLwcjYcXL14kIuL2Vq8rUIGbQmG2+3lEtwiz1cr0A3lMbf8s2k1vlrk/q+1LfLU3F2/jjQlIgJeWKZ3jGNw4mmWHEigwWehbP4LKwV4uq3Y2m40VhxNdiJUd+y5lcFezaCoFGbmUlo9OrWR8m8qMaVW5jM8dJHiiWqh3GSsdQN1IX4J9dEz8ee/12/KLLXy3+TxHr2byxagmBHnf5mqiV4g0yttX39VG6Vm6A1CrlH/bTKv/d9B6CQGKbirWq6x4iG3rsDreLAoyxaamMYLBT6yh2Ymi3pjypT/G/nmMbCwkyWqW1eJB0yQk5NphSc2zmmT207rXXLfRaDScXSur/Oc2iAKRfApqV3f0jal0UiQp1TL3KCdRFJcFE6T4HL1AthPZRGxm5amovhFiJSrMkYGzv9/ruO/oQrGE7f/F/XNbTYH4Pa7Eyhm7voW2j8k+XjsmA4YLMhzEyhAgxX3pfjQ7Eg851JjS8IuVmXKBVeQ4XNwisfA9psrrqvXy2numuw4vBoke3/2tvD+vYDmndjVq3HKJeG/7mGz7+GL5b/OJJXHuPkL87CjOg4YjZP6SOzQYLr1aKg3UHwEHfpbzFdHQlfQmn5CEwCtuiBKAbxj81EcSKKt1lnS/fTPcPxbg8m6Zo2eP1reYhKRs+1RIeeV2Ejhis0q/2pZPyh+mnXnZ0Zdov8Y3vAOXNso2avSChqNKlLmkEgsucnztyqYzbDb8tr/LgCEt+NZLe33OU3J2IYrmA+U4ZcULuc5Lk332i5ZzC/L58RRgAqgKUvHWBXEuJQ9vvZpdF9L5ZERDAr3K+a4vypNjVZgpcf9ewTcXSgToNWpGtIhh0+mytkCAwY2iCCzPZn4nEdFI1NrSg5ob3i2LgRWowN+M2yZXzzzzDN26daNhQ0dy1pNPPnn9/61WK1u3bqVLly5/bQ8rUIHyoPeVFfS/mCDXs244A748x12NBlFzQFX8drwnPRnBNUhp+SwLkiJZfTKJH8Y1u6nX8zdq8TdqqRPpWeVKyytm3h43iVwlWHYogVn3taTIbMFbp8bfqEWvUZFTYOJadiFrjyeRW2Sma+0wKgUaebxbdbacKTuAdnTLWD7yEBCx/Vw6CZkFt0+u7LjdqPC/Cel5xWQXmCR8z6DB/5/6Uf8nYbMJ2VGqrqctlguDnxQWA7+WYl7rLbPGbgYFmdKnsvFtCVsIqSkqRmgdKXbPrIN2TwoRASFayccdM7tq9BISsPoFKUwVSgmC0HiJ1SrpqGNb4fVL1KNsKUotxUICF012XcG/8KcMre71Dqx/U+YngRSkq1+Eri9LOt7SR6D9k6JKuEPjsVL4htWBNo9Jv116CfkxBkpR3vlF2PS26/dMzT5CzI4v83zcsuLF4hjXTf67cKKQQjuUas/EzA6bmwK6c8kA2p/7y7FSKCVQo9GYkhltNinE17wkJNMZWi+oPxxmDZFzUdqid3ge9Hgbtn7smph5boNYA++aIc+1Q6GQERZ1h4ht0BmRjR3n9/hSOSdXdokiN+R7IUenV8l+HPkd+n0Cs4eUPSb1hooTQaWR97rqebEqljdYu+MzMqB83wwHGQqoLP1Ya18WxXTNS/Jed34l94XWBRa4f73QupBe4kaoOwRSgPiS42O1iLXwyh5ZUJg7UhYFNAZJ6jz0q8fdDD38LcPq/4vvdsp5OJ9eTGHSGfRjl4iKu+wx+ax6BctnqSgHqnQQG6NvlPvZYkBhSEOuZmbgrVNjsljpWiuUttXKUahzkuDP94SQ2Ml8bGsY/K2os4DFasNitaFVux8d0iQ2gEYx/td7eu2I9NMzonkMalX5I0fuGLyCxXbcfKIEr9isUKe/LLwYg/6ZfajA/2vcNrnq3LkzS5cu5aefxAc+cuRI+vfvf/3+bdu2ERkZ6dKDVYEK3HEYQ6RpuXTMNMjq1U0iKsBA/wYRTJx/jh/GdiS+fhWifFRcyLTwzfpMLqUlUT3Mm3qRd9ZOUN7UeXvM+t5LGaw+mkSYr45RLWNJySlk4s/7rj/u603naBcXzDtD6vP+sAa8vvQYeSWJgIFeWupF+XE10/O8kkNXsqgf7X9H3s+/GyazlZPXcnhx8ZHrsfOtqgby5sB6xIV6/+/M3cu6IsXc4XkSbtBishRCPjcxYFmjl7+bhalIiublTzhuy00Sa9bg76TwbXCXEJoaPSWuvNh1wCmnV0mBVqOXFISNx4il6cBMKZLD6sLSx6DhcFHFji0UNaXRaIhuBWdXuxIrO85vkvTA1lPgyHyn29dDz7fEVlh3sNgJ+34Mq5512L4UCjluudeEBGXFy/aqd4dd0+Ux4fXhp57QYCTcPR8SDggxjW4hRdq2T2XQbOW2QjoPzHYN7gitLb0tNXpJUdzrPdeZXRqj2BY9LRD5RgnRcFZ0YlvLaziHTvT7VMjHulcdhXFoHUkpPL9RZlPZLKIwd3pRhvJ66pFTqiTEw90ogqt75Tg5h0uknBJbZduSRMoTy+S147pDYGWxKKaeluTAFpPE6pafImStyTiJczflC9G+vFPSGw/OgovbpEhuPlHu/+NZIfVJx2S7xxdL2qM7+1fVzkLu95bq+c64KOmN/T4VlTO2lQSJVOkg56JmH9j2mfv48tYPwYa35HyF14UUN8EbucmixjWfRLFPNMpxf6DGCssfc3+sAVVuAvWr6ZkxLJpIgxkfLy/w7ghpJ0X5BOkXdO4ZvLAZOj4rdsMVT5Z5TWul9uxK01NosnJfu0rUDPPhvaENyvT7Xoe5UGaf7Z3uevvlHTB3BKbRizmVa2D2rktcyyqiR90wOlQPIapUfHuYr55vxjRl46lkZu28RJHZyuBGkQxqHEVUwD88kscYKH8RDf7Z7VagAvzFIcJ9+/alb9++bu9r3749Bw4c+CsvX4EK3Bh6H1m5NhdKAWdHdAsY9A1sO+z5uU4I8tLxSv+67LmYzsH4TFpVrcJXG8+w5ngyBo2K+9pV5r52VQn3u3M2tUCjlruaRvPuqrI9HUatioc6xjHsm+0kZTtWcX/dE89DnaoxsnkMvzqpXlvPprJw/xWKzRZ+GNcMrUqJVq0kyFuH2WpDpVRg8cDkgr3/d1Sdy+n5DPtmO0Vmh1V05/l0hk7bzvJH2xMb+D8wcy8rHmb0c/QbgURnV+0sq8w+dzgqPi9JFCd3+ONfYn9Sqkp6dtLKEis7DsyGexbLSvv3nR1qwuF5onyOXyHF65qXHM85t0GUAE+qEwhJa/WQKEt22MM2Tq6QP4VSCN0D2+RYWYqkT+ZkyTbtOL5UCm47tn4ir3VobkmfTW0hNju+kvdStRP88bSQ3bB60P9TKMgS0nhxi6hU88c7iKEhAMYuEVJRs7cEWhRkQKuHZRaVMxQKmX216R2Jjl71nNjXGo9xtVJW7yFqVWkLVPJxiZAfORvGrZDzGL9b7JPl9UjV6ithGp6wbwYM+FJizS9tkTCUqMbwQ1dR4qp2kmthy4dipev3icP+t/8XUXNUGjk2hdmi8mRcFHWm+USIaSG2z1YPyOvkpcG6V+T5hdkOtSrnmlxLzSdKv5kzOjwtfW3ukJ8u1+nAaUL4Nr3juO/YIgnOWPGkg8QZA0UlSr8goRT1h8Fv90HE4+5f//JOLG2fQDuzn5CtOoOwRTVD4W6GIWCOaUOvsEw0iydLWqVShalGP2ztn0BR3riLrCvS4zrsR7mG08+X2H9HktdsCi9+dZrOtUK5v0PVG/ZLkZNU9hjakXyCwrTLDP0x7fr36sZTyYT66Pjt/tZUDnadQRXuJ2M/etYNw2qT8Rr/tn7ZClTg34S/RK7cwWazcfbsWfR6PTExZWcnVKACdxy+kVJU5qU4zbkKAa0vcHPkCiBEXUifsAysqUvhWA5ft+9Dcb8mZCr8CfLWuu11+itQKhUMaBTJ3D2Xr8fx2vFQp2p8ufGsC7Gy4+tN5/hpfHN+2xvvonzN33eFe9tWYdT3u9BrlCyd0o5IfwN5RWb61AtnmZv5Wzq1krp3WI37d6HQZOG7zedciJUd2YVmlhy4ykOd4/67f+gtZon3diZWdpzfCElH7jy5yknyPCy6MEtCAnwioGav8pP1inOlsN43Q9QKFLLPV/dDs4lQnC9DZFs/Atik0CzOkRjv8voqrSVzbZyVH99IGQpuh80qg3aTjsGuafKcWn2lB6P5RCjKFTUu9ax8fwz/BU4VQqLTAqHNJoQFJNjg2CLpW7IjfhfMGSHEo85ACbM4u95VcSvIkLj5+kMlztxuf+v+Bgz4XIYSZ8VLP1KLSdITdXU/pJwWlTDzsqiTeU59LfXvkp4ud8i+Kr1MxiCxl5kKoGpHIS7mImh8t8zoUmmEeJ1YIr1c1nKCqCwmeR9WC3R5GZJOSIiDvWer9MDnLR+JZfTsOlHPLEUS/nBhs6SK2q/l4ly5TaN3EEW1XsiD8/vxjZTryFQgpKLl/dJjl3BAHh/XTbZTOqHSGZmXIax+2T6x5OMSLnL3bzJHLSdJAm0KMku2a4Sji6DeEEhz+8rYjEGoDs502C1PLkdx929C0Ev31mkMKJuMQfl9Z4fiaLWgObkEmt5TvuVdYxRi6hMm6m9MC0g7i8Wm5EiON4sfakuor77MoHm3KM713PcH5Cedw98Y4vJ7lJxTxLurTvLhsAZ4u5k9WG5vVwUq8D+O2zbALly4kLFjx5KR4fgCu3jxIg0aNKBWrVpUrlyZkSNHYrF4brisQAXuGAz+kkwW01zSwrxu0VddkCnpXl+3RvnnOyh3fIlqRh8MSyYRocq6KWJVZLaQmFVAYmYBeU4Df8tDpL+BuZNa8VLf2tSO8KFelC/vDq1P3waRrDrmZrZOCfZfzqB2hGufTVa+CaNORe0IHx5pHcLZy/HkFZnx0ql5rnctqoW4Ru9qVUp+GNeMML//jR/BnEITOy94GIwKbD6TQn7xzZ2X/1jkp0rMtCfs/UmGj95JKG9w7StV8rf9S/nseUJYPVF9IhtJKuD+nyXNbeI6sR991xF+GwM/9ZL7zIUSs+0VLNZfT6jZW/qvnNHhGUcP1vXt15UY7jqDJLo97RzM6C1JfPtnSIKYV7AoKAtKesc8NfPX7AV73IwgALEiar1gzl2i6JSei1Z/mKgqzn1Fa18RO1qHp0XBa/+UHKs6A6WnLaQG/DIQFj8oyovaSYlQ6xwzmdwh4yKcWS3kbNh0UWDUeiGXK/8lNs5f7xZ1aeQcOe61+nl+vdr9ZSixRieKoDFAbH8xLWTmWJtHxb5nR9YVR59L9R5i9wNRWlJPuz7WL9p1GLK5EBIPivXUju2fw8CvQB8gsfvVugqRqdRObH3zxsh7Ka8fK7yB+3RLEAK35SM5/sW5cp5UGiFHs4fBhjcgtJ7Hl1bUGSi9UnZYzdLLNOxHIc12RDTENm4Zys0fuQ8sOb8RW1wP9xvxCRfyl58qCwZ/PAPmYswmE/F+TWlWJYRaEb43R6xArtdy4snNPlFkFZQl3GuOXSMjvyIRugIVKI3bVq6mTZtGUlISAQGOZLAnnniCY8eO0aVLF9LS0pg/fz5du3Zl0qRJd2RnK1CBvw2Zl6QoKo1LWyXqveWDMlfEA65k5PPNpnP8vv8qJouV7nXCeLpHTaoEe6G8gVIS6W/gvnZVGNIkCgUKAry0xKfne7TxARSZrWhLmoNjA400ivGnXpQvrUOK6db0PMEnZ8JVKxbGQM1eRAVEMWdSS84l57LnYjqR/gZaVgkk3E+PtryErP8iaFVKgrx0ZVRAO8J89R4bsf9nYLPCjeKO89OlgLywGdQG6TfxCRPFxh0MAUIySg931Rig80uAQorZpuOEnARWLQlVKIWBX8kMobSzjtv0frDoAZkdZIfVLORLqZaI7P0/i0JyfHHZ5v3olhBU3dGPElpbUu5yk6Wg1/s7+mfMRZI02OFp+LGXQ2mxK18Xt4nFOCteiCBAg1Gw7cOyxyPrqmdFITdJitXcZHkfdYeIUgMSlpFy0n3cd9o5ORbjV0hQhcux+1KIjCkfjv0uatWBmWLB868kUerOCX7OCKgk7zuyGSx5UGYn2SwSCuGM8xvh19EwqsT+GFzdleiAhD7EtJIghy0fiVI57Gc5XqdWCKlQacT2aAyC5Y+Dd5gk0FVqK+/buSft/EZRD+39Y9lXJQHRGZs/lBlTVTrIeSpIh6wEmLxRBmM72/qC4iRwQ6EStWx1qfcIsj/+MULsPCE/TQZSr3/d/f2HZoO2f5mbbR2eQZGwv+y5iN8lBGjQN6DWYQMUChWKomw4sdj9Nvb9jHXsMhTZCSiTnCyFXsFilXWy6tpiWqJI2I/y9BoMjcMp9PVCG1AOuSwN71AJQ3GepWZHYFVOFfhTaCo76sNq45+JV69ABf7LcNvk6vjx4/Tu3fv6v3NyclixYgUjRoxg7ty5mEwmGjduzI8//lhBrirwnw2bTSKMnVF7gESM22ezZF6SIsYNwUrILGDEtztdQiP+OHqNLWdSWf5IuzKedHdQKBQuNgofvZpmlQPYe9G9taVppQCWHkrg0xGNyC0ys+1sKl2jrMSuuR9FgiPsQnV1P+z5FsYsIswvijBfPW3i/jcn0/sZtUzpXI37nCLnnXFvuyro7rC18x+HMUgi1bd86P7+phNEyfCE3BTpaTrslF6mUEh8d6MxkihYGhYT9HpXZkDZV9jVehj6owyQXvOi47GxrWHEbCn8LmySz5YhQOxfl3e6EiulWop1Z2LljENzYcIqsfEd/k16lY4tksUOtQ6a3iv9Xuc3yQwvjR4yLsHeGdBzqvR+jZoLc0dJEmBAJejzMez6znUIrh1Z8UImLm+XSO1EhKzFdRV7nx02bhwcYlf7TiyDwd84yJXez/0AXTtM+Y7jEtdN/v/yDtl+7X5C1o4tFgIRVlfOzbbPxaa47ZOyr+cTLgqMIVBmVYGkI27+wP3208/LcUg4KFbFK3vFOmezimJVqa2cL623BH80uxcsBaJ+ORPq+N3Su9b7A1GfjIHQ+z2Y3l2+R5vcI1Hqap2Q8R1fitXx6j7pL9MY5ViAbHvVc/K8gV9K9H9EA7EElh5eXJAhr3N5l6hgrR6SkAa7ShhaR0YCKJRQpX3ZFD+vELG42ueveUJuMgQCQ3/AlnyEAoWR1IiORAf5oJjW2v1zsq6UWNfTUWz5WAIptF7y565PsTiXgqSzFA6eg1dBIorUU2j9I1Ga8uUzZ/8shdRC0fEZ+H0iyoIMws5vwNJjKjSbIK99M9AY5bgXZLiGQ4XUoviu2bzwg/vhwI1j/fFxYwmsQAX+v+O2yVV6ejrh4Y4fmK1bt2I2mxk1ahQAGo2G7t27M3v27L++lxWowN8Jm9W1h6H9U1LULLjX4UP3CpGCJqaFa9oXsPN8mts0vtwiMz9sPc/L/ercclHvb9TyWv+6DPl6O8UWR++IWqmgX4MIsNl4Z3B9pq48wdnkXOJCvfFLPuFCrK4j5ZTYoVo+8JcG+/43oHFsABPaVOan7Rev36ZQwDM9alL1JkjufzxUGmg6XgIeskrF+Fdq5z4ZKy9NikuNUQIiDpcqKG02IUOV2oKhkRR6pgIpzDQGyLosSXx3z4NTf0gR3fBuITznN7q+1uUdYl3r/ob0DNlnXPlEwJKHXB+r95NQAk8wF0lvzOHf5N9bPpQV+84vSrx44kEZFJt4SHqYMuPls9ntVXkP3qFw9QCMXSoKi6VY1LnSBbkzLmwWYmOfJbT8cejwpJCIzHhRc3wixXI4Ypbs24mlrq8R3kB6t6Bsr1j6OWj9sOftB8UJMRs6XRSbkBrQ6QXZH2uxnL/sBCEWnV+E30r6cgZ+LcT6wC+O2UfBNUSJW/GUxLTbE+sMAR7ju68fg7pD4ed+cj01Gi3bOL9J1LLhM0Vli+sOe34UK6idWKk0Qkyr93D0uWm9RT3MTZHeupp9JJr91ErpJ2sxWSxzvwyQa3HzBzD8Z1j6qEPlUutklprWG7KviA38+KKy+97vU0mEtCtu9YfJa9sAvyhRHOeOFBIx6lchquZC2c+ur8j/p18QYtZ8ouynOxW2UhvIAZY+imXkTJ7Yqmf9mkSOP+6Dtu4gxzXrDK23zPuaOVBIXsIBUcgajCibaljynjMD6tPhsyPEBhqZO7w1ocd+gPB6ck2Y8uU45CTBwskuPWaqda8KGb9ZcgVCxPt/JipxXvJ1m2ye0p+mlbJYccT1s6pVKXl9QF23Q+0rUIH/77htcuXr60tamqOjc+PGjSiVStq3b3/9No1GQ16eh+SoCvwfe1cd3ca9NUdoyZaZOXYShxwmO8zMzNA0TdOkmDIzpJxSmoaZmZmZ2QHHzMzi74+RIrDkYN/X96o5xyexYLXaXcl3fjN3rgP/AGQXK1GiVCO0zgCIb2xmYeUVAWyyKoBKs4ElA4EXTgHekShXa5FTrMQdwwDg+ROaY/35FGy1Co3YdyMLL3aqCX+3R1dMogIU2PpSG8zadxt3s0rwXLvqCPaUoVSpRZCHDCn55UjNJ6nrWdMFPjer6MW5sIRWIpf/TdXKCC8XKV7pGoXRMWE4GZ8HsVCAlhFe8HF1+t9ZYfUIBZ7Zwcb6K2vYcN9iisHeZ6aolOdTQdj/OVe5u38BnP7L/nYzr5GAHP2BfTpBTYFW01l43t5Dm1T1jpwVo/Bj+IEtpF+kLWrtRPbuRLRnkqd1T4eyuOq+GKGo8nO2vMSi+NjP3Nc7e0gclgxkKl1kByDrJiAWA1pPDoX9qwPDIra8wt4de/ZHwDQvTFMOwJnK0L5PABc/YMJW2tdu7SJxkDgDzSdRlTMGSsg8OMtpyyv8vU4/qj8ACULtvuwx8qvDoAlrtHmVizqNRnM7F5ZQkXIPowozchXJnEcY+3gAEpJN0xjz/ux+quwiCYnpjndoj7u732Tr1KpY6NtLonML4jUzdAFwajZ7jARCkqLB80gcPcM466rLpyZiIJLy/ptbmJCo0/C2RmOoVLkG8vo5+j3JXUB9oNdMJi9m3QC6fMJ0xrBY+s06fcDrQyQm2b+82mTdHra48gDdgAaGPi4zK+OVtfwBeBzcQ02E7eBXTHw88SvJ86ZplpZFhR9Vri2vWC5kyDyYRnujGOj+OXQu/th9/RZGNA9FaqkAEQ1GkHymmi10ObmaFLOSLBL0UD+S4SELuQBmjLYHAIkzVEOX4a09OdDpgR96+CJw/QCqX4b7MWwxybWtsBmdhtv0rGZ5u0ZF26rWsNiiCLB0Y8g9DP3LNe7f5Ang437RaF/LD38eikdBmQotI73wSpcoVPP+H0hfdcCBvwGPTa5q166NLVu24PPPP4dIJMLy5cvRtGlTix6sxMRE+Ps/5eQqBxx4CtBodbieXoRXV13E3exSrB1VC828ImkFPG0nklarAq6uRVnMa9h4MRUfbb4GtZZ+c7FQgBc71cCkNhGYd/Te/ae4ysSPnU4nFYkQ5e+KmYMbILWgHJMXn0WCWT9RbKQ3Zo1sjOnL7diq/qVwl0vgLpeghl8VRfR/O9xDqYA0Gm0KFTCHuoKWp51vm27TadgAbwt1+nIVfZ6ZupR1gyrXmHWmAbHGNMAanatO8NNUAH1+ofLxZxtav5o/yxh0I7QqvqZ3ddszrGr3tbTjGRF/kEEYCUdYbFYU8nhcWUf1zacmCWKbVxnY4OzFRLys68ANCWdWmc+IsjgO/Ugerm4E3EZRuWs1g6EZG5+n0mKEugw4/gvQ9g3OW9KpGViw5yOSB7kn1TsnV+6v3ANw8Wc/1YDfeX5ubCaB86zG4j/jMlMGhWLG1d8PvTgJXFnNUIrgZhxe3P4tqoqn5zLSfccbnIfV+wcSLNdAEjShhD1XRlzbADQaRUunNaQuVG3u7AZSTvP7cIgh0twtiImDfX4i6bPuOYt5gVbOuO2W5/jcfEBbwQHN5sOHs25wXwbNBQ58zp69yI4kdCuHc/vVOwGBjWnVNCc+AiGtqeYJd+GtGNwB0D4b0Z7EIfE41b6bW3n8jEg+xeHRY9YC6yZZbh8gCdrxJs/t+md5W0Q7ksAd7wG+z0MffxjFQW3h5SxF17oBmLj2Glb1VcC/4Uig9Svs63LxpS1TJKNSK5JwAaKToV9x/WT+P2YqCZGzF3T+0fj+ohTH7qWimrczQkqvmoiV8drTVNhP8QSgF4pg8ZenOAM4+QeDm4zKbsf3+Dl7QACUr6sThjULRadaftDo9HCVieHiZKd81Ot5LMtySIBdfABF4MMPLHfAgf8BPHZ390svvYS0tDSEhIQgLCwM6enpmDp1qsVjTp48iYYNG9rZggMOPAAVRUBuPJB4Aki/XLWF6BGRauiTuptNZfX5zem41WM5tEHNbNtAjEi/iOziMry74ep9YgUAGp0eP+69jcahHvBwNq22T2oTAR/Fk6XxFSs1mLTIklgBwIn4XKw7n4KhzUKx43YpsmuNsr+RxmMdk+n/1yAUsiiyJlYAbT3WzfiZ17nibguNRtsOdNFpqOJ2/pCKghECYSV7rAVkngw4SDxKEpZ7h6qQ+TYAqi99f7ZMjANYZDcYxmGy1lCVWA5BzrwKDFkAhMcypOHEL0CjkUDubRb3PlGmvq70SwzviGhfebtNxgEQMM0wwZA+2O9X9orlJ1gSK3Oc+oP9Rz61gCM/ANAzMW/sBipsuXfYk5R8mv0/pdnAoZlAmxnAuC1UIFq9SLIT1JjJpdtes0wTBEicZG7AgS+AP9tRtbiwDOj2GVDN4BhJOUOVZd8n/FkzDjg8kwN+jbi1k+ehplUSndyTIy2OfM/ffaP4mkIRAyKkChKrG5tNtsK7+2k/A0huzImVOS6vsh3vblQGWzzHAcUbJjPmXObBY9HxPQ7sDYuhFW7iTkN4xnYqlUMX0abY/k0SYbEzyWmPr2ll1Kr5vL6zaHPLv0f1r+8sWibdg3mbcaaVNXLvAu5BfI3hS4HgpuxZbPk8AEBwfSM8UIo2Nb1x9HY2EnLL8PxeJdL92kKfd48qUXEGIJUDJ38jQa47gNs+PYfXvl7Hba57luQ08SRS9T6Yc5zHuKa/KzxTD1bet6JU2khtQSSFxtPsvrI8LjQc+8nU31WSRbJ8eZXtgBUb8HF1QoC7zD6x0qhIZv/qBMxuC8zpAPzRhiS6wkafowMO/I/isZcSBg8ejN9++w3z5nGi94gRIzBhwoT79x86dAhFRUXo0aPHE++kA/9ClGQC+74ALi42rZB6RTIq2K/OE21ar9dj88U0lKtNtpKcEhV6L7qH+UOqoa1PTUtLhxl0wc2w7kLleVFGrD2fgj4NgrD0ZCLaRfmgY22/J9pXAEgvLEdSnu0EvN3XMjB7TFMsPZmIO86N4BXYGCLz2TwAC9c6/f7n+60cMENJVuVV7Str2Mtye5dlMeXkSvVHayfCvTCZK+UjlpMYVBRyyGujMVQlrBHcFMi+wd6YCrPUtG0zGHDQYDhVBOiBRmOBkhzaGt0CAVU5i/q0i1QTrAkGAFRrw+hyI3xqUYkyt1Uln6JyANB+6Gxmh938EnvCmj/LCHexjJ8PuTv7V6TOwKS9wJm7JBLZN2mxswdVCYvwtPMMBsm6Rgvl5hf5vgSGAcvVO7GY9asLtH2NhS50JtuaVyTnbbkGVF7gEYoYO75qtOV5Nc5lGreZBK77l1TxWkyheulXC7ixleer9/cksyVZ7Ivr+xO3mXKWYR9e1YF1z5CA1u1Pwrj9dVMvj8wd6DmT9juxjMTq3kEqLje327cZAlQw7M2dyounyqYsZljFid+Azp8AQQ2ApYOpbhoh8wDGbeR1dX4hhz7rNFQG284A6g0BDn5hSfKub2KvbM9vSWSO/QjcO8L303QCVaWqUJJFi6u5UletPQCOHRDm3cIb3bvg1/1UXy+kFKP7wnLsG9sOvk7neLyuruNCSHATEtv8BKqJWjU/k4Up3H5YLOAWhCNXS++/XFG5GhX+Iahkaj71J69jG58Tdc/vkaJSIMJ4Q2l25d5AIw5+ReXa4ynMJS1IApYMsPwuqSig8jdpD8+DAw78C/BEOu3UqVMrqVVGtG/f3mIGlgMOPDS0auDMPOCCVYJfXjwtNc8dpHXlMaHUaHE2sfK1qdbq8dbOdGzu/RZ81g+r/ESJHPo6A3BgRZrdbacVlGN4s1D0bxiECB8X+Lg++QypLBuDhI3Q6XFfQZu8IRXzBv2KWqXn4HF9MYeoNh4DRPXgCq0D/x7YmlmjKmGy3NCFwOHvSQYEAqB6l4foxRPQXmec+5SfRBtX/cFAaQ6VrOsbWfS2e52R6wIhUK2VaRPqcmCzoYerekf2nfhEsQfn6jrui1jGn0FzbdsOgxrz+8GYuCeSUjFJOmF6jHsIUH8YVZdGo7hqHtSIBEWnZeG3820qNcFNgJo9qBgUpgItnwMO/Qq0mMZt3dwKCAWM77YHoYg9UOX5wLwulvdtns4htxN3ssiPaEvV7PB3LKQjO9D6WJ5P9enWTsaYW6Nmd4aJ2LKBaVVMI5y0l/a5xGMkwFfWMECj1UskXBeXAl0+BiQu3Of4g8C2N0gmg5uSmDUcyZ6lRqMZ/GB+DioKgQ1T2KfkFUn7nqqE77HPT6YQEHvQVjVjTmAi+fEHuC9X11kSK4CFenEmlT3zUI7kU5xv9cwu2kWtkXya1/ullbQ7Gre17xMSU5HEtnojELI3ydoCeWMrEGyY6ebkihBPF/SsH4CVZ9ibVVShwd5kYEDWach3vk27qpMriePpvzikuDyf5FjkBNTqQ1Jt6H9qU0MOiUgAtVaPs4n5yO/YF64nv7Pcj7x44OQf0E3YCf2VNRClnobaNRzZDSZjR5ozWgSYlXfmKZ3WUBYZ5qQ9IbnSaWkXtbdIc+ArEkljX6MDDvwPw2GCdeCfh+IM4OTvtu8rzaYv/QnIlUQkQnVfFxy6lV3pvrTCCuwrCMPQPrMg3POeKbLZPRQYMh86t2A0DivDlVTbQzsbhXqgY20/yCRPL/I7xNN+07CTWAhPFwncDB748/lyVG86AmhsSN6yNwTVgf8/6PV/v4ro4stizdpKe+8Q1ZFhi7niLxBw5b48n4ELtpQiz2osxm/tZjKcaxCDIo79TEKl15EQNZ9MtSj3NjBmA3ByNlPaIjuwkDeiLJcBEVHdAFUx0O4NIHoIgwNKM6kyaVXA+K1Mjrt3iIVpo9Fc+V4/hduRKmir2vUOCUn6RT5G4U8icXkVScOwJbQq9f4R2PaqKQihPJ8/7sHArrd5+70DfPzeD4GgGbxNU8Fj5RpYuS8HMKheHlSF6g/l70Ix9y/jEkMamoxnSuGgv7jNhsOp/BSn096Wd48/AiELXbdgS/IQ2NByMK01Us6Q6Nzcxv8r/Gi1EwjYN1SjC8njxhcqP1dVzP2HgATv+aMMj7DXU3dmLsMohswD9n1GW+bKUcDQxbTsZV6t/JywWNr+bMGnJq/V3e/zd72eBE9ZDHR8FzjwpemxfnV4fdlKO9SqSFobDOc+WuPsPCpyRnJlxOWVQPPnaNuzRsORto+7cSSB3AMCNy5c1Q5wQ51AV9xI59+M93alwanXC2hXewi8r86HoDwf+lYvQVCzK/9+eYaT9NtAgLsMf41rhilLzkGp0eGXs2X4tO8cyLc+bxHkoRS74VyOE67Kx6N2i2ew/WYBtqzIRakqD9tqVzNt8EF/B8xtto8LTQUTEO0h5yYtiQ5y5cC/AE9Mro4dO4aFCxfi4sWLKCoqgpubGxo3boxx48ahTZs2T2MfHfi3Qau0PYfGiJxblQdNmj9dp0d2cQXUatsrpSKhACNahGHh8QTYmtPr5+8PYY2RQI1OXJUXibmy7xoICYDxraph5elki4h0gKEWk9tGPlViBQB+bk5oFOqOi8mVCd3Y2HBEB7ph96vtIBAI4KNwMgRoPLli5sBTRnEGezsuLudquHHWzwOaySuhPJ+r7DJ3+zOtXANZ7C7uZ9n0L5EDPb9mcWckeAXJ0CadhqjzRxaDSeFdnQpQjS60fUV1Zz9Oi+cZnmCuEGgqaDes1obkK/cuFRuhCGj3JovrrOtUeBqNpnJ0eCafKxAAtXoD4zcBZfkGJWYpbVNNJ7I3piSLfVyFSUDHd/jeZR4MlEg+xc9pv1+AuJ2WvWP595hqOGQBwzgmbAcyrrAHxTeKz1s/2VSwatVMj6vZDSgFj6+qgsSp3y9MKywyU67DYtgbVl7ANMb4Q9yepoLHusl4Kj0aJVWjohRg94e0DhpxdS1QfzgQ0hSQNGcvTucPad0zEhzvmoDrZfvXhFsQVQOj9as43RBRPxRo/SqDDNrOAFYMr/zcphOZBLh2AgM13EJIlHt/T1ugtWqTexsIawns+Zg2QWdvoDyHytSAP2ihM1dK/OvxcTlxlV9b7ETSe26BSX30q8tAjlOzGfzhFmQ65gENLFVKayQd53G2BXU5lc/uX/G6lLmRzCafIdF39qSyVJ7Pa6vlFC6qbXmx8rZqdgMqAPSYyb9HvrXg7ybD/PHNseDYPSw7lQSVVgdX7wAcKvdBmve70Gs1KM2WY1CIOyJctJBWMZ5DKhahZYQX1k1thUvJBSgoVyM7qCZUww/BLecCRMoilAe2wOEMCT5akwitTo8545ph5flb97dRrDT7++cexr9hpTYCbSLaW9pmHxciGc/1vUO27/eqzs+EAw78C/BE5OrVV1/FrFmzoDd8+QoEAuj1epw7dw7z5s3Dyy+/jB9++OGp7KgD/yKIZbSY2PPo+9W1+9SsogqsOZeCuUfiUaZUYWYL4HxiPqJDvSyacEM95fhjTFO8uuoiylQsrMRCAV7pUhONQz1oN/IItelDD/WSY/nklnhj7WXcy2FzcJiXM2YOaYDwvyGa1kfhhN9HN8UHG69if1wW9HrOGBkTE4Yp7arDzVkKx1rgPxxF6YynTj5puu3CYg507fLRw0Xkl2Qx3OX4z1Q3anRhAehRrfJwa4EACGoCvHCCfSlp5xmtXrcfC0YzYoWFvSAqSGKU97hNnF1UuxeJxtl5LNpDmtPSFtyc/VfW1qsOb1Mx2vshC2vvmkDMVOg9IyCQedAW5eJLZST3DofeNpvEhZTTc2i/EwjZv3NrO9WMRqMAJzem92XHkbAcnsnXUZfx+0EgZKHbYgofe+KXysdNq2YIxLAl7OXMS6AClnqW+2Kt1iUcBZo+B8SDyYJn/6QFa8ebQKcPAYUvyZRHOBWqvLuAk4LH2XwAq7qcBEFZZJgh5sXi35xYGXFlFdBkDBWcaxs4fHjkSuD8YhJyZy+SuLhttq+NJuO4f5W2a5hPlniUM8ECGpBAGRHSnIRj+VDTbQWJwJ73qdq0fJ7EzBzeNYHa/RiOknGZRN4jHDj+K3uwOn1AYp4XTzKdfZPhG/1/4zm4vIo9RsFNgeiBwMFvTNeTUMRwin2f8vcLS6lqHp/F31UlVfdIyT3t937V7kMiHtaKRPvySl5H1Tux6PdvAIzdBOg1PK8CEbDh+crk0j2UCtj5ZODMHKBGB/YsAQj0kOP17rUwsU0ENFo9vtx+AzuuWqrHC44mYN3UVqgf4m7/fQCQS8UI83KGSqPF4pOJuOTljBdXJCHcOxQysQgJ+3Oh1JgW+FQay8U+iyAl10Bg9FpgcX+DBdAAr0iOKZB7VLkvDwWRiET99J+VY/IB9vc9jddxwIH/Ajw2uVq0aBF+/vlnREVF4aOPPkLHjh3h7++PrKwsHDhwAJ988gl+/vlnNGrUCOPGjXua++zA/zpcfBnre+CLyve5h/APtg3klijx5rrLOBhHu5+TYWFw/MLTmDu+JdrUNM3UkUvF6FjbF7tfbYeU/HKoNDpU83aGj8IJzvaSkAyQikRoVs0Lq6fEoKBMDb0e8HCWwM/tKVgr7CDIQ44fhzdCbqkKpUoN5BIRKjQaXEktQKSPAt4K6d8yx6mwXIXMQiV2XE1HqUqL7vUCEO7l/FR6yVCcaSqQ5Z4sWv+/oFHRcqrXMY76adop9XoWy+bEyogLi5ls9yByVZpDVenKGtNtuXeogj27t3LaHgCIJSye2rzC/jtrAqbVsgfFGNYgkTMoInY6Axkumc1NK0yh5WzMestIaIDpZ1oNsPVV023ZN4EtL0PQ7xdAXkw1Z9xm7vOWl0xDu529GW3tFsKhsI1GsVEfYKHd/3dazRJP8PrQaUyWMLGMNrukE9x3eyvmAGO/8xNoxYrqRgKTc4s9XyNXkkAYhwuLZQbrUhHnH0HNIr8wmSTqzHwg9QzVL50G8Ixg2Ie9uV+XV9Eq6BYCXF1vfx/PL+Z3W5vX+Lk4u4AkMGYqj1PiURKPw9+ZFC2BkLbKzKumPjRrpF0EonoC+7+kGpWfwPMuEjONb9kQ28+7tAIYvYYE0UgwBAJG3G+axv0xQubBYyCWsgerWlsqjEsGmZTT8nze1/w5oMkEAHoqnKVZ/PyHNGPIyJl5pkCP4gzLz+Ld/Uz7u7DE9j63nAokHK58u4sv7allufwcZd803Re3g8do5Coel7Sz7NHq8xMXPtIusP9LpyFBq9mF5M9zomHmVXOLl5KKRQh0l+NqamElYgUAKq0OH225ivnjm8PjAQN43eQSNAn3QqSvAumFPI6JVqmxptc1fb7bR/nCR2G2baEQCGgIPH+Mym3eXSCwEdMG3QKr3IdHgkcY+8nWPWtaHJXIqRYGRD+913HAgX84Hptc/fHHHwgJCcGpU6fg7m5agfH398eIESPQs2dP1K9fH7///ruDXDnwaCjJ4h/DFpOBc4tMDbKBDTlzpDCFg36tkF5YcZ9YmUOvBz7cdA2rpsTC14wUSEUihHg6V9nTVBV8XWXwdX14QqXV6ZFTooROzzkhCqdHI0NucgmkYiGO3cnBiysu3FfchALg+fbV8WzbSHi5VP3H+lFQUKbCwmMJ+GmfaSjnnMPxaFfTB98Nbfj4ZFJdwTTGzdNNRZRfXVqA/Ov/5+ehFGcAZ2bTmqQqZbHU4ytaXCRPQYkszeYKtz2cMswuEldx7gqTLYmVEcoiYPcHQO/vaO2R2tlfc2KlLGFBm58I+NclQUk8zkL+/GL2N5kTKyO0KipTfa3UoQbDaAWzBWdvFlp1+/P5q8dYrmqX5dJ2NWIFbYXmKpJOC2x6ARi1hgWtVmkKpQA4G+j0nwAMfWP23rsRIieqQGufMZGTxGMs1AfO5nnKuMzZTmI5gCIqZh7hHKjrHsowAmv1qCCB17G1wmH+PjRKoDjN0qJpDU0Fz/OiPkBoDPepKI3fhfEHuP2CBCpRuXf5HnyiAKkrsKC7/e2Knbi9/Z+RwE7YQdtfYRIXOMxJmUBAsigQsAesIJnXVWk2rZi9fzAMvD1q+RoVBUwyHL+VxzPhCCD8kOfM4nGFHEC86y2+hybjgP5/0DKYcYX9dBUFpscHNaXaCLCPLGYqC/jOH1UeNVCzGxDZnpZFj3DaLXUakv/avRmTX2+gJbECGMDiH03La3kexwD0+BpIOUfiGdIcqD+EhPH8EoYqCZxIruoPpeXOBg7b6Ok14nxiAQrL1Q8kV0Z4OEuh1ent2sPbR/nibEIehAKgR70AfNC3buVtC4V23RhPDRIZENGBfXslWbz2Xf3ZY/k0+roccOC/BI9dxVy7dg3PPvusBbEyh7u7OwYPHoy5c+0MZHXAATOUKTXIKVVBpdEiHOWQbH2FjclDF/IPpEgCZN/iIM82r9GiZIUzCXl2tx+fU4oSpdqCXP0nkVFYgbXnkrHoRCJKKjRoW9MHr3evhQhvF0jEwgdvwIDUgnI8t+QctDo9avgp8HxTVwS6inE7rwwXkvLRuc7TG9qdlFdmQayMOHw7B7uuZWBMTDgEjxPMkB/PXiBjUzjAfpwFPYGpx6m2/CexdiKQdsb0e8oZYF43YNLuSqvSAEjGygtY6Ms9H6w66bSAyvZqMwAGCuht2GjMccOOHQwA7uzhDCatmnY+qYv9x5bm0L5VlMKkPHU5589U78R46pZTGAxhD6nnua+eETx/jUayJyb2RRIy834kmQdXr9VlTKw8v8i2XUivpwJXb6BlD5nUhYV91jWSMLk3layNU6kuedegha/BMO5z0/FUcvQ6Q0+WOws8TQUtaFJnzn2yDmrQaRim0PlDFti1+1DdCHyZCX812gErRwPjt/Bct3qRtjJjka7X81pw8eVr2eoXFTtxZl9UDyb72UL1zgy/AKhynvydFr3bu9n71uFtYOM0YNlQBl4IBFTxRq5m34y1cicQkFDW6MpZZcb3rTUQPbcgS5tWk3G0t2Xd4GP967HPrd8vPG9uwSSzke1p6Tw7z/L1yvNJMsNiOBtMVcJZXke+47GRuVMpy08wDY0uTOE+yDxpnfQIBQ5+bYj7l1B1hYB/CwQiEp7fW3KW1aTdhuHIQvar5dyhIhk9hNdCtTb8nMrceczq9gfuWalaLZ/n+VozwXRbwhHg7HzO/JIq+H2QcobXW4vJwEU97k/n9YzgsfSu/J3lLLXfUyUSCqDU6KDT6SF8yCHz3gon/DqqCaYvP29BsFrX8Man/euhRKnBiOZhf5uL4aEhEtNh8gShUw448N+Ov3WJ+LEKLwf+dUgrKMfMnTex9XI6NDo91o4KQzO5J+00l1dVfoJ/PZvbqWoVUCQUQGxti/oPIau4Ai8sO4fzSQX3b9t9PROHbmVj07TWqB348B1TG86nQqvT45uewegsuwmfs28CBUlo7VcHuQHvorRQAhf3J7e0aXV6LD2ZaPf+eUfvoUd04KOTVVUZcORHS2JlhLocOLeYisR/Ur3KuFL5Nr2OA2lHrTbZktTlLLK2vGxS3AIbAf1/BfzqVbbdGeHsRdJz+i/b90cPsU06zFHV8RAIAeg5gHXaaaoZ9pB0Eohsx8/V8V+pUjV/lqTg6hrOArKViHf/tQzf6WPWs2fp1Gy+L5+atPelnjXZ+sRSEivj83Ju2d4mwJCE2BepoCn8gI7v05pXkAx4RwFeOhaycncS8PJ8qi4CARW4am35nvr+AkiceP6KM5l0WFFIclWea7+PsziDpL7Lp5w71Wo6cA+0wMkU7MXJukEyJxAyjMTFF9j2OtBsIv/f8T3DIFsZe4SMs/KCm1Ixcw3g8+K2V96PgAZc2S9IZH+MX10Sj+qdmVZ3eRWtn72/o5KTcIyvFdiAtrZWLwKZhqAO10DO0XIPYVqjqoQBQNnXuW+ugSSTmVe5z8FNSc70WmD5MEsFrvXLVG+vrQcajqJV8NIKKljBTSoPVi5KpcLnkUa7aUgzPr/b5+yVSz1rmb5Xtz8towH1aZ28dxgYPJeW8K5fkHSf/M2kWAqEJGFJJ/mZu3eYQQrBjTmvSachMer9A69JgAs3Og0/v+Zx8UIxRwIstxHyUZpN8thguIlE5t7hsTPH5VVASCObl1TbKPs25861/bD2XDImtopAoMfDhzyEeDpj3vjmyC1VoaBMBS8XJ3grpPB8SAXMAQcc+M/gsavNevXqYd26dSgpsd08WlxcjHXr1qFePduFsAP/HpQo1UgvLEdGYTk0Vgl7WcUVmLLkLDZeTIPGEN0363QJCpu/bHtj7qF2p9I3DfOE2M4qYPd6/k/VMvcouJtVYkGsjFBqdPh6x00UlduYr2IDWp0Ot7OKMaGZL3qXboDPjilcPVeXAann4L12MGQJex5cqD/Ua+mRW2pnXgmAwnI1tDo7Uc1VQVVsP5IZYMO/uvTRt/t3IOUMbYJG5N7lgEzzAa/pF6m4VTVkVuwExEyzPQfIuwaL6vWTSSTsoXYf+/fV6sWoc70euLqBak3WDW7PfLZQcSZ7hlaNZW9JUSqvn+2v08pVbxBtaRHt7UfFR3Rgf8qNTdzn1HMkCsmn+btbMAkBwALVuwa3lXDM7ucWAOAZSfJwdS0wYDbJyZoJwJ4PmHC3821AoCeR2/oKX1fmBjyzl8c+LAbIugkE1KPqtP45Dha+uJQKiE4DQEQ1reN7JM1DF/Hfdq+TqJQXkrgo/IDtb3C/FvYEStKAnW8yMCLlDEMRdr1HEjl+C4/z3M7crw1TODw4dhqVE+8afD2jYnJuEfuYGo3i63iEM8Wv/ZucAzRwNh/vHgL41qZy2vcXph16RgClubRZNhzJc75pOq8rgRAYt4WpfEPm8TitGMl5Y/O70+44eB5tddtnmOLSz/xFi11gA0brW1sbj/3MPrWYFxgAYcThbw39aFYIqE/C1eFtxqGnX2Ja4tV1XMS4s9f02GptuN+p54BzC6lINpsEnJ5HkqtT0wYJ8DutZjeer8CGPJ+pZ3msQprxuuv1Ha3Fvb5l4uP1TUxPlCp4Ddw7BNTqaXr9wIZA0in71+StnVTpjBCKaXON7MhtAsCV1SYSZwU/Vye807N2pdv93ZwwJiYcy04mIaOoCpuoHXgrnBDl74oWEd6o4adwECsHHPgH4rGXh6dMmYJJkyYhNjYWH3/8Mdq3bw8fHx/k5OTg4MGD+OSTT5CSkoJPP/30ae6vA/9F0Gh1iM8pxXe74nAwLhvOTiKMbhmOMTFhCHTnal1qfjmupBZZPO/wnTwcrtcZnVoWwOXcH6Y+jKAmXNV0C7L5en5uTvhlZGNMW37eImI9xFOOd3rWsUgL/E9ip42mZiMO3c5GiVIDN/mDbRwioRAtI73RzqcEilU2UtEAiHa9DVRr/cSWDKlYiN71A7Hvhu0m+XZRvnB7HOuJWMZCyJygmMOzGh/zd0Gr5vX0MK8hdTGoQmCf0qGvbRNXZTFJQZvX7KtXntWAyftpO7u+mapOvUFAza4sKktzqFSMWcei2xpuQbQwnZptebuLD9B0AtPYABajRanAkoEslNu9wR4iFx8WpMbBr9a4d5jb2fUeC9SO71tGmgNU4FpN5zHY+Zbt93n4W2DgX0CdPlzlF8s5QPfichbjV9fa7k1q8wqJQIspVC2sh54WJAJrJjJkwDWARNcj1EAqNjGCfcAfTL0ryeJj+v3CYn7fpwD0QKOxHDK79WXLsJzqnUi0nNzY23RqNiA0XB+BDUlism3EiEvkDFi4ZhVSoSziOX12H0lu+kXayTZOZYFeswuL836/cj/3fEQyMHwZiaG5wnfsR6DX90whvL2b6tHEnVTm2r9DlW7vR7yuBEISmY3TGEFvjtu7abFs8xqP7ZD53JeMyyQpKVUseFxaSQUr64bptuJ09nqZI7gpycegOZyp5RnBz9nu90hK27zKSH6hmIqVUEJib0RJJo+nXkMr381tvCZv7zEkCw7iYGOj6n19Ex83cgUHCBsXOJxcgZ7fABnXmI6pVZN0bn2VRK7FZJJPoYgEzh6sP+t1+/P5AfWBzp8BZ+OZnulse5SCq0yCTrX9EOHjgt3XM5FfpkKzcE9U91Xg3Q1XUKrSokL95AthDjjgwD8Pj11tTpw4ERcuXMCvv/6KYcOGAQCEQiF0htVsvV6PF198EePHj386e+rAfx3ic0rR79ejqFDzmlCV6fDbgTs4cDMTCya0gL+7DFftDON9cVMyhjXshc+mTICTupCFjIuP3T9kACCTiNChli/2zWiPXdcykVFQCuAeFk1sgRCvpx+R/rCoijjJJaJHmifbrY4/JElx9tWpsjzDYNQn97vHRHojxFOOlPxyi9udxEK82KnmA1MVbULmDrR9vXKU9/0XfcH+7KYngaqMBfrpuUD2DcZPNzQQEnsnoMkE2r0AEhKjzcsWEo5QFbDX7yQQ0HbW4T2u2KsrgFs7aEky9sJkXKZyZItcOXtxXlStXrRJlRdwO6EtWaAaFbbgZuzVaTyW6s/u90hmYqayyLy9x/b++dXlPrV4jipCx/epBp1dQAUqtDlfa+c7VAvU5ba3ozQMpN31jqnAF0nYzyRxAZ7ZTRXjwlIeUydXFr4QMFHMxZc2vjaG5MGMK9yfkkyqbDrDfC+RBNj0IomMiw/Q7i2GERiHJvf5kZa9AjNrq0TG8IxkqyGyd/dz9EKHd/la5ojsAFw3kCepC8lfWEsSdPdQEgCR1BS6Y4RGSeua3Bu4s88ULS73pEqnKqelzNmLlr76w/i7tXVSr+f5HbWKZOLeIfZF7X4f6PYZsGiIyXopduIxsCZWRsTvp0omknKYsKaCZKfnN8CNrbafA/DYWx8zwLRAIZIwNKLje0D8YeD0bF6P1TtSKbq0kgqdsw+juovSgGOzbO/nnT2Mv89P4EJBYEP2qdUfwn22thNXFALb36S1dc+HvE1ZTPVw8kGG5uj1DKh4dh9DawIbARO2AXG7eH6P216oQkR7k2XYuwbVwgtLuS+GxSF9p/dMKpYNOEvFeG/DVTQJ94SHXIKtl9ORVayETqfDl90D0VxyD9jxPS2Z9YcwqMn4neOAAw781+KJlvJnzZqFoUOH2hwiPH78eLRtWzl0wIF/B0qUany/+9Z9YmWO6+nFuJ5eBH93GQLc7SsIG6/m4aXu9RHiWzkZ0B7kUjEifBR4vr0CarUa27ffg//fGJH+MOjTIBC/7L9j876RLULh/Qh2xSAPObSFD+jREj4dhS7IQ44Vk2Pw+4E7WH8hFSqtDm1r+uK9XrVR7UnmeQU24CycA1+YiIVIwhX6vyPMQqthUbpylGVK3NlFQPRvtBNtmWb5nIAGVGmMCX4iJyox5oEN5vCoxqL1QVAWcXaOPWTHcZXeGkVp7PdJOMpjd3E5I8iPfG96jGc1EpsrazhPyIijP3DVXyThj8yd4QWBjXi/wp9zsC6vYsHcZCxDDyTOJHoyd77u4e/4eKH9Rn0AQEW+qXAWCEmeNBXA5mlMggtuxuIWAgZVuAYAa8Yzda3Lh7SSGecahcVSmRDLuU2FP22JJ341vV5pDkMTOn/E30NbMj7bnFgBTEa0Tpgz4vYuzuGxmeanZwE9ZD6tgEcNsxuNw4+HzGcCoTXByjKQ+MRjpuM28E/aC0NbUgnR6/na0cOoqNmCXsf37FeX+7huEonL5dUmYgXQ8mgkl7bQ9TNaLM1VwaQTHJBcrTWvAVsIblo5YS+yA4cwP3eYnxGdjvsfbxaqcW4hCeHQRTyGQhF76vIT7BNAsdwQmBLO3rea3Xm9aCrsz6/KvAp4v2N5m07Lz0j3L/n75ulU2zp+QBuhQMS5YmIZe72Mw5eNkDhT9S3JoqKoKec58K9L+6tWDzScA8HK0cCg33k+rfoiiyvUcBILMK1TdXy8+Tqebe6DX7q7w6XgFjwDwiCROUFQmAJEtuW1smIEdOFtIOj1LQSuTy+YqBKUJVwwKcnk+3TxsesGccABBx4Pj12FHT58GG5ubmjbtq2DRDlQCcUVGhyMszN3BcDmS2noWNsPdQLdoHASo0SpqfSYQU2Cn848JXsoz+cfGr2WRU5JFleSXXxs98c8JgLd5XinZy0k5ZWjdQ0my93LKcXR2zmY1CYSUvEDilUzCIUCCD1DWfBW2FD9fGtD6eSJp3XUQr2c8VG/enixc03oAbg6iR/KwlglnL1ocYseBGReZ9HlV4dxvQ+K034cFKezF8Y6JU5rsARVawtMP8uggZJsWvV8a7Ho16q5Ei6WUc1ZOtD2a7SYTOLyIEjkfJzWjh3JluJYmMq0syzDMNkm44CIdrSwASTTtXoxIW3jCybbnbMX0P4tKixpFxhhPXo9e9qOz2IynVgGRA/muTj6A4nK7V0kDQ1H8LNhnQqnLuNnpDSn8r66BbEvyIh2rxt6oaK5L6oSKhhX19M6WJYLeIQwlKLHV8CifpZR3EkngIW9OQBVKGF/W9OJHEh7dz/3T2E4T8YCMbwVcHuvxW5BKOZnXSDgzKf6Q3ibXgdc28ji2pxYGRMgAxuz+C3PY/+RkSgBPM43t3KbrV5ice0fzdsLk3g9i52YgnhtA49p2iX2I534nQokBBwGLZaQHNsL/agoBLyqsyAuy+XIgnMLLB9Tnmd3BiA8wqkmWdstAfYWjd/KIAjzHkOA10e9QSRlRriHUAm6dxyoyKXy0+0zS2J1f5/yGYCh8CeZvL2LCqxxppg1ogfznCQco4Xx0gqg+9eWg49twVb/Z0EC4BrEdEGtisS0LIdJoEYirAigKhjZgWMIyvN4/TQYTrWxw1u8bo58z/lvmwyLMEbbaEkGsHQQ1FOOo8Q5FJ4uUhSVqxGXUYyf991CQm4ZXu5cAwdeqA+/a/PhsvInWluvrGCfo/F7ILgJMOgvCDe9gIp7x6GO6vP3JP6VZgPHfgFO/mpyP7iHcEaZf337tmYHHHDgkfDYn6SOHTtizpwqZrc48K+GEIIqe5w8nfmHI8BNhsXPtIDC6rFNwz3xcpeakEkennhYoCSbhTvApK5iM6KnruAq5MoxwE/RwB+tWDhVFABzu7BAtadQPAbc5BJ0rxeIwjI1XlxxAS8sO48dV9Mxo1vU44VsuAZyNdi6mHdyQ1rnX/H7qULkVxFG8aiQSUQI8pAj2EP+5MTKCCcFVao6fWgd8qz29xArgAWpLSJqRHkBm9Jbvwx0/5xN7M4+LET3fMj+pfXP0lY2bJmljVAkYa+PZ/jD7YvCF6hvI50MoB3IWrnT6biCn3WNv0cPAQ7NpEWt8VgO5p18gIVfUTqvjZDm7EkaNJdzeVaO4gyihb0BnYq/GwMWNBWMBt/+BtDjG9Prxm3jfbV6VbYpnfiNKqP19Sd2Avr8bCANht+rtWGP0eFv2Rez4Xn2RRUmk5z51eYA58Zj2NtkTqyMUJdThUi7wGS+I98BYmda9IKbs/AuSOA5HjyP1jFra6lOQwti31k8xlteBlaP42fdxYeKEgQMKwhpxvcHABmXqHrKvSyJlTlubiVxuLuf73H1WB53tyBaIat3Jjls8wrtlWsmkFzo9SQSt3cDi/sz4c6eRTW4KdWTXMNoBGVx5UHXfvVIpP2jKz8/oD6Jqi3otOz7GrvRcvRAUGOqhlJnWnmbTqTdstvnTOYLjwUOfEnV5u5+29sGOEDbN4pEQl1GYlOzW+XHhbbgsXf2Bva8z9+VxcDtnfx8CuyUKy6+lgqeEYGNGbyiVfH5Cn8uIJgrjCUZwPxugG8dIKo753/ptLTrpp0jufQIBbp8TBXOFjQVKL+0Hj/siUNaQRm2Xk7H0D9P4OidXKTkl+PnfXfgX3QFLqd+pMUx9y6JrPkCS+p52j87fwjZmT+Ql2t/RtZjQ69nv+fxny1t5YUpwMI+lYeDO+CAA4+Nx1au/Pz8IJM5hsI5YBveCinGxoTjZxtzkgBgcFOu0ItFQjQIcceuV9ridlYJMosqUDfQDYEecvgoHlN/KUhi4ZRxA2g4h2lZvtW5OmdcHZ7b2eTfV5VyFTj5FNDjSxZcEjnQ92cWZE+ItIJyjJ57CqkFpj6Vq6lFGD7nJDZPb416QbZnxdmFSAxVcAyKxx2BNG4jXAtuIt+vBbID2+OVnbm4np6FrvUC4Pm00xG1atqOSrMACEkUFAH/+aG/j4oHpifaWPXOvEKVxNhblH6R/TVdPgVevMDfRU60CSn8eb08DCTOQKf3WMjcO2i63TUAGL2OPTpajemYlmUD5xeaHucWxJCGhGO0hp2dT1VEq2Jh3eYVFsiJJ2i7NKbCAVSiTv5e2b4GsIekPJ/Ewxg2cnMbw0cGzSHBi9vOAjekBW2To1ZTrci+yeK9bj9TUiHASHiRjEEUZWZqll7PEAj/uiSlpTnsCTu/yDSnyhrJp7hvQc2pdCp8SHjNUxrv7KPK0ngMe2SsyYRGSYJ2dr7pNnUZU+3KC0iQWk2nBbDUQMavbeASpNFCaQvG4b7mfUnZN0mYRq1iFLiLD9/brZ2252CV5wMJh5nGaFQkjQhtQcXBLQSIHgqEteL1EdwMWDWSry8QcoTBypH83jr6I62cAElwRDsSWnsoSKBVr8c3nNskcSahXDWaASmBDfn73X2mY97uDRJw95Cq57iJJLThOSlIbje+AHR8h/19F5fx89lgGG2hJ37lSAC9nsctegiHDl9dz0CUM3Mrb7/D25XVVamCiuHGKfy90WjgtJ3FYI0SuLuXfZPm57B2Pw5SPvoD7bGNRjMGfu9HlTbhlnsZhbpOuJNVik+2XLO478UYbzifMPQQRg9hsIYt5MXzO0Wvw4WEHLi4eT9d50ZxOnB4pu37lEWcreZpR/l0wAEHHgmPXRV17doVBw8ehF6vd8yzcqASxCIhRrQIxb4bmbiaZpkG+ErnmgjxdLZ4bLCnM4LNbntslOUxlSvtgsm6AVC9Wj0eGLGCTf625ixlXecfdddAFlWd3n8q5OpMQp4FsTJCq9Pj251x+GVU40e2gOQqgU7zEtAguAN8Xbsh6Wo5Lu809ZhsupiG6OBHJG1VQVnM+TRbXzEVh3JPqjYR7f8+1elpwC2Q5MdeCIPcSgEozWFDvK3H7/sYqNuXhdvjQFnK2UP9fwEqiljQuvjyJ+EYo8fdQ9mg71mN16PxWvWvR1LT61sqIoUpvM6NZKkwGdg2g4N2faIqB3AENbI/wBagMlOrFwmYXsftludSKWv3JkmLWMYfTQXVPbk3r4Okk1SUhi/j7+X5/OwUpVoSKyMajWaf2vrJ/Gw6uQFNxlORXT+5cu+Tiw8LQLVBTbu2wXb8/bX1VLe8IisP1hVLaf0CeIybTSQJM6pHUhdaBBuPoWIZ/i6QcxvQPURctq1+O52G0etyTyo8QxZQnbOHO/tot1MVM71P5g40HscADWUx4ORCW6qymOSh+WQS8mVDaGW9tYPXxNpnOAy688em/ciJI/G0F97QcCRwYRntravG8Ph0ep/nD2AfnDW0aqpYEjkXWS4str3tegOpRqnKSdaHLmR/l5MbSaFEAux4y/RaRji5Ufn8rQV/7/Y5wzfOzmf8vX800PFdbsM8fdQnit9L9w6TsKWe53e6iy9n0kldeQwvLWcPGMDnu5r1Hck8gGYT2AuoLOb9SSeZXhgzFThtacks8WmIzDsqFJWrodRYLg40CpIDZw1OCKGY17E95N9DSdQAbI4rRbO6D58kqNLoUKJUQyYRwVlqp6wzLo7ZQ+Y1+/c54IADj4THJldff/01YmNj8dxzz+Gbb76Bl5fXg5/kwL8Kge5yzJvQHDczirDlYjo8nCUY1CQEwZ5yuD8te5k1ynJMK7bWSL9IT729pDqAf2wDooHb6fTaPyH0ej12X7P/B+3UvTyUKDWPTK70ekCj1ePUvTyb96s0TzniN+c2G+nNUZ5Pi9nzx6hC/FPh4s+idYudwACFVfN4eb7twcIAoNdBn3oBgkcN3tDpWKBdWQuIRAAELB7r9uN8pb86WVrizi+iAlFvEFBvMBMO6w/hezAqEJ4RtCudnW9JIg5+CQy0sUqvKmPBbt1XY4TciwRs1GqSl5DmDNhoGMsBxcYeK49wxrUXpQF7P7Dcxr5PqHTtMPSqmFuN3ENMQRrO3iSSxoJOWQSc+AVIb8Oifvf7ltttOBI48gOVgxpdSXLt4eJykrC6/amI3NpJQit1JdGI6kFyd+R7gwIp5XlwDeSw3du7qeSYOz2zbtCaZysxskZXKoW2kHbepMqV5Vbdyyn3pDpYoysHKju5koxoVVRszi8yPVZVwpj2slxg0h7OMDtqsDJWa8Nzd2k5e9n8ajMYQqNkwMOudy1fN7QFVbAbW2ihBXhMvKvb31fXAF5LBcnA6T8ZshI9mEmQ5vCsRoVK5EQL3jzDnKmA+iTnpTmW164RIgl7Ic1Vot3vk6j1+YnKmkTOnqzE43xfYjkVPa9I4ORsxv4PnM0Ye/cQ2n33fUp11cWX+1V3AANGAhsB+fGcLRbVnWR12+uVVcZzC/n5OGtGJMUyaGv3RVepxKaNvVgvgyawMcTF6QD03HdbNkYA8AhHtnMDXDqUbHdmozlUGi2S8sox/+g9XEjOR4iHM57vEIkafgq4y60Iv9iJx8Ge/S+w4QNfzwEHHHg4PDa5GjNmDDw8PDB//nwsXboUERER8Pf3r6RiCQQC7Ntnp3nVgf95+LvJ4O8mQ/soG/HSfwceRIiURVyVLM+3fb/MnWlWQtFTUa0EAgGCPOxbxrxcpBA9hvLrLpega11/bL9im7j1afgU059UpZapdObQ66h09P7BlKz3NFCez9cVCEmORI/ZewdwFlC9gYBPLc6qyrvHAI02bwAXUh+cfmcFlUYLvVr7aP2ABUns4dJrgGub+b7q9KNVZ+c7tnuNtr1G9aX5JFpZlw+1tDjm36PKM3IFhy8bezgKU9iPIxBYzpS6vtFAUuycyxqdqXpoKmi18q1NxWjVGKv3kggsHcQi09rGlx3HorSfQSExqmoNR7DAP/4L+3Vc/Ei0moxnSIBRnUs4yrAT8wK00SgWuX61qa4FNa7a6qnTkixte40qW0Q7EmipC4vqJuP4noz7rVWR9KaeZ8rioa8rb/Poj5yxd/ArS4IV0R5oNwNYMsj2vij8Td81t3axT85e71OD4VTVSwz9oQH1mfDn4sNhyLZwaRnQ8jkABsU9LJbK3ooRpmN0dx9wZh5V++pdgMmxDPBQFvPx5fnA5peAfrNMaYpNJwBJp0nured4AYzNhxA4a7DpHfgC6PIJe6lubOb3cL1B7Ms6/Rcf1/sH0/YyrjBUZcRyYHE/03sGeE31ncXFgLjtpts7vM3v5/XPcYFB7snPRpNx7OUznk+3YD723ALg1m6+xo0tljPiSrO5z82f5TUY2JALb92+ALxrAr80sm1PBbjvnoYEW9dAKPv/jnf2FeBKRil+HNYIrk5iFJsFNO29W4rIFjPgdXsnldFGo2zbG10DUeHXCJOWpuG5dpHwdX1w28XllEKM/Osk1Fp+zm+kF2PPjUx81LcuhjcPtVSxXAMYl79xauUNOXtZ9ts54IADT4THDrQ4ePAgrly5Ar1eD6VSiZs3b+LQoUM4ePBgpR8HHPiPQeZuv/EZYHHVdKL9+yPbs7+jwUjb84YeA0Oa2p85NbldBHwfw1fv4iTGjG614GojNKRDLV9EeNuZt/Q4UJVWjmI2R/YN+yuxjwp1OZB6wRA2Uh+Y3YY9D0XpT7ZdmTsLvWFLgEm7WSjbW6mVe9CCZwsCAdKc6yAp7xHer7ocKEkHdr/LYIfMayzQDnzB4JWqggZSz7G4vrzKNqHQqthoH9XTdJtICpXIGfo6/Swfm3CUtsKw2MrbafMabVRGO97Br6kenF1Q+bEAVZC4HQyA8I9mP0zDkVSkChJJBk7/ScJXowtViLUTqeTo9VRIDn9LwtfuDcttFyQzXGHMBuDZvYAikOpEk/FUDtzDgfpDmYxnK6GxRifG0RvDLS6vYiEvceacpxO/2S6c8+J5ndtKbKwoANY9y2J84g7Gr0/aQ9JeXmj/+m/2DHDFoObotdzf+kMqP675JAZymJMMn1okh+oyAHYWYHRavv6dPSSwLZ8nWbe+VjQVJJtCISBRAI3GkOgUZ3CxYcg84NQf/L3/b1QIPUI4g2vsBs7hkrqYeu3KC0hGdFqec7dgErPd75P0+NQEvKrR0nfmL57zbTOoGBrR4R0S/d4/MK4/ejDn3I1aRSKaecWU2lizK7/Xd75jUm7L8zke4O5+Ps+IolRT2Mf5RfzsW/dkGXF+Ea2QJ3+nLVBVwte1R6wAbrsnw1/UI9di5E4dtl/PQXJeOWbuisMHfevCXHRacToZqeJgZA9YQXtlWAyvG/NFNe/qKBiyFn2W0849qEkIRA9QrrKKK/D6mkv3iZU5vth2AznFyspPiurOmXPmQ9R9ooAJ2xnc4YADDjwVPLZypbMVfeqAA//fUPix6fvKqsr31eptsINMZtN42gXL+zu+xyb+eoOBzh/YHwj7iAjykOOLgdF4f+NVCyGhc20/9IoOfOyexQhvF2x5qQ0WHL2HfTezoHASY1KbCLSP8n26jdBSF87YsRXjDDDCV/KUeq4yrgALepiKw7Jc4MDntA4Nmf/khFfmxh8AUNuJQ3fxha7vLxAu7EkSYYai2Lex+EoZyhCPzwbUh1T8EOtTyhIWgLl3K9+nsdMHdv/+CvYRWl+r5si8SvJigKreUHx2IAtvt/8ILiIJLX46Lfs9bu9m5HnuXRI3kYSF9K1dLEBDmlNdkXvQGpZ9o/Lr+UQxOlruxcG7iUfZSyR14baL0hhgcHEZe/G6fEL7qC3E7SBpMh/E66SgQpRzi0V1y6lUF4szSbjEUhI2rwhawDKvs1Ffo6QlTlVKxSPnFtDlI2DTdG63ooAqlrUtzhzxB4GmzwB3bViHKwpIEjZNoxLpFkxb5u3dLFgPfGFJalo+z3NnnOkU0Y6R5m1epZqSdIKEISyW1/X87qbnetdgjH1xOknE8CWMtD88s3IvoE7NcxjUhMqhvZ6eEoPKfWcXlSxlEZMM275GQtt4PNC7IfvDdrzFeHWNisErcg8mHqpKSdJz73CxYvhS7l9FIQlVylmqfDoNA1fModfxnDQcAdTuQzJzZQ1/xm3molbmVZJynZbkrfE4Lq40Gs0+SFu4uo5k/ORvJqVWXcHrXafhd4i90QdaNd9Tg+H87g9qzOMSFsMeK2sIBOxHOzMPkA3A81szcT7JlER6+l4evF2k2PBCa6w5m4xbWSVoEOION1dX3NE1x/U2SxAsVMIz5h3IWr0JqSofAidXFAg8cDHfCbPHhMNH4QQP5we7AArK1EjItU3qNTo97mSVIMx6kc3ZG4iZxmCNslySLBfvytZoBxxw4InwD4/5cuDfjPTCclxJKcSe65kIcJehX8MgBHrIK8W2W8DJFej2KQuwKxt4m1AE1BtKi43cgz8jV/IPfdwOrrTW6sVCR+zEQucpWAKNcJVJMKBRMFpV98GxOzkoUWrQpoYPAt1l8H7cRERw5lU1bxe817supnWqAZFA8ETbswupC1f8b26xtJkBPLYtpzwdS2BZLvsfbCk0CUeoiDwlNfFBKPGsg7JR++B+aS7k6aehVQQiq+FUbMnwwoKzGYgOdkOZUgPpw7xvTTkLN1soTKH9zp4yGNyUx90j3P4MJPcwk+IR2BBo9zpCzxUgKbcMdZzcqNZp1exHub0XmNeVgQgTtgH7P6OSo9Owb0YkJbEpTgfav83XNY4lcPFlmEZxOlWuvHiSLLdAoHZvEsEzc2mZinmBCkP6ZRIg64G+5si6zlXz3Lt8fYWfKTHv3EImxY3bCKRfAQKjgSUDLAlEZEcGaWTHUekw9tbl3mEfjpMbr2GpC8m7s5ftGV0ArVNyT9vKZVgsBSRjeEJBIo+NbxRHO4xcyd5EvY5k995hYO+HJDAtp3DfRE4MCBHLaPuDnnPM/OqYCEBQE6DXTKYNGnugABLHwfMY5a5Vseeo3688Fjc2c4ZUw5H2j3O3L2j/Szpuuu3KakbJj9vMwdErRpIMDllAG13yKdNjT8+hBS8slseoIIkWPXPVrnZvKl/HfqK92ho6Dd+fRmlSoKQKJhRa92vdO8zXM6pWtlIWjago4piE7a/R8qfwN1lNHzRUvaKA32PX1lNV3PMRU2PXTqpMVNu+DlzbAH14ayATaBLmhcN3Ciwecim5ACn5ZRgdEw6lWgsvFyn83GQI83JBprcz8svUyBUK4OkshYthEcwHQJfAqnfzUWF3zU4iY0rnw46PcMABBx4Zj0yu4uPjUVJSgrp160Istv10tVqNGzduQKFQIDLyERu/HXAAQGp+GUbPPWWxMvfL/jv4enB99G0QVOUMLbgGMFI49hXgxDXguUOAeyBXxM0f4xrA1eT/AFycxIhwEiPC5yna9QyQioXwewh//hPBuwaT3La8bOohcfEBBsxm0/rTgLK4aoXmzv6/vy+goggozYGiOB1qnQzx0dMR51OK23karN6cj9xSrv7X9FNALn3IniuJs32r6pm5TEFbPa5ygmWL5xgNfWE50O9nDgnW67gtVSlJUcZlFu4JR1kQO7lBKtBjcj0B9C7uwLGLltHjRpTnGwYaO/F1a/UkOdr/mekx5xcBXT+hwmKc57XjTctktssrqdDIPFioNxhGO5tWBYTGsOD3jqzc/2UOJzeqMUIxkw5PmYVx+EfTmlZeAATW4+Nq9wIurTQ9Jv4AlVW9hj1L5siL5+e880dAyjkg7y7QcBRtgrZQpy/tczFTgQQw9lyo4+1iGa1tAPdV4UelJqINlQ+xjI939iJp1mmAZ/cBN7eTbLiHAGPWAokngQOfkZg1n0QVQVlES7JWzX60Bd0rE8CEo1TL6g9haMeA2VR5Es3IUvQQ20OqXXy4YGROrIxQlzEcI2Y6iVVoC6YLmhMrI84vZlCIVwSwqG/l17m5jTOjhi4i+Ry+lP1OV9dy0cQ3CsiKI1FrOILfHfaILsD+oHZvcoByVZC5cVZb/9/5PSF1ZQ/hnX08zt7VbSvHXpFU7RT+fPyFpbQMl+XS/qguA6DntRPSFLh7ALizF7mNXgIy41A30M1icxE+Lviob118tvUG7maz/1cqEuL59tUxvlU4AtzlCHC36sE1DrDX6wBnT0vLXhXwcJYgwscF93IqB9SIhQJU93t6C4QOOODAo+GRyFVSUhKio6PRrVs3bNy40e7jJBIJPvroI+zevRu3bt1CcHDwk+6nA/8ilKs1+GnvbZuWh3fWX0HLCG9EVEWuAMYWe4YDuMY/4JK/KZ3w3wInBW2VwU25MgwBlQzXQPZxPA0IRJb2MGtUlbT2NFCSRUvU+UUQ6nXwBuDtEQ7PnvPx2+kS5BoGMwsEwOS2kXB62EALZ2/am3a8Ufm+vHiSrymHqWgkn2Kh13YGlY1fmgC9vmMRv+dDk0qg8OMCgl7LJDupC2dONZ0AnPgVguIMCEJbQj/gDwjWTDDNnjKiZjdAo2YPUdx2Kh4bX7B8THE6+8M6vENF5vomS2JlxKnZtLkd+4m9WqEt2UeVfIoWwsQTQGQnBitYQySl2tZiCq1YmgoqFQlHqIrFTCPZKTUMVRWKSSa7fGKZJHd+EdD3J5KOwIYs5NPOs6juO4uR8jvforVULANSzlj2ugkEnGGWc4u24k3TOSMvuAlQsxOwebphDpGExyOoEX/3qkHlDkLa2LRKEgedDmgwBFjUj308RlxeTQVp7Cb2Brn4kACknWN6XmQHJhXaIxzXNgATt3MQdX68JbEC2F/W+hX2s5kjqAmj/u3h1i5T31LtvgyDsIdLK5myZ89qd34hr6dTczi7q8EIDmm+uY2pjS7ehoCXeKZ4rhzJviixUyUbLrRq4MISvp69tEYXH1pUi9OAiyto0fwjlsS1+WSqUoPnM8a+zCxd1dg7te11zodrOIrnL/8eSbRxhIBUQYvknX3Q5dxB+egtSCjlmAu1znLB4I3utTBj9aX73xUAoNLqMGv/bfi7O2FUizBLG3hROhWzM3P52a7Vi4sJHtUe+L3q5yrDt0MaYNRfp6DSWrZpfNCnLnwUTzFgyAEHHHgkPBK5+uuvv6DRaPDDDz888LE//PADatWqhT///BOffvrpY++gA/8+5JWosOlims379Hrg8K3sv0UBcuABEIm5+m6r4f9pwNmHjfO2ktEEAq4s/13Qargqb11UFiQiaNNQfNdzMwYuK4XCSYxvBjdAtUcJDBEIgDp9uP1Mq4j30BjaAt0CaadSFZNwOHuzl6juACov1j1LJVnAhinAuE38d+xGEqy/OpgeE7cdguOzgPGbgZN/sqgNjQHk7oBAzAL32lrOHRIILUmAEcd+plLR8X3LbVsj/gDJUfxBkip1OdWYGp2Ara8xiS77puUsI6GIRbdETqvu4v4kVzU6A72/5/teNdZy5pVOQ8Wu50yqVVnXebumgipE/9+o8Igk7G1yC2axfGklAzBubAbC2/L55QVA4hGqHDW7sNDNuEqLYi1DQMiJX7kwU7MrU+8GzmHE+cGvTPskc6dCA4FBzVHRvrdthu1juvdDYOQqLk5seckyGvvGZiB2uv3jrFUxBMUtGNhnY67UtQ0k5oPnUdXKTwT86lG5O2/j8UaIZSZ1VSKzvd9GVBRS4bWH0hwqhF0+Yu/W+UUkLR3fB87N5/Fq8woQ2JhK0YiVJOAd3q08oFcoZuBFRSF7YjdPN9lUARKfvj8b7J4+wI2NTG9UlfDaPfYzHzdiOS2UxelUsLyrUyHc9R4VNmcfKq46FTCnvaU1WVUCbH0V+vHbkNcgCF8fzEHtYCF8AbhITAQo2EOO3BKVBbEyx897b6NLbX/4uxuUqeIMXt+pZ0wPOjuf9sjJB6qOwjegQag7drzcFguP3cP55AKEeMgxpUN11PBT2J935YADDvzteKRP365duxAbG/tQVr+IiAi0bt0aO3bscJArBx4JWj0qrcSZo6DMjrLhwH83pHJGKCefqGzh6ffr39t0XZJhf8BqWR7qiZKw7cXW8HB2gp+bEyQiO6vKOi0LT5HE0obqFgSMXg3EH+bKvkBI1Sgs1qB8gI93UtDyV5jMQrBufwYE2IJWxajpmj04xHXJQPblRA9hAZt1DTi/BDj8PdD+LSpfx37iCoVPFPTdvgD860Ow/XVaCu3h+iYqUdaDfc2hrrBM7ru9h69z4Etg0F9U5YYsYCGbcJRqQ1gM0wjjtlOxGTyXUfB39jHNLvWC/dc8/SeT+HYZbIAD/mDynHlv24nfqHw1nwTETqOSlXQSSDkFOHsA6VdJPBR+JkWjdi/g95ZA71+AFAAd3gOgpO2v8TgqQ7f3WO5LRSGwfDitcEbV1SvSvsVVp+W5TThaeeZQcYYpIc8WZB6AupQqjb2h2Ee+Z2BE7It8nYJEEpx6A3ncbCF6MEm9QEiVNLIDVTZbqNWz6h5Lv7ok0hunsldudltuq+VUEhrjIOuYqRw8fHsXe74EQtp+T/5BQhzYiDHz1zZSKdz3GS20ymJDqmMo3QmHvwdaTTcFV9jq2Tw1m+/p7AJ+Fm9sMfV8BTYi8Y7bxj4xOzH/giPfwce/Hj6OjsUbZ5Xo4QXUDnDDn2ObYtWZZNQJcEVGkf2AmqxiJZRas21nXrUkVkZUFPI99fmeCw9VQCoSobqfAh/0rYcSpQYysRDOD3J1OOCAA387HulTeOvWLUycWEWMtRUaN26M+fNt+P0dcKAKKJzEaBDijssphTbvbxfl+x/eIwf+Y/AIBcZvZWRx3A7aDqMHsSAyJytPGxql7VlTBkjz76Be3d5VbyM/kUVk3DaSm9jpLNwUhuvVLQhoNIIFvEDAHhiNihYyoZBqVPolKlBbX2UB2edH+ymNAAlU9y/5vIGzmSh38CsO0w5pTgVI5klLlPmKf84tCFYMY6y4Z6ShsG3GwtoaCn8SxuqdmYxnCxHtgJ1vc4ZPnX5UHARCqhgpp4E+P/D+phNImBKOMAXO2IcVf5AE0dhPlH6R6YD2kHeP1wbAMAhNhYlYiSTcHyd3WhFr9eBrGwcWA3yfvb6jEmI8vlIF1ZFhy4CsWwAUQPp5IPcmkwAHzrFvl1OXAaVZJHOnfrffX2aEQGg7jU5dRgtkQAP201mj5XNU4ap3Zqy2vSCUoEbso0o9b7otoh2vyRO/Wj7WK9KUbDjoL4ZejFjGz591iIRXJODsC0BH9cxciTSi9Usk02W5VAJDY4Dkk/x8JRwm0Q1qCiwbxMeXZJKU5icYwk1CgMAGVJIgoFVOWcgUy7XP8HPkEUYrY148bd/qMipMIS14zTWZANzZbbrm7x0mQW7xHK+78nwqp7V6A61fZhS7zI2Kmz3k3gHq9odiw3h8PPYgTl7Og0avR/d6AehQyxcCCLD3hv1r1kchNS3K6PW0MNrDzS1A5/cfSK6MkIqF8HqacwYdcMCBJ8IjNUuUl5fDxeXh7TDOzs6oqKhitdMBB2zAy0WKj/vWsznno1V1L4R6PqXYbwf+mXAL4up4v1lAx3cA31pPNb3RJsSyqhUD/+iqn597F/irI2Pj0y6QLCwbAuz92NS7YYTMjcXd2fnA6rHAznf5/C2vsPH/3AJT0VyYyohre/CpCX3icSb0XVwOHPmOxapOy+J99VgWns4+lePD9Hpg3+fsOzk9l7YsN6v+WCc32gb3fGga7muNsFhaANu/SWK4agzf+9JBPB7V2jK6Ovk0j/PlVfy/NQG5to6v4R8N5CWQINiDb20GEbj4sPfs9F+8vdEoWvQ8IxgQ0NgwADmig+XzO73PWHRz4qoqAXa9w2jzy4bAjLgd7FfT69kTVFViXdYNwNUf6PMTybJPlO3HCQQkT4VJptvETlRWonoAJ2dTxavZ3XTOnFw5i0zmDtzZy36hiPYmgmkOzwgSTnNiBTDKvNkkpho2GE7SMmgOCfji/sCi3tz2Mzv5PsdtotolduLrNnuGIRo6FQABMGwx99kI10Ba+JJPm3rzUi+wbw3gNdlkPNMJL68gQQSodImk7K06+BVtccFNgAuLgDntgHldOCRY5g70NVj7kk7yNfzq8jUPfElC3+VjKr/ekUy/HL6UPXhOrrT+Ovvweh+2mEqjiw975a6s5mfNu4b98+tTk1HtLj5wT2OvW7mKSpSTWASpWIiGIR5wl9vu753WsQb8jcFDAkHV4yvETrA728wBBxz4x+ORlCsvLy8kJyc/9ONTUlLg5eX1yDvlgAN1g9yw8YXW+HL7dZxOyIenswTPtI7A4KYhT3eGkwMOAOzvafsGQw8q3RfIYt4eVKXAga8qkyiA/WMtJrOHyojcO8D8HlQohGL2g6RfouI1dCHjrY24tBzo+ikLVmuInYDqnSDYOA0YsZSztKyh1wN7PmCKmrKQr3PkexNJSD0DQMe5cEnH+FrqMgY7uIdSqZB5AKlnSZSGL6WtK/4giVfDESQRZ+exWDaSHCMKkkiyBvwB+Ne1rXQYoVUDqjL2DFUUUvVzcrM9t6n925yh1e0LBqFUFHIorm8dWvSMuL6RZH3YYlrQlMUkb2olMOB3FtwiCe15x3+hVezglww3MMs+gNSFKoJHGN9TpXMho5JUUUTiIxAB3b8igbNOgWw+mSqlRzXa31o+z6TAu/t5LdXpC0DI0I6m4/l8vY6k9OgOEjOJHIAAGLOeQ3pvbqMSEz0EiGjLWVxG+EfTgqlVk5DotEDrV9lbteUVzrEy4tIK/ozfwl60tm8wwCP9EvvBFvbi/rj48rrt/hVthxol+wXPLrAMnfCNotoZ3JSLDge/BEasoGVwwB+ccdXtMy42GFXRrp8xZMI4HwzgZ2Xryzxn47czGVIkJaHdNoPvcfg7JPHmPZtObiST6lJA7gOUZQPLh1mej4j2/Jzc3s3HXlha+ZwBVF13vw+0nAphYRKAAAitFgCDPGRY+VwMJi8+i5R8WgRFQgEmtqqGvg2DLB/fdByvSVtoMr7qxR4HHHDgH41HIldNmjTBnj17oFarIXlA+ppKpcLu3bvRuHHjR9qhr776CuvXr8fNmzchl8vRqlUrfPPNN6hVq9b9x1RUVGDGjBlYuXIllEolunfvjt9//x3+/qaejKSkJEydOhUHDhyAQqHA+PHj8dVXX9mNj3fgnwWZRIT6Ie6YPbYZypQaCIUC+CicHji13gEHHgtCES1pZbnA8Z9NqWUBDdgr5F5F4ml5AXB9g/37r20wqTAVRbSoGdPv6vSjdSn+IH8XCC3TEovSaGHr+imtVsagAdcAJq0d/Ym2w0Sz5DtrZN+kJSvxOBMXR62msqQqZQ+Msd+oMAVYN4nbdg8BSjazcH7hJBWVWzuBVaPZnzN6LZUR7xpA9nX2zxhjyq1RUUg1zas6SYI1hCIW/E6uJEwbpgDPHWQBPvgvDv019uBJFQyqSL9g6kWLHkxyUqevJbEyP4aHvycRPP0XwxQyLzPNzi3QMANMQgvmrnc5L8sjlORK5gG4eHA48t0DTHLbbpX6qPADBs1lUX5tPbcX1ITPmXyANrS0izyuLaea5mJ1+5wDmIUSzpcy4uJyEsvuX5Ac7P+ctjqpwtRDZkwTvLaeRK3dGyQbbkEkD3odCX3vH3gO7+wlAdSUk+A6uZK8mBMrc+x8hymLczsBTSYCzSZQpfKM4LUc0JAEJC+edr5d71TehsSZquaZv4D+fwDLh/A8n54D1B/Kxzx32GCRNFy/igAuGpgTK3McmsmByhoVFb7Q5kD7NzjP7PgsftbMoSziNTtmPT9XcTvYf3joG7P9NKhJOg170gb8wevA+Bl1cgM6vsvrvTQb8K0FgSIISATkVomhAoEAdQLdsG5qK+SWKFGh1sFbIYWPwqny+BDPSKDpxMpWU58oqoSiqmssBxxw4J+LR2IaQ4YMwY4dO/Dhhx/iq6++qvKxn3zyCTIzMzFs2LAqH2eNQ4cOYdq0aWjevDk0Gg3effdddOvWDdevX79vSXz11Vexbds2rFmzBu7u7pg+fToGDRqEY8cYNavVatG7d28EBATg+PHjSE9Px7hx4yCRSPDll18+0v448P8Ld7nErs3CAQeeKlx8qJo0HkOrkFjGFfoHriA/oL/G3P5WnsdC14g6ffm73tDoXpBES5d5dPqp2UCNLiz6nL0MaW0FwOHv2BRfqxdJiT0IRVQ6bu9mKp/CFxixytCP1JPFbe8fGAeddZ2hCsWc5wWBkMV/61eoYiUeox2vIIkktCCJts1e35meYwu5d4GKYhbD/tF8neaTgBpdSfIkMhbjWg2L4MurGZ+dF88hyOpyEsuKQpIY896v1PNUHAqTqULcO1jZcnh7F21gaRdYiNfoQmKrKiH5UvhTHez+FSPzizMABAGtXgICarPXpzyf1ryun7GfqSyP9q7+f3D+mzkhSDtPlWf0OqDTh0DubZIfnYYWt/J8RsrXG8ShztZIv8gExoajgc4fkLCVZrN/bfcHJCfnF9Hmp9NxP0oyAL/afC8lGVR5zIkpwONWqxf7mdJt9HQZkXmV143CDyjLohUvsBEAAVMHy/MZ8BHZgapu7h2SBCN5dvHh8VaXMyXw5hYTiU85y2OvVVMJavUiVU2BAOj/S9WR8fkJVAUX9uICyNU1vH3EMqqUtlCez9f2iqTNMe8eydatXbzPyR2o0Y09Wrf3kLh2+4xkVmhISC3P5/+jBwEyD+hcw4HE23ade/7icvhLcwBhBSDyAMQ27Jsu3rSnNhjOz56qmLH1YTEkyQ444MB/LR6JXI0bNw4///wzZs6cifT0dHzwwQeoXt0yLvTu3bv4/PPPsXjxYjRs2BBjxox5pB3auXOnxe8LFy6En58fzp07h3bt2qGwsBDz5s3D8uXL0alTJwDAggULUKdOHZw8eRIxMTHYvXs3rl+/jr1798Lf3x+NGjXCZ599hrfeegsff/wxpFJH46cDDjwOVBot0gsrsO9GFuKzSxBT3RtNwjwR5PFwjdeWGytjERh/iIVjRDsWQAq/qp+j03Dl3bqH6GlAImMCmWe47fs1KhbkErmp2VzuSZJkvWpuRL0BVq/hTAudkwLwCCfZCGrEQvTuftqw1oy3JAh39pJQNRgBbH+dNivfWnztpuOpUhgVIGtE9QCurDUFJNw7zDS+0BbA/G68zTMC6PAWX+fKWt7mV4ek69p6EpAm40zESFMBDFkIbJxCpSf3jv2AA4D7enc/EFiffTE6Lbe7YoSpIPeKJIH0ijTta+p5FrbVWlPBkbqwGI0eBGTfYgiHsojDjSsKaYmLnUZ7pzmpML5G31kkbmfn0SLoFkQlQyCkHVJZRDJ3cg4gCCJpvXeYZMC7OlWilNNUDUVOvE6yb9lWWnRaqlZ1+/P347+QHBghktAWZw/nFlLtSzpJK6FrAI+Fupyfm+5fACI5rZ0nfuNigEc4MHoNUyLjD9oenGuca2avJwzgdSWR05oYf5CqZb1BTCm8d4jXZvoMILgZ52OFtwaaTWTfkpMrz9PZ+bQyDvjdkjC5+PA9aJVA/H7+dHwX6PoFxw9UtZjh5EYyXmkelqbqEJHSLMAjgt81zp5AxjVaPMvzga2vcFi2powJjmkXSICDm1J9zLrBfrX7yZVfQlCtE+A5AZ4yGyVUXjywcZppYLPMg7O36g3k4og5XHz4E9KcCyxih+XdAQf+F/BI5EokEmHz5s3o1q0bFi9ejCVLliAkJAQhIZx7k5qaiuTkZOj1etSqVQubNm2CSPSQgzbtoLCQiXHG3q1z585BrVajS5cu9x9Tu3ZthIWF4cSJE4iJicGJEydQv359C5tg9+7dMXXqVFy7ds2mVVGpVEKpNH1hFxXR569Wq6FW2xmW6MA/Gsbz9l99/ozxwlKXvz/U4QFQa3Q4m5iHF5advz88c83ZRPi4OGHhxOao9iizx1TlQPw+Dq41Fr6HvqedatAcFpLmKM1h2tuZeYC6hMVuja5V2/Ue9H4e5frQqGivOruAqoJnOC1eXpEkSe3eARJO0CJojnoDAYkbcHoBVZ5avYARa9jXUpYHJJ8HvGoCB74FwlsB1TuRRI3aCOz/jAqCkytQbzBJ1NX1fH7aeZKa0FbQK0IgyLoOdPuG/VXmRaZ7KND4GVrthDLT7ZfXMsLdyZOFbmE6sPlVzl+qO5TFq1sg5/C4+LD4XTrMMtDB2ZPq0qaXgIurgeZT2ZdlDbkHoAgGvGsDF1YyoS3jEnB1EyCQmlb/C9KAra8D/f4gga4oAUJa8pjn3AWaTKL169Q8KkjhwcCVlQxAMCLzJnB5HdD3F2D9ZNPQZb+6gEsQcPBbWsMAHo+SPGDbWwzjSL8OHP8dcPaCetAC4Eom1B7VqVxcWAokLDclPmbGkdDETqeqY35szZFyAWg0jv1LhRmmx4kkQGAznn97z1WrAbELUJoHlOYDGyabXV9rSab6/QrkJADKMh6/TS8D9YYArV8kcbW37WtbeAzFCtv9RS2mAamXSDKNKuqFlSRl7d4BjhhmXaZfBZSlwInfaemLHgCk7+Jxv7aRkfBaPdBgFFB/JK/PRuMBj0gST+P+Hf4JmLSH4wT6/gxIPWzH8DeeAKRcqvy+NGrAJcB0fAQCKmoiJ/YP+tVnmqeqAii6AYTHAhAAdw7wml4/DRi+FPr2gE6jgkAogDD1AlBaCGyZAehg8ZqalPOA5wQkZuWjWoC3ya5elA4sGcJFBuPjVRXAjncBqbuJaNuEkOfcgf9q/E/UHQ7YxcOeV4Fe/6DM2MooKSnBt99+iwULFiAlxXJOR3BwMCZNmoTXX38dCsWTRSfrdDr069cPBQUFOHr0KABg+fLlmDhxogURAoAWLVqgY8eO+Oabb/Dcc88hMTERu3btun9/WVkZXFxcsH37dvTs2bPSa3388cf45JNPKt2+fPlyODs70ukccMABBxxwwAEHHHDg34qysjKMGjUKhYWFcHNzs/u4x0p3UCgU+OSTT/DJJ58gKSkJGRn02gcEBCAsLOzx9tgGpk2bhqtXr94nVn8n3nnnHbz22mv3fy8qKkJoaCi6detW5QF04J8LtVqNPXv2oGvXrg8MYPlHoaKIzfpnrJLXBEJg+DJan/4fcOJuDiYvOWf3/q3T2zy8enVmHrD3I9v3SRUMAjAO1009x6hoW2g2ibOJVCWcqXPyd6A8F6jWjjY29xDa5Wzgoa+Pkkxg8QDT0FFziJ2AyQcZgADQnqQspDKhLGWUtLqc+zB4Pu1+tlC7DxWqSyvYg5J8Bki/iIpxO1BakANPfT6EvrWA9c8CObcrP1/mzojpTdOAps8wobAgGVg/iS1htmZ4NZtENTDZbN6SSAqM38Zelrv72Z/U+UNg+VD7x2f8ZuDuQaqNQYbY7bx4QCSmTez0HB67+kNoa1SV2j4Og/4Cdr9H6501Rq4CoKfdLeEIr5GGI6hObH3FpFDdfx8SoN9vVJyaTaQVrnonhmTYw+g1VKOkLlDX7Ik9SVJ0TfgaksL4yo8VioHB8wAIAYU3sKCX7W3GTqe1sdN7VF+FIp6rne9Qlez7M4fmms+rcguh7XDby0CpWQKlizfQ+yc+t8hsUXPgHGDTC+wP7PcL+7+Cm1Atu7Tc9n4NnMPIeWcfJukVpVMh96tNW9zRH/g7wFTDbp8CayfS6lhvENWuG5t5f2RHxu0f+IyqaXgb9vId+rpydP2wJcC2V02BHObo9wuVyZzb3P8Wz7MPqbzAkFrpzuu78wfA/i8qW1DbzmBfWNY1BlaYrxtHdADqD+IMLzPoY6ehokY/XMoX44UNiagf4g53uRTxOaV4v2cUmqcuhuj4T5V2VS2UYU/9WQgLD0Gi1hc7r6bj0wHR8Dz3i/2h3wDw/DH7lmMH/ifwX1t3OPBQMLraHoQnjs4LCwt7qoTKiOnTp2Pr1q04fPjwfdshQAKnUqlQUFAADw+P+7dnZmYiICDg/mNOn7aMLs7MzLx/ny04OTnByamy31kikTg+IP/l+K87h4V5wKlfbN+34zXOobG2zf0HUKoGlFr7fU46gfDhj3NJGqCzMwOvogIQATBu68pK+4+9vBRoNZWk6uTvptszLgDn5wHP7qElrAo88PpQFQL5NggNQMtPSQrgG2ncGCAz9GIlnwCU+fx/YBMg7bT993FzI4v1CwuAW1uBugOAxIMoSDqHN69H4Y/+DeFSdA/IumL7+WUVgEgExE5l/5aqEHD3B3p+yT41hR/7X8wtdJGtgAvzLffJzQ/IvACcnMXfhWKgPMv+fgNAaQZw2BAUJBRxFtKdvXw9I5y9gLp9gGX92VflJGe/ixE+NYHiZKDIRsy5zB0QCYEVw0hUAe7T4S/Zc9X1QxIsC2gA73DAPwrY8gIXJhoMrvp9qIuBO4ae35vbgIZzIKnfH5LDNsKbdAA0Jby29Hqg5xfshTMv6MNbA0HRgEQMCAV8fxJnQO7KY9FkFM/ZsAXAufkMilCVAF0/APa8BRRbkYfiVGDPO0Dsc+wxA/i+dGWAQAcU3gO2v8LPg7qMPYy3tphS74wIaQaoi4DtM0iy1oxn/1WPr5mWF9QIiHmOxyD7JpB3k8elRkfOqFLmAaEtgWurub26vRiuUr0d+5SqteN8t3Kr1wWA6+uAkMbAjS2WtwtFgHsgULsHcPgKkHycP85egMSF77PT+3yP19cBIxaz/0ujZJ/cpVWAszvg6g2s/Ljy697dCYQ2BoLqAylnTLdfXIzjnv0xYW0iAOD4PbYhuDqJkVCgRsuwlpActX/NJBULUCjS4VxyMdZfSMcUn0gI7F1jck9e9/9Nf4sceGz819UdDjwUHvacPtIQ4f8E9Ho9pk+fjg0bNmD//v2IiIiwuL9p06aQSCTYt2/f/dvi4uKQlJSE2NhYAEBsbCyuXLmCrCzTCuiePXvg5uaGunWrLrQccOD/HRl2CmiAjfO2VIj/AKL87fd8+Sqc4PYoqY41Otm/L7Ch5YBNXVUeZyGDDMyJlRGqEmD7m5X7oB6EsjwgN54/ZXkkGFVB5GSKTI/byR6VslxTOhrAxD1bPSRG6DQsIAG+nqEPzUudgZ9jiyAvTnxwz52TK+c8yT1JXPLuskF/68vAylFc/W/zKh8bPZjXmZGsGNFiCnB+oeV+ObnaVf8gcTbtN0BlY8MUIOZ5y8CRRqOZeqjTknQ1m2S5He+aphALazQcCZyYVXlfAR5ziZyqjTnq9qcKCDDEYsx69ktZBwoYUa2tZdFthG8dqmS2IHNnH17eHUCrA6aeIAGInc65WrV7G64fKQfhbn+dCtPC3lQIRVLApwaHCfvV4SyyZ/cxnMRWEAXA4BC/uhwyPHwpxwQENKAqZ7w/oL5BHZwIDJxNFdMrks/r+inJr9yDZN6zGo9LWCyPYa3uVDPjD1D5HfA71dlrG4BaPfgaNbuZYsKrtWWcf58fGaZxdR2w530GjvSdZTtOXGQjUKr920wbVPgxRdH4mLI8Xs99fgT2fQo0GMZey0V9gGVDObB67ydA7Au8Fi+vtn3cAM5nix5seZuqBBKr8R5+rlJsmNwQbXxKoZZ5M/UwLNbmJmefLUKolzPyylSYtf8ONEEt2B9rC7HT2JfmgAMO/M/jHzf0adq0aVi+fDk2bdoEV1fX+5ZDd3d3yOVyuLu7Y9KkSXjttdfg5eUFNzc3vPjii4iNjUVMTAwAoFu3bqhbty7Gjh2LmTNnIiMjA++//z6mTZtmU51ywIF/FMR2mtCNEPz/fGy9FVIMaxqC1edSKt33QZ868Hd9wH6bw7cWi72s65a3CwRcQTdPDGs4kvYuW4h5nmlu9pBwhGRU7vHgfdJquFK/9VUmwgFASAug17emOU+V3kdtJsrN68o5UUZU70SbnkjKaPHMayy6T/xm+7XDWzHkAaBqdXMrAEAU1BieQhFw4lfGbzt7WZI2I1x8aIE8PJPzrADTUNkBs4GNzwOHv2WhOGwxi7zF/Sy3UW8gUK0N7WASZxLErBu0jTV9prJNFWAogsydz0sw2Lf1OuDOfmDsJuDId9xGWCvaAwHgzj6GWjR/lnHiWjVfy6+O7WMT2sL2axuRcAQIamyKZ5d7MgGwLI/v+eRvVJQajACGL6fF0dyu5lmNpHPtM5W3HX+ASYW3dlneLpaRBOlUvG4U/sCqcUCraVRuyrJpjxMIuCDS42vGbefcIhn0juDx2vk2FwFCmnP+VmEyyZg9VO9MVWrHm6brQCzj/ntXB479zN9P/kFFZ9lQkqEm43kdXtvAGPa1E0mMIjtwKK9OBdzZw3MV2IDjCI58R1to18+oRAnFfA2fmiTJUw7z2leVA0v6W16XKWeBml2Bzh8xbt2IRiMB1yAq78mnALdQErHEoyRmBYlAz2+BugP5uZXIaV1Mv8z3U3cA51aZK4QlmcDK0cD0s3wP9lCWW2mBQlu9K44kmebKucnE2DGxOtyOvgvJzY18ny6+0Ld9HYJqbXg9eYQhL/YjIAMI95LjfFI+tDo9ylRa5Ih8EDh2E68xc2U2eijJ6hMGfDnggAP/HfjHkas//vgDANChQweL2xcsWIAJEyYAAH788UcIhUIMHjzYYoiwESKRCFu3bsXUqVMRGxsLFxcXjB8/Hp9++ul/6m044MDjw7+eqSi3RnAz+6vvTwtaLVCWwxQ3Z5/7qoWHsxRv9qyNusHu+P3AHWQVK1E7wBXv9qqDxqEeED7KgGfXQPa4HP6OfSEaJd93z29Y3JnDJ4pF5d19lrc7ewGNx1a2GD0uChIZTa4qNd2WcpozdSbt4RBZrVUE9IDfOZDXesbT3f3AkR/ZD7b3IxbQ+fc4X8l8zhVAZaD1yyxgm00imTj4JQmoUMTC/vZubqP92yZLmMV+/MmC2Vz1NKpEYhlJ1uVVjMcOb8UhthO2M3VQVWKYrRXHXimPEEauK/z5r0jMwbddP2HRXpzBGOuYqbQcrh4HdHib6pNxIGpxOkleuzf5/mTugNyLtwPAttfYMzV0EQAB1ROhGDj2U+U4ea2aRb5xgLI1ZB6cVVScTiIRPZhK4cqRlgXu5ZV8f8/uZ+Jj5lUqEspi9mLZUoR1GksV1YguH1OtdAsG1k4Ces4Ecm+x30nhz+vi8Ez2eul1HLbc/k2ex2ptgYPfcB+MSDnDZMZxm3ldC8WVU/wEQh7zlSNN/VAAFdGDX1Glcg/l94bS0Beg13FRwHxhoCgVGLMBuLWDs72CmgCrx1oeK4mcPXAHv+a5qz+U56XH15wztXIY4F+f/XgVhZafGSNu7wEajuL5qSjguSlKB5YOovoU0RGo1gqQKEi43YKBtm/w82atUnZ4h8fm4Ne2I9d1Gg5fjuwAXN9U+X4ACI3hIofZe1S1ewfblpg+u9/2DITX5vEQmKuopdkQ7HwLmr6/InXsKTjLZXhtawqG+eeiZ/1AzFh7FQAQ5uUMkUjMfrHnjzIdtLyA597Fl+maDjjgwL8C/zhy9TDhhTKZDL/99ht++83OKjCA8PBwbN++/WnumgMO/Geg8KNFaMNky0JC5gFt318glHvam1355ChMBi4so6VKIOQ8pIYj7kee+yicMD42HD3rBUCr18NJLIS34jHVYHdD437bGQb7maKyvQvg8RjwO+ftnPyDRXbtvkCzCdyvyA72XyOiAyB7iKJGqybxsFUkqkp5TKad4sp12gWqHW1fZxFob3ju1TW0eZVmAXG7aEvq9AEQ1Z0qTlkeVY6Wz7Eg7vQBlZI7e1lIipxIGM4v4vYSj1MpGzKfxyHrOq1YLaaQwNizk15eSQvY5VU8v2InbmdJf1reJHJeZ4PmAPs+AxLMlED/+lQxdr7F4nTcFqp7pVkMlzAShB1vkSjFbWMgRWRH2hLXjOP7rNGVxNE8qv3SSpKKbl9QRQuLoZVs2wxLC2VpDtBolEn5skZEOw43juoBVO/I93RuoSVZMCLlNIcM5yfyeGrVJEklmba3Xb0j4OpHlSrzGq/Z6EEk9DW6Ut0pTLEkQt2/BLa+RrJuRO4d2iWNZNKcWBmh1wH7PgY6fgi0eK6y1TWyA+c0mRMrc5yZy+AMnYaKmb2/pV4RwLpnDbOyvqRdsTyfnzMXXx6P8nwquN0+5/XY8T3OGQtqTHI+ZCFtnCd+5TEZupiDgq0V5vgDQJMxgHs4FcA5HUjSjITvCGhtHLWKwSvrn7Vt/zz0NZXVnDjb7wng/K3+hv0xV5EBQCiGvu0MCDa9AIgk0NXohoxmb+CrA6X4fEA0Zu6KQ2JuGeo751sSKzOID36OhParIRf6YnCTUCA1F2+tvwyNjt/G7/aqDT83g3rvHsIfBxxw4F+Jfxy5csCBfz0kchbgU46wyb0gEbrwtiiP7I73DpSgQWgCekQHPN7g3qpQmMzUswKzUIH9nwKXlrGoNhAsgUAAf/dHsABWBYnMlLRXFVwDSPJqdmPxKPc09XO4BjBh77hVCIiTG9Dza0Du/uDtK4tYnNlDwmGg3Qyg9/ckWxI5eysurrT/HK2axKL+UPaK6LRUkeSewPAVTHwrSKbSsWaCZc/RsZ85wDWosWUS3tn5VLIajwaaTgAUgcDV1VX3pWmUplli/vVZxAqEvL3xOJIFIzmInQa0eZlpjnHbSWT1hvvkXsDVtUxis4Uzf1GpiNsOyNyAPR+a7ruzh5awyA4kyUa0foXFvbKYiYkhzYHnDrLnSFlE5UzsxGsy/kDlpMSWz/O8Ge2W9QZyjpV5AqI1sm8CyhLDrLCbwIhl3HZFYeXHlhcCGyfzXNQbxOHDa58h+THa7ABTD5VrAPfbnFgZoddTmWv9qv19SzkLVOQb+qM+A47/THLp4sPzbc8eC1CVC25KEli9c2WFFOB2NCoSK4DJdXodMHQhj0lhEgcXQ08lVeJMm2JxOkm2utwQdHGD/xpxZi73t+4A4PpG0+0iJyCoGUm1izcH5Vrj8LccVq3wA2p05iy45FNUqo0EUa8n6fOK4Pu0Be/qvI76zgIuLCYB1mmBoMbIaPMZLub6o93wtXASCaCDHq4aoGVgMT7fdgMDGwejfS1f+CausH98izPgJ9NA7CzFkuNZ6KLgbgW4yfBu7zqIre5t/7kOOODAvwoOcuWAA/80aNQstFeNYSqXszeENzZBcmsvxrX4GkOX3cDC4wlY+VzM0yNYOh0H1JoTKyNy79LO1Gzi03mtB0FZSmWkLNcUVqDw4322LJFyDxasNbsBx2YxHa16J/Y4eDxk7LHIiSQHdtQfhT8gknF/JIZjXpLFgtEenFxJSM8tYlFcUcCiud2b7JtbOxEYvRY4Odt2mMPej4AXTlE1KTOL5C5KBQ7N5P8HzwcCGlWdiCgU014oEALNnwFubAX8alEBu7aB/WJ6He+v1YvhEzW78Xk3NtPu1/Z1Fs77K88CvI/sm0DsizzuC21Ek2+cShtZ+7dIwKQKKmiFKVT4Li5n6p9OSxLgWxvo/hUL5tNzgEFzSa5ubuGxjepB5evYz9x+rV5UdjIu085qCxJnwLsWEB7DwAmdhkX40IXAlbUkWVIFB93mgpbV3j+Q9O14B4hsB7R6mURKKGKx32AEr59hi9krl2p/XAFSzxuuMzuQOJMob55OtbHfr1RJIeB9GVdMvWXW8KlFNTAnjse5MMUy4l3uyZ6zLWZx5CInoPsXwIbnLa8xz2pUz5VFDLnY+gqHVg9bzM+mkaybY9/HwMiVluQqoi3j05XFTP2rO4DHXSAC8hNoI82+wc914jHaA9Vl/Py2fB7Y/gbttABQnMljf2df5dcWCIFmzwDLhgGacmDsJujavYUCtQi7bpehhs4FnUu3QrL0N6AkC6KgxpC0ehFjcBOt+w7AF8fzEeWvQO2q1CaxE+QyZ3i5OuGtHnVw7mgadr7UDnKZBP5uMgjMA1wccMCBfzUc5MoBB/5pKE4Dlg6mNcqsV0IKoJbvYvSsMwBbr+Vg/fkUTO1QA6JH6XWyh/K8Bydt1RtoPxhCWQyoK1j0Sp5A1SrJZh/W2b9MvTe+tYBhS9n3Yw8u3rSHBTWhouDkaplUVpxBBUCnIVkxj7JXKxkv3WKy7dV+gAqLk1UKWOpZznHyj2b/jjVipvOYnvjVdFvWdWDtBBKFIQuoINibRQQASSeAdm8w+MAavrV4TM4v5DH3rm47Za7eACDpNHtycu+ShIidgFN/WPar6XUkB1olE+iajCORKUzhfcmnDKqGWWiAayCJb2EK4BnBOUm5d21bJTVKYNd7JHWp5wDXYFrMWr9CleLsPNNjS3OA0qPsz5mwnSl8W19lD0u/n0mytrxMQiCSsM+qVi/a3STOfA3jHCYjZO5M2Tu3ENj1Nt+TkxvT6TKv8vPW7g1DEIUMOHaB6XpOLiQh7V6jPTTjCtBgOBXXVi9TjTr4JclN+7f4WvYUJmcv2l/t2fbqDzWdk/OLeXwEQi4wrJ3I/RHLbCdPtpgM7HqXxz7xOMMknFwNiwC+JKslWZaEy8WXARHmxAog8Tn4Fedw3d1PYgXweq87ELiwhMfZXFXVaRnY4VmNz68/lNeEXsdeUbcg7vvGF7j/AfW5jwnHePw3v2jaVnYcAy4G/gksH8bPrU8NIOMarYoHvjS9tsydJPz4r+wV9YoEMi6hQifB+7fro2WgHo0ufwrJLbNrPe0CFcj+vyLi7Bf4pNMXSFVLoHWLhsjJtfJ8LgCq6BFw9QnGwhOJ2Hk5FVMigUsp+WhV099BrBxwwAELPFEUe3Z2NmbOnImhQ4eia9eu6NSpU6Wfzp07P619dcCBfweST9mN7Xa5vAjjG1A5WXsuBXmlNkIvHgcCoe2IZCPETlxttkZ5PnDvCEMNFvXmSnN2HK1Hjwqthnae07MtQw2y44DFfVnYPQhOChawRmKl1QAp54B53YDZrYE57YE/WpH0GJv+Ew4BvzRmwdXy+crbbPcGwzbMoSxm39OBLxhuUKOzKXpcImcyYL3+tDzZwoHPmdin1dgPagC4T+GtuQ/mkeDV2nFG0ak/mZZ48CumrFkrWLV6MwQjqjstjD4Ggipzu59IWAm391AxTT7Jotg9hENldRqgTj8qWn51OBC2/VsM6ej2OdDre95nHfphDbETFafGo0jI6/bnsbSF0mwg5ybJVOo59nEt6strrs+PVFKe2U175LpJJNZSAxlq9aLltjp9wDjvm9tMyouyiOdIXcFwC48w/q4yXBuludzffZ9wkPWV1VRmVo4Etr0OiKUkKxqlQW0eTXJTo6vt99PyBUDszD4za/hHA7V7mex2zt48bz61eH6zrvM8DPrLsp9H5k4SlHKWn9FqbXltbXmZz1EWUy07v5Cfi8BGfJ5QxONr3Z9kRMoZWlv3fszf27wKhDSlwuTqzx69Tu9bxvTrNLw2+/9GS+v2NzgceKAhsfLiMtN3W8YVYN0zQO2ewCUbCzslWSRYtfsCMS+wTy6gLr8HBs0xJF8u4fEQCHleZO4MFzn+K7RuocgtUaJTkM6SWJnj8HdAzS7w1WVj8clEjFiVhMz+y0m6zaAPiwXavYkhf53DD3tu4W4OP7Nvrb+C19dcQnZxFWMWHHDAgX8dHlu5unz5Mjp16oT8/PwqQygcKzoOOPCIKEi2f5+qFM4iFoZP9bPl7MVo7E0v2L6/+WRAZjVnSVkCnF3AwtOI7Djg8gpg/DYgrOWj7UNJBm19tlCcwSLW0Pf10ChM5kwc8xV2ZRHf5xhDqtj651gUHvyax2D0GkY/i2VAVDcWqjLLYgs6DXuvyvPZL9VyCtDpQ0OvjYD/VhULnZ8AqEuAzCss6pNO2H5cWAyw/zOgy+fsSSrJACCkCqGtAK6s4eNKMlm8tnmVaoGqlErW3f0klf7RVD3Sr9CqVZ5nP/AA4PEqywMCGvJYAOyX0apZ1IqdgPWTLUMjPMKAkatIFoOasKfJGsFNAe8o4LlDVKGK0gG3QNvhE0ZkXre0oen1wLX1/AF4/MJbm4Ie6vRhUp93DZ7LtIvsG/KrYz/04+TvJKvLhjCZsPkU3u5Tk7Y0axUMIPms2bXye933MTBhGy2G5kEXNbqyv60wiaR57Eam9RWnMyFSrzVdiwAVx20zGHcfPZh2wMTjPC/t3uRnVq+jUnP3ANB8EpPqUs6SfEV2AHLvAVIZP6MpZ/jcXjNJUAWiygOGrVGQyP3p/CGv2XndzI7ZHyTbPWdyPwGOLihMZfiFMRky5nkg755lUp8Rej0Jb93+wG0bow5ubgPGrGMfncSJtr9+s4DdHxg+a3puY8I2EvzAhgCEgECAVGEQ2kaJIM+uopcyPwFw9kZx+m2cTwxAWmEFpuxT4JO+2+FfkQBPfT6cghtA5xqErw9m4V5uWaVNHL6dg9uZJfB9lFEUDjjgwP80Hlu5mjFjBvLy8vDee+/h3r17UKvV0Ol0lX60WhsNrA444IB9hLawf59nNSQbhI5hzULh5VKF2vSoqNEJCLFBiCLas8i3RmkWC39raA09IyVZle+rCpqKqgckm9uZHhbXN1sSK3MYgxnMC+Azc4Hlw5msd2kFC21rYgUw+rveQP5fVUL16MoaKnirx7L3xcXP/n4JhCRv5xcDrV+yPaQ3oAGVoMZjgIJ7tCxWFPIYFaVRLTFXOEuygJ3vACtGMJnu1k4qdBolVZ8lA4CAeuyts3dMjJDIqVoZbWkAC/PCRPbubH6xMiEqSGI/j0c1KhruVkElUT2ZDrnpBaqHi/qQtAglfK/24FeXVrN2r9P6aQ2dmuei9w/sf4rswON0dh6PxY3NQPX2JDL2UJ7PXh29njZHY2hCeT5thPZwdS3VJnMoi3nMx6xnP1OHdxjl32AY8HsMt3l3Hy2P/vVIhPZ+BGyabgrVaPUS+7NSz3EkgkZlUquyb/I4rxrD660sl8rp4gG0RZ6azdlScztTWTs52zQgOfE4FdCRK9n75Bpo/71J5CZLokc4r1Vr3NjMXqpxm4FRa0wDt81J28XllW2H5ki/ZLCb2oBQBGTdpN0w8xoXBfZ9ysUMvc60QKAsZqrmor7Agc9ROmQlpm5JR7NwT+hlVQTaCASAQAilSwgKyknOL6aWoP/SJPTeIcOPmU2gknlDX5SGCTUr8Ef/YIR7V47mX302+aGSjh1wwIF/Bx5buTpx4gQGDBjgmB3lwP8/1GW07+i1gNS16pCB/wb41OCKuXUyGoDcVu9j1vFiRPi4oH+joKfTb2WEayAwfDELurPzDQEIz3I12LxHyYiMK7Yb2wEWQ8Z454eFWGaaiWMLvrUfflsASVNKFQV1zh3AVu6BXsf9B+ym8GUUK+Faoy9cTv7BgAmNknY0IzKvUikRO/E+a9TqzfcrdQFy44HJB7nSr6kAbm6nvanZRCpSW17mCrsRbsEsjrVqBj+U5th+fyEtWNgaoVUDp+ZQ0Uq7YDn41+J5zYGCFFrAVOWmNMcbm0wpeUZVwhopZ0iWNr8IdPmI56AwlSqSVwQwv7vpeBhnMKWdB0asBOZ2qrw9hR97yza/yKS66p1oudw2g6okANTpz235R1NJ0ZQzkCP9Iu2lGVeAE3/QpmkPIglgHHDQfDLTEv1eoA3RVjS4Eepy23ba8nz2GIXG8Bxuf50kAqC1r89PVKk2Pk9S4leHx04kIam9tQs4N5/x9e5h3Le+s9iPefRHy946F1+S6kIrxVujZLR5/99J5qq1oQpWlM7+rVo9eE3UG2RSAc0R8wKJ04gV9u2tAElstTbcL4GQRHfUavaOFaWQcJl/NqwhdbGfdll3IFMqI9rRYgjws2luizQQpPvfl0knUFRahns5Zfhx7y0sGtTU/tzAyE5A5nXEKXqizMqeO7KhOyZ5nYN0zodARQHCAIR5V0ejvr/jxb1CAAX3H/tUv4cdcMCB/3o8NrmSSqWoXt3OapMDDvynUJAMHPiKcdRaNS06PWeyWRo21ID/BrgGcsjnrvcYKKDXAa4BKGr7EfZW1MbIFq7oUscfgU87ih0giardm0UsBFWHUwgeJHzbLziKy9XIKlHizL08CARA82peCHD1gXPrl7gybWu/HpVcCcVUROz1Fnk+IEnQJ4qr/AXJXIk3rOKn6twxfM5p6HR6LBmyFoHX58M5bj17jw7PpN0qLAaI28nEtzUTLNUxzwiqMGufpY3u0EwqFzoN1YLmkzkcOT+BvVnmxEok5XG4uJT9O61fBXa/Z3l/uzfY71KSxeh4gPOrMi4DSceoUO75iKEPmgrayIwIaszZRzoNcOhbfo5qdKEN7dp6FttVqRAAi9g6fZncl3iMPTe397AnxhbRLMkisej6Ge1rxmPlE8Xjt/0N9iECfA+XV7GnZ/kwKlrV2pCUZF1nT5RHOKPqi1K5UJB9E7iyCmg4nFa6srzK+1BvIIlenb6M7k+/CPiBlsBaPe3H9NfoAiRZxb57RZIU6vXAnf3A4a8tewjTL9GGOGEre8cEAlosfWpxgejI93x8n5+oXs1pb1rEcA/hOd33KZWc2n2qHiOgLOYQ6PFbeN7WTQI6vkvSf3k1VcyRq2jpPDOXKqyzF69BuQfDV5qMYzy8PZTnm8iTXsc+KYkLUyaFIqDRaOhlnhAIhDYXY/SNx0FQYKPvyyOM883WPwfkWi00matEtXoDCUcs7y/JhEwixIDGITiTI0TMoAWQrBtneR7cQ4A2r0LpEoR35iYAIEmSiATwdnHCuPACeG54yXK7uXcRuH4wvhi4EzdvFdy/eXjzUEcLhAMOOHAfj02u2rdvj7Nnzz74gQ448HehKJXDR83nnqSdBxZ0Z7Szb/T/3749KTxCOTi39JP76XciqS+66/Rwl0v+/j/kkocgbv7RLJ7MC5b799UDnG0P780vU2HekXv49cAdi9tf6lQD01uOhrQkizOTrNMCH7XfCgDqDwGOfGt78GqbGcBtFQl5yvHK9w/4kz1LxjlMAODiA3n331DXzxW74wrQfUECetcbivdHPQ+f7FMQDFtCgnPvEHtrgptyXtm9w1QWwmJZvC4fSlVix1vszTFCXQ4cn8WeqUYjTWqHRxgT0TzCAGUhkHEVSL/AwANNBWd8qYrZ3H9+MYM2jJB78lo69C0foyxmQb5uEgc4t32dhNDZiwTy2gZa6xqNAqADyrJJeGKn8xy4PCBKXCKnsiVxZpS43JOF7OVV9p93ZzcDMWp2JfkxzhHbMBVIs4o2L06nHW3gX4DcjURhYS8+r25/HpMzc/m5afYMlb49H5DsjlwNrBxhqfaFt6FKU5LFBMgtLwMwBKJ41+BreEVWnq/k7M2FiGVDTLdJFSSna5+hdbPRKPZybZhiSbCTTnI2l0cYkHqBZObYT6b7q7WlSnXByopXmAKsn0JyGbeD2y+2MwDZiLx7VM9ybpMI+den7bCikMc7+SwQPRSo248LCZpy4NIq03WZdoHDuO3ZKqt3ZIjF0EUA9LTTXl7BNMy9HwDnFkIwdBHV1hUjLAiWPqgJBLV6UCkdsoAphKpS9piFxfA4Ca0WcdyCue9CMUlx7T5U6MwgcPHFrBHBCPN2Rn6pCteETRE49gjcE3dBWpwMfXhraPzq41CyBqFOPvByScV3PXwRKSuGQFUCF79QuG17zvb7VZXAO+0AAC7O9IwOQKSPwvZjHXDAgX8lBPrHNArfvXsXMTExeOutt/D6668/7f36f0dRURHc3d1RWFgINzcbPRcO/P/jxlamc9lCRDuoBy3A9v3H0KtXL0gkEtuPexSoyhgoEH+ISkZEO9Mq9b8RqlJGTu940/J2iZzx2cFNbD7t+J0cjJp7yuZ9K5+LQUywzP6cq0eFRsXggTXjTYqFSAp0fB/qBiOx/cAJ9GrbBJJTv5KUqMuoDPX6nsRxQY/K2xSKkTxiHzouTINGp0d1XwXWd8iGe8pBFuN7P7J8vH80k+0gYHG70lBgjlxF9cUWRFIuEPzZlmpK47EkTOmXaCeMHszCOvM6lRVlMQMibm6hKmINqcIUxX5tvYm0ASRUI1cBK4aZFAGPcBbDK0daKmcSOQlKwiEmrVmjzWtUGcwj3lu/TOvZuUUsum3Z7BoMIwHOuQ10+wxIOA7kx1MFsYV6g4AOb3Nbpdmcm1WcQbKwbYalQqLw4zyxy2uocMRO4+06LT+/Lr7AlhepjhlIuFoow/aGc9ArIBeSw1+YrHXXNtLCFtWDM70qCjh3KS+eKl9ANGPC0y6YXr9OP6qk1kOuO74H3N7Fa2LMehKJI98xFW/wXEbP21MJB/7Jazv1DPvidn9gP5xi3BaqUClneG58awEnfudxaTaJCwFleSSKR3+s3NsokgJTjwELela2oDq5AaNWsddJp2H0e8xU9ip6RfJzB5BgT9zJ74yUU7Rxh8VC610T2uO/Qnp2Dgl429d5DC+uBK6to2LddALP5853AIEQmuEroHYLh6wiC4Kr6zjKwHzxJKABKkasgcyDVuaE3FK8s+4SukZI4eXqgvOZWhy+lY2E3DJ4u0ix4+XWcC+4Cac1I3kNufgAYzcB87txf21AXWcQtssGQFGjORqEecPX1cn2sXfgXwe1Wo3t27c/vbrDgX8UHpYbPLZy9cUXXyA6OhpvvfUWZs+ejUaNGtl8IYFAgHnz5tnYggMOPCHittu/L/E4ydDTgqqMhdDaZ0yF24Ev2NcybBH7K/5tkLoADUdQnTn+i0mZafaM3eG9pUo1Zh+2MYvJgD8P3UX9UU3g4hXBHp0nhVjKJLkpR7l6r1UCrkEsqAWGP3yuAbSktXsdUJbRzViUQoufNaq1AZo/i2BhHk5P8ESiUoE8lQjuZz9gsWyLLGVeZe9T4zFUWXRakp3SKgI/tCoWdh5hQP1hwIrhJuKjqWCkddoFEowtr9AGBz2b+m1BVQKU5XN75sQKoNpzZw+VptavsMfO2ZuhCObECiCZWTWK5FldTkKqLObxbP0K9+GogVhJFUCPr0hST89hgT1uM/ejIIFkJv4gCUTtvuw/UpVS3Ri7CThvZhUTSZi25xrA85l9E5jbhQqcUET1ouN7wF8dK1vPSrL4XoIa0+63fjIJa4vJ7D1yUjBo4/omKpVSBRA9DMgHsP9TQJnPfarRlSQt7TyVyP2f0bqYdJzP3/G2ZXKmETe3sAfJnFxJnDmX695hYMBX7CkrzQGaTgR86/D75EEhEDm3+Pk7M5cKpK1ZaHUHcMFg4/MkhXX6AR4RJEIR7akUNRxBtS7hCEmbMQhFXcrHtHsDyE8iAT/2E7939TqgZncSqR1vmlQ5ZTFtrl0+JkkxojzfML9vEOBXj98dZ+dB1/VL5NcdC/8LC9hvKZEZhlrrTc/b8RbQZDz0vb5DuV8TvH9Uie1xCVg7qhrq5CdCZE6sAhsCw5bcJ1YAECrMw/yoU5DfWAuIpGhbdyx6dmuBSetS8HG/evDV5UCwrL9pNEPH93htelaznXAIQOdfDygE2kX5OgpoBxxwoBIem1wtXLjw/v/j4+MRHx9v83EOcuXA34aqCI3c8yF6gh4BxemWxMqIlNNM4+r8geXQ2n8idFq+D2Ux1Q8XXxaWTwKZOxDSjKqIuoLbq+I4KDU6ZBfbn4OUVayESqODy9NcCBaKaGezthWqDUVZ3E7gxjpA7s3ZSynnSMKsA0XqDyV53PwShMoieAHwcnKDqtePLGITj9nfhytr2Lvi4stAifwEFpMPQrcvgGM/2o5Nz7pOMqIsJhmTyO2utAPggNWs66YBtkIxCVFkew52HTKfBODAF8CIZUD8ftvbURYzQr4kk4qcsw+tWge+YF+VEQNnA0d+IBmp3ZvR4nn3mL6YHUcS03cWr5m7+037rlGStDWbRItZnX5Ak7FUqmWeDJkwD1jQaanKpJyxHVoAkMS0MMSrC8VAk/HAkkEmUrBsKPexxXNA9S7APYNNtHonQFvGa6JOXxJuoyonEDAVMe8e7Xr2wlP0eqCiiJ8LFz8uPMROA66sZcT54n4mNW/Xu/x3wGz2XtoLDvGpSWtkaQ5VooJE9rYd+4nqpNyTVkf/elT3je/zzFyeo9HrqJAd+IIqqMjJoKqOJOnr8wMVq9TzJFOFaRxL4OzDPjiJC/Su/hAs6mtKODTHid84i8ocFUUABBYDt4XZ13EasWgxcC38dZmMcLd1rZ9fBMEzuwGtBh3rhyMyqBz5Ynco+8+FszqPx0HuaVC5fU3PK0yGaFFvyAsS79/knXYeLUJa4vj0uRC7+0Jwe4uJWEnkXFjY9ynP0dZXK++LSAJhnX7AyRu2z40DDjjwr8djk6t79+49zf1wwIFHR/QQ+ylWMS9Yrpw+KW7vtp+Md3Yeo4EfpyfoP4WyPBZV+z/j/4UioHY/oPvnlslbjwuJ/KH6tBROYrSq7o0b6cU2729d3RsK2SMGkeh0JEMiqe1Ic3soMhSu658FdIZI87NzOUg4tCULWGMCm1TBGUUrR7GYbfUiFRSNElKxFPrAnhBcXGH/tVQljCqXuTMcYsMUFoS2enkAoOFIPtY1gAWuPaScYX+eTxRT8aoqyN2CqXqNWEE7l9yD85Fu72ExrSpjAATA4cZVOcbL84HEEyQIAPDCKSDhsOn+iHbcVtp5qgl1+nFeVn4CSVSkIaTh4lK+buMxpucKxSx2JXJaCr1rMB5fryMB3PJK5f0Ry2wX+eYwhi7U7ErCYN4DpdNQubq+Cah9Amj/AZB5i9eU3A0YvhTIvmEiVhJnxqynXQKCGvE8VgWfWsD0cyRBRoJZtz97C23ZJM/NJ/Hd+Vbl+xR+TNArTAH2fEiCa7Qntn6F+yL3pEK4uE/l81iaQ9JarQ1/j9vBa/vsfBLVG1ssbZ3DlwK73kVFmzdQmpsFbYkaCK0F37sb7B/z0mxTnyLA8yMSc8ErsBH/n3EVeR4NkF0OHEUNDAjwhKggyf4xTDsHacZNXBNOwO5bRVA4iSAVuSGnxBV1AoPhq3CCq9xsYUerBc4vNczDsoQo5RQUOZeRLvaGPPOGKfrI2Yef+dw7VA5bvQSc+sNkO5R7AoPn87MEB7lywAEHbOOxyVV4+AOSthxw4O+GewhXvre+bFlARLRnP8qjFNoPQpGdghVg4az/B89z0+m46m++CqvTAtc3sIgYsw5wrSKk4ClCKhZhTEw1LD+VjHK15TFzloowqmU4JCLb502p0UJVWgCZKh8idQmEci9ana6sYbO9by32Z7gGUaUpzmAzvCKAxZDI7OtOq2YxicaVX+jUbAY6NHuGigrAQvjSShbVQ+YzqvvErwYFSARB9BBas07+Zlm0GxHemmpPZCcStWf38Zz0+pbnxVhUBjSgpaokk2EGYbHAsMVM98u3saAl96JFTlNBxafVdKZMWsO7OqDXcLZXo9Ekjns/Nt1/fBYDBAbNpY1N4Vd1zLtXde6jEXnxtM0ZQyvq9GX/DkA16OiPjGYPasyer32fkETV6ccAitx43hcWy2OfcZlkof5Q4Mo608KGQGRSGcxRkAT4VZEm6RnBa2DoQvbAbX3F6jh6ksiWZFHV2vIS4D+d4R66CuDcApLuSbtJakRSWjCbTgB2vMHUwJDmpnlSRji58juqMBk4vo7XT1QPzknLibOvdiaf5hiEtq/zOjPOM/Ovx2HQxlhyrQrYNI1R7s2eBVyD2XPnGsjPtj2CHLeDc8cA4NYO9tfFH6xM9BuPAdIvQR/VE/tSxfjtalMUlquh09/G8QFVpAVLXSw/B+1e53foiOW03GmUQOtXIFRE4cvfb+DZthHQBQirzneVOENckgqFlw7xOaUI9JBj/ILTqFDrIBAAk1pHYGqH6vBWGGTvshzg8kq7mxOfX4DVnqEY41cX97/9yvP4/QFQRWswjOSyoshg6dUAvlG0GzvggAMO2MFjkysHHPj/RH6ZCjqdBJ71BkNYrTUjjysKaOPxCGNxaLR9PQ3U6AQc/9n2fYENWTT9U1GcDhywMewXYMFfkPQfI1cAEOopx7qpsXhv41VcSCoAADQJ98Dn/aMR6mX7OKbml0FUnAafQ+9CHL+bq/NdP2PinXHl/+4+EqPB84DzS0y2Npk709WCm9FSlp/IsI1LK4BaNsgVwIG93jXYM3TgS1pQ43YAbV6ldc5iPpSARL40Gxi7kQXatY0kr0b7Xfu3AegYC399Ey1i9YfRIjZ8Ga/dwlTAqxqwbJiJQJz8A1D4M+1v0zQSxvsvKyAhOvoDkHWDRDO4GY/L0R+oLgkEQPXO7JtZNdqUsGaecGeExIWESqcl8Wz3ZuWwEoDkID/BsnjOu0c1L24H910sB5QlpuMf2IhEcPVYy+HSZ+byWPf6Duj0AY+Ped/a3g/Zh9TpA6quQpHthEqdBkg+QzX76lrL+wQCoP2bJIMiCe2rXtV5Dt2CaM2DgO/JuwYJUYUNAndqNsMjts0wDVCWutJOWJwO9P2Z7898BtXg+cBBq4CL84uprEcPoe1TqyKR9KpG8phwlNdu3A6g4WgSzLy7JExFabSrWpOgwlQqmJtf4DXSeCzVInuQyLi9llNIqk79SeKZcYXXp1QB1OlDgnZpFQR9fkRxQgniMovRs443xjWQQ+/rDIHM3bZ61Wg0FybCYrno4OLLcJLtZuFXJ36FIqov5gx6G9M3J2JGi9r8XNpSasVOgMIPJV71IJAqsHRSOAQQYNaIxkgtKMe8o/cw9+g9NA7zQO8GBnIkQNXWcIEQ+eUapMhqwl/hz+tDVcpeM49wKl6XV/NHJOUCWpMJtE064IADDlSBJyZXy5Ytw8KFC3Hx4kUUFRXBzc0NjRs3xoQJEzBq1KinsY8OOHAfWUUVOHonB4uOJ6BCrUPfhoEY2DgEwS3txOY+LfjWAvzqsmfFHAIBm9mfpgXxaUNdZlnQWiPjMhDa/D+2O2KREHWD3DF/QnMUlqkhEADucgk8nG2vBqcVlOPCzbvoefU1iFINfS0tpzKkwNpSpddRdej/m4lcVRQCq8dRLVo6iKvmg+exiLIHdRmLTo2SceKugSRlAQ24om2ESMr489u7gCUDTb1PjcdyHy6vpvogkdNSaK72HJ7JvpnBc0nCZG6ciWWtzJRkAns/oXJiVJsEAqDHTAZl6HWchzXoL6oc1doCI1eQRBgDNJYP43Fo+xrDXqzhU5N9TQt7m0iTawAtZ8dmUTWTuQPNJ7HY12pJGA99zX3xrUl74YStLNQzrwGRHTl4GKB17sYW29dhfgKL+qjuBjXRCucWAAP+4P7cPcDwiuubKj/uwlJgtGEg7/nFJDzBTYCYaSRwzepSNTm3mGEWt3fx3G59xaQcGt9371+AOBt2vbgdVCGNs9OK07ig4xpAe+PwZbSTFaYy6OXaOktiZcTJ30k8Nk4lWez/G/cx4YgpKEIo4aLH6rEMmjj0DcMmmj9LNeXaBhKp4CYk6ns/JhHv9AHJjF7Px9tCkwlA4lEe++jBvFZubAXqD6Y6du8wFeHITkDXT6C8uhk3NSOxfkwEatxdBJdti6kGDp7H92CeVBjVncRRp+E5OLcY+pZTIDg+q9JuON3agobhXRDmFYnrJQrU7zETwuVDTeQV4PXV7QvgwjJo234EwS0hJi8+d1/5ru6rwGf9o/Hl9hv49cAdxER6U71y9iHJ2297YSmz1hgc2FuIQ/HA8oFrEbp/OoNCDnwF9P+VASHZcXywVsWBxu3f5Gf5aS7cOeCAA/9zeGxypdVqMWzYMGzcuBF6vR4ymQxBQUHIzMzE3r17sW/fPqxbtw5r1qyB0HpOhQMOPAayiirw8soLOBGfd/+2uN3FWHoyCWunxiLE829Uj1wDWbgd+pZx0s7eXJENacFV4NJcwMX773v9J4FIyiLb1gBX4On0XD0GPJ2l8LRDqMxxOC4brT2VJmIFsJi11asEsNdDp7F8z3odcHYB47OPfMfwgWrt7L9o9c4MFyjJ5Lwf3zpUj3LiLB8XO43Wo7gdptvU5UzHa/YM0P1r9tVIXSyJlRHZNxmFfXM7wxHMlSlzZFzmUNnWLzNwwcmVc7QaDqed7ugPLNjbzOAcLIGIqkxePEMK9HoqujV7AudsBAy1eI5N/OZq1PFfaKGLncb+HK2a9r4/WlMViZ0O9P6BqYdX19E2GdiQJMw/mnO67uxhRLyTG8mMPdzeXfWQ6MuraSE8v5jpnIUppv4wgGRixDKee69I9soYgzO2v05VTeTEWU4AlZkRKysTK4DnYM+HQNg7lfdDXcbryojAhkCNbsCm6TxHAIlFu9eZTHh2gf33dGsne89ubiOpHrmS7+/k7+yPHL+V3zc5t6hYxR/k887M5bGu1QPwr8tetuJM9rm5+pOIF6dz0ad2n8pDtEOa8efMPODWLv4A/J5IOknS7FPLdFxUZcipPRot8sSod+xliFMNYxQyr3KBo/sXPP4FyYYewbPAot6GcQMrAbEEgvML7R4G70uzMaHR78gq1WBzgTP6jt8GUfx+LgK4BQE1u0GffAq69m/jYqEbZu6ynHt2N7sEr6y6iG+HNMCb6y5DrdWZzlXd/oxqN1cTAajD2uKqLgKpBeypHLQ6C6+1/hkx7XQIcRVC4urHxMqyXC52uBhssnIP++fTAQcccMCAxyZXs2bNwoYNG9CmTRt88803iI2NvX/fyZMn8dZbb2Hjxo345Zdf8PLLLz+VnXXg343r6UUWxMqIjKIKLDmRiNe7R9nt13kqcA8Ben4DtH+L8662zeAPwCKr788c0Cl6YkH46ULhBzQcRQXAGk5uVOT+oShTabAvLhPt61qRjgeN59OqaIGDGaHMvUULV5+feEzqBQAXUio/N6gx9J7VgK6fQXB9A5Ugt2AWyk3GWT42vJWpt8ga5xeTYHmGV11k395DRazQxr6YoySdfU0HPmcRfH9/mzDiPCcOWDaYJOi5wyzKs67zej3xG/flyHcsyi9Z9aK4Btomq5lXSU56/8DwiravkSSpSqm8dXyPhefBr0kqpApaFVUlQG4C8Mwu4MIyBiZUZZ2VONPaaA9lOYCsKXuP1k4COr7LeVgZV3luvCKAimJatxT+tHUt6Q9AQELqFsTUxfZvssdo/2ecLZV+0fbr5d8DwmzcXqMLSUjd/uwhqtmVSqmRWAEkcIv7AZ0+ZIFvD6oSk3VPp6GtNaIdSVRRGnBuIVCtNRdzyvNI0I29V6oSU5gIQOtktTaGGHMDudj9Pvv36vYnkdMogZrdOEdK4kzFqiiVQR2dPuAxqyhgb15RCgleaQ7047eiAh5o6pZqIlZGZN8E1j/HbTafXGlIMLLjAI9qQIad4wwA5fmo4e2EnfF5mHs0AandojA8ejDkUQMggha5hcU4Lu2P8PIgbLqcbHMTheVqJOWVoXu9ADhLxfz8x+0Edr3Nz3t2HI+BSAp9k/G4Km6AF1YkmHazWIl3dqbBRyHFlhfbINDdEM7jFmh/vx1wwAEH7OCxJaVFixYhKioK+/btsyBWABATE4O9e/ciKioKCxZUUVQ44MBDQqPVYeUZ239YAWDDhVTklf4HrBoSGaApp30qzaw3IP0SML9H5blA/wRI5CwqjelgRsg82CP0/zWjS6NiEVmUZncmmVgohFQshM7Z1/IOdZl9K6ZIwoAC61hy3zpcWT/6Ay16e97n7VE9SQpcA1mIt50BweL+0AnFQNs3GFywZjxJhVDEYbEA7WdyLwZODFvMIARjYqLUheqScVZVVQ3wIinfj9yDFihbkLoAzr5MxzQnVgCvw22vUjlQlzPMRSQxzNLKBYKbk3zV7Mb34OTKgItHgUBIcnp2PpMMjTg+i9vq9jkXGFaPpQXz4EzAPYgkQ29Qw5o9Y3/7jUfzc2UPEe1IGl0DmeToEcYQDL86JAg3tgIVeRzwvag3BzlPPsgBumEx7FMSiqkStX2dypp5mp09mIfi+NWjunbgC77HM3OoroTF8rzV6Ex7n7KU9seU0wznsIfIDkDKWdPv+YkkhkZc3wQENuD/b2xmuII9NB5LO6Y5sdFpSLB2vs3jFx7LBRaBoWfNPYQWwwnb2du3ZAAVtMX9gNN/AQPnAM5eENzcgjB9Ojyyz9p7dZJcuWflRFV1OfvFwmJtPw+AvlpbBPj5o2GIO3wUUkT6KdDshwuo991l1P7uGlr/lYQ3tqVg9LxT6N8wCGKh7c/InawSTG4bATe5hOrj1lcYyLJqDM97WAwQ2BCC03Og1Wqg1FROf32hYw34u1bRq+aAAw448BB4bHJ169Yt9OvXz+4APYlEgr59++LWrVuPvXMOOGAOO39TDfdVcefThFZNFcLWirSmgk3vavtznP7f4BYEDF0ETDEMCh27EXj+KHthnmaqohE6Lfs47ClMBcnsEfk9FvilKQuh3DtMNjSDVCzEuNhqiCtzYdy4EWfmcrXdFlq9RBuZOYRiru6vGGGyOxmJsIsP0GsmrVxpF1mMqUog2vcxdDJ3y3lXmdeALp/QXth2BrDpBRbaa59hT9PotUxE6/szVQOJM2czNRpt/1jV7Uf73O09QKOxth8TO50EJ+WMbQKWcpY9PqNW4//Yu+roqA6vOW897k4SCBIgBBLc3d3dtUKNusuvTqGFtrSlxd1diru7BgkJCcTdk83ufn/MLutBSvtV3pzDabNv9/kmd97MnYvwbgwFcA0iEdr6MofrZsfzWu98C+j6FVB3iNHiVlrAvkJbkMr5BL8wg0//q7YzLivN5zGW5AC73zdaH6t3BA7PYO/M6d+A+Z1ZfFsSfID7W5TFAlzpYr1c4czz5+hN8utdHUiLoeKyqBdDNw58DqwYxhCCLl+wd+nITBKuZQOBA19w8PLuDxiD3/VLfifszWQznGPDPLjmLwG9Z3MeluH+yYwFNk/lOsb/Titd3GEgUU9+L69lmqAhAt4UvrX5umlMuG8t858lUoaM1B3MwIvoUSSFlmjxMv+bdNZ6GUBr24VlQFkx0GMGCfqx70m+3CoBG56hAmWK9BiSyGYvAGVFkN/aUbHtWaqw/V33jwRubGMfl4u/9XKZCkKjSThzOwlVfJywYGwjLD9pO45drdFh9/VUtAn3sbm8dqArtl5KRlyGntyWFRgXJp3jMZ+YA9w/gwg3NYLcjaMjpBIBE1pWRu96gZBU9IdGhAgRIh4BT+xfUigUKCysoCEcQGFhIRQKMbJUxB+HTCrBsMYh2H7Zdk/KwAaV4OX0F9xrpflsBLeHu0eBsnxA/jSn4D4lOHnzn+Fp+J8BdTGLz7OLgIwYILgpEDkQcAsx2iVz77MoNo0Wv7SKhfvkg7R4mSDczxk6uZKzmLa9SovPvdOAV1Xohq+BcPJnph66hzLhTunMZDwDXPxZVOYmms+ActePkzi/BDj7q/Wx5CQgv1gNl9FbIDm/mE+/XfyAg1+T2JnOENKW00aVconL1k3k64IA1B1KInZ1g3W4QfVOPGd5SezNmnyQ2zgzn0WxaxDJYo3OvPd6zGBPU14SLX6mPVoSKWPY278HlGQD+z7Rz+X5jWESt/dSpYvZyvNTuy+H1QoS/UDg7xjKYbCeGdD2HQZnAFQmTJP6JDISomPfm3/GP9LctgZQRRm6gtfh0ioqKFHDeQ5XDqWyOGYbsOtdkiOAlszWr5FANZ5MgpgZSyVmpY3ApMtrSNI8qgBVWpFIWYaelOSScPb5kX01a0aTOIY2pyqmKQMgA0pARVJXBriFAnMa247ZPzqLqt2JObR31urJ19VF7GMbspQPZG7vARSOtE+GtSWpMUDhRGXl8Azja3WHAqd+AyL6swfw1i6g2XM8/3GHSDqrd6SSqVXzmC16ix7AM4yWxtWjeP5Dm3PGWI2u5gq8Ke6fBbrPYGDHpVXQBTXm9bZ1DgzWQ8vX7p/lA6kdbwJ95nC8wPUtPIbQFrR2nl+KNg1exHen7mFY4xDcTiuwXr8esWmFqOrrbPW6o0KKiEBXDJ17AifvZGJZN3mFT46lUgmWTmyMolINSso18HZWwttZCSfl38zSLUKEiH8knvg3SXR0NFavXo13330XgYHWtqLk5GSsXr0a9evX/0M7KEKEATX9XdG+pi/2xZgnjgV7OmBYkxDIpH9BcIpMSWsSbCSAASzkZX9DYvVXoLyM/SIrhxvtQbf3sidp7DammgEMcLA1s6kkl3OiOn9mdg7d1RnAql4swlu9yqftJTmAozcER09g0ALaCmVKwNGTKsjYneyLEyS0WskdgNn1WJQ7+XD7RdnW+2AKhTNclQKEwhzO+2n+IovwPj+wz8TWk/qsOyRBrkG0q+l0jHwPqs9Y7tTLVBEkcvZ/leYxOAOg8pF0gcVyp09IWoqyqWhsfdWYfghQxRu+mkEGmlLul6M30O1LElBTe+q5xUDbt1mM1+zBPqPceyQ4hrlUnT8F7p0Dhq2idTDxJM9z1AgS2ZhtfJ+TN0lDs6m0GSqcAbmzdTR6aT6VjpIc42t1B3PG1YVlLKy15RzgXKMb+5Ourichr9KaEeEAkHGb9tWWr3JmWe0+jMLe+4n963ZxOXu8FM72UzIzb7OPa/cHVHHzU3jeY/fp0x7HAnfB8y9oAF28bVIB0PppCE5JuURyawhTSTpPJTRyMImxbwS3u36S8dx4VWV8/oEvjOv0qclZYT81YwDJs8dpd8xPAVwrAUHRVAXXTdSTRwFoOY0EzhbqDuVDBMNQ7IB6QPpNIMRG5LzZsRVwFIFHZZRKlCjs8Ru8tk0wu95an1rQtX4Tut8/gEzlxu9X/TEMFDHM1stJ4EORkJZM3RMEBnGk3wQy7yCzSANPJwVupuQjMsgVybklNnenaZgnulZVoZlPIC6na7D8QiZUcim+GlAXR25l4NfRDbHwaDzKHLyhUrranonm7AuFiw+quFmTNBEiRIh4GnhicjVt2jT06dMHDRs2xKuvvoo2bdrAz88PqampOHDgAGbOnImsrCxMmzbtae6viP8wfFyU+GpAJC4k5GD+sXiUqjXoFx2EDrX8EGhi8fhToXBikX1ju+3lLV62bW36L6AghcWeVd9FEYvosTsAlYu1omGKmO3siTG1EKVcNio0O94gYZI7cL0uAcDEfeaN546e/OdrYnPLvQ8MX8PQgJxExl37RQE3S2lrK7VRzEWPgrDvEyOx8K1NFSL3nv2n/QCf1vvUJLlSuQMNxlAlK9Mn2bV7j6Qr9x4thw4enAPVZArPX3G2UblpNJFk1JRYAQyrWDuOtq2tLwMelWmXu3/Odt/fgS9oCS3K4jwjHYAr6+m1jehHElOWD3iE8B6+f5YKWXY8/zt0GYmC0o3qTmYssOUlXutavYHnTjIoYvcHfO3KOiBqJIcFG66JTy3OJQO43IALyxiJ3mMmrZGugVTPdn/Ic1i5Bc+RXMX9VziTqFXvDCQc43GYqm1FWTzv9tIxDdCUs8+pvJTHknffuCzxLFBvLl9z9dWrWRVAYvKn9NhsRsdveZnFfVkhe53KS2nr86jChw2l+SQpDh68Fxw8SSwj+jPNb5VemdOU8V5vPJn2OnUJ7/97p4xDiAtSGXrR6X8M6zDsr9yBNlYIxtRAhRODUU7+zHtOEGw/KBAEbrflS8DyIVBBho3eU9BuzFG4JR9FafY9FAY0w43yAMTdkCKs7v+AmoVQ6ySo4eMIt9iNcAtry+9yzZ5M1Dy/xHwbjZ9BecNJWH9Tjd3X0xDq5YgprcPg5qjAmjPmAS+fdQnEkIBYyPZMR3heEroFRuPl8W/gYrEPfjtxF9XcBRyPycfwJiHIljggoM+PVCVNj00i1cf6i0EVIkSI+PPwxOSqV69e+Oabb/DWW2/hjTfMB03qdDrIZDJ888036Nmz5x/eSREiDPBxUaFThD+aVfWGRqeDq0oG4a/qtzLAtyYHj+77n/EPtyAArd4whh3YQ+59fYrbdfa4+NQE3IL+/H3+K5B7z7zPwRSZsSRfqVds96AYoHSmXcwUpolulVsx4lvuxGQ4y8LaFsrV0KZdg2TFUKP6cH0z4OgHhE+nNW7jRPOn3FXbMwBg7VzG7oc258yf4iwmqTl4mM/iMYWTN5B2lepV7+9pGzs6i2rGgHl8gn9qLm1/Ic2AwUv4tH9JX+t1VutobnE0RWYs902qIAla0o/Kkz3r1pV1QMJxqlJeVYFes6nWLOhGpaFaBwYbuAQy/W35IPNQkJo9qSouH8R72IDj33Ng8sgNJGKbXyARazyZJPbW70DNXtbDfU1xcTkVqQOf82e3SsZZQyo3EpEj3wH1hpKcX15NAlG9E+O+f3/bmDYY3BhIuciIenvnQuFMkh7enQW/KbEyhaMHLX3t32HCpC0lzLu6eZx7/BGqSb1n64dIS0mqtRpa5459Txtfm7doXUyPoZJUdwjv/eubSZgNULmzr+vmTnPFrmp7YOB89vsFNWDfnFTBqPqSPONDiNSrQNoVErCAelQx933KfYs7SHJ9Zb31cdXuyzEEzn6Aby0oLy9H32deRpYiAM/vz0duSW3cOVOIzEKqYYMaVEL3yABkF5TiRpEcdRs+BxdhJCSHvuI+2vie6vwjcFJTHXMO3gYA3EorwJ7rafh6YCRkAnAsNguNgp0wuI4LGmivQLp26oP1SG4kQ5VwHNGjt2F6+A24x6wEpHJkFI+CI5py8PuUIzzfGTdo2Wz6LB9EiONhRIgQ8SfiDxmMp02bhr59+2LZsmVWQ4SHDx+OsLCwp7WfIkSYwVn1/+iNd/Bg4Vi7L58e63Scd+XsSyuMPWTcYq+Rad+Psx8wZov9MIF/Eh72dD/7LrD1JYYpXN9s+z2NpwDOFg3rhiCLLp+z2N/9AW1wSlfGP0MAytWAzE44QUEKJGvHWRfZJbkAAK1LILQT90HIug0h6w6v5d3DwMbnGY7g5M0UOo9Q2smurKNd7vgP1tsSJOydOTKTNsAtLxoj1tu/T1IVd8j4/vjDJDcj1lFROvAVcHsX76mQ5ow5t7TcmaIwXW8fzOT5j9lCRceWslqmL74BErMl/UhMGozjuVyhTwEcvprWTsvrGbOVyotrkDm5AniMl1dT1QptQUVl1/uMO284ntZFG0NkjceRYV58596jnbH/PBK1jc/wfO54w3zbl9cCt/bQGrp8MMlU3SHA8TlUM5s+a90PBgAtX2bP0cMshrH7qLrpAPT/jYEopmE2Kneg7y+MxzfF/bNM3uszh6rkgq7WFrU9H1KtOzUXaPoc7bO27LItX+EcrfsWaX2x+3g9W7xCwqAt5zkszmGwhlTG/q7KLXkPjd5EZXPbq0YyeWou+/ykSpJfjZpELnIQ76N1E0m8nXyBtOtQagrg7aJENV8X/HzIPLp/zdl7WHP2Ht7tUQs7Lyejeu8ISLz8qDyesTFbzckHGT5NMWrOLQgC4CiXorRcg9fb+KO5ayYGRGZA0sQDODMfwvHrgHc19sCdX8K+LQDo/T0UGyZCYTLc3Tt2H7Rh7Rjc418H6D2LtmGF03/Xsi1ChIi/FH+4Qg0LC8P779tJ7RIh4t8KpcvjRVoXpLGZ3JRYAXyavHI445Bd/Gx/9p8C98r2lQInHxalRVksnOsOMfb7GBDakj1BlqjUkKl3+SnmBXppHnBkBpATzx4g39q0jhlQXgpAYMFaQey2RFMEyY8tgSptGZ5QkM7QipEbSJJu7aJicm4JUHcgi9r6Y4DkllQpHqxIShXs3GL2xZTkGImVwonWQFNiZYBOC+z9iKSz3du0EcqUtIkVZbKAtkdcXfwfkEQAVCkMvW2WCG1hbsnUlJHk1hlA0g/QdpZy2f72Tv3CobF39lsvu76ZCl+bN3lfKxyBjVN4TzQcx+3fO2P9OQCo1AhIvWb+WuQgqpO73gW8qnOdlqQO4Hm+vBZoMY0BD5oyoFIDzvhy8gG6fU0LXHYc+9qaPsdUvpu/k1yhgplpOh2/53JHYN9nJMApl43r8qpKctZ4Iu8LU4Q0Z3hMwjHbvT8ACU23r0iKBi1iWE52PBXeu8f4noB6JGK2cOt3quhSOaPYT//Ge2LgAipiaVc5LLjBeKY8eobRCnhmAY9BoyYRdvIh0ZY78l4tK+R7BIGDim/vAQQBaqkj1BodhjcNxaozicguMo6/kEoEjGwYgF5VBHjrZBB0OuSXqOES1g4YspzKW+plkuWAeiju9QvGrEnFF10D0dxPC1lRGjwCq0NxbCYkh+8wHXHFYKPNOOkcr3Pv2fxdIEjY45Z2zeq0SO7sJxmt2YOJjzKV1XtEiBAh4s+CGI0j4t8LQ9FZkAq4B9mfIfRXoCjD/pBUQ3N9ReRKp+PT5sxY/tcnHHALplr2JMi9D2Te4rYNReIfnXfl7MOhsoY+G1O0e4eFH8AUuzZv8Sn07b0s8OoNpUXS1jlwrcQ+oF/b2t7u1fX8fG4iLVr5ycC9s1QmHDxoSasQAtWaba8yfrrbdBaa6TEkVgAViuwLVFjcKzPQosP7VNqSL1KxDIzmE/4TcwCvaizCZSqShLpDaMezh+SLQGEawwPa63uyFnRjgEPUcA6UtURgfRbipmTWqxoJrCUqt+T6TQMmDLi12/j/jl7WDwBMUZxNS6YtSJUMNZFIAQhA/FGqB1qNXtFrzuMwJYMAC/rIgVSeDPAMY0BHQRrPefUu1uTFFLF7qZLt+ZDH02gScGUD7w2/OlSdirP4HTw2m/c9ANw9DkQMYFKjLVRtz+HNJTlUM+8epvXXxZ9E0RBh3v5dpg/e2EEyUKMr74dTv1K1s4XwblRA931Ke2ilRlxnYTrPVctXGXBigEQG1OjCnq2CVPYCqovYQxh/hL8PfGtzpp1ERgW2vBSo2pFDpPf/j3ZFvzq8d2O2UYUtSOP+ZtykepZzl3bCOgNJijRlQM5dlFfrgrln81Amu4NxzUOxfFJT/HwwFnuupSLU2xGL+vnD88oCSFdvQj+pAuUYA22dgYCmiPd+cRaDNfr/ijKlB25kSfFtV6DaoRch3X+K93Pt3hyaPGAeh1db9m/qtFSuu35lTJ20hzPzeA3+v+b4iRAh4j+LRyZXhw7xiWvjxo2hUqke/PwoaN269ePvmQgRTwp1Mefg7PkMcB8FLO4HNJvCP9xPSkaexj5VBDtDdAGw0E69Cizpw0LTAP96wLDl7E95HKTfBBb3Mo/xdgumbehxh8uaQuHEuT7+kcDBL2kD9IsEGk8Crm9i6pzheA58QUWg4XgSLYWj/fVKJHyyb+8c6nRUeBJOA43GAStHGAMnlK5Ak2dY3FsWag/WL2egQZ8fWeDLlIDMgX1ABmTcZF/L4RlAz29p0/r9XR6zVzUSgdCWHDbc+nWSg6QLwJAlwIUVwMVVtCjZPUb9r+KMGyQbMhXQfy5QnEtborachaRGrxSEtQOaPW8MiAD48KDOQEAALYDxR0gK64/i/mx81nq7rkHGBDmA5L3OAPv76V2DPWe2EDWCaZGeYXyf0oWKWEku7a/tP+Qw490fAnEH+JngpkCrV0hqNUYVBEENuR2DjVFTxvNiD3JH9o/VHQoENqClrSgDiOjLdSRfYPx5ymUAOu5Pja5UnCRyWh5tkUqZA0cDFKYbX0u5rF+PCbQakqSwNrzXDk0noS4tAPxqmb/XM4xWP88wnp/6o/mZ1SYzzuIP0444djsTC6u05oyv61toRXYPAQbO46Bh6HjPOvkyNn/3+0Z7YVhbJmze2Q84+7OnMesO75uhK7ltpTuQftW8z0tdTPtdxi0gegQ0IS1wq9HH+GHpXRSrU1DF2wn1Q9zh66zEJ30i0CmwFK5Lu5qdJ1nCEeicPLheQ29qzFbAwQOKcTtR1c0bjgfegvT+KS6rOwg4OVf/YaX9nsaiLJI/QWI/wdFwTW7u4sMNZQV9niJEiBDxlPHI5Kpt27YQBAHXr19HjRo1Hvz8KNBoKugZECHiaeP+OWBRT0BQkFzlJgDbX2Wx2XMGn87/1XDwsm+Zk0grHtCZnwQs7W9OrAA27e94E+j386MnFOanAiuHmRMrgAX2mrHAqA0s5p8Ujp4MGQhqQEIkVQKHvgEurrR+b2k+gwUepQ9C/pA0SIUzUF5Ma5ppkl+1jizCGk2gimAL6gIW1tc2MnJdp6WdyjTM4c5+Wg/PLQa2vcZeLKmctj+vMNrWtBomkWXcIjmq0hJYPQbIiuV8J53WfjJbzZ5U8Yav4XpSLwOJp7gPtXoD1bvSwqYtJzEoK2KBbFCB5I5Ap4+BSyupSNQdwnh1TRngWY3E3BYC6pJYn1vMn/Pu815yCzYnXQa0f59E3xJB9Wn7k8pI6C6u4L4YUJAKbH6On288kVY4TSmQl8x7sf5YkrObO6k8uQcDVzdyvpdrIJWpbtN5jWwhagTgWZUEvlZPBjpoykgW3SqR2Oan0WJXqzfJx6XVwK8dqEL1+YG/N65v5rmMHgskgtveOQ3oOZvX1FZ4ipMPvzM6LRVhiZTXxaMy5zrVG2K02oU0BZq/wPvGYPUL726u2hlQlMW+tc6f8gHBimFGu2biKVrkeszkuiL6UV1b1NP8/rpzgGrdyPUktMXZDHbIuw8cns5z4VuLlkdbSDwBXaeP8XvEN3h92V0Uq/m3/Ls9N7FqclP0jgrCoZgkSJMXmxNQAGg0EcLq0db3e3E2sPkFOPf7BYKBZAO0wRbYnmNoE3GH+L05Osv28hpdgVM/A1XbiuRKhAgRfykemVx98MEHEAQB3t7eZj+LEPG3QkEasG2avpC1WHZtA3tq7JGr8jIW2ekxfOLsX4dKl4PHH98vZx+GYJyYY72s/jg+dbaH7AQWp7ZwYzt7hB6VXBWmGy1Rlki5xOV/hFwZ4Ohp/P9G4zirxzIaW+VGO19hGpB5h9v3qGwMTTBN9HL0JmG7f9Z6W4a5V1XbAzvfNL4uUzJZMOE4FbTu09l/kpvI3qLGzwF3AMTs4Puvb6GysucjkrWqHYxEQqfj6wPmAVlxTHu7uYNKiYs/0+JSrgABdfhzURagLmQ/SOQg2sUiB5AgbH/NfP89KlNd0JQyOOPSSp6rmj1pl0u6QBvo7b3seeoxg2rKiDX6niwl4ODG3h+Ddc40QKDp8wwD2f2BkdxL5Uz+cw9lOmBAlDGV8Xe9xe3Y9yzIdXqlp8P7JEIRfXn+LixjT1TkYCpVSRdobVOXmBMrUxyZCYzfxR6ke+eAKi1ImG5sp8JUpz/DPSRSEq/iHKYarhzGc1x3MEmRKYIa0A66pA/7dHLv8bxcXkuLm09NILwH1Ty/Ojymba8aP5+TACwdQDVwwHwW/xfXAWhBJbHj/wAXXw683f66+bYFAejwIYNIRm1g35hOQyLu4geEtgIcfZhaV5JDgpYVy6Ha987wPJqmYVoidg+g/YCz0Gz1we16l3O6ygqAvf+zTdwLUkk6zy1mUiXA4JEWL/P96hL7aYkAkHQBgR6d9HMESa7uZhVBqwP8XZUYE+UCpyVbzD/j5MN7xV7v3r1TENQWan3GTdr47h7jfWpvTpXKHZA5QFN/PCQ+1SFcWW/9IMA/Up/aeR2lJcW4mpANNwc5vJwUcHf8C4bNixAh4j+NRyZXH330UYU/ixDxt0BpnrEPwhYSjtu2Z6lL+JR3zRjzp9PRo1g8WSbYPS4UThzy6eTDJ60lOSQXzabSSqesYKBloZ1BqABJZPlDLIemUBc+ZPljrOtR4V6FBfW2V6gOAIxU7zGTxd3CHlQYDFC506IYUM/YJ+fkBfT/FVjcx7yQcvCgTW/Px+zhMi3mqnehberm7+z9OTOPwRhO3lQuYnYAih4swt1DWTzn3SORcQ8xBjAk6IMFUi5xXa4BVLKaPk/7V+Jxkr+oEVQXzy3mLCtD6INPOG1uG55lTPjw1VxWlMltBDXk+7a/Zt5jc2IOcHkN931BN6Dnd8DwVcCm50mQq3fheRQEPqU3zDyyRHE2FbyJe4zn2T+ShO/nFuyhGraC6tCZBSTYZxYAHT8Eil+kwlhWACSeYSJjUDSPt+d3XFaYQdLg6MU5ZZ4VpMSWFZJcXNvM3rK5bc37wE7+QoI4ZDlDMPZ/ToVi+Brg+laerzqDeF3VRYzb1sFoeTy/hCqOayVa3m79DtQdRiXs4NckxecW2d63O/vZpxc1gkT4YgpJpzofODidaZFDVwCn5wJZ8RzJUH80758r62hru7aR+1WzBwAd0PkTPrA59BWPy8GTtsuIfvydIEjN7ZCW0OkArdb27DKA31fDd7ai2Wt3j/JYDOQq8SRwJxKo1Yfn31RV96hC9VkqB+4egyCVoe7J17Fm2KfovywRBaXlqOrjDJlUwL3sYiQmpqO3zIKwSBXmqYo2j01rbtc9v4S/ExKO8yFIxw/NSTAACAJKun2LI0VhaFJyFC47+wK9ZtGVcHMHLZ51hzAEZ+VwwMkHZ5LVGLGa3+G2NXzwxYBIBLj9RXMRRYgQ8Z+EGGgh4t8FQWrfegXYJzF59zm00zL2+vwSNlo3HPfHAzGcfYDmL/Hpe3kJlRXnAFqpKoJnBX1QShc+4X1UOHrb7z+SyJ6OSmcJmRwIjAJGrGUPkSAYt7NmnDmxAljsLRvIiGjTGWBeVYFxO5ikdu8MC2aVOwvy3j9QwYrox6Z8gMpB2nWShQ1TOE8KoFJRqTEgdQRyQJVGLgU2Pmfed+PgAYxcx0L+7EIAAq/dtmlAp0+olBjOY34ycPgboEobFqaxe6moANzHuIMkdNlxLMRDmvHaHfmOPVoqN3NiZUBhOq1qNboCm58HRm/hPTp8DdWeU7+Q2GjKgEkHSMJMyUqDcXxAcOhr/XDjcA4mvnuMCYU6HR9ILOoF9JtLwqQtZ6G+pJ9530u1jrQLFqSyr63t21T2Wr7Me2fjFKbUWRbalpDKmZIXVJ/x2pYJgqX5fKCwuI+x4L+zn2SyrCqVqAj9dzHuMHDmN3ML5/WtJMC1+/K8b3qWRfullUC1uQyAsIecRP357gUghdd1zQij6urkTSWy+UtUN5f2N6ord4/y/ffPkiCM28FztXQAi/2e3/IhDnRUxqNHk/C3e9v+/lRqRCWsIpSX8Hvt7GfbygmQbFrOdrq0ipbE27uBWr14P3WbznN+baNRPQ1pBsmBL1D1xHuY0uRdzDiUgte7hEOj1WHUvFOoHeCMjnVHw3G/SaJhfjLVRHtwD+UMsToDGeEP0HVwdQMTNw9+RbVt6HLozi+DkHUbGq9wFDR6EV+f0aBvzQK4HHif9+eKIfze1RvG70bMNhLfklxkd5yJWaeMSaEHbqbjvQ1X8O2QKLg62BndIEKECBF/EE9MrvLz85Geno7g4GDI5cZfUqtWrcLmzZuhUqnw/PPPo359O7HAIkT8GXD0Zn/KzR3WyyRS2mFs4dom+/OEjswEanan3euPQip9/AAKF382tNuK8W457fH2y8kHiBoFnLfx9L7RJBZofxYcvcwtmZm3gTt2EuAK01koWg5Ydg9mH0xgA6A4EzqdDqU9vkeGzg1FmWWoHDUWigvLWKhl6y1h8UdY3N7aBRz9Vp9qVwJIVEC9uQw+ODXHOtAgvBuLtxpdmTgoCFRp+v7EQbm2CGrcQQZ47Psfk/6kCt5XpnO9tOUMLDDgyjqmwNnDzZ28ztc3U13tNYsKq2kP3u4PgOvbgAm7SJyy7/KY5Y7A/E7Ge7swnecjajhVU8MMKJ2W56b+GM6SsoWIfgwkSL7EnzNjGQOecYskTa7iOrp/w3vSsq8PIOE0hEGcmEOCJnMgOUo+z/XUH8PESdP+RENkeP1RwNkFVJ/UxRx8PGQplUuDvU5dyPTFmzupIFXvYow1z7rDaPH7dlQev9oszqvrRwLs+cjczlqYwUHLp34l+TdVgp18jMS25TSe8+M/kqD4R3JmlEFlUjgD43fymO6dpZp1ZZ35vsiUQKtptKG6BgJ5Sdb7K1XQVpodzwj/fZ9av0eQsHft5E/mr5fmQ+sahIxKXeAdXANCeA8IF5byHjMg8STtn31+hHTFUHRv/CEUTjXRpIonTsVloaC0HKfic5DVrRcc/NdBSNHfGzotELufBPL8Yov9EUh23YKpFktkwOVVPF9X9T2fgxaRtCpdoev2FYq1EtzNl2LE4svIKizDpAidkfjrdNxn0/0uyUdWlx+wLq82TsWb34d7Y9KQUVAqkisRIkT8aXhicvXGG29g6dKlSE1NfUCufvrpJ0ydOhU6vWqwcuVKnD17FjVr1nw6eytCxMOgcgG6fs5Cq9Aibar3j/bJQ8Yt++vMT6p4kOuTQKOmLUwQ2JNh+VTZFE7etIbt+4xFiEZNNaTVa+wpkj5GkaByBTq8RxXt5M+0e6ncgOYv0uJUUWrf40CrrfiYAP1TfBMonGiREwQ+/S/KtP05iRRw8UWO1B0XEnNQVq7Fd3vO4VpyHoI9HbB68Fb4xSyG5PomYwhF5GA9IdJZhxIoXWj5M0X36bRQrRhqtG15V2dPTmk+i3d7uHdGf58JLPzTY2DdAGgCAVRc7UGqNBIN10AmD1qGmwDAvZN82n9jOy13985Q2bJ1715YTnviiTnG5alX9US+DUmiKWr1JsloOIG2xF6zeB6WDyYpDazP3qjLa9i72PM7qoWmseuuQYzq3zCZ91ybt3hv+4RTJWz3DnB+KfuQDn5lvc/dvibZMR1pcH0Li/ghS2gDUxeTBO79mNev92y+P1GfVHl+KfvPVo+2Xr/KnSTo2Pc8BsB+f6K2nEStzVsMiNBpeG1O/8b7N6AeFcWE4+yRWznc/PNlBcCC7iRYKVeAkCZUBk/9SrIf3BioN5y2U3URCeuqkdaEvuMnvHfijzIZsHYffYKgHlIFw0PUxUxTNIVvLVzLkWHkVgUmtgSeC3KFYEpQDMi6Q4WwSlv4O2jRuLIn3B0VuJdttBCPXZeI34f/AmnCUT7EkCkZluIeyrTEswtJtgOiSMh99TWBiz+/a23eYH+dTAFdTiKEkhzoDs+EEH8IEqUrZPXHIzhqHMrKefw6ScW/87RulTDlmA6n420QfAAFpRWkDIoQIULEH8QTk6uDBw+iY8eOcHQ0FmNffvklgoKCsHz5cqSkpGD06NGYPn065s2bV8GaRIh4yvAMAybsAeKOAglgb0zUYCpGCjupUWFtzaO3TRFQ7+FpdY+D7AQWYVfXkxg1GMfggormsbgG6ouQ10lKFE6AyyNYCm3B2Rdo+xZ7vcpLWAS6+D8eSbOFokw+QT+3mEV13cFAQDQtWjZQrnCFTOnKQrPNmyyqDcVdw/Gcv2VAcTaDCi6uAEryoIvoi1KHapBKnHDkRjLm9PSBc7kMao0OjnIBxTUHwClyAInD0BUMiygrsL3fEhkH43pU5vsVLiR3hrlcBmTcog1s5Hr7yY8Araf+dXkeUi6yZ09dAhz43Pb7o0dVHGgS0Ze9XgCLf3vrAVjYqlxZzNYZYOyxkcrNe3s8KvPaR/TnfWggWCd/YoBD0XN8XSKjZUzuwITCnW9S9Yo7ZK603D3K3rS+P/G9J39hj1xxDpMXvavzPtv8Au+NIUsZwJB6xbgOQQC6fgk4uLM4N1WMPKqQzNmaFVdWwAHPdQYC6depgnX6H8nE0e+BmC20mp36hfdQ3GHu5673jATeL4LXae/HJOKwE9tv2M82b/F7dOcA7/mwNhxx0O5dnnPXIAA6qlb2ZjGV5lFp8qpGhbVKaxIQqZxEd+VwXqPKLbnNYStpU067xkCMhuMAQYpSnQS5NUfAV1rIwI6o4TxPCmfALQi6uCOk9gXmvZvF7f6H+RcKkFOkRlSQs/1eNICqadPnUSJ1hotCjvvZRWhW1QtKmQSl5VrcTitEfJESleOOQOrsy3tt1/tUSv0joR20BBKVM/v7HNzN1610NrNrl5erIZ/fEYLhfi3OhuLoDMjj9mN2z1kYvy4R13JkqOJVzTb5dfBAqVMgTsdfsV6mv3wuKlG1EiFCxJ+HJyZXycnJ6Nq164Ofr1+/jsTERHz99ddo2bIlAGDt2rWPNQ9LhIinBvdKTB5L2M6eBvlD/piGNqetxzJOGGChZpp+90eQnQDM62ie/rf7fSagjVhdMcFSOAKKyk9nP6RyWuyeFoqyOAPq+I/G165uYErf0GVMbUu9yv4xv9pIKPfA6lN5mNT0VbipZEDSec6+MuD0byQHXb/k0/cTP3N2lh7C+SXwCYiC28AlaBSeDFVGIgmiIAGSrjN1DDqqZ25B7EkatgLIiAXOzjfOAQLY+7F/qbFwHzCfhe+QpSQdmlIqHnGHeH9kx1HlOzPf+jwIAp/OO/uytyukCdWHxlNYRFsWgyHNuI3CNPYIWUaN+9RkfPfRWew5Uzixad8eJDKqhmfms8ju9jWvc2kBi9rky4yOL8pkoIWzH8nn5TX8FzGAylJpPr8Trd+gEnZtE4mQRMp9NvS1mUKnY2pe/7mcwbViKDBsFa/7xRXG4j6iH/uiUq9Yf37nW8DE/SQ455cYlwXVN7d9WSJ2HzB0OVWfjc/yXDYcB/zWkcszblJ9u76ZA4M9PmMPXmE6H1Bk3mEvncoNqN6RNkuvSbyP7h0331aHD7m++SZWzgvLSILqj+bDnWPf87tcpTW/F/aQHceeu5M/sWev+zc8znunAZ9w6OoNh+Dgzt5EiYy/06JG8FyeXwZU64BspxqQp10Bkg4AUSOgu7oRQsplQCKBpnZ/CI0nAQe+gmAg2J5h0Hb8GIcLAhAd7IK8YjUUUgGSinq7dFpovapj/sVi/Hj4IJQyCfpGB2H+2EZ4btk55Bar0WfRLeyb/DHcY1ZAce43oDgHmqodoevwIaQeobSNPgTFeZlQ7H7fZsiHkHQO0S3S4O2swFdHslG/9xwEbBjAe9UAqRwYtBBqBz80q5qM47HW6nfn2n7wchITA0WIEPHn4YnJVWlpKRQK4y+ogwcPQhAEdO7c+cFrYWFh2Lx5s62PixDx94J7MBvQt7xkTF1zDWJxGlDv6WxDo2YDu61Y9dTL7G+I6Pd0tvVXIzvenFgZkHqZVqf0a4wSBwBHLyj6rcGWK3mo2rIj+rjdgeT3d60/e2UdlRWvambEygBJ1h0oijMgQRnJRHoMFchGkziQNfce3+jkw7lUchXtSN2nAyoPEq27AFaNAor010Tlzrk/V9cDJ34k8XH0pL0wtAUJYNJFNs/f3kvSaIrOnzMRbvvrvJ4KZw5/TbkIdPyIfUoxW0iQavdhMb95KonFuJ3svbq+lYpFja60zZ1dREUkpCmf/Ef0577ZQr1hTK/zqQlAMJ4XA8K7My1z5yRjAXviR8ay+0fSIilT0upXnE2VKbQFe+WubSJpLMrkeS4rYO+SqVUtO44/e1YFJu7lNWzxMs9bURZ7pJo+z4ANW8EzOh0tidEjqYQZwk7KSyseN6BwIlFaM8Z47zQcZ1x+4HMS9art+CDjwlJ+v92DqSyV5FKNcvDgeavVC0gDe6dKs/gApCCN18M1kPZES8QfobUvdh9J1u6PeBy+tezHrfvWpqJmiJdfNpAksN/PQPpNCE7e5jOwDPPIAGDAPGgCG8Jn4zOQJuoJ4MWVEGr2hDZ6JLJ9GkOmcoLbin4MxhgwH4AOKEiF5MAXqNfmK+R6haB+iDt+2H8boeFD4Xdzp83d1NXuhwvlofjxMJXQ0nItVp1OxIWEbHw7uB4mLj6DglINus67iR+GjkOD6FGQCDpIlC6QObrbv24WkKgLIb172O5y17u70L/+WMw9FIcpu6WYOeB3+CbthWvqad6/dQYAbpXgKlNixqB6eHPdJRy+ZbTQdqrti496R4j9ViJEiPhT8cTkqlKlSrh0ydinsHXrVnh6eqJu3boPXsvMzISzcwUR0yJE/J3gXR0YtJDFo0bNwtc95I+nBBpQlMmi3R7OL2FxLX+EvqfiXKDYsJ+utAg+LWg1LCR1Gu7Lo6h2piqDJS6vYnCBgVwVZcJ/6xh81G45TtwrQZ/bC+x/9thsoMmz5q8pnEmYavWGpCwfWDee+yyRcUCraZ8UwGLf0ZMFfvRI2tZitgMqTwCRtOVpS6hWBdZnr5BpD1ZRFgMqBi9lRLwg5dPygfNp0Yo7zILbQJYy9LYwQSAB2f8ZG/j3fwa0/wCo3plDbs/MM+/1K0hm9HjLV/XBHfp1BNQFCjO53we+AOr0A27ttE5ZrNOfJMjZF+j3E7B2AvtlTHFjOy1Y9YYZC3WdjoN7u31NEhA5mIqNWyWeh5I8qjENxzMwpqyA5EnlRjvnpdVUvQwoTGf6YJ85QJVWvJc6fkKF6OIKHoNvTQ7GPfS1dS9QcTYtiO0/4HmOP8y0u+qd+HlbqDfMfLZXeQkVTwO0GhJej8okLwpHWgF/aQ2ENqNl8domhkKsHQeUaxh2snoU4B4IDFlGS2StvoyRt4drm6hsKZyA5s9TkW35ChXD7FgqqAYLpkTKOW+m/V86LdXLRhOojrn4Q1dvGATL4w7vxlXcOwEh0URZ0yf9Sa5thEuP2dC5h5Jcp8dYfUd9jn+CjLa/4r1d9/Fpn0g4Kf2gC25mvj4AcA1CZu0xGDjnhtXh3kgtgFwmwcHX26JYrYWzUgY/VxWkEovfmUVZvC/ykvT3qB/TPC0hSPgAwY6Ft1zpganNq2FA/WDczylGkaMC6kZTAIepVj2ege4O+H5YNDILypBfWg5XlQzezkqRWIkQIeJPxxOTq27duuHHH3/Ea6+9BpVKhZ07d2L0aPMm4Zs3byIkJOQP76QIEX8Jsu/yifR1fXKgXx3adALqPZ2gB0GouK9Jqqo42MCAzFjOfzHMUXIP4X6Gtqh4XtajID+FYQcnfiQZrNQY6Pwp4BsBKO30q+l0LMDtoazIvNAFgNxE1HAsxDWFDBLT6HBLlOYZe5tc/BnUIHek5a5KG1qpAutzBpF7ZSbmWVqKWk0jOWr9OnDoG+M8IENaoLMfoHLWx0fXsA63EASg5yxGVl9YZlx/YH2GI6TFsIg+/gMJ14YpJHFDljFIwNmXBePQ5YCmHMi8BVxdZD24NTuBhbl7MElQZizT64IasjenSktGmN/eTbKWm0hSJHcgsfOuQYUlaiRQlG1NrAy4uoEPEQzkqlpHKqY/tzCfE1alNWPbt71C4jpmKwmK6fk5At4fAAlW5ZYkvjW68P6MGg54hFHF2/KCkVjE7uUsowG/8T4zJZmBUcDBLxiKEX+ECZ/VOvLcNxjHtEBTBEbzM4e/Mb4W0pz3nGWvWXY8CXuV1kDkUCp51zfxHhu0ENg0lT1bEhMLW9Yd4MCXjKqXqbjvtiCVA23foWXSNBDE0Yv2yKIMbqc0j5a++qM5T8zWbLnCDN5Px2ZD6PAhMOUgv0c6HR+mAEDKFQgVPNRQnF8AbbMX7C6X3D+DWh5arO3tCKkiBZA5Mnzj7mHggr5Psc4A6Gr2hjq3AL/0DcLHB7LMgiwA4OjtDLSqXsvudpCXxF6723uMr3lV48w2r2pmb5W5+EAdNQbyU7aVWUlEH7g6KODqoEC4fwVKph7ujuLQYBEiRPz1eEicl328/fbbCAkJwcyZM/H555/Dz88Pn3zyyYPlaWlpOHr0KFq3bv1UdlSEiD8Vuff4tN20uT/1CrCwe8VDiR8Hjj4sDu2h8URash62nwu7G4kVQKKxfLA1KXhcFKazuNz7MYs7nY5F8fzOFQ8oFQTO/rGHah3YQ2IBSVkeTqdokFu5q40P6VG1A0lVveEsUItzOQx2z0e0oDWcQItaeSmVtjr9+RlTeFVjwR93yPZx7H6fQ4qvrgPuHrFeXqMbCdHZheaFetI59vdEDmBEuJMPC2x1MZ/Ul5cAv7/NfqniLO7z8kHAjZ2ck9VnDve/Vi+g1atGMrCwOz8Ts5XHum4i0P5dEm9tOcnImjFUcQzHtucj2llz73N+lS3rqQEatXmCYJMptMOaEiuA5yvhBIlNjW7cnq17bPf7DC9x9qP17sIy3sclOcCyQUy72/mWdWpheQlDD0yVyYB6VJcSTzESviCNvVB3j3G9jp7A2G0kJpGDSXgaTTAOEQZ4Djt+yMS/bl8b56q5h/AcO/kwnW7DZK5vxBo+mCgvNZ8RZoo7+0jMtrxIQmYLEf3Y02WZtFiUSbtfeSkT//b+j32cd4+SRFtC7sBZYdpy7nNAPeDwTGBRT94bO9/mQ5DiLF47e8q6thxqeQUExNELkrvHIP2tHfBjY2DtWKAghcO1u3zOfru4wxDmNEbAsrbodGIsVvdzR1Uf84csfq4V9FKVFTIm35RYAew9XDrQavyBVK4Emj0LrW+E9ao6fgadSwU9qSJEiBDxN8ETK1f+/v64evUq9u7lU7zWrVvD1dU4zDQjIwPTp09Hly4VzG8RIeLvgntnrftnANp0dr9PFcIy5epxIZGwJ+DiKvYimaJmLyplD0PCCdvzgwA24Q9f/eThG7n3qYoYIFOyYKzUiETGr7b5nCpTBNZjQp5l8a1wZirhyhHmrwsCSh38ceDmPWS17g23C79ah4k4eHDmkUbfb7N2HAcm1x9NG56TD7B8iLmF6PgPJC2luYwil8ppLYvoC+x8x/6xxx1kIp2zjZlhkQNJPmwhO45ziA7PBAbOY0R7nYFAk8nAwp5U1KJH0qpoUOCy49lP1PwlFs9atZGc/tbRmoSU5pE89ZrNc1KaT8LqGsR79s5+fsajCotjrYaWPXuQqWi/AnjN7p+zn3x4YRkJikRq/xzodByAPHEPrY8XV5pvqzTPOGjX1vlz9qWNru4QWiZzEvi5+CMMxgBI7MK7MxwisD7j2yUKEu/YvXx/eQlQuRX7pAQZkHWbQRVTjgBZsSScfnVIXjY8y2TBe6e47mGrrAM2LI/RyZt9cK6BjBi3/H1RszewfoLtz5fk8Bw4+ZBQLO0HjN/F471zgPtgGITc9m2mHwIkqxsmmyf9xR8G7p+hEhp/hL87TOeo6VFQazAKHKvA397Q8OjRxgG+AL8vO14Hunypnwn3nfn7s+MQuGkQpnfdiP7LuK8SAWgXXkHSZUEacGWN7WXZcUBukpWlWe4RjLJhayCkXYUkZit0jl5AnYEQXIMgd3K3vy0RIkSI+JvgickVADg4OKBnz542l9WuXRu1a9f+I6sXIeKvww0bQ4cNSDzJwuePkiuAhdmI1Vzn+SW0AjaexP4P5wqKFANi7QzdBaik2LIYPSriTVQb/0iqKxeW0xKlcKJqFDnQdrS6SwCjoi8sY+9LWREL0SbPUHlQF5m9XVNnME6lSbD2mWYoVkpRMnonFEenQ3J1HQvZ8G4skouzSKBMFYXkCxwyuuUl694MjZrWtZ4zgbXj+bNS/9CnNBd2UZxDEufgQWJiOp9JIjNPJLNEdjwL9pI8kjOpAri6ERi8mCTm93dsk5fjs4Hha3hPHJ7JniJ7cfFp13ksXb5gkX9jB+1q3tWAps9y8G1+kvH6591nUqMliQdo1TPMQnJwt52QaUBJrnEMgaH4t4XiHGDHm+zBqt2X96KjNxDWztr+aAlHb87NuraJyk6PGUayZJg3VZrPiPyu+mCTxNMkDHIVrate1Uk2HdypGpbmMcpf6UrFxzBwFmAKYof3gDVjeU7LCkjaOn5YwT56Ahm3gZxEnteeMxmPf3EF1xHenUTaND7eEvnJvL8K03le4w4wBdOvNhMbzy7k3LpbuzgAuVJDknWLCHUAvM4XV3AGWtRwkitBQhVLqwE8w6Cq1QXlmfdRPukgZCd+MI+ED2vH7/iRmebrzYzl76GzC20fQ2EGAkti4efqjIyCMnw/LBp+rhWo7WWFFc8IzE8C0MDqZYVHEOARBIR3tv6MCBEiRPzN8YfIlQgR/xpUFEvu6PXwgbiPA9dAKkI1urIgepgV0BReVe0vc/anwvCkcPDgf+WOJFarRxtJRWE6sPs9FnFDllAxsIRbEMMYokcB0DJ5T11MRSI3gUWv0gVoPAW6RpPQsNQZvx2Ow4bz96GDDhOaPIPnJr0Jp/zbDJwoKwJO/WwkVhIZENSAhbfcwTzW3HTuVEkOLXSG13IS2LcT2sKcQJqiRlfa0A5NB/rOATY+b9yuTstzYkEQH8A9mGl+v79jbiE9MQcYu93+IFqdjjbPvPsspqs8xEKtUbOnzlQFu7OfaYLDVwH7TaLs939OZWTrK0aro0RGe2WjCSRCEimvSeWW1jO9DPCtzV5EdRHP/f2ztt9XtR1QVI8EsygTULoBPrX4EMGjMgmnpe0QIGnJTQTWT+LPgkCSVJrL62y4n6t3ZgjGhWXsMzPg+mZe244fUQE6MtNo3RyyjHZBS9Xs7jGqfLX7GoM47uwDZJ/zPrCVmNf8ReD8YlolvWswnKXheKqUKjfeI1l3+LvC3vBrr+rsPzIg+y6Hecds430zdDmDL079yuUBUdxXe7h7nGMm3II5168wDdBpoXMJgKDTQraoB9wL0wGpHJpWr0M79nfkx56ES/XmkCceY2+gARIZ7wOVG5XUCvog3Qvj8EnvoagZ4ApfVxUc5BX8zlG6GImyzZWF2v+sCBEiRPxD8cjkavz48RAE4UF/1fjx4x/pc4IgiEOERfz9ETmQyWW20Gwq4GQj2eqP4kkGE9fqw3ADWzafFi+z7+VJEdqcxWzdwXxybUutuXeKKootcgUAUimVrbwkEpkbO2grHL/LSFJc/JGcp8b7my7h6G1jIfrjkSQcTyjC8rq3oDq7gE/xDYpig7FUB+KPsNCXyIAe33I7IY25r3JHqkhHZpKEDJzPot6zGu1PXb8k0Uk4TutamV5l8Amn6qAppa3xwJfAmC18ql6QzljzBmOAEz9ZH69rIAvq65tt9+YVZ1V8zhXOjE4vzWN6mj0Ll5MP4ODGvhhLFUxTBmx8jn1Z907xNaULVZTu3zBVsjCDfTw3dgI732VPjURGO6x/JNMAbQVgtHyZ56N2X6DTx8Ci3tb756/vk8pPoa0sL4kELv4wCdGZeVzPQRvfr07/M0/5ixxMdVan4zm/uoFKSr1hvG6mxMqAxJO8J2NMwkxc/BkgYc+OeGUt+7UM5EoQ+Nl6Q0m8Lupfdw0Cmk7iuuL0MxuPfsvZbZDwfivJpb0TOqDpcwxPsYRvbb7PVJn0CTfONcuMpYUxoC5tmAkn+HDB8MDDFhw8uK9ZseyV1B+rIHektbB2H5JmjRrSA5+joHd1vHm/OV7wU6Hu/s+NZDdyINB4MlVCjZoKYQUkURUUiS7VHzGd1NmPoSjHf7BeFhD1dFNORYgQIeJvgkcmVwsXLoQgCHjzzTfh5+eHhQsXPtLnRHIl4h8B1yCg78/ApufMi8dqndkP8zjKlU7HwlamfDox7gXpLJwkMhaNQ5cz0MDUghQ5mH1Ff2R7zn5Av18BbRmwdZr9911aTaXCHnLvAUv6MUoaMKa79fyOhZxUjqyCQjNiZcC5hBzEd2iHmm7BnAUlkZFYOXqaz/s5/RsQ3Axo/w6DSAzwrcXr6FaJjf95SUyky7gBzG3La1u9MzBwAbB/Oj/TZw5waQVJwp39PK8SGQtWlwCSw+iRLDYvrzHOZvKqBnT7ClCXmkeRmyIz1nYvGsBt+NY0DjS+tplF7smfrd/b9m1a20ztbabIT6ZSCNDC2VVv5ZzXGajVk+l9mjIgvCv3adkgqm1yB1rPen8PnPwFuLHN2L/V5k0SioAokrXjP9LqeHQWA0oUzgzyaDSJ87RMC2i/CKqP+UkkSK1e5eymM/NJSHxq0Q7r4EUi4exLJcglkCEXLV4m4S06yut5dZ191REAzi0CanY39k05eFqFJZihvNT8uxLWjt+xteOZ+Nf/V+B6PqP9Lyw2D0LJjuc9sKCLUeGRO3BWWNX2JL8nftIrqBLeb40mGtU5gN9jlZu5kpV4kgTx7hF9muEgKoGWg6UNaDie13zfp+YkUl3EPtFBi3ju9STJ7cR0dKz9IxZdLsKn9cbA4ewvQM2eXM/tvbz+JTk8hqbPcr2WcAngPatHiVqDtPxSXEvKRbFag7pB7vB2UcLNEHcuV3HOm6YcODvPSH6rdgR6fUflToQIESL+ZXhkchUXxwIgKCjI7GcRIv4VUDpz/k1IE84tKsllgeMWRNXgUaApY0/GxZUsxgKiqL64hVA1eFyUFAC58SzU4o/ySXWDMSwEp57VzyDKZRS1s9+TB1kYoHBk8Z2XTGJozwansBPJDtD+c3imkViZYuvLtB4pXXA7zU5vEYAx65JwePJWyBMOQ6g7mGl1K4ZavzHxOFWOKq2NqkLadWD7a1Rs/COBLp8Bi3ub963c3Em71aitwNl4kg25PvGs/liGKKwcSsLd/j1g1ztcf5u3gcmHaXEUBJLIzS9SBbJ3rk7/CvT9iftv2bPU8SNAqwWqdWKQyPklfK3HDJKQnEQGMLR5Q2+tekg/ncyBhKhSQ37WowqgKye5NY0vD2rAHicIwKm53PcaXYGOH1O1dPIFClM5Wyu8O1WZuW1IupIu8B5s/gIJSsolEg3TocaOnlRqLq8zjjA4PIOEt+4QWuly7jJJcchyEjaZA69BcTZ7EhXOVAIlcmDlcA4ErqifUF1MotbxY8CzCvfJMv7fFM6+RhVJ5Q60eo3JfYY5U4IMQJg+5dDC0uZTk9HxA+cB6yeTvKiL2Vs4bgftfj1mMEzFLZhBGpueMxLjgCigwwe0bJpC5UaiW28o7XLJF5nS2PxFxsebolZvqkubnueDjhYvcjyDYXA2wKj9yIEkTQCQHYdgVxne2ZWCgUPGoH5RBpQtnqWaaRpjH7sPqNEVuqbPQTj9m1Hh8osgYXOrBAAoLC3H7mupeH3tRag1xmHQo5uF4qUO1eHlrDSe604fkrCV5nIsgZP30+lhFSFChIi/IR6ZXIWGhlb4swgR/3gonQBlGC1Sjwudjmlbi/sYi5Hbe1gUjVzPfp/H7dvKus3oZUNRnh1H0lazJ5WJmj0efz8fBoWTPuFuNHBsls23aKOGo7hUDSeljZldhRnsiwmIIjHNvcciUe7ApMTCDEDhjOo+KgiCUQQyRVSQE2S6MggqNxa9loWlKS4sB9q+ZSRXAO1tpfmcPSWR2Q4EKM3Tz3nS9zlV78r5UGVFeiKhZvLiqlHGIvzYLL39C0DKRSa6leTQllW5lfk+GJB7j/swYQ+taAnHWXA3HE8b2P5PqYw1mQzs+4ypgF7VGFLgHkLVa+UIRsEPWWq/90vlRnKSnwKoS0huSvOp4BiK+iptOfMr5RLtlr61qAoenkmCUJJLMgOdMQzENYiFuyGUID+ZNkFT1B1ifiGbv8QCXZAyFv/8UuO5ODzD+L7oUby2tlS/IUsZe2649+8eZ2R9wnHr9wL8TvjWAna9C6Rc5n08eDHns6VdtX5/6zeB1Osk0lU7UGEyhDikXgHavgdk2+gRA8ytf71/AFYOMy47+TNQvQuwTp8aGNoC6D6dFlapgvuVeJK9YKZx+VIFULkFicvJnzg7zSOUxK92bx7f3SMkcSFNSXLXjtUT3nO0p/b+nuEvBtto1h2qljIlibB3OBLyNdBodRi16i7e7/QKRgnlkJz6xfoYd7wBoe4Q6KYchqAu4vfX0dtMabqfU4xXVl+w+g4vPn4XDSt7oHe9IOOLckfAs7Lt8ylChAgR/zI8xS59ESL+w8hPZlS4ZdO+poyvV2RRsoW8ZBbathLaYraa24meNqRyFvve1a0WlTecjCydK4rjTqL40iaUJ18hYTLF4MW0aCmcWBSO3QqMWEvismIIMLc1Im7/gu1jqxrtQ3p83CkA34Wdg+S39sDqURzIWtGA4pIcFm6WKEhl0EH8YfufTTjK/5bmsRcr9RoJkLqICtb1reY9MiW5tEzu1w8OHrsNGLyUVqkWL9seEB0YzXWvGslrWqs3LYZLBwKbnmUy3IHPSWbavUPilXmb9jAnHxKfmvq5SueXUMWyhc6fUQmo05/K6eW1VEu7T6fi2eEjoMULnLe06z3a6Ha+RXLacwYJyW/teK9eWsX0Okcv9uBZDmUGSBgNMF0eWJ/HfHgG0HAMCZWthwDOfiRlhtRCA6RyPtyIO0Q7nQHJF/S9cVWs1+XiT8VtSR8eB8DvzbqJQLcvGZFuiJ539KRqBC1Ji7O+z23Ph+bX2tAfZhogo3ThZzNvG/9pymjZNCA7HgiqD/T5EZh8iA9BchJIeHTlHAB856A5sZI7sIcr9z4VpHrDaKFs9y6QHgNd3CEqeREDSeJXjSK5M03hy0uirdT0XPvUJCEatBBo9w7U7T5AtdBQ9IgMgFQiYP3VXJI1e0mYl/Tx9EH1SVxNiJVOp8PKUwnQ6YDaAa74sIM/Pu/sj7bVPSEIwI/7YpFRUEFyoggRIkT8i/HIylVCQsITbyQkJOSJPytCxD8Chen2508VpvOfW5Dt5bagLmRUsz3c2EEL458Ft0rAqE18yn5pFXQqd+REjILcxRveK/sAeUb7ka5Kawj9fiHJyEtixLVBXZGpgEor9cmDRpIkPfQ1avpuw8IBv6HfUlqM61ZywyDX63DYZjKP6s5+qlem83hMUbkllTFLBEaTbKTYWGaAoUfJuxqgU/MJf82etAxGjwTWWYT2SBVA4hnawTJvk4gd+ZbLqrRhOt2Jn4D4Q1SSGowFghrSOlZWQMtZ44mcf2WpPpXmk0wPXsxZVcU5tILe2AZMOUSl4ubvJBcD5tHmlxlLwtH0OS7bPNWYnBd3GDj4FXubRm8m0Z3b1pz8K125Pwu6Gfv31EW0JMYdYrDC+oncBkAS0mgCSU9JHkmBupjXuEoboPlUqrflJVTLjs4i6XQP4WeurANKC6imVOtEm6hhfyQyoPVrVDzTY0gKvKqRkGfe4vp2fcCBv+eX8n7QaqhmNZ4C7HzTWgYtzqYdc+x2IHo4t1Vews/HHSKxGrqMCYiJJ80/m3YNCADQ/zcg946RyJxbbD4Q984B9rMF1ON96FfHaFUVpJxRZSB8QQ04NLpae6DJJFpYHTxJDmUOwNVN7E078CVVJ0EAwtpDaKZPrhRAVdieBfX6ZqZ8XtvEz9YfRYWsJBe6Wr0hrTcCQXDAm11r4vUu4VDIJBBK4+2HqAB2g2vUGh2Sc0uwfGgoauSfhPe1RYC6GD2r9UZqqwF4aWcmyjV21ilChAgR/3I8MrmqXLkyhCdolhcEAeXldgZUihDxb0FFs1wA+0Na7ULQFz121ltRP8nTglsQ4NYfqNkTl5PyUZKTjMZb+1iRSCHuEHR7P4HQ4UMGbZgWfxH9gAtLbaa2CWlXEYUYrJnQFAfu5GN0HQUcV08xf1N2PBAUzULbMtJcKuccrXWTzF/3ra1PWROAxs+QeNhCg3FAAqgEFOtnPbkFA31+oGXPNKmtShuqFimXuV6thiEABsQdpN0ueiT/KZy5z8sGkViFNmfvTNYd+8Vx2jUGQKybyF6bNm9QkSnKBjq8D8i/ZNEVD+2TAAEAAElEQVRcksuUPZmKytPtvSzYa/YgQVza39ifdGMHcPx79jZ5VaVVEqBdrcvnAHTAuJ0kS3s/AZL0UeuZt1nQu1fm+Ws0iYOi44/SemYoxt1DmLrX9h0qR+UltFMCDKBIvwkMWkBS6FsbyIrnMeq0gGslY7R7nx9JCkwthzIl160tJzHyrgFcWsOhudU6kJAlnqLt0978t7JC2g4NipJnVVou5Q5MHky9SgIR1o5E3hJaDZMYteUMjakzgOrjjW38vKMXCVeDsZyv1ngyML8rMH4HsHKI+YyvqBHAwS+NQ5LdKnH/8pN5zsK7Uq01kESdjgOS065x+ZGZJGwPg6Mn0P4Dhlno57UJ1zdDCGuLgEbmQ47Lcz0grd4Zgq34eWdfCLaUQgAKmQTvtPZAwO7nIUs0xsW7ZnwD1ytLMG/QFjgpxUkvIkSI+G/ikX/7jR49+onIlQgR/wk4+bCgtjUEVu74aAOCTeHoDYT34NNoW6hle3j3n4EijQTf74/Dx1E5dtU54fIapoIZ7IpB9dmvU60TsOM1u+sWrqxDzebVMDe1DMraTuYN+QBtZrd2A12/4GDeq+tJHCq3BNq/z8GunT6mCqVV08ZUuTUQewCoVJ/9UNEjjX0/BtTsBXhXBRLum9uichOpdgxbyZlQ986Q4DR/kcVq9l3Gq1duRXXMNAWwOJu9SypX/cDZu8DQpYw7dwtiqIGphcwW5E6MkE/Qk4Ydbxgj3lVuVDbkToCrP++5499z2alfgF6zOafLMvhBowY2PkOL2vpJQJMpjPTf9BzJBUDFqPt04MxC4OIyvhZ/BAiMYjJj/3nsAby4wnzdOQnsOerzg3GW0d2jHAJ9Ywcj2A99Q3IS0ZffBQOBHPAbcFMf1Z8Vy0AJU5SXUj0ctgpYPogqz/A1nNF1/zTfE9aO90JFs5SCGlLlPTSD9kKlKwnW4MW0glZpB3Srxet1fStJe+W2wG0t19nmTdrizsxnaIShf3DYCj7kODKD/WPDV1Nd6vghSZXl8GQnb54vgOs1fVjg5M05abaaEPOTSepz7wNNnjUfBmwCXZ0BgH9dCN2+5qwsSzXu2PcMKDEZAl6s8IJD5y8gzUuCYHovO3pBM3wtpK6Bts8pgIDi22bE6gEKUuF7bSGkQR/b/awIESJE/JvxWFHsfwUOHTqE6dOn4+zZs0hOTsaGDRvQt2/fB8sLCgrw1ltvYePGjcjMzESVKlXw4osv4plnnnnwnpKSErz66qtYuXIlSktL0aVLF8yZMwd+fn/CrCIRIgDOKOr6BbD5BetlXT57/PlTDm5UShKO01JoiqbPmRVIFUKrISEqTGMcsosfZ3bJjYOLS9TlECBAaWcYqBY6qOQSyArs2B4BFs/qYibVtXmTpCQrDnALJMkqsjPvSeEIl6vL8Wmn5+EqL6VaZBo37uDB9ez/jIpB7x9Y/LpWov1O6co+lbwkktsGY6kGyORMwru0Cmg5jfH18Yd5PsLa0C63cSrg/Yz1PqmL2RdTqRGHIoc2A35tb7SwXQG3O2INbWE5d/l6s+dZeC8fbF4kN3mG5Do/hcED9mxYLgEkH0v6ktytHm0+zLUkF9j9AVWe2/uAps/wM4Z+PsNAXlsoytSHEvgyrOTXduYWweQLDGOZuAe4sobLHL1ouwuoB/jVBra/anvdxdkcF+AayOtw4idaFx29ee0bjKVl7tA3PIbKLfldSTpHQqIpBW7tYbJd7H7z+UpaDb8DQQ0Z/75iMNDlC2C9nlw1GEtCWKc/VTxLeNdgEujyQcZrUprH4InkC0Dnz9n7dvcoExNbv0Gla/MLQO1ZgFRFi9/8rsYHJ+oi3ltxh6n+yVQMn4g7BCTmcL7ULRtqqUZt/wGMIRDHHuIO8nq4BjA909SaCAAu/tA1fgaSw9Ptki8UpqO0tAhJGYXwdlbARSVHWkEp+s25hV/7zUWUSy6kGTEocw7CLU0A5h0sxcd91PBwtKGSa8shvbDU+nU9pFfXMgjlUX9PiRAhQsS/CH+7QIvCwkLUq1cPP/74o83l06ZNw86dO7F06VJcv34dL7/8MqZOnYrNm41P+F955RVs2bIFa9aswcGDB5GUlIT+/fv/VYcg4r8IqYJF1dhtQEgzFkLBTYExm4GI/rQ4PS68qwMTdrGPIrQF+4HGbCVZeJR4+PJSFoC/tGK/zbyOwI+NgQtLgOIcpOSWYMflZDyz5ByeXXYO+2PSkJZv8vS/tAAoyoKzrhi96gWgzL2CFEWlfvBoi1eANeNJHiIHAMmX+NqQpTwvlgjvAVxcDj8HHSQO7rS7mYYlZNykeqJRs2dn3QSSjoybJCnbphnVsrICzlo6v4Tn69IqFq2HZzAwIvki+1zWT2FPU8Zt6/2JHERFIrgJiWjdQVR7LINKSvPY49T1C/6scuNnDn1jrT6c/Jlql1swB7W2eMl6u4JAZWnXu4y8To8xJ1amOPETLWVFmUC/X1iwA/b7ZgyQKIAxmzivyvJ4AJKGc0uojgGM+N74LC2DRZn29weg7c7Zn4penx+5Lw3GMBb9/FJeF5+aJLYplxmv7h7MkAR1CdUsrYbns/OnDNIwID/ZaNE0hKeENKPaJgjA5VUccuwXYb5PgoQx+Lveta0IJZyggtRqGn++uZPpnOFdAZV+ezl3qfjYIkTp15ng2eRZXvedb3Ef9n9G8m6Jq+sZs24LmbcrfgDj7M9zkhnL3zPdp/N+849kX1vv76E9u5DqlT1UaoTbmWq0n3EAX+2IQUZBKU7HZSGvuBxDlt9B1PwcdDgQiuZrdOiz9C42X0xBTpGNMBMAgAChovTTR7EvihAhQsS/FH87U3S3bt3QrVs3u8uPHTuGMWPGoG3btgCAyZMn45dffsGpU6fQu3dv5ObmYt68eVi+fDnat28PAFiwYAFq1aqFEydOoGnTpn/FYYh4WtCU82m3VE671d8ZKjc+lR+2guqH3MG8b+dJ4BlGS1rD8YzJNsxjehTkJADLBpj3e6mLgW2vQuNZDW8fcsT+G0ZVbF9MGtqG++CHgeFwLkkBEo6RjHjXQKeQZkgtC4TGPwrSlAtWmypo9AIUOgGKHa8DPaYD17fQomaA3BHo+S2f8ht6W6JGsKju+xN0sQeA2L0Q3IOB0ZtowbqyjkqMozeJiakqI3c0hklY4tYuJq2Z9qyVlzCo4sF5KAI8KvP/e88GFCqqQAWpwJaXaMmTSIHRWxlxrdNyfeoikpuk85x1pHKnKlZWAFxZb/9anFsEdP4fFQf3YA5UPruQM7P8ImkX1OmoztTswfNuD2nXAI9XgfxUkp6x26iaOHhSUbPR3waZkkSnNM/YV2UL906SDLd4ifHnNbqygM9JoHXNMhnSgMBoXhOFI8MlDEplaAuSpcaTgdu7SNjbvUtSJFEAm14wH9B7dQMfInT6H21yhnUfn2N8j07Lc1SSy2umKSMB7vwZf08kneO5CKrP72D6DfvHG7uX6whtwQckjSdy39u8ASSCBNtezx7Ae7nFy8D8Lvz5xnaSHs8qJEumqYA3dnB4dVY8EGuiPCldOTy5yRQqk5YQJECVlsCFBOhu74ZwZR3758J7MBEy8TRw9DvIVG7QNhgDwcXf2r4rSKBp9Rq+3JsDnQ5YejIBNfxcEOBm/H1SrNbgbqadfkBLSKT8nXR1g+3lUSMffT6gCBEiRPzL8Mjkavz48Q9/kw0IgoB58+Y90WdtoXnz5ti8eTPGjx+PwMBAHDhwADdv3sS337LQOnv2LNRqNTp27PjgMzVr1kRISAiOHz9ul1yVlpaitNQYHZuXxwJFrVZDrbb39E7Enwadjv03l1bTYqN0ZTx4YPQj/9E2XLe//PrJnPmPG38665SoHm99Wi1wbjkAmbkSpIfu0Aw09f8Ax26bP9F3lGqhyLoJ9ZpRDFIwQOUOz4HzUNB/CRR73oUsdjevkcIJRdGTccihC6KS78PfsyaQfge4ude4zwCg0QJbXyPxdAtlL1bmLcCjBrDtZdrKDDj5G9BjJhAxBAC3gf7zoTv6HYTYfdyuTgKUFptvwxSpMUC/BYB7JRbjWi3J2vklHNDq4AN1t2+Ac/FQ7/ucCX0A1cZeP7HXKbwHkHKNSoQhhMJJP6j28lpaAvMzOI+p9Rscumtvf4ryAacA4Ly+Zym0JdBjFslAaR4Qd4xKTNdv2GfnU8f+ujyqAHmpDMzQZQNFOUBYJ8DRHWj/MYfzWqL5K0B2IvvLnIOBzLu21+0Swm27BHPf8lN5fap3BZq+yBh6Szj7AZ7Veb/seIuvSVS0BIZ1BGJ2AUdNiPDlDexZ8qnF82t5nDf3AOE9AddgQJADDn5AbrLxfTJnYP9rVDPdKgOulXn9tr7G6+NZjdbQM4tIfOUutuPkAUDuBsQfB+qOIEnbMBVQF0MtUQGRs1FWlAsoPYEyO/1cSg/g+Fw8+J6VFAISB6AwBxi8Atj8PG2tAEnS7f20mjYYTxLn6M2HRvs+AeqPga5mfwg3TXrPJDIq1+dXQedZAyhMhSBRAdn3gRNzTd6nAuQuSCvQwLv/QkiOzSbx0+kAn5rQtXoNcWovnIqLhVIvKs09eAsLxjaCUmpD1QMQFewGZ0UFvz89qkFXsx+EmzssXq8CRI0CtDr2Qf4L8f/2t0XE3x7ivfHvxqNeV0Gns+WXsIbkcQegGjYgCNBoHpKkVsFnLXuuSktLMXnyZCxevBgymQwSiQS//vorRo8eDQBYvnw5xo0bZ0aUAKBx48Zo164dvvrqK5vb+uijj/Dxx9YNuMuXL4ejo405OiJEiBAhQoQIESJEiPhPoKioCMOHD0dubi5cXe27qR5ZuYqLi3sqO/ZH8f333+PEiRPYvHkzQkNDcejQITz//PMIDAw0U6seF2+//TamTZv24Oe8vDwEBwejc+fOFZ5AEX8CyoqAHa9bDxg1YOw2Ntk/BGq1Grt370anTp0gl9sY8PpvhlbL6Oaj39lcrAluhgV+7+K7o6lmr5+f5A/5YhtDX/XQjd6MxguyUFxu/cBk3bBghOviOdvHHqJGMPUsLxHo8xMwv7P99/aYAZQVc87SuvHGVD+JlIEPx35go78lHNyBrl/TRliczX4fgH1hI9cz3a75i1CfXYbdwa+i0+UXIddaKBP95gLXN3GYryXqDADqDgWurgOyE2g/q9WLs4oW9bS25UkV7J27d5qzjKp1APaaPMhp/iJQozNw9Hsg+Tzg5EslTKZgyl9xjvG4o0ay38jFF9j7KWPE6wygulu1I8+9SwDQ7yda+bLjgUtraT/s+iXPWdevgNRLtFUaeq8ECdD6dQZHHJsNVO/CEA6lC+152frf/7X78FgFKVWihJPA6V8ZYLGoF/ctegSw7TXz9L5KDdibtOEZ2lTbvw+cWWA2L80MVdpwfzY+x32XymkXNJxnnZY23PNLqHC3fIVKYuoVzpqqM5DridlKm97vb7FfyQBBwjCK23t4TmP3AecXP1islqiwO3I2OnkkQu4XTour5Ty1qJG8lse/B+6fo2LT5TPg5FygekcGabhUYmfzvbPs8XJwZ8x+8gXgxBwGs3T5jCMMAEDpguPt10LpGYDknBL4uilxM7kQi0/E435OMd5v74/e2YvhcM0itMIzjN8JQ7pffipw6GuqtdpyQO6IonpjccqrL17YkgidDgjzcsL8cY0gkwi4lVqA+UfjkFFQhiZVPDC4YQgC3VWQSW0/VL2dVoChc4+jpFyLQDcHdKnhAqUESFfLMbV9dfg4P0GPabkaKEyljbMkG/Ctw/vcwfPx1/UwGCLwY7bTQlmtA/vl7Mz1ssR/+m+LiAoh3hv/bhhcbQ/DI5Or0NDQJ96Zp4Xi4mK888472LBhA3r0YAFYt25dXLhwAd988w06duwIf39/lJWVIScnB+7u7g8+m5qaCn9/+784lUollErrPwhyuVz8gvzVKMoHrq2zPxsqZhMQ0vCRV/efvYZRg4Hj3xoHxJqgtMU0zF+di1KN+XgFOdTWRMMEOl0ZVEo5ckqtwxN+u1CMmc3cIPEOY1+QLQTUBu7sYVCAoAEq2BbK8tgjlhcPdPqAfUU1urLQTrkAtH8bWHeLs6MMUDgBPb8BDn7NmPSuXwCBdZjEVlwCHJ0J1OgIuPkDWTeAYECuLbE+5qRTgK7Uev+qdwKC6gJLexlfi98HnPoRGLQYGDwf2P8pC2mADwG6fQ3E7WORr3IGtr5iXG+VtkCVFsDCLsZZaXkJwKrBnB01egODJMoKSJokcgZ1HNrOMIi0i8Ca9dyGkzsgFYDcOGD9eAZLHJ0JZN/kemN3AQN/IelyCwDGbOB3LCsO8K8LaEqYiggAd3bTdtjvFyArxhgIcWUV/wEkv+cXAEWpgNIRUDkCzaaQKFjecwlHOay5Rkfg2kbg3nGgWmv21tlC9bbAxcVAu9fZLyZI2LO0biwH8coUvKaRA4E6vYEDn3JuWc2utKKdnM2HNFXbcYZZ3x9pQ004rg+bacKeN10ZoFTxHrNxL8rd/CDfOIn9chhFAid35FDkpAvAtbWM2fepTuK3cQrTPWN3AoHR0HX8GML9c8C19UBAXRb1W583if8vA/ITHmxbHdwZR+6r0dQZuJ5ahBVnktC1jj+ebx+OXddSsP+eDk1aT0NQvUFQnp8HqboAqDsECGluHFJelAXseIW9hwaUlsDt1Ey0aFiKvpF9sfJ8Ol7pUgsBHrQv+7g5oV6oF8rKtXBWSSGX2g+kKCgpx4w9t5FbqgMgIC6rBD+fMJ673lEhCNSv95FRXgYknwJWDDOfAxfeg72aLk8x6besALi5jaMIDDg7l/f7qI3siXxE/Gf/toh4KMR749+JR72mf7tAi4pg6H+ytChKpVJotSz2GjRoALlcjr1792LAACYn3bhxAwkJCWjWzEZamYi/JyqaqSb87UIu/55wD2axsG6CMVFP6Qp0+woanwjIpResPlKq8IRcprRJyCCRAS5+mNhKhk+3WQcuXEwpQZlvXSjavw/JymHWn3cNZGFriC6HAPjXATzCSIqSzhtnOgF8knxpNWcUyRwAr+pM3cu8zcI6vAd7anISgbtH2OPjFsR0QMPMnmPfMyzCEHN9cwcDKsoKqCLYg1swt2WJhuOBNWOtX1cXA7vfAxpPYWJes6kkJFmxJAdSJZB6mQqDaepem9c5O8nWEOoDnzO4ITsROPUz0HgSB9Y2e55P2DNvATW7s4fsyLckAAMXAtDpr5+EIQ+GhxTulTgA2HSWWFADoPs3VMVidpvHxGfe5myxsHa2h/TGbOOySo14rK3e4Gds3TsAcHm1fljwRl6HsdvZX2YZkuETTiK5820eryWkcipUd4/yn084r6m2HLi4Ejjzm/G91zaSOLZ9i0V7/bHAja1UdKJH8p68f57nwZSMGJCbyGTGTVP53qCGJEYbppAodf2KCYgHv+J8NNMHQknnIaRcgja8GyR7P+Lcq0qNgODGDAtRFzFJ9IZ+gK9MibSG07B1XRb6NFahpFyDrnX88fGWa/BxVqJ1DW9IJAImro1DXrEaPw37EtV8HODi5Gw+RqEw3faxAHC88BvGDhiGelUi0biKuSLkpJTB6REEp7wStVkQjiW2XkpC06peD1+RKfKTOHDbMsXyht6l0Oo1oALC93jbSmUvnCUyb1Oh7PYVg1BEiBAh4gnxh8nV0aNHsXDhQly4cAF5eXlwdXVFdHQ0Ro8ejZYtWz72+goKCnD7tjEiOS4uDhcuXICnpydCQkLQpk0bvP7663BwcEBoaCgOHjyIxYsXY+bMmQAANzc3TJgwAdOmTYOnpydcXV3xwgsvoFmzZmJS4D8FKg+gVl/O27GFiL5/5d78cyFV0KY1cS8LWJ2GYSDOfnCTyrHmmWZYeToRG87fh0wiYGijEGidfZh+dtBGb2KTZyA4+6NftBLFZRrMORCLYjVJQdMwT3w9sB5ydRKczgtDj/7zIOx+zziDqUobJtBteVG/b3KSta5f0dpVksNi1z2EYRLBTTnHysGNpOvwDOP8K/+6TPg7MYex3pEDOMOqMNOEuOmRl0T7mAEyJQu4y2tpUbQVjiZTMY3Nxc98dpLKjaqAPfKQfoNWum3TzF/v/CnTB/0iYDX9Qu5oTigtkXCM1zC8G+2CrV6l9c90bpjSlbY8lSeJmmEwsCAAzV4EIvoxNGFxb+shzffPAodn0tqYeYsqwRaTqPir63ndbJErgNds36fAtleAsTtow7MHdbExXEWQksT1/43buLmTBDSiH2dXHZttfz01upjvT/oNJub5hJsTKwNSLnGgbtIFknh1Mcn1xmdJlALq0SJ4/AfzgdIAcHEVVdOVw3kv5ZkM9Va6kFjtes967pQBl9cgK7QnvAYtgqAp5fw0mZKz6mQO/P+g+tC1eAk5cl+8uSMTb3StiY83X0XDyp6IDHJDs6peOB6biXXnjEOJm4V5ITFXjRELzmHemIZoVd0HUon+gZTlNTZFeSmquWpQvUYlSO1Y/h4GiQCoZBIUltnupXZRPcHT+jsHbY8HAPg9rz+SD0+eBm7vtR3NDwCXVtKO+hjqlQgRIkRY4g+Rq1deeQWzZ8+GIRNDEATodDqcPXsW8+bNw0svvfSA9Dwqzpw5g3bt2j342dAHNWbMGCxcuBArV67E22+/jREjRiArKwuhoaH47LPPzIYIf/vtt5BIJBgwYIDZEGER/xAonYD27wB39pkPFAWAesMBt5D/n/36J0IQ+MTd0IthgiAPR7zUoTpGNQ2FIAjwclJAIhGARpOoHJz6BajaQd/jE8An+CpXeAGY0iYMfaODkFeihoNcCi8nBdwcFUjOKcaOW0XoFnAD0j5zAImEhWziaSpoBoLU9yf2NJnGtd/YQXI1bCUJwtFZLOw3WTxlTrkELO3PgcJV2wFFGex5sQWZynz+U73hjNaOOwBEDgESLN6vdCVxOzyDZKjLZ8CBL1l02xv+awpbRZtOS9JRqRH7O7xrcE4X8HAVVqZiwpxPTfY4rZ9sPZC5NI/kpuNHRmIlkQG9ZpFUb3mRx2Gv6L6xDWj1CvvA/OowkTPpPJdp1eYzp0xRuw/nhxn6sfZ8DLR4AThs51g8qpBkVuvInqsr64ETP7KXqvUbPE8+NakI1eoN3NpNtccU9UdTHTIdNA2QVKdesbNhkEy3fJkzwa5uYh+XAffPktyP3ABsfcl4DgGgzVuAupQJkYdnGPvpPMNIyGK285zZI1caNZwUAnSnfoNwV39ifGqSLG95kWoJAEGmglur1zBvwBC8tScNp+KzcSo+G15OSgxvHIKB9Sthz/VU1At0wqBwGWTqQqQWZ2NyE1+8s/4y1j3bHAHuerXFsWLVSKZ0Bp6QWAGAp5MCgxsFY8HReJvLe0dZ/655KAyJirZQksORHE8LthRpA8pLjeMbRIgQIeIJ8cTkatGiRZg1axZq1KiBDz/8EO3atYOfnx/S0tKwf/9+fPzxx5g1axaioqIeJPk9Ctq2bYuKAgz9/f2xYMGCCtehUqnw448/2h1ELOIxUFoAFKZxkKjKlU/PlY/pp38SeIYBk/azvyRmG1WDZlOBoGgWmX9XFKYzVrw0l0WOk88fn3X1J0ImlcDX1SIK29kHiB5FMrDnQxbAEhkQMQBo9zbgURkKmRTBntYpmkqZBF0i/KBJ10G6rD/QfQZjss8vZkHs6MWn9t7hwLqJ1juUkwCc+pVFffRIYxiFJYqyOOeoOBfwCGbRbGvQa+RAztwCeE81msBgg7hDVHkifwKGLAPKcvWqig44NotkLeE4ULU9rWwOHlSZHL1IDApSaC0zJTpuwdZFvyAAvrVpAbu9G6g/jkX52vEs1POTSV4Tjlvvu0QKBNYHlvSh7U2jNpIyU3iGsd/Ipyb39fIaIKwtLXG3dnMAbUGa7fMIkNQYitezC4GmzxrJVa0+tudEBTem+phtUhTLZAAEwLeW7Tld7d+j6ph1B1gxhOEigVGcP1aaRzJ7dBbvsStrOSg37RoHYatcOSg4J57n0pJ0CVKSMntQF/H6eVYFAusB+fdpxfSoArR+Fci+y2j4Fq9wlly5FrgD9rhteRYIbsRrAABSGZCXzKAPvwgSdjsobzIV6hu/w+GuCePs8D5Jsum9Ul4Cyf5PoVC54v023bAvJh25xWr8evgOPu0bgYhAV9RwKUG1exvgsHgWUJoPN0GCaTV6onf/d5BVWGokVy7+vCdMexENqNqB88r+ABQyKSa1CsPBG+m4k2F+zl9oX81sdtYjI7S5eVy/KbyrP958v4ehanvgwBe2lwVGU5EUIUKEiD+AJyZXP/30EypVqoSTJ0/Czc1ou/Hz88PQoUPRrVs3REZGYs6cOY9FrkT8jZCXDOz5iL0ShiGqtfsBXT61qYQ8dXiEciZMo4ks5P7uf/Sy44HVo81Txap3AXp999ecr6eJ7HhgXidjc7lGTctM/CFg/C6bthmNVod72cVwUcmQXWMg/AJqkyB4hAI1e5G86DT6lLdl9rd9ZS0JD4SKh+kKEib26bRAv5+ZLGea1Bfagta/Y7NJOvwigCPfsZAbtx3ISQZiCllkp1xiSEJgfSAg2qiExe5jOMUzh0n8js9h75R7MInjvVMcKixISB6OfW++jz1n8WFE6zdYqBdnkqwM+I3bjD/CHo/FfayJWefPOeQWgn4orI0+xIYTWPgfnQXsfp8ksP4YoFpn2vUAnhP3CtReuYOxxyQvyZjO5uRNVUldyF62q5tILCKH0Ea4uI/5epSuPIZOn9BOeX0LVSa3YKb5ZcaSTJ7QuwgOzwD86wF1BwEnfmHB2/sHYP8X7CvbNo37EhjN+3DnW1TnTv5ifQyuAXzwcn2z9TKAaXD+kUw3bPsO0O4dPaHUcZhxfhJVpPV6wi9RAfXmspcvtBnVztt7rdfbaAJ/L5mqkQa4h6A4oDFc15v0H3pV5X1kea31EI7/AA9Hb7zROgzv/p6ElLwSVPV1gUSrRmjCBjgc+dT4Zp0W8hubUSPvHvL6LQXgztdd/IHhq4Al/c0Hb/vXpZpZUa/hIyLQ3QHLJjXB+YQcbLqQBE8nOYY1DkGIpyPcHRWPv0L/OuwdtLT1ArTVOj/FQAuPyvwdYDpUHOB3uNtXD1X+RIgQIeJheGJydfXqVUycONGMWJnCzc0NAwYMwG+/2fDAi/j7oySPT2avrje+ptOymC0vAfrOeSp/pB8KqRRw/BOieJ82CtLYl2FqKQIYkb3rPRY1f3dyaIC6GLqj30IwTe0yIC+JFqiG46wWpeaVILdYjTv3UtDY9TKw7x2qS6HNae878BWQdA6o0poqgSUcPKiIACSj5WUszE0LRIBqUJW27LHRarjOwzNJoEpyaRP0qgbInUgamj5PpWPLS0x5SzwBbJ4KDFzK9a0ZbZ4U1+o1EvrTv7HQGrqSJG/NGGPwRMZNFtsdPgDaf8DC3rUSj1WuYjHY5Fnu+6Le5v0kkYPY+3N9CwvK69tJWK9vZo+VSyBQfxSQdgPY+SaVvvvngXBf2gQNEeeB9VmUbjBaolGczfj9jJtA69doaVQX6fvvmhpTDE3RYJyRlAbUAwpSqRLX7gPc2E4Fs3Y/ILQVAzrunea1mriHCmBxNlCpMdU8/0hgSV+SmYELAOio7p1dSCJi2ksVf4SpfUv6AaM3A1FDgRM/k1CmxwCDFvJ7FX+ESkyLl4HT85jYZwq3YN43Kg9a9CztgUpXXtMr63nvFaQAh2aQOBkQGA20e8/63FxdD/T7gSTbchCxWyWUhbZFiloF5wGr4XJ7M+QXlwBaDfLCBwH1huF0Qh46lJooqm4hQMYt6+0YkJMAQSpDywC6NzydFFDJJfBU50J52nYfmjT5HFzK0gCY9CR512D8f04CRx94hbFnSaokuY87BEAAqrSisulg++94RQhwc0BApAO6RPhBIggQKgohehhcA4Exm4Htr1Ph1eloRe7yORD8lIOonH2BAfN5T576hbbD4GYkcX61n+62RIgQ8Z/En5oW+Id+2Yr4/0VhOnBtg+1lN7Zx+V9Brv4pyE+xJlYGXN1AVeMfQq5K8rOgshdgAHD+WN0hgMLcFphZWAYfFyVq+GXAaZ2+T0qmZGG7cpgxCCL5Egv6U3oFQioHOnzIAit2H58gF+eQmDSaBOz5wLgRj8pAj5nAnf1UoWr2ILlKOgesHkW1ReVOpST9JnByDvuO3ENI8Cq3YghGpcZ6K14j6+M7/A0wYTeJmFswicnasXYS/b4EphwC1k8BenwDOHoDjSaTrGjK2C9m2ad1eQ1VBICEqkpr2uvkjkyPK8wAlg1m0ecWzIAHmQrQlPK4DJamhuOZKGgLN7YDDcbw3GrUJC2dPyfxurGNxyJ35Loj+lGhBpismB3PfTj+PdWd0/OA0RuBhd3Z4+bsD3iE8Ph8a9NSlxVLYpl6lT1rez8xJv05eAAtp7GoNyUWDu608pUV8p5KuczrKkiATh8Dx38kkfOuzmt1Zh6Jrk91rltTxmj+ukOZEugaBPT/FbiwjOqnupjXsOF4YP0krr96J+D0EnNiBdAGaevPVUku92PQQt5v904DEhnKa/ZBedt3MXlLOg7fvouB9SvhxfbjkeTeGYlZRdh8qwz9fRU4m6BGiyqdoLqkPxd590k87cE1ECjKhFxFK/FzbavC10UFSUaR9fw0E0gzbwKVoo0v6HTWvZaFmcCRGVQ5TdHyFc5ae5SHWPmperIuo0VcpoTUIr33ieFRmcEsRRl8sKJyJcH6M+oI1wCqyQ3G8PspdwIc/772bREiRPyz8MTkKiIiAuvWrcP//vc/ODtb9+Dk5+dj3bp1iIiI+EM7KOL/CcU59hOVALu2lv8sClLtL9Np2bv2D0CxuhwJOaUIV7kb49st4ej1IPVNq9Uhu6gMgsD/d5MWwff0N8b31u5DO6Fpwl5JDs9XldZ8gt5tOsmAaXz0ucW0pDV/gSEGmbFAk2dosStMJ0m6sp4FfYNxJGU5d0kK6gyg2nFxhXF9OQnssWr3DlWg6JFMo6xhg1wBVJVq92PAQZcvrXt8DNCUcd39fmLx7lmZ343QFrQ+2gvAOLuASo7CmQ32v7/N86ApozLoVZVEoFYfxtH71Qb2f8ZeuM6fAid/ZvFp7xoBJDOuQfpBwisAz1DGuTcYywJZ5gAoHEhGcu4yZETpbJ12CLDYrd4JcK8M1BtK8nR7N5eFd2fCWk4ClavL69gf1fZtEqvce8C5RXq1xASNJhmDIJLOs1frzn6SpeRL7BkDzM/9/M7A4MUk1XJHRqNveQlo+yZVrvxk7kePb2lJjTvE8BN1MT9flMW00cJ06wTEjFski6Yz2iq3BkozgSsbgD4/QleaB0iVKBKcUabW4te2ahS08obg4oZXN11Hn+ggnM8qx8n4NDgo5fB3VSE9YjKCb2xgKErGTV5bpYt1MiHAKP/zS1Ha+luMauqBPlFBTAGUOfA7Z2f2nyBT8pypXIG4I7w2nmG8Vm6VqJSmXrYmVgBj/Ku25/fRHopzSXB/f5u9XAZi3vyFp2t5Vrny318BqfSfZ9cWIULEPwJPTK6mTJmCCRMmoFmzZvjoo4/Qpk0beHt7IyMjAwcOHMDHH3+Me/fu4ZNPPnma+yvir8LDVBblX/QH8J8ClwD7yySyf4xqlV2oRlq5M7zrTobXnpet3yCRMnVNpkBSTjE2X0jC+vP3IBEEfDWgLsqLCyBkmESL+9a2Patoz4e08dXuRwJiay5PzFaSs4iBDAjZ+KwxtEIiA9q8SSKjLQPavctzfPx7oM4gYH4n2wd47Hv29WhKKya8RVnA4a95Xe1FRBtQnA2s1QdKtP8AOL8U8KxmjKG3hfwU9hPVG8aUPo0a2Poyn97X6Eq1LHYf1QG/CK4foMIUWJ+R7B6V+VTf3kMQ1yDzkIcDX5KM9P0JuH8GULjwe1xvGFBnII9TXUKydGO78XOCwGtUvSv7u+Z1oqJjQMxWWu16zqIlzzecKkjCCa6ztMCaWFXtwONvNJGEwz1ET6RHAVIV8Gs72ERJDomRXx2u+9B0EsZTcznLbNxO3jNX1nJ5tY6c4xW7j4TP0Yv9Ve3eJRkpMpmxdXgGMGoDsHUa0HAicBfsrXOJ5joPfQPh8mqeWpmK672xHcob2wFnP/w8cCnOqWXoHhmAwQ2DkVVYimBPR8zcdwv/G70bysNfQn5rO3D4O+iGLIOw8VkjcZTIgMaTgZCm0CaegodPIN4IdX8Qa6518oEQMQDC5VXW58TZl72MhWkkkoUmM6iOfksLXFg7Km/2cHQ27yt7YUXxh4BVI40/q4vYO5d8gcOznX3sr1uECBEi/mN4YnI1btw4nD9/Hj/88AMGDx4MAJBIJA+G+ep0OrzwwgsYM2bM09lTEX8tnLyByi2pAFiiUqM/nDj1r4OzHweR3j9rvazecBbJ/wAUl2nw2fYYvNWyEZpV7QZl7A7jwibPQBfRD0L8EWjijwJeTaAuLMfNVJKUGbtu4JfefkxgM6ToleQyMdEyuay8lGmBg5eSENnDhRVAxw+AZf3MbXnacio5fX5gmtz5ZXxSP3wVY53tEY7SfJKFtJtUl+yhcnMGQvSaxf4fj8pUgCwhU7EgLSvktd/yItPu9nzI3iqD+mKJwCgqJYHR5sVwdjxVKQNCmnOGlykMNsjmLwBhHYBYGzHgcgcqFj2/pQpXnM1UwpCmwNGZQOo1oM0bwIJR5nYz39okX3EHjcQsYiDtiy4BwLkl5sQKYH9P6zeAZQP0wRt6hLWjOldexujx23tIakOa0/K5cQrvjfbvcx3Hf4au0QSgvBiCreTHB+foLnusSnIYhnH8B2OITO49Rv4bELMVGLSIvW0bn+ExyVQklEOWAIt6GdWgwnTet71nA2smAJXepKqnLSGJ6z6d5P7Gdva9bX2JQ7rDuwMqVyizb6KGvx8azLqCiEBXTOtUA/MO38HrXWshvqAU7u2+QUH02whzLILiyioONnb05PlRONIamX0Xkp7fwt3FSFaScoqx5WIK2td9FWE5CZAmmiRLOvvxO5B+Ezgz3/xeAvg92DAZeO6k9TJTFKbx2sAGucrXJyPawt1jvJYiuRIhQoSIB/hDPVezZ8/GoEGDbA4RHjNmDFq1avW09lPEXw1HT6Dvz8CasXzKbUBAFDBwvkiuLOHswyJu03PGp/SCBIgcDLR/l7O7/mqoi2m/K84GZI56K1IeC3gnb1piZCqgrBBaQYoyB2/IpQJiUvIxaUMBvujyJprVnwq3u79DEdYKsruHIdn3PyCsHaQAAo+8i3FedeDddRg+2ZuK4U1CkV9aCIdGE4wk88o69lwlnrS9jx6VbUeoG+ATzkGutvqdAODMAlqfDn5NAndwOtWPiuARxr6hsA7ABRvqkm8EU+x6fEtl58ZcptStn2QdatDhA+DsIuPPOXcBCFQkgurzPBdmmH9GEKicyBwBlQvT3UxJiSn86piHypji3GIqLRk3zEM/pHKg31ySqrML2XfU6lWGBWTHc1RAy2nAxuet+3jSrpFIRA3n+qNH0w5YkkviZUjTM0Xbt3jfWx7nnf28x6KGM7QiMJr7dmG50RKXl8TjLysEIvsDm5+H0O0rqjH24uNdAxguYjkDD2CyoSnqDadqdXah8bXyEtoyS7IZO29IeAxtwf06t4Q21Eom69FpOdx62EqjqqfVcPhtegxJnLMfPFu8jIWD22Ls6ji8vPIClkxsAl8XJQL1MemFSkCx5jnzhzCm6mNeEu2weiTlFGP4rycQn1mEWQopZveegXbtsyFNvUxiqi0Hdr7N+9PWgzCA92zqFSZ22psFFtbOvhuhtIBWS3u4d4b3uggRIkSIAPAUAi1atWolkqh/K9yDgeErWYwVpPApqZPvw59SajUsmKUKY8TzfwHuwbTIFGWwIHFwYwH0/2EJLExnZPWx2SwMBy7QJ63tN77HrRKtedumQVKcDU39Z6CoOQTzRjfE+5uu4LXtSXBWytCiWh98UaUQnpWbsZH9kt6aVLMnnIMboX1pBmR9IzD3UCxea+EBX0HOaPS9n7AoK8lhkX7exB4oCEx/u3+GhZ29MJDgxlQP7CHnLu9LBw/2ZAVEkTAOX03V6OIKcxUrIAq4vYsFfnu9ZblyayBuN/ufokaw/2RhD+63axDQYwaQeQeYuJdFevJFKiGRAzj42NLSmBULdPmC4RZDlgN7PzLGPntUJrHSaoEtL9Bq1/p19oNZwtEL8K1p316o0wFlRcDQZVQC1SVUIFz82Y8mU7A/Ke4wAB0QNQy4uYs9aepCHp8t3NgOTDnCayZVsHje+yHVHsuZbQ4e3LYlsTLgylpa/zRl9gl2XhJtlIUZEILqk/w0eZZ2SUt4VGakvS1i5ehpTFI0oFZPjkewhasbgRFrgOM/QFetM9DlMwhp14HrGwHYGJys1fA+9Qk3zv7KjjMOgi5IhfD722jWbBqG1++G5efScTw2A1HB7g9W4SQXjOMNDDC9P8sKOeMNdH/svpaK+Ey+v6hMgy8PZSCqUSy8T3HW1YMHExX1xxrWGz0cOD7beh6YwtkYfmILUkWF/V5w/meo8iJEiBDxV+FPTQsU8S+Akw//PUpErU7HYvfSGlqVnPw4r8a7xn8nicnR4///WLUa4PJaKhAAlYOYrebECqCFav1koPP/gPWT4XTkc8iTzyIv7D3MH9sIcRmFKFZrUFSQBw9lEbDtPT7RN+DITMCrGnx7zECkRILYABkaeJcD16+zcO81i2Q89z7T+eqPYlO8VsMI8WubmV43Yi1DLywLdLdgKjeVGhmDDyzhG0EiOWAecPBLY5KeVA5EjQR6zaZVT6djEdjzW2Dba5xptG48ZxlV7wJ0/YTqzNFZTDY0KGV596lYjd1OhaIwnfHQF5bz3NkaXOtZjd+Xxb1JbBuMY5y6TsvemID6wKGvScIrN+d2W77CHhZD8Id3DW7n6nqgVm8qgKZw9qWyfOQ74M5eHp+TD1XC5AtM1gOYojd6M7B0AMl+q1dJDJMuwi50WpKGjc8AQ1cAW6Zy/dc200poOh/I0avi3rLyUvbpKZzsD/n1qUkSnnef11OuV1lbvUaLpIFAhDSjUlhog1gJAtD5Mw6gNoVGba02mkArVSJn3DHonHzgLimDVCLl+yUW5MqjMm2nMgcmyxkQEGUenAJAeeoHjBnUH8vPASfvZGF8Cw2Ucv36VB68nvbmt9UZwDlwAHKL1Vh37p7Z4ttpBcj1bQTvwjRzNbcwjXZc06HOpghqwAcFE3ZTwbx7lK+HtgS6f817wh6cvDlA3Fa/l0xFRVKECBEiRDzAY5GrwsJCREVFwdfXFwcOHIBcbvtJV1lZGdq3b4+MjAycP38eDg7/IfXiv4yMm8C8zuZPxK9v4pP6Js/8dSlQ/1WUFdJKVV5iJFYAUKObeR+KKQwphyo3oCQXitjf0bPtm8gsvgsvQYGPDqfhh/5VIcRtNydWBmTehnD/LHzCq+NF96NQ/mqiNpyZz6Ku5SvA7+8Cfb7nQOryUmDfbePT9u2vM0L78lrG1gsCi8xmU2nZajKZpMfW3K3Gk1h873zTPOZbo6b1y8GD0e06HYnArvfYE7XjDSBHn7QnV9JCuXac7fS90nwO/L17jFY7nY5DdW2RBSdv9lMd+97Y43L4G/P3DFlK+12XL0j0/OswzCByELclU3H51pdJOIcsIbEzVfc6f061y7SYLkzneej5rXHeU3E2sO9/QJ1+VDI3PENbb0U2LkdPKlsR/UhuDNcp5y6JT+RgXkeAdkbPMPvrcvBg8mhDixlXBlRpxf3e8TptaXWHcmivoxcQu5/KqiCQLN8/x16wiP7A0OUkuFmxJKLRo3jfW6pj9tSYBxCw+WYJPt13GismNUZDz6oQfGoCmfFc7BYCdPuUvVgGK1/v2cDdE8Cpn4GwNhzebApNGZzLc3h43k6QS02iyqVSqqO2+qPcKtESqI8eFwQBMhsx57NP5eHDLj/Cc+ezxmtz+jfaj9dPslKxNPWGA44+JI5+EVQ6i7l/cHC3ViMtoXBi32PqZfMkRamCNknXCsJ8RIgQIeI/iMciVwsWLMCdO3cwb948u8QKABQKBb744gu0adMGCxYswHPPPfeHd1TE3xzFOcD2N2xbjfZ/xkJNJFd/HvJTqdqcX0wLoJltSldx4l1+CgssfVCBPOEo/PPuwz/lEuZ1/QRuKjWVLxd/PsEvzKDyY8D1rfCo2RuSgzZsXPfPssjv/wv3KcVGz0fWHWDFMGDSfiCsLZUTqYLkQekCxGwDBvzGItZA8Jx8SNpv7WGBa28w66m5nFG09RVjX1LmLRKbDfpZXEpXbrOiWPOUK0Y148Z22h5r9zUPrHAL5rYEKd8jCCQj6iLzgvfyGs4JK80Des/i+b+5k8RNKif586nFnq/4Q0BmHIM/CvUDdVVuLHjtqRRHZ1Ex3v46f769h/t1Uj9X7MCXJGD2Amuav8jEwyqtSb67fMYByQUpJDQdP6bF8PYeAALgWZUx6rbUmCbPcH9qdCHJPv0bCaRExgS+Nm8Ac9vxHBVmcG5X/GEmUrZ4iWEVKZdJZqNH8vpf3wzEHgTCuzDUo6yQhN01yBjvb3rdKjWktdESXtUgybiBjgER+Fomwaj5p3Hk9Tbw7vYlsGwY39P/Z2D1cPOeOKmC9+OQpUBeMoM+LNQ7jVQFQcjDsCYhkEgs5jR5hFJBOvY9FUlBoOWy6bO0Fuvh5iDH6GYhOJdgPvZi09UcyCSV8fGkE3C+sxPIuw9t1Y5IdawO6eBt8Dr+OaTJ5wAXf2RFP4/zDk0RXqZCJYPg5uDxcEJlCbdK7O/LvM0USNcgkmCXQJ4PESJEiBDxAI9FrjZt2oRatWqhdesK5mHo0apVK0RGRmLdunUiufovoDgbiDtgf3ncYQ4DFfH0UV7KIvTsAv3PJRykayC6GrX9uToALUGm4QEOHkBuAtBwAgIyTkDn2Rlo8xaftKddZWHlVY22wMRTgEQKSZqdnimAT+k9KgPe4bbDG+SOQORAADr2rxydBXR4n0V27T5URC+tYqHuGkii4h4K3DsFpF4CPKvY33ZZAYtv08CHgjT2jzR9FijWH69Uzjhwe4373tWNhFWnZSx8k2fZs1OUxQK7rIAJiAPnc56WaxBnWDl6sUfn8AwSWImCc7okUpKqGzuoVrV8mce/4VkqNkpnQKrk0Nyz87n90Ba0f93YZv+Ys+PZh/YAFv04GTdJKDt8yNCKy2t4zzj7kayU5pGgNJwAOAcAx74jefWoDDR9HijLB1YOpyUOOvZV9f6BtsY7+3l9FE48P/51SPpj9zIxcPhqqoTqIlrTysuo9pme9/jDJFb7PqEq1mAsLZR7PiaJcQ2i+hJ3CFg+2Jhe6BMOXd+foEs8A8mpn4CQFtB6VYMQ0Q/CiqHmDwTcKgHdvgJ+fxeeYV3QILQHDt/KwJXkArT1rcpAkFidfpsW96umDNj4HAm2ky9VQlNy5VUV13MVWDimIaoqcoDbp7ncrzb33dmX92zXz4HWr/Ezjl4cuG2BZlW90aiyB07HmxOsu3k6FDpXhnPLlwEAyTlFaPXVfng6KTChwSeoGyVHRpEGv54vwJX7dzF/jA8qeTharf9RUVRWjky1K8qdo+DaoBG8nKz3VYQIESJEEI9Fri5evIiBAwc+8vtbtGiBtWvXPvZOifgXQmu/7+Hx16Vlf0baNRbN/nVZbLv4Pfyz/0bkp7A3x9GLBfjlNWxQNwwMvbyGoQJHvrX+rF8EP2Ow3MmUgJMXe1dO/QpEj4JQvSNtW6YFsNyBPT+achbhSeft719JHsmYVsM+mu2vGZeFtmAf0PnFwJpxJFC9ZhuL1XunSVSurKOVzxRV2gDt3wNgoQyYQqZ6YLMyQ1EmUKxPyku+AET0YoLe1pet3+vgQeLhXd3YO+Rdg6QgTz+01qcmSZJrIPfn3GJjPDhA9WTAPFoPw7twv5YPMo+ojzvIMI0unzMGfuQ6xsov7W9Uvi4s53si+tk/ZqWrebBD1Q7sdTNA7sDtbnmJqlSzqbz+goSq0OEZJEKZt7gfBmTHc3nOXRIk03WuHUcS1GgSbYX5KcZkQIAkKawtP7NXHyTS7Hn9MOWJwO4PzI/h5u+8n23NSJMpgax468+k34CwpD+ECbuAkMbQnZ4HyZn5jJ8ftIj7nZ9CQqR0onrWbCpUKnf8r4YrVvgqUdNVzUG5KTeAKu/bD+EoK+DDijsHaAM1DFR28EBJ/8WIdqkKr7xrkM4dYD5wPagR0HcOkH4d8KrO31mOXra3AcDPVYUfhtfHhcQcLD+ZAJ1OhxFNQxEV7A4/V9WD9xWXaaDVARkFZfjqoHXyZGbhQ2a1VYCknGJM/z0GWy4mo1yrQ6CbCu/1rI2W1bzh6vAw26UIESJE/PfwWOQqJycHXl72/xBYwtPTE7m5uQ9/o4h/PlRuDB64d9r28iptns52tFoWw0v6ms/b8atD/7+JreY/gbIiFtKt9ITFNZAN9t7VaT27vIbqSLUOVCVO/8bCWBCAsPZAs+eotgAsNnvMBE7ONa7fyRvY8Za1oqMuZlDEgN/Y4C+rwBpUpRUtd17VaYnq9jVVL4AWtJXDqKz1m0sL6c43aG0E+DkdbM8QS75AFcjRk0pErnnzPwCeg+tbrF938gFuzAbC23CbZ+Yy+KHNmySlBnLiVQ3o+gWw633Gt4/aSEKfn8LCvyAVCGxAO5pcSbK3/VVzYgXQlnZsNtD1KzwgX5azvwDGhkcO4va1GmDXu9ZJcLH7mDAoU1mn4wFA9AhjAEblVhxsnHKRwRqX11AldKsEDFrAnqrN+sAKuSPQcDzTEb2qMU1v8BIAOpKv8/rURlsPSkrzaXM78RNJ5I7XeT3bvg10/ARIPkdyb+gbC6oPhDbnYNrBS6zXJ3fgPthC/dHA4em2l5XkkKSeXQjBsK34w8DxH4FB89nT1/Vzxvuf/AnQaiABUFnhhDd7zoJEo6Gl0yXI9vrNjjmP92Tnz3j8XlWBgGjovMOhyLoH6dL+1jbp+6cZvKJwYoph9a60hrr4292Mn6sKXSL80bqGD6ADHBTWSYZOShl8XZRIyy+1uY7agU9myU7LK8H4hacRk5KPqj7OcFXJcCejEM8tO4dfRjVAlwj7+y1ChAgR/1U8FrlydXVFZqaNpCY7yMrKgovL/0MMtYi/Ho6eLMzndbIu+BpNfHqqUn4Sn+RbDjJNvcJBl31/op3q3wZNOZB3j0/KU64CwQ2B4KYkTr+/Y4xJlsjYx5JylYR32Eo+6XfwRGHVHpBETUBqWip0ckcoVY7wKLgNVd0hEBw8WPCe+tU8VTCsnW3FC+A1EGQc6uoaQDUn46b5e6QKhjXs+Zj/rdQAULgAIzeQHGyYQltj589IJAx9O0WZxvSznW/xaX/KZYZeqAs5u6nOQAY4uIcAw9cAq0eah27U6gNUbcc5VC1eptoQs5Xb1ZabF765icDpX6mc+UeS2EjlfH3bqySX1TvR3pd4gj1JBsTuAe7sA/rPZRqgrUHSAG1sHT5gMMPVdbbfA1ABix7Jfit7Edv7PqUlceVwc7tnja5AtU4MsRi3nT1H68bphwg3B4atYES8ugjY+z8OIzZAXUR7afv32T9Wls9ERY2a6kozfY+adw1j/5YlwrszHXLkBp7fC0tJkENbAj1nsU/LqyrVv/WT7R6frnZf6AQpJEe/s55x5lnVftoewAc87qHmASDqImD3R0xtTL3O4zRFWSEkGyYzbl+QGBMGnbyBfBukHeD9qdWQSCdf4HUL746E6HC4JV+3H3V/bRN74M4tBm7tBI79wPuiogcUABzk1qTKAH9XFd7tXgsvrbpgtaxVNW/4m6hcj4P4zEJUcpHg+64h8Eg/DXlRCgpbNcW1En/M2H0T0cHu8H3CdYsQIULEvxWPRa5q1KiBQ4cOPfyNehw6dAjh4eGPvVMi/qHwrQ08c4TFQvwhqgMtX6Gi9bgN1PaQedvcZmOKmK1A4Sf/PnKl1bIIXtzHaN+7soZR55ZWOW05sP9z2qC2vswZTON3Ai4ByM4uwpXkXDyzNBMAH5IEuTtgy4RX4Pn7VPbGCIJ+XlAZyYjsIYVTYTqthTGbSYAurWFBrS6iWtnuPRarXb+k3WrLi/xcpcbsedGUkoC5+JsXzIem0x649RXauVaPpr2r9evc3qlf2W+jKWMR3e5dKiSugSR9Dp68D4pzSJbiD7EPrcuX/DnpHIMZTAPbLq2kapSfbAyDMCC4KVWdsiIqPZbQaRkUMWiR9TJT5N4HoOP77UGnoRpmb+ArwH4ll0Bg2GqSoNxEEiKpkgS7yxdMKTSNsI/ZSvvaaH1whimxMoXShQOGE01sf0WZtPO1f5+KTdQI6/ljjp4k9gknaGdcM9p4nNc28XfA4CW0habH8HVDDLvp4bd4GUVOlZBRJkXAuL1QbJ3KcyFIoK3eBTrf2pB6VLat/AEkVrF7rV9Pj6Gi+/s7tj+n07K3r85A4MpGvtb8ZeD316zfG9GP6ZF1B9PSqr93NTV7Yu6hO3jLv4J4em25+fU/Ox9oMuUPqe6CIKBtTR/8NLI+Pt9+HYlZxXBSSDGiaSgmtKwCL+cn65FKz8nHl9HZ8D7wFgNcPH3hlrgNfilXEdj1WxSp7Qz3FiFChIj/MB6LXHXv3h0ffvghVq5ciaFDh1b43tWrV+PatWv49NNPK3yfiH8RpDIWL92+YgEmVTDq92nCNHjBEjqtbZvUPx35yVQoTKPIa/eteLjuxRVUiuoOYdgCgOvJeSjXmCsF93OKcSFNjdZuIZA1mkjlI/ceoHDkTB+FI4vmoizb23FwAzZMZnLa3v/RFlezOwvp2P3AmlFMulva3zyx8N4pzoEatBA4NMN6KGzuPfYEtXmTxb62HJCrWIgv6sX7yxSFmXzPgS+pvEnlLOTXTzKuu0ob9trsepeFsaM/UPk9oPf3wJbnSWLTrlEJeuYokwA15UwjVLoCpYVUKOwh83bFqYyCwGO4c5DX78Qc2++r2YNKoKKCAAL/ulRN1AX6RLxGjMr2CQe0AEpzjcTKwYNpdL61SDwvLGWcuS3IVCSopsTKFCd+pELdcDz389SvVGjC2gHVOtJi2uFDKl6WBLI4G9jzAWP293/G3w/dp/Oa1ugKKF2ga/EKNCV5UOz7EKHqPORU6wfdwKVIyS1CabkOrp6+yM0tQHijSSTrVvuv5ODpQ3ZsgxDsh5YAjHZv8pyRXHlVI2E+8AXJmZMP0HAcCdz1LYBXzwfEqrxSU5S5hWHHlYt4JaKW/W04etJWa0BZYcX3zSPCzUGBbnUC0CDEA8VqDeRSCbydFVDI7CteD0MrfzVc76Xx/jmvT6ys1AjS1tNQLWUPCgPG/OH9FiFChIh/Gx6LXE2dOhXffvstJk6ciJKSEowdO9bm+xYtWoSpU6fCy8tLTAr8L0Ku4r8/A7417S9z8GAh/jdDUVk5MgrKkJZXApVcCi9nBfxdVRBsBS3YQkGq9UwcJy/7/W0AkHcf5d2+gcStEiT6fVh8/C5GNAmFo0KKojLjE+dfj95Di35TITv+HUMWDFYthTN0k/ZBaDmN86EsEd6NvUTpMbShOXrQ4leSS5UNoB3v9K+2i8fSfODucZJAZx+qHv51uf2MmxyEu3kqr+mE3cAvrW2vRxBo37q5A7j1O18zzBIyECsXf6DpMySpBsuXWr+uS2toy0q/yfCNvZ8AAfU4XNgQlR27Dwioa7Rf2oOmjP1tt20oJ7V609ZZlEkF6NpG6/j3kGZUc9aOBwYvZl+S6dBegEpgq1epcCWcANSlVK+8qgHLBtIy6RvB99boSjJwci6LY2cfIHo0VS6J1Npy5+JvXxECSLLdgvWDft25H4JAK2TMVqDTJ7xepuTBFPfPAW3foeITPZqhGSd/oSW1Sltozi2B7NRPD97uHrMN8AmH16A1qPfdFWx6Phh5eSk8B42nAGd+Mx6DoycwYIH1XDED3IIBTRl0/pEQ7hyw/R6/Ogyb6PENcA/A+UWcs9b3Rz5sKMpicqJXNfaubZ3Gc9bmbehCWkLIT8a+Ed4QVK7Q1O4P6bX11ttoNtX8wYiLP3vMnhKepk3PuTSdKqnpEOsbO4Bbu6EYuAAy5AMQR2yIECFChCkei1y5u7tj9erV6N27NyZMmICPPvoIbdq0QaVKlQAA9+/fx4EDB5CYmAiVSoXVq1fD3d39z9hvEf9VuAQClVvT5mWJdu8wOvpvhKzCMiw6Fo85B25DrVeNfF2U+GVUA0QGuUFmOmDUHmwNz828Q3ubHetYiX8DzDySBS/XMnSPDECpWovxLaugTK3Bl/0j8dKqCw84VF5JOSSJJ4BzFpa2sgIIv78LXePJEHp+y6CH7Hja66JHAoHR7JkCOItq8BIAWjbrD15CRcO7BmPL7eHuEc4/cwuionPwa74eWJ/BCkdnsccm+SKJwvXN1usI784+LNNkubA25oOT649h75iBWJki/hDQaDSJzdWNfO32Pu5TcCPgzAIgpAltiMNX03Zni2SFNufcqM6fA0EbGFufepW2xtr9gYZjqcj51KLNsc8cptFd20jFqME4RnQv7GlM72v2AhDUkMV4cRYQ3ITFeXEOUJbHfrdaPZjWWKUte9ditnJ/PMOoOKwcbiQgpXnAng9537T/gP9vipJckhB7kEi5XwWpjBVfN4EDlg04MYfKVcPxJLe2IHcggd74DCPX02OA3ETo6gw0I1YPkH4D8nPz8UanYbifU4x9N0oQLb8CB0dHYOI+fl7uQGJ79wjDT+IPm69DkAAdPkC5RAm0eRcyW+RK4cz0ymUDAd9IIOh1oPWbgKMr0yKTLgCXVlPdOnQHqNWLKr2TL5AdD/n89pCX5MIBANyCoe77C7Te4ZAfmc77xdGTUfY6rfksrvbvP1CX/24QJBJzYmWAthw49DUktsJIRIgQIeI/jsciVwDQoUMHHDt2DC+++CIOHz6MJUusf7m2bt0as2bNQr169Z7KTooQ8QBO3gwOOPg1cHEZlRLDQNnavQEpLTD3s4tw+k46BAArTiWgbU1/BLg5QC57BDLzFHHwZhpm7TUfcJuWX4rhv57ErldaI9jzEWbPuAaxODS1WcVsZTjBlXXWao5UgfTa47BwURLqBjmjuU8JqjkWwbG8BHkyTxQ4eGH1lGZYcvwuErKK8GE7b8j3vGh727d3s29OpmIPVEkOVYnLa2gRMzA0bTmtbNteNSpqbpWAgQs518eeGuLiz36mpf3NgxmSzjGafdRGkrkdbwKNxlMRvbKe25PI2PtSqxeHKJuRUME8LMEvAjj4lf1znHKZtsCceP7s4E6VJawNENGXFkWABLTz/4CdFpY0R09GuatLSTzKCql0tH2H843un+VA44QTXA4w8XLKYSo/Dp5A8iXez/WGkpjcP0uyVZrP/jClMy1o986QWCeeBnxqAEdnk1wdms7UwkaTjXbOg19aq1MAr1/TZzm7SunC8BODIuMXQRXYVm9jeA8m7jUYy6RBU2JlwN6PGaRyfok1mXUNZD/W5TUcYmxIeKzeBbqY7XZD9ZWXFmPQqHHYc68MG69k4tmxz6Hypn60I25/g+TaQHjbvMFgm3OLgNz70AVEQdvyFRTIvPDStiQEOQPTei2E1/43jdfCpybQ8UP2KwI8F0HgveuiT8gtSGZ/lQGn5pJ0dfuKCZGmyE2EfFl/ZI85gOIqfaAS1HBzdoTk/BIIx/QjEhw8+EAovLvtcQF/AwhJF+wvTLnMnkkRIkSIEGGGxyZXAFCvXj0cPHgQsbGxOHr0KFJSOFfD398fLVq0QNWqVZ/qTooQYQbXAMYpt3qFPVZyJz75lZA43UrNx+BfjqOotAxfNwY+234dn+24iaUTm6B+iAekkscrZHKL1ShRa+CokMJF9ehzXdLyS/Dt7ls2lxWrNThwIw2jmlV++IqcfKhWHJttfE1TxqJ62Cpgx2vGlDyvakhtNwPvHixApxpu+LhuFry3jAKKs+EAIFDhhOw2nyIzpCsc5FI0DfOEj5PUdoy5AWfmUxEpymRMdXE2FRdT8uJRhcWWqVUx9x7nH3X9gqTCFhpNZrFua8BxeQkVG5Ub0PUzqj3VOgLjdpAQlOQBF1dSPek1i+fJYJ+MP0x73M2d/FmnZR+WLeUKoGqhK6fCpdXQ8ph1h/8C6xvTKWO2cdvDV9H6l5tItSOsHT+fdBFYPcK43sur2Z8zaCFJR2GG+Xbz7lEBTDgBaMvYM9RwPHBrNx8gDF9JcubkxZCRwCgg/igL8/2f89waCAFARSSkGeAXScXLlp3zwXsPAyPWk0DnJjIN0CMMkMg5CHnNOPPEu4B6jEGXOzA18dIq++u+e4yk2VJBavs2xwEAQONngOPfo7DRC9A2eQ6OBz+2vz51MXQ6HbQA9r3aBhKJgJIxv0OTeBpOHd43n5128GvG/g9eBKRcQaFTJVwsCcGI3049eMuVdB+83n4tgpTFCHR3gkYig+zMb1AUpAJBDZBb/yXaAlUmlje/CGsrZb1h7DuzhfISuNzcgPnl/XHgZh5aV1dgYuOpcK8/GkJ5Cfv4XAIfPBD601Ccy/vs0ip+h2v1ITl3fQS1TOFkf5kgMEBFhAgRIkSY4YnIlQFVq1YViZSI/x/IHRjBbYHMglK8tPICsovUUJrULKXlWkxefAbbXmyFQPdH62/IKSrDlaQ8zN57E4lZxajl74KXOtZANV9nOCkf/tUp1+iQkGXD0qfHteQ8u8vMoHSmfcq7OtWX3HuMs240AQiqj9KRW6EpzEJmYRkuZkowY2cO7mXnYd/oAHivGm1eDJYVwmP3K5ANr4E3WwVDqVNDJ0gA/zpUamxACO8OFKQAMVtoz3Pxp6Xt7hFjJHeHDzh81hK5iSQmTZ+n0vVgpRKg9WtUDu5X0DuWeAKoP5aErs9PQHEmcOoXpu75R9ISl3oZiDvCWV873+TnLq1iEEHCCRKE23uBmj1J5GwhoB4Lz+WDqXokniahTblsrSpcXEn1rOlUJhTu/xTY/T7j4Le+ZL3unLskxsNXA4t6M4XRcA5cAoBf2xtVyXOLaecbuY79WApXkqSCVNrR3IJZ5B+ewQHA+z+z3t65xcY5YYJgP85d5QasHGqMzz/+A++r3j8AWh0w/neS9ty7JCsKZ5I6QUIrnC1CbEBJHpWxglQO/Pavy59jtgFZd6Dp/QNSnOsAXX6F0tUb0AGqOgMhvbzS5uo0Nbpj7ukszD+Vir3T2sDdSY69dxWoFdQVQUI6lGO3ARdWkET41wVqdCExlqugUigQE28+uuHivVyMXM3XBtRXAiiHm2wIohoPR3apgJZBVYB7B813wtmXDxl2vmV8zT2YASF2IEs+i2xVZ1y+n4vL93Mx72gc1j7THHWC3Oyfu6eJ4lwOaja1f55fyp68EWtofa0IlVtYq+YGVO1AdVSECBEiRJjhD5ErESL+bsgqLLNLWrKL1EjJLXkkclVUVo61Z+/h023GePDk3BLsv5mOX0Y2QMdafpA8RAFTSCWo6uOM2PQCm8ujgt0fuh8P4ORN1aB6ZybYyeTIkXggKbsYt9N0CPEKwge7r+LSPRaM3SN84B2z1LYlDIDziekQghqy6K/WCbq2b0NYNsj6jd41OPh3UU/zYvrqBib5NX+Rg2qz42z3fwkS4Pd3GQdftS17kCQyIKwti/m8ZBbqdo/bjySqMAsoyWa8vAEJx2k9G/AboC5h2ECbNznItjSPqYDDVlBtiz8MdPmclrrcRPNttHyFNjX3EKpIm56jre3iChKynHja2UzDJ7RqoHJz4Ne2tAD61maSoD0ic30LED0KaPGiUWmKGkFCYFm4Zt0BDn3N0Ijo0cDCbuw3qz+WiqXcgcOfd77N826J4iwSupTLVNRi99m+Lm6VrOeSZcayb8rRm1bDPj9SvUi7ztlc1TpwXlbsXloQ7QVDhDTmdYgexXs3qAH3qWYPILw7pJfXQOnbDHFZhYjKPgf51TXQNRwPXVBDCPfPmK9L4Yzcxq9iybxEqDU65BarcTU5D3MOxCIltwS/9KuEhgdf48MHjyoMx0g4TtteQRpkTt4Y3Ohl+Pdpg+c3JVrt6p30QnzYuzaO3MrA7SItBjaoBD9nOazuZoUzlaqgBtAdnQ0h7x7KHXwg86hirUjqUehZG4kpxv68ErUWb667hCUTGsPT6S9QffLvW/fVAewHPPkL0OF9Krr24OQLdP8G2DbN4nVvjldQ/UUkUYQIESL+QXhkcvXMM8/g/fffR1DQI0yut4GVK1dCo9FgxIgRD3+zCBFPiDJNBfODABSWPSTtTY+MgjJ8tTPG6nWdDnh3wxVEVnJDgFvFJM3bRYnXu9TAM0utFSFXlQwtqno/0r6YwcUfAHA/uxhTV5zG+YQcAEDtAFf0iw56QK6quEngkGW9/wYIWXeY5FepAZB+E4LSnYX0no+M1rqAeuyz2v6qbZXi0HQOXU08yZ6sIUv1REkH5CQypr20gH0pt3azyPOorI/MLwUK0tlb1WMmCZAtRA1n8EGPmcCG162Xq4s5ULfPT7QHVu9Mi6AgYdF4cxdVrm7fUMHqP5ekIeEEoNKf/6IskjTvGiye759lvHnKZYZPeIQC3b7m+sv1PSahLUjYygr5s1zFY7UHbTkVq4Ao2sHqj2GP4Pwutt9/dSMwYB6VOo2a5Oz6Fi7zDKMKZItYASQ//8feWUdHdW9t+BmfyMSdQEJwd3f34lYoUCilLfXeem/d3RWnRUpbpMXd3d1DgBAh7qPfHzvDZJIZCm3vvb33O89aLGDOmXPOnJnA751373enHhOHYtgM+XP5EQZ933cfhFyW0yukV27/TDi9HM6sdg1Gzrkir+HgXBj0tSTJlS+1jGog73HiVldZYI9XxVHLOCd/V2sIbvcYYVvuvyHwVBc2w6CvcKSfRHXweyjJw1azD5lNHmTi0gwKzTbuah3H4oNXmbE98cbpnl2TxryuLxG+dDQ0GCHv7e6vXddTcB3Tphfo3Ow+JjQfyqx97smbVcP8mLU9kbxiK0/2rkVUoBGVtzlkPkFQuSUp3T9l9aGLlKT5Mazlk4ReGVFxX7WWjOrD2bbNveT2eHIu2YWWf4+4OnqTYdX7Z0qCZkCM930M/jL7LbaFlAfnXoHqPaFWb4+VAwoKCgoKtyGufv31V2bPns2oUaMYN24cXbp0+d3nJCcnM2/ePGbMmMHp06f55ptv/tTFKij8HkG+egKMWnKLK4ootQoqB99CgARwJavwRrpfedLzS8gqsPyuuAJonRDKiwPq8v7q0zfizwc0jOaR7jXILrKQey2XUF89kYE3iU92OMSJUetA70t2oZl/LDp0Q1iBlBje1ymBhrGBHLmSw7ksG4Wh9fBN3Ob5mGG14PppCYoAmQ1Uf7iENeh8RSzpfOQb+Sv7PB/DYZdAg6j6oPMX0XJiCfhHyRylK/tgzbPi6tTuD76h4r6F15IFeY2eUtKXdlKE3o5P3J2f5hOlrMxaGhLhrV8q7SQy3AkZmnx2TcV9avSU17zxdVkgRtaXmT1+uFISLYWg1cufi7Kk36YoA3Z8LMOHJ28UQXL9tNyrYz+5jp9+Gto95vn6QIRq5gVxxvp/JL1pp1d6HybsDGdIPS7PST7o2pZ5QfrLguMlvbEsao30Tv0yWcTk8seh/8ciYK7sE6HbeDRkX5H3yuO5bUDp+3DsF4kcd4qrgnS5T4WZ4jyO/EEcqoubpRet0Z0SAvLLvRWP2/cDcb+O/AjVuqI5ssDdOTPnw493oYprR/GIhexLsbHqfDGLpiVRYrWjUkHX2hFMnO1eRpqYUcBhaxxd7t2GGgeqaV09viy/g9MYM2Iss8p8nNUq6N8ohvu/30+J1c62c9dZMrUd1cNu/rM9Z18aX22SXmNrx0jGdXkD09bXXHP2fILJ6PMNr2/Pw2b34mb+O/A2cB3kft9smLUTY4CMIej3gXwutUqflYKCgsLNuGVxde7cOd59910++OAD5syZQ0hICC1btqRZs2ZERkYSFBREcXExmZmZnD59mt27d3Py5Ensdjvt27dn5syZtGrV6l/5WhQUiDQZeLZvHZ795WiFbRPaxhPqr7+l42h/p+TvVhLUQcTe2FZV6Fk3kswCM/4GLceu5jD0q53kFIlYiA408umoJjSqEoi+fHN7dlKpa7EMDIHQ+gHUQbXYdbHiUN9nfznKq4Pqo1GrWHLgKvn178L34HTPseFtHpBZSk6SD0l53PzR8vewmtDqfqjU5OYv0KGCgFgpYzu90rWY2/k59HgFJq6BJQ9IyEJsC5kh5RzEq9FDi8niTqm1Mvvoyl5xgOLbS1ne+ldESHgpb7yBSivXXL7MDaQvJDBWyvtq9JCemfTToDZCozKOQ7Vu0msFUlrmHJ7c9UVZYK59Se5lYKwInLLf3JsLpOytWteKZXjOuVRrXhDH6OdJUmo36Gu8El5b4tavn5WkwO8Hu9+DlU9LX9WBWVKiabPINXf5p7hJzvchK1Gi2KMayDEj64M+EExehCpIaZ3TvbSZRdQ7iW0BqSfkzxe3iCvWeIyIZr2f3NclD8jnq1o32S/1mAQ3LBwLNbrL/K6iLPfepbJc2o7u0Cxmpg1n/SmX4xZpMpKeV+Kmv7VqFfNGxdPkxLtoflssfXbeBvLarZhs2Tfa0IJ8dTzbpw4L916mxCoio8Rq562Vp/h4eH3v9wcosbjei7OZZuy1WohzW5Injqlai90Qy5XciuWCdaMDCPNRibubnyqfD/8I+VJC8xdX6tcZIPPiPFGt6+3NBVRr5JeCgoKCwk255X/JfXx8eOmll3j88ceZM2cOM2fOZPXq1axcuRLgxkBUR+n/fCEhIYwfP5777ruPFi1a/AsuXUGhIlqNmj71owjz1/Ph6lNADtEBRqZ0qUnPupG3nPYXE+SDn15Dgbnior5KiC/Bvrcm0gD0Wg2xwb7EBvtyMCmLhxccctt+LaeYMdN2s/qxjlQNK5POlZUoZWN5Ka7Hzq7Gr8k4Xup2Ny+vu+Z2nAKzjSd+PMzM8c2JDfbhTHEwgaN/wrB0iity2hgkCXOnVrh/q20zS8Kbcz6RMVia2S9slACF1OMVX1ibqRDTSBZvGoMIh8IMCXewlogYGfMT9HlbFpC/PuyeSmgzS8iFXzhc3SclaCN/kBCHa0ddpV0F6SJovDXWB1eV4IZ+H8APw13ugc5XgjYi6kgPjm8IVO0kUeeHywUn+ARDqymw5QPpD7KZofYAOLZIyhK7PC/DZZ3XH1ZTSgz3z3Jd0/pXYfxvMotq/0y5F5Vbi9DYP1si9VNKRb+5QHq/4tvLbKyyqFTQ6y1ZyDps0tdy11IRsEk7xQFsPEaOr/WFCaXvZcoR6TPr+nzFIIuUoyJ8Wt0HS6ZA/SHSK1c+zQ9ECO4unTdVs5cEl4BLJC4tMxi+MBN2fAaAvddbqK8dhvFLIe2UCOPCDClTrNIGqnURIZh2UkJDvA0aBtQlebxyRz0MOjWHkrKJCjTyWPeaFFvdfx5HNgmj4flv0J4sDSq5Wf8QEBAQwIzxtdBqVGQVmJm14xIHktzdna1n0ykoubmY79sgmhnbEwn00fFMcw2B3/eWz4FKDTjA4SDcGMinQ1bSfYarXNSgVfPtyFoEXFgh/YPOcBNjEAz6Unrk9Lfmrt8SEXUqOp8gX2x0f1XpmVJQUFD4F3DbX5OZTCamTp3K1KlTyc7OZufOnVy5coWMjAx8fHwIDw+nQYMGNGjQ4F9xvQoKv0uQr54edaNoEG1i95Z1zJvcmpgQ/9s6RkSAgQ9HNub+7/dTtqrHoFXz8cjGRATcpIzPC3nFFj5a5zma3Wyzs2jfZZ7oWUui4s1FsOV9d2FViubgHLqPGM07Og1FloqLQIdKxYZTadzXuRqHshrg338p4eo8zFYb0eFhaArSPQ/23fGZRGWPXigN69mXpfeo64vw413ujkD7xyRY49tOrsf2z5RepIFfugb4Ju2Svo3gqt7j3nd8Av0/gbOrxd1oMxXqDnLf58QSaPuQDBUui1oDXV+QdLrsy5KAdmIppJ2Q4azrXnV3SDR6cU5imsG20mPVHwKNhsOiCfKc8JqQcVEctk1vyz5511yvwTdUBOqhBdIXtewhWSTbzDKAdtJa6dWylYgoXfYQhNaU/rVp3VzXsv5VEWjRjUuHBGeJ+9T9FXGLrh2EpN3yWhqPkUCLJnfJuY79LImBQVWgTn9JObxxr5ZKKeD6V0XcgIjTnm/INSYfkGNOWivu4MHvpew0oo6UZyZuk+s2RYv7tPtrcb06Pyui21N4g28oqdFdiajeA82OT6Qny0naSUlvHP8rJO2A9FM4bBbsNfqgcYqictjrD0evVfHWkAYUW+wYtGqCfPVczixEr1Hf6K28s64Rwy/zXE/MuezdwQyuyrarDmYcOU/d6AC3vq2y+Og0vzt2Kj7Uj861wmkQpiZs7zsugV1W/BfnEJe6nkntu7H17HVaVQ1hUvuqVCo+Db/c437A4mxYOAbu2y5fZvxVmKJg1DwZhL1vmjhrCV1lpldYjb/uPAoKCgoKN/hTNQhBQUH06dPnr7oWBYW/FGcJYLjp9nsE9BoNHWqEseqRjvyw+xLJOUW0qxZG19oRtxzlXp5Cs40zKd7jqw9fyabEasNXr5XEt6M/et03PPE3msUNZNs594Vu51rhRJn0rHi4HUHWDKKK9mM/vZpivxiK4vtxOltN3YAgWVhd9yD0Nr0FU7aJMMi5LKl4+SmyEN/xmWuwbbWuMHtAxedf2i6L/T7viXviHyXO1OXd3m9MURaYImHE3DLf/qtkYX9+vexzaB50fBIGfw0H5kpyX1QDaHqXzE1qdb8s+gvSpZSy0SjpF7q80/1cNrMIxbuWSHT7NeR880eJ27buJej4VOkcsY/LvDkLZFhs4laJwN/ynpRpNrkTJiyXe2QtgZBqkoAYXAVUGimVi2sjgRLmAgmy2ClOD9ZiWDQe6g2FSeugJEecIJ2PCL2yYnTvNHEGbRa5Ro1OhFbDEa4SPidHfoSsS+Lk+UdB4XUZkOwfAb8+JPvofSUiP7y2lBcGVRZxuvMzSQxs94gEGeSlSqmdo/T5Gi2Osb+gWvnkjc+PI749qR3e4ttDJbzYON9dWDkx54uT2eV5+O0xrBe3k93yCcLPr3W5N863qFILNmeHcf/sTQxsHMODXWsQWfplRrjJwHvDGvLoj4dwOMDoKHYX/Ts+E2G55D53EegTTOaAmbz2UyapOSVM7pDgVVyNblmFYN+bO2BhJgPvDm2IOfsq2oWeRxgA6JK28OSQSUztUh1/gw69vQjWfeh5Z4cDdn4J/T/8a/uaAmIkRbP53XIOg8l9fpeCgoKCwl+KEsWuoOAFX72WmlEmXuocApkXUKWvQ5WVANpa4gTcJna7g7hQX1Jyiz1urxVpwuBs5tLo5RtsL7OndCobHWuGs/NCBja7A7UK7mgYwxs9I1BfP4DR5geL70VbGnigBwJ2vUfuwDnY/RNQt3sUlk6teOCYpuIGfT/KtWg/vAD0Jok1r9ZVth/8wfOL7PCEODt7vpOyxoi6UhYX18b7jTGYRMj9fA/U7CNO0qLxMGSaJPUdni8lZPtnifBp+zCkn5LkuUUTRHA0myj7hlaXcAWdLxye5/l8Nos4M8E14FqezJG6tl8clswLEJogZYK/Piz7a43iAGRdhO4vSzDG1g/E4SvMlOs6u1r6xsz5EmNuLYHB38iAa98QyLwIcwZAs7tFRJ76VXqqqnUVF+34L3LfohuKO+fJ5Vv5JNy/U9ytrERJ8ft+iAzj7f+xlOE5Sz0dNgiKF2HlGyrCbtE4EXnB8bK/f6SIv20fQKUWMky4Ri9xKvfPlJlc1iJX+Z7eD8c96ykMrsmpLt/j7yjAodJwOEODPSOQB9oZUB2b4f19TtwiJYtAjiaYl7YV8c9Rqwg/+AXac6vAYKKo8UROh/fmwYWXKLHa+XHfFTafSeeX+9tRKdgHo05D97qRrH6kI/P2JKExquT9cZaC5lwRp7Lfh+La5V6FwMo44juw7ryWy5kSp7/pdDoPdK7Gl5vOu11ijUh/JrWvil77+71FEQFG0ARJP5mXKHaCEzAajBidvUr5hZ5dNSfpJ0uDVf7i0AiN9uapgAoKCgoKfxmKuFJQuBmZF1HPHewee+0XBuOW3Vb5TmGJlbm7LjGuTRw1Ik3EBvuQllvM0kPJZBSY0ahVjG0ThzXnKuZrR9EmbUNbZyCqzs9KGlu5kAR1/aGMiahCr3qR5BZZMOo0RKqzMfw2FW1IvCyqsxKll6PxnRDXFhwOAvzCYNkDkg54x+cyhDbvmrhM1XvK4ve3Ryu6IeY8mD9SBMOp36SMqTz1hogLVDYp7uJm+TX4W1m4n11d8XlN7pIyN4AzK6U8LbYl/HQ31LkDxvwsx1WpREBc2uH+/A7/kLKz1GPSU1SzF4RUd8Wkl6VSU5fY2PYBhN4r97fLk9IPdGq5fLt/cSsExUGTMRICkXxAAvSqtBTHKqEznFsn7lr51D3nvVv9rFy7zSzOW0mezBXT+0P17uLoHfpB3EBTdGl8vN57LL3DIXOlIurA2hddfXQ7P4Muz8mQ4rxrIvJSjsK84SI4h0wDaxGOYTNRqdQiTC2FMHeQDJGt3V96bxK3SXlleG1oNkFmaxlMstBf/QJc3YtjxxecqPcsw+eer3B5CRMaEH6zejqVShwwjZ7MsOaUnC/mcGEY501TqdXlPootDk7lGWmpCyPAmHwjXTM1t4R1J1MZ1yYOlUqFn0G+9Hixf11s5iIczSehKjugOuMc/DhO+uta3gurn0V17Shd27+EUaem2GJn7q5LTGgbz3fjmrP5dBr5JVY61AynVXwIMUE+WCyeAz/S8opJySnmen4J0YE+RAWYCO70lJSzenq9zSa4h0DofeX98yawIhuIIFdQUFBQ+K9FEVcKCt4ozITFUyrOEyq4DvNGSqlcQPQtHSo9v4RrOUW0qx5GSk4Rm8+kUSXEl1cG1uPIlWxaJ4RSmXR0cwe5x2trdCKCbBZX+EDNPuAfiUGrxmKz8/nGc1zKKOCHVlfQXtwILebCTxPExenzrgxTNRdIUl5JHtzxpYiva4dFTOlN4mBYS6TczlsJn7lAnh/TvHSG1Cr37Q1HyKLWE6ufgbtXSYy58/WpVFB/qJT3OQMUQKLRe7wir/f4LyI2hkyDS1tFPNnMkH5GHJg2UyHzvOznJOtSxfTAal2h9QNwZY+U7ZmipZTwnE1S/n65V5w5m1Ve18XNMOQ7KQ10Dv0FKY0b/J2k8pnzxdUxBnkWm1mJ4pyodRIU4hyAbM53F2S934aMC7Drcwl9uFkyYn6qpPQN+krEZ7HMNWPjmxIi0eEJOWdEHRg5T+YyWYpgy3tYW96PbmYPEZc9X5P9cq9K/5xKI25fn3dL+7DmuAIxfILFbTs0H/X5tVRq/DAmg5a8EvcUyr3JJTSv2RPNprc8X3vVznBpO7ZR85l92MzollWYMnd/hajymIPJvDigLg/84HJtVxy9xtBmsfgbXP9lqdUq1EZfaPcIdnMB6kNzXfcutoUMbF48RX5eD31PSPvHmDupFY8uOMTV7CJm7Uhk2eFkXhtYj4ISKx+tPcPMCd7DlxKvFzBx1l4uXHeJ9qZVgpg7uiV+bR+ShEznPdPopfew/CwovZ+8RyeXVRw4rdbI3CnnOAAFBQUFhf9KFHGloOCNguvehUZOaYzyLYqrEquNllVDGTt994011eXMIrafy+CVO+rRJFKDesWzFecW2Szw6yOSomcpkCGpej/4fiiOMb8wbUsW59IKGF7Pn9DjpSVZWgP0fkfcqnnDpf/p2C/iTFTvJqVHpkjZvmyqnMNuk54ibzHWTtQaCXqo2dN9zpLWIMLL2/MLM6UMbtR8KeHKT5VjnVsv5YllF5qFGTJo14m1WL7x3zcDmoyTYIj009JbFVlPxM3w2eIoao1gLhRx0e1FcRTi2kLDkbBgtGtW1sG5EBAH1V4D32DIvyZN/12fhzkDxbVKOezuItXuL31fhRnikh1ZIOcbNh1WPyfXVB6f4NJobg3UHShhE2Vp96gIHFOEPD/1uARcOOPqy1OpGez+RpynpuPFCXPe/2pdpLRx/0y5ZzX7yKDihWMg+xKWdk+h8wmW8rDMC65j/vqohE2MWQTJ+11zv5wUZUlQx72b4doBonIPsWxsPUYvSnErcd1y9joja0UT1nIKqj3lZhoaAnD0eA00ejS+wdwf5s/TPx/xOAMqOaeY1NxiEsL8bgiZAB+t9/EIpkjUvd7A0WQMqrxrImxSjkqZqbNM0lqMGjtBPjqmdqlGmL8Bm8OB3Q4/7rvM5jPiNqbmFlMjsmI8eXpeMZNm73MTVgAHkrJ5aMklvhz2BMZmEyQARmuUz59/pAyXLk9oNRGryx5yXZ9fuPQTBsd7fo0KCgoKCv81KOJKQcEbVu9R0YDLNbgFtGo1760+XeHLaoC3Vp5kVPUaaM6tqrgRZKFclAG17xCBUerGOPZOo3LwndSMqkKXKmq4WCy9YKYYcdvSTkLbR2DnFzI4NnGbpMo5HLLY7/ayzFpK3CohCgExss0/0lVyVh6fYOllOrdWoqOPL5XgDYddUgFvehMM4n6pNXKOnyZWdAVBnKyMMmVnKrUsPofOFLFTrbukEQ76Skr6jixwORaVmklowk8TpHdr4Jciupy9WWVxvsbGY2HbexJlXpQjC94OT4iIcdLsbqjdF5Y9KAt3vzBJ7wurAYvvk2v5YZj78at2lFLD6t1EfLV5UETelb0iAGKbSyT+xa0iEAE2vwsDPpb3qbyDVb2b3BdLoZQHtpnqEle93pTSygubXPtf3S8icvBX2A/8wKYUPZ0Hz8b3wkoIq+3ar/C6fKaCqlRMY3RiLZZwkb7vo17zAlULrvN5/wUMm3fpxi57LmZy1V4bGt1PaM3eqHZ9haooE0fVjqgSOqNaMuWGeIwe8BklZg/z10o5cCmL2tGmG2JmVIsqGHU36YMy+KOyW707p5Vbgd4frUXFc4uPeT1MiJ/nXqf0vBLOp+d73LbhdDrXiutSNby6uMW/h95fhO992+QLHJVK+vRM0aC+xQF6CgoKCgp/WxRxpaDgDWOQe7N8eQIq3fKhCkqsZBZ4dnWKLXZsFnPFMqGy5FyRyOwyjoP+6HxqdxjCpMXnOd44irfrDUOX0AHSjsOlnbJoazQKWk6GlOPus53u+EwW9mv/6XpMo5dv1Hu+Dr9MrngNjcdI+ZrDLsJk/mhoMhbuWSeLflOMOE4luRWfG1xV3JhfH5G/h1aHvu/ChjcqujRtH5ZeMCe1+kof0dp/intXu5/0vJ1YIj1LZbm6H1Y9LQLr10fE6as/RASJN6Iby++maFCVvgeGAFdIQXRjqNJKZmg5KbgOW9+Xa2s+UYRr1Y5SsgciHts9KiIw75q4XpvecrkadqskDjrsEuduKYThs8QRs5olPXDDG5J26BMi9zkkwX3GlLM3xxQl11tWWDnJviTBF12epfOJlfgeWYpDb0JVras4gKuekV65wFgpC8xPq3gMJxln5fWWzkyqXHya2OBgrmTJlxCRAQZMRh0LD1toGxlBrXZP4oMZNQ5x05yz0q4dQjOrDx+OWEOn6TkeP/Yh/gYulIqZIU0rkVloJq/YcvM5daHVZK7Y5V3uj6s1Ep3vG0KoykKXWuFsPJ1e4enVwv0JN3kuyfP2s+vE0zy8m6LRyj3/A8E4CgoKCgp/bxRxpaDgDVOkLPS3vFtxW/3h4l7cIhpvJU2lmLX++AbGep8FFVGn4ja7jdgg+ab950MpvNVtIKx8zH2RfXyxBEk0KdNwX7mVxG6f+s31mEolUc1qtYjGO38UgZNyRP7ebII8T6OXxfjJZVICeORHSRgMqgy7v4WBX4hrVNZ10flIj8+6l12PZZwT52r0ApjdX4RlYGWJjL64xVVuWKWNiJer+8TlajxGgiX8I0VseuL6WRHGOt/SfigPYq8s2tLSrVb3QUBl6XGzFImgOrNazr/hdc/PPbsaOjwu11vnDilz9AmSctHlj4sLdnyxlNydXSMlhWUHulbrKgEYq56R8IjgeAipISK652sy66okD47+JI6XE99Q+TViDgTEwvElcu8NJnH6ci6L85aVCEcXoQ6tju+ezyC2Oapa/cDhwKH3R3XPOhF6OVckRr7NVHE6PRHZwC2+PyR1J83ixlBssTGgYQy960dxOT2HEVFXiFg52SVONTpoPVVCN5z9a+Z8KiUto0vNLmw4nYFGraJf3VAmNPTBV20lOsyPped8GNs6juPJOSw7mEy/+r9TgusfKQL1wGzY842UocZ3gB6vSkgHEOCj443BDZg67wAHk7JvPLVqmB/Txzcn3OR5fl3kTeba6TQqAozKf6UKCgoKCsJf+j/CoUOH2LhxIwDt27enRQvvzcEKCn97tEZoNUWS1La+LwtlvR+0mCzhCD5Bt3yoUD8DUQFGjzHsJoMWs28E5h5vof/propPrt4NUk9U7Geq3Y98m5RKVY/wp/jiLvSe3Iuzq6HBMNfituFIeT1l6fWWuCZOdyYoTgTVwC/EIdn8LkQ3ktK3RqNlEeuwi4g6ukgW0j1fl9K7yZskvS/9pJTpxXeEDa+JoCpLSZ6It6l7oDgPHFbQ+sh56g2RGVtpJ8RNOfIjTFov+2x+W67Bm6MIkJcsA3od/H4EtV+ovM/hteHniXLNHZ6Cyi1ELBkDPYve4KrQ7304skiEqkYPDYdLlPtPk1whF9ZiEYzjlsGh7yX5Ue8vQrFKa5mx5bwfliLQ+0BkexE9/tFyT4KqiMPnLG1s/xjkp0sZXO93IaYRrHlBXDKQ19L7LXHHLEUQ00Sec2mn9BFW744qpCqseFJmk4GUbba8F/p/BL895v5a/SMgpjGsf+3GQ9rQeF7sUpecIgvvrDrNptNpTKoHYXNKZ4Y5sVkkGKT/R27z1TRJ23mv92g6XsxmxrAqNEj6Ht9fZ4qL5xvC0NZPsDa7A5+uv8J345rja7iF/64CoqHDk9B0nAh2vV+Fn9OYIB+mjWtOWl4JydlFhJvkZ/Nmg8FD/Q20rx7KtnMZFbaNalGFsD8wS09BQUFB4X+T2xJXW7ZsYdq0aTzwwAO0bt3abdsLL7zAW2+5p0Q98MADfPbZZ3/+KhUU/lP4hUmqXL1BpfNnfOQb8ttI9Co0W7HZ7bw3vCETZ+3FYnPVQalV8MGIRgT76HHEd8Ay+id06/8p/VI+wTha3ouqckvXAtyJfwQ0HMWx81I6NayuPwFHpnu/iANzpI8opoksNsv2VEXUBRxSNljnDtlH5yvOSMZ5cc3aTJXZSUOnQ0k+rHtFysTKkndN5lPV7A0JXaUnrfYAmNHLe1ne5T2QmQi1+kjv1PEl8nid/hLYEFIdcq9Iil36aRE/DrsMuNUa3BfxIA5c+ydEIJ1eJYK04UioPwyO/eT5Giwl0HwSrHxKXKX4jtKHFttMgh7MhaUx4mXq19QaEVaL73OPrd/8roRs9H3PVVoZkiDJhd90EKFcf5gIrt1fi+jo9pLM1GowEpqNF1GVclwEcOYFEfkNholLte5VaHmPlEnmXMbR932IboRqRk/360s/JYEOI+aKOPxponv8955vxSUMr+USV9YSGcLb8SmoNwyOl96vSk2h+6siHi9svPH6VbX6EOpvYMWxFIK0ZqY2DcH35MKK78mNc34ngtLpYJqiCElay66H++Gz7mm0p5a59i3MxG/D83Rr9wxPdR9Io8qBno/pCY3mdwV1qL+BUH8DdaJvbZhuiJ+e94Y34vXfTrLy2DXsDtBr1IxuVZmpXarL4G8FBQUFBQVuU1wtXLiQRYsW8fnnn7s9vnHjRt588020Wi133nkn/v7+LFq0iC+//JJu3boxaNCgv/KaFRT+vWg0f7g3IqvAzNxdiXy6/hytE0KZPr4Fq46lcDYtj5oRJsa1jadyiA86NYAZKjXGMmYJDksxqLXobQXiWHR9UcSBpVBmJFXvTkZWJrMPSrKZUeMAy02cHEuhCIdW94tYiGkiCX4t7hEhYi2GyRtFYB0sXZA3Gi0L+11fQ6t74cB8SNoh4RK93xKRM29EmftU+s+J1iB9L8d/kWMEVZHFvieCq0ofz4JR7oNYj/4EFzbD2F/E7bBbpJfKYZftp36FhqMqJtv1eEN6zqb3dD22+ysY/SNE1ZcAjPxUmV3V4Wk474BNb4JOLwIuO0nCBc6tk4COzPMijBK6uM8aq9lHZmKVnwcG0ltUlCU9QBnnJQxj24dy7WfXyq+yqLUw5ic574E5EFXPvbfKWiwlkGknJexi01sSYGEpxuETDCufQuWpcclcAHkpEi3vaa7S5nfgzoVyTnuZcIndX0sfXZMxODRa0Jvk+DP7ynatAYbPudFzGGW00y/+HP7n9nl/n0GEoinK9fd6g1Etvh+/uLaoywqrMpj2fMrEe0dh9FKu9+8kOtCHd4Y14MletSg02/A3agn31+OjCCsFBQUFhTLc1v8KO3fupG3btgQEuH/b980336BSqfj666+ZOHEiAI8++ij169dn1qxZirhS+H/LrosZfLhWHJ69iZm0jtHycBMjRpsG/wADWpMNitKktO7gbLDb0LR9BHuNXhTqgtGq/FHnp0siX60+4h4k7aIwP48dMfdy4bqUq225bGNs/RFoI+pASFUpGTuxRBb5QXHQ4zVxkiyFENlEenvsNildy0+TXqusRBnAe36dCLHkg9Kv1fNV+K6bzGdycnaNJBEO/lrcm9jm4izFNBUXqDBTxFXWRWh9vyvIoiwaPVTvKvHkZYWVk4J0ETDhtaTcq6zbduxnmUNVkiuvs1IzcVzsNljznPtx7Db4Yaj0d925UOZO5afArmlgGi29ZLGNpacprAYsmSIzoi5tl5Q/YxAMmyGvL/eqHDO+nffeJJA0xbh2MjesSmv34JDyXNws70HTcTKLzNO9AgnrMBdISeqCOyErEdXI71GlHPF+bP9w771pIEmFsS0gaafrsZJcyEqkMLg2qy5aMarMtI+0QKdX8AkIQ1epkYgkrZTCdYi2YkxWgc3/Rm+TR8JrSa+fWgtd/ykiUwWq7Even2MpRGv+nZ65fyP+Bh3+hpuEaigoKCgo/L/ntsRVcnIynTt3rvD4xo0bCQgIYMKECTceq169On379mXPnj1/9hoVFP4rycgv4eNSYWXQqvnxznjqHnod3ZzlrhKu6t2h7UOw5R3wi4Deb6NOOYL614fw94+kuMlENHWHoqrWE0fiNtS2YjTdX0Gv0tHNXML6e2ux5KyN3nWCpTcq/bgIksDKkgZ37TDEt4cl90m5lm+IiJ3oxnBln7gXTtES2xw6Pwd9P5CQCZB+rWYTJCShPDs+gSlbpEyyb2kJW81eElfe41VJBPQNkxLGNlMlYMHpkPgEizjKvCDiwhtnVsqiXFXunyq7TQb/tpoCkzdDUaYImrSbOCc7PoWeb0hpYfppUBvFWdvxKQRXgn4fQtJuiWYvzpHSORABuuwh6PWGiMCUIxBeV8ShN7RGaDpRgkT8IuQ1eJqDBeAfJffw8AIpP/UUT+/k8m5xopyBH+Z8cVW9RefrfG+elGjOl8ARt2s3gMPO1Twr9YLtVNEXYsvPwJDQFpV/OPiHuu2ut+aLS3ftsHwBsOMzdyHupOOTIg5H/QCH5omoNgRI+elNUOt9b7pdQUFBQUHh78RtiausrCx8fNz/I05KSiI9PZ1+/fqhLjejo3r16qxYsQIFhb8dxbky3yc/VcIF/MLdS5b+Asw2O0mZsrCd2iZChNWZ39x3OrdO+oI6/EOCHBZPuVFqpgZ8D8/D2vUlHFXaor+6WwRSfgrqqh3QrnyKag47Dw+bA8Un0S64W3pzmo6X17b2nzJb6fJuERVF2eLYRDWRxfnyx92v5co+6RO6c6G4Gc50unPrxBly9tuU5dIOGL8CFox0D6xY/gQM/kbu6clf5XhVO4loKV284x8pZWQ3m49lMEFgJfAJlDI0p3MEItRyrwEOKU9s/YBrKKsn/COlx8uTyMk4L9t8wyAgSgRJ2YHOuVfhp7uh3lBXGWXDkVKi54nGY8HoL8e4fhbaPSbDivdOcy8L1OhkfpbWR8Shb6iINm/DmI2BbumHKr1JxPLP91TcV6WSQIeyEfHliWsn709ZGo3GGl6fqtZCtPNHuou9Gr1gwCel15ENNgvqpJ2w+lnZHtMUhk6DVc+6nmcw4ej4FKrU4xLJnpdy43DFjcahM8WgMUW7wjjK4Ihvj1qlgr0z5LMQ21w+U+UFoYKCgoKCwt+E25pYaDKZuHr1qttje/fKAqxZs2YV9lepVBiN//laeQUFN/JTYfUL8FlTmNEbvm4PM/vc3PX4Axi1GmpEinDoV02L7uxyzzte3AIJnSQ+umwPT2R96P0W2pB4dAYfSD4AJxaLY7R4irhF+anoUg+jO7EYBn4uImHrByKI2j8mi/eETuIm/fqQxKuX5Mg+nijMgCv7pcfIiVojYRZl/96yVIRF1IGCFGhyl7sDUZgBC0ZLCdihH6Ts0W4RYaXSiDDa8JoIrgZl5keVp+FI0Jsg56o4ceoy3wc50+3OrBQxcu0wxLX1fqw6d8CxRd63n/oNVIi48QmRwIegONkW21z6ogJiZJju+Q0iZCPrVzxO7f5SXrj1A0lXXDpVnMOFYyXso97g0us3Su9SQbr0OSV0gqwkOa4nNHoJx3CKlqod5bOs1klJpLrMkF2djzhxe2eKwPbkssW2EJFbWCYBr2YfSlo/itWhQvvDkIouWkEa5CTBb4/CV23F4SzMkLANvZ98Rlc/B20flL6tEXOwT1xDQc3B2JN2u4SVRkdh03vZFTmaVEJLe85C3M8VkoCq6z9hendY/hj8cg983lycWU/OmIKCgoKCwt+A23KuGjZsyG+//UZBQQF+fjLAcvHixahUKjp27Fhh//PnzxMT8zsxyAoK/05sFtg7XfqbypJ5AeYMkFCHv2iwZ7Cfnqd712bMtN0YbPk3HxKs1ro7Gj1eFWG05ztZ4IbVkqG0GWdh20eyoD29AgZ+LdHfGp304TjPkZ8KVw/Ic9JOimPkRKuX0jZvJB+EiDK9MzV6SMgFyAJ+8DdSmjZ/tCtgIqaJlPktuV/OrVJJiWFRjqTjbf9YFsUqtes5AN1ehiptofYdUD7UoHZ/KSm8sFlCHk7+CvesF/cj5SjUHSKvwxmTfnGTLOoPz5Oer7IYAyXQQn2Tf/JUGhFxUQ1g2VRxNNs/JiLOGAQL7ypTYrdO4ubvXimBI8cXy361ZYYUp1fA4fnux7dZYMU/JFK+Zh9xYnZ9ASnHJFgk9SRkX4T2j8tjZd8jjV76vs6skh6xhiNEnOVcltI6nY+Ef+SniUgxBEr6osMCpkoylHjj6zIDzRgITcbJgOn00zDye/l8+EdgLS7kfLGJuo6zFePnDSbo+gLMHSzlfSBO4db3xc3r9ab0i2VeEOeyxT2QdZHiji8y5OcLDKnzAj1avITWVkihxsS8Y8XM+/kSm/6RIAmLU7bKZzXzovxdq5fPdFk30m4VkfXAbim1vFWKsqWksyhTXodfmLjVCgoKCgoKfzG3Ja4mTpzIuHHj6NSpE+PGjePMmTPMnz+fKlWqVOjFstlsbNmyhS5dung+mILCf4K8FNj1pedt+Wmy2PyLxBVAg0qBvDW4AVbdTcrVAFC5REej0VIitesr1+b0U5Ig1+0lGUirMYAxAC7tEnG14Q3P4m3Hp+Iw7f7a9dj1c/Ias5M8X0podZnvBBKdHRAr1wcyfypxu6T5lSX5oESZd3lOFtidnobrp2HDqzBqPpwp7TkqK6zqlYqjwEpQuw80HQunVsiit3YfsFnFDTm2WEomTy8Xkdd8IvT/WAbsJm6TUjSQ17/qGRgyrbT8brU8VrMPtH8UbDZx2JJ2eX7d9QbL4n3vNNeg38St4nhV61Kxd6k4W8oFt30kgsdugbUvQrtHYN8Mz+dwOCSMIy9ZBJmTre+Lw9T4ThFAvd8Wdyb5kAjMsBqQfob85g9yOtNKs+Nvy/tvDBSx4cQnWH4f8p2UUeZcAZ0RfpkkA5kbDJO0yBNL5RqHzxCRrNaAtQTrPduICQqA8+4VCoC4iHunu4RVWa7uFzfTP0J+jkDCPMLrkq8N4UzqVd5OzeftG0+Qn4fONcMJ8tWJGA+Mdf3s5aXCtG6uY5W/h0d/gq7Pe77H5cm9JvO8TpUpf4xuDCNmS7CLgoKCgoLCX8htiauxY8eyfv16Zs+ezcGDB3E4HAQEBDB9+vQK/VbLly/n+vXr9OrV6y+9YAWFP4W1WIa1euP6WZlF9BcR4KOjTbUQrAVq7NV7oD63tsI+jsqtUBWkufqc6g2CBWM8H3DrB7Jwdg77rdoJ4lqLg+EJh11EVNlF795p0HqqRJuXR60VIZF9WRLdVIiTMGWLiNKaveFHD4OOQXqujEHiCkTUg/2zoGpnCbLo9LS4bZmJco74DpCfLA7RXb+KC7HuZajWDYLjxAFLPy3uTKPRYIqQBL+5g0Qo+oaK+DAGyoLcL1zK666flVlbDUfCsJkS9W41S9lg+gnpu4ptLv1lZYlpIql+KUckWKIsJ5dB/SGlfUZlHEDfUBEv18+4R537hHgPmACZ2+XJQds3XV7r9dNw9SCcWSHJj8U5Uu4ZVgN1TCuitCXYWt6HxugPSx5wP4bT5Vn3kgx1rjdYxFryIflVnmM/SxR+4lbS+83gn2uyuLtTHq1CEiruW7mVlDh648Lm0vliK+XvMU3IrD6UOUcLmdgunhnbE912D/TR8UL/OpiMHtL37FYpQfTGzUI/ymIugPWvuAsrELdx/ii4aymYIm/tWAoKCgoKCrfAbQ/omDlzJpMmTWLnzp2EhobSq1cvKlWqVGE/g8HARx99xMCBA/+SC1VQ+EvQ+ci3+96CD8qWw/1FhPppyS8sxt7rLVQ2C6qLm25ss8W2puSOb9Fa8tD3erM0Fl3nPneoLOZ8cUicXNws3/LfDI1eStKcJB+ApneJi+Ms9wNxiQZ+JfeoTj9Y+SSknZA5VS0mQ93Bss3bkFgQ4VB3kAiRri9I/5ZfuLhhPiHiZmgM4BcCV/dKH9WJxdBkjPQIZV6EeWV6sKzFUgaYfEDKESetkTlS189AgxEiPJY/LpHwG98UB6UkT1yh6EYSp16tq6TTbf9YXmO/D+S5p1bLOfp/BFWaw4a34MQvnl/XuXXi/JxZVeZBh+cUxetnxBlxDuctT0xT6UErj6VI3t9Go2H2ABEGV0s/p/HtoeUUfH8ei2/mBXksoBJ0e1HE36ly/Xypx10uVnlhUZbzGyge+RP7qz3GO1uyOXI1i0s5x1kyvgaGyPqQesy1r80s77+3sA2dj0sQ+QRjqTuEUzkBfL5xDw92rc5no5vw6+FkMgvMNIsLZkTzyiSE+3k+lt5XvmxI3OZ5e42enh8vT36ajDHwRNpJyL+miCsFBQUFhb+UPzT9sH379rRv3/6m+/Tq1UtxrRT+fvhHS3LbuhcrbguMlYGxfyGOomx8T63EtOZZWZS2fQjaPYJDoyfdbuJMvp46V44Quu5R6QlRqWDkDzc/aHnX4/ppCVYouxB2ojVIKEN5MbniSbhvG9QdKM6W3k9iuxO3iUBaXWZWVMZ5KbdrOVn6aLQG7wIrqpE4IfNGishQa2W+1Jb3RQQ42fw2tH9CrmvvdyI2Jm/wPg/q2mFJ3ks/LTOmMs6DvbTEsO/78n7W6AUdHpeysYBYKXXT+oC1SEJAQATL4vtE7CV0BytSJnd1P5xb7e2Oey65LMyU5DqNzl28HvxeBFvSjorP8wuTEj9P7xXg0PtjL8xCU7b0Tq2VPqwFo93ve+5VcfhGLxB3qny5Xu410AdI75g3dL7sTYO7fnQ5nyev5ZFuDyR29AJxqpxR+WfX4mg4EpUzor481bpK2mSl5lgHfMaIH1Po31DNawPr8eaKUxh0anrUjaRahB/960VSVZeJ6sxWcf+iG8nn1Cl0fIKh+ysSZlH+Hpqibx5cUhZzvsT2eyP3mghhBQUFBQWFv4jbFlcXLlwgPz+funXrotV6frrFYuHkyZP4+/uTkOChvERB4T+FRgONR0tj+64vRfAEVJLUuz7vSBrcX4jt6iG0S+9zPbBJuk5UxkD04zZQ1ZpN6IJxrl4kh0OcF2eZW3lCq8uiXu8vC8eELhBeR3qQ5g5yT1FTqUR4BFaW3qljP8ni3C9c9j/4vQQq+EXI48XZMHS6hC54Yt8MGRDc6E5xk8oTkiCO28a3RFhpjdLvlXHOXVg52fYBDJ8tgQzF2eLcpN8ksTFxmzgWW96X9+vqXulV0vtDq/uk9NFuB0sBrHgCavWTYwbGVFygZ5yDrCvQqK087+xyEYWeHCWA+kPhp4niyJmi5L0pzBTnrOcb0m/mpCBdXu+o+e6R5HHtZFbWquc8nyOhMxTncMERReUWUzEemiHXX2cAjjOrUHkStA67vI/1h8KBOa7HoxvJvcy5LI7jiaUeT2lvdjffH3XvJTNo1ahUKgiqLCmABdfBUoBFF0BGoZWoCxul/LIM1tYPUhxYA78pW1H5hoAhmOHNr/Dc4qN0qRXBx6MaY7U50KhVxAToqMMF1F8Pci/RjWwAdy5w9V2F14Fxy8SZvH5WPs81ekHvt269L1Jvqih+yxJQsepCQUFBQUHhz3Bb4iopKYn69evTs2dPlixZ4nU/nU7HSy+9xJo1azhz5ozHskEFhf8Y/hHQ6RkJRjAXSAmVWiNpcSX5N5+7dIvkFVugKAvTxlc971Ccg3/OWfyOL3YPeQAZwtrvQ1h8ryyunRgDYdCXkHoC7vhMyuzST8pQ3JBqMHyWlKJdO4IjOB5VzZ5wfKmk3+l9YfC3skA1xUjPUcY5ER1l+4M0Ou8lk3abODylIoATi12iJaqBBElknocTS+SxTk+LK+Yt3AFEhDQYJvuoVFJaVvY1lyWoipzfL0x6e3Z8KgOON74pfVhtH5akPK2PRJP7hYlL1eaBisdSqSWRzvnn44tdDlB5UVuzlwz6nbgKx/WzqK6fkb6w8NriKqUchQkrpJct+5KU8DUeI+/r8Jnyu8MhgRjFOSLivx/ifp7wWtD2IVQL7kQ3eBmvFQ7huXvuQWMrRqX3xbB0svd7mHpMSjyd6Hyh8zPiTmr0OIZMQ9VgeEXhGNuCgoQ+rF7mLmhHNIslzFQa3e4TJL+AvAIzTyw+wFNd51DdfBK/U79gNwaRU+8ullzSYz6rY0qnaoD8x9K3QRTBfjreWXmKKXP3E2HSc2/HanSL0aL+dkjF3sfUo7Dmn/LZNviDoXRG14QVMttLrZE+N2OA93tRHv8ImTnm6cuAqEZ/+Ww7BQUFBQWF2xJX3333HVarlQ8//PB39/3www+pVasW33zzDa++6mWBqaDwn8JWLE7Ohtdd4kallhCAxmNuLChvF6vNzsXrBby96hQTGxhodxMnRluSDddPVNyQekwcpdELJITg+hkcsc1RBcXBb4/Ldr9wEWCrnpHnXDskM5Xi20NoDVRN7oJZfWRbSLz08aSfhrNrJOTg5NKKPUQ+wb/vCOh8pRSt6Ti5PmuJlGmlHJHyseCq4gZqdNK/lpV488G+hZkiDGr2Eger0WjPYkytlXK63GQJebDbZOhvq/tg1AIIqw756SLujv8iLlerKXLsiLqu48S2gM7Py0DfC1shAzlvh3/A8ifFaTv5m9wng7/M0YppIs7HvJGoygYp+EeWpvLFSDhIVAOoPUDmVf1yr7wnTqq0ltK+n+6GCctFYFlLJBUyuCqU5MpzirMJurKBAltnph+zMW3bZZZMaUHloAR0l/d4vodBcfJ5rdQUoptAnf4yz6w0Sl11egX2llNQ1xkoIRk2M46afbBFNWHQHPfEyDrRJh7oWh2DVlPhNCF+eh7vVZOrOSV8fiSOAP3jlBQ4MBzQMqhJJaqGufdPBfnq6VM/muZxIZRYbWjVaiJMBtQXNroHg5Tl5FJJxCz7BYd/hPz6I+hLhaalSHqvnD/rVdrAkG//+HEVFBQUFBS8cFviavXq1bRp0+aWSv2qVq1Ku3btWLlypSKuFP5+pB6H9eU+lw679BrFtoDKLW88bLHZSMstodBsw6jTEG4yYNRVXHwCJGUWMvCL7RSabfSMi5aFb5oHAQVYtL5oQmqgTjnq4UC7RGRE1IVafVEdXeRyhEDS8Dz1viRuk19aAzQcBXXvkHKxbR9JUEbdga746boDZXCxuUDEUL8P5L5E1JFm//IYg2QRbykUp8gZ716jpwis0ytk1lJEXVk8Z14UV6dKWxGynohrK3HtKcdg4BfS13X1gLswUWulh2nXVyJ6+n4g8e3NJ4pLZQyAnZ+LUFTrZAZUy3slur7DP+DiVul10/mK43Vpm5QTqo3Q6FsJ0KjZDUff91Cln5YY9lp9ZN+0U1JatuWdigl1+akSO9/xH+LSLRwLPV6TMray1+98P3d/LdflcEiJoU+wOG15qW7lnNriDO5oFMPLv54gt8jKzsQ8AhpNJuxouRRDJy0ny/2O7yDlmD8Mc+szsiUf5kKte0kpMVKtyeM41FrWnMmjW0wU08dHsfVcOhl5ZlolhFAt3J+IAO+D3zUqFQ/OO4C9XJXlnkuZLLy3jcfnhJsM5e5bitfjY7eB7SaBKbeJw+Eg1R6EusPrBLb7BxpzDhqjCZVfOPiGYLHaSc0rJimjkEKzjWoR/oT56TH+oW5kBQUFBQUF8BB15Z0zZ87QtGnTW96/SZMmnD179vd3LMOWLVsYMGAAMTExqFQqj+WHJ0+e5I477iAwMBA/Pz9atGhBUpLrG9ji4mKmTp1KaGgo/v7+DB06lNTU30lUU/j/Q0meiA1vbP9UQg6A9LwSPt9wnp4fbaHHR1vo/uFm3lh+ktTcYtf+dhvkXMWeehJj/mXGNAnDqFPz7f5crjd/3PM5NDps4XUxt37I/fHQauKeDZ8twiDzopRDlRVWIA5Txjnvr+H6WWgyFhbdLSVvliJxRw7OFRHQ931xlCaslACNYbNEfATHyzZjULnr1cOgr8QdalwuJt5ulWssSIeVT0tfkblASrjOrJYZUzqfitfoHwnVu0tvVrUusOE1mW01dBrctUQEUfeXYdQ8KR88u0aet/ktCIqHSi1k0OxPEyT2PS9Feoy2fiDBGP0+FAEaGAs1+8n5bGYRVuU5tRxH3jUsBdkivo7+JK9n/cviEpaPbneSdVFEUs5l6YcLr+makVWe8xvEMcEhiYFFWRLMUbZPDnBU60Z2kYWkTPkM7ruUxdoUXzJ7fSH36sZ7opPBvdYS8A2TctLTKysEOGS3eJQN5/O4a2ESbb86Q7svTrD6fAFBPjri9dncFZvBowlXaBOUQ4Teu7DJKTLzzspTFYQVwOXMIo5c8eJGlcdZjukJ39CbB3DcBiUWG7suZDD4y+20/GAPtT46Q5vZ2WzKCKZIG0CJxcbOCxn0+mgLd07bzT1z9tH1g018sPYMmQVeEhEVFBQUFBR+h9v6fq6oqAg/Py/RuR7w9fWluLj493csQ0FBAY0aNWLixIkMGTKkwvbz58/Tvn17Jk2axCuvvEJAQADHjx/HaHQtOh577DGWL1/OokWLCAwM5MEHH2TIkCFs3+4lGlnhfxJHaT+Qvfxq0FoiSWveyL0K1mKKVQa+23qBb7dcuLGpxGpn7q5LpOUV887QhgSRDyeWwYZXURdmEKPW8GTNOxg69mlGzE9iTUF1BrR5EtPuj0SEhNUAv0hyWz/Blis6KgVGkNDvWwLXPQG1+4vI2PqhhBHofKHBcOnvcQZY3LjGZBFiedc8v4Y6d8i8puLsituyk6Q3q2onEQe/PiwzqEBKIzs8CeOWwvn1pVHsceI+qVSSWDd6gcxH8guTXq/Gd8Lmd+T5MY3ETRr8tRyr4QjZd/hsWfwnbhUhVqsvNLtb3MIqbeR1tH9crvfiNgiIhKSd0gNXvrSy4DqU5MD5deL8eBo0e/1s6QDd0khvm1n6texegg0A9c7PyRv2I8R3I0BrQ7X0AXnN5YcHl8dcIA5XWA253puh94ct70mq4Y/jKvTbOaIbk+9flR82ur4sqhnpj7/Jh+3WdnSdvBNj/mU02CRAxC8CVGosuamohs1G++tDrvdc70dWpzdJ0ccxd5frS67m8UF8O7o+AZlH5f109typVNDkLko6PsfxHCPnr+dTOciXuFBfooN8KCyxsSfRe4nn+pOp9K5/Cz1MATES7uEpqr7ri39ZH9TlrCLumr4Ha5mf//T8EibN3stvD3XAR69h4qy9btsdDpi1I5H6UX54mL6loKCgoKDwu9yWuAoJCeHyZS/DSj1w5coVQkJCbuuC+vTpQ58+fbxuf/755+nbty/vvvvujceqVat24885OTlMnz6defPm0bVrV0Bmc9WpU4ddu3bRunXr27oehb8Rudekt+fYYllUNx4tSXjl+qOsNjtXs4v47dBlYoEP1p5mRMuqVAr2wUenkX6Oyq09l76BLPYNJtJzSphVbvApwMAGYUxqpMcv+xQ4rLJgrztQjpe0E/2pxdTMusC7vT/jviVXON60Bw+OH0GE3ozq6l4ozkPrE4AuP5+jaf58dLwSn0zYSlDuaVTzR7pOZCmEA7OlVK/HK7D8Cde2Iwug9zue5wCptRDbTOY6eePkryLkfrrbPUDCYZcSOJ1RerSsJXKOA3NkbhXAxS3Sm5R5Ufq/CjLEQbmyXxboM3uLW9T+CQmc+KaDOGZNxklZHA44v1GGETccJQLv/AaZRRWSIH1MWYne3SKQXpqohuJYeePsWhGs5nwRlGrNzUvSCjM4cCkTTNG0CytAn31JVtvGgNJZYR7cDJVKPn+mKCmBNJi8H1+llmOcXil/HjFH3qMr+0R0NRqNrdUDnMrw5ciVbHmZGjV1ogOIC/GjqnMmVGTFsuxMbQSXjK0wDlhOGNngsJOpDuFikR/1A0L4ZmwzruUWUydUQ5Q1GU3GEZg/0j1UwuGAA3Ow+MXx8cV2bDmXKacLMPD9pFYE+egJ8dWTnu/Z3YoK9F5O6IZfuLiTm9+Fw/PkM+YfKUOra/eT9+lPYrbamL39optwcmJ3wJrj19BpNB63A3yz9QIPVv/Tl6GgoKCg8P+Q2xJXTZs2Ze3atVgsFnS6m3+vZzabWbNmDU2aNPlTF1gWu93O8uXLeeqpp+jVqxcHDx6katWqPPvsswwaNAiA/fv3Y7FY6N69+43n1a5dmypVqrBz506v4qqkpISSEteiITc3F5BYeYvF+7fdCr9PsdlKer6ZXRcyyCww0yohlNhgH8L8Db//ZCd51+DH8e79S3umQ8cnZQFvDLzx8PHkHCbM2IvdbuW15rBgdyJzd13i05FNaFs9FL1WA82nwJGfKy6YdT7QZALYISu/CBU2DGXWeh/1i6Vtzq/4/TodLEVYVGqo3gNaTQbfHdD2cdjyLqQcpa5vNiFGNRaLFU3yfuzrn7hRsqUDOsZ14kKrV3kjMZujyYG02fWa9AGV59oxaFcJfCOln6nJGFDrpXTvruUSapFR6kz4hUogQEEOGIJB7cXZMoRA2jmwOTyfc98caPeIKzCjzVQ4sQL8oqTEbtnD7u6fRi8x7js/l+PlXYeVz8KwmfL3onzY8aWHC9GCQ+u6huxk2PUdNBsPPuEVE+UA4tqDTQU2G+hMnq8fQOsPcR0hLwMcKkg7I/1hF8QxsZQ+z/m7Pb4zNUINpBRcx5F6EUtEY5lVdf0iNLsX9k2reI7a/eDiTgms2PoJpJ/HUbUHqktbK+xqrzsIMq+gVhvhzHq4dkJcvzaPQ2Bl7OfWsjvZyvbEVNTYifDT8e7QBsQHG4kK0N3036HdF67z3ZYLjGsTxzWfIKx20Dhg+bGr7LyYzXN961AzVA/n1mLf+Ab2ZneDxeLx3hkOfMfkLt3ZfVGER3ZBMffP3cvsu1tyT7sqfLjujMdr6F8/4tb/rfQJh26vQeuH5WdQ7ycunFot1/UnySu2cOpaNgaNZ/GUW1hCTpHF6/bMXHEr//b/9psLSscCZIhj7BcqQlXhX4rzc/G3/3wo/NtRPhv/29zq+6pyODxNx/TMzJkzmTRpEk8//TRvvfXWTfd9/vnnefvtt5kxYwbjx4+/1VO4X5xKxeLFi28Ip5SUFKKjo/H19eX111+nS5curFq1iueee46NGzfSqVMn5s2bx9133+0mlABatmxJly5deOeddzye6+WXX+aVV16p8Pi8efPw9fX9Q9evoKCgoKCgoKCgoPDfT2FhIXfeeSc5OTkEBHgfC3JbztW4ceP45JNPePfdd7l27Rr//Oc/3UryQHqiXn/9debMmUOjRo0YO3bsH3sFHrDbpT9h4MCBPPbYYwA0btyYHTt28PXXX9OpU6c/fOxnn32Wxx93hQ/k5uZSuXJlevbsedMbqHBzLmUUMuDzrR6b4Ce1i+fBrtXRaX6nDCgvBaZ199w/BBLHXVqydjY1n8FfiTNhUDt4rbmdf+5TU2JXATD77hY0iytTqlpwHYqypbzLGCh9RKXkFJl5ZMEh9l2SPpP5I2JpsGKw9x6codNhyQMQmgD1hpLnH8+akvoMLFqMdqtnUY9fKNs6/EDbygbUM3tLiZQn+n8i8eE/jqu4zRgIA7+EhaVBEzofCYOo1kMSEcu7KPUGyfBhhx1+e8zz+UISpEzLnCdR4SlH4ciP4mbt/ExK/EISAAfkpUmE9pmV0OddCaYoypbjNJsEjUbBwlFSPliW2v0lmXDLexXPP/hb2DddYrSvHZHSwYi6UtK5/jUYMVfi9HOSYfeXEllfllp9JcGvMEPmO1XrKvdl97cS0X5gFpYL21lb/2N6ZM5E1/lp+Zzt+UYCKfT+MOoH6aXa+p7cq17vQmgCDrsFHA4sNjvn8nRMO1RATLCJe2MvEbBsYqn7eZeUl9osoNFiNoYwdEkxgT5aXhlYn0h1HnprLurCDIo1fpwt9OPJ5VdJySumbUII49vEs+9SFokZhTSuHETX2hFEBxrRaipmENnsdl5Ycoxfj3h2KSsH+zJ3UktC806hmtVPkh3bPyrhI54wxbCpzXQe/DXZ7eHv7mpGm2phZBSYSckuYueFDExGHW0SQgk36fHR/70i9k6l5DL8m50V5kcDfD+pFREmAyO+2Ul2UcVvIqeNbUzmmf306NHjd6s0/iPYbfJZ3vRGxW2+IXD3qr98ILqCC4vFwtq1a/++nw+F/xjKZ+N/G2dV2+9xW/8bajQali1bRs+ePZkzZw5z584lNjaW2FiZjXP16lUuX76Mw+GgVq1aLF26FM3vLZxvg7CwMLRaLXXr1nV7vE6dOmzbJr0nUVFRmM1msrOzCQoKurFPamoqUVHeG6UNBgMGQ8UyNZ1Op/yA/Ak2n8ugyKryuG3O7qvc1bYa0UG/c381aii+LoEQnijOgNL3SKXRUGJzP1+JXXXjMatD7f5+BkXLLw+E6XS8PawJd8/ay7m0fAI1ZnQlmRV3bDxGIs9VWhj2DRRlQkAs2fYILqUUoy5ORGfwkdlQsS1kYVScI+Ih5QhNqwSh19pQ1ekjIRTlUWuhcmMZiGv3EBBTWAyphyCipvSklRTDxlfBPwx6vyy9YOc3SEx59W4SEHFujYQqGH1l1lR52k2Fcyulr6rxnbD3K2j3KETUgDp9YOvbIlzi2kGHJ6BWL6g/UEoFNRq5zho9IDgafhkPd3wiYRYXt8hcqZb3Qk4SrH6+4hDlqIaQcxGStoLhZbi0We7X6WUS5AGQdwn8Y8A/FHq8KD1VJ5ZJeWLTu6SccFpH6W2qOxjCq8PSB6H53WDJhUbDoN1jcPAKumbj0S2ZLAK76XhoNkYi1o/9KOVq3f8pgkkFXN5GSUJ3Pt1v4cL1AlYekx7U+9vqCD78LWp7sdz/XZ/Kr1J0Vdrw2dBpHM2Akd/tlZI0rZpQPz2jWwWSX2zlUnYJtaMCGNGqKlPmHaLEKvflt2NprD11nTcHN6BaRMUkPR0wunUCPx303E82qlU8UUF+2PNVaOzFcm99AsAv2GMgSmbLR/hif2GFn6NKoSZ0Oh1RQTqigvxoHB9W4bl/JxIiAnlveFOe/vkIhWYpxzXq1Lx8Rz1qxwThb9Dy/eS2PPbjIY5dlf8ww/z1vDygHvUqB7H1zN/43/+cNNj5oed/D/KTZX5eaNy//7r+n/G3/Xwo/MdRPhv/m9zqe3rbXzVWqVKFffv28d577zFz5kwuX77sFnJRqVIlJk2axD/+8Q/8/f+aSF0ner2eFi1acPr0abfHz5w5Q1yc/EfSrFkzdDod69evZ+jQoQCcPn2apKQk2rTxPIdF4V9Hao73tMj8Eiu2W6lKNQRIX9OZlZ631xt8449BvjrC/PVcz68YPqBVq6gSeutplwCVQ3yZN7kVV7OKCNOkS7N92ajrXm+Kq7JgjEv8maJwDJ/NVzsL2JmYy8TefQhvMBB2fArbP5F9AmOh09M48lLwoxhV3nURaSnHJCTCiXPGk0orwRbeSDshw3VTjrge2/4xDPhUHIrKLeW6lzwgAQ/1hkivy6j5EpThPKchQFyN3GRxb1rfL6JO5yMhIKufg7OrXec4s0pSBcf+Iq+/amdYUxp80WwC/DxZnL4fhkk6YUJn+bs5H06tqCisVGoJ79gzTaLfD84TB+rMaok8z0+T/qYr++HsW9DjVdj4njhF7R6VsITfHoOLm1zHPDxP4tVHLYDZ/QGHuGlVS/99WlJGtG54DeoOgvaPwZk10qO1eIrrWJH1uRbdmzk7z/HZnU1YdzIVi81BgA7UJTf5Rqskl3A/DU9+cxBbqY1bYrWTnFPMB2vO8OGIRkQFGJncIYEXlx6/IazaVw9jUvuqHEjK4qvN52lXLZSWVUOpFOwebV81zI8JbeOYteOS2+NNqwTRv6GMtSgxhuJrDBShuu4lmSu24XVIPiA76/0paf8kK82NOHTZ3bXqUz+KUD+999f3N8TPoKVXvUiaVOlISk4xdoeDmCAfwv0NGErn1NWINDFnYkuyCixY7HYCfXREmozYbF6+yPm7YCu5+XDutJMyq01BQUFB4d/OH6rj8Pf355VXXuGVV14hKSmJlBT5xjQqKooqVar8qQvKz8/n3DnX/J6LFy9y6NAhQkJCqFKlCk8++SQjR46kY8eON3qufv31VzZt2gRAYGAgkyZN4vHHHyckJISAgAAeeugh2rRpoyQF/gfoUDOcb7de9LitfqUAfL0M43XDaILuL8GFjWAtJ9aiG0Oky8mMNBl5fVB97vv+QIXDPNajJmF/YIEYYTISYTJSlK/GXmcQ6uM/y4aYpiJY9nzn/oS8FFTfD+GeIWtYdDAVn4gaMH+gy3UBiQlf9hCMXYwj7QTsnyFCofUDMr8o+aDM/IluKENmcUBQFe+zrYKqSHR5WTIvSNJdYYYk1DkxRUlpoM0sYnHkXCmPtJaIe2MtEScoaRfs/kpS5OoNln3KCisnNgusfwVaTAZTjCQJ7p0GDlwllNGNJFbeGCjnyL4sovHAHDj0vSwUK7eScsaTy6Hz01Lq12w87J0uMeqVmsLYn6Vxf/5IeU5RNvR9D3Z+IUEiPsEinOreASufdAnh7CS4uBkmbwJzroi6RZMh7vmKr+fEErjzR0g+4l6K6hNMwYCveWVtKnklVr7beoEvxzTjq03n2XbFzJj4XgQkV/zcAThq9WXN+ZIbwqo8P+xOYkjTSpiMWtLzpDS0WVwwQ5vFcu/cfVhs8ryf9l8hzF/PwiltqBbu+vIqxE/PI91qMqRpLD/tu0KB2cqgJpWoFWm6MRT4qjWQkG4fELpistyPxVOkpLbTkziMQWAIQFuSRy+1Hzsuh7L8RAYGrZpRLSrzQJfqBPn+d4krAL1WQ2ywL7HB3vtmQ+zZhDiuS+qnIxQcUdi87v0HsdslrOOvQmOQEuaC656332yWmIKCgoLCv5Q/XSRfpUqVPy2oyrJv3z66dOly4+/OPqjx48cza9YsBg8ezNdff81bb73Fww8/TK1atfj5559p3779jed89NFHqNVqhg4dSklJCb169eLLLz0llSn8q6kZaaJmpD9nUt3n/6hU8GL/uoTcamJgSHW4d5M4C+fWSeR183tk8W1ylfWp1Sra1whnyQNt+WTdKSCNhpUCeaBrLZpUCcLXcPsfebvdwdm0fF777STPtHuS2rkpaC9vl9Q+b8OIzQVUztrLlI6tsGZc8vots2r9K2j7vA1J20XERDWAa4eh/hBxq9Qa6TXKvCyJfZ56pDQ6iGtbMXo9OF6O6RvqmmMVUAmGTIOCVJlvVJQtAi5xG4TVFGcq2939QOcrM6gOzvF+k67sg7aPiCui8YGYZhKXDlB/qPQ8bXzDJTAj6kClZjKsucer4pKlHoffHpfrSugo87d8giWa/eQyceWO/CgR5jpfcbl8gmB6T4hpIt/Ul+TLzK24dtDpGTmnk3PrxDHc8y2Otg/J6/RWOZV2AnuHJyi8ehxDo7soim6JNqEDH+8uZOPpdAC2n8vgbGo+E9rG06teFD6aGDj8XcUFr08w9kZjWL7U+yDzpIxC3hvWkIz8EgY3DOOu+j5UD9FxNC2DhrGB7L+UfWPf6/lmnvzpMDPGt3ATPMF+eoL99DSMDfJ4DqPBwMeJVbh/5BrCD3+FLvMMttSTqGJboN47DY79jAYI0xr4dOhMXujbFqvaQLjJgPFWvgT5u2IulFJdkIRNQ6kotdsh9SgsmiBfRID8u9LjVag14M+ftzBTRgrsnyU/Fw1HyBcyAZ7LkG8LU5TMo1vloW/OP0IRVwoKCgr/QW57pfnGG29QUFDAK6+84rX20Gw28/LLLxMQEMAzzzxzW8fv3LkzvxdgOHHiRCZOnOh1u9Fo5IsvvuCLL764rXMr/PVEBhiZdXdLPlt/ll8OXqXEaqd2lImX76hH/UqBv38AJ1qdLMgHfwMluYBaops99PT5G7Q0rhLMB8MbsXXDWr4c05TwwNsrByzL5axChn21g7wSKyOSsnm79zt06m4jQK9GlXPF85Maj8GnUm2eVm1GlZYpAuH6Gdj4pnvv2LVDqAyBUvZ4Za/MnopuJAuyE4tlAVhvMLR5AIwtoM2DsOtLVzmdMRD6fgA7vwSVBmr2kKG/+alQpZ3MsBr5PSwcCzhkmG9JrpTulb326t3k/vb7EI7/DMcXi4NVvbuUyJ1bJ0LHG2qtHD/tBBxZKP1lpmi5lvpD5Pxlf67TTsL3Q2DEbPh+qPuxDAEuh7IoS0Rj0/Gw7UNxwja+Cc0nQkkejqOLUI2YDZd2inPnEyyhGhnnxNHU+bjmeBkD4MJGrP0/RlOSc9P33OEfybrrgSQ7uhJdsx9nUvI4vyGbLrUjiA/1JTFDHLlKwT50qxNJQrgfKpU/TFoLm96RewhQZxB0eZaj+UFUCy9k8xnPTkPNSH/C/A1U0uRQz/8nfH+dC5Yi2vlHUrfNMyyr2ZiX1rr6ow5cyiazwHxbblKEyUB8dDg95p1hSIMHaNnYSNfAZPwWjJZIbyfWEjQ/jiV66h4IqeH9gFYzFJa+Ht9Q0N7GaIV/F5kXYdNbcPwX+ZmpPUCCWkKrQc5lmNXPPe6/JE++wPCr9OfOW5gpw8B3fuZ67MQSiKgHYxZB4J88vlojX1rkp8k5nCMlwmvLlw+BsX/u+AoKCgoKf5jbElfr1q3jxRdf5N13371pU5derycsLIwnn3ySVq1auTlRCv//iAny4aU76vFg1+pY7Q78DNrbm3FVFoPp5oNay2Ayymf0lhaglmKwFoHOD7Su/W02O78cuEpeiQiiPvWjUPuH8si6KzzfOYQaIQmub72dtJwMPiGoZvTGLRKgZi8Y8Aksnep6zD8Scq9Ax6fE6cm5LIu7nDLDuvfPhFO/weCvxZm580dZDOtK+250vvKN/J0L4dRyuH4WqnaU/qbC6zJMd+IaKMqQBfDC+2RRVpZz60UM2e3Sz3HHZyKYknZKSMXW92HQTdzf2v1EgFXrBqZKMtz54A8w6OvStD0PX5iY8+HiVnGZLm13Pd54NBz7xfX3xG1SvuYk+YCEcah1qDQ6+GWyy5kDOL0Cmk+ScsWoBnB5jzxeZwD89jj25lPQnlgm87I8odFjjmnJQ5+evdH75OT4tVy+uas54ECnURPsK27RDUISpNyx24vyd58g0ko0PLZoJy8PqMcPu5MqHBPg8Z41CXDk4lj+EKrz610b8lMJXvsYg7q+zbrqjdh6zuWAWmwVj3MzDDoNQ5vGUjXUnw/WnqZDFT1+q59wF1ZOHHY4vgQ6Pen5YNlJsOsrEdIOOzQYBm0egmB3KzC3yML1/BKyiyyYDFpC/fWE+P2bRFhWEszo6f5ZP7EELmyC+3fA2TWe56gBbH4boh/94+fOvuQurJykHYf9s6HTU6D5k4Uj/uGlc/7GiZjTGcE3TJwrBQUFBYX/GLdVBD5nzhyCg4N58MEHf3ffqVOnEhISwsyZM//wxSn872DUaagU7EtcqN8fF1b/CkrypAxv2UPipKx+DtLP3IhEzzfb2HpWysDqxQTQomoIH6w5w93t45l2sJCMVuXKcnQ+Imo2e4heP7NaBn5GN3I91my8fMPtEwKHFkhvUVlh5aQgXZL2QqrK7yeXybX/+rAM7m0xERaOk9j0puNEsO2fIQl3tfuL0Ng7Q9yq8sLKydFFUKs3HPsZfr5HyqVSjsp58q7J9l5vVnxeYKw4Syd/hcj64rJ9P0QWl3o/OYY3Uo9KZLmThM4SE392jffnAA6fYCyhNWHPt+7Cysm+6aXDVEvlbbMJ4hwGVcFamA0HZktYR3lUamyDvmF/ptGjCKoc7MvCvUnYHZAQ7u8urJzofcWZCKwEej/MVjsXrxfyxabzfDqqCe2rhxETKH1QgT463h7SgJqRJshNcRdWZQjc+Q4PtXD1WIX7Gwjwuf0kqiBfPV3rRDB3Yks61QjxmBZ4A2/9fTlXYGYfcVALM8Rd3PMdTO8hoquUlJxi/vHTYbp+sJkhX+6gx0dbmDR7H1eyvIwy+Cux28Wt8vRZL86W5MrLu70/3zmU+49y4Hvv2/bPkJ/nvwK9j5T/Vmoq5cOKsFJQUFD4j3NbX53t2LGD7t27e4wsL4/BYKB79+5s3779d/dVUPiPYCkWl+OXe12PXT0AB2bBXUshvh0GrYoIkyyEx7aO45N1Z3ltUH0e+/EwmQVm6gTVZEinlwnY8a6UrFXrBqe8pBoCHPpBZkRdO1w656meuGUOKzhsEpnuiabjxeE5slC+FY9sUNp38Q9xC5ZOhT7vyLyps2tdz9v1JbS6X2LRI+tJuaATn2CJWY9qKC7SsZ/lsfBa0HisPMdukxK9FveIgzblQZi8UcRJYYYk9wVWkejygV9CcS6sf9lVpmQuEBfL22IysLJcg9YIEbXlfJf3QHwHWdznXpXQkrIL/Zgm4B9JQYmVoJuJsMTt4la1e0R6wja9TcmdiykoseJblAWrnoX4F8RlunZA7mOtvtj9oogwBxIdaORambTLhrGB3NU6jqnzDmAyaqkTfWvz73RqNbHBPoyu50MjbSKd6h4G/wjM4Q05nutLgU2FiQIRmt4oyiJS70rA/OeAukSWfi7/CCH+Bij0k3t5Za/nnap3rfiYwyGR957KYfNTZZRA+yfIt9p5a8VJ1hx37zM7mJTNfd/vZ9bdLf+1X7KU5Irb642za+VLjqOLPG8P+pMx5jcrO7UUenZyFRQUFBT+J7gtcZWcnExCQsIt71+1alWWLl162xeloPBvoSBNREF5bBZYcj9MWo3RFM09Haqy6ngKgT46wvwNnEjOJbNAFrovr7vG4YbteP+eTWhyLskAT09DcZ0UZohoCa8lAqQ4RwRT9e4QXAXST1Z8Tq0+EFYD5o1wPXZln0SMj10srpfeXxZ0ZYWVk91fQWxzGZDb83V5rFo3aHUv7P4G9s2QYzS+U0oDRy2A66dh1TPSsxJeU1IM6wwS8bPjE+j6orgC5zeA9RwMmyElSSlHxBVwcmqZBHH8PKnidalUMux397eS1Lb1fag/TPq/inOkp8TgL2Wgv5UO+Nb5QKenUGVfxj+wSsUo9zI47BZUOekSN+4XBgM+RX/9OKG1Sgfp2koHNsd3lJlP59bCz5PQNBhJXKOxPN+3Dg4gPa+ESsE+XM0q4uH5Byk02zDbbn1xHBFgYPFdCQStmopu3bYbjxu1RmoOmI0jvp30qt2s3FWlItDfh7rRATzbtzaNY4NQqz3Pj7tlfEOgx2sws3fFbf6RUKVtxceLc1z9ZJ44vhiaTySj2IdfjyR73OXY1VzS80r+teJKo5N+RG9kX4LOz0rgSfkEUoCO/4ALFR++ZRqM8C7cava5+bUpKCgoKPxXc1viSq1WY7FUnGbvDYvFgvqvjJ9VUPgDXEgvQKPVls7AKrOgy7rkCjsoT/Yl6WMwRVM9wp9/9KyJRq2iZqQ/h69ku+267Nh13unkg2becOnxqT9M5j95onJruLBZRIIzWAKkbyqslvxe3r1qOg5+HF/xWNYS+PUhGDlPosc9DSB2cmKJuEHFOSImWkx0n81luSqi0G6DgBhY8Q/3e3F2rThTwR3ESfp+qPR41OgtAskvDK4dEsGi83X18eydDs0mSj/Ori9cYkjnIyWGhxeIY9NwlCxya/SAZQ+6emGC4mDYTLmmal0k3OPgD9DuYTSJW2R21sXNnl9z9e5ynCptS4c2z0B17RCqxG04xv8KSfvgMvDT3ZDlKgNTb3kH9dGFNLxjEb1nXsBk1JJVYMFcpsepXbVQ7/e6HCqbhdCj01AnbXPfYC0mdNldOB7YKe9PzV7iHHpKlqzeHR/fAL4aG0+gUYvpD5QEeiSqAYxeKO+3sxw1vgP0/xiCKlfcX62V99cbel9Qa8gvseIldR4QwVrHQ2ie3e4gNa/4xpcXoX56IkzG2xeSej8R9efWed7e9mH5bN21BH4c60p41OgkhS+uLVzYdXvnLEt0A/k5uXao4nV1fhoMfzxgR0FBQUHh781tiauYmBiOHTv2+zuWcuzYMSpV+pOpSAr/b8nIL+FaTjF7EjMJ8dXTtEowEQG3Fgtttto4ViqC7vhiGyU2EUbvDm1I3ZgA9FoNMojJO1abnYzcYiJMBka1rEJWgZkIkwGdxv0Lg0iTgcIrR9GD9Bd1fkackfL9LBqdpNz9dDfcvVJKEGOayEwrm0UGuzYZK2Ll9Ap5jjFQ3C6bGY9knBdB4xMiAsIbRdniRqx/BcYugeWPuacWOqnUVAIiPLH2Bbh7lYQ2dH9Jesh2fwU7PobRC0SYnVou86z2z5Ln2MzizJkiJHAj56oEhhgDRXid3yCR7JYiKX1MP+UeMpB9Cba8A91fkRLHH4bDuGUwZyAqlQoGfwtX91UMZag7CFXOVTj8Q0U37+xqVO0fE+cv5B7PPW5ZiVROWcuy8b15fMVVUnPF5YoKMPJm7xgamXIhp0SGFv9eSl5BGur9Mzxvs5lRXdohLmD6GRj4OSy+vzQRs5SwmtD2YQ5eLeD+JSeJCjTyUNcatE4IJeTPDvY1+EufXXQjOadaJ46WT5D3/VvfL31/nmh1P/gE419YgEat8jrXK9xU8Z4VWWzsvZjJE4sO35j1FW4y8P6whrRMCMXnduPgoxpKr53zs+ik3lApZ9XqZLbavVvk/luLJSbdLwJUf1K8mqJh9Hw4NE9mvpkLoGZvCbIIufXqDwUFBQWF/z5uS1x16NCB77//nsTEROLj42+6b2JiIhs2bGDcuHF/5voU/p+SllvMk4uOsPmsq1dHq1bx2Z1N6FwzHB/9zT+6V7KKmDBzL681cz12JjWfkd/uYuUjHUgI98cRFIdKo/csXAJiOHBdzSOzt/Ngl+q0Sghh9LRdfDqqCSUWOwv2uhbkxVY7xRpX2ACrnoUxP8GmN8XBstukLK/947DjMxEPV/dLOVyzcTDwK+m3unZYkv6GfAftHhWhkX4KDL9TQuRwQExjiG8vizlPVO0gYqgwE3KS5PzlUWtEcHlz8wozxVX5cRxo9OKWjfpB+r1WPSsx76dXymNJu+TaAQ7Ohe4vizDyDQGb1V08NLkLourBtWOw4vGK5z27RtwEHFCjF1za4XJ3Nr4hUfPHfpbHfUOg6QRZKGdfEjHn6X7lpcgCO7/iZieqYz9RvXou3/fuxLO7wqkSpOPBemZ81z+Iatk+cd8aj4X2j948+tpm8ZzI5yQ3WV5bSDxseldSGfPTIC9ZorWtxRTk57IjNZKsQgtZhRYe+OEA93ZI4KFu1W+kYv4pAqKBW5y/VKm5RJqf+tXtYUe17jji2qMGwvwN3NEomsUHK5YGNowN9CiukjIKuXvWXjdBlp5Xwt2z9rLykY7Uirq1lNAb+IVJ+Wrzu+H4Uvls1xskjpVfmOyjVrvCR8pyGxUaXgmIkTEGTcaKY2sMFOdKQUFBQeF/mtuq2Zs6dSoWi4Vhw4Zx/bqXyfBARkYGw4cPx2q1cv/9HhK5FBRugs1mZ+Hey27CCsBqdzD1hwOklLoIZcktsnAhPZ+tZ9M5dDmLaznFxARJVLlaBW0SQunbIIq4UF9m7kjEbLWRow4mp/Mb7geKbgzdX8E8Yj5+ASFkFZqZvTORjafSuZ5n5pmfj+Jv1PLqHfXQlJYqZRaYyfBNcEWjZydJEIN/lJS0jZgDNXrC8idcJWzGIMg8ByufhuIsyLoAVTvDyLnSiL/8cfk9vr0sfNVexGRQnPTrZCVK6Z3ev+I+pmgp/3IKKrtVXLTyOBwymPdmOLfbzHD0J+mF6vOuxNEXZYmr8cu9sqgc8KkMTq0zQIanNhkrAq2ssKrVT8rQclPFTfPU6O9wyP1s/7iUVJVN1Es+KL1o5kIRabXvkNe3/hXpa0s74fl1aA0i8m6GxgDmfAIWDePVrmE8UM+C3/d9UF3dJ9stRRJ1n35ahN3VAyLm7Db34+j8ZK6SN+LaQr0hsPUDaPeQvPdb34fTq2DVs9hyU1hyvRLxoe4L8++2XSAj34uj+a/EPwL6f4h9wgrsDUdhrz+ca4MWsabmS7y3PYuUnGL8DFqe6V2Hfg2iUZWp6GsRH8yXY5pW6Lcqttj4busFj06X3QHfbrlAicVWYdvv4hda+jP9EvR8TVxSp7D6d6DWSPBMQIwirBQUFBT+n3BbzlXTpk159NFH+fjjj6lbty733XcfXbp0ITZWvrW9evUq69ev59tvvyU9PZ3HH3+cpk2b/ksuXOF/l/R8M9O3X/S4ze6AtSdSuLeja7GallfM2ytO8ctBl0sRGWDgjTvqUHB+H1+Mbsr2i9mk5RYztGksdaIDKDRbuZrvYG1OU+4av4WgiyvRVGqII/MiqgOz0e/6ktoJXVk3/gGmHXOQVyLfZCdlFjL8651MaBvP/MmtOJeWT36JlRIfE7ahM9H8OFYW95f3SPT3vukVX4QpSmZqWUtkcG9+ChTnQ9upMH+0y0lLPSauzZBvxflx9mc5UWug2z9lUZ52EsYvh4mrYP1rEs6g1kCdO6DxGPfgjotbZTF/ZKH78Rx21zfsZUsMVSopTQuoJC6MkyptRDSoNZJ6aCkS0dLrTUkTtNsljCOhM+ybgaP1A6hq9pY5Qw679BgVZcE3HWHYNC+fBuS8Jblw9QAOjRb8IiRgvUob6atSqUW0bnhVFs+1+mO/aynq/V7GQNTsLfO7zm2ESo29n7feYIl6NxfgZ0lHv+lld+HU6Sl5jfNHud4z31Bx8Cq3cs1LM0VAzzdh/siK5wivJWElGj3FV49i3PK+vNfGQLDbsATX4NsjFr7bncqzfdxFgcMBJ6/lEh/2H1i0+0dwKEPLtKJ7UeFg929ZXM8XN3fnhUy+G9eMyEAjbw9twD961SKnyIy/QUeon95jfH2R2caJ5NwKjzs5cS2HArMVw+2WBiooKCgoKPybue0phh988AFGo5H33nuPN954gzfecP/m3+FwoNFoePbZZ3n99df/sgtV+P+D3eEgu9B7WU5ytivdy2Kz88OuJDdhBZCaW8Jzi4/xfEOYOv8ARVb5+vzXI9cI89ez4N7WhGkLGVbNhs/JJagcxTjsdlRqrbhA1hI0R+YTe3IJT45bw2l7OJ+ud8WBz9qRyKwdiYxuWZkwfwMjvtvHknEJ1L/zR0jaAcV50OsN6a/KOO+6MJ9gGSTsFEp93hWxUasfLJniuURxyf3wwG6ZYbVvhpT1RTaQdL+934mwAhnWG99OZmENmylCxz9KXJDcqyKSqnaWgb9ag8z5yUp0P5dDBQO/kNI/h136pxqOgGtHxO2yFEHfD2S2TtIOKWU8uw76fyjH3/yufEvfYLikB8a1hSsHsDUYgSr3GqrFUyC2Bag08PNkl4uVety916wsHf8B+2ZC3TsojGlLUeM6hDUdKxHiziG2tfpA6wdwOOyYo5pgCIwCU6S8vrLphdW7Sf/Wd13AZodKQOUWcGmr+znj24vjVxoBb9Sq5fU6CUmQGPllD7k/rzBDZnw9sOuGW2W3O8iNaI7P0DkY1j0vPV5qLdQdhL37y2SrQtCrNWQ1nExhbH9MlgwcdgMXi/14Y2EaJ1MKuKt1HGtOpFS4NT76/4zYyMgv4YUlxzlxraIgOnQ5m8SMQsJNRkxGXWnZ4s0FoFGvJiHMz+PxAKqF+f/HXquCgoKCgsLtcNviSqVS8eabbzJp0iRmzpzJjh07SEmR//SjoqJo164dEyZMoFq1m5TBKCjcBKNOQ8PYQI5c8RzQ0KGG6xv89LwSZmzz7HLlFItAizAZuZTlKiW8nm/mbGISvTLnod71uesJe7+TErWBX8gQXQBLEYYNL2Np+QG96kWx+rj7Ave3I8nMursln204x6e7c/mixml0FzaJaPrtcSmP0xhkBpAxUOK2174kvVWVW0HyARFDOOQxT9htsl9eurguJTlShvfjOJmZYwiQYcRx7eUc2Ymw+2txZ4yB0GgUTFwjvV5aPSwcKz1Tfd6R3p7Lu8E/CkfDEahOLJE5XFO2QPJhKMqQsruy5Xp1B0kq3NYPXI8dmCW9YzV6SIDE9k/AYMIxeSOcWIxmxWNw54/Se3RhU8XXuPk9HA/sQhVeE/bPFkcroo7MqLq8B5IPYO/9NkWaCEJ8C3CYQVWjtwi4dS9LL9uJZagmrsKgQu6PRi8uUt41HDlXJADj2mGKU06hb/8YbC69/gYjoOFwEXYqlcwfC6kmZZxOdH7ujl6j0TI41xM2s/SAdXoKh8PBiWu5jP52P1VCQ3is7Q9U8rXi5+uDITCSzzcls+vCBaIDjTzTpw4/nVUza0cBdkcBkAlAtXB/utSO4J7Z7vOoDFo11cI9lIH+Gygw27wKIYBtZ9NpER9yy8fz0WmZ0rkavx31PNR4SqcEfHS3/d+VgoKCgoLCv50//L9VtWrVFGdK4V9CiJ+eF/rVYcQ3FaOQq4T4UjfGNby1xGonr+TmvTOhfno3cRVg1NLINwP1is8r7py4VcrYYpqKoAG0iRswNiugS+1w2lYL5ftdl8gsMNMsPpiHO8cT5shk930J5Fh1nHL0pVr4RXyzkyRiPOWYlK5FNYDfHhPB46R6dzg0Hzo+iVtjiifUOhn0m5XmXmroHwGDvoKdX8LOz0UE+YWLqIttLqJj9zfiboXVlLTC6EYicBZNEKHU7hG4tBO7MQhN5dYSipGfCo1GwqypFa/lxBJJFYxuJM4VyHl/e0Rivc+ulf6zUfNgy/uoEkuT5VKPQ+WWIpbKYavVl61XbDRJuINAZyR9zmXY8j5knMPedAIOvzDCzq+H/TMkiTGqkcRtj/0F5g6U3q6LW2DTW+JY6f2wN5+Eufl95IdFcSk5hRzfKObsLWRSs5q0HFoPzlllsHNCR+jyHJxaIe5b3/cg7bhcXFgN6dNpMVlcQJA+uCzPoh6Q+2K3kZJnZtLsveSVWDmenMs9i3OJC/XlmT4xPDJjz41497Np+Ww5u5XZd7egf8MY5u1OIqfYwqDGlagTbWLCzD1u0eYqFXwwohERHoIh/h1o1CoMWjUlVs9zxv7IDKuqYX58Mqoxz/5ylEKzlF/66jW8ObgBVf8TpY8KCgoKCgp/AOWrQIW/JfViApk7qSUvLT1OkK+O7nUiiQv1pVlcMFGBPjf2M+rUhPsbSM+vGHLhJCXXfUjo4EaRRJ36wvvJjyyUPqVScYVah59BS7jGwN7ETMa3iaNngoEQbQnq/Z+i3jcdzPlEBsdzvc0LHKgygZYhKvRDp8ORH6Wsr9V90O8DSDslQ1jPrJYyvy7PgdYIhiDpv0k/XfF61FoRRqZoaYrfP9M1L6rn67D8H+4L/YJ0WP0c9P8IIutL75beH1DJbK96Q6DbS7JvdhIsGo+909M4VGo4+Su0fRCsZumb8sbBueJwOcUVSA9ZcTbcvx0KMgAVqiNlZm9t+wiGTYftn7pK9VQqLDX6c6ze00yZf44eNQN4vlV1Iva+hyZ5H/hHYR74HY7Ylhh2fOQeq31hI1zcJCWQfT4AawEsnuLabi5AveNT1MlHOVT/DVKtJp5fIqMkdl7MZunYBOCM9G5dOyTCSaWCfh9JfLZKLU5hn3dExLa4R2aUXd0L2ZflPfGUuggQ2xLUGtJyS27EuDsZ3yaeD9accZub5eTuWXvZ9GRn3hnWEIfDgVajxuFw8MM9rVl9PIUd5zOoGubLyBZViA32ub0epMIMieQHKU/1vXVnqTxh/npGNItl7u6kCtvUKuhQI/y2j+lv0NKnfhTN4oJJLf2ZjQwwEmEylI5OUFBQUFBQ+PujTPhV+FviZ9DSoUY4sye2pF/DGH4+cJW3V51izs5LJGcVyk5F2USRxczRNT1GO0cHGAHIKHD1Mek1asa2rIS6xMOgViclua7kP4A6dxBs8uWzDefIy82hT2gKEY5MtMsfRb3jE3GUALISCVtxD3WLD3K+0BfHoflSRjbwCwlc+Lod/PYIjqA4eGCnlK4te1jK7ra+D/0/8TwzqfvL4gwtf1wWx3d8LiLLP0KEl0+Q/Lk82z+VckGAugNxhFQTQXf9NPx4FywcA1f2wJ2LsMd3guvnxMGZMwhwSBS4NwqugzHAw+PpsOQBEX9ZFyre158mQlwbGL0Ax92ruDByM18FPsao+YmUWO38diKbgT/lcKLNh6SN2cCWNjN4N7keOmtexXlFIPdl3ctQpSVs/dDjpeoTN1LLr4BTKbl8OqoxDSoFYrHZeXJ1qlxWbDvMYXWw9Xobpu4VR7HHq/DQfhj8DQRVkQMFRMOoHzCPW0G+Q4+9/RMez4fOV2LqgXwPrmpMkA/n0jxnwNsdcPRKLhq1Cm3pPDWVSkXlEF/u6ZDAN2Ob8UK/utSMNOH7O+MIbmCzQvIhGfz8WVP5NW+EzGQrn2x4ixi0Gu7vUp3a5eLRVSr4eGRjIgL+mKOm12qIDfalWVwIzeJCiA32VYSVgoKCgsJ/FYpzpfC3JSW3mAfnHeDwlRw0ahWPtY+kf9USArKO4sjIR7XlfVQZZ6kXVpNNw5/muzNBfLxNFsxNqgTx7uB6nNiz2e2YAxpF8+uJTMbH9SO0/HBZJ1U7ulyrgEoSHGG3U2i28ljNbELVRsjJEufEAyHbX8X/rt9QXd4lJXsLx8gitnoPqDsQlc4XTq+WwIPibHnS4XnS/zR5I+ydIaInMBbaPCjBCd8PBhyQflIi2kd8L4ENaSekjDGkmvRBrXtF5juBuFn+kVB/KA69P5bY1uh/GCyizsnOL+D4EjRDvkPlFwLzhkDLe6VUrnIrmVvlidgWUuZXFpVKgi5SjsCBOdD6vorPK8mTsju1hoLJu+j6VcU+s2f61OHlNUnsvyQCuFFsII7oS56vA6QE0FIopYxeMFw/xrZzCWQUmJnQNo4mlYM5kZyF7dIBzvo2IaFjJwJ9yqbYeRl+bookw2biuc06emiM9O3xEUFbXnIFcwTFYRs6A01gZTlKkA8qleeEeW+ob1IhqtP+ge/DshJhRi+Z/eXkyl557L5tf3iobUyQD3MmtpSSxjPpRAQY6Fo7ksgAw60LPwUFBQUFhf8xlP8BFf62HL6czeHSUIvpQ6vQ+sJnGPdlSgLdupfFrQmIQXX9DH7z7uChOz5n8BMDsDg0hPgZMOlVnABeHlCPr7deZFizynSvHcngr7bTdWQLQoPiXELEid4Pmk+CbR9LqlxoNWxHfya50XM81jqQsIvzpBxMfZNv0/NT0VkLZK7Tzi8k0GL4t9IPtOYFcbPi20OX56HuYDixWJ53fh0svChzsZqMgRPLpI+q87OSWtf2YemnajlZhNTsAVLq5cQUBQO/hKUPyJBcQwCEVofOz6I6vQptTrK7sHKSexXVhY0S2uBwSBLh6udg8NcizsqLFrVWrsEZ+uGk+SQRYw6HDJht+6Dcq+tnKpzSXm8IydaKzlfNSH8yC8w3hBVIaInD8DvBDRqDlPE5PPcA6QMieXVgPbacuc6ui5mYjDoaVgrk4CWoXykQne7WB/GGmgz0bxjDE4sOs6Z6bR7pv4JQVR4OtQ5dQBjh0XFoSl2nUH89o1tUYd4eV/lcUmYhtaNMnErJq/gy1Cq3nsI/jbUEdn3lLqycmAtg/xzo+gJo/th/BREBRiICjLSr/m+cHaWgoKCgoPA3RikLVPhbYrba+XGfzM3pUD2EJlmrMB5fAE3HSR/TsBnQ9UUp4er+Egydjmb3V8Tp8qgeYSKkzCydYc1imXdPa5IyCjmXno/V5uDepSmc67uAokZ3SwmgWoOjZh8Y+b0Mb/ULg2M/wU8TyWg4mb3JFjrFGaU0LHFbxX4VnS80myDpdCPmSMlcbEvpLer1prg1u7+WFDyHXYTWrH7QbJz7UNPM85BzRaLCt38kCXY2M/R4TRyGTW9BYRYsvs9dWIEIqrUvitsF0HS89Dmln4SCNNTHf/J+w0/9Br5B4j4ZAqDPe3Lekd/LAGTn8ODoRjD2ZzAGS2CGX5g85iyf2zdD9rNbpXSwzzsQWc/tVNbqvchq+092JhVTK9K9rKxb7UiWH3FPjEvOKaYwqLak/3miUlMpp6zdz/N2vT+W0FrcNX0P3229wKJ9V7h37n6mzD3g/X7cBL1GQ496kfx8fxvsai1Tf0vjhT1arvtVwxQWi07j+mfVZNTxWI+aPNO7FsG+IuBWHr3GKwPrYfDgQr3Qrw7hfyAMwisluXBpm/ftiZvBXFHkKSgoKCgoKPwxFOdK4W+JSiX9UQBTmvgSuL40gEJjgJ6vSUhEfprrCaYoGPgFjqJsVEGVKxzvQnoBi/ZfwajT0LlWOOtOptF39iUG1B/N8H6TMGpVxAT7EnJ8Ntp934GlEFt8F9JGfMw/1uWj01kYHB+Er7kAVEgggN5f+q2C4iQ8Yv8s+HkS2K2oqnaS0IjaA2Thf+1QxRdpt0qceZNxsK20X0ilBnu5GV86X5ltdXmPpP2F1/aeVJd6TERY9e4Q20x6nNo/LqWFnq7BidYIvhGS8Je4A44ulJlWtftBlxeg5RQpvcs8D8YgCXKIaiizqeI7wKKJkCZhERgCoOMTYKoEBanQdAK2qEZk5xeSrw0mqcSX42eszNh2kfeHN+LZX45yNbtILkOj8hj08NLGLN4b8AXapfe619gZg2DAp1Ji2etNSD/lHmmvNVIycgEP/Fqxf+xCRj5UgxKL7bacK4AAo45mcSF8cWcTisw2fPSa0nlOFQk3GZjcsRoDm1TCYrOj12oI9dWx6tEOzNudxJ6LmcQE+TC5YwLVwv3wNfyF/yxrjOI+pp/yvN0UIz9TCgoKCgoKCn8JirhS+Fui06gZ2zqOlcdSCDCooFBm/uAfIQKmrLACcW1WP49j+BzKt6zkFVuYVjoLa/HBq3w5pim7LmSSX2Ll58PX+bk08K5j9XAe6foAYTXGkllQwv5rVr5ZlE56vplp45sz5/BVHizJR1N/mMxxuuMzEXl93naV4jm5uBlm94PJm2H3V95faOI2ifh2UrOX+xyo0t4dQmtCUDw4AGvRzW+ebyh0/acIoYFfiku2+2to97D82RP1h0JEbQm6KNtLdXgBnPwNRs6FxfdCu0clRfDqARGPlgJ5DU5h1XwSVOsKRxfB8aUQ3QhHy8msuQQPL81ArSpmwb2tiVcXk5ZXwrO/HOXxnjVRq1RcySqkYWwgPjoNx5PdZygtPpZB08r1GX3vdtSH5qLOuog9rj322v3RhsQDYPaPJanPfHzzLuKXuh9jRFUygxuzNVXP3ksnvd6urEIL/r7Gm99TL7iG5N4cjVpFdJmUS4CqYf481bsWBSU2jDo1xn/FHCejCVo/IJ9HT7S8V0pMFRQUFBQUFP4SFHGl8LelVqSJPvWjuJpnp2FwvDTm20qk/8gT6adkO5CaW8yZa9kALD+SwpSOCRi0KuIDoK5vDnseqM7uazbe25yKxWZnaLNYetSJ5NjVbHLtZmr4FNA/8Cq9B0dxrjiazEIzDavHkuX7KGFZhyG8Duz5Fu76Ba4edBdWTixFcHq5iB1v6P2k/A6kP6nj07DrS3GfMi9IX1ZRliS7VessYic0wXt/kUYPKo2UOm5+DwZ8AjN7idujUovwOb/B/TmVW0mKYMqRiiEVIO7cwR9gwgoZtHxonjy+4VUY8q0kBEbUhUrN5LoXjnE9N/kAqsPzaDHsF9pVC+OR7jWoHxNITJAPTaoEcTApmyd+PEyAj5YwPwO/HLjKzAktmLcniStZLhHZJiEUP1MADb48Sttqg4nw03D6cAmXN55n4ZRwEsL9ycgvYcCs8/joNcSFdMR8ys7d7f1IzCrwfv8Bm/020ib+YnQaDUG+/8I0vKIcKEgTEbXnW9fjKpX08GVdEkdSpwgsBQUFBQWFvwJFXCn8bQkzGXhtYH2SMgvIa/88pl8nSx/PTbBZSriWVci4GXu5kpnHuy3h9RUnqBTsx7IxlTBufg3tjOVgt9Eprj0tBr3B2vQgpu+8zNwdiWycXA3tT/ehTjly45ix4bUoGj6frw7k0rShHkdwVQiqgsoYJMLn3DrvF7R/lvQtOYfPlqfxGEnQu3ulLHAPzQOHTRa+sS3ENYqqD/kpcGUfnF0jvU2NRkuiX3la3Sflhpf3wNDv4Ow6VxndiieldK7BMBmW67DLcYpzJdzgjJdkQIBzayWV0CmsAJIPSjjH0Z+g/hCo1g1m9Kz4XGsJYWsf4Zu7fsMQFAzI/KKvxjRj3clU5u68RInVRr+G0YxsUZnYYF8W3tuGhXuT+OXgVQCe6l2L0d/tothiZ/0p98/As78c5Zu7muEAiiw2iiw2Mkvj91/97QRvDGrg/XUBvoY/KG5yrogYTTsh4jKyniQ8/p2wmWHHp1C1E4xZJNerUsv1nlgKl2ZLbLwirhQUFBQUFP4SFHGl8Kew2R1Y7XYM/6JZNGEmA2EmA5aQbtj6fohGo5ekvvLzeVTq0r6hUN5dfZrz6fmUXTN/2T8C/x/6uZUTqi9tw39uL1qOWsszqfk82yUS3bL7UZURVgCkn8bnwHQebTQa9dK7xUUCcYkGfHpzZ8rgL9fW9QXY8Lr7tog60HCURLpf3gPrXnJtO/azxJqPXihOXf2hIo4A9k2HAZ9JL83+mSLwfEOh3SPgEwIze0s5YduHJVY+pon87rCL81ScI4ttlRrCasncK5Va0gK9ofO94Qq6UZQj7ltALKCC1lNlwHD5sI2McxjMOUD0jYeiAo2MbR1Hn/pR2B0Q7Ku7MdupUrAPD3erwdjWcajUcOxKLsUWz0mAuy9mklVoIcRPR5uEEHZeyLyxLbfISnahhaZVgjiQlO32PGfkebCvl6CMm5F+Gmb3dy9P9Y+A8b/JMOi/C8YAiO8kQ5H3zYCQqiK2sy7K752eBr3p94+joKCgoKCgcEsoaYEKf4icIjNHr+bw/OKj3Df3AAv2JnHVOdz3X8ClIgMPnKxHkq4q9qZ3uzZENYQh38Hw2diHTMNms9Ep3v1b+IaVAolJ3VSxTwvAWkzowS8Y3iiUTpVUqJJ2eL6AxqNRzxvuElYgrsCqp6HxaO8X3uJeyL0qLsedC6H1/TI3647PJWjCWgTRjWH9yxWfm5UovV0qtZT5OWcpORyw7EFIOQy935aEwuFzIOeqPA6Qcxk2vyUuWL3BcGm7CLim4yVi/uSvUkZpzpc+q5VPQaNR3l9Hg2HiopVF5ysCMKwmrHkOpneToIuBX0D1bhUOUWy1kZRRQJHFfbBuqL+BcJPhhrByotWoiQgwEu5v9DiMtywWm51AHz0v9KuLTuPedffmipM83qMmD3WtTqCPDpUKWlUNZt49rW96TK/kpUrpY/nPU34aLBwLeR4+Z/8ptAb5zOl8RFxnnJdyU4cDjIHyWdQoQ3oVFBQUFBT+KhTnSuG2ySu2sGDPZd5a6Uog23g6jcgAAz9OaUNc6E0ckD9AfomF91efZvXJDNacyuDbIXfTql0EAal7ZZbU8sehMAM1YFRruaPto9j73cHzqyTK/b5WIQQc9zIwGDBe3kKrllPQWr305kTUl96UvGsVtxXnSLhD+8ddiX9Oag+AsBpweL64OYd+gMqtJUBg05uQmwxNJ4jT4W3K7LFFsji+uk/6osqmBJ5bL79ABM2JJe7PveNzCdoom553ebeUG/b7QFL9DCbo8aostP3CJY3QGafuJKoBVGkjM7fKMuhLWDoVLu9yPZa4FZJ2wojZUoLm7EULSWBTkoWHft3M+Dbx3NcpgTDTrYdI1In2PvspKsBIgFH+KasR6c+yB9vz7qpTbDt3nUAfHePaxFMj0kTrhFDGtIrD7nDgp9fgq1ORdPiWL8FFQbr7PS3L9TNQmA6miD9w4H8RwfEwaS0sf0Lef5CEx77vQWCV/+ilKSgoKCgo/K+hiCuF2yY1t8RNWJV9/N1Vp3l3WEP8/sI46bwiK+tPySBbhwMm/3yJLjU78mWfgfhM7yiDUp3YrWi3vU+vvtWYHVEJyKapX2bFuVRl8Qkh2wxmXaDnoIjuL8K1m6zCN74hi9fKLSFpl5TPxbWD7CRAJaIFwGYR8VGW3CvSq1OrjwzrvVpu9pLNIiV2AZWg7UMiJMsTFAcanfuw37i2kHzAswi4stcVrb7hdXHEGgyVfqra/XE0HAmHfkBVki99VjFNZBCtMQgCYqTvrUob+XtZYeXEboXtn4pLtvkdUGtJ6/I+763JwWJzMG3bRfwMGqZ2qY7+FstJw/31DG8Wy6L9Vypse2VgPSIDRKjptRrqRAfw6egm5BdbUatUhPnrbwz1jQp0CTqLxVLhWLeEp4G8ZbH8TprjvxuNVgTy6AXyZQDIKAGfoP/oZSkoKCgoKPwvopQFKtw2m894L3tadTyFrELzX3o+lQqM5RbhWUV2ik+udhdWZTDteo97mvgD4L/hOag7UDZUaip9Jp2fEYEAZDS+nxXnS3D4hmFvWK40LiRB+orCanq/QGOQOEo/3iXld8mHYPEUWP0cnPpVhJPKw49aeC25Do1ejlG9h4QOxLd37RPTVErtdn9T6jh96Bo6rFJJiMToBbDmn+7HrtZNSv+8cegHCcY49av0fC19EAKiYNNbWI0hJLd4Dnu17jLIeP5IaDQKx9AZOBqPwd7/Y+xd/wlnVnk//uXdUKkp9kZ3Yp20AbVfGG91D6ZpZXGgpm29SHqe5/fOE4G+ep7uXYvXBtYnJtCIWgUNKgUyf3Ir2lYLRaVyLwU0GXVEB/kQGWi8Iaz+MnxDQe3lywO19uY9eP9JfEOk5yqkqiKsFBQUFBQU/kUozpXCbVNs9hwsABJw4a3CDSTN7XpeCYkZBTgcUDXMjzCTAR+ddwcjxE/PqJaV+W6rqyQuMsCAf5b32UVkX6JqiJ6LWUiplrlA3KULm+DkMnGnavXB0fUFfEzx3BusI9uq5WCNh6mLAZ9j34trVG8I7P0Ger8ji9PCzIrnan43HPlR9r+y131b4lZxpvp/BCv+IfuAOEB934cfhksghROtAQZ9BeZC6anq/DQcXyKhFgfmQPWuEomelSiizFwgv+vcZyj9Pg449ou7S7f9ExxDppFcbMDuG4C6wWBI6IDDUoRq/ihUmRcAmaFMQhccVTtWmCnmeh1GbIFxaDR61DN7EmYtJsw3hG97fMarx0JYdjyLArPN27M9EmYyMrZ1FXrVi8Rmd2DQaQjx+wNhFH8WvwiJNt/1ZcVtre6TYAsFBQUFBQWF/5co4krhtulYM4z31pz2uK15fDAmo+ePVV6Rhd+OXOOlZccx22RRr9eo+WR0Y5pWDkKnVRPsq6/gQui1Gu5uV5X1J9O4cF36oi5nFpEb15RQ5nu+yPDaJESFcPH8BdD6SGjEL/e4z3FKPY7q2C8YR83ner4f+85eoW0lLUl1pxDR+lGM1hy0Bl90x3+B3x6FO3+Cn+6G7EvyfJVaAgFiW8D2jz1fhzFQznn9jESyZ12SsrlqXeHne9yFFYgT99vjMHSaPDftlKQjtntYnLZ5IySdr82DUnLX5104sRj6fgA/T3SVfV3YCLX6SaqdJ2r1hT3flHuDUrAYgrlnQSIDGpqZ2qUaGoNJ+qpKhdUNLm5G1fYhz8cG7I1Go9n6nqQeOinMJOzXcTw1aj0bz+fdVFB7Q6VSERHwxwb+/mUY/KTHzhQtfXZFWSK82z0uoSD6v7bnUEFBQUFBQeG/B0VcKdw2lYJ96F0vilXH3Qfn6jVqXh5QjyAv0dbn0vN5drErbc9k0PLW0AacTyvg8w3ncDhgWLNY+tSPIjrI3YmJCfJh7qSW7L6YyerjKfgbtBhrdYcdgS5BUYbsts+xM7nUQuv5upTreRqQm3kBVdIuBse2xHHmY3Sr1oPen8LGE7kSPwRsBqpX7Yhq/yz4ZTL0eUf6VWxm8AvHUZwLeSmovNl1DYbD1g+k/+rcOhw9XkMVUk36nVKPeX5OcTZo9fDjOFeIxsHvJV79js/kcZ0vxLaUBb7WCDu/lNTArEQc6SdRBcVBtS4SclFeGFVqJq8h47z742oNZ7PsnE3LZ8PpNMa3iyewMAPVxS0Vr9Fhh6OLsPd+F/Wqp9y3hdWAhiNgzsCKz7PbCD02k89GPE1kwH/Adfqr8A+X2Pn6Q6UHS2sEU5QIYQUFBQUFBYX/tyjiSuG2CfEz8Nqg+nSpHc53Wy+SVWCmTbVQHu5Wg/hQz8NIC0usfLPFfTH/xuD6fLnxPCeu5d547NXfTvD9rkv8cE+rCgKrUrAvff30dKwRxoXrBWxPL6HLXb+hWzzRFdxgCCC7/T/54Wokn24/xLstwV61I5z4Cdo9Kg7S2dWuOVnGQFQhVdFO7+oKIjAX4LvtLapfWANdn0NVd6CU/WWeh0UTJCwiOB7qDUF1cC7U7CNx58cXu7/ougPFiSrOhdYPQFxbioJrozP6oS245r2kDiD7spT8lSXnMuz+Wtyy66fFvZo/Cmr0gk5PSnlgUJz0bK39p7hGPV+T+PjTK2XhX3cw1Oghg2/LYa55Bz+flj6oUD89eo365uEMh+eTX388usk74NhPaApSyarSC8JrE7n6PhGg5ancCp8mw+h4dRHqn/eL0Kt7h6TWaf7L/jnSaCCw0n/6KhQUFBQUFBT+RvyXrWYU/i6EmwyMbFGFbrUjsdodmIzamyYElljtJGW4Fuq1Ik2k5pW4CSsnF64XsOJYChPbxbuXCOanYcxOwnhlH2GmKKjUhBLfWpzr+yOR2nwyc/PJdJj4bG8+G86k3RgibM++DFf2iQsU0wTG/AQb35T+qEajYOcXHkWEKnm/PO4bCmN/FpESVBksRThM0ajsNhFNSXsgupG4GBc341BpsNQdisoYgPrCJjQj5uLY8RmqvdPwNZiwNZ8MjUdJAmDu1Yo3S6WWvp2SiveGs2thxBzp3Tq3HgZ/DSeWSuS6byj0eB1VcY7M/zKYQK2DknwRVHY7HFkoQRbBCSIQsxLlHoXX42KTp5n3vfz9ng4J+Og12A0BqPX+Mg/LA1l2IwuOqGkWP4X5ey5zal0e/Wrl8qRfJLryO0fUkcTDH4ajdibunVwGm96CccskbVF1U8mpoKCgoKCgoPC3RhFXCn+KMJPhlvbzM2hpXDnohphqVz2UtSdSve6/aN9lBjeJIcSv9Pi5ybBwHFwtExih80E7aiGncuOZm6Rm7q4s7A5XD9OIhiFAOtofhoC9dDGffAAOz4NhM2DFU1JaV36uU1lOrxBh0eYREWeBsXBkIaozq137VO8pDtHh+ZB7DVXziajNBZC4BVXVDjC7Pyqni1OYgWbL23BurVzDjF4Vz9l8Ipz2ksTnDKDwCYbYZvDjeJcI6/wsbHnHNfsKJL2uzztwcauUCGoNUnKYvB8GfYPt8h5SAxtwoiiUxxckUWyxM7lDVWpFmcgvtnA4XU/Lto+j2/RqhUsx1+jH2iQ7UUE+1IsJZF/iEXKKLCw4YuHuEQ8TfXal+xPaTJVhxeWjzK3FsGg8TN4gQR8KCgoKCgoKCv+lKFHsCv8W9Fo1E9vHo9OIM+EA1OVMCq1aRZ/6UTzTuzajW1ZB7XQxLMWw+V13YQVgKUIzfwQ9YkqICjAyY0ILBjdxlWmNb+glWMBSBJvehhaTcGh0oLtJAIHOF2xWGQzrcMCB2VBWWAGcWwOrnoHY5tDxH7DqGbQ/DEJbkoN605uey+OS90N+OgydLmmCKpWU9PV4TeZD7Zvu+XpCEqSE7uoB2POtS1jFt4e0k+7CCv6vvfsOj6pKHzj+nZ5JmfQeEnpvgVBCbyKIVBVBYAGxV9R17YK/3RXXtta1IyggYgEB6dIRkBYpQqihpEJ6zyRzf39ckzBkJhRDGu/nefLo3HPuvefOnMR5Pee8R02eseLvEDlBHREbMEPdz+qPnyA3BaXNKHICOnMsz5WH+zVlzRN9eGRAM3zcjJxJy2fC7L3s8B5G/qDXylOMG1zJ6/wAMe1f5K3NKfRt7k+QxYWfHu7JyI4hFBTZ+Pywjtzhn6lJOUq5+qlBsiPZier+WTXNVgKZ59REIOlxFadmCiGEEEJUQkauRLUJ93Fl3rRu/P3739l89DwTu0ew46Sa2rxFoAcvDGvFigOJLPjtDB4uejxc9PRq5kdASYo62uRIcQHGM5vpFdKX4V/u4umbWzA2qgFbjp0nIO8oh3CSNCHxd5Rhb5HvGgrtJuK66wPH9ZoMgP3fwZGfodWtzrMCntwA3R+E7CTIPa8eC+0E2993/oYcX6MGbO3uUKfo5aSogU9JETQf4ngfqcH/hC1vQNvbYcO/yo+3G2v/+mKKAqe3w8TF6qjVmufV50qPQx8WRfNAC80DLXanWEtszPlVTX0/eeEJFky7HffhfXGhEK3BhZVxCp/8cJYP7upEkMUFjUZDQz83Zo1ux7NDWoIGDOZIaBKtvh8areMg82KlaeprSm6qum5u47/VlPtavfrZDHhJ1lYJIYQQ4opIcCWqjVGvo1tjX75/oAcZeVYMOg2dwr2ITcrmhWGteGTBXrIKisvqP7nodwa0DODTYd7onWwWDKDJSqBhya/0bNKMN1bH8sXkKPaeSUNLJRtuAVa9B7+nG2nX5T6UuF/QnL9k36wej6lJJEwWKEhXR9AccfWBjhPAPVAd7ej+oLqmq7hQHRVzsl4JV1913de+r+2PB3dA6f8CtrCu6Hb+Tx3RCekEA15UM//FrlD339Joy6cJuljKgzpHclIgO6F8Y+HIiep6LI9gh9WLim2cTVPXodkUmL5oPz9ObIhP1gmMh3/mPrdA7rt/LBpPE3qDjvS8IlJzijifXYC3qxE/dxNGoxGMDdR1aoXZavsMrmqmxEsZzNhc/WpuKN1WAod+VEf5yo4Vq1M9U0/AuAVqhkAhhBBCiEpIcCWqXaDFhcA/9yr634TOnE3L4/OtJ+0Cq1Lrj6SQMzQQL6+I8v2lLtWwFx7rXmFKx3fZdiKdrccucFOrQGyBgXDuqONzAlpzNMtAWkER8bYCmg94UR1ZObxMDZZajVCzA6aeUKfUpZ8Cg4P9lVrcAp0mwc5P1LVbbgHQ5R4Y+aE62tV+rPM1Xa1GQngPdepZ0gHwbIDSczo06YfNZqO47Tg0rUegTf4DLhyBZdOh2SD1i76LF0qbUWgOfK9eK+UwhEZV3MS4VFgXdT3TsdXQqDd4N1JHy5wkkHAx6Oje2IftJ1Mx6rTMvS2EkJ/GqpsZ8+d84u3vwNDXyWxxB4//cIzNx8qn9bUM8uCTSZ2JMBeqmQm3vA2+jVH6/gPNupkV7pfZ43msWm/8HLf++stOhI2vOi4795uaeESCKyGEEEJchgRXokYFebqgKAq/HE5xWmfhYSsPDP6nur9ThQu0g7xU6PsMETpXfv5bBMH6LDzdzOTrPSvWB9AZsd7yNv5mM/nFeTQ7+hmaXZ9B73+o2ey2vAnf3FmeQXDXZyj3bUJz/Bdo3A9OblSP+zRWR6xiV6nZ+XQGdc3Tmheg5TA1g2BwRzizXQ1+Ltb7KchPU6c7DnwZPMNQbDZI/B3N/6LRWfPQtb0NxegBe+eUn7d7tvpjMMPdq+HUZnVUat/XMOQ1NTHEpXtueYVDw56w/l8ot89BE9xe3TOrkj2ZdFoNoyJD+XTzSYa28iH8j4/LAis7K/9BUUAPtp1ItTt8JCmbn3cd5QHzOrSl0xVP/IKm15Mw8n/qBsapx8GnCSld/8Hi8yE0TcxnoJel4j2qQ1GuOhXQmeRDENKx2pojhBBCiLpJgitRI7LyraTlFlFYXIKLQYdOq6HY5ngaX2puETTqizLmczS/vKJO1dMZ1f2R2o2FH+5BGf0xDVPWYdz4f2VBkckSDk3+RfaYBXjv/QBNdoKaij3qbgyKQqA1gQAfFzSL56k38m8KC+6omFihuBDN99Pg9i+gQTd1ClncFrjlLSjKhpxkdUPgsCiY8CD88oo6atXpb7D0UbjpFTXgObkJ3HyhUR84u0vd/PjQYji0GNt9W2DPl2j3XDTK5dkATZyDDXwBrPlozu2BMV9A3CY1G+CFYzB+Iax5Uf13jVbdg6vL3SirXyD/ptdINwQR6n3JXmTFheozKzYwuoOrNwBh3q4seiAasuIxf7/Q6WdpPL6S9qE92Xc2o+yYRgNDG+vRfvNv+8pb31ZHzaIfITmwF2tP5PHpukzOpCXx8cQazBSoN6lrrGwVR08BsDiePlkv5KZCbgqknQI3PzUjpmRtFEIIIa6JBFei2p1Ly+Olnw6y8eh5FAXu6tqAkR1DWLT7nMP6wzsEk1yoJyDliDri4+qjFhxdBYsmgXsQmsJsjGufsz8xRx0Ns3qEkDv4TdxPLFc3AN7+Pzj8E9hK0Iz9unyEyuDqPGNdyiEoyoOjK9WkEgY3OPSDmnWwVPweNSHF7bNhyUNw/qj6RfXcbjXIKSkErREyEtSRpJ8eVs/TaCnWGDDum3tJ+5PVDILxex02qSQrgeL0c5jO/aomz8g4A8fWQNQ09cuxq6/ahkWT0RTl4BLaCbeo6fYXyTynJunYN099H8J7wJBXIaA1Or2JNiGeFLtkVEyffhFdURYuBvtRsGCLC64X9lccRQN1iuWKp8i4fT0vrkkC1MyRLYMqH7UqLrGRmluEooCPmxGjvgpXaLn6q+vYDiyqWGb2Bt9mVXev2iQrUe2HJy7KMmkJUfeCC2xTc+0SQggh6igJrkS1Ss4qYNLs3zh1oTzF9fd74vl8chRbjl0gMdP+S/yEbuHoNBr+uzaW14r/gK1vVrxox7tg58dO72nJPolJFwQhnSE/A2xWdfQJ1KAprAvE7y5PDuFMSaEagBXlqudfHFiVKsxW1xd1ngxmL+jzDOybC9+MVc/xCIIRH8B3U9SRK6Cg9ViseZkYS9tU6vAyGPOpOrrlQEpgb4pc/IjY85k69bDU2Z1qO++cB6v+UZaFT7v3KzzbjwMaqvWyEmHebXD+SPm5Z36FzwfBvRsguD0AehcLhEeX3yOkE7Qdo45yJe0nJ2Iwf+y23/BYAXXkrBIXbxD96IBm+Lk7yewIJGTkM3/nGb7bfZYSm8LwDiFM69WIBj6uTs+5KiY3GDRTXWcXv6f8uNkbJv6obvhc31jz1A2cLw6sQE2X//UouHejZEkUQgghrpIEV6JanTqfaxdYARSV2Hj2h/3MGtOO06l5rDyYiKfZwNSejQj1MjPyg624uxhI6XcbAbErKl7UEqomnriUixcA+ph5aE+sVEdRjG5qwokhr6l7U+2ZC8PeVNdzaXWgd3E8SmPyUNdUHV4KJ9ZD65HOH/LMdnXDXI9gWHy/OqLUaiT4t0AxuqEpyFQDK4OZ/A5TSGh9L+GuDtKUF+Wo0wuHvKZONSwdYdObSO/zT+afdCUmKZO5U1ejW/0snNqklod3h57TYcO/7dObF2ajuTiATNpvH1iVshWjrHmJgjFfYvbwUacJDpkFs4fC8HfU0a7dsyE/HSWiJz4+3rQNymDbqfJ7JWYWUBzY3j6j4cWC2hObqadTuDePDWxKhzAv3F0MDt/OhIx87vpsB3Gp5VkG5/wax8/7E/nxoR5VF2B5hqrTKrPiIemgOoLj11ztX9p6uCVgTiVbHOSkqIGmBFdCCCHEVZHgSlSr/fEZDo8nZBYw5ctdbHumP7d3DkWv1WIy6DianM3gNkHkW0vI9W+AEtgOTfIB+5Nzz4NvU0i4ZPpc339AEnByffn0tKJc2Pauutlvs8HqNLq9X8HYr9VMe72fVNOoX6rvM7DjE+j/PGz8z+Uf1D1ATbTh1xyGvg4Hv4c/lqBxD8LW43Eyp+3AZDKxP9PM51vP8eYtDfAK7VQ+BTCovbo2S7FBXhpZUzaRe+EsoJBhDOJ/u3JY9kcKs8a0QxvYAMZ+BQUZkJ+uBmTLHiubFlmmcT91RKvUkZ+dNl8Tt5lT8cnEZGYzoGUgQQGt4YHNsOo5OL6uvN6R5RiPreF/E1YxeGEhyVlqyvy+zf1x8wlWN0Ve84L9xQ1mbMPfI9rSnN4dtXi5Oh+xAth87LxdYFXqfE4hC3ed5YlBzdDrqij4cQ9Qf0Iiq+Z6tVlxQeV7i2U6nqYrhBBCCOckuBLVKrySUQZXo7pux82kjmAkZOTz26lUEjLy8XAxkKx4Y771K7yP/4gpZg4UF5DfbBipYcMwe7bG98c7yy9mcAXXShJ7//YZDHtbDa6OrobE/TBuPpSUqF+sN/1H3VPKtxl0vU9Nx33wO0g9Cjf9Ux2Bcnbt0Ch1yp2Lp5rGfeF4NWkEQMphtCc3YOjxDPtCx/PKmqMEeZjI1Vkwjfwc85J7oOfj6n5ZsStAo6Wk0xT0Jjee2OHG7+cyybeewcWg5aF+TejTzE+dXmf2Un8UBf74qWJgZTCrgaMlqPyYWyWpxV08OZ9j5fnFB2kdfJrZU7oQVJhjF1iVKSnCsull1j7wJafzTLiZdPi6m/A0G9T9tBp0gW3vqSNC4T2gyzS0XhH46S7/5yen0MqSffFOy1ccSGRKjwj8PRykyReVM7ipe7gVZjku92tRve25HqwF6trFpP3qaHFoZ3U/utJ1m0IIIUQVk+BKVKu2oZ64m/TkFFbMyjaxewT+HiZATXox9pPtJFy0BuvnA4lM6h7BPT3vIy90BG4mHe/+eoGln5/gsR4BTBrwH7y2/p86OuUeqE7HI9xxQwoy1exwpcKi1GQUJUXQqJ+6T9Xp7WpmwjUvqvsgAST+TmpKPMWNBuDd9SGMv/3P/roGM/R5GnR6NaHEkhfLA6uLuG9/ndZ3j+GN2ztwPruQ2dvi6N8igM6jvsDl+wloUv4oq6s7sx1TWFfeGPoxR3IaYy2xodNqWLIvnm9+O8Pjg5pjKB258W6oTm3b8T/Yv0hdV9N0IPR+GjwveS/a3a6mnXcgp+M05uxXp2/+kZjNkcRsghJXO34vAc3prVg0+bQLC7AvMHupGRbHfKaOlJROr7xCOo22QrKMi7kYtOi0TsNcURmPIOj1JPwys2JZYFvwCqv2JlUpa766NcL3U9Xf61Jtb1On2roHOD9XCCGEuEYSXIlqFexpZt49XZk8exeZ+eqUpFAvM+8ND6ZjgAFdaiwKCu7FBno08mDJ/kK7FO1f7zhNvxb+hHgG8uamkyz9Xc3u99aWZA60aM+jI1fjTSYGoyveZEFaJoz+FHSoe0Lt/1ZNOqEzlidcCOsKvf+ufhmz5kJCDGhQv3z98oo61Q5AqyOny2NsKWmDMUUhwzyWQSN74f/7x2hyk1HCoyHqbor0Fgz7ZqMN66KmaHdEUbCkxqD4DObnA4k0C3Dn7bVH+KLVPswXBValdOd+wyVhF7O2BnHyQi4mvZb2YZ4UFJVwIbuQYC+zWlGjAd8m0O856PbAn+vMzOrmxnqT/UX1Zuj/gro262KhndBHTmDjxvK9uVYdSqJPoBtOJ9/pDJUnsDC6qj9XyWzUMaVHQzbGnndYPrlHQ3zcTA7LxGXoDOoG2LYidapsUa7af5repI7qugfWdAv/mqx4NZvopWv+Dv6g/s53u9/pJtpCCCHEtZLgSlQrnVZDu1AvVj7em9OpuRRYS+jllYbh9GZIz4PtH6LJPY+Xwcx/Ok7irrumMn7haQqLy78gbT1+gXAfV4I87aeCrYlNZ02sGgiNaOfCm309gUxYfB8oRdD8ZrhjLqz4O4T3wObqg+2eDWDNR7/6OTXLntlHDUqyEuDgj3DLG5S4+pOWayXTFMzXB3LRFevp7KGw5EgOUYOa4NrrOUwUYXMPZk+yjUeXHmfWzXdwk1eJ86mDgFaxse5wCiM7hjDly128MigI7yPfOK3vf2QeQ5vPxL2NO7c2tOF5ejVapQSXbB0YItQ9ikq5+dm/vlSJFXZ/oa4Lu2uRmoSjMFtNhlGYTeHBJfRo3J1tJ9T389SFHJTeg2HdS46v12aMOlJ3HbQN8eSWdkGsOJBkd7xLQ2/6t6ji0QebrX4mr3DGzU9NftJh/J9JVlzVYy5ONuCuSw4tcZ4B9Nd3oc0odfROCCGEqEISXIlqp9NqCPEyE+JlVhfNr3kD/JuraaFLWfPR7fqU9qkneGnAi7y4JrGsqKjYxuaj55kc3ZBPN5+scH2DTsO/+nmg+XootPqvelCxQexKOPsbjP0KRaPll/RAGoUEYjFb8e/1JJqiXDVDX8wCOL1NPe+He9AFd2BN83d4YfVp2oZamD7QDze9wge9iwlY1F+deven7v5tWHDnF4z8Oo4DjzXHENwBEn+v+CZotCiBrck5W8Lu02oAo9HgeF8oULMYNhnAw009MOWnoEs9CqdWqSNjO/8LbW6DoVcx1akgQ11vdv4I7F+oplc3uMKhHyEvDc/QzkSH9mHbn0kYx3cNR2exwKBXYN0M+2t5hqmJPq5hZOpK+HmY+L+RbZkc3ZD5O89gLbExrksDWgVbCLBUwVqr/Aw4H68mNslLVadLhna+cTbS1ZvAy8n02bos7ZTzsuyk8u0YhBBCiCokwZWoWReOQctb4OcnHRbrT/5C367Po9dqyqYHRjf25fklB/BzN/HskJb8Z/URu5jkif4RuO79BKUot+IF81JRTm/H1vZ2uhpL+O+WP3DRaXk28z112qDJAg17qanWz/6mBluhUfRq6s9ngSGk5hbx0aYTfHVbMG6fT7ALrAC05w/RaN/rTIh8mOQ8COv3PHw/pTyNeqleT2JDj82mkFOgrj/7+XgBI1rcgVfKK/Z1zd4w5jOUA4tw3fiqOurk3VDdUDl+L+z5Ut3QuPVwaDP6yt53raF8dMJWomZKvEiJizcZfy4V6xDmSXRjP3Bxgc5ToEk/2D0HcpLUFPMNe1/39Tl+7ib83E10aeiDgoKuKkeXdn0GWy7KAPnHEjXL48QfwatB1d1HVK+mAyBmnuOykE7q+kghhBCiiklwJWpW6nF1tOXPDXUdMWScwMfNl5TsQno29SU5u4Cs/GK+23OOER1CmD25C4cTsygsLqFlsIXGLnnoV2zAWZJpzYlf0Flz8fz1fZ7o+SJrXG4mzXsYPhE9wb8lHFutJqG47XNQbCgxC4jY+g/cGw0nzq099/VpRP7Znbg5Ct4AY+xPjLntCV7dfIH32qahv3M+HFkOCfvUdSwdxqFknOFQpoGujTxwMWj5anscO09lcK7PELx859nv2zX4nyhrX0JjdFNHjkwWNfvZmhfV/afO/ArnY+HX96BR3yvLhGb2gh6PwbcTHBZndLifuH0K/72zAz0a+xFYOgXT7AXmjuqaHKXkqpJTVAWtVgOVTra8BtveBZ/G0HqUug9aYoyaqfHX99TkJJL4oG5q0E3day47sWLZ4H9JxkAhhBDXxQ20uEDUSv4t1ax9lSws17j6EWRxYdbodoyNasB/VsaWlS39PYG75+4iKsKbRn5u5BWWqJn6zF7O7+nqo+6NZSvGc8tMenskYmxxE2Schu8mq9MCLSFqSvO5w9H8/g3ErsB31YN03jCJLt556vnO2ErQK1ZWHLrAmsJ2WM/tVaeeNe4HHkEoh5dR0mo0NrcA8qwlpOYWMW9aNyb3aMjk7+M5MHAe6X3+CUHt1GDJLRBNz+nQ7Gb47VNY/byaqv22z+HUFug8Vb1vfgbYKtm36FINukL7cRWPR03DvWFH3h7bkdGRYeWB1cW02moPrK6bm2dB94cgbrM6RdLVFyZ8ryY2STpQaeAvajHPMJi6ApoOKv/74t0Q7vpO/d0SQgghrgMZuRI1y7cJ7P0amgx0vIeSqw/eYc2ZPTUAXzcjx5JzaBbozqEEdW8eP3cjH03sTEpWAbO3xXHqfC69mvny366PofvpAcf3bDMaVjxd9tL/8FwUj/vVoArU9U3h0bDwrornpp3EZdf/KOgw1fkzeQSRXKD+aj229Cw/P3w3LTrmQkEWGMwUmnz46Ug2z/+4nZKLMiFO6RHBw/2bMvLrP5jYrT+Pjb4dLw9X9In74MAiNa10qWNr4OQGNUGH5s9U5U1vAhcv5+26lHsA3PwqRD8Ih5er2f5ajQBLCCZXH26YHHxxm+Hw4vLXF46pyUzu+FKdFpp7vn4keLgR+TSG22dDXpo6ndbFIkkshBBCXFcSXImaZQmB9ndAwx7qnlLny0elcPGEiT9i9ArF7881Ns2DPPh6WlfScq1YS2z4uBlYeTCJmUvL05evPJjM8KZN6Nd6TMX7RU1TpyKWplcHdJ5h2PbMLq/ToBuc3Oi0ya4HF5DX6X6KG/RAf/bXCuU5fWaw5ISNO6PCuKd3Y4I8XchSLLhZGqDTajgRn8kz3x+ocN6cX0/zyaTObH9uIC56LZ6uxj8baLAPrEqVWGHr2+rIi8kDuj9QMd365bj5qj/BHa/uvPokdmXFY4VZsOsLNVFHoePpn6KOcPGU4FgIIUS1qXXTAjdv3szw4cMJCQlBo9GwZMkSp3UfeOABNBoN77zzjt3xtLQ0JkyYgMViwcvLi2nTppGTk3N9Gy4cspbYiE/P42B8JkeSskjJKqhYyacx+LeGcQtg8lJ1g8/xC+GBbRDUoUJqbB83E00D3GkVbMFaovDayiMVLvnIT2dZ7HMPAPndn8TW9xm461swuMDG1+zqlvg0QVuYVX5AZ1A3vHWmuICzGUUcin6bkqh7yxfGezaA22djanUzL97ammeHtiKzwMrT3+1n6pxdvL/+GGdS8/jy1zinl/544wlMFwdWAKcrBnBlzu1WMwze8wt4RTivJ67e0VXqVNHcFLBW0h+EEEIIIf5U60aucnNz6dChA3fffTdjxjgYefjT4sWL2bFjByEhFdMlT5gwgcTERNauXYvVamXq1Kncd999LFiw4Ho2XVwiM9/KygOJ/Pvnw2QXqhnxGvm58f74SFoHW/5MTvCn0hEU36bqOiMHsgusXMgp4mxaHu4mPcGeLmQXFFNgrbiXjU2Bt7ec5+WO8FR8X/450Jegef3UaV4Xc/Ujv/HN6H1b4pKwT50ClrAX2t+ppuZ2oLjpzeDiic3oRmHPp3Dp+QhajU5dO2YJxgDo8618vuUk760/XnbentPp5BYWE5+R7/C6AMlZBRQVX/I8JovT+mj16vQ+n0bO64jL82wALYaqU0LP7VL3/dJo1X2vFo2Dh3aAX7OabqUQQggharlaF1wNHTqUoUOHVlonPj6eRx99lNWrVzNs2DC7ssOHD7Nq1Sp27dpFVFQUAO+//z633HILb775psNgTFwfMWfSefZH++lvpy7kMu7THax8vDcNfC6/L1K+tZjs/GJKbArv/XKMhbvPlqVd93Uz8vGkznQI8+T3c+VJB3zdjLx+cyDNTKnsiytkRocMMvIt6McuwW/lA+q0QK0Ohr6BzbcJrltfRWMrUUfM8tNhzQvqtLDw7nBmh32DDK4U9p+BW04u/id/wvXod6DRUtJ5Krpmg8qqpWQX2gVWpQ4mZBHZwIvtJ1IdPm/nCG/cTZf8WjYd5LAuAK1Hg5tks/tLbvonmFzg4A9q8N2oH/SaDkdXgzUXbMXqusBBM2+sDYaFEEIIcdVqXXB1OTabjUmTJvH000/Tpk2bCuXbt2/Hy8urLLACGDRoEFqtlp07dzJ6tON9gAoLCyksLCx7nZWlThOzWq1YrVeRgU0AkJ5bxH/XHMGkq7gprrXYysbDiYzr6nzj0qKSEs6m5vPL4WR83E2k5hby494zhHmaeLCrD538FTRKCQkpp3luSHMmf/kbABYXPfNvD6LR+vuxpsdDu/fwWXE/ga4e5N82nzMjfyA/M4UATzfMO/6LbuXz5Tc9uAQlojea4R/CupnYRn4ESQfQ7v0KijJRGg+goMtD5BZpabR2KqSeKE/3/vPTlAR3RHPbF+ARyNajSQ6ffd/pC9zXMxw/s44AiwvDmrth0Cr8ElfAwYRsHuzTCINWse9zZl8Y/Dqse9n+YpZQ6PscaI1Qm/toQQYoVJ7BsQZYi4rUf57ZDbE/lRckHAT3IBg3X91kWesCybFQkKtOKxX1Xunvn/ztF45I/xDOSN+o3670c9UoilLxG2AtodFoWLx4MaNGjSo7NmvWLDZs2MDq1avRaDQ0bNiQ6dOnM336dABeffVV5s6dS2xsrN21AgICeOWVV3jwwQcd3mvmzJm88sorFY4vWLAAV9fLj7AIIYQQQggh6qe8vDzuuusuMjMzsVicL9moUyNXe/bs4d1332Xv3r1oKtkX6Vo899xzPPnkk2Wvs7KyaNCgAYMHD670DRSOXcgp4u4vd3Ey1XEikb8Pbs6UHo7XCWXkFRGblM2Ti34ns8DK22M78uSiGH6aEEGT5bdV3HdIo6Hkb8tYnOBLb79sAr8ZDIBV68Ladu9x04HHMNjUhATZ438iUR9Gs61PoTm10XHjgzvwVfi/MXn4cmv7INwogJxklMwENCY3dargtneh7z/UTWcPLYHCbHUaYbPBENSOY+k2Rn/kOBHFgnENabP7eXRnd9oXeDdSk25YLjN11VaiTmuszbKT4cd71fVrF/NtCuO+AUtwzbTrIlarlbVr19r1DzsmDxj/LXw9Sk0YIuvarllCej73fr2b02l5ZcdMOi0fTexEZANvDPraNd2yrG/cdBMGQz3Zz01UGekfwhnpG/Vb6ay2y6lTwdWWLVtISUkhPLx8OllJSQlPPfUU77zzDnFxcQQFBZGSkmJ3XnFxMWlpaQQFOd/fxGQyYTJVTGNtMBjkF+QaBHsbeGRQcx5esK9CmUmvZXDbUKfva15xER9uiiMltxjQkJZXQv9WQQQlrsOQl+zwHMPmVxnf5xkUnR7NJV+UDbaCsi/PhVmpbDxvpE1ROjj6Qg1QmM5tnULQeQTgUXQeVj0LHwLPlwAAM5ZJREFUh5eqWfk0Gmg+FP72Pfz6ARz6sfy8hN9g/3y4ew0h3uHcHhXB/J1n7C7dLMCdtpzEdHpTxfumHoZD36vrfSoNnupAf4zfAeccBJfnD8LR5dD9wUo3jq5OF/cPOyU6MOhh3Nfg17D+bJpczbILrPxrVSxHz+cD5Z95YYnCvfNiWPNEH8K8a+euavL3X1RG+odwRvpG/XSln2nt+t+FlzFp0iT2799PTExM2U9ISAhPP/00q1evBiA6OpqMjAz27NlTdt769eux2Wx069atppp+Q+rRxJfpg5qhvygroI+bkTlTu+Bu1JOWW0hiRn7Zz8nzORyMz6So2Mb2k+UJHxbuOsOkLsF4JW93frPEGDj/B5rsRDXjmxNF7qGsO5lHeuMRTuvYWo3EyycQDyUXVvwd/viJsiwaigKnNkFeqn1gVSovFTa+hpfeypM3NefTSZ3pHOFNIz83bu8cxkd3tsb0+xznzxEzD/IuOC+vCwqzYc+Xzsv3fa2+T7Vdy+FqNkadCXTGy9cXDqXlFrHucIrDsryiEo4lZ1dzi4QQQojrp9aNXOXk5HD8eHmWtVOnThETE4OPjw/h4eH4+vra1TcYDAQFBdGiRQsAWrVqxZAhQ7j33nv5+OOPsVqtPPLII4wbN04yBVYzbzcT9/VpzJhOYcSn52NTFDLyisgpLGbv2XRKbAqzt8VxPCWHCB9XJnaP4MT5HAa3DrS7zqGELM7n2rB6NnY+ZmMJhdwLELcVoqbCjo8qVCnqOIWD2a4UWrOJD+qPt2cYZJ6zr+Tmh7X9BEw6vXq9Iz9XvFdoFBxb4/zB/1gMN83E1zOMwW2C6NrQh6xCKzabgruuuPI37YZRi5Z6Nu4Hx1fZH3Pzg+iHYMlDMNZxSn5xZYqKbVS2sjc1VxZ+CyGEqD9q3cjV7t27iYyMJDIyEoAnn3ySyMhIXn755cucWW7+/Pm0bNmSgQMHcsstt9CrVy8+/fTT69VkUQlXox5Ps4Ef9p5l0hc7SckuZPuJVM6l5/PAvL38diqNtNwi9p3N4PXVR7i5TRCZ+VbahXraXefpHw6Q0Wqc86lknafA/oVqOm2/ltDveXD58xq+TVGmrkTTuC/9Ez9nXsdDuOnh3JglWLs+CGZvcPEkv/1k4kYt5Y2deRRYSyqu7bpGXm5Gwn3caOjnjp+3F3S+23nljhPB1a9K7ltjTB7QearT4pKOk1DMvk7Lq92Al+GWNyGsCwS0gu4PwV3fqWvrut6r7iMmrpm7i54AD+fT/tqEyJpWIYQQ9UetG7nq168fV5PAMC4ursIxHx8f2TC4FrmQU8j3e+LxNBvwdTPi527ihSX2+191a+TDy7e25v55e7DZFP41uh3rD5zmrjYuuNlyKNabOZhuoOuIL3H7+X4o/jNtvkajfpEvyoPUE2qCCUswXDgCN/8b4oCRH6L59k4M2UkYAFfAR2/i/MhvON3x75wLGI9WA8uOFvLTnDO0CPKgoKgEF5OH4weK3w1d7oHfPnNc3nqkGrA5ExYF4dHqRrUX82mM0mEsCtra9389rlZETwjtDPF77I/7Neeob3927zzD0HbB+LnXgrU2vk3Bwxca9oLiP9dend4BEdHg0wQM5pptXx0XZHHhhWGteHxhTIWyfi38CbTUgj4ghBBCVJFaF1yJ+ud0ai4AkQ28+PVEKn2a+5OVr06PM+m1vHVHB7ILi/n5QCLn0vPRaMCzJJ1XPBaj++EzKFH3I2rUuD95g9+i6MFdGNOOqut2XH3UzV7XvqTerPNU2PUZHFur7k/U4VNY+yJkJ9k3qrgQ/+VT0E3eyKDv7acGtgv1xNWkB40fNOwNcVvszy3KhYIMlHZ3oDnwnX2Z2Rv6v6AGec54BMHtX6rX3fUZlFixtR9HQZOhvL0lm/iMvYzsGErHBp4EedbRL/aWYLhzPsrJDWh2fwE2G+ktxnLGrw9Tvj1Lep6Vkxdyeeqm5ri71PCiX61W/Uw8gqDEqn6+Aa1BL1/6q4JGo6FfC38+ndSZV1ccJi41Dw+Tnsk9IvhbdEN83OR9FkIIUX9IcCWuO0+z+uW5RFHQ67ToLkpw8cyQlszbeZroxr5sOpqCu0nPwOZetDyzAN3OD+2uoz25AdfFU4gf9jUNmt0EmfHwaT/IvWixfMOesMP+PM7uctywwixcc8/ibtKTU6gGe3qthqk9G2LUa0HvA6M/hh/usRtlUsK6khsSTX5wX3xaj0G34wN1CmHLYdBxAnip2SxzC4pJyMxn6e8JJGTkM7BVIJENvAj2MqvBR/ux0GwwBUVWFh3M4eW3DpbdY+XBJJoHujN3ale1fl1kCSal8Wh+SmmBYlP4+UAB+8/FlRXP/TWOKT0a1nxwdTGdodZtdlwfeJqNDG4TRMdwLwqKbOh1Gvw9TBh0dX6MVgghhLAjwZW47oI9zfi6Gdkdl87E7hGk5hQR5m0mM89KgMVEboGV25ppuCtEQ3F+Md4hFlx+t6pT/i6ZIqpN3o93yXmgIXiGwtQVsGw6nN6qVlCUCudUxpaXQaiXD7HJ2QRaTLx1R0ca+JRvGl3iEUreqLmQex5r9nl07r7gFoDN5I2fmxFNcAQ06qWOeLh4gk79lcorKmbFwUSe/n5/2bV+2BtPmLeZb+7tXn4PsxfH0zJ5edkfFdp2NDmHr3ec5ombmtfZL6Hns4t4dX2SwzKbAgkZ+UT4VjLKJ+qVAA/nmTyFEEKI+kCCK3HdBVlcmD2lCxM+38mB+EwUm8KLw1rz1fY4UrPy+GKgQsC3gyEvTT1Bo1FHgG55C35+ssL1XLJOA13UF37NYNw8dYpgSfGfqbONZVMJAXXqYE6Cw7Yp/i14b3woJTYFHzcjgRYXuw2q/0jMYtwn+8gtKsGg02AtOYtRF8+cu7vQtaEPep0GXCouyE/JKuSZH/ZXOH4uPZ83Vh/htTHt1amHwPd7zlWoV2rBb2f4W3RDgjzr5pdS42U2h3U1yp8gIYQQQtQfdfN/h4s6RavV0DbUk5WP96ZFoAddG/kQ4GHkxWGtGN7QRsDiseWBFagjT/vmQX66mvzhEhqvMPsDZm81KUFASzUle9Q09XhgG/WfPR532K781uOwmvxoEWShta+eoJIkNAkxcD4WclM5n13Aowv2kltUAoC1RB0RKyqx8dD8vaRkFzp95u0nUrE5GUBbcSCJtNzy4C+7wHkq6vyikqtK8FLb+LoZaRHoODGIv7up0ixyQgghhBB1jfxvY1EtdFoNDXxc7abcWYttaPd+X56h7VK7Poe+z8C53eXHPBug8w53fiOjGXo/AVodhPWA48XqXlYjPoBf34ULx8DNH1u3B0lvfDsebl6Qkwyb3lA3vrX9uQ9VWBSeIz8jt7DE4W0y8qykZBUQ4mQ9VFYlAVOxTaHkooBpRMcQftgb77DuwFYBWMy1aE3SVfJ1N/HBXZHc+ekOu4DS1ajjs791JtBSN0fkhBBCCCEckeBK1BiDXoty4YjzCtmJ6pS+Uj6N4a5FYLnMZtDugereRYd+AkxqRj6fcHUvLEsYFGajjV2BX7s7MeptsOUjtQ6A3gVKCuHcbozfjuW1wbOZ9uNZh7cpKLY5bUJ0E+f7OLUOtuBuKv/VaxlkoWMDL2LOZtjVMxt0PHlTc9xMdfvXtFmgB8se6cW+s+nEnMmgRZAH3Rv7EuJlRqt1sm+ZEEIIIUQdVLe/tYm6zVqAJiTSeblfMwhoA5MWg6uvGjR5BF3ZtQ0mdZSKturrC0dh9Qt2VYxDZqmjVnu+hF5Pqvsa5aerm+BmJ8HmN2ntloHZoCPfaj+CZdBpCKlkHVSol5l+LfzZGHve7rhWA6+MbIPvRfs7BVpc+HhiZxbvi+er7XHkFhbTv2UAjw1oRoSv66WXrpNCvc2Eepu5tf1lAmMhhBBCiDpMgitxWSnZBVhLFAw6TdVm+0o9pgYyrr5qQopLDZwJfk3Vn2sR1A5OOFmvZAkFnQkKMmD4u7B/IWx9u7zctwmMeB/vvHR83T04l55vd/pjA5rhV8l6IV93E6/f1p7F++L5Yusp0vOKiIrw5rmhrWgWVHENUpCnC/f1acxtnUKxKQoWF0NZwgshhBBCCFE3yLc34VRabhFbj13grbWxnE7No4GPmSdvak7f5v5/fePPwhzYOAvOH4Exn8K6VyDpz+x6Lp7Q73mI6PnX7hHcAU7EOC7r/4K615Rig+NrIXalfXnqCVj2OKYJ3/Hm7QHMWnmYo8k5hPu48sRNzenWyOeyme4CLC7c27sxoyLVgMnVqMPTbHRaX6fVECBrkIQQQggh6iwJroRDhdYSFu0+y2sry9dEnU3L54lvf+eJQc24r09jzH8ljXZhNpzbBTkp8NPD0O0B6PesmlDCVgxJB8DwFzfPtYQAMeDfApJ/V48ZzNDnaWg+RH1dUgQHvnN8fuZZNHmpdG/SijlTu1JQXIJRp7Wb0nc5Wq2m5pI2FBeq0x6LC8Hgqk6p1Opqpi1CCCGEEDcACa6EQynZhfx37VGHZR9uOMHoTqGE+/yF7qMzqGuoclLU9U3rZtqXR01T64Camj07Ua1XmAWeDcDN3+H+Ug6NXwhFmWpWQvOfa7cMJshKKA8+nMlU96DydnM+4lQrZSfBtvfU9WTWPDUxSJ9/QLs7wM2vplsnhBBCCFEvSXAlHErNLaLQSTa8ohIbGXlW3E1FpOUWkldUgperEX9345WPZrn5Qe+n4Lspjsuj7lZHWRRFHcX65k41GAJ1k+EOE2DQDHAPuIJ7+YPXJYkUshJg/h3Q5+9gdIOiXMfn+l7jeq+alJ8OK56Gw0vLj+Wlwapn1efs8Rjo61iwKIQQQghRB8gmwsIhk9551wjwMOFq1HH3nF0MenszIz7YxqC3NvHfdce4UMnGuhU07AVd7rU/ptWpe1J5R6ivM8/B3OHlgRWoAVfMPNgzF0qKr+KpLnJ0NSQfhIM/Qqe/Oa7j31IdJatrclLsA6uLbX0bcpKqtz1CCCGEEDcIGbkSDvm4GQn3ceVMWl6FspdubcXdc3bblRWV2Ph080ksLnru79sEg+4K4nY3fxjwInS7T90oWO8CIZ3A3V8dTQJIjFEz+jmy/QPoOB48w67u4fLSYO9X6r8fWQbD31dHyvZ9DSV/bv4b3gNGfwwegerrrARI2AdHVqhrl9rdAZ6harbD2ibjtPOyolwoyKy+tgghhBBC3EAkuBIOBVpc+GhiJ8Z9soPswvLRoSCLCR83k8OgC+CTTScZHRlGqPcVJqMwe6k/fs0dl1845vzcggwoLrqy+zijKLDsUegwHu6YqwZXLhbwb6VmEwTIOAtfjYC0k+XnbXlTTeHe9nYwuf+1NlQ1s0/l5fq/mChECCGEEEI4JMGVcKpVkIWV03vz64lU9p/NoG2oJ32b+7Phko1xL5ZdWFxhw92/JKi98zL3QDBcQyY+Vx91KmDCXvW1okDMAvUHYMSH0GSA+u9F+bDxNfvAqtTy6dCwd+0Lriwh4BGsJgG5VMPe4OZb/W0SQgghhLgBSHAlnNJqNYR5uzI2ypWxUeVrjxr6ujo9x2zQ4WKowqV8Aa3UYOHiNVel+j0L7kHXdt3mgyGwrbru6mKB7aDpgPLXeRfgwCLH11AUdY8s3ybX1obrxRICE75TR9vy0sqP+zaBkR+A2bv625SVoAaoKYfBpwn4N7/66ZxCCCGEELWcBFfiqjXycyPAw0SKg+QVf4uOIMDjL24wfDHPUJi8HH64p3ykyeCqZvlrNRK01xjIWUJhwiI4tg72zgE00HkqNB345/5Yf1JK1L2wnMnLuLb7X2+BbeH+zZByBNLjILAN+DRSR7SqW9op+Ho0pJ8qP+bmD5OXqcGzEEIIIUQ9IcGVuGrBXmYW3NuNe+buJi5VXXul0cDIDiFM69UIo76KN6r1bQITvldHkYoL1JEX90DQ/8UgzhIKnSdDqxHqa1cHIzomi5pkozSwu1TTgX+tDdeLRqNmOqzpbId5afDjffaBFUDueVgwFqatqZmATwghhBDiOpDgSlyTpgEeLLo/mgs5hWQXFBNgccHXzYjFbLg+N3TzvX5rhRwFVWVlPnDL6zD7ZrBdspasYZ/ylPGOFOZAVjwc+F79Z4uhaqDmGVo17a4L8i7Aud8cl2WcUdPGS3AlhBBCiHpCgitxzQIsLgRYriGhRF0T2A7uWQ9rZ8DpLWo2vu4PQscJzjcxLsyFw8vgpwfVtVkAMfPBuyH8bWnlQVl9Ys2vvFzSwgshhBCiHpHgSojLMbhASEcYO1fdJ0qrBbcAdcNjZ3KSYekj0GwwtBkDBjOkHoc9c+CXf8KId8v38qrPXLzU6ZvFTjaX9ghxfFwIIYQQog6qwrRuQtRzZi91Sp9HcOWBFcDpbXDHHHWkasXTsOhv8MdSGPQKaIC81Ovf3trAPRCiH3Vc1vYOcPOr3vYIIYQQQlxHMnIlxPXg3RDW/xPO7iw/lhgD30+FMZ+hRlg3AIMLdHsAXDxh69uQn66O2EXdA9EPqQGrEEIIIUQ9IcGVENeDRmsfWF1sy1sw8Uc1k15+GpQUq8GHpZ4mdnD3h+4PQ9sx6hosvcuf2R6NNd0yIYQQQogqJcFVLXYhp5AzqXks2RePDYXRkWFE+Lri516F+0hVt+xksBWrX7CvV/a/2sBZhjwAm1VN5PDDNDizXT3m2QCGvQURPcHkft2apSgKyVmF5BQWY9Rr8XUz4maqhj8DOp1sGiyEEEKIek+Cq1rqfHYh/7fsEMv2J5Ydm7fjDLe0C+KVEW3xr8qNeqtD7nk4thY2v6Gm4A5sC4NmqqnJzZ413bqq51rJWqKb/gVzb7Vfd5V5tnzfpwbdrkuTMvOL2HLsAv9afpikrAJ0Wg3D2gXzzNCWhHqZr8s9hRBCCCFuJJLQopaKOZthF1iVWnEgiX1n0mugRX9BQTZs+S8seRDSTqojV4kx8PUoOLa64v5R9UHDXo6TXgS2hfQ45wkt1s5Q1yVdB9tPpPLIgn0kZRUAUGJTWPp7AlO//I3kP48JIYQQQohrJ8FVLZRdYOWLrSedln++9RRZ+dZqbNFflJsCO//nuGzVs5CdVL3tqQ4egXDbbHXt1cUa9al8ymBiDBTlVXlzUrIK+PeKww7LjibnEHcht8rvKYQQQghxo5FpgbVQsU0hp7DYaXluYTElNqUaW/QXpZ0s30j3UnmpalIHz9DqbdP1ZnBV97h6ZDccXQVZidCkPwR3hJ0fOz/PIxh0Vf9rmWct4Wya8w1995xOp1vjerwGTgghhBCiGkhwVQtZXAwMbRPEwfgsh+U3twnCYjZUc6v+AoNr5eW6epo1zugKvk0g+mH74+3vgC1vgmKreE7vp9RMelXMoNViNujItzqeghniLWuuhBBCCCH+KpkWWAvptBpGRobi7yAroJ+7kdGRoei0dWifJK9wMFkclwW1A9c6NGJiK1GnMWYlQnHhtV3DEgZjvwL9JZ9v5ynQ/Oa/3ERH/D2MjOvawGGZSa+lU7jXdbmvEEIIIcSNREauaqkwb1d+eDCa/208wZKYeABGdAjhkf5NaeBzmZGg2sYjGO78GubfDiUXrRUze8OYT8Gtksx6tUlWAsQsgL1z1cCq9WiIflDdMPhqGP+cMvjwLkg5DEU5ENwe3AKu26a6Rr2O+/s04XBiFjtOppUdNxt0zJ4SRZDF5brcVwghhBDiRiLBVS0W7uvGzBFteHxQM1DA282Ii8FBBrraTqeH8B7w0G9weCmk/KFm02vcT93fqS7ISoB5t6ltL/Xbx3DwO7h3/dUHWHoTeEeoP9UkyNOFD+7qRGJGPgfiM/FzN9E6xEKghwsGvQxiCyGEEEL8VRJc1XIuBh3BnvVgPYzeCL6Nodf0mm7JtTmz3T6wKpWXCr99BgNnqM9Yy/m5m/BzN9EuzKummyKEEEIIUe/I/64W4nKsBep0QGf+WKJmPBRCCCGEEDc0Ca6EuByNFgyVjB7qTaCpQwlGhBBCCCHEdSHBlRCXozdCl3udl0dNU5NRCCGEEEKIG5oEV0JciYDW0Pb2iseDO0Kb0TJyJYQQQgghJKGFEFfE3R+GvAZRU2HXF1CcDx0nQmhnsATXdOuEEEIIIUQtIMGVEFfK3V/9Ce8ONludyA4ohBBCCCGqjwRXQlwtrV4m1AohhBBCiArkK6IQQgghhBBCVAEZuRKiCllLSjifXYS1xIbZoCPA4lLTTRJCCCGEENVEgishqkhKVgFfbY9jzq+nySksJszbzPO3tKJHE1+8XGV9lhBCCCFEfSfTAoWoAhl5RXy14zQrDiSRU1gMwLn0fB6av5d1h1Ow2ZQabqEQQgghhLjeJLgS4q9QFMg4g/vRH3mocDbf9jjLz5MjaBnkXlbltZWHSc4qqMFGCiGEEEKI6iDTAoX4K5IPwJxb0RdkogdcAX8XT74c/QPjlto4nZrHhZwisguLkd2whBBCCCHqNxm5EuJaZSfBt5OgINP+eEEmwavu5fne3gBoNGDUya+aEEIIIUR9J9/4hLhWuechPc5xWfopWnsWAdC/uT++7pLQQgghhBCivpPgSohrVVxYabG2pJAIX1deGdkWDxdDNTVKCCGEEELUlFoXXG3evJnhw4cTEhKCRqNhyZIlZWVWq5VnnnmGdu3a4ebmRkhICH/7299ISEiwu0ZaWhoTJkzAYrHg5eXFtGnTyMnJqeYnEfWemz/onIxI6Yx4+YXw7f3RNPBxrd52CSGEEEKIGlHrgqvc3Fw6dOjAhx9+WKEsLy+PvXv38tJLL7F3715+/PFHYmNjGTFihF29CRMmcOjQIdauXcvy5cvZvHkz9913X3U9grhRuAVAryccl/V+CjffEIJkE2EhhBBCiBtGrcsWOHToUIYOHeqwzNPTk7Vr19od++CDD+jatStnzpwhPDycw4cPs2rVKnbt2kVUVBQA77//PrfccgtvvvkmISEh1/0ZxA3CaIau94NnA9j0GmSeA88w6Pc8NL8ZDOaabqEQQgghhKhGtS64ulqZmZloNBq8vLwA2L59O15eXmWBFcCgQYPQarXs3LmT0aNHO7xOYWEhhYXla2iysrIAdSqi1Wq9fg8grpvSz+26fn5GC7QbB436Q4kVdAZwDyxtwPW7r/jLqqV/iDpJ+oaojPQP4Yz0jfrtSj/XOh1cFRQU8MwzzzB+/HgsFgsASUlJBAQE2NXT6/X4+PiQlJTk9FqzZs3ilVdeqXB8zZo1uLrKmpm67NLRTiEuJv1DOCN9Q1RG+odwRvpG/ZSXl3dF9epscGW1Whk7diyKovDRRx/95es999xzPPnkk2Wvs7KyaNCgAYMHDy4L3ETdYrVaWbt2LTfddBMGg2TrE/akfwhnpG+Iykj/EM5I36jfSme1XU6dDK5KA6vTp0+zfv16u+AnKCiIlJQUu/rFxcWkpaURFBTk9JomkwmTyVThuMFgkF+QOk4+Q1EZ6R/CGekbojLSP4Qz0jfqpyv9TGtdtsDLKQ2sjh07xrp16/D19bUrj46OJiMjgz179pQdW79+PTabjW7dulV3c4UQQgghhBA3iFo3cpWTk8Px48fLXp86dYqYmBh8fHwIDg7m9ttvZ+/evSxfvpySkpKydVQ+Pj4YjUZatWrFkCFDuPfee/n444+xWq088sgjjBs3TjIFCiGEEEIIIa6bWhdc7d69m/79+5e9Ll0HNXnyZGbOnMnSpUsB6Nixo915GzZsoF+/fgDMnz+fRx55hIEDB6LVarntttt47733qqX9QgghhBBCiBtTrQuu+vXrh6IoTssrKyvl4+PDggULqrJZQgghhBBCCFGpOrfmSgghhBBCCCFqIwmuhBBCCCGEEKIKSHAlhBBCCCGEEFVAgishhBBCCCGEqAISXAkhhBBCCCFEFZDgSgghhBBCCCGqgARXQgghhBBCCFEFJLgSQgghhBBCiCogwZUQQgghhBBCVAEJroQQQgghhBCiCkhwJYQQQgghhBBVQIIrIYQQQgghhKgC+ppuQG2lKAoAWVlZNdwSca2sVit5eXlkZWVhMBhqujmilpH+IZyRviEqI/1DOCN9o34rjQlKYwRnJLhyIjs7G4AGDRrUcEuEEEIIIYQQtUF2djaenp5OyzXK5cKvG5TNZiMhIQEPDw80Gk1NN0dcg6ysLBo0aMDZs2exWCw13RxRy0j/EM5I3xCVkf4hnJG+Ub8pikJ2djYhISFotc5XVsnIlRNarZawsLCaboaoAhaLRf7ICaekfwhnpG+Iykj/EM5I36i/KhuxKiUJLYQQQgghhBCiCkhwJYQQQgghhBBVQIIrUW+ZTCZmzJiByWSq6aaIWkj6h3BG+oaojPQP4Yz0DQGS0EIIIYQQQgghqoSMXAkhhBBCCCFEFZDgSgghhBBCCCGqgARXQgghhBBCCFEFJLgSQgghhBBCiCogwZWoU2bNmkWXLl3w8PAgICCAUaNGERsba1enoKCAhx9+GF9fX9zd3bnttttITk62q3PmzBmGDRuGq6srAQEBPP300xQXF1fno4jr4KOPPqJ9+/ZlGzhGR0ezcuXKsnLpG6LUa6+9hkajYfr06WXHpH/cuGbOnIlGo7H7admyZVm59I0bW3x8PBMnTsTX1xez2Uy7du3YvXt3WbmiKLz88ssEBwdjNpsZNGgQx44ds7tGWloaEyZMwGKx4OXlxbRp08jJyanuRxHVQIIrUads2rSJhx9+mB07drB27VqsViuDBw8mNze3rM4TTzzBsmXL+O6779i0aRMJCQmMGTOmrLykpIRhw4ZRVFTEr7/+yty5c5kzZw4vv/xyTTySqEJhYWG89tpr7Nmzh927dzNgwABGjhzJoUOHAOkbQrVr1y4++eQT2rdvb3dc+seNrU2bNiQmJpb9bN26taxM+saNKz09nZ49e2IwGFi5ciV//PEHb731Ft7e3mV1Xn/9dd577z0+/vhjdu7ciZubGzfffDMFBQVldSZMmMChQ4dYu3Yty5cvZ/Pmzdx333018UjielOEqMNSUlIUQNm0aZOiKIqSkZGhGAwG5bvvviurc/jwYQVQtm/friiKoqxYsULRarVKUlJSWZ2PPvpIsVgsSmFhYfU+gLjuvL29lc8//1z6hlAURVGys7OVZs2aKWvXrlX69u2rPP7444qiyN+OG92MGTOUDh06OCyTvnFje+aZZ5RevXo5LbfZbEpQUJDyxhtvlB3LyMhQTCaT8s033yiKoih//PGHAii7du0qq7Ny5UpFo9Eo8fHx16/xokbIyJWo0zIzMwHw8fEBYM+ePVitVgYNGlRWp2XLloSHh7N9+3YAtm/fTrt27QgMDCyrc/PNN5OVlVU2wiHqvpKSEhYuXEhubi7R0dHSNwQADz/8MMOGDbPrByB/OwQcO3aMkJAQGjduzIQJEzhz5gwgfeNGt3TpUqKiorjjjjsICAggMjKSzz77rKz81KlTJCUl2fUPT09PunXrZtc/vLy8iIqKKqszaNAgtFotO3furL6HEdVCgitRZ9lsNqZPn07Pnj1p27YtAElJSRiNRry8vOzqBgYGkpSUVFbn4v8AlpaXlom67cCBA7i7u2MymXjggQdYvHgxrVu3lr4hWLhwIXv37mXWrFkVyqR/3Ni6devGnDlzWLVqFR999BGnTp2id+/eZGdnS9+4wZ08eZKPPvqIZs2asXr1ah588EEee+wx5s6dC5R/vo4+/4v7R0BAgF25Xq/Hx8dH+kc9pK/pBghxrR5++GEOHjxoNy9eiBYtWhATE0NmZibff/89kydPZtOmTTXdLFHDzp49y+OPP87atWtxcXGp6eaIWmbo0KFl/96+fXu6detGREQEixYtwmw212DLRE2z2WxERUXx6quvAhAZGcnBgwf5+OOPmTx5cg23TtRGMnIl6qRHHnmE5cuXs2HDBsLCwsqOBwUFUVRUREZGhl395ORkgoKCyupcmuWp9HVpHVF3GY1GmjZtSufOnZk1axYdOnTg3Xfflb5xg9uzZw8pKSl06tQJvV6PXq9n06ZNvPfee+j1egIDA6V/iDJeXl40b96c48ePy9+OG1xwcDCtW7e2O9aqVauyaaOln6+jz//i/pGSkmJXXlxcTFpamvSPekiCK1GnKIrCI488wuLFi1m/fj2NGjWyK+/cuTMGg4Fffvml7FhsbCxnzpwhOjoagOjoaA4cOGD3h27t2rVYLJYKf0BF3Wez2SgsLJS+cYMbOHAgBw4cICYmpuwnKiqKCRMmlP279A9RKicnhxMnThAcHCx/O25wPXv2rLDly9GjR4mIiACgUaNGBAUF2fWPrKwsdu7cadc/MjIy2LNnT1md9evXY7PZ6NatWzU8hahWNZ1RQ4ir8eCDDyqenp7Kxo0blcTExLKfvLy8sjoPPPCAEh4erqxfv17ZvXu3Eh0drURHR5eVFxcXK23btlUGDx6sxMTEKKtWrVL8/f2V5557riYeSVShZ599Vtm0aZNy6tQpZf/+/cqzzz6raDQaZc2aNYqiSN8Q9i7OFqgo0j9uZE899ZSyceNG5dSpU8q2bduUQYMGKX5+fkpKSoqiKNI3bmS//fabotfrlX//+9/KsWPHlPnz5yuurq7KvHnzyuq89tpripeXl/LTTz8p+/fvV0aOHKk0atRIyc/PL6szZMgQJTIyUtm5c6eydetWpVmzZsr48eNr4pHEdSbBlahTAIc/X375ZVmd/Px85aGHHlK8vb0VV1dXZfTo0UpiYqLddeLi4pShQ4cqZrNZ8fPzU5566inFarVW89OIqnb33XcrERERitFoVPz9/ZWBAweWBVaKIn1D2Ls0uJL+ceO68847leDgYMVoNCqhoaHKnXfeqRw/frysXPrGjW3ZsmVK27ZtFZPJpLRs2VL59NNP7cptNpvy0ksvKYGBgYrJZFIGDhyoxMbG2tVJTU1Vxo8fr7i7uysWi0WZOnWqkp2dXZ2PIaqJRlEUpSZHzoQQQgghhBCiPpA1V0IIIYQQQghRBSS4EkIIIYQQQogqIMGVEEIIIYQQQlQBCa6EEEIIIYQQogpIcCWEEEIIIYQQVUCCKyGEEEIIIYSoAhJcCSGEEEIIIUQVkOBKCCGEEEIIIaqABFdCCCGqxJw5c9BoNMyZM6emm+JUw4YNadiwYU03o9ppNBr69ev3l66xceNGNBoNM2fOrJI2CSFEfSTBlRBC1ENxcXFoNBo0Gg1BQUEUFxc7rHf48OGyejdi0FFdduzYgUajYciQIQ7Lp0+fjkajoWXLlg7L33nnHTQaDS+99NL1bGaVq4qgTggh6hIJroQQoh7T6/UkJyezYsUKh+VffPEFWq0WrVb+c3A9RUVF4e7uzrZt2xwGuhs2bECj0RAbG0tSUpLDcoABAwZc0/0PHz7MV199dU3nCiGEuHLyX1MhhKjHevTogaenJ7Nnz65QVlxczLx58xg0aBAGg6EGWnfj0Ov19O7dm5ycHHbt2mVXlpqayoEDBxg9ejRQHkiVstlsbNmyBZPJRHR09DXdv2XLloSHh19b44UQQlwxCa6EEKIeM5vNjBs3jp9//pmUlBS7suXLl5OcnMzdd9/t9Pzc3FxmzJhBy5YtcXFxwcfHh2HDhrFt27arasepU6e45557CA8Px2QyERwczJQpUzh9+rTD+idPnuS+++6jUaNGmEwmAgIC6Nevn916rsrWeF3N+qCEhARmzJhB9+7dCQgIwGQy0bBhQx566KEK7xnAlClT0Gg0nDx5krfeeovWrVtjMpmYMmVKpffp379/WdsutmnTJhRF4bHHHsPHx6dCcPX777+Tnp5OdHQ0Li4uZcf379/PuHHjCA4Oxmg0EhERwaOPPkpqamqFezubnhcXF8edd96Jj48P7u7u9O3bl82bNzNz5kw0Gk2FtpbavXs3N910Ex4eHnh6ejJ69Gji4uLKykvf/9LnK516WtvX5AkhxF8lwZUQQtRzd999N8XFxXz99dd2x2fPno2Pjw+jRo1yeF5BQQEDBgzg//7v/3Bzc2P69OmMHDmSDRs20LdvX7777rsruv/OnTuJjIxk7ty5dO7cmccff5zevXszf/58unbtysmTJ+3qb926lcjISD7//HNatmzJk08+yZgxY8jPz+fdd9+9pvegMps3b+att94iMDCQ8ePH8+ijj9KkSRM++ugjoqOjyczMdHjeo48+yquvvkpUVBTTp0+nXbt2ld6nNLi6NHjasGEDZrOZ7t2707t3b4flF58PsHTpUrp27crSpUvp169f2f0/+OADoqOjSU9Pv+xzx8fH06NHDxYtWkS3bt147LHH8PPz46abbmLnzp1Oz9u1axd9+vTBaDRy//33ExUVxZIlSxg0aBAFBQWAmjhkxowZAERERDBjxoyyn44dO162bUIIUWcpQggh6p1Tp04pgHLzzTcriqIobdu2Vdq0aVNWnpiYqOj1euXRRx9VFEVRTCaTEhERYXeNV155RQGUCRMmKDabrez43r17FaPRqHh5eSlZWVllx7/88ksFUL788suyY0VFRUrDhg0VDw8PZe/evXbX37Jli6LT6ZRbb7217FhBQYESGhqqaLVaZeXKlRWe6+zZs5Xer9SGDRsUQJkxY4bd8YiIiArPmZycrGRnZ1e4xty5cxVA+de//mV3fPLkyQqghIWFKadPn65wnjPFxcWKp6en4ubmphQVFZUdb9u2rdK/f39FURTl7bffVgC75xw+fLgCKJs3b1YURVEuXLigWCwWJTQ0VImLi7O7xzfffKMAyiOPPGJ3HFD69u1rd2zixIkKoPz73/+2O/7FF18ogAIoGzZsKDte+p4CysKFC+3OmTRpkgIo33zzzWXvK4QQ9ZmMXAkhxA3g7rvv5tChQ2UjEnPnzqW4uLjSKYFz587FYDDw2muvlU3xAoiMjGTy5MlkZGSwZMmSSu+7fPly4uLiePrpp4mMjLQr69WrFyNHjmTFihVkZWUB8NNPPxEfH8/EiRMdZtYLCwu70ke+YgEBAbi7u1c4PmnSJCwWC+vWrXN43tNPP31V65h0Oh19+vQhNzeX3377DYDz589z6NChsil7ffv2BcpHq0rXW5nNZrp16wbAV199RVZWFrNmzSIiIsLuHuPGjaNTp04sXLiw0rYUFhby3XffERAQwFNPPWVXNnXqVFq0aOH03D59+nDnnXfaHSvtR5euJxNCiBuNvqYbIIQQ4vqbOHEizzzzDLNnz6Zbt258+eWXREZGOp2ilZWVxcmTJ2nVqpXDgKZ///589tlnxMTEMGnSJKf33bFjBwCxsbEO1z8lJSVhs9k4evQoUVFRZUHH4MGDr/4h/4Iff/yRTz75hL1795Kenk5JSUlZWUJCgsNzunbtetX36devH8uWLWPDhg307NmTjRs3oihKWXDVsWNHPD092bBhA5MmTSImJoaMjAwGDRqE0WgEyt/TnTt3cuLEiQr3KCgo4MKFC1y4cAE/Pz+H7YiNjaWwsJCoqChMJpNdmUajoUePHsTGxjo8t3PnzhWOlfaRjIyMK3ofhBCivpLgSgghbgD+/v4MHz6chQsXcscddxAbG8v777/vtH7pSFJgYKDD8uDgYLt6zqSlpQEwf/78Suvl5uYClK1vCg0NrbR+VXrrrbf4+9//jr+/P4MHDyYsLAyz2Qyo+0sVFhY6PM/Ze1OZi5NavPjii2zcuBEXF5eyUSmtVkuvXr3KRq4cpWAvfU8//PDDSu+Vm5vrNLgq/dwCAgIcllf2bBaLpcIxvV79OnFxUCqEEDciCa6EEOIGMW3aNH788UemTJmCi4sLEyZMcFq39At0cnKyw/LSvZgcfdF2dJ1ly5Zx6623XraNXl5egJps4XJK9+ZytG+UsyQUlyouLuaf//wnwcHBxMTE2AUbiqLw+uuvOz334qmSV6pDhw54e3vz66+/UlRUxIYNG+jevbvd6FG/fv34+eefiYuLK8vWd3Eyi9L39MCBA7Rt2/aq23DxNRxlQwTnn7sQQojKyZorIYS4Qdx8882EhoYSHx/PqFGj8Pb2dlrXYrHQuHFjjh8/7jDQKf3Sf7nMb6UjMtu3b7+iNpZOtVuzZs1l65a231H79u3bd0X3u3DhApmZmURHR1cYxdm9ezf5+flXdJ0rpdVq6du3L/n5+SxdupTDhw9XSJFeuu5q3bp1bNmyBXd3d6KiosrKr/Y9daRFixaYTCb27NlTYWROUZS/dO2LabVaGc0SQtxQJLgSQogbhE6nY8mSJSxevJhZs2Zdtv7kyZOxWq0899xzKIpSdnz//v3MmTMHT09Pp2ncS40cOZLw8HDefvttNm/eXKHcarWydevWstcjRowgLCyMefPmsXr16gr1Lw6kOnfujEajYeHChWUpwAGOHTt2xSnbAwICMJvN7N27l7y8vLLj6enpPProo1d0jatVOgr1yiuvAFQIrjp16oSHhwfvvvsumZmZ9O7du2zaHagJJzw8PHjhhRc4dOhQhevn5eWVrctyxmQycfvtt5OcnMw777xjV/bVV19x5MiRa3iyinx8fDh37lyVXEsIIeoCmRYohBA3kKioKLtRkMr84x//4Oeff+brr7/m8OHDDBw4kJSUFL799luKi4v57LPP8PDwqPQaJpOJ77//nqFDh9K3b18GDBhAu3bt0Gg0nD59mi1btuDr61v2Zd5kMrFo0SKGDBnC0KFDGTJkCB06dCArK4uYmBjy8vLKRqVCQkIYP348CxYsoHPnzgwZMoSUlBQWL17MkCFD+OGHHy77jFqtloceeoi33nqLDh06MHz4cLKysli5ciURERGEhIRc0Xt1NUqDq4MHD+Li4kL37t3tynU6HT179mTVqlV29Uv5+/vzzTffcMcdd9ChQweGDBlCy5YtKSwsJC4ujk2bNtGjR4+y852ZNWsW69at49lnn2XTpk1ERkYSGxvL8uXLGTJkCKtWrSqbenmtBgwYwKJFixg1ahSRkZHodDpGjBhB+/bt/9J1hRCitpLgSgghhEMuLi6sX7+e//znP3z77bf897//xdXVlb59+/L888/Tq1evK7pOly5d+P3333njjTdYsWIF27Ztw2QyERoayqhRoxg/frxd/ejoaPbu3cusWbNYvXo169atw9vbm9atW/PAAw/Y1f3888/x8/Pj22+/5cMPP6RFixZ8+umnhISEXFFwBWqQ4ePjw5w5c/jf//5XtpnwzJkzr3lNU2Xatm2Ln58fFy5cqLDeqlTfvn2dBlcAw4YNY9++fbzxxhusW7eOtWvX4ubmRlhYGFOnTmXixImXbUeDBg3Yvn07zzzzDGvWrGHTpk107tyZNWvWlG0Qfbk1dZdTOoK4fv16li1bhs1mIywsTIIrIUS9pVEunushhBBCiBter1692L59O5mZmQ73ABNCCOGYrLkSQgghblCJiYkVjs2bN49t27YxaNAgCayEEOIqyciVEEIIcYPy9fUlMjKS1q1bo9PpiImJYePGjXh4eLBt2zbatWtX000UQog6RYIrIYQQ4gb1wgsvsGzZMs6cOUNubi7+/v7079+fl156iZYtW9Z084QQos6R4EoIIYQQQgghqoCsuRJCCCGEEEKIKiDBlRBCCCGEEEJUAQmuhBBCCCGEEKIKSHAlhBBCCCGEEFVAgishhBBCCCGEqAISXAkhhBBCCCFEFZDgSgghhBBCCCGqgARXQgghhBBCCFEF/h8hsoKuh6JcZAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import seaborn as sns\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 7))\n", + "sns.scatterplot(\n", + " data=ccs_df, x='weights', y='CCS_AVG', hue='Precursor Adduct', palette='tab10'\n", + ")\n", + "plt.xlabel(\"Molecular Weight\")\n", + "plt.ylabel(\"CCS (Collision Cross Section)\")\n", + "plt.title(\"Weight vs. CCS\")\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# Seperate Clusters\n", + "\n", + "from sklearn.cluster import DBSCAN\n", + "from sklearn.preprocessing import StandardScaler\n", + "from scipy.stats import ttest_ind\n", + "from scipy.stats import chi2_contingency\n", + "\n", + "# Standardize the data\n", + "X = ccs_df[['weights', 'CCS_AVG']].values\n", + "X_scaled = StandardScaler().fit_transform(X)\n", + "\n", + "# DBSCAN clustering\n", + "clustering = DBSCAN(eps=0.3, min_samples=10).fit(X_scaled)\n", + "ccs_df['cluster'] = clustering.labels_ # -1 is noise, 0/1 are clusters\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 7))\n", + "sns.scatterplot(\n", + " data=ccs_df, x='weights', y='CCS_AVG', hue='cluster', palette='tab10'\n", + ")\n", + "plt.xlabel(\"Molecular Weight\")\n", + "plt.ylabel(\"CCS (Collision Cross Section)\")\n", + "plt.title(\"Weight vs. CCS\")\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# Analyze clusters\n", + "\n", + "upper_cluster = ccs_df[ccs_df['cluster'] == 1] # has higher CCS values on average\n", + "bottom_cluster = ccs_df[ccs_df['cluster'] == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1682682/1741744029.py:4: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=ccs_df, x='cluster', y='ring_count', palette='Set2')\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAFDCAYAAAAHwhi5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+ZUlEQVR4nO3deVgT1/4/8HdYEqgEkEUQRBRQrLV1X3HftaXWvdKruFy1bl1s761WK9Cq9PbWpa1L7aLWKnXf6r6iFddiqb1aV1ApVBGVBFBA4Pz+8Jd8CQRIAkMSfL+eJ49m5syZT4aZ+eScMzORCSEEiIiIKpmNuQMgIqLqiQmGiIgkwQRDRESSYIIhIiJJMMEQEZEkmGCIiEgSTDBERCQJJhgiIpIEEwwREUmi0hNMvXr1IJPJdF4KhQJ16tTBgAEDsGvXrlKXjYyMhEwmQ2RkZGWHJZmDBw9izJgxaNiwIZydnaFQKFC7dm306tULixYtwr1798wdolmMHj26xH7g6OgILy8vtG7dGhMmTMDOnTuRn59fah2Wtj9oPtPq1at1pltanACwevVqyGQyjB492tyhlMpSYzT2mLbUz2EJJGvBhISEIDw8HOHh4ejfvz/s7Oywc+dOhIaGYvr06VKttsqkp6ejV69e6N27N1avXo0nT56gW7duGDx4MJ5//nmcPHkS06dPR0BAAM6cOWPucI1WWSfNwMBA7X4wePBgtGrVCmlpafj2228xYMAABAUF4fDhw5UTdClKSwzW6ubNm5DJZKhXr565Q6lWrPWYtuQEZydVxf/85z91PnB+fj7effddLFmyBIsWLcKIESPQunVrnWWmTp2K119/HR4eHlKFVSlUKhU6duyIK1euoFGjRvjmm2/QqVMnnTK5ubn44YcfEBERgb///ttMkZpfx44d9Z7Yf//9d8yYMQP79u1Dnz59sG3bNoSGhuqUsbT9ITo6GjNmzEDt2rXNHUq5Bg4ciHbt2sHFxcXcoVgFHtPSqLIxGDs7O/z3v/+Fs7MzAODnn38uUcbDwwONGjWymBNKaaZNm4YrV66gXr16iIuLK7EjAoBCocCECROQkJCA559/3gxRWramTZtiz549GD58OAoKChAeHg61Wq1TxtL2h9q1a6NRo0ZWcdJ2cXFBo0aNrCIZWgIe09Ko0kF+BwcHNGjQAABw9+7dEvNL65Yp2gTMzs7GzJkzERQUBIVCAW9vb4SHhyMlJaXU9e7YsQOdOnWCUqmEi4sLunTpgt27d5vU1ZCYmIiYmBgAwMKFC+Hm5lZmeS8vLwQHB5eYvn79evTo0QNubm5QKBTw9/fH2LFjcfXqVb31aMYxStO1a1fIZDLExsaWOj0hIQGDBg2Ch4cHFAoFGjdujAULFqD4A7VlMhmioqIAAFFRUTrjKJXZDJfJZFi6dCkcHR3x8OFDfPvttzrzy+qm27RpE3r27Al3d3fY29vD3d0djRs3xvjx43HhwgUA/9eV9MMPPwAAxowZo/NZitZbdPuuWrUK7du3h4uLC2QyGW7evAnAsK62W7duYdSoUahduzYcHBzQsGFDREZG4vHjxyXKltcNGRsbC5lMhq5du2qnjR49GvXr19euq/g4l0Z53SZnz57FsGHD4OPjA7lcjlq1aiE0NBQHDx7UW77oZ09KSsLIkSPh7e0NhUKBwMBAzJ49G7m5uaVul/Lcv38fU6ZMQd26dbXHw7vvvouHDx/qlFu1ahVkMhn69OlTal2pqamwt7eHo6Mj7t+/X+66K+uYLq68v0FZ55/4+HgMHz4cderUgVwuh7OzMwICAjB48GDs2LFDW65evXoYM2YMAOCHH37Q2ReK7jcamzdvRt++feHp6Qm5XA5fX1/84x//wKVLl8qMr6CgAAsXLkTz5s3h5ORU5rmoKMm6yEqj+Zbq5eVl9LIqlQodOnTA7du30alTJzRp0gSnTp3CmjVrcOzYMfz+++8lvl1+9tln+OCDDwAAbdu2RUBAAK5fv45XXnkF//73v42OYdeuXSgoKICrqyteffVVo5cXQmD06NFYs2YN7Ozs0LlzZ9SqVQvnz5/HqlWrsGHDBmzZsgV9+/Y1uu6y7N+/HwsXLkRgYCB69eqFv//+GydOnMD777+P5ORkLF68WFs2PDwcCQkJ+P3339G0aVM0a9ZMO69jx46VGpe7uzv69u2Lbdu24eDBg3jvvffKXebjjz9GREQE7Ozs0KFDB/j6+kKlUuH27dv4/vvv8cILL+Cll16Ck5MTwsPDceLECdy4cQMhISEICgrS1lP0c2lMmzYNy5YtQ4cOHfDyyy8jMTHR4IMpKSkJLVu21P5dHz9+jKNHjyIqKgqHDh3CoUOH4ODgYPC20adjx47IysrCli1bUKNGDQwZMsToOr799lu8+eabKCwsRPPmzdG1a1fcunULu3btwq5duxAZGYmIiAi9yyYkJODtt99GzZo10aVLFzx48ABxcXGYN28eLl68iG3bthkdz8OHD9G2bVvcv39f5wvR4sWLsXfvXvzyyy/w9PQEAISFheGDDz7AwYMHcfXqVTRs2LBEfStWrEB+fj5GjhwJd3f3ctdf0WO6sh0+fBj9+vXDkydP0LRpU7Rv3x4FBQVISUnB7t27UVBQgAEDBgAAhgwZgtOnTyMuLg6BgYE6x2ejRo20/8/Pz8cbb7yBjRs3QqFQoGXLlvD19cXVq1exbt06bN26FVu3btV73hFCYNCgQdi3bx86deqE559/HhcvXjTsw4hK5u/vLwCIVatWlZh36dIlYWtrKwCIc+fOlZgfEREhAIiIiAid6atWrRIABADRp08foVKptPMePHggmjVrJgCI+fPn6yx3/vx5YWtrK2xtbcXWrVt15m3cuFHY2NgIAMLf39/gzzdy5EgBQHTv3t3gZYpavny5ACA8PDzEb7/9pp1eWFio/fyurq4iLS1NZznN5y9Nly5dBABx9OhRvdMBiK+//lpn3uHDh4VMJhO2trYiOTlZZ15pfwtDhYeHCwAiPDy83LJz584VAESdOnXKjSEnJ0c4OjoKJycncfny5RJ13bx5U/z55596Y9G3T2potpGzs7M4depUmZ+peD2aOAGIAQMGiEePHmnnJScni4YNGwoAYsaMGeV+vqKOHj0qAIguXbroTE9KSip3v9UcM8W3/4ULF4SdnZ2QyWRizZo1OvP27Nkj5HK5ACAOHDig97MDELNmzRL5+fnaeX/88YeoUaOGACBOnjxZakylxQhAtGvXTty/f1877+HDh6JDhw4CgHj99dd1lps1a5YAIN56660Sdebl5Qlvb28BQMTHxxsUR0WP6dK2dWnTNUr7O3br1k0AEGvXri2xTEZGRon9s7z1CCHEhx9+KACItm3bisTERJ15mzZtEra2tqJmzZri4cOHJeLTHJtXrlwptf7SVEkXmUqlwoEDBzBo0CAUFBRg9uzZaNWqldH11KhRA6tWrdKO4wBAzZo1MWPGDADAoUOHdMovWbIEBQUFGDZsGAYOHKgzb+jQoRg0aJDRMWguUaxVq5bRywLA559/DgCYM2eOzjdomUyGiIgIvPTSS8jIyCjRXVRRgwYNwsSJE3Wmde/eHX369EFBQQGOHj1aqeszhmaMxZDuDLVajcePHyMgIEBvN4W/v7/ONzdjvf/++2jXrp1Jyzo6OuLrr7+Go6OjdlqdOnWwYMECAMCyZcuQk5NjcmyV4YsvvkB+fj4GDhyIkSNH6szr168fJkyYAAD473//q3f5li1b4pNPPoGtra12WpMmTbR1FT8GDbV8+XKdrilXV1d8/fXXkMlk2LhxI/766y/tvMmTJ8Pe3h4//PADsrOzderZsmUL7ty5g/bt26NFixYGrbuix3Rl0wwf9O/fv8Q8FxcXo/fPBw8eYNGiRXBwcMCWLVu0XawaQ4YMwcSJE/Hw4UOsXbtWbx3z58/X21osj2QJpmh/t6urK/r06YNr165h7dq1+OSTT0yqs1WrVnoHLTUDbsXHYY4dOwYAeOONN/TWV9p0qfz111+4ceMGgKfdUMXJZDJtf2pln/CLX6GlUdq2q0qFhYUAYFBXlKenJ+rVq4cLFy7gvffe09t3XBGmdDlp9O7dG97e3iWmv/LKK3B3d4darcb58+crEl6FacboShsXGDduHADgl19+QUFBQYn5r7zyit6/U0X2o+LdsBovvvgimjdvjsLCQhw/flw73cfHB0OGDIFKpcKPP/6os8zSpUsBPL0C0Vq1adMGwNPz04kTJ8q8V8wQR48exePHjxESEgJfX1+9ZTTjNSdPntQ7f/DgwSatu8rug1EqlSgoKMCkSZNw9uxZk+qsW7eu3umaFk3xb4eabz2lDeKbch+Bpi84LS3N6GU1B5+7u7tOK6yowMBAnbKVxdhtV5XS09MBoNzBVY01a9agVq1aWLhwIV544QW4u7ujf//+WLRokbYuU1Xk3pLi3wz11Vv0m7g5aPar0mLV7H85OTl6W5RS7EdlbTfNvOLb7a233gLwfwkFAC5cuIATJ07Ay8vLqC8KFTmmpRAdHY0WLVpg79696NSpE5ydndGxY0fMnj0bf/75p9H1JSYmAng6tlP8ohDNa9iwYQCg98bwWrVq4bnnnjPps1TZfTAqlQoDBw7E0aNHMWzYMFy6dMnooG1sTMuHpX0zNnTwtqiWLVvixx9/xPnz51FQUKDTVWBOmlZAaUzddlVB863+xRdfNKh8p06dcPPmTezevRvHjh3DyZMnsX//fuzduxcRERHYtm0bevToYVIsRbu3pCCKXbFXlvL+puZgrv2o+HZr164d2rRpg7Nnz+LYsWPo0qWLNtlMmDABcrnc4LrNdUyX9vf19vbGr7/+imPHjuHQoUOIi4vDmTNnEBcXh/nz5yM6Olp74ZIx6wkKCkJISEiZZfV1L1fkmKiyvcXFxQUbNmyAm5sbbt26hYULF0q+Tk1zUHOZaXGlTS/LK6+8AhsbG2RkZGDnzp0mxXP//v0S93xoaL5tFG/K2tvbAwAyMzP1Lnfr1i2jYrEU6enp2L9/P4CnXUyGcnR0xJAhQ/DVV18hPj4ed+7cwYQJE5CZmYmxY8dKFW6ZkpKSSp2n2dfq1KmjnaY5CVbl31SzX2n2s+I00x0cHAxuUVaUsdtNQ9OKWbJkCTIyMrBu3TrY2dnhzTffNGr9FTmmy1KRv6/mMuO5c+fi6NGjePDgAZYvXw6ZTIYPP/xQ29VuCD8/PwBAcHAwVq9eXeZLM55dWar064inpydmz54N4Olgd0ZGhqTr69y5MwBor3EvrrTpZQkMDMSIESMAAO+99x4ePHhQZvm0tDRcuXIFwNODRNMFoe9eCiGEdnq3bt105mlODPqayBcuXEBycrJRn6M8moOjov2/ZRFCYOrUqXj8+DHc3Ny0/f+m8PT0xGeffQYAuH37ts79E1XxWQDgwIEDertZ9uzZg/v370OpVKJly5ba6WX9TQFg9+7deqdX5PNo+tpLu5dn5cqVAJ62Eu3squYuhgsXLmjvXSrq4sWLOH/+PGxsbLTHclHDhg1D7dq1sX37dsybNw/Z2dkYOHAgfHx8jFp/RY7psmj+vpcvX9Y7v7S/rz4ODg5488038dJLL6GwsFBne5W3P/To0QNyuRyxsbFV3g1Y5e3dyZMno27dulCpVNqra6QydepU2NjYYP369To3JwHA1q1bsWXLFpPq/eqrrxAUFISkpCR07NgRJ06cKFEmLy8PK1euRPPmzXVOIO+//z4A4JNPPsHvv/+unS6EwNy5c5GQkABXV1eMHz9ep76ePXsCeHrjY9Eb2m7evInw8HCjul4MofnGaPD17ka6cOEC+vfvjw0bNsDW1hZr166FUqksd7lbt27hu+++09sC1DwdombNmjpjXFJ/Fo3Hjx9j0qRJOjdVpqamau/tefPNN3Xug+nevTtsbGywf/9+7QUpwNN94csvvyx1/9TcJHfnzp1yT4bFvf3227Czs8P27dtLXDF04MABrFixAsD/7adVQQiBSZMm6XwpUKlUmDRpEoQQGDx4sPZbeFH29vaYNGkS8vPztVdnmjq4X5FjujRt2rSBs7MzLl26VOJihE2bNuHLL7/Uu9znn3+O27dvl5h++fJlXLt2DcDTqyU1NPt3aRe8eHl5Ydq0acjOzkZoaCj++OOPEmVyc3Oxc+fOUpOhyYy+sLkcZd0Ho7Fy5UoBQCiVSp1r38u7D8bY68mFEGL+/Pk619qHhYWJNm3aCADivffeEwBEgwYNjP6cd+/eFV27dtXWXb9+fTFgwAAxYsQI0b17d+Hk5KS9r+LMmTPa5QoLC7XX3dvZ2YkePXqIESNGiODgYAFAODo6ij179pRYX2JionB1dRUARN26dcXgwYNF586dhaOjo+jZs6f2noHS7oMpPl2jtG1+584d7b0NISEhYvTo0WLcuHFi5cqVBm0fzX0TgYGBIjw8XISHh4s33nhDvPzyy9p9RLPdjhw5YnBsv/32mwAg7O3tRevWrcWwYcPEsGHDRPPmzQUAIZPJxHfffadTz++//y5sbGyEjY2N6NmzpxgzZowYN26c2LFjh7aMJh5DPlNp98GMGjVKuLm5CW9vbzF06FARGhqq3Ybt27fXuT9G4+233xYAhK2trejatasYNGiQCAwMFPb29mLGjBl674MRQoghQ4YIAMLPz0+MGDFCjBs3TowbN047v6xjZsWKFdp7wFq0aCHCwsJESEiIkMlkAoCIjIw0+LMbsr7SaJZ59dVXRUBAgHB1dRUDBw4UgwYNEm5ubtpj8+7du6XWcffuXaFQKAQA8dJLLxm87tLqMuWYLuuzL1q0SFtf+/btxZAhQ8QLL7wgZDKZ+Oijj/Set1xcXAQA0ahRIzFw4EARFhYmunbtKuzs7LT7WVG5ubnCx8dHABDNmzcXo0aNEuPGjROfffaZtsyTJ09EWFiYACBsbGxE8+bNxeDBg8Xw4cNFSEiIdj/du3evdhlD7rcqj1kSTH5+vmjcuHGJm8+kSDBCCLF161btRlQqlaJjx45i+/bt4vjx49o/vKn27t0rRo0aJYKCgoSTk5Owt7cX3t7eolevXmLx4sU6CbSomJgY0bVrV+Hq6irs7e2Fn5+fGD16tN6bBzUuXbokBg0aJGrWrCkUCoUIDg4Wc+fOFXl5eeXeaGlsghFCiOPHj4uePXuKmjVrak9Ihp5Ait6Yp3kpFApRq1Yt0bJlSzF+/HixY8cO8eTJk1Lr0BebWq0WixcvFgMHDhQNGjQQTk5OokaNGqJhw4Zi1KhR4tdff9Vb17Zt20RISIhQKpXaE2nReisjwURERIjExEQxYsQI4eXlJeRyuQgKChJz5swR2dnZeussLCwUCxYsEM8//7yQy+XCzc1NhIaGivj4+FJvtBRCiPv374uJEyeKunXrCnt7+xLxl3fMnD59WgwZMkR4e3sLOzs74e7uLl5++eUSN1iW99kNXV95y6SlpYmJEyeKOnXqCLlcLvz8/MRbb71V6vFTVNu2bQUAsWLFCoPXXRZjj+nyPvsPP/wgWrRoIRwcHISzs7Po3r27OHjwYKnnrbVr14oxY8aIJk2aCDc3N6FQKIS/v7/o16+f2LZtmygsLCyxjj/++EO8+uqrwtPTU3us6ttv9uzZIwYNGiR8fX2Fvb29cHV1Fc8//7x4/fXXRUxMjM5+WhkJRiZEJfetWBHNI0emTZtWanOViCzX1atXtQ8gTUlJMflyWpKG5V67WkmuXbtW4oF5ALBz505ER0dDJpPpvemRiCzfnDlztGM4TC6Wp8ofdlnV1q1bh/nz56N58+bw8/PDkydPcOXKFe1VIJGRkTpX9hCRZdu5cyd27NiBixcv4syZM/D29jbpwbUkvWqfYPr27Ytr167h9OnT+PPPP5GTkwN3d3eEhoZi8uTJlf7UYiKS1vnz57Fy5UoolUr07NkTCxcuhKurq7nDIj2e6TEYIiKSTrUfgyEiIvNggiEiIklUuzGYwsJCpKamQqlUmvQwSyIiSyOEQGZmJnx8fCz6wbXFVbsEk5qaqvexEkRE1i45OVnvgz8tVbVLMJrnWSUnJ5f6mytERNZErVbDz8/PoOf1WZJql2A03WLOzs5MMERUrVhbt7/1dOYREZFVYYIhIiJJVLsuMqo+cnJysGTJEty7dw+enp6YOnWqzu+pEJFls7g7+evVq6f3p0QnT56s/c3tsqjVari4uEClUnEMxorNnj1b78/6BgQEYO7cuWaIiMh8rPW8ZnFdZOfOncPff/+tfR08eBAAMHToUDNHRlVFk1xkMhk6duyI6OhodOzYETKZDImJidqf3SYiy2ZxXWSenp467z/99FMEBgaiS5cuZoqIqlJOTo42uXz//ffaLrHJkydj7NixGDduHBITE5GTk8PuMiILZ3EtmKLy8vKwdu1ajB07ttTL83Jzc6FWq3VeZL2WLFkCAAgJCSmRQBwcHNChQwedckRkuSw6wWzfvh0ZGRkYPXp0qWWio6Ph4uKiffEufut27949AMDLL7+sd36/fv10yhGR5bLoBPP999+jX79+8PHxKbXMzJkzoVKptK/k5OQqjJAqm6aLdPfu3Xrn7927V6ccEVkui00wt27dwqFDh/DPf/6zzHIKhUJ71z7v3rd+U6dOBQDExcUhJydHZ15OTg5OnjypU46ILJfFDfJrrFq1CrVq1Sq1q4SqJwcHBwQEBCAxMRHjxo1Dhw4d0K9fP+zduxcnT56EEAIBAQEc4CeyAhZ3Hwzw9JH79evXx4gRI/Dpp58atay1Xi9OungfDNH/sdbzmkW2YA4dOoTbt29j7Nix5g6FzGTu3Lm8k5/IyllkC6YirDXTExGVxlrPaxY7yE9ERNaNCYaIiCTBBENERJJggiEiIkkwwRARkSSYYIiISBJMMEREJAkmGCIikgQTDBERSYIJhoiIJMEEQ0REkmCCISIiSTDBEBGRJJhgiIhIEkwwREQkCSYYIiKSBBMMERFJggmGiIgkYWfuAIhKExYWVmJaTEyMGSIhIlNYZAsmJSUF//jHP+Du7g5HR0e8+OKL+PXXX80dFlUhfcmlrOlEZHksLsE8fPgQISEhsLe3x969e3Hp0iUsWLAANWvWNHdoVEXKSyJMMkTWQSaEEOYOoqgZM2YgLi4Ov/zyi0nLq9VquLi4QKVSwdnZuZKjI6kVTx5Fu8TKmkdUnVnrec3ixmB27tyJPn36YOjQoTh27Bh8fX0xefJkjB8/Xm/53Nxc5Obmat+r1WrJYsvNzUVqaqpk9RvCx8cHCoXCrDFUleIJJCYmhq0XIiticQkmMTERy5cvx/Tp0/Hhhx/i3LlzeOuttyCXyxEeHl6ifHR0NKKioqokttTUVMyaNatK1lWaefPmoX79+maNgYjIEBbXRSaXy9GqVSucPHlSO+2tt97CuXPncOrUqRLl9bVg/Pz8JGlKVrQFk5KSgmXLlmHy5Mnw9fU1qY7q3oIp2kLR1wVW3nyi6ohdZJWkdu3aaNy4sc60559/Hlu2bNFbXqFQVNkJV6FQVErrwdfXl60QA4SFhZU5BkNEls3iEkxISAiuXLmiM+3q1avw9/c3U0RUlYqPs5SWVNh6IbJ8FneZ8rvvvovTp09j/vz5uH79OmJiYvDNN99gypQp5g6Nqkh5yYPJhcg6WFyCad26NbZt24affvoJTZo0wSeffILFixfjjTfeMHdoVIVKSyJMLkTWw+K6yADglVdewSuvvGLuMMjMmEyIrJvFtWCIiKh6YIIhIiJJMMEQEZEkmGCIiEgSTDBERCQJJhgiIpIEEwwREUmCCYaIiCTBBENERJJggiEiIkkwwRARkSSYYIiISBJMMEREJAkmGCIikgQTDBERSYIJhoiIJGFSgrl9+zbUanWZZTIzM3H79m2TgiIiIutnUoKpX78+vvjiizLLfPnll6hfv75JQRERkfUz6SeThRAQQpRbhoiq3vXr1zFnzhzt+48//hhBQUFmjIieVZKNwfz1119QKpVGLxcZGQmZTKbzatSokQQRElU/YWFhOskFAObMmYOwsDAzRUTPMoNbMB9//LHO+9jYWL3lCgoKkJycjPXr16Ndu3YmBfXCCy/g0KFD/xeknUkNLaJnSvEk0qVLFxw7dkxnfkxMTFWHRc8wg8/ckZGR2v/LZDLExsaWmmQAwMfHB//5z39MC8rODt7e3iYtS/Qsun79uvb/RbvEJk6cqNNldv36dXaXUZUxOMEcPXoUwNOxle7du2P06NEIDw8vUc7W1hZubm5o1KgRbGxM64G7du0afHx84ODggPbt2yM6Ohp169bVWzY3Nxe5ubna9+Vd3UZVLzc3F6mpqWaNwcfHBwqFwqwxSKlot1jxBFL0/Zw5c9iKoSpjcILp0qWL9v8RERHo1q0bOnfuXOkBtW3bFqtXr0ZwcDD+/vtvREVFoVOnTvjf//6nd0wnOjoaUVFRlR4HVZ7U1FTMmjXLrDHMmzfvmbiqsehxWlSHDh1w8uTJKo6GnnUyYeGXe2VkZMDf3x8LFy7EuHHjSszX14Lx8/ODSqWCs7NzVYZarqSkJMyaNeuZOdlpVKQFk5KSgmXLlmHy5Mnw9fU1OYbq3oIpOv6ir4VS3nyybGq1Gi4uLhZ5XitLhUbP79y5g/j4eGRkZKCgoEBvmVGjRlVkFXB1dUXDhg11+piLUigU1frEUR0oFIoKJ1RfX99nKikb6+OPPy51nKX4+AxRVTEpweTk5GD8+PFYv349CgsL9ZYRQkAmk1U4wWRlZeHGjRsYOXJkheohqs6Kj7MA+rvFOMBPVcmkBDNjxgysW7cODRs2xIgRI1CnTp1Ku5T4/fffR2hoKPz9/ZGamoqIiAjY2tpixIgRlVI/UXUVExOj0xVWPLmwa4yqmklZYePGjWjcuDHi4+MrvXvqr7/+wogRI3D//n14enqiY8eOOH36NDw9PSt1PUTVUUxMDO/kJ4thUoLJyMhAWFiYJGMf69evr/Q6iZ4lQUFBbK2QRTDpRpXg4GDcvXu3smMhIqJqxKQE869//Qs7duwo9couIiIik7rI6tSpgz59+qBNmzZ455130KJFi1KvzZbiZkwiIrJ8JiWYrl27QiaTQQihffpxaUq7P4aIiKo3kxLMnDlzykwqREREJiWYok9WJiIi0keyHxwjIqJnGxMMERFJwqQuMhsbG4PGYGQyGfLz801ZBRERWTmTEkznzp31JhiVSoVr164hOzsbTZs2haura0XjIyIiK2VSginrp5IfPXqEGTNmYN++fTh48KCpcRERkZWr9DGY5557Dl9++SVcXFzwr3/9q7KrJyIiKyHZIH+nTp2we/duqaonIiILJ1mCuXfvHrKysqSqnoiILFylJ5jCwkL8+OOP2LBhA5o1a1bZ1RMRkZUwaZA/ICBA7/T8/HykpaXhyZMnsLe3R3R0dIWCIyIi62VSgiksLNR7mbK9vT2aNGmC1q1bY+rUqXjhhRcqHCAREVknkxLMzZs3KzkMIiKqbvioGCIikkSFE0xKSgp2796Nn376Cbt370ZKSkplxAUA+PTTTyGTyfDOO+9UWp1ERFQ1TOoiA4Dr169j0qRJOHLkSIl5PXr0wLJlyxAUFGRyYOfOncOKFSvw0ksvmVwHERGZj0kJJjk5GR07dkRaWhoaNWqEzp07o3bt2rhz5w6OHz+OQ4cOoVOnTjh79iz8/PyMrj8rKwtvvPEGvv32W8ydO9eUEImIyMxMSjBRUVFIS0vDsmXLMHHixBJXlK1YsQKTJk3Cxx9/jG+//dbo+qdMmYKXX34ZPXv2LDfB5ObmIjc3V/terVYbvT4qX3p6OjIzM6t8vZou18rsejWGUqmEh4dHla83NzcXqampVb7eonx8fKBQKMwag7G43SyLSQlm//79CA0NxZtvvql3/sSJE7Fnzx7s3bvX6LrXr1+P8+fP49y5cwaVj46ORlRUlNHrIcOlp6fj/ffeQ96TJ2aLYdmyZWZZr9zeHp8vWFDlSSY1NRWzZs2q0nUWN2/ePNSvX9+sMRiL282ymJRg0tLS0KRJkzLLNGnSBPv27TOq3uTkZLz99ts4ePAgHBwcDFpm5syZmD59uva9Wq02qVuOSpeZmYm8J0/wj2A3eD1n8rCd1bn7KB9rrzxAZmZmlScYHx8fzJs3z+TlU1JSsGzZMkyePBm+vr4mx2BtKrLdKmObaWKgp0w6W3h6euLSpUtllrl06RI8PT2Nqjc+Ph5paWlo0aKFdlpBQQGOHz+OJUuWIDc3F7a2tjrLKBQKNkeriNdzdvBzkps7jGeCQqGolG/Bvr6+z9S36crYbs/aNpOSSZcp9+nTBzt37sT333+vd/7KlSvx888/o2/fvkbV26NHD/zxxx9ISEjQvlq1aoU33ngDCQkJJZILERFZLpNaMBEREfj5558xYcIELF68GF26dIGXlxfu3r2L48eP4+LFi/Dw8EBERIRR9SqVyhJdbzVq1IC7u3u5XXJERGRZTEowdevWRVxcHCZOnIjY2FhcvHhRZ363bt2wfPlyjoUQET3DTB6xbdCgAY4cOYLk5GQkJCRArVbD2dkZzZo1q9TEUtbPMxMRkeWq8CVBfn5+bKkQEVEJRg3yr1u3DkuXLsWTMu6HyMvLw9KlSxETE1Ph4IiIyHoZnGDOnj2LUaNG4a+//oK9vX2p5eRyOVJSUjBy5EjEx8dXSpBERGR9DE4wK1euRI0aNTBz5sxyy86cORNOTk4mPSaGiIiqB4MTzPHjx9GjRw84OzuXW1apVKJHjx4coCcieoYZnGBu376Nhg0bGlxxgwYNkJycbFJQRERk/QxOMIWFhUZVXPwJy0RE9Gwx+DJlLy8vXL161eCKr169Ci8vL5OCkhofPU9EJD2DE0z79u3x888/Iz09vdyT1L1793DgwAG89tprFY2v0qWnp+O999/Hk7w8s8VgrkfP28vlWPD550wyRFQlDE4w48aNw/r16zFy5Ehs27at1Mfp5+bmIjw8HI8fP8bYsWMrLdDKkpmZiSd5eXANeQl2LjXMHU6VyVdlIyPuglkePU9EzyaDE0yPHj0wfPhwbNiwAS1atMD777+Pbt26oU6dOgCedvscPnwYCxYswJUrV/D666+je/fukgVeUXYuNWDv7mLuMIiIqi2jHhWzatUqyGQyrF+/HuPHj9dbRgiBESNGlPoofyIiejYY9agYBwcHxMTE4MiRIxgxYgT8/f21P/jl7++PsLAwHDlyBOvWrTP4FymJiKh6Mulhl127dkXXrl0rORQiIqpOTPpFSyIiovIwwRARkSSYYIiISBJMMEREJAkmGCIikoTFJZjly5fjpZdegrOzM5ydndG+fXvs3bvX3GEREZGRLC7B1KlTB59++ini4+Px66+/onv37hgwYAAuXrxo7tCIiMgIJt0HI6XQ0FCd9/PmzcPy5ctx+vRpvPDCC2aKioiIjGVSggkICCi3jI2NDZydnREcHIyBAwdi2LBhRq+noKAAmzZtQnZ2Ntq3b6+3TG5uLnJzc7Xv1Wq10eshw1x6kIO7j56YO4wqcz+noMJ18KchjHfjxg38/ffflRxR+e7duwcASEhIMMt2q127NgIDA6t8vVIyKcEUFhYiPz8fqampTyuxs4OHhwfS09ORn58PAPDx8UFaWhoSEhKwceNGfPfdd9i1axfkcnm59f/xxx9o3749cnJy4OTkhG3btqFx48Z6y0ZHRyMqKsqUj0EGUiqVsLGxwd5bz17ytrGxgVKpNGlZ/jSE8T8NkZ6ejoiICKN/4LAybdq0ySzrtbGxweLFi6vV085NSjAJCQno1asXGjVqhLlz56Jt27aQyWQQQuDMmTP46KOPoFKp8L///Q/p6el49913sWfPHixYsAAzZ84st/7g4GAkJCRApVJh8+bNCA8Px7Fjx/QmmZkzZ2L69Ona92q1Gn5+fqZ8LCqFh4cHoqKizPatctOmTRg6dCg8PT2rfP21a9c2+YDX/DREw6Y98ZxTzUqOzHI9ynqIq78fMumnITIzM1FYWIju/q1R08FJoggtz8OcLBy5da7a/ZyGSQnmgw8+QG5uLg4cOAAbm/+7TkAmk6Fdu3bYt28fmjdvjhkzZuDrr7/Gpk2b0LhxY6xfv96gBCOXyxEUFAQAaNmyJc6dO4cvvvgCK1asKFFW87BNklZgYKBZmu9JSUnYtGkTmjVrhvr161f5+ivDc0414eRS9cnRmjV084OP07OzzVKz7uHIrXPmDqPSmXQV2Y4dO9C/f3+d5FKUra0t+vfvjx07dgB4+hTm7t274/r16yYFWVhYqDPOQkREls+kFoxarS53MF2lUkGlUmnfG9rsmzlzJvr164e6desiMzMTMTExiI2Nxf79+00JlYiIzMSkFkzjxo3x008/ITExUe/8xMRErF+/XmfM5Pbt2wb1oaelpWHUqFEIDg5Gjx49cO7cOezfvx+9evUyJVQiIjITk1owH374IYYMGYJmzZrhn//8J0JCQlCrVi2kpaUhLi4O33//PbKysvDhhx8CAPLy8nDgwAH07t273Lr5S5hERNWDSQlm0KBB+O677/DOO+9g8eLF+OKLL7TzhBBwcnLCihUrMGjQIADAo0eP8P333/NGSSKiZ4jJd/KPHTsWgwcPxo4dO/D7779DrVbD2dkZTZs2xYABA+Di4qIt6+rqigEDBlRKwEREZB0q9KgYFxcXjBo1qrJiISKiasTiHnZJRETVg8ktmLy8PGzfvh3nzp1DRkYGCgpKPrdJJpNx0J6I6BllUoK5desWevXqhRs3bkAIUWo5JhgiomeXSQnm3XffxfXr1zFy5EiMHTsWderUgZ2dxT35n4iIzMikrHDkyBH06NEDP/zwQ2XHQ0RE1YRJg/yFhYVo3rx5ZcdCRETViEkJpm3btvjzzz8rOxYiIqpGTEown376KY4cOYLNmzdXdjxERFRNmDQGs3v3bnTr1g3Dhw9Hly5d0KJFCzg7O5coJ5PJ8NFHH1U4SCIisj4mJZjIyEjt/2NjYxEbG6u3HBMMEdGzy6QEc/To0cqOg4iIqhmTEkyXLl0qOw4iIqpm+CwyIiKShEEtmNu3bwMAfH19YWtrq31viLp165oWGRERWTWDEky9evUgk8nw559/omHDhtr35ZHJZMjPz69wkEREZH0MSjCjRo2CTCbT/oiY5j0REVFpDEowq1evLvN9ZYqOjsbWrVtx+fJlODo6okOHDvjPf/6D4OBgydZJRESVz+IG+Y8dO4YpU6bg9OnTOHjwIJ48eYLevXsjOzvb3KEREZERJHvGflJSEqKiooxu7ezbt0/n/erVq1GrVi3Ex8ejc+fOlRghERFJqdITzO3bt/HJJ59gzZo1yM/Pr3B3mkqlAgC4ubnpnZ+bm4vc3Fzte7VabVC9+aqsCsVlbcz5eXNzc5GammrSsikpKTr/msrHxwcKhaJCdZjqQdotPMp6aJZ1m0POI8OOwbLce5Rh0nJPCvORkZNZ4fVXhKuDEvY2xp1aTf28ls6orXDixAl89NFHiI+Ph52dHTp16oTPPvsMwcHBePToEWbPno1ly5YhLy8PPj4+mDlzZoWCKywsxDvvvIOQkBA0adJEb5no6GhERUUZXXdG3B8Vio0Ml5qailmzZlWojmXLllVo+Xnz5qF+/foVqsNYSqUSNjY2uH3tbJWu1xLY2NhAqVQavZxSqYTcXo4tV45IEJVlk9vLTdpmlkwmyvrN4yLi4+MREhKCvLw8nem1a9fGL7/8gldffRWXLl2Cj48PPvjgA0yYMKHC3xgnTZqEvXv34sSJE6hTp47eMvpaMH5+flCpVHofwJmUlIRZs2bBNeRF2Lk4VSg+a5KvykJG3B9mOdFWpAVTWczVgrlx4wb+/vvvKl/vvXv3sGnTJgwdOhSenp5Vvv7atWsjMDDQpGXT09ORmWlaKyQvLw/37t0zadnK4unpCblcbvRySqUSHh4eeuep1Wq4uLiUel6zVAa3YD777DPk5eUhOjoa48aNAwB8++23mDVrFjp16oS7d+9i9uzZ+PDDD+Hg4FDhwKZOnYpdu3bh+PHjpSYXAFAoFCadOOxcnGDv7lKREMlACoWiypOapQgMDDT5RFsRSUlJ2LRpE5o1a2Z1297Dw6PUE60heMWp5TA4wcTFxaF79+744IMPtNNmzpyJQ4cOITY2Fv/9738xffr0CgckhMC0adOwbds2xMbGWt3BQURETxl8mXJaWhpatmxZYrpmWnh4eKUENGXKFKxduxYxMTFQKpW4c+cO7ty5g8ePH1dK/UREVDUMTjD5+fmoUaNGiemaae7u7pUS0PLly6FSqdC1a1fUrl1b+9qwYUOl1E9ERFVDsvtgTGXgNQdERGThjEowa9euxenTp3WmXb9+HQDQv3//EuVlMhl2795dgfCIiMhaGZVgrl+/rk0oxRW/Ax8AH4hJRPQMMzjBJCUlSRkHERFVMwYnGH9/fynjICKiasbinqZMRETVAxMMERFJggmGiIgkwQRDRESSYIIhIiJJMMEQEZEkmGCIiEgSTDBERCQJJhgiIpIEEwwREUmCCYaIiCTBBENERJJggiEiIkkwwRARkSQs7ieTiTTCwsJKTIuJiTFDJERkCotrwRw/fhyhoaHw8fGBTCbD9u3bzR0SmYG+5FLWdCKyPBaXYLKzs9G0aVMsXbrU3KGQmZSXRJhkiKyDxXWR9evXD/369TN3GGQmxZNH0S6xovPCwsLYXUZk4SwuwRgrNzcXubm52vdqtdqg5fJV2UavSxQUoCDrsdHLVSZbJ0fIbG2NXs6Uz2tuxRNITEzMM9N6yc3NRWpqqsnLp6Sk6PxrCh8fHygUCpOXJ7L6BBMdHY2oqCiDyyuVStjL5ciIuyBhVJbJXi6HUqk0dxhkgNTUVMyaNavC9SxbtszkZefNm4f69etXOAZ6dll9gpk5cyamT5+ufa9Wq+Hn51dqeQ8PDyz4/HNkZmYava68vDzcu3fPpDgri6enJ+RyuUnLKpVKeHh4VHJEJAUfHx/MmzfP7DEQVYTVJxiFQmF0M97Dw8PkE21wcLBJy5Hxio+zPCvdY8DT/ZqtB7J2Vp9gqHopPs5SWlLhAD+R5bO4y5SzsrKQkJCAhIQEAEBSUhISEhJw+/Zt8wZGVaa85MHkQmQdZEIIYe4gioqNjUW3bt1KTA8PD8fq1avLXV6tVsPFxQUqlQrOzs4SREhVhXfyEz1lrec1i0swFWWtfwgiotJY63nN4rrIiIioemCCISIiSTDBEBGRJJhgiIhIEkwwREQkCSYYIiKSBBMMERFJggmGiIgkwQRDRESSYIIhIiJJMMEQEZEkmGCIiEgSTDBERCQJJhgiIpIEEwwREUmCCYaIiCTBBENERJJggiEiIknYmTsAotJkZWUhKioKGRkZcHV1RUREBJycnMwdFhEZyGJbMEuXLkW9evXg4OCAtm3b4uzZs+YOiarQpEmTMGHCBKSkpCA7OxspKSmYMGECJk2aZO7QiMhAFplgNmzYgOnTpyMiIgLnz59H06ZN0adPH6SlpZk7NKoCkyZNgkqlAgAEBgZi5syZCAwMBACoVComGSIrYZFdZAsXLsT48eMxZswYAMDXX3+N3bt3Y+XKlZgxY4aZoyMpZWVlaZPLN998o+0Se/HFF5GVlYUJEyZApVIhKyuL3WVEFs7iWjB5eXmIj49Hz549tdNsbGzQs2dPnDp1qkT53NxcqNVqnRdZr6ioKABPWy7FE4iTkxMCAgJ0yhGR5bK4BJOeno6CggJ4eXnpTPfy8sKdO3dKlI+OjoaLi4v25efnV1WhkgQyMjIAAMOGDdM7f8iQITrliMhyWVyCMdbMmTOhUqm0r+TkZHOHRBXg6uoKANi4caPe+Zs3b9YpR0SWy+ISjIeHB2xtbXH37l2d6Xfv3oW3t3eJ8gqFAs7Ozjovsl4REREAgBs3biArK0tnXlZWFhITE3XKEZHlsrhBfrlcjpYtW+Lw4cN47bXXAACFhYU4fPgwpk6dat7gSHJOTk5wcXGBSqXChAkTEBAQgCFDhmDz5s3a5OLi4sIBfiIrIBNCCHMHUdyGDRsQHh6OFStWoE2bNli8eDE2btyIy5cvlxibKU6tVmtPUGzNWK+ilyoX5eLiguXLl5shIiLzsdbzmsW1YABg+PDhuHfvHubMmYM7d+6gWbNm2LdvX7nJhaqP5cuX805+IitnkS2YirDWTE9EVBprPa9Z3CA/ERFVD0wwREQkCSYYIiKShEUO8leEZkiJj4whoupCcz6ztiHzapdgMjMzAYCPjCGiaiczMxMuLi7mDsNg1e4qssLCQqSmpkKpVEImk5k7HB1qtRp+fn5ITk62qitBzInbzDTcbsaz5G0mhEBmZiZ8fHxgY2M9IxvVrgVjY2ODOnXqmDuMMvGRNsbjNjMNt5vxLHWbWVPLRcN6UiEREVkVJhgiIpIEE0wVUigUiIiIgEKhMHcoVoPbzDTcbsbjNqt81W6Qn4iILANbMEREJAkmGCIikgQTDBERSYIJhoiIJMEEU4W2bt2K3r17w93dHTKZDAkJCeYOyeItXboU9erVg4ODA9q2bYuzZ8+aOySLdvz4cYSGhsLHxwcymQzbt283d0gWLzo6Gq1bt4ZSqUStWrXw2muv4cqVK+YOq1pggqlC2dnZ6NixI/7zn/+YOxSrsGHDBkyfPh0RERE4f/48mjZtij59+iAtLc3coVms7OxsNG3aFEuXLjV3KFbj2LFjmDJlCk6fPo2DBw/iyZMn6N27N7Kzs80dmtXjZcpmcPPmTdSvXx+//fYbmjVrZu5wLFbbtm3RunVrLFmyBMDT58z5+flh2rRpmDFjhpmjs3wymQzbtm3Da6+9Zu5QrMq9e/dQq1YtHDt2DJ07dzZ3OFaNLRiySHl5eYiPj0fPnj2102xsbNCzZ0+cOnXKjJFRdadSqQAAbm5uZo7E+jHBkEVKT09HQUEBvLy8dKZ7eXnhzp07ZoqKqrvCwkK88847CAkJQZMmTcwdjtVjgpHIunXr4OTkpH398ssv5g6JiMoxZcoU/O9//8P69evNHUq1UO0e128pXn31VbRt21b73tfX14zRWB8PDw/Y2tri7t27OtPv3r0Lb29vM0VF1dnUqVOxa9cuHD9+3OJ/8sNasAUjEaVSiaCgIO3L0dHR3CFZFblcjpYtW+Lw4cPaaYWFhTh8+DDat29vxsiouhFCYOrUqdi2bRuOHDmC+vXrmzukaoMtmCr04MED3L59G6mpqQCgvdbe29ub38r1mD59OsLDw9GqVSu0adMGixcvRnZ2NsaMGWPu0CxWVlYWrl+/rn2flJSEhIQEuLm5oW7dumaMzHJNmTIFMTEx2LFjB5RKpXaMz8XFhV8MK0pQlVm1apUAUOIVERFh7tAs1ldffSXq1q0r5HK5aNOmjTh9+rS5Q7JoR48e1buPhYeHmzs0i6VvewEQq1atMndoVo/3wRARkSQ4BkNERJJggiEiIkkwwRARkSSYYIiISBJMMEREJAkmGCIikgQTDBERSYIJhoiIJMEEQ8+UyMhIyGQyxMbGmjsUomqPCYaqhfj4eIwbNw4NGjRAjRo14OjoiMDAQIwcORIHDx40W1xdu3aFTCYz2/qJzIkJhqxaYWEhpk+fjlatWmHNmjUICAjAm2++ibfffhstW7bE7t270bt3b3zyySfmDpXomcOnKZNVmz17NhYtWoRmzZph8+bNCAwM1Jn/+PFjLFmyBPfv3zdThETPLrZgyGpdv34dn332Gdzd3bFv374SyQUAHB0d8a9//QtRUVGl1hMbGwuZTIbIyMgS827evAmZTIbRo0frTL927RrGjBmD+vXrQ6FQwM3NDU2bNsU777wDzfNjZTIZjh07pv2/5lW8rgsXLuD1119H7dq1IZfL4e/vj2nTppVIikVj+fPPPzFw4EC4u7tDJpPh5s2b5W8woirGFgxZrdWrV6OgoAATJ06El5dXmWUVCkWlrTc1NRVt2rRBdnY2Xn75ZQwfPhzZ2dm4du0ali1bhs8//xx2dnaIiIjA6tWrcevWLURERGiXb9asmfb/O3fuxLBhw2BjY4MBAwbAz88Ply5dwpIlS7B//36cOXMGNWvW1Fn/9evX0a5dO7z44osYPXo07t+/D7lcXmmfj6iyMMGQ1YqLiwMAdO/evUrXu2XLFmRkZGDx4sV4++23deY9ePAAdnZPD6vIyEjExsbi1q1beltH9+/fx8iRI+Hh4YG4uDj4+/tr561fvx4jRozAnDlz8NVXX+ksFxcXhzlz5pTZKiOyBOwiI6ul+eVBc/1+ur5fO3RzczN4+TVr1kCtViM6OlonuQDA66+/jhYtWmD9+vUllvP29sasWbOMD5ioirEFQ2Sk0NBQzJw5E1OmTMHhw4fRt29fdOnSBQEBAUbVc/r0aQDAmTNncOPGjRLzc3JykJ6ejvT0dHh4eGinN23alF1iZBWYYMhqeXt74/Lly0hJSUFwcHCVrbdevXo4ffo0IiMjsWfPHmzcuBEA0KhRI3z88ccYOnSoQfU8ePAAALB06dIyy2VnZ+skmPLGm4gsBbvIyGqFhIQAAA4fPlyhemxsnh4G+fn5JeapVCq9yzRp0gSbN2/GgwcPcOrUKcyZMwd37tzB8OHDtWND5XF2dgYA/PHHHxBClPoq3n3GGzfJWjDBkNUaPXo0bG1t8c033+DevXtlls3NzS11nuYqrZSUlBLzfvvttzLrtbe3R7t27RAVFYUvv/wSQgjs2rVLO9/W1hYAUFBQUGLZtm3bAgBOnTpV5jqIrBUTDFmtoKAg/Pvf/0Z6ejr69euHpKSkEmVycnKwcOFCvVdxaQQHB0OpVGLnzp3abisAuHv3LubOnVuifHx8PNRqdYnpd+/eBQA4ODhop2kG/ZOTk0uUHzNmDJRKJWbNmoWLFy+WmP/o0SPtOA2RNeIYDFm1uXPnIicnB4sWLUJwcDC6d++OJk2awN7eHklJSTh06BDu37+vN1FoyOVyTJs2DfPnz0eLFi0wYMAAZGZm4ueff0aXLl1KDMD/+OOPWLFiBTp37ozAwEA4Ozvj0qVL2LNnD9zc3DBmzBht2e7du2Pz5s0YPHgw+vXrBwcHBzRt2hShoaHw9PTETz/9hKFDh6Jp06bo27cvGjVqhNzcXNy8eRPHjh1Dhw4dsG/fPsm2H5GkBFE1cO7cOTF27FgRFBQkHB0dhUKhEPXq1RNhYWHi4MGD2nIRERECgDh69KjO8gUFBSIyMlL4+fkJuVwuGjZsKL744guRmJgoAIjw8HBt2dOnT4uJEyeKJk2aCFdXV+Ho6CgaNGggpk6dKm7duqVT75MnT8S///1vUbduXWFnZ1eiLiGEuHz5shg3bpzw9/cXcrlc1KxZU7z44ovirbfeEmfPntWWS0pK0rs8kaWSCfH/n2tBRERUiTgGQ0REkmCCISIiSTDBEBGRJJhgiIhIEkwwREQkCSYYIiKSBBMMERFJggmGiIgkwQRDRESSYIIhIiJJMMEQEZEkmGCIiEgS/w8QzXrpAq1QvQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ring count t-test: t = -32.745, p = 8.467204378555626e-177\n", + "Rare element chi-square test: chi2 = 13.761, p = 0.0032495757117942474\n" + ] + } + ], + "source": [ + "# ring_count, rare_element included\n", + "\n", + "plt.figure(figsize=(4, 3))\n", + "sns.boxplot(data=ccs_df, x='cluster', y='ring_count', palette='Set2')\n", + "plt.title('Ring Count Distribution by Cluster')\n", + "plt.ylabel('Ring Count')\n", + "plt.xlabel('Cluster')\n", + "plt.show()\n", + "\n", + "# Cluster 0 (bottom cluster) seems to have more rings compared to cluster 1 (upper cluster). This makes sense since molecules \n", + "# with more rings tend to be more compact\n", + "\n", + "# print(upper_cluster['rare_element_included'].mean()) \n", + "# print(bottom_cluster['rare_element_included'].mean())\n", + "\n", + "# 27.6% of the molecules in upper cluster include rare elements compared to 32% in bottom cluster.\n", + "\n", + "ring_upper = upper_cluster['ring_count'].dropna()\n", + "ring_bottom = bottom_cluster['ring_count'].dropna()\n", + "\n", + "# Perform t-test for ring count\n", + "t_stat, p_value = ttest_ind(ring_upper, ring_bottom, equal_var=False)\n", + "\n", + "print(f\"Ring count t-test: t = {t_stat:.3f}, p = {p_value}\") # ~0\n", + "\n", + "# Perform chi-square test for rare element existence\n", + "# Build contingency table\n", + "table = pd.crosstab(ccs_df['cluster'], ccs_df['rare_element_included'])\n", + "\n", + "chi2, p, dof, expected = chi2_contingency(table)\n", + "\n", + "print(f\"Rare element chi-square test: chi2 = {chi2:.3f}, p = {p}\") # 0.003\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10 3\n", + "17 4\n", + "66 3\n", + "68 2\n", + "89 2\n", + " ..\n", + "44114 3\n", + "44167 4\n", + "44297 4\n", + "44342 4\n", + "44395 2\n", + "Name: ring_count, Length: 1344, dtype: int64" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring_upper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Prediction
" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "fiora = SimulationFramework(None, dev=dev, with_RT=True, with_CCS=True)\n", + "fiora.pred_all(ccs_df, base_model)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "ccs_df['CCS_pred'] = ccs_df[\"Metabolite\"].apply(lambda x: x.CCS_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 tensor(191.9466, device='cuda:0')\n", + "1 tensor(191.9459, device='cuda:0')\n", + "2 tensor(208.1397, device='cuda:0')\n", + "3 tensor(213.6994, device='cuda:0')\n", + "4 tensor(171.2999, device='cuda:0')\n", + " ... \n", + "44402 tensor(176.8240, device='cuda:0')\n", + "44403 tensor(176.7797, device='cuda:0')\n", + "44404 tensor(202.7449, device='cuda:0')\n", + "44405 tensor(192.2687, device='cuda:0')\n", + "44406 tensor(188.1292, device='cuda:0')\n", + "Name: CCS_pred, Length: 44407, dtype: object" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccs_df['CCS_pred']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Measure MSE of predicted and experimental values" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "253.72799306954525\n" + ] + } + ], + "source": [ + "mse = 0\n", + "\n", + "mse = ((ccs_df['CCS_AVG'] - ccs_df['CCS_pred'].apply(lambda x: x.item()))**2).mean()\n", + "print(mse)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot Experimental CCS vs. Predicted CCS" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(ccs_df['CCS_AVG'], ccs_df['CCS_pred'].apply(lambda x: x.item()), alpha=0.7, label=\"Data points\") #alpha:transparency\n", + "plt.plot([ccs_df['CCS_AVG'].min(), ccs_df['CCS_AVG'].max()],\n", + " [ccs_df['CCS_AVG'].min(), ccs_df['CCS_AVG'].max()],\n", + " color='red', linestyle='--', label=\"Ideal Prediction\")\n", + "\n", + "plt.xlabel(\"Experimental CCS (CCS_AVG)\")\n", + "plt.ylabel(\"Predicted CCS (CCS_pred)\")\n", + "plt.title(\"Comparison of Experimental and Predicted CCS\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "residuals = ccs_df['CCS_pred'].apply(lambda x: x.item()) - ccs_df['CCS_AVG']\n", + "plt.scatter(ccs_df['CCS_AVG'], residuals, alpha=0.7)\n", + "plt.axhline(0, color='red', linestyle='--', label=\"Zero Error Line\")\n", + "\n", + "plt.xlabel(\"Experimental CCS (CCS_AVG)\")\n", + "plt.ylabel(\"Residuals (Predicted - Experimental)\")\n", + "plt.title(\"Residuals Plot\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAIqCAYAAADM2TdPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmNklEQVR4nO3deZyN5f/H8ffsC7NgNsMYg7LLzlCDaEZU1kqphmyJ+kobspdEJd8UUqF+0aJV6YvJniZFVJZkGRTGztAw6/X7o++cr9MsZpwzZrhfz8fDo+a+r3Pdn/s698y85z7XuY6LMcYIAAAAsDDXki4AAAAAKGmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgBFVrVqVbm4uNj98/LyUuXKldWlSxd99dVXJVbb6tWr5eLiorZt2xb5sTnnUpL27dsnFxcXVa1atdiPcfE/Nzc3BQYGqlq1arr99tv1/PPPa//+/QX2UxrGK0dB41aa6syR8z20b9++ki4FwH8RigFcttatWys+Pl7x8fHq1KmT3N3dtXjxYt1+++0aPnx4SZeHQujRo4fi4+N1//33q3379goLC9M333yjZ555RlFRUXrooYd07ty5Yjv+lfgj4Err06ePXFxcNH/+/JIuBUARuJd0AQCuXv3791efPn1sX2dmZuqxxx7Ta6+9pldeeUX33HOPmjVrdkVrat68uXbs2CFfX98retyr1UsvvZQrkJ4/f17z5s3TiBEj9MYbb2j79u1KSEiQl5eXXbsdO3ZcwUoLVqlSJe3YsUMeHh4lXUqhrFixQhkZGapUqVJJlwLgv7hTDMBp3N3d9eKLL8rf31+S9OWXX17xGnx9fVWrVi1VqVLlih/7WuHj46OHH35Yq1evlre3t9atW6epU6fmalerVi3VqlWrBCrMzcPDQ7Vq1VL16tVLupRCqV69umrVqnXVhHjACgjFAJzK29tb1113nSTpyJEjebZZsWKFunfvrooVK8rT01MhISHq1q2bEhMT82y/a9cuPfjgg4qKipKXl5fKli2ryMhIde7cWfPmzbNre6k5xYmJibr11lsVGBiosmXLqmnTppo7d26+51OYl/fzmx+6fft2jRs3Tq1bt1alSpXk6empChUqqEOHDvroo4/y7S8/RRkHZ2jcuLEeeeQRSdIrr7yizMxMu/35zdU9fPiw/vWvf+n666+Xt7e3fH19FRERofbt2+ull16ytevTp4+ioqIkSfv37881zznH+PHj5eLiovHjx+vAgQPq16+fIiIi5OHhYXulorDTMN588001adJEZcqUUWBgoDp16qTvv/8+z7aXmovctm1bubi4aPXq1XY1vPPOO5Kkvn372p3P+PHjbY8taE5xamqqXnjhBTVu3Fh+fn7y9fVV3bp1NXr0aJ06dSpX+4vP3RijOXPm2M4xICBAsbGx+X5vAfgfpk8AcLqUlBRJUmhoaK59TzzxhF5++WW5urqqadOmuummm3TgwAF98cUX+vLLL/Xmm2+qb9++tvZbt25V69atlZKSopo1a+q2226Tm5ub/vzzT61du1YHDx60a1+QRYsW6Z577lFWVpbq1aun+vXr648//lD//v21bds255z8RaZNm6a3335btWrVUv369RUYGKgDBw5o1apVWrFihb7//ntNmzatUH05cxyK4r777tOLL76oU6dOaePGjWrZsmWB7ZOTk9W0aVMdOnRIVapUUceOHeXt7a1Dhw5py5Yt2rRpk5544glJ0o033qhz587pk08+UZkyZdSzZ88C+961a5caNWokT09PtW7dWsYYBQUFFfpchg8frunTp6t169bq0qWLfv31V/3nP/9RQkKCPvroI3Xr1q3QfeWlbNmyio+P17fffqs9e/aodevWqlGjhm1/w4YNL9nHyZMn1b59e23ZskX+/v66+eab5eHhoTVr1mjSpElauHChVq5cmW/479u3rxYuXKibbrpJt912m7Zs2aKEhAStXbtWa9asUYsWLRw6R+CaZgCgiCIjI40kM2/evFz7tm/fbtzc3Iwk8+OPP9rtmzNnjpFkatSoYX7++We7fWvWrDF+fn7G09PT/P7777btffv2NZLMc889l+tYqampZs2aNXbbVq1aZSSZNm3a2G0/fPiw8fPzM5LMtGnT7PZ98803xtvb20gy//yxmJSUZCSZyMjI/IbDNh5JSUl221evXm327NmTq/1vv/1mKleubCSZDRs2FOp4RR2HguQcI6+a/ykrK8t4enoaSeatt96y25fXeE2YMMFIMgMHDjTZ2dl2+9LT080333yTZy0Fje+4ceNsx7rvvvvMhQsX8j2nvPrJeayPj49ZsWKF3b6pU6caSSYgIMAcOXLkkud3sTZt2hhJZtWqVXbb4+Pj8/3+yJHfNXP33XcbSaZFixbm+PHjtu1nz541t956q5FkWrVqlee555z/zp07bfsyMzPNgw8+aCSZ2NjYfOsBYAzTJwA4xZkzZ7R8+XJ1795dWVlZGj16tJo2bWrbn52dbXv5+IMPPlCDBg3sHh8TE6MxY8YoPT1db7zxhm17zhSMTp065Tqmj4+PYmJiClXf22+/rbNnz6ply5Z67LHH7Pa1b99egwYNKlQ/RdGmTRtVq1Yt1/aaNWtqzJgxkqSPP/64UH05axyKytXVVeXLl5cknThx4pLtc+rs2LFjrqkHHh4eat++/WXXUr58eb322mu53vBXWIMGDdLNN99st+3JJ59U06ZNdebMGb311luXXZszHDhwQIsWLZKLi4vmzJmjChUq2PaVLVtWb775pry9vfXdd9/pu+++y7OPGTNm6Prrr7d97ebmpkmTJkmS1qxZo4yMjOI9CeAqRigGcNkunjMZGBiouLg47dq1S++9956effZZu7abN2/WoUOHVL16dTVp0iTP/nLmAV/8C7958+aSpMGDB2vZsmW6cOHCZdWaM++zd+/eee6Pj4+/rH4v5dy5c1q0aJFGjRqlgQMHqk+fPurTp48++eQTSdLOnTsL1Y+zxuFyZGdnS1Kh1vrNqXPEiBH69NNPnbqcW4cOHRQQEHDZj8/vOX7ggQck/e8aKSlr165Vdna2GjVqlOuPRunvFTbi4uIkSatWrcq1393dXR07dsy1PSwsTOXKlVNaWlqh/rABrIo5xQAu28VzJo8dO6Z169bp7NmzGjx4sK677jpbQJKkvXv3SpL27NlzyXB17Ngx2/8/+eST+vbbb/XNN9+oY8eO8vDw0A033KCYmBj16tWr0Eu+/fnnn5Jke2PXP+W33RFffvml+vbtW2AQyZl/fSnOGoeiysrK0unTpyXJdse4IPfff78SEhK0YMEC9ejRQ25ubqpTp45uvPFG9ezZM9ed2qJwdC3jSz33OddISTl48KCkgq/FnNU1ctperGLFivmuZuHv769Tp05d0T+mgKsNoRjAZfvnOsVnzpxRt27dtGrVKt11113avn27bb3gnLuNYWFhtrtd+bn4zVO+vr5KSEjQjz/+qKVLl9peOt64caOmTZumhx9+WK+//rrzT64Ics7tYgcPHtTdd9+t8+fP66mnnlLv3r1VtWpVlS1bVq6urlq+fLni4uJkjCnUMUpqHLZu3ar09HRJUv369S/Z3tXVVe+9955GjRqlJUuWaP369Vq/fr1mzZqlWbNm6fbbb9dnn30mNze3Itfi4+NT5McURWGfixx5Pe8lydWVF38BRxCKAThNQECAPvzwQ9WqVUv79+/XtGnTNHr0aElSRESEJKlChQqX9UlfzZo1s90NzczM1Oeff64HHnhAM2fOVM+ePdWuXbsCH1+pUiX99ttv+X6sbn7bPT09JUlnz57Nc39GRoYOHz6ca/uXX36p8+fPq1u3bpoyZUqu/bt27Sqw3vw4Og5F9d5770n6+3nLb9pLXurUqaM6deroySeflDFGK1eu1L333qsvv/xS7777brGslHEpSUlJea4AkfPcV65c2W67h4eHMjIydPbsWfn5+eV63KU+Bruocj7II+dVlbzk7ONDPwDn489KAE4VHBxsC8IvvfSS7aX3Zs2aKSgoSNu3b3d4+TN3d3f17NnTdsd5y5Ytl3xMmzZtJEkLFizIc/+7776b5/bg4GB5enrq5MmTOnr0aK79y5Yty7V+r/T30lqSFBkZmWufMUYLFy68ZM2XcjnjUBQ//fSTXnvtNUl/L2d2OXd3pb/nIrdv31733nuvJPs6c/7oyGsMne3//u//Ctz+z7Wtc4JnXp/c98svv+iPP/7Is7/LPaeYmBi5urpqy5Yt+vnnn3PtP3z4sJYuXSpJTv/jBwChGEAxePjhh1WlShWdOXNGL7/8sqS/77qNGzdOxhh169ZN3377ba7HZWVlaeXKlXYfpjBz5sw834yWnJysjRs3Sso7eP5Tv379VLZsWSUmJurVV1+127d69WrNnj07z8d5eHjYVnYYPXq03UvmP//8s4YOHZrn42rXri3p79UlLr6TnJWVpbFjx+a7ekB+nDUOhXH+/HnNmjVLbdu21YULF9S2bVvb2sKX8u6772rTpk25tp89e9b2RraL68z5oyM5Odn2h0RxmTVrVq43073yyiv64Ycf5Ofnp379+tnt69ChgyRpwoQJSktLs23ft2+f4uPj851ukXPHuah//FWpUkV33nmnjDEaNGiQ3Vz0v/76SwMHDtSFCxfUqlUrtWrVqkh9AyiEElwODsBVqqB1inPMnTvXSDJ+fn7mxIkTtu1PPvmkbU3VunXrmi5duphevXqZtm3bmsDAQCPJzJo1y9b+hhtuMJJMVFSUuf32203v3r1NbGys8fHxMZLMzTffbDIyMmzt81un2Bhj3n//fdsayvXr1zf33HOPiYmJMS4uLuaxxx7Ld13a77//3rZW7/XXX2969uxpoqOjjYeHh4mPj89zzdmMjAzTpEkTI8mULVvWdO7c2dx1110mMjLSeHh4mKeffjrPOvNbb7eo41CQi9e17dGjh4mPjzfx8fGmZ8+eplWrVrY1m11dXc1DDz1kzp07l2c/eY1Xly5djCQTHh5uOnXqZHr37m06depkAgICjCRTr149k5KSYveYnj17GkkmIiLC3HPPPaZfv36mX79+tv056xSPGzfukudU0DrFw4YNMy4uLiYmJsbcc889pn79+kaScXNzM4sWLcr1uL1799quySpVqpgePXqYmJgY4+PjYzp06GBatWqV5zrFP//8s3F1dTWurq6mQ4cOpm/fvqZfv37miy++sLXJb53i48eP257rgIAA07VrV9OzZ08THBxse/7/+RhH1tIG8D+EYgBFVphQnJmZaerUqWMkmREjRtjtW79+vendu7eJjIw0Xl5exs/Pz1x//fWma9eu5q233jInT560tf3qq6/M4MGDTaNGjUxwcLDx9PQ0lStXNm3btjXvvPOOSU9Pt+u7oFBsjDHr1q0zcXFxxt/f3/j6+ppGjRqZN954wxhT8Ic1JCYmmtjYWOPv7298fHzMDTfcYGbOnGmys7PzDRxnz541o0aNMjVr1jTe3t4mJCTEdO3a1WzcuDHfOvMLOEUdh4JcHIpz/rm6uhp/f39TtWpVc9ttt5lJkyaZ/fv3F9hPXuO1du1aM2zYMNO8eXMTFhZmPD09TVhYmImOjjYzZszIM2CfOHHCDBo0yFSpUsV4eHjk6tdZodgYY2bNmmUaNmxofHx8jL+/v+nYsaNZv359vv1u377ddO/e3ZQrV854eXmZmjVrmueee86kp6fn++Edxhjz2WefmdatWxs/Pz/j4uKSq/6CQupff/1lJk+ebBo2bGh8fX2Nt7e3qV27thk1apTd90Zhzr0wxwPwNxdjivh2WwAAAOAaw5xiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJbnXtIFXK2ys7N16NAh+fn5ycXFpaTLAQAAwD8YY3T27FmFh4fL1bXge8GE4st06NAhRURElHQZAAAAuIQ//vjD9hHs+SEUXyY/Pz9Jfw+yv79/CVdz5WVkZGj58uWKjY2Vh4dHSZdzVWIMHcP4OY4xdBxj6BjGz3GMYcFSUlIUERFhy20FIRRfppwpE/7+/pYNxb6+vvL39+eb8DIxho5h/BzHGDqOMXQM4+c4xrBwCjPVlTfaAQAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA895IuAACAq9Xx48clSUlJSXJzc7vsfvz9/RUcHOyssgBcBkIxAACX4dixYxrw8CMa0Od+9R0yTOnpGZfdV3k/X7037y2CMVCCCMUAAFyGlJQUnTqXKkmKjBugjOzL6+evk0d0LPETpaSkEIqBEkQoBgDAQX5B4cp04G06x5xYC4DLwxvtAAAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWRygGAACA5RGKAQAAYHmEYgAAAFgeoRgAAACWV+pCcVZWlsaMGaOoqCj5+PioevXqevbZZ2WMsbUxxmjs2LGqWLGifHx81KFDB+3atcuun5MnT6p3797y9/dXYGCg+vXrp3Pnztm1+eWXX3TTTTfJ29tbERERmjp16hU5RwAAAJQupS4UT5kyRbNmzdJrr72mHTt2aMqUKZo6dapmzJhhazN16lS9+uqrmj17tjZs2KAyZcooLi5OFy5csLXp3bu3tm3bpoSEBH311Vdau3atBg4caNufkpKi2NhYRUZGatOmTXrxxRc1fvx4zZkz54qeLwAAAEqee0kX8E/fffedunTpos6dO0uSqlatqvfff18//PCDpL/vEk+fPl2jR49Wly5dJEnvvvuuQkND9fnnn6tXr17asWOHli5dqh9//FFNmzaVJM2YMUOdOnXSSy+9pPDwcC1YsEDp6emaO3euPD09VbduXW3ZskXTpk2zC88AAAC49pW6UNyqVSvNmTNHv//+u66//nr9/PPP+vbbbzVt2jRJUlJSkpKTk9WhQwfbYwICAtSiRQslJiaqV69eSkxMVGBgoC0QS1KHDh3k6uqqDRs2qFu3bkpMTFRMTIw8PT1tbeLi4jRlyhSdOnVK5cqVs6srLS1NaWlptq9TUlIkSRkZGcrIyCiWsSjNcs7ZiufuLIyhYxg/xzGGjsnKypKnh4ckyV3Zl92Ph6vk6emhrKwsyz0XXIOOYwwLVpRxKXWheMSIEUpJSVGtWrXk5uamrKwsTZo0Sb1795YkJScnS5JCQ0PtHhcaGmrbl5ycrJCQELv97u7uKl++vF2bqKioXH3k7PtnKJ48ebImTJiQq97ly5fL19f3ck/3qpeQkFDSJVz1GEPHMH6OYwwv37BBD0qSYssdvfxOyrlK1w3Sjh07tGPHDidVdnXhGnQcY5i31NTUQrctdaH4o48+0oIFC7Rw4ULblIZhw4YpPDxc8fHxJVbXyJEjNXz4cNvXKSkpioiIUGxsrPz9/UusrpKSkZGhhIQE3XLLLfL4750SFA1j6BjGz3FWHcPjx4/r7NmzDvfzxx9/aMKUV/T4kAFafipEmZf5Np2zxw9pz5cz9fzYEYqIiHC4Lj8/PwUFBTncz5Vg1WvQmRjDguW8sl8YpS4UP/nkkxoxYoR69eolSapfv77279+vyZMnKz4+XmFhYZKkI0eOqGLFirbHHTlyRA0bNpQkhYWF6ehR+7/aMzMzdfLkSdvjw8LCdOTIEbs2OV/ntLmYl5eXvLy8cm338PCw9EVo9fN3BsbQMYyf46w0hseOHVOfAQ/p5NnC3z3Kz4XzqTp+4qQkKVOulx2Kz6Wc0c6dv+mxZybk+XumqMr7+eq9eW8pODjY4b6uFCtdg8WFMcxbUcak1IXi1NRUubra/2Bxc3NTdvbf87WioqIUFhamFStW2EJwSkqKNmzYoMGDB0uSoqOjdfr0aW3atElNmjSRJK1cuVLZ2dlq0aKFrc0zzzyjjIwM24AlJCSoZs2auaZOAACuDSkpKTp5NlXB0T1UpnzopR9QgKN7turI8gUO15SRdl7ZLu4KatldFcIjHerrr5NHdCzxE6WkpFxVoRgoDUpdKL799ts1adIkValSRXXr1tXmzZs1bdo0Pfjg3/O2XFxcNGzYMD333HO67rrrFBUVpTFjxig8PFxdu3aVJNWuXVsdO3bUgAEDNHv2bGVkZGjo0KHq1auXwsPDJUn33nuvJkyYoH79+unpp5/W1q1b9e9//1uvvPJKSZ06AOAKKVM+VP4hlR3q49yJZCdV8zffcsEO1yRJx5xQC2BFpS4Uz5gxQ2PGjNHDDz+so0ePKjw8XIMGDdLYsWNtbZ566in99ddfGjhwoE6fPq0bb7xRS5culbe3t63NggULNHToULVv316urq7q0aOHXn31Vdv+gIAALV++XEOGDFGTJk0UFBSksWPHshwbAACABZW6UOzn56fp06dr+vTp+bZxcXHRxIkTNXHixHzblC9fXgsXLizwWA0aNNC6desut1QAAABcI0rdJ9oBAAAAVxqhGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeaUyFB88eFD33XefKlSoIB8fH9WvX18bN2607TfGaOzYsapYsaJ8fHzUoUMH7dq1y66PkydPqnfv3vL391dgYKD69eunc+fO2bX55ZdfdNNNN8nb21sRERGaOnXqFTk/AAAAlC6lLhSfOnVKrVu3loeHh/7zn/9o+/btevnll1WuXDlbm6lTp+rVV1/V7NmztWHDBpUpU0ZxcXG6cOGCrU3v3r21bds2JSQk6KuvvtLatWs1cOBA2/6UlBTFxsYqMjJSmzZt0osvvqjx48drzpw5V/R8AQAAUPLcS7qAf5oyZYoiIiI0b94827aoqCjb/xtjNH36dI0ePVpdunSRJL377rsKDQ3V559/rl69emnHjh1aunSpfvzxRzVt2lSSNGPGDHXq1EkvvfSSwsPDtWDBAqWnp2vu3Lny9PRU3bp1tWXLFk2bNs0uPAMAAODaV+pC8eLFixUXF6c777xTa9asUaVKlfTwww9rwIABkqSkpCQlJyerQ4cOtscEBASoRYsWSkxMVK9evZSYmKjAwEBbIJakDh06yNXVVRs2bFC3bt2UmJiomJgYeXp62trExcVpypQpOnXqlN2daUlKS0tTWlqa7euUlBRJUkZGhjIyMoplLEqznHO24rk7C2PoGMbPcVYcw6ysLHl6esjDVXJXtkN9ebi5yNvLS5JjfXm4ucjb28s5NblKnp4eysrKuiqeVyteg87GGBasKONS6kLx3r17NWvWLA0fPlyjRo3Sjz/+qEcffVSenp6Kj49XcnKyJCk0NNTucaGhobZ9ycnJCgkJsdvv7u6u8uXL27W5+A70xX0mJyfnCsWTJ0/WhAkTctW7fPly+fr6OnDGV7eEhISSLuGqxxg6hvFznNXG8Kmhg/77f8mOddSiotRioiQpttxRh/rp12KKc2oq5ypdN0g7duzQjh07HOvrCrLaNVgcGMO8paamFrptqQvF2dnZatq0qZ5//nlJUqNGjbR161bNnj1b8fHxJVbXyJEjNXz4cNvXKSkpioiIUGxsrPz9/UusrpKSkZGhhIQE3XLLLfLw8Cjpcq5KjKFjGD/HWXEMk5KS1HfIMEXGDZBfULhDfR3+fbO2fDpLM6ZM1PJTIcq8zLfpHP59s75/f7paPzhGIRE1HKrp7PFD2r/sTc17fXquGz+lkRWvQWdjDAuW88p+YZS6UFyxYkXVqVPHblvt2rX1ySefSJLCwsIkSUeOHFHFihVtbY4cOaKGDRva2hw9av9Xe2Zmpk6ePGl7fFhYmI4cOWLXJufrnDYX8/Lyktd/Xya7mIeHh6UvQqufvzMwho5h/BxnpTF0c3NTenqGMrJ12SE2R0aW0YX/TqvLlOtl95eRZXThQppzasqW0tMz5ObmdlU9p1a6BosLY5i3ooxJqVt9onXr1tq5c6fdtt9//12RkZGS/n7TXVhYmFasWGHbn5KSog0bNig6OlqSFB0drdOnT2vTpk22NitXrlR2drZatGhha7N27Vq7uSYJCQmqWbNmrqkTAAAAuLaVulD82GOP6fvvv9fzzz+v3bt3a+HChZozZ46GDBkiSXJxcdGwYcP03HPPafHixfr111/1wAMPKDw8XF27dpX0953ljh07asCAAfrhhx+0fv16DR06VL169VJ4+N8vl917773y9PRUv379tG3bNn344Yf697//bTdFAgAAANbg0PSJtLS0PKcUOKJZs2b67LPPNHLkSE2cOFFRUVGaPn26evfubWvz1FNP6a+//tLAgQN1+vRp3XjjjVq6dKm8vb1tbRYsWKChQ4eqffv2cnV1VY8ePfTqq6/a9gcEBGj58uUaMmSImjRpoqCgII0dO5bl2AAAACzIoVAcHh6u++67T/3791f9+vWdVZNuu+023Xbbbfnud3Fx0cSJEzVx4sR825QvX14LFy4s8DgNGjTQunXrLrtOAAAAXBscmj7h5+enGTNmqGHDhoqOjtbcuXOLtPQFAAAAUBo4FIqTkpL0n//8R927d9fmzZs1YMAAVaxYUQ899JA2btzorBoBAACAYuVQKHZxcVFcXJwWLVqkP//8U1OnTlWlSpU0Z84ctWjRQo0aNdKsWbOKtEYcAAAAcKU5bfWJoKAgPf7449q+fbvWrVun+Ph47d69W0OHDlV4eLj69u2rH374wVmHAwAAAJymWJZk8/Pzk6+vr9zd3WWMUVZWlt555x1FR0erc+fOuT5YAwAAAChJTgvF586d05w5c9S8eXM1atRIM2fO1PXXX6+3335bJ0+e1A8//KCePXvqP//5jwYNGnTpDgEAAIArxOGPef7+++/15ptvatGiRTp37pzKli2rgQMHatCgQbaPXZakpk2b6sMPP5Snp6cWL17s6GEBAAAAp3EoFNevX1/bt2+XMUaNGjXSoEGDdO+996ps2bL5PqZu3bpasGCBI4cFAAAAnMqhULx371717dtXgwYNUrNmzQr1mN69eys6OtqRwwIAAABO5VAoPnz4sPz9/Yv0mIiICEVERDhyWAAAAMCpHHqjXZkyZZSSkqLs7Ow892dnZyslJUVZWVmOHAYAAAAoVg6F4gkTJigkJEQnTpzIc/+JEycUGhqqSZMmOXIYAAAAoFg5FIq/+uortW/fXsHBwXnuDw4OVocOHfTFF184chgAAACgWDkUivfu3atatWoV2KZmzZpKSkpy5DAAAABAsXIoFGdkZMjVteAuXFxcdOHCBUcOAwAAABQrh0JxjRo1tHLlygLbrFy5UlFRUY4cBgAAAChWDoXi7t27a8uWLRo7dmyuFSaysrI0ZswYbdmyRXfeeadDRQIAAADFyaF1ih9//HF98MEHmjRpkj744AO1a9dOlSpV0sGDB7Vq1Srt2bNHtWvX1hNPPOGsegEAAACncygUly1bVmvXrtXgwYP12Wefaffu3bZ9rq6u6tmzp2bOnFngxz4DAAAAJc2hUCz9vezaxx9/rCNHjmjjxo06c+aMAgMD1bRpU4WEhDijRgAAAKBYORyKc4SGhqpz587O6g4AAAC4Yhx6ox0AAABwLXD4TvH27dv12muv6ccff9Tp06dzrUIh/b1W8Z49exw9FAAAAFAsHArFa9asUceOHZWWliZ3d3eFhobK3T13l8YYRw4DAAAAFCuHQvGIESOUmZmpt956S/Hx8XJzc3NWXQAA2Bw7dkwpKSkO97N//35lZmQ6oSIA1xqHQvHPP/+sXr166cEHH3RWPQAA2Dl27Jju69tfJ8+mOtzXhfOp+vPgYVXJyHBCZQCuJQ6F4jJlyrDsGgCgWKWkpOjk2VQFR/dQmfKhDvV1dM9W7f9jrrIyCcUA7DkUijt16qR169Y5qxYAAPJVpnyo/EMqO9THuRPJTqoGwLXGoSXZXnzxRZ0+fVqPPvqoUlMdf1kLAAAAKAkO3Snu1auXypYtq9dff13z58/X9ddfL39//1ztXFxctGLFCkcOBQAAABQbh0Lx6tWrbf9/7tw5/fTTT3m2c3FxceQwAAAAQLFyKBRnZ2c7qw4AAACgxPAxzwAAALA8hz/mOce5c+f0+++/66+//tJNN93krG4BAACAYufwneJ9+/apS5cuKleunJo1a6Z27drZ9q1fv1516tSxm3sMAAAAlDYOheIDBw6oZcuW+vrrr9WlSxdFR0fLGGPb36JFCx0/flzvv/++w4UCAAAAxcWhUDxu3DidOnVKa9as0ccff6xbbrnFbr+7u7tuuukmrV+/3qEiAQAAgOLk0JziZcuWqVu3bmrVqlW+bSIjI7Vy5UpHDgMAAAopIz1d+/fvd0pf/v7+Cg4OdkpfQGnnUCg+efKkqlatWmAbY4zS0tIcOQwAACiEtHNntC9pr4aNGi8vLy+H+yvv56v35r1FMIYlOBSKQ0NDtWvXrgLb/Prrr6pSpYojhwEAAIWQkXZe2S7uCmrZXRXCIx3q66+TR3Qs8ROlpKQQimEJDoXiW265Rf/3f/+nX375RQ0aNMi1f926dVq5cqWGDRvmyGEAAEAR+JYLln9IZYf7OeaEWoCrhUNvtBs9erR8fHwUExOjSZMmaffu3ZKk//znPxozZow6duyooKAgPfnkk04pFgAAACgODt0prlq1qpYtW6ZevXppzJgxcnFxkTFGt912m4wxqlKlij7++GNVrFjRWfUCAAAATufwJ9q1aNFCu3bt0pdffqkNGzbo5MmT8vf3V4sWLdSlSxd5eno6o04AAACg2DjlY57d3d3VrVs3devWzRndAQAAAFeUwx/zDAAAAFztHLpTPHHixEK1c3Fx0ZgxYxw5FAAAAFBsHArF48ePL3B/zhvvCMUAAAAozRwKxatWrcpz+5kzZ/TTTz/p1VdfVYcOHTRkyBBHDgMAAAAUK4dCcZs2bfLdd8cdd6h3795q3LixevTo4chhAAAAgGJVrG+0u+6669StWze98MILxXkYAAAAwCHFvvpESEiIdu7cWdyHAQAAAC5bsYbitLQ0LV26VIGBgcV5GAAAAMAhDs0pfvfdd/PcnpmZqYMHD+qDDz7Qb7/9pkcffdSRwwAAAADFyqFQ3KdPH7m4uOTaboyR9PeSbPfccw9zigEAAFCqORSK582bl+d2V1dXlStXTk2aNFHFihUdOQQAAABQ7BwKxfHx8c6qAwAAACgxxb76BAAAAFDaOXSneO3atZf92JiYGEcODQAAADiNQ6G4bdu2eb7RrjCysrIcOTQAAADgNA6F4rFjx2rDhg1atmyZrrvuOrVu3VqhoaE6cuSIvvvuO/3++++Ki4tTy5YtnVUvAAAA4HQOheL27dvrhRde0Jw5c9SvXz+7u8bGGL355pv617/+pWeeeUY33nijw8UCAAAAxcGhN9qNGTNGnTt3Vv/+/XNNo3BxcdHAgQN16623asyYMQ4VCQAAABQnh0Lxpk2bVLt27QLb1K5dWxs3bnTkMAAAAECxcigUe3p6avPmzQW22bx5szw9PR05DAAAAFCsHArFsbGxWrp0qV544QWlp6fb7UtPT9fkyZO1bNkyxcXFOVQkAAAAUJwceqPdiy++qHXr1umZZ57Rv//9bzVt2lQhISE6evSoNm7cqKNHjyo8PFxTp051Vr0AAACA0zkUiitXrqyNGzdqxIgR+uijj7RkyRLbPm9vb91///164YUXFBYW5nChAAAAQHFxKBRLUlhYmObPn68333xTO3fu1JkzZxQQEKDrr7+eucQAAAC4KjgcinN4eHioXr16zuoOAAAAuGKcEoqTk5P16aef6rffflNqaqreeustSdKxY8eUlJSk+vXry8fHxxmHAgAAAJzO4VA8c+ZMPf7440pLS5P094d25ITio0ePKjo6WrNnz9aAAQMcPRQAAABQLBxaku3LL7/U0KFDVb9+fS1evFiDBw+221+3bl01aNBAn3/+uSOHAQAAAIqVw0uyValSRatWrVKZMmW0adOmXG3q16+vdevWOXIYAAAAoFg5dKd4y5Yt6ty5s8qUKZNvm0qVKunIkSOOHAYAAAAoVg6F4uzsbHl4eBTY5ujRo/Ly8nLkMAAAAECxcigU16xZs8CpEZmZmVq7dq3q16/vyGEAAACAYuVQKO7du7c2b96sCRMm5NqXlZWlJ554Qnv37tUDDzzgyGEAAACAYuXQG+0eeeQRffnll5o4caIWLFggb29vSdJdd92ljRs3at++fYqNjVW/fv2cUiwAAABQHBy6U+zh4aFly5ZpxIgROnHihLZu3SpjjD7++GOdPHlSTz/9tBYvXiwXFxdn1QsAAAA4ncMf3uHp6alJkybpueee086dO3Xy5En5+/urdu3acnNzc0aNAAAAQLFyKBRXq1ZNt956q15//XW5uLioVq1azqoLAAAAuGIcmj5x/Phx+fv7O6sWAAAAoEQ4FIobNGig33//3Vm15PLCCy/IxcVFw4YNs227cOGChgwZogoVKqhs2bLq0aNHrg8HOXDggDp37ixfX1+FhIToySefVGZmpl2b1atXq3HjxvLy8lKNGjU0f/78YjsPAAAAlG4OheKnn35aX375pVatWuWsemx+/PFHvfHGG2rQoIHd9scee0xffvmlFi1apDVr1ujQoUPq3r27bX9WVpY6d+6s9PR0fffdd3rnnXc0f/58jR071tYmKSlJnTt3Vrt27bRlyxYNGzZM/fv317Jly5x+HgAAACj9HJpTfOrUKcXGxio2NlZdu3ZVs2bNFBoamudqE0VZq/jcuXPq3bu33nzzTT333HO27WfOnNHbb7+thQsX6uabb5YkzZs3T7Vr19b333+vli1bavny5dq+fbu++eYbhYaGqmHDhnr22Wf19NNPa/z48fL09NTs2bMVFRWll19+WZJUu3Ztffvtt3rllVcUFxfnyJAAAADgKuRQKO7Tp49cXFxkjNEnn3yiTz75RJLsQrExRi4uLkUKxUOGDFHnzp3VoUMHu1C8adMmZWRkqEOHDrZttWrVUpUqVZSYmKiWLVsqMTFR9evXV2hoqK1NXFycBg8erG3btqlRo0ZKTEy06yOnzcXTNP4pLS1NaWlptq9TUlIkSRkZGcrIyCj0uV0rcs7ZiufuLIyhYxg/x10tY5iVlSVPTw95uEruynaoLw83F3l7ezmvLy8vSY715fSanNWXq+Tp6aGsrKxiu0aulmuwNGMMC1aUcSlyKE5JSZG3t7c8PT01b968oj78kj744AP99NNP+vHHH3PtS05OlqenpwIDA+22h4aGKjk52dbm4kCcsz9nX0FtUlJSdP78efn4+OQ69uTJk/P85L7ly5fL19e38Cd4jUlISCjpEq56jKFjGD/HXQ1j+NTQQf/9v2THOmpRUf1aTHFaX2oxUZIUW+5oqanJaX2Vc5WuG6QdO3Zox44djvV1CVfDNVjaMYZ5S01NLXTbIoficuXKafz48RozZozi4+MlSRs2bNCGDRv06KOPFrU7O3/88Yf+9a9/KSEhwfbpeKXFyJEjNXz4cNvXKSkpioiIUGxsrCVX4MjIyFBCQoJuueUWeXh4lHQ5VyXG0DGMn+OuljFMSkpS3yHDFBk3QH5B4Q71dfj3zfr+/elq/eAYhUTUcLivLZ/O0owpE7X8VIgyL/NtOs6uyVl9nT1+SPuXval5r09XVFSUQ33l52q5BkszxrBgOa/sF0aRQ7ExRsYYu21Lly7VxIkTHQ7FmzZt0tGjR9W4cWPbtqysLK1du1avvfaali1bpvT0dJ0+fdrubvGRI0cUFhYmSQoLC9MPP/xg12/O6hQXt/nnihVHjhyRv79/nneJJcnLy0te/32Z7GIeHh6Wvgitfv7OwBg6hvFzXGkfQzc3N6WnZygjW5cdPHNkZBlduJDmvL7+O60uU66X3Z/Ta3JWX9lSenqG3Nzciv36KO3X4NWAMcxbUcbEse8YJ2vfvr1+/fVXbdmyxfavadOm6t27t+3/PTw8tGLFCttjdu7cqQMHDig6OlqSFB0drV9//VVHj/7vpayEhAT5+/urTp06tjYX95HTJqcPAAAAWIvDH/PsTH5+fqpXr57dtjJlyqhChQq27f369dPw4cNVvnx5+fv765FHHlF0dLRatmwpSYqNjVWdOnV0//33a+rUqUpOTtbo0aM1ZMgQ253ehx56SK+99pqeeuopPfjgg1q5cqU++ugjLVmy5MqeMAAAAEqFUhWKC+OVV16Rq6urevToobS0NMXFxWnmzJm2/W5ubvrqq680ePBgRUdHq0yZMoqPj9fEiRNtbaKiorRkyRI99thj+ve//63KlSvrrbfeYjk2AAAAiyr1oXj16tV2X3t7e+v111/X66+/nu9jIiMj9fXXXxfYb9u2bbV582ZnlAgAAICr3GWF4vfee0/ff/+97evdu3dLkjp16pRnexcXF6YmAAAAoNS6rFC8e/duWxC+2NKlS/Nsn9cn3AEAAAClRZFDcVJSUnHUAQAAAJSYIofiyMjI4qgDAAAAKDGlap1iAAAAoCQQigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYnntJFwAAuDYdO3ZMKSkpDvezf/9+ZWZkOqEiAMgfoRgA4HTHjh3TfX376+TZVIf7unA+VX8ePKwqGRlOqAwA8kYoBgA4XUpKik6eTVVwdA+VKR/qUF9H92zV/j/mKiuTUAyg+BCKAQDFpkz5UPmHVHaoj3Mnkp1UDQDkjzfaAQAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsz72kCwAAAKVTRnq69u/f75S+/P39FRwc7JS+gOJQ6kLx5MmT9emnn+q3336Tj4+PWrVqpSlTpqhmzZq2NhcuXNDjjz+uDz74QGlpaYqLi9PMmTMVGhpqa3PgwAENHjxYq1atUtmyZRUfH6/JkyfL3f1/p7x69WoNHz5c27ZtU0REhEaPHq0+ffpcydMFAKBUSjt3RvuS9mrYqPHy8vJyuL/yfr56b95bBGOUWqUuFK9Zs0ZDhgxRs2bNlJmZqVGjRik2Nlbbt29XmTJlJEmPPfaYlixZokWLFikgIEBDhw5V9+7dtX79eklSVlaWOnfurLCwMH333Xc6fPiwHnjgAXl4eOj555+XJCUlJalz58566KGHtGDBAq1YsUL9+/dXxYoVFRcXV2LnDwBAaZCRdl7ZLu4KatldFcIjHerrr5NHdCzxE6WkpBCKUWqVulC8dOlSu6/nz5+vkJAQbdq0STExMTpz5ozefvttLVy4UDfffLMkad68eapdu7a+//57tWzZUsuXL9f27dv1zTffKDQ0VA0bNtSzzz6rp59+WuPHj5enp6dmz56tqKgovfzyy5Kk2rVr69tvv9Urr7xCKAYA4L98ywXLP6Syw/0cc0ItQHEqdaH4n86cOSNJKl++vCRp06ZNysjIUIcOHWxtatWqpSpVqigxMVEtW7ZUYmKi6tevbzedIi4uToMHD9a2bdvUqFEjJSYm2vWR02bYsGF51pGWlqa0tDTb1ykpKZKkjIwMZWRkOOVcryY552zFc3cWxtAxjJ/jinMMs7Ky5OnpIQ9XyV3ZDvXl4eYib2+v0tnXf6cVONJXqT4/Z/XlKnl6eigrK8vueuP72HGMYcGKMi4uxhhTjLU4JDs7W3fccYdOnz6tb7/9VpK0cOFC9e3b1y6gSlLz5s3Vrl07TZkyRQMHDtT+/fu1bNky2/7U1FSVKVNGX3/9tW699VZdf/316tu3r0aOHGlr8/XXX6tz585KTU2Vj4+PXf/jx4/XhAkTctW4cOFC+fr6OvO0AQAA4ASpqam69957debMGfn7+xfYtlTfKR4yZIi2bt1qC8QlaeTIkRo+fLjt65SUFEVERCg2NvaSg3wtysjIUEJCgm655RZ5eHiUdDlXJcbQMYyf44pzDJOSktR3yDBFxg2QX1C4Q30d/n2zvn9/ulo/OEYhETVKVV9bPp2lGVMmavmpEGVe5iqnpfn8nNXX2eOHtH/Zm5r3+nRFRUXZtvN97DjGsGA5r+wXRqkNxUOHDtVXX32ltWvXqnLl/81lCgsLU3p6uk6fPq3AwEDb9iNHjigsLMzW5ocffrDr78iRI7Z9Of/N2XZxG39//1x3iSXJy8srz3ffenh4WPoitPr5OwNj6BjGz3HFMYZubm5KT89QRrYuOyzmyMgyunAhrXT29d9XLTPletn9lerzc1Zf2VJ6eobc3NzyvNb4PnYcY5i3ooxJqfvwDmOMhg4dqs8++0wrV660+4tSkpo0aSIPDw+tWLHCtm3nzp06cOCAoqOjJUnR0dH69ddfdfToUVubhIQE+fv7q06dOrY2F/eR0yanDwAAAFhHqbtTPGTIEC1cuFBffPGF/Pz8lJycLEkKCAiQj4+PAgIC1K9fPw0fPlzly5eXv7+/HnnkEUVHR6tly5aSpNjYWNWpU0f333+/pk6dquTkZI0ePVpDhgyx3e196KGH9Nprr+mpp57Sgw8+qJUrV+qjjz7SkiVLSuzcAQAAUDJK3Z3iWbNm6cyZM2rbtq0qVqxo+/fhhx/a2rzyyiu67bbb1KNHD8XExCgsLEyffvqpbb+bm5u++uorubm5KTo6Wvfdd58eeOABTZw40dYmKipKS5YsUUJCgm644Qa9/PLLeuutt1iODQAAwIJK3Z3iwiyG4e3trddff12vv/56vm0iIyP19ddfF9hP27ZttXnz5iLXCAAAgGtLqbtTDAAAAFxphGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYHqEYAAAAlkcoBgAAgOURigEAAGB5hGIAAABYnntJFwAAKD2OHTumlJQUh/vZv3+/MjMynVARAFwZhGIAgKS/A/F9ffvr5NlUh/u6cD5Vfx48rCoZGU6oDACKH6EYACBJSklJ0cmzqQqO7qEy5UMd6uvonq3a/8dcZWUSigFcHQjFAAA7ZcqHyj+kskN9nDuR7KRqAODK4I12AAAAsDxCMQAAACyPUAwAAADLIxQDAADA8gjFAAAAsDxCMQAAACyPUAwAAADLIxQDAADA8gjFAAAAsDxCMQAAACyPUAwAAADLIxQDAADA8gjFAAAAsDxCMQAAACzPvaQLAAAA176M9HTt37/fbltWVpYkKSkpSW5uboXqx9/fX8HBwU6vDyAUAwCAYpV27oz2Je3VsFHj5eXlZdvu6emhp4YOUt8hw5SenlGovsr7+eq9eW8RjOF0hGIAAFCsMtLOK9vFXUEtu6tCeKRtu8d/J3FGxg1QRval+/nr5BEdS/xEKSkphGI4HaEYAABcEb7lguUfUtn2tbuyJSXLLyhcmYV8m9OxYqoN4I12AAAAsDxCMQAAACyPUAwAAADLIxQDAADA8gjFAAAAsDxCMQAAACyPUAwAAADLIxQDAADA8gjFAAAAsDxCMQAAACyPUAwAAADLIxQDAADA8txLugAAgOOOHTumlJSUIj0mKytLkpSUlCQ3Nzft379fmRmZxVEeAJR6hGIAuModO3ZM9/Xtr5NnU4v0OE9PDz01dJD6Dhmm9PQMXTifqj8PHlaVjIxiqhQASi9CMQBc5VJSUnTybKqCo3uoTPnQQj/O478T6CLjBigjWzq6Z6v2/zFXWZmEYgDWQygGgGtEmfKh8g+pXOj27sqWlCy/oHBlylXnTiQXX3EAUMrxRjsAAABYHqEYAAAAlsf0CeAqdTmrDeQnPT1dnp6eTunL399fwcHBTukLAIArhVAMXIUud7WBvGSkp+vggf2qHBkldw/HfySU9/PVe/PeIhgDAK4qhGLgKnS5qw3k5eierdq7b67KNe+iCuGRDvX118kjOpb4iVJSUgjFAICrCqEYuIIunvLwzw9OKIqcD1ko6moDeclZccC3XLDDfUnSofR07d+/3+F+mIYBALiSCMXAFfLPKQ///OCEoiitH7KQdu6M9iXt1bBR4+Xl5eVQX0zDAJCXDCf94S3xxzfsEYqBK+SfUx7++cEJRVFaP2QhI+28sl3cFdSyu0NTMZiGASAvzvzDW+KPb9gjFANXWM6Uh39+cEJRlPYPWXDGVIxjTqoFwLXDWX94S/zxjdwIxQBKpUu9RFqUOdml9SVSZy2rlzPHHLAKZ70Hgj++cTFCMVAIzggvBJfCK8xLpEWZk10aXyJ15rJ6pXWOOQBcTQjFuGY56y7ciRMn9PTo8TqX5ljgILgUXmFeIi3snOzS+hKps5fVK41zzAHgamL5UPz666/rxRdfVHJysm644QbNmDFDzZs3L+my4KDiuAvXtNdjCgy9/JfrCC5FV9BLpEWZk+2sZeIk5336X3EsqwcAuHyWDsUffvihhg8frtmzZ6tFixaaPn264uLitHPnToWEhJR0eZbkzDmWR0+mqGLM3U67C+flX96h8EJwKRnOfLe6Mz/9j1cOgJLH8m64mKVD8bRp0zRgwAD17dtXkjR79mwtWbJEc+fO1YgRI0q4uuLlaPi8+E1OWVlZTrlz5qxpCtJFgcPPsSArEWavds58t7ozP/2PVw6AkuXs5d3KerppyqSJqlChgsN9EbBLhmVDcXp6ujZt2qSRI0fatrm6uqpDhw5KTEzM1T4tLU1paWm2r8+cOSNJOnnypDKu4J2e06dP2459uU6dOqXJU1/W2SJ+YMTFPN099PCD9yt+0BAd2JekipUi5eZRtGXF/in9/AUdOnJE17fpoTKB5R3q6/Th/XI7clR/HU6Sp3FwLvDJQ/L0dNeFY38qpWgfPFdgP26uUqqXq84c2q2sIq5T7KyaSmtfhemnsOOX05drZpqU7th0GtfsdKf3VZLj/s8xLI3XQqnvy91dqampl/V9XGw1XUV9FfXnoDNrOnt4j9y9vFX2+pbyL+9YAD17LFnb1n2uh4Y9JQ8vD8cKk+Tn4a6RTz+hcuXKXbJtVlaWUlNTtWXLliJ/OmpJCQgIUGBg4BU51tmzZyVJxphLtnUxhWl1DTp06JAqVaqk7777TtHR0bbtTz31lNasWaMNGzbYtR8/frwmTJhwpcsEAACAg/744w9VrlzwK8eWvVNcVCNHjtTw4cNtX2dnZ+vkyZOqUKGCXFxcSrCykpGSkqKIiAj98ccf8vf3L+lyrkqMoWMYP8cxho5jDB3D+DmOMSyYMUZnz55VeHj4JdtaNhQHBQXJzc1NR44csdt+5MgRhYWF5Wrv5eWVa87Rlbr1X5r5+/vzTeggxtAxjJ/jGEPHMYaOYfwcxxjmLyAgoFDtHJsEehXz9PRUkyZNtGLFCtu27OxsrVixwm46BQAAAK59lr1TLEnDhw9XfHy8mjZtqubNm2v69On666+/bKtRAAAAwBosHYrvvvtuHTt2TGPHjlVycrIaNmyopUuXKjTUsXVtrcDLy0vjxo1zyjI2VsUYOobxcxxj6DjG0DGMn+MYQ+ex7OoTAAAAQA7LzikGAAAAchCKAQAAYHmEYgAAAFgeoRgAAACWRyjGJU2aNEmtWrWSr69vvh9YcuDAAXXu3Fm+vr4KCQnRk08+qczMTLs2q1evVuPGjeXl5aUaNWpo/vz5xV98KbR69Wq5uLjk+e/HH3+UJO3bty/P/d9//30JV186VK1aNdfYvPDCC3ZtfvnlF910003y9vZWRESEpk6dWkLVlj779u1Tv379FBUVJR8fH1WvXl3jxo1Tenq6XRuuwYK9/vrrqlq1qry9vdWiRQv98MMPJV1SqTR58mQ1a9ZMfn5+CgkJUdeuXbVz5067Nm3bts11rT300EMlVHHpM378+FzjU6tWLdv+CxcuaMiQIapQoYLKli2rHj165PpwMlyapZdkQ+Gkp6frzjvvVHR0tN5+++1c+7OystS5c2eFhYXpu+++0+HDh/XAAw/Iw8NDzz//vCQpKSlJnTt31kMPPaQFCxZoxYoV6t+/vypWrKi4uLgrfUolqlWrVjp8+LDdtjFjxmjFihVq2rSp3fZvvvlGdevWtX1doUKFK1Lj1WDixIkaMGCA7Ws/Pz/b/6ekpCg2NlYdOnTQ7Nmz9euvv+rBBx9UYGCgBg4cWBLlliq//fabsrOz9cYbb6hGjRraunWrBgwYoL/++ksvvfSSXVuuwbx9+OGHGj58uGbPnq0WLVpo+vTpiouL086dOxUSElLS5ZUqa9as0ZAhQ9SsWTNlZmZq1KhRio2N1fbt21WmTBlbuwEDBmjixIm2r319fUui3FKrbt26+uabb2xfu7v/L8I99thjWrJkiRYtWqSAgAANHTpU3bt31/r160ui1KuXAQpp3rx5JiAgINf2r7/+2ri6uprk5GTbtlmzZhl/f3+TlpZmjDHmqaeeMnXr1rV73N13323i4uKKtearQXp6ugkODjYTJ060bUtKSjKSzObNm0uusFIsMjLSvPLKK/nunzlzpilXrpzt+jPGmKefftrUrFnzClR3dZo6daqJioqyfc01WLDmzZubIUOG2L7Oysoy4eHhZvLkySVY1dXh6NGjRpJZs2aNbVubNm3Mv/71r5IrqpQbN26cueGGG/Lcd/r0aePh4WEWLVpk27Zjxw4jySQmJl6hCq8NTJ+AwxITE1W/fn27Dz2Ji4tTSkqKtm3bZmvToUMHu8fFxcUpMTHxitZaGi1evFgnTpzI85MU77jjDoWEhOjGG2/U4sWLS6C60uuFF15QhQoV1KhRI7344ot203USExMVExMjT09P27acu3inTp0qiXJLvTNnzqh8+fK5tnMN5paenq5NmzbZ/UxzdXVVhw4d+JlWCGfOnJGkXNfbggULFBQUpHr16mnkyJFKTU0tifJKrV27dik8PFzVqlVT7969deDAAUnSpk2blJGRYXc91qpVS1WqVOF6LCKmT8BhycnJuT4FMOfr5OTkAtukpKTo/Pnz8vHxuTLFlkJvv/224uLiVLlyZdu2smXL6uWXX1br1q3l6uqqTz75RF27dtXnn3+uO+64owSrLR0effRRNW7cWOXLl9d3332nkSNH6vDhw5o2bZqkv6+3qKgou8dcfE2WK1fuitdcmu3evVszZsywmzrBNZi/48ePKysrK8+fab/99lsJVXV1yM7O1rBhw9S6dWvVq1fPtv3ee+9VZGSkwsPD9csvv+jpp5/Wzp079emnn5ZgtaVHixYtNH/+fNWsWVOHDx/WhAkTdNNNN2nr1q1KTk6Wp6dnrvf8hIaG2n4Ho3AIxRY1YsQITZkypcA2O3bssJvIj4Jdzpj++eefWrZsmT766CO7dkFBQRo+fLjt62bNmunQoUN68cUXr9lAUpTxu3hsGjRoIE9PTw0aNEiTJ0+29EedXs41ePDgQXXs2FF33nmn3RxtK16DKH5DhgzR1q1b9e2339ptv3iuf/369VWxYkW1b99ee/bsUfXq1a90maXOrbfeavv/Bg0aqEWLFoqMjNRHH31k6ZtKzkYotqjHH39cffr0KbBNtWrVCtVXWFhYrndd57zrNSwszPbff74T9siRI/L3979mvqEvZ0znzZunChUqFCpktGjRQgkJCY6UWKo5ck22aNFCmZmZ2rdvn2rWrJnv9Sb975q8FhV1DA8dOqR27dqpVatWmjNnziX7v9avwcIKCgqSm5tbntfYtXx9OWro0KH66quvtHbtWrtXxvLSokULSX+/ikEozi0wMFDXX3+9du/erVtuuUXp6ek6ffq03d1irseiIxRbVHBwsIKDg53SV3R0tCZNmqSjR4/a3nWdkJAgf39/1alTx9bm66+/tntcQkKCoqOjnVJDaVDUMTXGaN68ebaVOi5ly5YtqlixoiMllmqOXJNbtmyRq6ur7fqLjo7WM888o4yMDNvYJiQkqGbNmtf01ImijOHBgwfVrl07NWnSRPPmzZOr66XfYnKtX4OF5enpqSZNmmjFihXq2rWrpL+nBaxYsUJDhw4t2eJKIWOMHnnkEX322WdavXp1rqlNedmyZYskcb3l49y5c9qzZ4/uv/9+NWnSRB4eHlqxYoV69OghSdq5c6cOHDhwTf2OvSJK+p1+KP32799vNm/ebCZMmGDKli1rNm/ebDZv3mzOnj1rjDEmMzPT1KtXz8TGxpotW7aYpUuXmuDgYDNy5EhbH3v37jW+vr7mySefNDt27DCvv/66cXNzM0uXLi2p0ypx33zzjZFkduzYkWvf/PnzzcKFC82OHTvMjh07zKRJk4yrq6uZO3duCVRaunz33XfmlVdeMVu2bDF79uwx7733ngkODjYPPPCArc3p06dNaGiouf/++83WrVvNBx98YHx9fc0bb7xRgpWXHn/++aepUaOGad++vfnzzz/N4cOHbf9ycA0W7IMPPjBeXl5m/vz5Zvv27WbgwIEmMDDQbhUe/G3w4MEmICDArF692u5aS01NNcYYs3v3bjNx4kSzceNGk5SUZL744gtTrVo1ExMTU8KVlx6PP/64Wb16tUlKSjLr1683HTp0MEFBQebo0aPGGGMeeughU6VKFbNy5UqzceNGEx0dbaKjo0u46qsPoRiXFB8fbyTl+rdq1Spbm3379plbb73V+Pj4mKCgIPP444+bjIwMu35WrVplGjZsaDw9PU21atXMvHnzruyJlDL33HOPadWqVZ775s+fb2rXrm18fX2Nv7+/ad68ud1yO1a2adMm06JFCxMQEGC8vb1N7dq1zfPPP28uXLhg1+7nn382N954o/Hy8jKVKlUyL7zwQglVXPrMmzcvz+/pi++TcA1e2owZM0yVKlWMp6enad68ufn+++9LuqRSKb9rLed3wIEDB0xMTIwpX7688fLyMjVq1DBPPvmkOXPmTMkWXorcfffdpmLFisbT09NUqlTJ3H333Wb37t22/efPnzcPP/ywKVeunPH19TXdunWz+yMXheNijDFX+u40AAAAUJqwTjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjEAAAAsj1AMAAAAyyMUAwAAwPIIxQAAALA8QjFwDZs/f75cXFw0f/78Qj+matWqqlq1arHVlJfLqbMoNm/eLDc3Ny1cuLBY+nc2FxcXtW3b1m5bnz595OLion379pVITUXRtm1bubi4lHQZV7Xx48fLxcVFq1evLulSSoW8fkZkZGSoWrVquuuuu0quMFxTCMWAk+3bt08uLi52/zw8PFSpUiXddddd2rhxY0mXaDnDhw9XrVq11KtXL7vt/3ye3N3dVbFiRXXt2lVr164toWqLx7UWsnKCd0H/rpVzvVrl9cedM3l4eOiZZ57RokWL9P333xfbcWAd7iVdAHCtql69uu677z5J0l9//aVNmzZp0aJF+vzzz/XNN98oJiam2Gvo1q2bWrZsqYoVKxb7sUqrlStXavXq1Xr77bfl6pr7PkCFChU0dOhQSdKFCxe0ZcsWffHFF1q8eLE+/PBD3XnnnVe65DxNnjxZI0aMUKVKlUq6lFLl8ccfV9myZfPcd6Vf8XCmoUOHqlevXqpSpUpJl1KqxcfHa9SoURozZowSEhJKuhxc5QjFQDGpUaOGxo8fb7fthRde0MiRIzVmzBitWbOm2GsICAhQQEBAsR+nNJs1a5Z8fHzUs2fPPPcHBQXlep7eeustDRgwQE899VSpCcUVK1a09B83+XniiScUFhZW0mU4XVBQkIKCgkq6jFLP3d1dvXr10owZM7R7927VqFGjpEvCVYzpE8AV1K9fP0nSpk2bcu1LT0/XtGnT1LhxY5UpU0Z+fn666aabtHjx4lxtz5w5o7Fjx6pOnToqW7as/P39VaNGDcXHx2v//v22dgXN1f3iiy/UrFkz+fj4KDQ0VAMGDNCpU6fyrLugOaJ5zXU9c+aMpkyZojZt2ig8PFyenp4KDw/XAw88oD179hQ0RHZ++ukn9ezZU1WqVJGXl5eCg4PVrFkzTZo0qVCPP3XqlL744gvFxcXJ39+/0Md98MEHVaZMGe3bt0/Hjh2T9L+51qdPn9bQoUMVEREhd3d3u7H95Zdf1KtXL1WsWFGenp6KjIzUI488ohMnTuR5nLfeekv16tWTt7e3IiIi9NRTT+nChQt5ti1oTvHatWvVtWtXhYaGysvLSxEREerevbu+/fZbSX8/fxMmTJAktWvXzja94J93Uo8eParHHntMNWrUkJeXl4KCgtSjRw9t3bo1z5q+/fZbtWnTRmXKlFGFChV09913648//ihoaEvE7t275efnp8qVK+d6LvLalzMFqk+fPtq2bZs6d+6swMBAlS1bVrGxsXl+/0rS2bNnNW7cONWtW1c+Pj4KDAxUXFyc7Xm4WM731IULFzR69GhVr15dHh4etj/Q8prucnFdO3bs0G233abAwECVK1dO99xzj44fPy5JSkxMVPv27eXv769y5cqpf//++uuvv/Ksee3atbr99tsVFBQkLy8vXXfddRo9erRSU1Pt2q1evVouLi4aP368Nm7cqFtuuUV+fn4KCAhQt27d7K7LnLaStGbNGrspLTnfL876GSFJd911l4wxeuedd4r0OOCfuFMMlAB3d/tvvbS0NHXs2FGrV69Ww4YN1a9fP2VkZGjJkiXq0qWLZsyYYXuJ3xijuLg4bdiwQa1bt1bHjh3l6uqq/fv3a/Hixbr//vsVGRlZ4PHfffddxcfHy9/fX/fff78CAwP11VdfqUOHDkpPT5enp6dD57djxw6NHTtW7dq1U7du3VSmTBn99ttvWrhwoZYsWaKffvrpkjVu2bJFrVq1kpubm7p06aLIyEidPn1a27dv15w5c/TMM89cso61a9cqIyNDLVu2vOxzufiPgbS0NN188806d+6c7rjjDrm7uys0NFSStHjxYt11111ydXVVly5dFBERoe3bt+u1117TsmXLtGHDBpUrV87W17PPPquxY8fa/iDx8PDQhx9+qB07dhSpvn//+9967LHH5OPjo27duqlKlSo6ePCgvv32W3388ce68cYb1adPH0l/B5T4+HhbGA4MDLT1s2fPHrVt21Z//vmnYmNj1bVrVx09elSffPKJli1bphUrVqhFixa29itWrNCtt94qV1dX3X333QoPD9eKFSvUunVru/MsDWrUqKEZM2aob9++6t+/vz777DNJf79R65577lFqaqoWL16sChUq2D1u7969at26tRo3bqzBgwdr//79WrRokWJiYrRy5Uq78Th58qRiYmK0bds2tW7dWg899JBSUlL0xRdfqF27dlq0aJG6du2aq7YePXro559/VseOHRUYGKioqKhLnk9SUpJatWqlpk2bqn///tq4caM++OAD/fHHH3rhhRcUGxurW265RQMHDrRNHcrOztbcuXPt+pk1a5aGDBmiwMBA3X777QoJCdHGjRs1adIkrVq1SqtWrcr1s+DHH3/U1KlT1a5dOw0aNEibN2/W559/rl9//VVbt26Vt7e3qlatqnHjxmnChAmKjIy0XX+S1LBhQ0nO+RmRo0mTJvLw8NCKFSv07LPPFuoxQJ4MAKdKSkoykkxcXFyufc8//7yRZDp37my3fdSoUUaSGTNmjMnOzrZtT0lJMU2bNjWenp7m4MGDxhhjfvnlFyPJdO3aNVf/Fy5cMGfPnrV9PW/ePCPJzJs3z7btzJkzxt/f35QpU8bs3LnTtj09Pd3ExMQYSSYyMtKu3zZt2pj8flzEx8cbSSYpKcm27fTp0+bEiRO52q5cudK4urqa/v37223Pq87hw4cbSebzzz/P1c/x48fzrOWfnnzySSPJJCQk5LlfkqlZs2au7XPnzjWSTFRUlG1bZGSk7XlNTU3NVY+/v7+pVKmS2bdvn92+999/30gyQ4cOtW3btWuXcXd3N5UqVTJHjhyxbT9z5oypWbOmkWTatGlj109e47xlyxbj6upqwsPD7bYbY0x2drbtmjHGmHHjxhlJZtWqVXmORatWrYybm5tZunSp3fadO3caPz8/U79+fdu2rKwsU61aNePi4mLWrVtnd8x7773XSMr3enGWnGvy8ccfN+PGjcv1b/Lkybke06tXLyPJzJw50xjzv+tj5MiRdu1yvoclmREjRtjtW7p0qZFkNx7GGNt5v/nmm3bbjxw5YiIiIkxwcLA5f/58rvobNmyY5/dKXs/XxXVNnz7dtj07O9t06tTJSDKBgYF23zPp6emmQYMGxt3d3SQnJ9u2b9u2zbi7u5sbbrgh1/fT5MmTjSTz0ksv2batWrXKduwPPvjArv39999vJJn333/fbnte13EOZ/yMuFijRo2Mh4eHuXDhQp77gcIgFANOlvOLq3r16rZf0E888YRp166dkWRCQ0PN9u3bbe2zsrJMuXLlTPXq1e0CcY7FixcbSWbGjBnGmP+F4nvuueeSteT1i+Sdd94xkswjjzySq/26deucEooLUr9+fVO1atVL1pkTipctW1aofvNyzz33GEnml19+yXO/JFOhQgXb8/T000+bjh07GknG1dXVfPzxx7a2OaH4559/ztXPtGnTjCTz7rvv5nmcxo0bm6CgINvXEyZMMJLMyy+/nKvt//3f/xU6FA8ePNhIMnPnzi1oGIwxBYfin376yUgyDz74YJ6PzXkufv31V2OMMWvWrDGSzO23356r7b59+4ybm9sVC8X5/QsICMj1mNOnT5uqVasaHx8f8+qrrxoXFxfTvHlzk5GRYdcu53s4MDDQ7o/MHO3btzeSzMaNG40xxhw7dsy4ubmZm2++Oc9aX331VSPJfPnll7nq/+KLL/J8TEGhOK+fFe+++66RZNq1a5err4kTJxpJZuXKlbZtjz76qJFk1q5dm6t9VlaWCQ4ONk2aNLFtywnFMTExudrn7Bs+fLjd9oJCcUEK+zPiYjnftwcOHCjy8YAcTJ8AismePXts8zhzhIWFad26dXZvBtm5c6dOnTql8PDwXO0l2ea0/vbbb5Kk2rVrq0GDBnr//ff1559/qmvXrmrbtq0aNmyY5+oK//Tzzz9Lkm666aZc+6Kjo3NN7bhcq1ev1vTp07VhwwYdP35cmZmZtn2FmZ5x1113afr06erWrZvuvvtu3XLLLYqJiSnS6gs5c0QvniaQV5uccXdzc1NQUJC6dOmixx9/PNcYeXt7q379+rn6yFkOasOGDXnOh7xw4YKOHz+u48ePKygoqMDnIK9t+fnhhx8kSbGxsYV+TF5y6j9y5EiuNx1K/7v2fvvtN9WrV6/A+iMjIxUREVHo9ZTzOt6wYcMKfM4udvjw4UK/0S4gIEALFixQTEyMHn30Ufn5+WnhwoX5XvONGjXKc2WLm266SStWrNDmzZvVpEkT/fjjj8rKylJaWlqe57Nr1y5Jf4/fbbfdZrevefPmhar9Yg0aNMg1xz/nTZg50xPy2nfo0CHbtpznPGdqzD95eHjYnveLNWnSJNe2ypUrS5JOnz5duBP4L0d/RlysfPnykqTjx48rIiKiSI8FchCKgWISFxenpUuXSvo72L7zzjt6+umndccdd+iHH36w/bI9efKkJGnbtm3atm1bvv3lvFHG3d1dK1eu1Pjx4/XJJ5/o8ccflyQFBwdr6NCheuaZZ+Tm5pZvP2fOnJEkhYSE5Nrn5uaWa17l5Vi0aJHuvvtulS1bVnFxcapatap8fX1tb7S5+M2A+WnRooVWr16t559/XgsXLtS8efMkSc2aNdOUKVPUrl27S/bh4+MjSfm+eU2Satasmecv/7yEhITk+YbDnOfw9ddfL/Dxf/31l4KCggp8DnLmKBfGmTNn5OLi4vCqFDn1L1myREuWLMm3Xc41WFD90t/nUNhQnNcfgn369Cl0KC6qxo0bKzIyUnv37tWtt96q6tWr59s2v+ciZ3vOOOSM3/r167V+/fp8+8vrzW5Feb5z5PWm0ZxgX9C+jIwM27acmgv7ptXCHDsrK6vQ/TjjZ8TFzp8/L0ny9fUt0uOAixGKgSsgODhYTzzxhM6cOaPnnntOo0eP1vTp0yX975dMjx499PHHHxeqvwoVKmjGjBl69dVX9dtvv2nlypWaMWOGxo0bJw8PD40cOTLfx+Ys0Xb06NFc+7KysnTixIlcd2Nz7kBnZmbmuquWEwwuNn78eHl7e2vTpk267rrr7PZ98MEHhTpH6e87cv/5z390/vx5bdiwQV9++aVmzpypzp07a+vWrapWrVqBjw8ODpb0vwDgqPxW4Mh5Dn/99VfVq1fvkv1c/Bz8881ER44cKXQ9gYGBMsbo8OHDDq1fnFP/xW/oLEhB15BUtHMwxhS6rTM8+eST2rt3rypUqKCPPvpI8fHx6tSpU55t8zuPnO0545Azfo8//rheeumlItVTUp/8l1NzSkqK/Pz8rvjxnfUzIkfO93jO9zxwOViSDbiCRo0apfDwcM2cOdN2J6127dry9/fXxo0b7e7kFIaLi4tq166tIUOG2Bauz2sJt4vdcMMNkqR169bl2peYmGj3EmaOnNUEDh48aLc9Ozvb9lL6xfbs2aPatWvn+mV3+PBh7d27t8D68uLj46O2bdvq5Zdf1qhRo3T+/PlCLdSfM9Vh586dRT5mUeSsQpCYmFio9gU9B3lty0/OS+/Lly+/ZNucVw/yupvnzPr3799fKpdlk/6+E/7aa6+pTZs22rhxo8qVK6e+ffvmG343b96sc+fO5dqec96NGjWS9PerFy4uLoUev9Ig5zkvzk+Cc3V1zffusbN/RuzcuVOVKlWyTaMALgehGLiCfHx89PTTTysjI8O2dJC7u7ttuacnnngiz2C8detW2125ffv25fnSdM4vdm9v7wJr6NKli/z9/TV37lz9/vvvtu0ZGRkaPXp0no9p1qyZJOVa73jatGlKSkrK1T4yMlK7d++2CxsXLlzQ4MGDCx38ExMT85z2UNjzlKQ2bdpI+nuub3Hq27ev/Pz89Mwzz+Q5BSY1NdUufNx7771yc3PTtGnT7O62pqSk6Lnnniv0cR966CG5ublp9OjRuV5uNsbYzSHNCQt5BdbmzZurRYsWev/99/Xhhx/m2p+dnW33YTM33nijoqKi9NVXX9mtwWuM0ahRo4r0MvqVkpycrL59+6pcuXJ67733VLVqVc2ZM0dHjx5VfHx8nnesT58+nWt6Qc4c3Hr16tnm14aFhemuu+7Sd999pxdffDHPvjZs2JBr7d+S9PDDD8vd3V2PPPKIDhw4kGv/6dOntXnzZoeOUb58ef3555957nPGz4gcBw4cUHJy8hX5lFBc25g+AVxhAwcO1JQpU/Tuu+9q1KhRql69uiZMmKCffvpJr776qpYsWaKYmBiFhITo4MGD+vXXX/Xzzz8rMTFRISEh2rJli7p3767mzZurTp06CgsL08GDB/X555/L1dVVjz32WIHHDwgI0Kuvvqo+ffqoWbNm6tWrlwICAvTVV1/Jx8cnz/mpffv21dSpUzV+/Hht2bJF1atX18aNG7V161a1adMm16fzPfLII3rkkUfUqFEj9ezZU5mZmUpISJAxRjfccEOed5f/acqUKVq1apViYmIUFRUlb29v/fTTT1qxYoWqVaumbt26XbKPBg0aqFq1asX+8a/BwcF6//33deedd+qGG25Qx44dVatWLaWlpWnfvn1as2aNWrVqZZtjXqNGDY0dO1bjxo1TgwYNdNddd8nd3V2ffPKJGjRoUOg72/Xr19f06dP16KOPqm7duuratasiIyOVnJystWvXqnPnzrZpOjkf2jFq1Cht27ZNAQEBCgwMtE2XeP/999WuXTv16tVL06dPV+PGjeXj46MDBw4oMTFRx44ds/2R4urqqjlz5qhTp07q0KGDbZ3ilStX6vDhw2rQoIF++eUX5w90Hl566aV8P+a5Y8eOatmypYwxeuCBB3Ts2DF9/PHHtjeG9ezZU/369dPbb7+tadOm2ebn57jppps0a9YsbdiwQS1bttS+ffu0aNEi+fj46K233rJrO3PmTO3cuVNPPfWU/u///k/R0dEKDAzUH3/8oY0bN2rXrl06fPhwqZnzWq9ePc2cOVODBw9WzZo11alTJ1WvXl1nz57V3r17tWbNGvXp00ezZ8++7GPcfPPN+uijj9S1a1c1atRIbm5uuuOOO9SgQQOn/IzIkfP9ndc60ECRlNi6F8A1qqB1inPMmDHDSDL333+/bVtmZqZ54403TOvWrY2/v7/x8vIyVapUMR07djSzZs0y586dM8YY88cff5gRI0aYli1bmpCQEOPp6WmqVKliunfvbhITE+2OU9AyRp999plp0qSJ8fLyMiEhIaZ///7m5MmTJjIyMteSbMb8vSZu+/btja+vr/H39zddunQxu3btynOpsOzsbDN79mxTt25d4+3tbcLCwky/fv3M0aNH81zeLa86ly5dah544AFTs2ZN4+fnZ8qWLWvq1KljRo0aZY4dO1bAM2BvypQpRpLZsGFDrn3KZ53ivOQ3Lhf77bffTL9+/UxkZKTx9PQ05cqVM/Xr1zePPvqo+eGHH3K1f/PNN02dOnWMp6enqVy5snniiSdMampqoZdky7Fq1Spz2223mfLly9v66tGjh1m/fr1du/nz55v69esbLy+vPJfeO3nypBk9erSpV6+e8fHxMWXLljXXXXeduffee82nn36a67hr1641MTExxsfHx5QvX97ceeedZv/+/QUu4ecsl1qSTZJ55ZVXjDHGvPjii0ZSrrVvjTHm3Llz5vrrrzeenp7mp59+Msb873s4Pj7ebN261XTq1Mm2tneHDh1sS7H9U2pqqpk6dapp0qSJKVOmjPHx8TFRUVGma9eu5t1337Vb+u1SY1TQkmzx8fG52ucsizZu3Lhc+wr6OfDDDz+YXr16mfDwcOPh4WGCgoJM48aNzYgRI8yOHTsK1X9+dR0+fNjcddddJigoyLi6utrV4IyfETnatm1rQkJCTHp6eq59QFG4GHOF3+UAAFfQyZMnVa1aNd1555168803S7ocXAX27dunqKgoxcfH5/kR6Sg9du3apZo1a2r8+PEaO3ZsSZeDqxxzigFc08qXL6+RI0fqnXfeKfIyTwBKt4kTJ6pixYq5pr4Al4M5xQCuef/617+UlpamAwcO5FoCDcDVKSMjQzVr1lSfPn1UpkyZki4H1wCmTwAAcBGmTwDWRCgGAACA5TGnGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWB6hGAAAAJZHKAYAAIDlEYoBAABgeYRiAAAAWN7/A62LkuLi06TaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.hist(residuals, bins=30, alpha=0.7, edgecolor='black')\n", + "\n", + "plt.xlabel(\"Residuals (Predicted - Experimental)\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.title(\"Residuals Distribution\")\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R²-Wert: 0.3529058792913994\n" + ] + } + ], + "source": [ + "from sklearn.metrics import r2_score\n", + "\n", + "# Berechnung des R²-Werts\n", + "r2 = r2_score(ccs_df['CCS_AVG'], ccs_df['CCS_pred'].apply(lambda x: x.item()))\n", + "print(f\"R²-Wert: {r2}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Größte Abweichungen:\n", + " CCS_AVG CCS_pred error\n", + "36656 270.05 tensor(158.9468, device='cuda:0') 111.103192\n", + "36608 270.69 tensor(161.2299, device='cuda:0') 109.460081\n", + "38889 274.48 tensor(167.1784, device='cuda:0') 107.301564\n", + "32956 255.17 tensor(150.8709, device='cuda:0') 104.299089\n", + "32336 257.59 tensor(154.0916, device='cuda:0') 103.498371\n", + "... ... ... ...\n", + "13340 246.72 tensor(163.4458, device='cuda:0') 83.274214\n", + "37774 257.49 tensor(174.2220, device='cuda:0') 83.268015\n", + "39892 274.06 tensor(190.8424, device='cuda:0') 83.217639\n", + "36922 272.35 tensor(189.1557, device='cuda:0') 83.194315\n", + "1558 264.20 tensor(181.1316, device='cuda:0') 83.068439\n", + "\n", + "[100 rows x 3 columns]\n" + ] + } + ], + "source": [ + "ccs_df['error'] = (ccs_df['CCS_AVG'] - ccs_df['CCS_pred'].apply(lambda x: x.item())).abs()\n", + "\n", + "# 100 biggest deviation\n", + "largest_errors_df = ccs_df.nlargest(100, 'error')\n", + "print(\"Größte Abweichungen:\")\n", + "print(largest_errors_df[['CCS_AVG', 'CCS_pred', 'error']])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# not a very interpretable plot\n", + "\n", + "import seaborn as sns\n", + "\n", + "# ccs_pred_values = largest_errors_df['CCS_pred'].apply(lambda x: x.item())\n", + "\n", + "# plt.figure(figsize=(10, 6))\n", + "\n", + "# # Scatter plot of the CCS_AVG vs. CCS_pred\n", + "# sns.scatterplot(data=largest_errors_df, x='CCS_AVG', y=ccs_pred_values)\n", + "# plt.plot([largest_errors_df['CCS_AVG'].min(), largest_errors_df['CCS_AVG'].max()],\n", + "# [largest_errors_df['CCS_AVG'].min(), largest_errors_df['CCS_AVG'].max()],\n", + "# color='red', linestyle='--', label=\"Ideal Prediction (y = x)\")\n", + "# # Titles and labels\n", + "# plt.title(\"100 Biggest Errors Between CCS_AVG and CCS_pred\")\n", + "# plt.xlabel(\"CCS_AVG\")\n", + "# plt.ylabel(\"CCS_pred\")\n", + "# plt.legend()\n", + "# plt.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R² for [M+H]+: 0.2967642768217851\n", + "R² for [M-H]-: 0.4410620401378018\n" + ] + } + ], + "source": [ + "# R² for M+H and M-H seperately\n", + "if not debug_mode:\n", + " for mode in ['[M+H]+', '[M-H]-']:\n", + " mode_df = ccs_df[ccs_df['Precursor Adduct'] == mode]\n", + " r2_mode = r2_score(mode_df['CCS_AVG'], mode_df['CCS_pred'].apply(lambda x: x.item()))\n", + " print(f\"R² for {mode}: {r2_mode}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Split Train/Test/Validation Data" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "seed = 42\n", + "\n", + "def train_val_test_split(keys, test_size=0.1, val_size=0.1, rseed=seed):\n", + " temp_keys, test_keys = train_test_split(keys, test_size=test_size, random_state=rseed)\n", + " adjusted_val_size = val_size / (1 - test_size)\n", + " train_keys, val_keys = train_test_split(temp_keys, test_size=adjusted_val_size, random_state=rseed)\n", + " \n", + " return train_keys, val_keys, test_keys\n", + "\n", + "group_ids = ccs_df[\"group_id\"].astype(int)\n", + "keys = np.unique(group_ids)\n", + "example_not_in_test_split = True\n", + "\n", + "train, val, test = train_val_test_split(keys, rseed=seed)\n", + "ccs_df[\"datasplit\"] = ccs_df[\"group_id\"].apply(lambda x: 'train' if x in train else 'validation' if x in val else 'test' if x in test else 'VALUE ERROR')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "test_df = ccs_df[ccs_df['datasplit'] == 'test']" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "train_df = ccs_df[ccs_df['datasplit'] == 'train']" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R² for [M+H]+ (Test Set): 0.314364108288103\n", + "R² for [M-H]- (Test Set): 0.4507635426854415\n" + ] + } + ], + "source": [ + "if not debug_mode:\n", + " for mode in ['[M+H]+', '[M-H]-']:\n", + " mode_df = test_df[test_df['Precursor Adduct'] == mode]\n", + " r2_mode = r2_score(mode_df['CCS_AVG'], mode_df['CCS_pred'].apply(lambda x: x.item()))\n", + " print(f\"R² for {mode} (Test Set): {r2_mode}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1682682/2330683015.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " test_df['carbon_ratios'] = test_df[\"Metabolite\"].apply(lambda x: x.element_distribution['C'])\n", + "/tmp/ipykernel_1682682/2330683015.py:5: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " test_df[\"carbon_bin\"] = pd.cut(test_df[\"carbon_ratios\"], bins=10)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Error Compared to Carbon-Ratio\n", + "\n", + "test_df['carbon_ratios'] = test_df[\"Metabolite\"].apply(lambda x: x.element_distribution['C'])\n", + "\n", + "test_df[\"carbon_bin\"] = pd.cut(test_df[\"carbon_ratios\"], bins=10)\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "sns.boxplot(data=test_df, x=\"carbon_bin\", y=\"error\")\n", + "plt.title(\"Prediction Error by Carbon Ratio Bins\", fontsize=14)\n", + "plt.xlabel(\"Carbon Ratio Bins\", fontsize=12)\n", + "plt.ylabel(\"Error\", fontsize=12)\n", + "plt.xticks(rotation=45, fontsize=10)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "import fiora.MOL.constants\n", + "\n", + "def is_element_included(element, metabolite): # element as symbol\n", + " if element in metabolite.node_elements:\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + "def rare_element_included(metabolite):\n", + " rare_elements = fiora.MOL.constants.RARE_ELEMENTS\n", + " included = False\n", + " for element in rare_elements:\n", + " included = included or is_element_included(element, metabolite)\n", + " return included\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "# # check if there is any difference in rare_element_included ratios between filtered_df vs. ccs_df\n", + "# filtered_df['rare_element_included'] = filtered_df[\"Metabolite\"].apply(lambda x : rare_element_included(x))\n", + "\n", + "# # Calculate the ratio of True values in each DataFrame\n", + "# ccs_rare_ratio = ccs_df['rare_element_included'].mean()\n", + "# filtered_rare_ratio = filtered_df['rare_element_included'].mean()\n", + "\n", + "# print(f\"Ratio of rare element included in full dataset: {ccs_rare_ratio:.4f}\")\n", + "# print(f\"Ratio of rare element included in filtered dataset: {filtered_rare_ratio:.4f}\")\n", + "\n", + "# ccs_df['carbon_ratios'] = ccs_df[\"Metabolite\"].apply(lambda x: x.element_distribution['C'])\n", + "# filtered_df['carbon_ratios'] = filtered_df[\"Metabolite\"].apply(lambda x: x.element_distribution['C'])\n", + "\n", + "# ccs_carbon_ratio = ccs_df['carbon_ratios'].mean()\n", + "# filtered_carbon_ratio = filtered_df['carbon_ratios'].mean()\n", + "\n", + "# print(f\"Ratio of carbon in full dataset: {ccs_carbon_ratio:.4f}\")\n", + "# print(f\"Ratio of carbon in filtered dataset: {filtered_carbon_ratio:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1682682/2538906055.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " test_df['I_included'] = test_df[\"Metabolite\"].apply(lambda x : is_element_included('I', x))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Error Depending on Iod Existence\n", + "\n", + "test_df['I_included'] = test_df[\"Metabolite\"].apply(lambda x : is_element_included('I', x))\n", + "\n", + "sns.boxplot(data=test_df, x='I_included', y='error')\n", + "plt.xlabel(\"Element Br Included\")\n", + "plt.ylabel(\"Error\")\n", + "plt.title(\"Effect of Element I on Error\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Classify Metabolites Based on Murcko Scaffold and Evaluate the Error Rates Depending on These Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1682682/2821679205.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " test_df['rare_element_included'] = test_df[\"Metabolite\"].apply(lambda x : rare_element_included(x))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Error Depending on Rare Element Existence\n", + "\n", + "test_df['rare_element_included'] = test_df[\"Metabolite\"].apply(lambda x : rare_element_included(x))\n", + "\n", + "sns.boxplot(data=test_df, x='rare_element_included', y='error')\n", + "plt.xlabel(\"Rare Element Included\")\n", + "plt.ylabel(\"Error\")\n", + "plt.title(\"Effect of Rare Elements on Error\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "datasplit\n", + "train 35572\n", + "validation 4446\n", + "test 4389\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "datasplit_value_counts = ccs_df['datasplit'].value_counts()\n", + "print(datasplit_value_counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "ccs_df['carbon_ratio'] = ccs_df['Metabolite'].apply(lambda x: x.element_distribution['C'] / len(x.node_elements))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Class PropertyTrainer

" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "import torch_geometric.loader as geom_loader\n", + "from torchmetrics import Accuracy, MetricTracker, MetricCollection, Precision, Recall, PrecisionRecallCurve, MeanSquaredError, MeanAbsoluteError, R2Score, PearsonCorrCoef\n", + "from sklearn.model_selection import train_test_split\n", + "from typing import Literal, List, Callable, Any, Dict\n", + "\n", + "from fiora.GNN.Trainer import Trainer\n", + "from fiora.GNN.Datasets import collate_graph_batch, collate_graph_edge_batch\n", + "from fiora.GNN.Losses import WeightedMSELoss, WeightedMAELoss" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# debug freezing for LoRA\n", + "\n", + "def debug_freezing(model, optimizer=None, tag=\"\"):\n", + " params = list(model.model.named_parameters()) if hasattr(model, \"model\") else list(model.named_parameters())\n", + " trainable_params = [n for n,p in params if p.requires_grad]\n", + " frozen_params = [n for n,p in params if not p.requires_grad]\n", + " print((f\"[DEBUG {tag}] trainable={len(trainable_params)}, frozen={len(frozen_params)}\"))\n", + " if trainable_params: #not 0\n", + " suspicious_params = [n for n in trainable_params if \"delta\" not in n.lower()]\n", + " if suspicious_params:\n", + " print(\"Non-LoRA trainables : \", suspicious_params)\n", + "\n", + " if optimizer is not None:\n", + " opt_names = set() # set of param names that actually go in the optimizer\n", + " for g in optimizer.param_groups:\n", + " for p in g[\"params\"]:\n", + " for n, q in params:\n", + " if q is p: \n", + " opt_names.add(n)\n", + " break\n", + "\n", + " leaks = [n for n,p in params if (p.requires_grad and n not in opt_names) or (not p.requires_grad and n in opt_names)]\n", + " if leaks:\n", + " print(\" -> Optimizer mismatch (leaks):\")\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "class PropertyTrainer(Trainer):\n", + " def __init__(self, data: Any, train_val_split: float= 0.8, split_by_group: bool=False, only_training: bool=False, train_keys: List[int]=[], val_keys: List[int]=[], test_keys: List[int]=[], y_tag: str=\"y\", metric_dict: Dict=None, problem_type: Literal[\"classification\", \"regression\", \"softmax_regression\"]=\"classification\", library: Literal[\"standard\", \"geometric\"]=\"geometric\", num_workers: int=0, seed: int=42, device: str=\"cpu\"):\n", + " \n", + " super().__init__(data, train_val_split, split_by_group, only_training, train_keys, val_keys, test_keys, seed, num_workers, device)\n", + " self.y_tag = y_tag\n", + " self.problem_type = problem_type\n", + "\n", + " self.data = data \n", + " \n", + " # Initialize torch metrics based on dictionary \n", + " if metric_dict:\n", + " self.metrics = {\n", + " data_split: MetricTracker(MetricCollection({\n", + " t: M() for t,M in metric_dict.items() # t: metric name, M() corresponding metric class instance (e.g. torchmetrics.R2Score())\n", + " })).to(device)\n", + " for data_split in [\"train\", \"val\", \"test\"]\n", + " }\n", + " else:\n", + " self.metrics = self._get_default_metrics(problem_type)\n", + " self.loader_base = geom_loader.DataLoader if library == \"geometric\" else DataLoader\n", + " \n", + " def _training_loop(self, model, dataloader, optimizer, loss_fn, metrics, property: str=\"ccs\", with_weights=False, with_RT=False, with_CCS=True, rt_metric=False, title=\"\"):\n", + " metrics.increment() \n", + "\n", + " for batch in dataloader: # enumerate \n", + " # print(batch)\n", + " # Feed forward\n", + " batch = batch.to(dev) # \"cuda:1\"\n", + "\n", + " model.train() # training mode\n", + "\n", + " # print(\"Is model in training mode?\", model.training)\n", + " \n", + " y_pred = model(batch)\n", + " # print(\"requires_grad:\", y_pred[property].requires_grad)\n", + " # print(\"grad_fn:\", y_pred[property].grad_fn) \n", + "\n", + "\n", + " target = batch[property]#.to(torch.float32)\n", + " #target = target.view(-1, 1)\n", + " #target = target.to(\"cuda:1\")\n", + "\n", + " # print(\"Predicted shape:\", y_pred[property].shape)\n", + " # print(\"Target shape:\", target.shape)\n", + "\n", + " loss = loss_fn(y_pred[property], target) \n", + "\n", + " # Backpropagate\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + "\n", + " # Debugging purpose, REMOVE AFTERWARDS\n", + " if not hasattr(self, \"_freeze_checked\") and isinstance(model, FinetuneFioraWrapper):\n", + " # base params must have no grads\n", + " bad = [n for n,p in model.model.named_parameters() if p.grad is not None and p.grad.abs().sum().item() > 0]\n", + " print(f\"[DEBUG] grads_on_frozen={len(bad)}\")\n", + " if bad:\n", + " raise RuntimeError(\"Frozen params are receiving gradients\")\n", + "\n", + " delta_has_grad = any(d.grad is not None and d.grad.abs().sum().item() > 0 for d in model.parameters())\n", + " print(f\"[DEBUG] any_delta_grad={delta_has_grad}\")\n", + " if not delta_has_grad:\n", + " raise RuntimeError(\"No gradients on LoRA deltas — check forward (use W.detach()+Δ or functional_call).\")\n", + "\n", + " self._freeze_checked = True\n", + "\n", + " optimizer.step() \n", + "\n", + " def _validation_loop(self, model, dataloader, loss_fn, metrics, with_weights=False, with_RT=False, with_CCS=True, property: str=\"ccs\", rt_metric=False, title=\"Validation\"):\n", + " metrics.increment()\n", + " with torch.no_grad():\n", + " for batch in dataloader:\n", + " model.eval()\n", + " y_pred = model(batch) # with_CCS = True\n", + " loss = loss_fn(y_pred[property], batch[property])\n", + " \n", + " metrics(y_pred[property], batch[property]) # call update \n", + "\n", + " # End of Validation cycle\n", + " stats = metrics.compute()\n", + " print(f'\\t{title} RMSE: {torch.sqrt(stats[\"mse\"]):>.4f}')\n", + " return stats\n", + " \n", + " def _test_loop(self, model, dataloader, loss_fn, metrics, property: str=\"ccs\", rt_metric=False):\n", + " metrics.increment()\n", + " all_preds = []\n", + " all_targets = []\n", + " all_smiles = []\n", + " all_precursors = []\n", + " all_ring_counts = []\n", + " all_presence_rare_elements = []\n", + "\n", + " with torch.no_grad():\n", + " for batch in dataloader:\n", + " model.eval()\n", + " y_pred = model(batch) # Forward pass\n", + " loss = loss_fn(y_pred[property], batch[property])\n", + "\n", + " metrics(y_pred[property], batch[property]) # Call update on metrics\n", + "\n", + " all_preds.append(y_pred[property].cpu())\n", + " all_targets.append(batch[property].cpu())\n", + "\n", + " if \"smiles\" in batch:\n", + " all_smiles.extend(batch[\"smiles\"])\n", + "\n", + " if \"precursor_positive\" in batch:\n", + " all_precursors.extend(batch[\"precursor_positive\"])\n", + " \n", + " if \"ring_count\" in batch:\n", + " all_ring_counts.extend(batch[\"ring_count\"])\n", + "\n", + " if \"presence_rare_elements\" in batch:\n", + " all_presence_rare_elements.extend(batch[\"presence_rare_elements\"])\n", + " \n", + "\n", + " # End of Test cycle\n", + " stats = metrics.compute()\n", + " # print(f'\\tTest RMSE: {torch.sqrt(stats[\"mse\"]):>.4f}')\n", + "\n", + " stats[\"predictions\"] = torch.cat(all_preds).numpy()\n", + " stats[\"targets\"] = torch.cat(all_targets).numpy()\n", + " stats[\"smiles\"] = all_smiles\n", + " stats[\"precursor_positive\"] = all_precursors\n", + " stats[\"ring_counts\"] = all_ring_counts\n", + " stats[\"presence_rare_elements\"] = all_presence_rare_elements\n", + "\n", + " for stat in stats:\n", + " stat_name = stat.upper()\n", + " if stat_name == \"MSE\":\n", + " print(f'\\tTest RMSE: {torch.sqrt(stats[\"mse\"]):>.4f}')\n", + " elif stat_name in [\"MSE\", \"MAE\", \"R2\", \"PEARSON\"]:\n", + " print(f\"\\tTest {stat_name}: {stats[stat]:.4f}\")\n", + " else:\n", + " continue\n", + " \n", + " return stats\n", + " \n", + " # Training function\n", + " def train(self, model, optimizer, loss_fn, scheduler=None, batch_size=16, epochs=2, val_every_n_epochs=1, with_RT=True, with_CCS=True, rt_metric=False, tag=\"\") -> Dict[str, Any]:\n", + " \n", + " # Set up checkpoint system and model info\n", + " self._init_checkpoint_system(save_path=f\"saved_models/checkpoint_{tag}.best.pt\")\n", + " model.model_params[\"training_label\"] = self.y_tag\n", + " \n", + " # Stage data into dataloader\n", + " training_loader = self.loader_base(self.data, batch_size=batch_size, num_workers=self.num_workers, shuffle=True)\n", + " if not self.only_training:\n", + " validation_loader = self.loader_base(self.validation_data, batch_size=batch_size, num_workers=self.num_workers, shuffle=True)\n", + " using_weighted_loss_func = isinstance(loss_fn, WeightedMSELoss) | isinstance(loss_fn, WeightedMAELoss)\n", + " \n", + " # Main loop\n", + " for e in range(epochs):\n", + " # Training\n", + " self._training_loop(model, training_loader, optimizer, loss_fn, self.metrics[\"train\"], title=f'Epoch {e + 1}/{epochs}: ', with_weights=using_weighted_loss_func, with_RT=with_RT, with_CCS=with_CCS, rt_metric=rt_metric)\n", + " # Validation\n", + " is_val_cycle = not self.only_training and ((e + 1) % val_every_n_epochs == 0)\n", + " if is_val_cycle: \n", + " val_stats = self._validation_loop(model, validation_loader, loss_fn, self.metrics[\"val\"], with_weights=using_weighted_loss_func, with_RT=with_RT, with_CCS=with_CCS, rt_metric=rt_metric, title=\"Validation\")\n", + " \n", + " # Update checkpoint\n", + " if val_stats[\"mse\"].tolist() < self.checkpoint_stats[\"val_loss\"]:\n", + " self._update_checkpoint({\"epoch\": e+1, \"val_loss\": val_stats[\"mse\"].tolist()}, model)\n", + " print(f\"\\t >> Set new checkpoint to epoch {e+1}\")\n", + " \n", + " # End of epoch: Advance scheduler\n", + " if scheduler:\n", + " if isinstance(scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\n", + " if is_val_cycle:\n", + " scheduler.step(torch.sqrt(val_stats[\"mse\"]))\n", + " else:\n", + " scheduler.step()\n", + " \n", + " print(\"Finished Training!\")\n", + " return self.checkpoint_stats\n", + "\n", + " def test(self, model, loss_fn, batch_size=16, tag=\"\") -> Dict[str, Any]:\n", + " \"\"\"\n", + " Test the trained model on the test dataset and compute the RMSE.\n", + " \"\"\"\n", + " if model is None:\n", + " raise ValueError(\"Model is None. Ensure the model is correctly initialized and passed.\")\n", + "\n", + " # Stage test data into dataloader\n", + " test_loader = self.loader_base(self.test_data, batch_size=batch_size, num_workers=self.num_workers, shuffle=False)\n", + "\n", + " # Test loop\n", + " print(f\"Testing model: {tag}\")\n", + " test_stats = self._test_loop(model, test_loader, loss_fn, self.metrics[\"test\"])\n", + "\n", + " return test_stats\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "geo_data = ccs_df['geo_data'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "# geo_data = torch.tensor(geo_data, dtype=torch.float32).to(\"cuda:1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using pre-set train/validation/test keys\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lbarbut/anaconda3/envs/fiora/lib/python3.10/site-packages/torchmetrics/utilities/prints.py:43: FutureWarning: The default value for `maximize` will be changed from `True` to `None` in v1.7.0 of TorchMetrics,will automatically infer the value based on the `higher_is_better` attribute of the metric (if such attribute exists) or raise an error if it does not. If you are explicitly setting the `maximize` argument to either `True` or `False` already, you can ignore this warning.\n", + " warnings.warn(*args, **kwargs) # noqa: B028\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tValidation RMSE: 15.0869\n", + "\t >> Set new checkpoint to epoch 1\n", + "\tValidation RMSE: 14.4793\n", + "\t >> Set new checkpoint to epoch 2\n", + "\tValidation RMSE: 14.3275\n", + "\t >> Set new checkpoint to epoch 3\n", + "\tValidation RMSE: 14.2368\n", + "\t >> Set new checkpoint to epoch 4\n", + "\tValidation RMSE: 14.0803\n", + "\t >> Set new checkpoint to epoch 5\n", + "\tValidation RMSE: 13.9712\n", + "\t >> Set new checkpoint to epoch 6\n", + "\tValidation RMSE: 13.8536\n", + "\t >> Set new checkpoint to epoch 7\n", + "\tValidation RMSE: 13.7686\n", + "\t >> Set new checkpoint to epoch 8\n", + "\tValidation RMSE: 13.6701\n", + "\t >> Set new checkpoint to epoch 9\n", + "\tValidation RMSE: 13.6138\n", + "\t >> Set new checkpoint to epoch 10\n", + "\tValidation RMSE: 13.4433\n", + "\t >> Set new checkpoint to epoch 11\n", + "\tValidation RMSE: 13.3516\n", + "\t >> Set new checkpoint to epoch 12\n", + "\tValidation RMSE: 13.2831\n", + "\t >> Set new checkpoint to epoch 13\n", + "\tValidation RMSE: 13.2061\n", + "\t >> Set new checkpoint to epoch 14\n", + "\tValidation RMSE: 13.2056\n", + "\t >> Set new checkpoint to epoch 15\n", + "\tValidation RMSE: 13.1501\n", + "\t >> Set new checkpoint to epoch 16\n", + "\tValidation RMSE: 13.1945\n", + "\tValidation RMSE: 12.8891\n", + "\t >> Set new checkpoint to epoch 18\n", + "\tValidation RMSE: 12.8893\n", + "\tValidation RMSE: 12.8899\n", + "\tValidation RMSE: 12.6821\n", + "\t >> Set new checkpoint to epoch 21\n", + "\tValidation RMSE: 12.6379\n", + "\t >> Set new checkpoint to epoch 22\n", + "\tValidation RMSE: 12.8301\n", + "\tValidation RMSE: 12.4525\n", + "\t >> Set new checkpoint to epoch 24\n", + "\tValidation RMSE: 12.4874\n", + "\tValidation RMSE: 12.3834\n", + "\t >> Set new checkpoint to epoch 26\n", + "\tValidation RMSE: 12.6656\n", + "\tValidation RMSE: 12.2792\n", + "\t >> Set new checkpoint to epoch 28\n", + "\tValidation RMSE: 12.3258\n", + "\tValidation RMSE: 12.0949\n", + "\t >> Set new checkpoint to epoch 30\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[68], line 20\u001b[0m\n\u001b[1;32m 7\u001b[0m trainer_fiora \u001b[38;5;241m=\u001b[39m PropertyTrainer(\n\u001b[1;32m 8\u001b[0m data\u001b[38;5;241m=\u001b[39mgeo_data,\n\u001b[1;32m 9\u001b[0m y_tag\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mccs\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 16\u001b[0m device\u001b[38;5;241m=\u001b[39mdev \u001b[38;5;66;03m# \"cuda:1\"\u001b[39;00m\n\u001b[1;32m 17\u001b[0m )\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[0;32m---> 20\u001b[0m checkpoint \u001b[38;5;241m=\u001b[39m \u001b[43mtrainer_fiora\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbase_model\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[43m \u001b[49m\u001b[43mloss_fn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloss_fn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m60\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[43m \u001b[49m\u001b[43mval_every_n_epochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[43m \u001b[49m\u001b[43mwith_CCS\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 27\u001b[0m \u001b[43m \u001b[49m\u001b[43mtag\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfiora\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 28\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 30\u001b[0m model \u001b[38;5;241m=\u001b[39m FinetuneFioraWrapper(base_model)\n\u001b[1;32m 32\u001b[0m \u001b[38;5;66;03m# pre-optimzer check: is the model in the expected freeze state?\u001b[39;00m\n", + "Cell \u001b[0;32mIn[65], line 155\u001b[0m, in \u001b[0;36mPropertyTrainer.train\u001b[0;34m(self, model, optimizer, loss_fn, scheduler, batch_size, epochs, val_every_n_epochs, with_RT, with_CCS, rt_metric, tag)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;66;03m# Main loop\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m e \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(epochs):\n\u001b[1;32m 154\u001b[0m \u001b[38;5;66;03m# Training\u001b[39;00m\n\u001b[0;32m--> 155\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_training_loop\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtraining_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloss_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmetrics\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtrain\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mEpoch \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43me\u001b[49m\u001b[38;5;250;43m \u001b[39;49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;250;43m \u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mepochs\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m: \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwith_weights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43musing_weighted_loss_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwith_RT\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwith_RT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwith_CCS\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwith_CCS\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrt_metric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrt_metric\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 156\u001b[0m \u001b[38;5;66;03m# Validation\u001b[39;00m\n\u001b[1;32m 157\u001b[0m is_val_cycle \u001b[38;5;241m=\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39monly_training \u001b[38;5;129;01mand\u001b[39;00m ((e \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m%\u001b[39m val_every_n_epochs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)\n", + "Cell \u001b[0;32mIn[65], line 34\u001b[0m, in \u001b[0;36mPropertyTrainer._training_loop\u001b[0;34m(self, model, dataloader, optimizer, loss_fn, metrics, property, with_weights, with_RT, with_CCS, rt_metric, title)\u001b[0m\n\u001b[1;32m 30\u001b[0m model\u001b[38;5;241m.\u001b[39mtrain() \u001b[38;5;66;03m# training mode\u001b[39;00m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;66;03m# print(\"Is model in training mode?\", model.training)\u001b[39;00m\n\u001b[0;32m---> 34\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# print(\"requires_grad:\", y_pred[property].requires_grad)\u001b[39;00m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# print(\"grad_fn:\", y_pred[property].grad_fn) \u001b[39;00m\n\u001b[1;32m 39\u001b[0m target \u001b[38;5;241m=\u001b[39m batch[\u001b[38;5;28mproperty\u001b[39m]\u001b[38;5;66;03m#.to(torch.float32)\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1746\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n", + "File \u001b[0;32m~/repos/fiora/fiora/GNN/GNNModules.py:243\u001b[0m, in \u001b[0;36mGNNCompiler.forward\u001b[0;34m(self, batch, with_RT, with_CCS)\u001b[0m\n\u001b[1;32m 240\u001b[0m batch[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnode_embedding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnode_embedding(batch[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 241\u001b[0m batch[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124medge_embedding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39medge_embedding(batch[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124medge_attr\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[0;32m--> 243\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mGNN_module\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 245\u001b[0m edge_values \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39medge_module(X, batch)\n\u001b[1;32m 246\u001b[0m graph_values \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprecursor_module(X, batch)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1746\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n", + "File \u001b[0;32m~/repos/fiora/fiora/GNN/GNNModules.py:83\u001b[0m, in \u001b[0;36mGNN.forward\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m 81\u001b[0m batch_args \u001b[38;5;241m=\u001b[39m {key: batch[value] \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m GeometricLayer[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgnn_type][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbatch_args\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mitems()}\n\u001b[1;32m 82\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m layer \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgraph_layers:\n\u001b[0;32m---> 83\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mactivation(\u001b[43mlayer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mbatch_args\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 84\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlatent_dropout(X)\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m X\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1746\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch_geometric/nn/conv/rgcn_conv.py:267\u001b[0m, in \u001b[0;36mRGCNConv.forward\u001b[0;34m(self, x, edge_index, edge_type)\u001b[0m\n\u001b[1;32m 260\u001b[0m out \u001b[38;5;241m=\u001b[39m out \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpropagate(\n\u001b[1;32m 261\u001b[0m tmp,\n\u001b[1;32m 262\u001b[0m x\u001b[38;5;241m=\u001b[39mweight[i, x_l],\n\u001b[1;32m 263\u001b[0m edge_type_ptr\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 264\u001b[0m size\u001b[38;5;241m=\u001b[39msize,\n\u001b[1;32m 265\u001b[0m )\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 267\u001b[0m h \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpropagate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtmp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx_l\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43medge_type_ptr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[43m \u001b[49m\u001b[43msize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 269\u001b[0m out \u001b[38;5;241m=\u001b[39m out \u001b[38;5;241m+\u001b[39m (h \u001b[38;5;241m@\u001b[39m weight[i])\n\u001b[1;32m 271\u001b[0m root \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mroot\n", + "File \u001b[0;32m/tmp/torch_geometric.nn.conv.rgcn_conv_RGCNConv_propagate_bwcn05b_.py:179\u001b[0m, in \u001b[0;36mpropagate\u001b[0;34m(self, edge_index, x, edge_type_ptr, size)\u001b[0m\n\u001b[1;32m 173\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate(\n\u001b[1;32m 174\u001b[0m out,\n\u001b[1;32m 175\u001b[0m )\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 179\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcollect\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43medge_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43medge_type_ptr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mmutable_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 186\u001b[0m \u001b[38;5;66;03m# Begin Message Forward Pre Hook #######################################\u001b[39;00m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mjit\u001b[38;5;241m.\u001b[39mis_scripting() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_compiling():\n", + "File \u001b[0;32m/tmp/torch_geometric.nn.conv.rgcn_conv_RGCNConv_propagate_bwcn05b_.py:64\u001b[0m, in \u001b[0;36mcollect\u001b[0;34m(self, edge_index, x, edge_type_ptr, size)\u001b[0m\n\u001b[1;32m 61\u001b[0m edge_index_j \u001b[38;5;241m=\u001b[39m edge_index[j]\n\u001b[1;32m 63\u001b[0m ptr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m---> 64\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjit\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mis_scripting\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(edge_index, EdgeIndex):\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m edge_index\u001b[38;5;241m.\u001b[39mis_sorted_by_row:\n\u001b[1;32m 66\u001b[0m (ptr, _), _ \u001b[38;5;241m=\u001b[39m edge_index\u001b[38;5;241m.\u001b[39mget_csr()\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/torch/_jit_internal.py:103\u001b[0m, in \u001b[0;36mis_scripting\u001b[0;34m()\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m7\u001b[39m):\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28mglobals\u001b[39m()[\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBroadcastingList\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m BroadcastingList1\n\u001b[0;32m--> 103\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mis_scripting\u001b[39m() \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mbool\u001b[39m:\n\u001b[1;32m 104\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 105\u001b[0m \u001b[38;5;124;03m Function that returns True when in compilation and False otherwise. This\u001b[39;00m\n\u001b[1;32m 106\u001b[0m \u001b[38;5;124;03m is useful especially with the @unused decorator to leave code in your\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[38;5;124;03m return unsupported_linear_op(x)\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m 122\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "loss_fn = torch.nn.MSELoss()\n", + "optimizer = torch.optim.Adam(base_model.parameters(), lr=0.0001)\n", + "train_keys, val_keys, test_keys = ccs_df[ccs_df[\"datasplit\"] == \"train\"][\"group_id\"].unique(), ccs_df[ccs_df[\"datasplit\"] == \"validation\"][\"group_id\"].unique(), ccs_df[ccs_df[\"datasplit\"] == \"test\"][\"group_id\"].unique()\n", + "\n", + "torch.autograd.set_detect_anomaly(True)\n", + "\n", + "trainer_fiora = PropertyTrainer(\n", + " data=geo_data,\n", + " y_tag='ccs',\n", + " problem_type=\"regression\",\n", + " train_keys=train_keys,\n", + " val_keys=val_keys,\n", + " test_keys=test_keys,\n", + " metric_dict=None,\n", + " split_by_group=True,\n", + " device=dev # \"cuda:1\"\n", + ")\n", + "\n", + "# Train the model\n", + "checkpoint = trainer_fiora.train(\n", + " model=base_model,\n", + " optimizer=optimizer,\n", + " loss_fn=loss_fn,\n", + " epochs=60,\n", + " val_every_n_epochs=1,\n", + " with_CCS=True,\n", + " tag=\"fiora\"\n", + ")\n", + "\n", + "model = FinetuneFioraWrapper(base_model)\n", + "\n", + "# pre-optimzer check: is the model in the expected freeze state?\n", + "debug_freezing(model, tag=\"pre-opt\")\n", + "\n", + "optimizer_lora = torch.optim.AdamW(model.parameters(), lr=0.0001, weight_decay=1e-6)\n", + "\n", + "# post-optimizer check: dose the optimizer only touch deltas and no base weights?\n", + "debug_freezing(model, optimizer=optimizer_lora, tag=\"post-opt\")\n", + "\n", + "checkpoint_lora = trainer_fiora.train(\n", + " model=model,\n", + " optimizer=optimizer_lora,\n", + " loss_fn=loss_fn,\n", + " epochs=60,\n", + " val_every_n_epochs=1,\n", + " with_CCS=True,\n", + " tag=\"lora_fiora\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "node_embedding.embeddings.0.weight | requires_grad=False\n", + "node_embedding.embeddings.1.weight | requires_grad=False\n", + "node_embedding.embeddings.2.weight | requires_grad=False\n", + "edge_embedding.embeddings.0.weight | requires_grad=False\n", + "edge_embedding.embeddings.1.weight | requires_grad=False\n", + "GNN_module.graph_layers.0.weight | requires_grad=False\n", + "GNN_module.graph_layers.0.root | requires_grad=False\n", + "GNN_module.graph_layers.0.bias | requires_grad=False\n", + "GNN_module.graph_layers.1.weight | requires_grad=False\n", + "GNN_module.graph_layers.1.root | requires_grad=False\n", + "GNN_module.graph_layers.1.bias | requires_grad=False\n", + "GNN_module.graph_layers.2.weight | requires_grad=False\n", + "GNN_module.graph_layers.2.root | requires_grad=False\n", + "GNN_module.graph_layers.2.bias | requires_grad=False\n", + "GNN_module.graph_layers.3.weight | requires_grad=False\n", + "GNN_module.graph_layers.3.root | requires_grad=False\n", + "GNN_module.graph_layers.3.bias | requires_grad=False\n", + "GNN_module.graph_layers.4.weight | requires_grad=False\n", + "GNN_module.graph_layers.4.root | requires_grad=False\n", + "GNN_module.graph_layers.4.bias | requires_grad=False\n", + "GNN_module.graph_layers.5.weight | requires_grad=False\n", + "GNN_module.graph_layers.5.root | requires_grad=False\n", + "GNN_module.graph_layers.5.bias | requires_grad=False\n", + "edge_module.dense_layers.0.weight | requires_grad=False\n", + "edge_module.dense_layers.0.bias | requires_grad=False\n", + "edge_module.dense_layers.1.weight | requires_grad=False\n", + "edge_module.dense_layers.1.bias | requires_grad=False\n", + "edge_module.output_layer.weight | requires_grad=False\n", + "edge_module.output_layer.bias | requires_grad=False\n", + "precursor_module.dense_layers.0.weight | requires_grad=False\n", + "precursor_module.dense_layers.0.bias | requires_grad=False\n", + "precursor_module.dense_layers.1.weight | requires_grad=False\n", + "precursor_module.dense_layers.1.bias | requires_grad=False\n", + "precursor_module.output_layer.weight | requires_grad=False\n", + "precursor_module.output_layer.bias | requires_grad=False\n", + "RT_module.dense_layers.0.weight | requires_grad=False\n", + "RT_module.dense_layers.0.bias | requires_grad=False\n", + "RT_module.dense_layers.1.weight | requires_grad=False\n", + "RT_module.dense_layers.1.bias | requires_grad=False\n", + "RT_module.output_layer.weight | requires_grad=False\n", + "RT_module.output_layer.bias | requires_grad=False\n", + "CCS_module.dense_layers.0.weight | requires_grad=False\n", + "CCS_module.dense_layers.0.bias | requires_grad=False\n", + "CCS_module.dense_layers.1.weight | requires_grad=False\n", + "CCS_module.dense_layers.1.bias | requires_grad=False\n", + "CCS_module.output_layer.weight | requires_grad=False\n", + "CCS_module.output_layer.bias | requires_grad=False\n" + ] + } + ], + "source": [ + "for name, p in model.model.named_parameters():\n", + " print(f\"{name:60} | requires_grad={p.requires_grad}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "weight | requires_grad: False\n", + "root | requires_grad: False\n", + "bias | requires_grad: False\n" + ] + } + ], + "source": [ + "#x = FinetuneFioraWrapper(base_model)\n", + "for name, param in model.model.GNN_module.graph_layers[0].named_parameters():\n", + " print(f\"{name:20} | requires_grad: {param.requires_grad}\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "# DO THIS TO LOAD MODEL AND TEST THAT MODEL\n", + "# ALSO FOR DIFFERENT MODELS\n", + "\n", + "# model = model.load(checkpoint[\"file\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[6, 0, 0],\n", + " [1, 0, 0],\n", + " [5, 1, 0],\n", + " [1, 2, 0],\n", + " [1, 0, 3],\n", + " [1, 1, 3],\n", + " [1, 1, 3],\n", + " [1, 0, 3],\n", + " [1, 1, 3],\n", + " [1, 1, 3],\n", + " [3, 0, 0],\n", + " [5, 1, 0],\n", + " [1, 2, 0],\n", + " [1, 2, 0],\n", + " [1, 2, 0],\n", + " [5, 0, 2],\n", + " [1, 2, 2],\n", + " [1, 2, 2],\n", + " [1, 0, 3],\n", + " [1, 0, 3],\n", + " [1, 1, 3],\n", + " [1, 1, 3],\n", + " [1, 1, 3],\n", + " [1, 1, 3]], device='cuda:0', dtype=torch.int32)\n" + ] + } + ], + "source": [ + "print(geo_data[0].x) # Assuming geo_data contains PyTorch Geometric Data objects\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Linear Model

" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "def initialize_weights(m):\n", + " if isinstance(m, nn.Linear):\n", + " nn.init.xavier_uniform_(m.weight) # Xavier Initialization\n", + " nn.init.zeros_(m.bias) # Initialize bias to zero" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using pre-set train/validation/test keys\n", + "\tValidation RMSE: 24.8540\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 1\n", + "\tValidation RMSE: 24.7667\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 2\n", + "\tValidation RMSE: 24.5289\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 3\n", + "\tValidation RMSE: 24.3779\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 4\n", + "\tValidation RMSE: 24.0905\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 5\n", + "\tValidation RMSE: 23.9129\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 6\n", + "\tValidation RMSE: 23.7170\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 7\n", + "\tValidation RMSE: 23.5357\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 8\n", + "\tValidation RMSE: 23.3947\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 9\n", + "\tValidation RMSE: 23.3407\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 10\n", + "\tValidation RMSE: 23.0451\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 11\n", + "\tValidation RMSE: 22.8918\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 12\n", + "\tValidation RMSE: 22.7423\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 13\n", + "\tValidation RMSE: 22.5898\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 14\n", + "\tValidation RMSE: 22.4727\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 15\n", + "\tValidation RMSE: 22.3024\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 16\n", + "\tValidation RMSE: 22.2555\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 17\n", + "\tValidation RMSE: 22.0192\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 18\n", + "\tValidation RMSE: 21.8901\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 19\n", + "\tValidation RMSE: 21.7711\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 20\n", + "\tValidation RMSE: 21.6324\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 21\n", + "\tValidation RMSE: 21.4753\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 22\n", + "\tValidation RMSE: 21.3323\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 23\n", + "\tValidation RMSE: 21.2046\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 24\n", + "\tValidation RMSE: 21.0742\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 25\n", + "\tValidation RMSE: 20.9940\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 26\n", + "\tValidation RMSE: 20.8175\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 27\n", + "\tValidation RMSE: 20.7345\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 28\n", + "\tValidation RMSE: 20.5917\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 29\n", + "\tValidation RMSE: 20.4625\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 30\n", + "\tValidation RMSE: 20.3318\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 31\n", + "\tValidation RMSE: 20.2120\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 32\n", + "\tValidation RMSE: 20.1113\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 33\n", + "\tValidation RMSE: 20.0341\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 34\n", + "\tValidation RMSE: 19.8811\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 35\n", + "\tValidation RMSE: 19.7562\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 36\n", + "\tValidation RMSE: 19.6558\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 37\n", + "\tValidation RMSE: 19.6685\n", + "\tValidation RMSE: 19.5125\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 39\n", + "\tValidation RMSE: 19.3665\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 40\n", + "\tValidation RMSE: 19.2815\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 41\n", + "\tValidation RMSE: 19.1294\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 42\n", + "\tValidation RMSE: 19.0515\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 43\n", + "\tValidation RMSE: 18.9509\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 44\n", + "\tValidation RMSE: 18.8395\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 45\n", + "\tValidation RMSE: 18.8358\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 46\n", + "\tValidation RMSE: 18.6582\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 47\n", + "\tValidation RMSE: 18.5655\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 48\n", + "\tValidation RMSE: 18.4854\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 49\n", + "\tValidation RMSE: 18.4068\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 50\n", + "\tValidation RMSE: 18.3771\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 51\n", + "\tValidation RMSE: 18.2213\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 52\n", + "\tValidation RMSE: 18.1430\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 53\n", + "\tValidation RMSE: 18.0860\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 54\n", + "\tValidation RMSE: 18.0660\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 55\n", + "\tValidation RMSE: 17.9151\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 56\n", + "\tValidation RMSE: 17.8327\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 57\n", + "\tValidation RMSE: 17.7587\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 58\n", + "\tValidation RMSE: 17.7128\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 59\n", + "\tValidation RMSE: 17.6699\n", + "Model saved to saved_models/checkpoint_linear.best.pt\n", + "\t >> Set new checkpoint to epoch 60\n", + "Finished Training!\n" + ] + } + ], + "source": [ + "# Simple linear model\n", + "class LinearModel(nn.Module):\n", + " def __init__(self, input_dim, output_dim):\n", + " super(LinearModel, self).__init__()\n", + " self.linear = nn.Linear(input_dim, output_dim)\n", + " self.activation = nn.ReLU()\n", + "\n", + " # Include model parameters as required by PropertyTrainer\n", + " self.model_params = {\n", + " \"training_label\": None, # changed to 'ccs' through y_tag in PropertyTrainer\n", + " \"input_dim\": input_dim,\n", + " \"output_dim\": output_dim,\n", + " }\n", + "\n", + " def forward(self, batch):\n", + " # Handle dictionary-style batches\n", + " # print(batch)\n", + " if isinstance(batch, dict):\n", + " x = batch.get(\"data\")\n", + " # print(f\"X: {x}\")\n", + "\n", + " # Handle PyTorch Geometric-style batches\n", + " elif hasattr(batch, \"weight\") and hasattr(batch, \"precursor_positive\"):\n", + " # , \"ring_count\", \"presence_rare_elements\", \"elem_distr_vec\"\n", + " attributes = [\"weight\", \"precursor_positive\"]\n", + "\n", + " # Extract attributes if they exist, otherwise use a zero tensor\n", + " features = []\n", + " \n", + " for attr in attributes:\n", + " if hasattr(batch, attr):\n", + "\n", + " value = getattr(batch, attr)\n", + "\n", + " # if isinstance(value, (list, np.ndarray)):\n", + " # tensor = torch.tensor(value, dtype=torch.float32).unsqueeze(-1).to(dev)\n", + " # else:\n", + " # tensor = value.unsqueeze(-1).float().to(dev)\n", + " if isinstance(value, (list, np.ndarray)):\n", + " value = np.array(value)\n", + "\n", + " if isinstance(value, torch.Tensor):\n", + " tensor = value.float().to(dev)\n", + " else:\n", + " tensor = torch.tensor(value, dtype=torch.float32).to(dev)\n", + "\n", + " # Ensure tensor is 2D: [batch_size, feature_dim]\n", + " if tensor.ndim == 1:\n", + " tensor = tensor.unsqueeze(-1)\n", + " elif tensor.ndim > 2:\n", + " tensor = tensor.view(tensor.size(0), -1)\n", + "\n", + " else:\n", + " tensor = torch.zeros_like(batch.weight).unsqueeze(-1).float().to(dev)\n", + " \n", + " features.append(tensor)\n", + "\n", + " # Concatenate all features\n", + " x = torch.cat(features, dim=-1)\n", + "\n", + " # Ensure the input is a float tensor\n", + " x = x.to(dev)#to(torch.float32).to(\"cuda:1\")\n", + "\n", + " # Forward pass\n", + " output = self.linear(x)\n", + " return {\"ccs\": output}\n", + "\n", + " else:\n", + " raise KeyError(\"Batch does not contain the required 'data' or 'weight' & 'precursor_positive' attributes.\")\n", + "\n", + " def save(self, filepath):\n", + " \"\"\"Save the model to the given filepath.\"\"\"\n", + " # GNNCompiler.save(filepath)\n", + " # print(f\"State Dict: {self.state_dict()}\")\n", + " torch.save(self.state_dict(), filepath)\n", + " print(f\"Model saved to {filepath}\")\n", + "\n", + " def load(self, filepath):\n", + " \"\"\"Load the model's state from a given filepath.\"\"\"\n", + " # Load the state dictionary from the saved checkpoint\n", + " # GNNCompiler.load(PATH=filepath)\n", + " self.load_state_dict(torch.load(filepath, map_location=\"cpu\")) # cuda:1 / cpu\n", + " print(f\"Model loaded from {filepath}\")\n", + " \n", + "# Instantiate the model\n", + "input_dim = 2\n", + "output_dim = 1\n", + "linear_model = LinearModel(input_dim, output_dim).to(dev)\n", + "\n", + "#linear_model.apply(initialize_weights)\n", + "\n", + "optimizer_linear = torch.optim.Adam(linear_model.parameters(), lr=0.001)\n", + "\n", + "# for param in linear_model.parameters():\n", + "# print(param)\n", + "\n", + "trainer_linear = PropertyTrainer(\n", + " data=geo_data,\n", + " y_tag=\"ccs\",\n", + " problem_type=\"regression\",\n", + " train_keys=train_keys,\n", + " val_keys=val_keys,\n", + " test_keys=test_keys,\n", + " metric_dict=None,\n", + " split_by_group=True,\n", + " device=dev, # \"cuda:1\"\n", + " library=\"geometric\"\n", + ")\n", + "\n", + "# Train the model\n", + "# linear_model = linear_model.to(\"cuda:1\")\n", + "linear_checkpoint = trainer_linear.train(\n", + " model=linear_model,\n", + " optimizer=optimizer_linear,\n", + " loss_fn=loss_fn,\n", + " epochs=60,\n", + " val_every_n_epochs=1,\n", + " with_CCS=True,\n", + " tag=\"linear\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "import torch_geometric as geom\n", + "optimizer_linear = torch.optim.Adam(linear_model.parameters(), lr=0.001)\n", + "y_pred = linear_model(geom.data.Batch.from_data_list(geo_data[0:5]))\n", + "loss = loss_fn(y_pred[\"ccs\"], geom.data.Batch.from_data_list(geo_data[0:5])[\"ccs\"]) " + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer_linear.zero_grad()\n", + "loss.backward()\n", + "optimizer_linear.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[176.7583],\n", + " [193.6345],\n", + " [211.5869],\n", + " [221.5266],\n", + " [166.4722]], device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pred[\"ccs\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[176.6300],\n", + " [192.2600],\n", + " [211.1200],\n", + " [204.2200],\n", + " [174.4700]], device='cuda:0')" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "geom.data.Batch.from_data_list(geo_data[0:5])[\"ccs\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "# import os\n", + "\n", + "# filepath = linear_checkpoint[\"file\"]\n", + "# print(f\"Checkpoint path: {filepath}\")\n", + "# print(f\"File exists: {os.path.exists(filepath)}\")\n", + "# print(f\"File size: {os.path.getsize(filepath) if os.path.exists(filepath) else 'N/A'} bytes\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "# linear_model.save('../../checkpoint_test.pt')\n", + "# lin_model_test = linear_model.load('../../checkpoint_test.pt')\n", + "\n", + "# print(lin_model_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded from saved_models/checkpoint_linear.best.pt\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_221813/850025175.py:82: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " self.load_state_dict(torch.load(filepath, map_location=\"cpu\")) # cuda:1 / cpu\n" + ] + } + ], + "source": [ + "# Load Linear Model from checkpoint\n", + "\n", + "linear_model.load(linear_checkpoint[\"file\"])\n", + "\n", + "# In Debug Mode\n", + "# RuntimeError: Invalid magic number; corrupt file?\n", + "# .pt file size: 19809568 bytes\n", + "\n", + "# Not In Debug Mode\n", + "# No error, linear_model = None\n", + "# .pt file size: 1600 bytes" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LinearModel(\n", + " (linear): Linear(in_features=2, out_features=1, bias=True)\n", + " (activation): ReLU()\n", + ")\n" + ] + } + ], + "source": [ + "print(linear_model)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

MLP Model

" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using pre-set train/validation/test keys\n", + "\tValidation RMSE: 24.7917\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 1\n", + "\tValidation RMSE: 24.3810\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 2\n", + "\tValidation RMSE: 23.3950\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 3\n", + "\tValidation RMSE: 22.2945\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 4\n", + "\tValidation RMSE: 20.7235\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 5\n", + "\tValidation RMSE: 17.7702\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 6\n", + "\tValidation RMSE: 15.9848\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 7\n", + "\tValidation RMSE: 15.5552\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 8\n", + "\tValidation RMSE: 15.7988\n", + "\tValidation RMSE: 15.5499\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 10\n", + "\tValidation RMSE: 15.3858\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 11\n", + "\tValidation RMSE: 16.4078\n", + "\tValidation RMSE: 15.3830\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 13\n", + "\tValidation RMSE: 15.4556\n", + "\tValidation RMSE: 15.4141\n", + "\tValidation RMSE: 15.4718\n", + "\tValidation RMSE: 15.3777\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 17\n", + "\tValidation RMSE: 15.3852\n", + "\tValidation RMSE: 15.3970\n", + "\tValidation RMSE: 16.9249\n", + "\tValidation RMSE: 15.3822\n", + "\tValidation RMSE: 15.4939\n", + "\tValidation RMSE: 15.4792\n", + "\tValidation RMSE: 16.4404\n", + "\tValidation RMSE: 15.4641\n", + "\tValidation RMSE: 16.0642\n", + "\tValidation RMSE: 16.6332\n", + "\tValidation RMSE: 15.4066\n", + "\tValidation RMSE: 16.8924\n", + "\tValidation RMSE: 15.6262\n", + "\tValidation RMSE: 15.4927\n", + "\tValidation RMSE: 15.5607\n", + "\tValidation RMSE: 15.6549\n", + "\tValidation RMSE: 15.3686\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 34\n", + "\tValidation RMSE: 15.5186\n", + "\tValidation RMSE: 15.5050\n", + "\tValidation RMSE: 17.7836\n", + "\tValidation RMSE: 15.5371\n", + "\tValidation RMSE: 15.4136\n", + "\tValidation RMSE: 15.4761\n", + "\tValidation RMSE: 15.4559\n", + "\tValidation RMSE: 15.5841\n", + "\tValidation RMSE: 15.5349\n", + "\tValidation RMSE: 16.0649\n", + "\tValidation RMSE: 15.9570\n", + "\tValidation RMSE: 15.3756\n", + "\tValidation RMSE: 15.8634\n", + "\tValidation RMSE: 15.3717\n", + "\tValidation RMSE: 15.8407\n", + "\tValidation RMSE: 15.4918\n", + "\tValidation RMSE: 16.7155\n", + "\tValidation RMSE: 15.4209\n", + "\tValidation RMSE: 15.4413\n", + "\tValidation RMSE: 15.3820\n", + "\tValidation RMSE: 15.3651\n", + "Model saved to saved_models/checkpoint_mlp.best.pt\n", + "\t >> Set new checkpoint to epoch 55\n", + "\tValidation RMSE: 15.5519\n", + "\tValidation RMSE: 15.5919\n", + "\tValidation RMSE: 15.5065\n", + "\tValidation RMSE: 15.7562\n", + "\tValidation RMSE: 15.6260\n", + "Finished Training!\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "\n", + "class MLPModel(nn.Module):\n", + " def __init__(self, input_dim, output_dim):\n", + " super(MLPModel, self).__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(input_dim, 32), # First hidden layer with 32 neurons\n", + " nn.ReLU(),\n", + " nn.Linear(32, 16), # Second hidden layer with 16 neurons\n", + " nn.ReLU(),\n", + " nn.Linear(16, output_dim) # Output layer\n", + " )\n", + "\n", + " # Include model parameters as required by PropertyTrainer\n", + " self.model_params = {\n", + " \"training_label\": None, # changed to 'ccs' through y_tag in PropertyTrainer\n", + " \"input_dim\": input_dim,\n", + " \"output_dim\": output_dim,\n", + " }\n", + "\n", + " def forward(self, batch):\n", + " if isinstance(batch, dict):\n", + " x = batch.get(\"data\")\n", + " elif hasattr(batch, \"weight\") and hasattr(batch, \"precursor_positive\"):\n", + " # , \"ring_count\", \"presence_rare_elements\", \"elem_distr_vec\"\n", + " attributes = [\"weight\", \"precursor_positive\"]\n", + "\n", + " # Extract attributes if they exist, otherwise use a zero tensor\n", + " features = []\n", + " \n", + " for attr in attributes:\n", + " if hasattr(batch, attr):\n", + " value = getattr(batch, attr)\n", + " if isinstance(value, (list, np.ndarray)):\n", + " value = np.array(value)\n", + "\n", + " if isinstance(value, torch.Tensor):\n", + " tensor = value.float().to(dev)\n", + " else:\n", + " tensor = torch.tensor(value, dtype=torch.float32).to(dev)\n", + "\n", + " # Ensure tensor is 2D: [batch_size, feature_dim]\n", + " if tensor.ndim == 1:\n", + " tensor = tensor.unsqueeze(-1)\n", + " elif tensor.ndim > 2:\n", + " tensor = tensor.view(tensor.size(0), -1)\n", + " else:\n", + " tensor = torch.zeros_like(batch.weight).unsqueeze(-1).float().to(dev)\n", + " features.append(tensor)\n", + "\n", + " # Concatenate all features\n", + " x = torch.cat(features, dim=-1)\n", + "\n", + " # Ensure the input is a float tensor\n", + " x = x.to(dev)\n", + " else:\n", + " raise KeyError(\"Batch does not contain 'data' or 'weight' & 'precursor_positive' attributes.\")\n", + "\n", + " return {\"ccs\": self.layers(x)}\n", + "\n", + " def save(self, filepath):\n", + " torch.save(self.state_dict(), filepath)\n", + " print(f\"Model saved to {filepath}\")\n", + "\n", + " def load(self, filepath):\n", + " self.load_state_dict(torch.load(filepath, map_location=\"cpu\")) # cuda:1 / cpu\n", + " print(f\"Model loaded from {filepath}\")\n", + "\n", + "# Instantiate Model\n", + "input_dim = 2\n", + "output_dim = 1 \n", + "mlp_model = MLPModel(input_dim, output_dim).to(dev)\n", + "\n", + "# print(f\"MLP Model: {mlp_model}\")\n", + "\n", + "optimizer_mlp = torch.optim.Adam(mlp_model.parameters(), lr=0.001)\n", + "\n", + "trainer_mlp = PropertyTrainer(\n", + " data=geo_data,\n", + " y_tag=\"ccs\",\n", + " problem_type=\"regression\",\n", + " train_keys=train_keys,\n", + " val_keys=val_keys,\n", + " test_keys=test_keys,\n", + " metric_dict=None,\n", + " split_by_group=True,\n", + " device=dev,\n", + " library=\"geometric\"\n", + ")\n", + "\n", + "# Train the model\n", + "mlp_checkpoint = trainer_mlp.train(\n", + " model=mlp_model,\n", + " optimizer=optimizer_mlp,\n", + " loss_fn=loss_fn,\n", + " epochs=60,\n", + " val_every_n_epochs=1,\n", + " with_CCS=True,\n", + " tag=\"mlp\"\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "# mlp_model = mlp_model.load(mlp_checkpoint[\"file\"])\n", + "# print(f\"MLP Model: {mlp_model}\")\n", + "\n", + "# filepath = mlp_checkpoint[\"file\"]\n", + "# print(f\"Checkpoint path: {filepath}\")\n", + "# print(f\"File exists: {os.path.exists(filepath)}\")\n", + "# print(f\"File size: {os.path.getsize(filepath) if os.path.exists(filepath) else 'N/A'} bytes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'epoch': 55, 'val_loss': 236.0852508544922, 'file': 'saved_models/checkpoint_mlp.best.pt'}\n" + ] + } + ], + "source": [ + "print(mlp_checkpoint)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded from saved_models/checkpoint_mlp.best.pt\n", + "MLPModel(\n", + " (layers): Sequential(\n", + " (0): Linear(in_features=2, out_features=32, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=32, out_features=16, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=16, out_features=1, bias=True)\n", + " )\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_221813/905334369.py:69: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " self.load_state_dict(torch.load(filepath, map_location=\"cpu\")) # cuda:1 / cpu\n" + ] + } + ], + "source": [ + "# Load MLP Model from checkpoint\n", + "\n", + "mlp_model.load(mlp_checkpoint[\"file\"])\n", + "\n", + "print(mlp_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GNNCompiler(\n", + " (node_embedding): FeatureEmbedding(\n", + " (embeddings): ModuleList(\n", + " (0): Embedding(10, 100)\n", + " (1-2): 2 x Embedding(5, 100)\n", + " )\n", + " )\n", + " (edge_embedding): FeatureEmbedding(\n", + " (embeddings): ModuleList(\n", + " (0): Embedding(4, 150)\n", + " (1): Embedding(5, 150)\n", + " )\n", + " )\n", + " (GNN_module): GNN(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (graph_layers): ModuleList(\n", + " (0-5): 6 x RGCNConv(300, 300, num_relations=4)\n", + " )\n", + " )\n", + " (edge_module): EdgePredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=909, out_features=909, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=909, out_features=10, bias=True)\n", + " )\n", + " (precursor_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=309, out_features=309, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=309, out_features=1, bias=True)\n", + " )\n", + " (RT_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=308, out_features=308, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=308, out_features=1, bias=True)\n", + " )\n", + " (CCS_module): GraphPredictor(\n", + " (activation): ELU(alpha=1.0)\n", + " (input_dropout): Dropout(p=0.2, inplace=False)\n", + " (latent_dropout): Dropout(p=0.1, inplace=False)\n", + " (dense_layers): ModuleList(\n", + " (0-1): 2 x Linear(in_features=308, out_features=308, bias=True)\n", + " )\n", + " (output_layer): Linear(in_features=308, out_features=1, bias=True)\n", + " )\n", + " (softmax): Softmax(dim=0)\n", + ")\n" + ] + } + ], + "source": [ + "# Load Fiora Model from checkpoint\n", + "\n", + "base_model.load(checkpoint[\"file\"]) # model = fiora_model\n", + "print(base_model)\n", + "# filepath = checkpoint[\"file\"]\n", + "# print(f\"Checkpoint path: {filepath}\")\n", + "# print(f\"File exists: {os.path.exists(filepath)}\")\n", + "# print(f\"File size: {os.path.getsize(filepath) if os.path.exists(filepath) else 'N/A'} bytes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "# # Load LoRA Fiora Model from checkpoint\n", + "# model.load(checkpoint_lora[\"file\"])\n", + "# print(f\"LoRA Model: {model}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Test (Benchmark)

" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "# test_stats_linear = trainer.test(model=linear_model, loss_fn=loss_fn, batch_size=16, tag=\"linear_model\")\n", + "# print(f\"Test RMSE: {torch.sqrt(test_stats_linear['mse']):>.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing model: fiora_test\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tTest MAE: 9.9885\n", + "\tTest RMSE: 14.4352\n", + "\tTest PEARSON: 0.7389\n", + "\tTest R2: 0.4877\n", + "Testing model: lora_fiora_test\n", + "\tTest MAE: 4.4625\n", + "\tTest RMSE: 7.0893\n", + "\tTest PEARSON: 0.9362\n", + "\tTest R2: 0.8764\n", + "Testing model: linear_test\n", + "\tTest MAE: 10.4483\n", + "\tTest RMSE: 17.0548\n", + "\tTest PEARSON: 0.6767\n", + "\tTest R2: 0.2849\n", + "Testing model: mlp_test\n", + "\tTest MAE: 8.7385\n", + "\tTest RMSE: 14.8324\n", + "\tTest PEARSON: 0.6784\n", + "\tTest R2: 0.4591\n" + ] + } + ], + "source": [ + "# Fiora Model Test\n", + "fiora_model = base_model.to(dev)\n", + "lora_fiora_model = model.to(dev)\n", + "\n", + "# Residual-Werte, plotten\n", + "\n", + "test_stats_fiora = trainer_fiora.test(fiora_model, loss_fn, 16, \"fiora_test\")\n", + "# print(f\"Test MSE: {(test_stats_fiora['mse']):>.4f}\")\n", + "test_stats_lora_fiora = trainer_fiora.test(lora_fiora_model, loss_fn, 16, \"lora_fiora_test\")\n", + "\n", + "test_stats_linear = trainer_linear.test(linear_model, loss_fn, 16, \"linear_test\")\n", + "\n", + "test_stats_mlp = trainer_mlp.test(mlp_model, loss_fn, 16, \"mlp_test\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Visualization of Test Results

" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "# Find global min and max for consistent axes\n", + "all_targets = np.concatenate([test_stats_fiora[\"targets\"], test_stats_linear[\"targets\"], test_stats_mlp[\"targets\"]])\n", + "all_predictions = np.concatenate([test_stats_fiora[\"predictions\"], test_stats_linear[\"predictions\"], test_stats_mlp[\"predictions\"]])\n", + "\n", + "global_min = min(all_targets.min(), all_predictions.min())\n", + "global_max = max(all_targets.max(), all_predictions.max())" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "# Test Stats Comparison of Models, Barplot\n", + "\n", + "def compare_models_barplot(model_names, test_stats, metric): # give model_name and test_stats as arrays with the correct order\n", + " metric = metric.lower()\n", + "\n", + " if not all(metric in stat for stat in test_stats) and metric != \"rmse\":\n", + " raise ValueError(f\"Metric '{metric}' not found in test stats dictionaries.\")\n", + "\n", + " if metric == 'rmse':\n", + " scores = [stat['mse'].cpu().numpy() for stat in test_stats] # loops test stat dictionaries and extracts the input metric\n", + " scores = np.sqrt(scores)\n", + " else:\n", + " scores = [stat[metric].cpu().numpy() for stat in test_stats]\n", + "\n", + " plt.figure(figsize=(8, 6))\n", + " plt.bar(model_names, scores, color=['blue', 'orange', 'green']) \n", + "\n", + " plt.xlabel(\"Models\")\n", + " plt.ylabel(metric.upper())\n", + " plt.title(f\"Model Comparison: {metric.upper()}\")\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compare_models_barplot([\"LoRA + Fiora\", \"Fiora\", \"Linear\", \"MLP\"], [test_stats_lora_fiora, test_stats_fiora, test_stats_linear, test_stats_mlp], \"r2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_test_stats_lora_fiora = test_stats_lora_fiora.copy()\n", + "filtered_test_stats_fiora = test_stats_fiora.copy()\n", + "filtered_test_stats_linear = test_stats_linear.copy()\n", + "filtered_test_stats_mlp = test_stats_mlp.copy()\n", + "\n", + "# Delete unwanted keys\n", + "for key in ['mae', 'mse', 'r2', 'pearson']:\n", + " filtered_test_stats_lora_fiora.pop(key, None)\n", + " filtered_test_stats_fiora.pop(key, None)\n", + " filtered_test_stats_linear.pop(key, None)\n", + " filtered_test_stats_mlp.pop(key, None)\n", + "\n", + "# Create a DataFrame that includes prediction and target CCS, as well as smiles\n", + "test_df_lora_fiora = pd.DataFrame({key: np.array(value).flatten() for key, value in filtered_test_stats_lora_fiora.items()})\n", + "test_df_fiora = pd.DataFrame({key: np.array(value).flatten() for key, value in filtered_test_stats_fiora.items()})\n", + "test_df_linear = pd.DataFrame({key: np.array(value).flatten() for key, value in filtered_test_stats_linear.items()})\n", + "test_df_mlp = pd.DataFrame({key: np.array(value).flatten() for key, value in filtered_test_stats_mlp.items()})\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "test_df_fiora['rare_element_included'] = test_df_fiora['smiles'].apply(rare_element_included_smiles)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "test_df_fiora['residuals'] = (test_df_fiora['predictions'] - test_df_fiora['targets']).abs()\n", + "\n", + "test_stats_lora_fiora['residuals'] = (test_df_lora_fiora['predictions'] - test_df_lora_fiora['targets']).abs()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "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", + "
predictionstargetssmilesprecursor_positivering_countspresence_rare_elementsrare_element_includedresiduals
0216.163742215.240005Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc...True5FalseFalse0.923737
1212.879791210.649994COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1True4FalseFalse2.229797
2185.736084169.889999Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1True3FalseFalse15.846085
3213.806793203.990005O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc...True5FalseFalse9.816788
4187.023651180.759995O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2True4FalseFalse6.263657
5181.252243167.710007N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2True3TrueTrue13.542236
6175.756470165.429993CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1True3TrueTrue10.326477
7210.745056180.089996COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)CTrue2FalseFalse30.655060
8187.511887183.139999O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1True3FalseFalse4.371887
9165.144241147.960007Clc1ccnc(c1)C(=O)Nc1nccs1True2FalseFalse17.184235
\n", + "
" + ], + "text/plain": [ + " predictions targets smiles \\\n", + "0 216.163742 215.240005 Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc... \n", + "1 212.879791 210.649994 COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1 \n", + "2 185.736084 169.889999 Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1 \n", + "3 213.806793 203.990005 O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc... \n", + "4 187.023651 180.759995 O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2 \n", + "5 181.252243 167.710007 N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2 \n", + "6 175.756470 165.429993 CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1 \n", + "7 210.745056 180.089996 COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)C \n", + "8 187.511887 183.139999 O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1 \n", + "9 165.144241 147.960007 Clc1ccnc(c1)C(=O)Nc1nccs1 \n", + "\n", + " precursor_positive ring_counts presence_rare_elements \\\n", + "0 True 5 False \n", + "1 True 4 False \n", + "2 True 3 False \n", + "3 True 5 False \n", + "4 True 4 False \n", + "5 True 3 True \n", + "6 True 3 True \n", + "7 True 2 False \n", + "8 True 3 False \n", + "9 True 2 False \n", + "\n", + " rare_element_included residuals \n", + "0 False 0.923737 \n", + "1 False 2.229797 \n", + "2 False 15.846085 \n", + "3 False 9.816788 \n", + "4 False 6.263657 \n", + "5 True 13.542236 \n", + "6 True 10.326477 \n", + "7 False 30.655060 \n", + "8 False 4.371887 \n", + "9 False 17.184235 " + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_df_fiora.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "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", + "
predictionstargetssmilesprecursor_positivering_countspresence_rare_elements
0214.638962215.240005Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc...True5False
1209.737411210.649994COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1True4False
2176.077805169.889999Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1True3False
3206.821671203.990005O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc...True5False
4178.808792180.759995O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2True4False
5171.915634167.710007N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2True3True
6164.695648165.429993CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1True3True
7179.088211180.089996COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)CTrue2False
8183.180374183.139999O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1True3False
9151.224426147.960007Clc1ccnc(c1)C(=O)Nc1nccs1True2False
\n", + "
" + ], + "text/plain": [ + " predictions targets smiles \\\n", + "0 214.638962 215.240005 Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc... \n", + "1 209.737411 210.649994 COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1 \n", + "2 176.077805 169.889999 Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1 \n", + "3 206.821671 203.990005 O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc... \n", + "4 178.808792 180.759995 O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2 \n", + "5 171.915634 167.710007 N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2 \n", + "6 164.695648 165.429993 CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1 \n", + "7 179.088211 180.089996 COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)C \n", + "8 183.180374 183.139999 O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1 \n", + "9 151.224426 147.960007 Clc1ccnc(c1)C(=O)Nc1nccs1 \n", + "\n", + " precursor_positive ring_counts presence_rare_elements \n", + "0 True 5 False \n", + "1 True 4 False \n", + "2 True 3 False \n", + "3 True 5 False \n", + "4 True 4 False \n", + "5 True 3 True \n", + "6 True 3 True \n", + "7 True 2 False \n", + "8 True 3 False \n", + "9 True 2 False " + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_df_lora_fiora.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAIqCAYAAAA3jsKQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/kUlEQVR4nO3dd1iTV/sH8G8SIIAyHQwRBetEcQ9Ki7a1xVm11lF5Xa+1VulytFaLIFZrl7a1L2hrWyd963pd1dpWW6UqOKEgjjpwIjiYigyT8/uDK8+PmIAggSeR7+e6uEyec5LnTgzJzck591EIIQSIiIiIiCyQUu4AiIiIiIgeFZNZIiIiIrJYTGaJiIiIyGIxmSUiIiIii8VkloiIiIgsFpNZIiIiIrJYTGaJiIiIyGIxmSUiIiIii8VkloiIiIgsFpNZMtC0aVMoFAq9H7VaDS8vLwwaNAg///yzbLHt3bsXCoUCvXr1qvRtdY9FThcvXoRCoUDTpk2r7RxVeY5MrVevXgavJWtra7i5uSE4OBhr167F47AJobHHaexn7ty5Rm+3d+9eWeJ+HI0bNw4KhQLjxo2TLQa5/1/lPn9l3L17F40bN0b79u2h1Wr12iryO7VlyxYA//+5dfHixZp/EJWwf/9+KBQKvPfee3KH8lixkjsAMl+BgYF44oknAAA5OTlISEjAtm3bsG3bNkydOhWLFy+WOUKyFO3bt0eHDh0AlHx4JScn47fffsNvv/2GLVu2YMOGDbL/oWEKpR+nMeW1UYm5c+ciMjISERERBsk/PX4++ugjXL16FcuWLYNSaXx8LTg4GO7u7kbbvL29qzM8k3vqqafQv39/fPXVV5g4cSKaN28ud0iPBSazVKZXX31Vb3Tj/v37mDp1Kv7zn//giy++wCuvvIKuXbvWaEzdunXDqVOnYG9vX6PnpaoZPHiwXmIihMBnn32GmTNnYtOmTdi4cSOGDRsmX4Am8uDjJJLD6tWrkZ+fb/aJ3rVr17Bo0SJ07doV/fv3L7Pf+++//9Bvmvbs2YPi4mI0atTIxFGaXmRkJHbs2IGZM2fif//7n9zhPBY4zYAqzMrKCp999hkcHR0BANu3b6/xGOzt7dGqVSuzf5Om8ikUCrz77rto2bIlAHleS0SPK29vb7Rq1crs/+iPjo5GYWEhJkyYUOX7atasGVq1agVra2sTRFa9OnfujPbt22Pr1q1mPy3CUjCZpUqxtbWVvhbJyMgw2mfPnj146aWX4OHhARsbGzRs2BBDhgxBXFyc0f5nz57Fv//9b/j4+ECtVqNu3bpo0qQJ+vfvjxUrVuj1fdh80Li4OPTt2xfOzs6oW7cuunTpgh9++KHMx1OROaxlzcU6efIkIiIiEBgYiEaNGsHGxgb16tVD7969sX79+jLvryyVeR4qKj8/H7Nnz8YTTzwBW1tbeHp6YsKECbh27Zpevz///BMKhQKtWrUqcw5rQUEB6tWrB4VCgZMnTz5SPKUpFAq0bdsWgPHX0uHDh/Hee++hW7ducHd3h42NDdzc3DBw4EDs3r3b6H2uXLlSmi+ZmZmJd955B82aNYNarTZ4zVT2dSqHysZYel742rVr0a1bN9StWxcNGjTAK6+8gsuXLwMoGRn/z3/+gw4dOqBOnTqoX78+xo0bhxs3bpQZyz///INJkyahWbNmsLW1hZOTE4KCgrB27Vqj/UvP20xMTMRLL72E+vXrQ61Wo02bNli0aJHBa02hUCAyMhJAyehV6bmRVZ0DW/q9o7i4GJ988gn8/PxgZ2eHevXq4aWXXsKpU6fKvH1WVhbmzZuHLl26wMnJCXZ2dvD19cXw4cPxyy+/VCiGh81lnTt3rtG51VqtFt9++y0CAwPh7OwMa2trNGzYEO3bt8ebb75p8N5U3nnu37+PZcuW4cknn4STk5P0nv7WW28ZvC/olH5dbdq0CU899RQcHR1Rp04dBAYGYufOnRV6/KUVFRVh+fLlUKvVGDlyZKVv/6Dy5szm5+fj448/RqdOneDg4AB7e3v4+fkhLCwMWVlZBv1Lfy5oNBosXrwYHTt2RN26dfWmQ1XlM2DcuHHQarVYunRplR87ARBED2jSpIkAIFasWGG0vXnz5gKAmDNnjkHb9OnTBQChVCpFt27dxLBhw0T37t2FQqEQKpVK/PDDD3r9k5OThaOjowAgWrZsKV566SUxbNgwERAQIOrWrSvat2+v1//PP/8UAETPnj0Nzr1+/XqhUqkEANG2bVvxyiuviKeeekooFAoxbdo0AUA8+JJPTU0VAESTJk0e+nykpqbqHZ8wYYIAIFq1aiWCg4PFiBEjREBAgFAqlQKAmDp1qsF9lXW+yj4P5dE9RwEBAaJHjx7C3t5e9OvXTwwbNkx4eHgIAMLd3V38888/erdr166dACB+++03o/f7ww8/CADimWeeqXAsPXv2FABERESE0fbnn39eABCjR482aHvuueeEUqkU7dq1k+Lv1KmT9P/45ZdfGtxmxYoVAoDo37+/8PHxES4uLuLFF18Uw4YNEyEhIVK/yr5Oq/o4H3a7P//806DtUWLUPTfvv/++sLKyEs8++6x4+eWXhbe3twAgGjduLDIzM8Xw4cOFra2t6NOnjxgyZIho2LChACD8/f1FYWGhwf2uX79e2NraSq/3IUOGiGeffVbUqVNHABDjx48v87G9//77wsbGRrRu3VqMHDlS9OzZU/o9ffvtt/VuM3bsWNG+fXsBQLRv316MHTtW+lm+fHmFntOxY8cKAGLs2LF6x3W/F08++aTo3bu3sLe3F3369BFDhw4VjRs3FgCEs7Ozwe+5EEIkJiaKRo0aCQDCyclJ9OvXT/p9t7OzM3g/Kuv/tbz/byGEiIiIMPo6Gj9+vAAgbG1tRe/evcUrr7wigoODpffizZs3V+g8BQUFonfv3tJ99e3bV4wYMUJ6/PXr1xfHjh0ziEv3ugoPDxcKhUIEBgaKESNGSP9XCoVC/O9//zP6mMryxx9/CADiqaeeKrOP7rxlPV+llfU+ffv2bdGhQwcBQDg6OooXX3xRDB06VNSvX18AED4+Pga30b1Pe3t7ixdffFHY2NiI5557TrzyyivC399f6vconwE6J06cEABEixYtHvrY6OGYzJKB8pLZkydPSh9ER44c0Wv79ttvBQDxxBNPiL///luvbd++fcLBwUHY2NjoJVG6N+n58+cbnCs/P1/s27dP71hZyez169eFg4ODACAWL16s17Z7927pg9iUyezevXvF+fPnDfqfPn1aeHl5CQDi0KFDFTpfZZ+H8uieI93/xaVLl6S2e/fuiaFDhwoAokePHnq3W758uQAgXnzxRaP327lzZwFAbNq0qcKxlJfk3bhxQzg5OQkAYsOGDQbtO3fuFGlpaQbHDx48KBwdHYW1tbW4evWqXpsumQUgnnvuOZGTk2Nw+0d5nVblcVbkdg9+WD9qjLrHXq9ePZGYmCgdz8/PF0899ZQAINq1ayeaNWsmLl68KLXfvHlTPPHEEwKAWLt2rd59JiUlCbVaLWxtbQ3+7y9evCj9EbRq1Sqjjw2AWLZsmV7bnj17pKT8ypUrem1lJXQV9bBkFoDo2LGjuH79utR27949ERwcLACI1157Te92d+7ckZK9MWPGiLy8PL327Oxs8fvvvxt97KZIZi9duiQACC8vL72YdU6ePKn3O17eeWbOnCkAiGbNmum9nxUVFUmJmY+Pj8EfNLrnzdnZWcTHxxuNubJJWVhYmAAg3n333TL7mCKZHTFihAAgunfvLm7duiUdz8vLE3379pX+wClN9z6te97PnDlj9JyP8hmgo9VqhbOzswBg8DtAlcdklgwYS2azs7PFr7/+Klq1aiUAiLCwML3baDQa4enpKQCIo0ePGr3fTz/9VAAQ06dPl47169dPABDHjx+vUGxlJbPz5883mqDpvP322yZPZsvzzTffGH2jLut8lX0eylP6Q3vLli0G7RkZGcLe3l4AEAcOHJCO5+fni3r16gmlUqmX6AghRFxcnDSyd//+/QrHYizJu3Pnjjhw4IDo0aOHlCBoNJpKPcZZs2YJACIqKkrvuC6Ztba2Nvoh86iv04cpnbiV95OQkGD0dqU/rKsSo+48Dz4vQgjxv//9T2rfsWOHQfuiRYuMjrLqkoHPP//caCyHDx8WAETnzp2NPraXXnrJ6O369OkjAIjVq1frHa/uZFahUOgl+jrx8fECgPD19dU7/uWXXwoAokOHDhV+7ZsymdU9v2X9kVnR89+7d0/UrVtXABDbtm0zuM3du3eFm5ubACBiYmL02nSvmyVLlhjcrqCgQPqj9PLlyxWOsX///gJAud+CPOz3qfT/sbH36UuXLgmlUikUCoXBH4VCCHH16lVpoKP0e2HpZPbB12dFlfUZUFpAQIAAILZu3fpI56D/x2oGVKbx48dj/PjxesdUKhXWrl2LkJAQveMJCQlIS0tDs2bN0LlzZ6P3p5uzePDgQelYt27dsHPnTkyePBmRkZHo2bMnbG1tKx2rbm7Yg3HpjB07Fl999VWl7/dh7ty5g19++QUJCQm4desWioqKAADXr18HAJw5c6ZC92Oq56E0Z2dnvPjiiwbHGzZsiD59+uB///sf9u7diyeffBIAYGdnh9deew0LFy7E0qVL8fHHH0u3iYqKAgC8/vrrUKlUlY4lMjJSmgtZ2sKFC/H++++Xebvbt29jx44dOHHiBLKyslBcXAygZH4xUPbz27FjR/j6+hocf9TXaUU9rDSXq6vrQ+/DFDH269fP4JhurruVlRVeeOGFMtvT0tKkY1qtVpoPOmLECKPn6tKlC+rWrYuEhAQUFBQYvG4HDhxo9HatW7fGrl27ypynWV28vb3Rvn17o/EAMIhn165dAIAJEyY80mu/qlq1agUHBwfs3LkTCxYswKhRo+Dj41Pp+zl69Cju3LkDV1dXo/8n9vb2GDlyJL766iv8+eefGDVqlEEfY7dTq9Xw9fVFQkICrl27hsaNG1coHt08+Xr16j20b1mluZ566qlybxcbGwutVotOnTrB39/foL1Ro0YIDg7G1q1b8eeff0rvhaUNHTq03HNU5TNA99jLWn9CFcdklspUus7szZs38ddffyEvLw+TJ09G8+bN0a1bN6nvhQsXAADnz59/aL3QmzdvSpffffdd7N+/H7t370afPn1gbW2N9u3bIygoCCNHjqxw6a+rV68CQJlv8o/y5v8w27dvx/jx43H79u0y++Tm5lbovkz1PJSmWxBhjO750D1vOlOmTMFnn32G77//HnPnzoWtrS1u3ryJDRs2QK1WY+LEiZWOA9BP8jIzMxEfH4+bN28iPDwcbdq0MZp0L1++HFOnTsXdu3fLvN+ynt+yFvQ96uu0okxRmssUMRqr9lG3bl0AgIeHB6ysDN/6HRwcAJQs9NO5ffu29BxXJEm5ffu2QWmksiqP6KqilD5fTXhYPIWFhXrHL126BKAkqZSDg4MDVqxYgfHjxyMsLAxhYWHw8PBAjx490KdPH4waNUr6vy2PLkkv772wWbNmen0fZMr/y5ycHL3blqcipbmMqepjbtiwYbkVIar6GaB77MYWoVHlMJmlMj1YZzYnJwdDhgzBn3/+ieHDh+PkyZPSL7pu5xZ3d3cEBweXe7/169eXLtvb2+P333/HkSNHsGvXLhw8eBAHDx7E0aNHsXjxYkyZMkUaFZTLg7vSACVvfCNGjMC9e/fw3nvvISQkBE2bNkXdunWhVCrx22+/ITg4uMK7W8n1PDwYn5eXF1566SWsX78e69atw9ixY/Hdd9+hsLAQo0ePRoMGDR7pPA8meYWFhfj3v/+NH3/8EWPGjMGpU6fg4eEhtR87dgyTJk2CSqXCJ598goEDB8Lb2xv29vZQKBT49ttvMWnSpDKfXzs7O6PHH/V1WpNMEWNZxecf1lZWLEDJtxsPo1arq3S+mmBu8ZRm7L0GKBkd7N27N7Zt24a//voLBw4cwObNm7F582aEh4fj999/R7t27ao9PlM+d87OzgAq/ge/HMp6HwFM8xmgS+hdXFxMHnttw2SWKszJyQnr1q1Dq1atcOnSJSxevBhhYWEA/n/Upl69eli5cmWl77tr167S6OP9+/exZcsWjBkzBtHR0Xj55ZfxzDPPlHv7Ro0a4fTp02XW7CvruI2NDQAgLy/PaHtxcbH0dVFp27dvx7179zBkyBB88sknBu26r8Erq6rPQ2nl1S/UtXl5eRm0vfXWW1i/fj2ioqLwr3/9C8uWLQMAvPHGGxV/IA+hVqvx/fff48iRIzh79izmzJmD7777TmrfsGEDhBB48803jW77+KjPb1VfpzXBnGKsX78+7OzscO/ePXz++eeyJfhy8vb2xqlTp3D69Gn07t27Svf1sPcb3SiwMU5OThg9ejRGjx4NALhy5QrefPNNbN26FW+88Qb27dtX7rl1I+apqall9tF9K1ATGw80bNgQAMod1awq3ePQPS5jHvUxm+IzQPfY3dzcKnVuMmS+f6KSWWrQoIGUwH7++efIzs4GUJKE1a9fHydPnkRKSkqVzmFlZYWXX35ZGpVKTEx86G169uwJAIiJiTHavnr1aqPHGzRoABsbG2RmZhqtsfnrr7/i/v37BsczMzMBAE2aNDFoE0Lgxx9/fGjMD/Moz0Np2dnZRjcjuHnzpjQP0NhXd4GBgejcuTOOHDmCsLAwXL58GV27dtWbVmIKtra20ofAypUrce7cOamtvOe3oKAAmzZteqRzmvJ1Wl3MKUaVSoXnn38eAB6pdvKj0CV8xn7v5NCnTx8AwA8//ACNRlOl+9IlTMbq2ebn5+PPP/+s8H01btxYmodekfcG3dzmzMxMbNu2zaD93r17+OmnnwCgUn80P6pOnToBgElqVpclKCgISqUSiYmJ+Pvvvw3ar1+/Lr0XVvYxV/UzQKvVSq+DsubGU8UxmaVKmzJlCry9vZGTk4NFixYBAKytrREREQEhBIYMGYL9+/cb3E6j0eCPP/5AfHy8dCw6OtroBPn09HQcPXoUgPE3iwdNmDABdevWRVxcHJYsWaLXtnfvXml08UHW1tYICgoCAISFhel9zff333+XORqpWyyyceNGvZFbjUaD8PDwSi8eMtXz8KDp06frzYstLCxEaGgo7t69i27duiEwMNDo7d5++20AkBaBmXJUtrQhQ4age/fu0Gg0egvEdM/vqlWr9EaxCgoKMGXKlHJHl8rzqK/TmmRuMUZERMDGxgbvvvsuVq1aZfSr8BMnTphsW07dtwVyJ/I6r776Kry8vJCQkICJEycazOHOzc0tcxOPB+lGdqOiovTmaN69exevvfYarly5YnCbhIQErFu3Dvfu3TNo0/2xWpH3BltbW4SGhgIoeV8oPQpcXFyMt99+G+np6fDx8cHLL79cocdTFbrksTo3KfH29sawYcMghMCkSZP0RoF1z3lBQQGefPJJo4u/ylPVz4CUlBTk5OSgRYsWFrEFr9mTqYoCmbGHbZogxP8X0HdwcBC3b9+Wjr/77rtSSRM/Pz8xaNAgMXLkSNGrVy+ppt7SpUul/rqi2z4+PmLgwIEiJCREvPDCC8LOzk4AEM8++6woLi6W+pe3acJ///tfqQZuu3btxCuvvCKCgoKEQqEQU6dONVqaS4iSkjw2NjZSrcSXX35ZBAQECGtrazF27FijJV+Ki4uluqt169YV/fv3F8OHDxdNmjQR1tbWUj3HB+MsqzRXZZ+H8pTeNKF79+7C3t5eDBgwQAwfPlwq+dSwYUNx+vTpMu+jsLBQKtPToEEDUVBQUKFzP6gi9Vd1xdNVKpUUU1ZWlvS816tXTwwePFgMHTpUNGzYUDg4OEil1h4sv6QrzfXg8QdV9nVa0cf5YKH/B3+++uoro7czVqrpUWIs6zUuxMPL0D1sQxJdOTcvLy/xwgsviJCQENG3b1+pnuaIESMq/NiEKLsEV3p6urQZQ2BgoBg3bpyYMGFChTeyeFhpLmOPT6es5+/48ePC3d1dACW1Vvv37y9GjBghnnzyyUptmlBUVCS6dOkigJLNF/r37y/69u0rGjRoIBo1aiT+/e9/GzwnmzdvFgCEnZ2dCAwMFCNHjhQvv/yyaNmypQAgbGxsxC+//FKh8xcUFIjnnntOuj/d5g+6TTXq1atntBxcea+r8s5XnsLCQtGgQQOhVqtFVlaW0T6681alzuytW7ek91cnJycxePBg8fLLL4sGDRpI77llbZpQXsnGR/0M0Fm8eLEAIN57772HPjZ6OCazZKAiyez9+/dFmzZtBFCyw09pBw4cECEhIaJJkyZCrVYLBwcH0aJFCzF48GDx3XfficzMTKnvzz//LCZPniw6duwoGjRoIGxsbISXl5fo1auXWLVqlSgqKtK774d9IP31118iODhYODo6Cnt7e9GxY0fxzTffCCHKf0OOi4sTL7zwgnB0dBR2dnaiffv2Ijo6Wmi12jLfJPPy8sTs2bNFy5Ytha2trWjYsKEYPHiwOHr0aJlxlvUmWdnnoTylz33nzh3x7rvvCh8fH2FjYyPc3NzEuHHjKlQPUldfdNasWRU+94MqupmArmD9yJEjpWM3b94UU6ZMEc2aNRNqtVp4enqKf/3rX+Ls2bNlJq0VTWaFqNzrtKKP82E/gwYNMnq7sj6sKxtjdSWzuttPnTpVtG3bVtSpU0fY2tqKJk2aiF69eomPP/5YnDt3rlKPrbx6srGxsaJ3797CxcVF2k2pIv+nQlRPMitEyesxLCxMtGvXTtSpU0fY2dkJX19fMWLECLFr1y69vuU99qysLPHGG28ILy8vYW1tLRo1aiRee+01kZGRYfQ5uX79uvj4449Fv379hI+Pj7C3txeOjo6iTZs2IjQ01OgfpeWdv7i4WERHR4sePXpIm280a9ZMvPnmmwabkFTkeXnY+coze/ZsAUBER0eXe96qJLNClNTQXbhwoejQoYOwt7cXtra2onXr1mL27NlGf88rkswK8WifATrt27cXSqWyUvXLqWwKISq43JqIao3s7Gx4eXmhoKAAqampFa4dSURUUdeuXUOzZs3Qtm1baTpVbXDs2DF06dIFQ4YMMdn0nNqOc2aJyMDChQtx9+5dDB8+nIksEVWLRo0aYfr06Th27Bh+/vlnucOpMeHh4bCxsTFaBYEeDUdmiQhAyW5SP/zwA1JTU/HHH3/A3t4eycnJRnfSIiIyhbt376JVq1ZwdXVFQkKCWdcBNoX9+/fj6aefxrvvvotPP/1U7nAeG0xmiQhASXms8ePHw87ODu3bt8cnn3wiVXogIiIyV0xmiYiIiMhiPd7j+URERET0WGMyS0REREQWy0ruAOSg1WqRlpYGBwcHKBQKucMhIiIiogcIIZCXlwdPT89yFwfWymQ2LS2N5YaIiIiILMCVK1ekra6NqZXJrIODA4CSJ8fR0VHmaIiIiIjoQbm5uWjcuLGUt5WlViazuqkFjo6OTGaJiIiIzNjDpoRyARgRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwruQMgelxpNBokJSUhMzMTrq6u8Pf3h0qlkjssIiKixwqTWaJqEBsbi+joaKSnp0vH3N3dMWXKFAQFBckYGRER0eOF0wyITCw2NhYRERHw9fVFVFQUdu7ciaioKPj6+iIiIgKxsbFyh0hERPTYUAghhNxB1LTc3Fw4OTkhJycHjo6OcodDjxGNRoOQkBD4+vpi/vz5UCr//+9FrVaLsLAwpKamYu3atZxyQEREVI6K5mscmSUyoaSkJKSnpyMkJEQvkQUApVKJkJAQXL9+HUlJSTJFSERE9HhhMktkQpmZmQAAHx8fo+2647p+REREVDVMZolMyNXVFQCQmppqtF13XNePiIiIqobJLJEJ+fv7w93dHTExMdBqtXptWq0WMTEx8PDwgL+/v0wREhERPV6YzBKZkEqlwpQpUxAXF4ewsDCkpKQgPz8fKSkpCAsLQ1xcHCZPnszFX0RERCbCagasZkDVwFidWQ8PD0yePJl1ZomIiCqgovkak1kms1RNuAMYERHRo6tovsYdwIiqiUqlQseOHeUOg4iI6LHGObNEREREZLGYzBIRERGRxWIyS0REREQWi8ksEREREVksJrNEREREZLGYzBIRERGRxWJpLiIiIqoQ1s8mc8RkloiIiB7K2M6G7u7umDJlCnc2JFlxmgERERGVKzY2FhEREfD19UVUVBR27tyJqKgo+Pr6IiIiArGxsXKHSLUYt7PldrZERERl0mg0CAkJga+vL+bPnw+l8v/HwbRaLcLCwpCamoq1a9dyygGZVEXzNY7MEhERUZmSkpKQnp6OkJAQvUQWAJRKJUJCQnD9+nUkJSXJFCHVdkxmiYiIqEyZmZkAAB8fH6PtuuO6fkQ1jcksERERlcnV1RUAkJqaarRdd1zXj6imMZklIiKiMvn7+8Pd3R0xMTHQarV6bVqtFjExMfDw8IC/v79MEVJtx2SWiIiIyqRSqTBlyhTExcUhLCwMKSkpyM/PR0pKCsLCwhAXF4fJkydz8RfJhtUMWM2AiIjooYzVmfXw8MDkyZNZZ5aqRUXzNSazTGaJiIgqhDuAUU2qaL7GHcCIiIioQlQqFTp27Ch3GER6zG7OrEajwZw5c+Dj4wM7Ozs0a9YMH374IUoPIAshEB4eDg8PD9jZ2aF37944e/asjFETERERkRzMLpn95JNPsHTpUvznP//BqVOn8Mknn+DTTz/F119/LfX59NNPsWTJEixbtgyHDh1CnTp1EBwcjIKCAhkjJyIiIqKaZnZzZgcMGAA3Nzd8//330rGhQ4fCzs4Oa9euhRACnp6emD59OmbMmAEAyMnJgZubG1auXImRI0c+9BycM0tERERk3ix2O9snn3wSe/bswT///AMA+Pvvv7F//3707dsXQElx5vT0dPTu3Vu6jZOTE7p37464uDij91lYWIjc3Fy9HyIiIiKyfGa3AOz9999Hbm4uWrVqBZVKBY1GgwULFiAkJAQApJIgbm5uerdzc3PTKxdS2sKFCxEZGVm9gRM9gKt+iYiIqp/ZJbPr169HTEwMfvzxR/j5+SExMRHvvPMOPD09MXbs2Ee6z1mzZmHatGnS9dzcXDRu3NhUIRMZMFaP0d3dHVOmTGE9RiIiIhMyu2kG7777Lt5//32MHDkS7dq1w+jRozF16lQsXLgQQElCAAAZGRl6t8vIyJDaHqRWq+Ho6Kj3Q1RdYmNjERERAV9fX0RFRWHnzp2IioqCr68vIiIiEBsbK3eIREREjw2zS2bz8/OhVOqHpVKppP2gfXx84O7ujj179kjtubm5OHToEAICAmo0VqIHaTQaREdHIyAgAPPnz4efnx/s7e3h5+eH+fPnIyAgAEuXLoVGo5E7VCIioseC2SWzAwcOxIIFC7Bjxw5cvHgRmzdvxuLFizFkyBAAgEKhwDvvvIP58+dj27ZtSE5OxpgxY+Dp6YnBgwfLGzzVeklJSUhPT0dISAiEEEhISMCePXuQkJAAIQRCQkJw/fp1JCUlyR0qERHRY8Hs5sx+/fXXmDNnDqZMmYIbN27A09MTkyZNQnh4uNTnvffew927d/Haa68hOzsbTz31FHbt2gVbW1sZIycCMjMzAQBpaWn48MMPDebMTpgwQa8fERERVY3Z1ZmtCawzS9UlISEBU6dOBVBSZi4kJAQ+Pj5ITU1FTEwMDh48CAD44osvuCUkERFROSy2ziyRJfPz84NKpYKLiwvmzZunN2d23rx5cHFxgUqlgp+fn9yhEhERPRaYzBKZUEpKCjQaDbKzsxEeHo6UlBTk5+cjJSUF4eHhyM7OhkajQUpKityhEhERPRbMbs4skSXTzYWdPXs2vv/+e4SGhkptHh4emD17NhYsWMA5s0RERCbCZJbIhFxdXQEAnp6eiImJMdgB7PTp03r9iIiIqGqYzBKZkL+/P9zd3RETE4P58+frLfLSarWIiYmBh4cH/P39ZYySiOjRFBUVYevWrUhLS4OnpycGDRoEGxsbucOiWo7VDFjNgExMtwNYQECAQTWDuLg4REZGcktbIrI4y5Ytw4YNG/Q2fVGpVBg2bBhef/11GSOjx1VF8zUms0xmqRrExsYiOjpar86sh4cHJk+ezESWiCzOsmXL8NNPP8HFxQUTJkxAQEAA4uLi8P333yMrKwsjR45kQksmx2S2HExmqSZoNBqDObMqlUrusIiIKqWoqAh9+/aFo6MjNmzYACur/5+heP/+fQwbNgy5ubn45ZdfOOWATIp1ZolkplKp0LFjRzz33HPo2LEjE1kiskhbt26FRqPBhAkT9BJZALCyssK///1vaDQabN26VaYIqbZjMktERERlSktLAwAEBAQYbdcd1/UjqmlMZomIiKhMnp6eAIC4uDij7brjun5ENY3JLBEREZVp0KBBUKlU+P7773H//n29tvv37+OHH36ASqXCoEGDZIqQajsms0RERFQmGxsbDBs2DFlZWRg2bBi2b9+OW7duYfv27XrHufiL5MJNE4iIiKhcurJbGzZswKJFi6TjKpWKZblIdizNxdJcREREFcIdwKgmVTRf48gsERERVYhuygGROeGcWSIiIiKyWByZJSIiogrhzoZkjpjMEhER0UPFxsYiOjoa6enp0jF3d3dMmTIFQUFBMkZGtR2nGRAREVG5YmNjERERAV9fX0RFRWHnzp2IioqCr68vIiIiEBsbK3eIVIuxmgGrGRAREZVJo9EgJCQEvr6+mD9/PpTK/x8H02q1CAsLQ2pqKtauXcspB2RSFc3XODJLREREZUpKSkJ6ejpCQkL0ElkAUCqVCAkJwfXr15GUlCRThFTbMZklIiKiMmVmZgIAfHx8jLbrjuv6EdU0JrNE1USj0SAhIQF79uxBQkICNBqN3CEREVWaq6srACA1NdVou+64rh9RTWM1A6JqwFW/RPS48Pf3h7u7O2JiYozOmY2JiYGHhwf8/f1ljJJqMy4A4wIwMjHdqt+AgACEhITAx8cHqampiImJQVxcHCIjI5nQEpFF0b2v9ejRA926dYNarUZhYSEOHz6M+Ph4vq9RtahovsZklsksmRBX/RLR42rZsmXYsGGD3pQplUqFYcOG4fXXX5cxMnpcVTRf4zQDIhPSrfqdM2cO7t+/j61btyItLQ2enp4YNGgQQkJCEBoaiqSkJHTs2FHucImIKiQ2Nhbr1q2TRmZtbW1RUFCAw4cPY926dWjTpg1HZkk2TGaJTEi3mvePP/7Am2++Ca1WK7UtXboUQ4YM0etHRGTuNBoNoqOjERAQYPCN06BBgxAWFoalS5ciMDCQ3ziRLFjNgMiEdKt5N23aZLRdd5yrfonIUrDOLJk7jswSmVCrVq2ky127dsWYMWOkBWCrV6/GoUOHDPoREZkz1pklc8eRWSIT2rZtm3TZ2AiGsX5EROaMdWbJ3DGZJTKh5ORkAEBISAguXLiA0NBQ9OvXD6GhoUhNTcWoUaP0+hERmbvSdWZLrwMAWGeWzAOTWSITsrOzAwBkZWUZtAkhpOO6fkRE5k6lUmHKlCmIi4tDWFgYUlJSkJ+fj5SUFISFhSEuLg6TJ0/m4i+SDevMss4smdCRI0fw7rvvAoBUVFyn9PXPPvsMXbt2lSVGIqJHYWxnQw8PD0yePJlluahasM4skQzat28vXdZoNHjllVfQr18/7Ny5Exs2bDDaj4jIEgQFBSEwMBBJSUnIzMyEq6sr/P39OSJLsmMyS2RCpefC3r9/H//973/x3//+12i/zp0712RoRERVplKpuOELmR3OmSUyocTERADAuHHj4Obmptfm7u6OsWPH6vUjIiKiquHILFE1aNeuHUaNGmWwnS2rGBAREZkWk1kiE+rQoQPWrFmDr776CoWFhcjIyJDaNm7cCLVaLfUjIiKiquM0AyIT6tChA+rUqYPLly+jsLAQ06dPx8aNGzF9+nQUFhbi8uXLqFOnDpNZIiIiE+HILJGJWVtbAwDu3buHRYsWScd1o7K6diIiIqo6jswSmVBSUhKys7MxceJEODs767W5uLhg4sSJyM7ORlJSkjwBEhERPWaYzBKZUGZmJgCgYcOGBm1CCOm4rh8RERFVDacZEJmQq6srAGDBggXStAKd7OxsLFiwQK8fERERVQ2TWSIT8vPzg1KphFarRadOnfCvf/0LPj4+SE1Nxdq1axEXFwelUgk/Pz+5QyUiInoscJoBkQklJydDq9WW20er1bLeLBERkYlwZJbIhErvALZr1y6EhoZKbR4eHhg7dixWrVqFxMREbmdLRERkAkxmiapBu3btMHr0aCQlJSEzMxOurq7w9/fnNrZEZNE0Go3B+5pKpZI7LKrlmMwSmZBuB7CVK1di8eLFem1arRYrV66U+hERWZLY2FhER0cjPT1dOubu7o4pU6YgKChIxsiotlMIIYTcQdS03NxcODk5IScnB46OjnKHQ48RjUaDoUOHIjs7GzY2NigqKpLadNddXFywceNGjmYQkcWIjY1FREQEbGxsUFhYKB1Xq9UoKipCZGQkE1oyuYrma1wARmRCKpUKffr0AQDcv39fr013PTg4mIksEVkMjUaDxYsXQwiBTp06ISoqCjt37kRUVBQ6deoEIQS++OILaDQauUOlWorJLJEJaTQa7N27F56enkbbPT09sW/fPr7pE5HFSExMRHZ2Ntq1a4cFCxbAz88P9vb28PPzw4IFC9CuXTtkZWVxTQDJhnNmiUwoKSlJmk/Wo0cPNGrUCIWFhVCr1bh27Rri4+Olfh07dpQzVCKiCildpUWp1B8DUyqVGDduHKZPn84qLSQbJrNEJnTr1i0AQPPmzZGamiolrwDg5uaG5s2b4+zZs1I/IiJLoVAo5A6ByChOMyAyoezsbADA2bNnpcul286ePavXj4jI3Omqr6xYscJgUxhWaSFzwGSWyIRKr7Y0tlDCWD8iInPWoUMHODs7Izk5GR988AFSUlKQn5+PlJQUfPDBB0hOToazszOTWZINpxkQmVBFR1w5MktElkKlUmHatGkIDw/H8ePHERcXJ7Wp1WoAwLRp01ilhWTDZJbIhPLy8gAAXl5eSE1NNdjO1svLC1evXpX6ERFZgqCgIMybNw9RUVHIyMiQjru4uHDTBJIdk1kiE9ItkLh69SoCAgIwYsQIqNVqFBYW4vDhw9KIBhdSEJGlCQoKQmBgILezJbPDZJbIhHTb2Xp7e+PChQt6X8e5u7vD29sbly9f5twyIiIiE2EyS2RCuoUSly9fRo8ePTBy5EhpZPbQoUOIj4+Hi4sLk1kisjixsbGIjo6WamkDJX+kc5oByU0hhBByB1HTKrrXL9Gj4B7mRPS40b2vBQQEICQkBD4+PkhNTUVMTAzi4uL4vkbVoqL5GpNZJrNUDYyNYHh4eGDy5Ml8wycii6LRaBASEgJfX1/Mnz9fbxcwrVaLsLAwpKamYu3atZw/SyZV0XyN0wyIqgEXShDR40K3TfecOXOMbmcbEhKC0NBQbtNNsmEyS1RN7t27h40bNyItLQ2enp5o3rw56tatK3dYRESVkpmZCQDw8fEx2q47rutHVNOYzBJVg9dffx2nT5+WrqempmLAgAFo1aoVli1bJmNkRESV4+rqCqDkfaxVq1YG3zilpqbq9SOqaZwzyzmzZGIPJrIPYkJLRJZEN2dW97n5YDUDJycn5Obmcs4smVxF8zVlmS1EVGl37twpN5EFgNOnT+POnTs1FBERUdWoVCr06tULZ86cQWFhIWbMmIFNmzZhxowZKCwsxJkzZ9CzZ08msiQbjsxyZJZMaPbs2Th48CCAkoURWq1Wait9/cknn8RHH30kS4xERJVRemQ2OztbbztbjsxSdWI1AyIZnD9/XrrctWtX9OjRA7a2tigoKEB8fDwOHTpk0I+IyJyVrmZgbM7s6dOnWc2AZMVklsiENBoNgJINElJTU6XkFQAaNmwo7Qam60dEZO5KVzNQqVQGCSurGZDcOGeWyIQaNGgAACgsLER2drZeW3Z2trQjmK4fEZG5K13NwBhWMyC5MZklMiFPT0/pclFRkV5b6eul+xERmTN/f3+4u7sjJiZGbx0AULIDWExMDDw8PODv7y9ThFTbMZklMiFfX1+T9iMikptKpcKUKVMQFxeHsLAwpKSkID8/HykpKQgLC0NcXBwmT57MxV8kG86ZJTKhu3fvmrQfEZE5CAoKQmRkJKKjoxEaGiod9/DwQGRkJIKCgmSMjmo7JrNEJnTjxg2T9iMiMhdBQUEIDAw0qGbAEVmSG5NZIhPSzSezsbGBs7OzXtLq5uaGrKwsFBUVGcw7IyKyBMaqGRDJjckskQkplSXT0IuKiuDr64tXXnlFKsd16NAhqdi4rh8RkSXRaDQcmSWzw2SWyITc3Nyky8ePH0d8fLx03cbGxmg/IiJLEBsbi+joaKSnp0vH3N3dMWXKFM6ZJVlxeIjIhDp16iRdLq80V+l+RETmLjY2FhEREfD19UVUVBR27tyJqKgo+Pr6IiIiArGxsXKHSLUYk1kiE+rQoQPUanW5fdRqNTp06FAzARERVZFGo0F0dDQCAgIwf/58+Pn5wd7eHn5+fpg/fz4CAgKwdOlS7mxIsmEyS2RCGo0GxcXF5fYpLi7mmz4RWYykpCSkp6cjJCTEYL6/UqlESEgIrl+/jqSkJJkipNqOySyRCW3duvWhlQq0Wi22bt1aQxEREVVNZmYmAMDHx8dou+64rh9RTWMyS2RC165dky6XXvD14PXS/YiIzJmrqysAIDU11Wi77riuH1FNYzJLZEJCCOly586d9RZKdO7c2Wg/IiJz5u/vD3d3d8TExKC4uBgJCQnYs2cPEhISUFxcjJiYGHh4eMDf31/uUKmWYmkuIhOyt7cHUFJYPDw8HKdPn0ZcXBxcXV0RHh6OAQMGQKPRSP2IiMydSqXClClTpPewwsJCqU1XR3vevHmsN0uyMctk9tq1a5g5cyZ++eUX5Ofn44knnsCKFSvQpUsXACWjWhEREVi+fDmys7MRGBiIpUuXonnz5jJHTrXdrVu3AJQsBOvfv7/e/FmlUild1/UjIrIUCoXC4FslIQQUCoVMERGVMLtpBllZWQgMDIS1tTV++eUXnDx5EosWLYKLi4vU59NPP8WSJUuwbNkyHDp0CHXq1EFwcDAKCgpkjJxIfzOEBxeClb7OTROIyFLoSnO1aNHCYF6sq6srWrRowdJcJCuzG5n95JNP0LhxY6xYsUI6VnoFpRACX375JcLCwjBo0CAAwOrVq+Hm5oYtW7Zg5MiRNR4zkU779u2xdu3aCvUjIrIEutJcGRkZCAgIwJw5c+Dj44PU1FTExMQgLi4OQggkJSWhY8eOcodLtZDZjcxu27YNXbp0wbBhw9CwYUN07NgRy5cvl9pTU1ORnp6O3r17S8ecnJzQvXt3xMXFGb3PwsJC5Obm6v0QVYcHazBWtR8Rkdx006K6deuGyMhIFBUVIS4uDkVFRYiMjES3bt30+hHVNLMbmb1w4QKWLl2KadOmYfbs2Thy5Ajeeust2NjYYOzYsdKe0A9+Tevm5qa3X3RpCxcuRGRkZLXHTlTRN3O+6RORpcjOzgZQ8jk7evRovc9ad3d3KZnV9SOqaWaXzGq1WnTp0gUfffQRAKBjx444ceIEli1bhrFjxz7Sfc6aNQvTpk2Trufm5qJx48YmiZeotBMnTgAoWf2r1Wr1FksoFAoolUpoNBqcOHECwcHBcoVJRFRhzs7OAEq+Oe3RowdGjBghVTE4dOgQtm3bptePqKaZXTLr4eGBNm3a6B1r3bo1Nm3aBKDkr0AAyMjIgIeHh9QnIyOjzP3u1Wo11Gp19QRMVIqueLhGo0H37t3h5eWFoqIi2NjY4OrVqzh06JBePyIic1d60VdCQgLi4+Ol66U/W7lpAsnF7JLZwMBAnDlzRu/YP//8gyZNmgAoWQzm7u6OPXv2SMlrbm4uDh06hMmTJ9d0uERlSkhIkJJXwHBHMCIiS2OsNBeR3MwumZ06dSqefPJJfPTRRxg+fDgOHz6Mb7/9Ft9++y2Akq9q33nnHcyfPx/NmzeHj48P5syZA09PTwwePFje4KnW8/HxkaYaPKwfEZElyMzMlC537NgRXl5eKCwshFqt1vvGqXQ/oppkdsls165dsXnzZsyaNQvz5s2Dj48PvvzyS4SEhEh93nvvPdy9exevvfYasrOz8dRTT2HXrl2wtbWVMXIioE2bNti+fTsAoLi4WK+t9PUHp9IQEZkr3cKuLl264OjRo3rfOKlUKuk4F4CRXMwumQWAAQMGYMCAAWW2KxQKzJs3D/PmzavBqIge7s6dO9Ll8r6OK92PiMic6RZ2HT16FD169ED37t31FoDp5tByARjJhcUuiUzI0dERQMmiiAe3eFQqldJiCV0/IiJzV3phl0KhQIsWLdCrVy+0aNFC732OC8BILmY5MktkqXQbchQWFkqjF3l5eXBwcJBGMUr3IyKyFN7e3rhw4QJCQ0OlY+7u7vD29sbly5dljIxqOyazRCak+5rNw8MDhw8f1ptaoFQq4eHhgevXr/PrOCKyGLq5sFeuXEGPHj0wcuRIaZrB4cOHpWkGnDNLcmEyS2RC9evXBwBcv34dSqXSYN7s9evX9foREZk73fSBV199Fdu3b9fbOt7DwwOvvvoqli9fzmkGJBsms0Qm5OfnB6VSCa1WCysrKxQVFUltuutKpRJ+fn4yRklEVHH+/v5wd3dHSkoK1qxZgxMnTiAzMxOurq5o27YtIiIi4OHhAX9/f7lDpVqKC8CITCg5ORlarRYA9BLZ0te1Wi2Sk5NrPDYiokehUqkwZcoUxMXFISIiAjY2NggICICNjQ0iIiIQFxeHyZMnQ6VSyR0q1VIcmSUyocTEROmyboTW2PXExER07ty5psMjInokQUFBiIyMRHR0tN4CMA8PD0RGRiIoKEjG6Ki2YzJLZEIajQYAULduXaxfvx47duxAWloaPD090b9/fwwfPhx37tyR+hERWYqgoCAEBgYiKSlJmmbg7+/PEVmSHZNZIhPSbYZgbW2N8ePHIyMjQ2rbuHEjrK2t9foREVkSlUqFjh07yh0GkR4ms0QmpFSWTEPPysoyaCud2Or6ERERUdUwmSUyIQ8PD5P2IyIyJxqNhtMMyOwwmSUyIW9vb+myjY2NXkWD0tdL9yMisgSxsbGIjo5Genq6dMzd3R1TpkzhAjCSFZNZIhPas2ePdNnW1hZPPvkkbG1tUVBQgOPHj0vJ7J49exAQECBXmERElRIbG4uIiAj06NEDI0aM0NsBLCIighUNSFZMZolMSDdi0bRpU1y8eBF79+7Va2/SpAkuXbqkN7JBRGTONBoNoqOj0aJFC6SmpurtAObu7o4WLVpg6dKlCAwM5JQDkgWTWSITcnd3x4kTJ3Dx4kV0794dXl5eKCoqgo2NDa5evYpDhw5J/YiILEFSUhLS09ORkZGBgIAAzJkzBz4+PkhNTUVMTAzi4uIghEBSUhIrHZAsuKSayISef/55vevPPvssJk+ejGeffbbcfkRE5urWrVsAgG7duiE8PBwnT57E8uXLcfLkSYSHh6Nbt256/YhqGkdmiUzIyur/f6UOHz4sjcQCgEKhMNqPiMicZWdnAyjZirt///56m74sW7ZMGo3V9SOqafxEJTKh0m/mQgi9ttLX+aZPRJbC2dkZAHDkyBE4Ozvj1VdfRUBAAOLi4vDdd9/h6NGjev2IahqTWSITcnV1lS6XV5qrdD8iInNWOklt2bIlUlNTcfr0aajVarRs2VL6BorJLMmFySyRCfn5+UGlUsHR0RExMTHYsWMH0tLS4Onpif79+yMkJAS5ubnw8/OTO1Qiogq5cOECAMDe3h6HDh3Smz6lO56fn48LFy6ga9eucoRItRyTWSITSklJgUajQVZWFoYMGYLCwkKp7bvvvpOup6SkcNUvEVkEXSnB/Px8WFtbIygoCC1atMA///yD2NhY5Ofn6/UjqmlMZolMKDMz06T9iIjk1rBhQwAlU6VcXFywZ88eaYMYd3d3ZGZmoqioSOpHVNOYzBKZkG7OWLt27fDZZ59h+/bt0jSDgQMH4t1330VycjLnlhGRxdBVYrGyssLq1atx8uRJZGZmwtXVFW3atMGQIUNQVFSkV7GFqCYxmSWqBjk5ORg3bpze126bNm2CjY2NjFEREVVeRkYGgJJpBiNHjsS///1vqZrBvHnzpGkGun5ENY3JLJEJ6UpuXb58Gc7Ozhg+fDg8PT2RlpaG3377TUpuWZqLiCyFp6cnAKBr1644duwYFi1aJLUplUp06dIFR48elfoR1TQms0QmpJs+UL9+fWRmZmL9+vVSm1KpRP369XHr1i1OMyAiizFo0CAsW7YMJ0+eRP369XHjxg2prX79+jh16hRUKhUGDRokY5RUm3E7W6JqcOvWLVhbW+sds7a25naPRGRxbGxs0KNHD9y9exdZWVkYNWoU1q5di1GjRiErKwt3795Fjx49OI2KZMORWSITKl2lwM7ODm+++abeTjm60lysZkBElkKj0eD8+fPw9PREeno6fvzxR/z4448AAJVKBU9PT1y4cAEajQYqlUrmaKk2YjJLZEK6JNXNzQ1arRaff/651NawYUO4ubkhIyODySwRWYykpCSkp6cjKioKzZs3x9atW6UqLYMGDcLZs2cRGhqKpKQk1s8mWTCZJTKh3NxcAMD9+/cNEtabN2/CxcVFrx8RkbnTvZf5+PjAxsYGw4YN02v38fHR60dU0zhnlsiElMqSX6nbt29DCKHXJoSQ3ux1/YiIzJ2rqysAIDU11Wi77riuH1FN4ycqkQm1bdtWumxsAZixfkRE5szf3x/u7u6IiYmBVqvVa9NqtYiJiYGHhwf8/f1lipBqO04zIDKh0iMXD+6GU/p6amoqunfvXmNxERE9KpVKhSlTpiAiIgIffPABunXrBrVajcLCQhw+fBjx8fGIjIzk4i+SDZNZIhM6ceKEdLmoqEivrfT10v2IiMxdUFAQRowYgQ0bNiAuLk46rlKpMGLECAQFBckYHdV21TLN4OLFi1i+fDnWrFmDO3fuVMcpiMySra2tdNnKSv9vxdLXS/cjIjJ3sbGxWLduncHoq0qlwrp16xAbGytTZERVTGY/+ugj+Pj4ICsrSzq2d+9etG3bFq+//jrGjRuHTp06cYUj1Rq+vr4ASqYU1KtXT6+tXr160lQDXT8iInOn0WiwePFiCCHQuXNnREVFYefOnYiKikLnzp0hhMAXX3wBjUYjd6hUS1Upmd2yZQuaNm0qlRsCgJkzZ0Kr1SIyMhKTJ0/GuXPn8OWXX1Y1TiKLcPfuXQAllQsyMjL02jIyMqQKB7p+RETmLjExEdnZ2WjXrh3mzZuHoqIixMXFoaioCPPmzUO7du2QlZWFxMREuUOlWqpKc2YvXryoV28uLS0NR44cwfTp0xEWFgYAOHPmDDZv3ox58+ZVLVIiIiKqcboktXPnzhg9ejTS09OlNnd3dwQHByM5ORmJiYno3LmzTFFSbValkdnc3Fw4OztL12NjY6FQKDBw4EDpWKdOnXD58uWqnIbIYjg4OEiXy5szW7ofEZElWLlyJXx9ffWmGfj6+mLVqlVyh0a1XJVGZt3c3HDp0iXp+u+//w61Wq1XcqigoMCgRBHR46r0zl6dO3eGl5cXCgsLoVarcfXqVRw6dMigHxGROdPVj3VwcEBERAROnjyJuLg4uLq6IiIiAi+//DLy8vJYZ5ZkU6VktmvXrti6dSt+/vln2NraYt26dXjmmWegVqulPqmpqfD09KxyoESW4ObNm9LlQ4cOSclref2IiMyZbsfCvLw8vPjiiygsLJTadPVmS/cjqmlVeuXNnj0b9+/fx6BBgxAcHIyCggLMnj1bai8sLERsbCyLw1Ot0bBhQ5P2IyKSW3Z2tnS5vPrZpfsR1aQqjcx26tQJ8fHxWLNmDQBg+PDh6Natm9SekJCAZ555BqNGjapalEQWokOHDoiJiQFQMke2Xbt2qFevHm7fvo3k5GTcv39f6kdEZAl0a2Pq16+P27dvG7TXr18ft27d0ltDQ1STqrwDWPv27dG+fXujbT169MDmzZuregoii1F63/L79+8jISHhof2IiCzBrVu39KYVAICNjQ1u3bolY1RE3M6WyKR2795d4X6cfkNElqD0xke2trYYNGgQPD09kZaWhl9//VVKbrlBEsmlUsns6tWrH/lEY8aMeeTbElmK/Px8k/YjIpKbLkl1cnJCXl4e1q9fL7WpVCo4OTkhJyeHySzJplLJ7Lhx4ypdZksIAYVCwWSWagVXV1fpsrOzM1544QVpBOO3336TFkiU7kdEZM50pQRzcnLQo0cPdO/eHba2tigoKMChQ4cQHx+v14+oplUqmV2xYkV1xUH0WLCzs5Mut2jRAj179oSPjw9SU1Nx8eJFHD582KAfEZGl0W3NTWQOKpXMjh07trriIHosnD9/Xrp89OhRKXkF9Gswlu5HRGTOHB0dAZRMMyg9EguUvK/pphno+hHVNFY4JjIhW1tbAManESgUCum4rh8RkbnTvW/l5OQYnWqYk5Oj14+opjGZJTIh3XaOmZmZUKlUem1KpVJaIMFtH4nIUlQ0SWUyS3KpcjJ75coVTJo0Cc2aNYOdnR1UKpXBj5UVK4BR7TBkyBBp5KK4uFivTXddoVBgyJAhNR4bEdGj0NXFtrOzQ7169fTa6tevL60BYP1skkuVsswLFy6ge/fuyMrKgp+fHwoLC9GkSRPY2triwoULKC4uRvv27bkrCNUaKpUKdnZ25Zbe0v3RR0RkCZKSkgAA9+7dQ4cOHTBq1Chp84TDhw8jLi5O6te1a1c5Q6Vaqkojs5GRkcjJycGePXvw999/AwDGjx+PU6dO4eLFi3jxxRdx9+5dbNy40STBEpm7pKSkh9aQzc/Plz4ciIgsxbhx45CamoqvvvoKn376Kb766itcvHiRi8NJdlUamd29ezf69euHnj17Ssd05To8PDywbt06tGvXDrNnz8Y333xTtUiJLEDpbR27d+8OLy8vFBUVwcbGBlevXsWhQ4cM+hERmbMOHTpgzZo1OHbsGNasWYMTJ04gMzMTrq6uaNu2LaZNmyb1I5JDlZLZW7duoVWrVv9/Z1ZWeqNSarUazz//PLZs2VKV0xBZDN0Cr2bNmmHhwoV65bi0Wi1effVVXLhwgTvlEJHF6NChA5ydnZGcnIw5c+age/fuUKvVuHjxItatW4fk5GS4uLgwmSXZVCmZrV+/Pu7evat3/eLFi/onsLKSdj0ietzpdsBRq9VG23UlubhTDhFZCpVKhWnTpiE8PBzx8fF6dWZ1pk6dyrUAJJsqzZlt3ry5XvH3bt264ddff8WFCxcAADdv3sTGjRvRrFmzqkVJZCF0I7EnT55EWFgYUlJSkJ+fj5SUFISFheHkyZN6/YiILMmDf6iX9Yc7UU2q0shs3759MXfuXGRnZ8PZ2RnvvPMOtm/fDn9/f7Ru3Rrnzp1Dbm4u5s6da6Jwicybbm6Zt7c3zp07h9DQUKnNzc0N3t7euHz5Mr+OIyKLodFoEB0djSeffBKRkZEGc2YjIiKwdOlSBAYGcnSWZFGl4aHJkydj79690ou3V69e+Omnn9CkSROcOHECbm5uWLJkCSZOnGiSYInMnW5u2eXLlw2m12RlZeHy5ctwdnZmMktEFiMpKQnp6ekICQkx+FZJqVQiJCQE169fZ5UWkk2VRmYdHR3RvXt3vWPDhg3DsGHDqhQUkaVSqVTo06cPfvrpJxQVFem16a736dOHoxdEZDF0C1bT0tLw4YcfIj09XWpzd3fHhAkT9PoR1TRO3CMyIY1Gg127dgEAbGxs9Np013ft2gWNRlPjsRERPQrdNrULFixAVlaWXltWVhYWLFig14+oplVpZPby5csV7uvt7V2VUxFZhMTERGRnZ6Ndu3ZYvHix0XqMycnJSExMROfOneUOl4joofz8/KBUKqHVatGxY0eMHj0aPj4+SE1NxZo1axAfHw+lUgk/Pz+5Q6VaqkrJbNOmTaV96MujUChw//79qpyKyCIkJiYCKNkJz9raGh07dtRrHzduHKZPn85klogsRnJyMrRaLQAYfObrrmu1WiQnJ/N9jWRRpWR2zJgxRpPZnJwc/P3330hNTUXPnj3RtGnTqpyGyOLodsIjIrJ0uj/Sx40bh127dulVafHw8MDYsWOxatUq/pFOsqlSMrty5coy24QQWLRoET799FN8//33VTkNkcXQleZauXIl/Pz8sH37dqSlpcHT0xMDBw6UfmdYzYCILI2/vz9Gjx6NpKQkafqUv7+/lOwSyUUhqnkI6ZlnnoGrqys2bdpUnaeplNzcXDg5OSEnJweOjo5yh0OPEY1Gg6FDh5a7652Liws2btzIigZEZBGOHTuG6dOno127dvjqq68Mtul+++23kZycjEWLFnFklkyqovlatVcz6NKlC/7444/qPg2RWVCpVA9dBNGmTRsmskRkMXT1s5OTk/HBBx/o7Wz4wQcfIDk5mfWzSVZVmmZQEefPn+fiL6o1ioqKEB8fjzp16qBu3brIyMiQ2tzd3ZGXl4f4+HgUFRUZlO4iIjJHKpUK06ZNQ3h4OI4fP464uDipTbed7bRp0/hHOsmmWkZmtVotrly5gg8//BBbt25FQEBAdZyGyOxs3boVGo0Gzz33nEGbEALPPfccNBoNtm7dKkN0RESPJigoCPPmzYOzs7PecRcXF8ybNw9BQUHyBEaEKo7MKpXKcktzCSHg4uKCRYsWVeU0RBYjLS0NALB9+3YEBAQgPDxcqscYExOD7du36/UjIrIUQUFBCAwMNFgAxhFZkluVktmgoCCjyaxSqYSLiwu6du2K8ePHo2HDhlU5DZHFcHd3BwD4+voiMjISJ06cQFxcHFxdXREZGYlJkybhwoULUj8iIkuiUqkM6mcTya1KyezevXtNFAbR48HX1xcAcO3aNYSEhODGjRtSW8OGDZGbm6vXj4jIkmg0Go7Mktmp9gVgRLWJLlktKCiARqPBK6+8gn79+mHnzp3YuHEjiouL9foREVmK2NhYREdHIz09XTrm7u6OKVOmcM4syaraS3MR1Sa6xRH169eHVqvFf//7X4wePRr//e9/odVqUb9+fb1+RESWIDY2FhEREcjKytI7npWVhYiICMTGxsoUGVElR2Yf9atRhUKB8+fPP9JtiSyRh4cHVq1aheXLl+Pq1avw8vLCxIkT8f777+PWrVtyh0dEVGEajQaLFy+GEAKdOnXCv/71L2lh69q1axEXF4cvvvgCgYGBnHJAsqhUMqvVag0WfBUVFeH69esld2ZlhXr16uH27dtSbVkPDw/W06RaQ7fzV3JyMl566SUUFhYCAI4ePYpffvlFul7eDmFEROYkMTER2dnZaNeuHRYsWCDtAObn54cFCxZIO4AlJiZyBzCSRaWmGVy8eBGpqanST0JCAjw8PBAUFIS//voLBQUFuH79OgoKChAbG4ugoCB4enpy32aqNVxdXaXLD+4UXfp66X5EROZM9xk+btw4va1sgZLqRePGjdPrR1TTqjRndubMmSgoKMCePXsQGBgovciVSiWeeuop7N69G/n5+Zg5c6ZJgiUyd35+flCpVKhTpw5cXFz02lxcXFCnTp0KbXlLRGRuyqsrTySnKiWzW7duxYABA8qcI2NlZYUBAwZwtyOqNVJSUqDRaHD37l0UFRVhxowZ2LRpE2bMmIGioiLcvXsXGo0GKSkpcodKRFQhHTp0AACsWLECWq1Wr02r1WLlypV6/YhqWpVKc+Xm5iInJ6fcPjk5OQ/tQ/S40C3uat68OXJycvD5559LbW5ubmjevDnOnj3LRWBEZDE6dOgAZ2dnJCcn44MPPjBYAJacnAxnZ2cmsySbKo3M+vn54aeffiqzUsHZs2fx008/oW3btlU5DZHF0C3sat26tcHcMoVCgdatW+v1IyIydyqVCtOmTQMAHD9+HKGhoejXrx9CQ0Nx/PhxAMC0adNYyYBkU6VkNiwsDDk5OejYsSOmTp2KTZs24a+//sKmTZvwzjvvoHPnzsjLy0NYWJip4iUya7r6sdu2bYOPjw+ioqKwc+dOREVFwcfHB9u2bdPrR0RkCYKCgjBv3jyD9y4XFxfMmzePmyaQrKo0zWDQoEFYuXIl3nzzTXz11VdYsmSJ1CaEgKOjI1asWIEXX3yxyoESWYLSVQo0Gg3WrVuHvLw8ODg4QKPRGO1HRGQJgoKCEBgYyO1syexUeTvbMWPGYMiQIdiyZQv+/vtv5OTkwMnJCe3bt8egQYPg6OhoijiJLIqdnR0OHz5s9Pi9e/dkiIiIqOpUKhU6duwodxhEeqqczAKAg4MDRo8ejdGjR5vi7ogslm4u7L1796BQKNC5c2d06NABiYmJOHbsmJTIcs4sEVkijUbDkVkyO1WaM1vdPv74YygUCrzzzjvSsYKCAoSGhqJevXqoW7cuhg4dioyMDPmCJCqlbt26AEpqLTds2BBHjx7Fd999h6NHj8LNzU1aFKbrR0RkKWJjYxESEoKpU6fiww8/xNSpUxESEoLY2Fi5Q6NarlIjs6tXrwYADBkyBA4ODtL1ihgzZkylAjty5Ai++eYb+Pv76x2fOnUqduzYgQ0bNsDJyQlvvPEGXnrpJRw4cKBS909UHQ4ePAigZBvn77//Htu3b0daWho8PT0xcOBATJgwAdeuXcPBgwfRvXt3maMlIqqY2NhYREREICAgAHPmzJFKc8XExCAiIgKRkZFcBEayUYgH99wsh1KphEKhwKlTp9CiRQvpenmEEFAoFHqLXx7mzp076NSpE6KjozF//nx06NABX375JXJyctCgQQP8+OOPePnllwEAp0+fRuvWrREXF4cePXpU6P5zc3Ph5OSEnJwczuklk5oxYwaOHj0KAFCr1SgsLJTaSl/v0qWLXg1aIiJzpdFoEBISAl9fX8yfP1+v7KBWq0VYWJhUc5ZTDsiUKpqvVWpk9ocffoBCoYCHhweAkt1AqkNoaCj69++P3r17Y/78+dLxY8eOobi4GL1795aOtWrVCt7e3uUms4WFhXpJRW5ubrXETeTl5SUls+X9nejl5VVTIRERVUlSUhLS09MxZ84cg/rZSqUSISEhCA0NRVJSEheHkSwqlcyOGzdO7/rYsWNNGQsA4KeffsLx48dx5MgRg7b09HTY2NgY1Llzc3NDenp6mfe5cOFCREZGmjpUIgOvvvoqtmzZAqCkluyNGzekNicnJ+n6q6++Kkd4RESVlpmZCQDw8fEx2q47rutHVNPMagHYlStX8PbbbyMmJga2trYmu99Zs2ZJ2+rm5OTgypUrJrtvotLOnj0rXb558yaef/55LF++HM8//zxu3rxptB8RkTnT1cVOTU2FRqNBQkIC9uzZg4SEBGg0GqSmpur1I6ppVSrNdeXKFZw9exY9evSAvb09gJL5M5999hm2bdsGOzs7TJ06Ff3796/Q/R07dgw3btxAp06dpGMajQaxsbH4z3/+g19//RVFRUXIzs7WG53NyMiAu7t7mferVquhVqsf7UESVcKtW7cAlIzKZmdn4/fff8fvv/8uteuO6/oREZk7f39/uLu7Y8mSJcjOztarIOTm5gZnZ2d4eHgYLNgmqilVSmbnzJmD7du3633Fv2DBAkREREjX9+3bh4MHD6Jr164Pvb/nnnsOycnJesfGjx+PVq1aYebMmWjcuDGsra2xZ88eDB06FABw5swZXL58GQEBAVV5KEQmoasf++qrr+K5557DN998g6tXr8LLywuTJk3C7t27sWjRItaZJSKLoVKp0KtXL/z0009wdnbG8OHD4enpibS0NPz22284c+YMRo4cycVfJJsqJbMHDhxA7969YW1tDaBkwct//vMftGrVCr/99hvS09PRu3dvfPbZZ1i/fv1D78/BwQFt27bVO1anTh3Uq1dPOj5hwgRMmzYNrq6ucHR0xJtvvomAgIAKVzIgqk66bwz++usv9OvXT69Gslarxf79+/X6ERGZO41Gg71798LT0xMZGRl6n+cqlQqenp7Yt28fJk6cyISWZFGlZPbGjRto0qSJdD0xMRE3b97E3Llz4eXlBS8vLwwePBj79u2rcqA6X3zxBZRKJYYOHYrCwkIEBwcjOjraZPdPVBX169cHABw+fBhhYWEICQnRq8eo2+JW14+IyNzpqhkoFAr06NED3bp1g62tLQoKCnD48GHEx8dDCMFqBiSbKiWzWq0WWq1Wur53714oFAo8++yz0rFGjRqVW2ngYfbu3at33dbWFlFRUYiKinrk+ySqLrq5ZU5OTrhw4QJCQ0OlNg8PD7Ro0QK5ubmcW0ZEFkM3x79bt25YsGCBXnmuQYMGYdasWTh06BDXApBsqlTNwNvbWxppAoAtW7bAw8MDLVu2lI6lp6fzK1WqNVQqFaZMmYJ//vkHTZo0QVBQEDp27IigoCB4e3vjn3/+weTJk/lVHBFZDN0c/6effhpCCL1qBkIIPPXUU3r9iGpalUZmhw4digULFuDll1+Gra0t9u/fjzfeeEOvz8mTJ+Hr61ulIIksSVBQEJ588kmjWywHBgZyy0cisii6AamtW7di7dq1et+2uru7w8HBQa8fUU2rUjI7Y8YM/Pbbb/jf//4HoOQr1rlz50rtly5dwuHDh/H+++9XKUgiS7Js2TIcOHAATk5O6NixozS3LCEhAQcOHMCyZcvw+uuvyx0mEVGF6Ob4nz17Fi4uLpgxYwYCAgIQFxeH77//XkpuuRaA5KIQ5e25WUEnTpwAALRu3Vrv69NLly4hMTERXbp0QaNGjap6GpOp6F6/RJVVVFSEvn37wtbWFg4ODgYjGHl5eSgoKMAvv/wCGxsbGSMlIqqY0u9rderU0dvZ0M3NDXfu3OH7GlWLiuZrVRqZ1XmwnJZOkyZN9KodED3utm7dCo1Gg7t376J9+/aYM2eOXjWDgwcPSv2GDRsmc7RERA+XkpICjUaD/Px8+Pv745VXXoFarUZhYaFeNYOUlBRWMyBZmGQ72/T0dERHR+Ott97S23P+5s2bOHz4MO7du2eK0xCZvWvXrgEAunTpgsjISBQVFSEuLg5FRUWIjIxEly5d9PoREZm7zMxMAMDs2bORmpqKr776Cp9++im++uorXLx4EbNnz9brR1TTqjwyGx0djenTp6OwsBAAoFAo8N133wEoqUMbEBCAZcuWYeLEiVU9FZHFsLW1xejRow2mGTzxxBMyRkVEVHmurq4AAE9PT8TExCApKQmZmZlwdXWFv78/Tp8+rdePqKZVaWR2+/bteOONN9CuXTts27YNkydP1mv38/ODv78/tmzZUpXTEFmM1q1bAwD2798PHx8fREVFYefOnYiKioKPj4+0A5iuHxGRudPVz46JidGrLQ+U1JuPiYmBh4cH62eTbKo0MvvZZ5/B29sbf/75J+rUqYNjx44Z9GnXrh3++uuvqpyGyGKUXs176tQpXLhwAW5ubrhw4QJOnTpltB8RkTnT1c8ODw/HgAEDpG9iAUhzZ+fNm8f62SSbKiWziYmJGD16NOrUqVNmn0aNGiEjI6MqpyGyOPXr10dmZiYWLVokHVMqlahfvz53ySEii6RQKCp1nKimVHk7W2tr63L73LhxA2q1uiqnIbIYuh1wbt++je7du6NRo0YoLCyEWq3GtWvXcOjQIb1+RETmTqPRIDo6Gi1atEBmZiZu3rwptTk6OsLV1RVLly5FYGAgR2dJFlVKZlu2bFnuFIL79+8jNjYW7dq1q8ppiCyGbgHEq6++im3btiE+Pl5qc3d3x6uvvorly5dzoQQRWYykpCSkp6frLWjVuXnzppTcJiUlsTQXyaJKC8BCQkKQkJCAyMhIgzaNRoMZM2bgwoULGDNmTFVOQ2QxdAslduzYYTC9Jj09HTt27OBCCSKyKKWnRimV+mlD6eucQkVyqdLI7Jtvvont27dj3rx5iImJga2tLQBg+PDhOHr0KC5evIgXXngBEyZMMEmwROZOpVKhWbNmOHDggNH2tLQ0fhVHRBaldJLarVs3jB49WtoMZs2aNdI3UExmSS5VGpm1trbGr7/+ivfffx+3b9/GiRMnIITAxo0bkZmZiZkzZ2Lbtm2cHE61hm6TBAAGc8V113WbKBARWYKzZ88CAOzs7DB//nz4+fnB3t4efn5+mD9/Puzs7PT6EdW0Ku8AZmNjgwULFuDWrVs4efIk9u/fj6SkJNy+fRsLFy7EtWvXMG7cOBOESmT+Nm/eDK1Wi2bNmuHnn3/GF198gTlz5uCLL77Azz//DF9fX2i1WmzevFnuUImIKuTGjRsAgHv37iE8PBwpKSnIz89HSkoKwsPDpV0+df2IappJtrMFSkpztGrVCk8++STatm2La9euYeLEiWjVqhXWrFljqtMQmbXk5GQAJQvAhBA4d+4cTpw4gXPnzkEIIU250fUjIjJ37u7uAIAGDRrg/PnzCA0NRb9+/RAaGorz58+jQYMGev2IatojzZndv38/5syZg2PHjsHKygpPP/00Pv30U7Rs2RL5+fkICwtDdHQ0ioqK4OnpiVmzZpk6biKzpPu6bf369QgLC4NGo5Hali1bJi380vUjIjJ3wcHB2L17t15JLp3SC12Dg4NrMiwiSaWT2WPHjqF37956c/62b9+Oo0eP4q+//sKLL76IkydPwtPTEzNnzsRrr73GOrNUa7zwwgv4/fffkZCQABcXF0yYMAEBAQGIi4vD999/j4SEBKkfEZEl6NSpE6ysrHD//v0y+1hZWaFTp041GBXR/6v0NINPP/0URUVFWLhwIW7cuIEbN25gwYIFuH79Op5++mmcPn0aYWFhOHfuHN58800mslSrtG3bVrqs0Whw+fJl/PXXX7h8+bLeKG3pfkRE5kyj0ei9fz1qH6LqUumR2QMHDuDZZ5/FzJkzpWOzZs3C7t27sXfvXnz22WeYNm2aSYMkshQ///yzdDk3Nxfr168vs9+wYcNqKiwioke2efNmCCHg5uYGIYTeQi83NzcAJdMNNm/ejBEjRsgVJtVilR6ZvXHjBjp37mxwXHds7NixVY+KyEKlpaVJl21sbPTaSn9LUbofEZE50y1Y7d27t9FSm88995xeP6KaVumR2fv376NOnToGx3XH6tWrV/WoiCyUbjVvs2bNEBUVhe3btyMtLQ2enp4YOHAgpkyZggsXLnDVLxFZDN2C1ZiYGDz55JMIDw+XNk2IiYnBjz/+qNePqKZVaQcwItLn6+sLALh27RrGjh2rt9J348aNyMnJ0etHRGTuevfujd9//x0qlQpz5szB6dOnERcXB1dXV8yZMwcDBgyARqNB79695Q6VaqlHSmbXrl0rbV+nc+7cOQBAv379DPorFArs2LHjUU5FZFFyc3MBAAUFBSgoKNBrK53Y6voREZk7K6uSVEGj0aB///7QarVSm1KplK7r+hHVtEd65Z07d05KXh+0a9cug2PczpZqC2dnZ5P2IyKSW3Z2tnS5dCL74PXS/YhqUqWT2dTU1OqIg+ixUPqN3dHRET4+PhBCQKFQIDU1VRqRffADgYjIXOn++La1tTX4xqn0cf6RTnKpdDLbpEmT6oiD6LGg2xQBKJlq8Pfff0vXS1c3SEhIQNeuXWs0NiKiqigoKIC1tTWCgoLQqlUrnD59GrGxsUYTXKKaxAkuRCZ05swZ6XLpXfIevF66HxGROStdV7ZTp0546aWX4OPjgzZt2uDOnTs4dOiQQT+imsRklsiESteS7dq1KwoLC5GTkwMnJyeo1WocOXLEoB8RkTnbv38/AMDf3x+XLl1CaGio1Obh4YF27dohOTkZ+/fvR9++feUKk2oxJrNEJlS6zrIucX1YPyIic1ZYWAgAUKlUWLlypUH97FmzZun1I6ppTGaJTMjBwcGk/YiI5Obl5YWjR48iISEBAwcORHFxsdT27bffSte9vLzkCpFquUpvZ0tEZRNCmLQfEZHcJk2aJF0uncg+eL10P6KaxGSWyIQuXboEALC2tjbarjuu60dEZO5sbGygVJafLiiVSr2KLUQ1ickskQnp5owVFxcbbBaiUCikUQzOLSMiS3H8+PGH1sbWarU4fvx4DUVEpI/JLJEJNWrUSLr84FSC0tdL9yMiMme6nT1tbGwMFq/Wq1dPGpE1tgMoUU1gMktkQgEBASbtR0Qkt/PnzwMoqZV9+/Ztvbbbt29LNbR1/YhqGqsZEJlQcnJyhfsxoSUiS2Bvby9ddnZ2xgsvvIBGjRrh2rVr+O2335CdnW3Qj6gmMZklMqGK7uzFHcCIyFI0bdoUJ0+eBADk5eVh/fr1UptKpdLrRyQHTjMgMqHSe5Q/WNGg9HXuZU5ElqL0glWNRqPXVvo6F7aSXDgyS2RCpbeptbe3R3BwMDw9PZGWloZff/0VOTk5Bv2IiMxZRf/45h/pJBcms0Qm5OzsLF3OycnR+zqurH5EROasottvc5tukguTWSITelhh8cr2IyKSW+vWrbFt2zYAQJcuXWBvb4+8vDw4ODggPz8fR48elfoRyYHJLJEJNWjQwKT9iIjkdufOHemyLnF9WD+imsThISITcnBwMGk/IiK5VXRaFKdPkVw4MktkQhUtGs7i4kRkKVxdXaXLTk5OaNq0KYQQUCgUuHjxorSwtXQ/oprEZJbIhK5du2bSfkREctNqtQBKtrPNzc3F33//LbUpFArY2NigqKhI6kdU05jMEpnQjRs3TNqPiEhuSUlJAEq2s3VxccHzzz8vlRz8/fffkZWVJfXr2rWrnKFSLcVklsiEdHuUAyU74/j4+ECtVqOwsBCpqalSgfHS/YiIzJluxNXLywvFxcV6JQfd3d3h5eWFq1evcmSWZMNklsiEhBDSZY1Gg3Pnzj20HxGROXN0dAQAFBcXG7QJIaTjun5ENY3JLJEJ2dvb4+7duxXqR0RkCXQLuzIyMgzaSh/jAjCSC0tzEZlQ/fr1TdqPiEhuFU1SmcySXJjMEpkQ68wS0eOmonNhOWeW5MJpBkQmxGoGRPS4SUxMlC47OTmhY8eOsLW1RUFBARISEqQ6s4mJiaxmQLJgMktkQvfv3zdpPyIiuenmxTo6OiIvLw979+6V2pRKJRwcHJCXl2d0Ti1RTWAyS2RCnGZARI+r3Nxc9OjRA927d5dKDh46dAjx8fFyh0a1HOfMEpmQk5OTSfsREcmtYcOG0mWFQoEWLVqgV69eaNGiBRQKhdF+RDWJI7NEJlTRklsszUVElqL0H9/Hjh1DXFycdN3GxsZoP6KaxJFZIhNiMktEj5vySm6VHpllaS6SC0dmiUzo1q1bJu1HROaroKAAly9fljuMaldQUCBdfnD3wtLluAoKCvDPP//UWFxy8fb2hq2trdxhUClMZolM6MqVKybtR0Tm6/Lly3jttdfkDqNGPbilbenrixYtqulwZPHtt9+iRYsWcodBpTCZJTKh0l+5maIfEZkvb29vfPvtt3KHUSOOHz+Ob775Bm3btoWnpyd+/fVXBAcHIy0tDSdOnMCkSZPQqVMnucOsEd7e3nKHQA9gMktkQhX96olfURFZPltb21ozQteiRQt4enoiOjoaycnJAIBff/0VHh4eiIyMRFBQkMwRUm3GZJbIhOrUqWPSfkRE5iIoKAiBgYHYuXMnFi1ahOnTp6Nfv35QqVRyh0a1HKsZEJlQdna2SfsREZkTlUqFli1bAgBatmzJRJbMApNZIhPS7VFuqn5ERERUPiazRCZUepTCykp/Fo+1tbXRfkRERPToOGeWakRtqcdYv3593L59GwCg0Wj02u7fv6/Xj/UYiYiIqo7JLNWI2liP8cHi4qWvnzlzplY8H6zHSERE1Y3JLNWI2lKPUavV4q233kJRUVGZfWxsbLBkyRIolY//LB/WYyQiourGZJZqRG2qxxgWFobw8PBy21u1alWDERERET2+Hv+hIaIaFhQUhHnz5sHNzU3vuLu7O+bNm8fi4kRERCbEkVmiasDi4kRERDWDI7NE1YTFxYmIiKofk1kiIiIislhMZomIiIjIYjGZJSIiIiKLxWSWiIiIiCwWk1kiIiIislhMZomIiIjIYjGZJSIiIiKLxWSWiIiIiCwWk1kiIiIislhMZomIiIjIYjGZJSIiIiKLxWSWiIiIiCwWk1kiIiIislhml8wuXLgQXbt2hYODAxo2bIjBgwfjzJkzen0KCgoQGhqKevXqoW7duhg6dCgyMjJkipiIiIiI5GJ2yey+ffsQGhqK+Ph4/P777yguLsYLL7yAu3fvSn2mTp2K7du3Y8OGDdi3bx/S0tLw0ksvyRg1EREREcnBSu4AHrRr1y696ytXrkTDhg1x7NgxBAUFIScnB99//z1+/PFHPPvsswCAFStWoHXr1oiPj0ePHj3kCJuIiIiIZGB2I7MPysnJAQC4uroCAI4dO4bi4mL07t1b6tOqVSt4e3sjLi7O6H0UFhYiNzdX74eIiIiILJ9ZJ7NarRbvvPMOAgMD0bZtWwBAeno6bGxs4OzsrNfXzc0N6enpRu9n4cKFcHJykn4aN25c3aETERERUQ0w62Q2NDQUJ06cwE8//VSl+5k1axZycnKknytXrpgoQiIiIiKSk9nNmdV544038PPPPyM2NhZeXl7ScXd3dxQVFSE7O1tvdDYjIwPu7u5G70utVkOtVld3yERERERUw8xuZFYIgTfeeAObN2/GH3/8AR8fH732zp07w9raGnv27JGOnTlzBpcvX0ZAQEBNh0tEREREMjK7kdnQ0FD8+OOP2Lp1KxwcHKR5sE5OTrCzs4OTkxMmTJiAadOmwdXVFY6OjnjzzTcREBDASgZEREREtYzZJbNLly4FAPTq1Uvv+IoVKzBu3DgAwBdffAGlUomhQ4eisLAQwcHBiI6OruFIiYiIiEhuZpfMCiEe2sfW1hZRUVGIioqqgYiIiIiIyFyZ3ZxZIiIiIqKKYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFspI7ACIisnwZGRnIycmROwyqAZcuXdL7lx5/Tk5OcHNzkzuMMjGZJSKiKsnIyMC/Ro9BcVGh3KFQDVqwYIHcIVANsbZRY+2a1Wab0DKZJSKiKsnJyUFxUSHu+faE1tZJ7nCIyISUBTnAhX3IyclhMktERI83ra0TtHXqyx0GEdUyXABGRERERBaLySwRERERWSxOM5ABV/3WHlz1W/uY+6pfIqLHDZPZGsZVv7UTV/3WHua+6peI6HHDZLaGcdUv0ePLElb9EhE9bpjMyoSrfomIiIiqjgvAiIiIiMhiMZklIiIiIovFZJaIiIiILBaTWSIiIiKyWExmiYiIiMhiMZklIiIiIovFZJaIiIiILBaTWSIiIiKyWExmiYiIiMhiMZklIiIiIovFZJaIiIiILBaTWSIiIiKyWExmiYiIiMhiWckdABERPR6U97LlDoGITMwSfq+ZzBIRkUnYpcbKHQIR1UJMZomIyCTu+QRBa+csdxhEZELKe9lm/4cqk1kiIjIJrZ0ztHXqyx0GEdUyXABGRERERBaLySwRERERWSwms0RERERksThnViaWUOqCiCqHv9dERDWPyaxMzH1lIBEREZElYDIrE5awIXr8WEIJGyKixw2TWZmwhA0RERFR1XEBGBERERFZLCazRERERGSxmMwSERERkcViMktEREREFovJLBERERFZLCazRERERGSxmMwSERERkcViMktEREREFovJLBERERFZLO4ARkREJqEsyJE7BCIyMUv4vWYyS0REVeLk5ARrGzVwYZ/coRBRNbC2UcPJyUnuMMrEZJaIiKrEzc0Na9esRk6O+Y/gUNVdunQJCxYswAcffIAmTZrIHQ7VACcnJ7i5uckdRpmYzBIRUZW5ubmZ9YcdmV6TJk3QokULucMg4gIwIiIiIrJcHJmViSVMqCaiyuHvNRFRzWMyW8O4UILo8WbuCyWIiB43TGZrGBdK1C5cKFH7mPtCCSKixw2TWRlwoUTtw4USRERE1YMLwIiIiIjIYjGZJSIiIiKLxWSWiIiIiCwWk1kiIiIislhMZomIiIjIYjGZJSIiIiKLxWSWiIiIiCwWk1kiIiIislhMZomIiIjIYjGZJSIiIiKLZbHJbFRUFJo2bQpbW1t0794dhw8fljskIiIiIqphFpnMrlu3DtOmTUNERASOHz+O9u3bIzg4GDdu3JA7NCIiIiKqQRaZzC5evBgTJ07E+PHj0aZNGyxbtgz29vb44Ycf5A6NiIiIiGqQldwBVFZRURGOHTuGWbNmSceUSiV69+6NuLg4o7cpLCxEYWGhdD03N7fa4yR9BQUFuHz5stxh1LhLly7p/VvbeHt7w9bWVu4wiKoF39f4vkbmweKS2Vu3bkGj0cDNzU3vuJubG06fPm30NgsXLkRkZGRNhEdluHz5Ml577TW5w5DNggUL5A5BFt9++y1atGghdxhE1YLva3xfI/Ngccnso5g1axamTZsmXc/NzUXjxo1ljKj28fb2xrfffit3GFTDvL295Q6BqNrwfa124vua+bG4ZLZ+/fpQqVTIyMjQO56RkQF3d3ejt1Gr1VCr1TURHpXB1taWf8kS0WOF72tE5sHiFoDZ2Nigc+fO2LNnj3RMq9Viz549CAgIkDEyIiIiIqppFjcyCwDTpk3D2LFj0aVLF3Tr1g1ffvkl7t69i/Hjx8sdGhERERHVIItMZkeMGIGbN28iPDwc6enp6NChA3bt2mWwKIyIiIiIHm8KIYSQO4ialpubCycnJ+Tk5MDR0VHucIiIiIjoARXN1yxuziwRERERkQ6TWSIiIiKyWExmiYiIiMhiMZklIiIiIovFZJaIiIiILBaTWSIiIiKyWExmiYiIiMhiMZklIiIiIovFZJaIiIiILBaTWSIiIiKyWExmiYiIiMhiMZklIiIiIovFZJaIiIiILJaV3AHIQQgBAMjNzZU5EiIiIiIyRpen6fK2stTKZDYvLw8A0LhxY5kjISIiIqLy5OXlwcnJqcx2hXhYuvsY0mq1SEtLg4ODAxQKhdzh0GMsNzcXjRs3xpUrV+Do6Ch3OEREVcb3NaopQgjk5eXB09MTSmXZM2Nr5cisUqmEl5eX3GFQLeLo6Mg3fSJ6rPB9jWpCeSOyOlwARkREREQWi8ksEREREVksJrNE1UitViMiIgJqtVruUIiITILva2RuauUCMCIiIiJ6PHBkloiIiIgsFpNZIiIiIrJYTGaJiIiIyGIxmSWqJitXroSzs7PcYRARET3WmMwSPcS4ceOgUCgMfs6dOyd3aEREj8zY+1rpn7lz58odIlGF1ModwIgqq0+fPlixYoXesQYNGsgUDRFR1V2/fl26vG7dOoSHh+PMmTPSsbp160qXhRDQaDSwsmLaQOaHI7NEFaBWq+Hu7q7389VXX6Fdu3aoU6cOGjdujClTpuDOnTtl3sfff/+NZ555Bg4ODnB0dETnzp1x9OhRqX3//v14+umnYWdnh8aNG+Ott97C3bt3a+LhEVEtVPr9zMnJCQqFQrp++vRpODg44JdffkHnzp2hVquxf/9+jBs3DoMHD9a7n3feeQe9evWSrmu1WixcuBA+Pj6ws7ND+/btsXHjxpp9cFSrMJklekRKpRJLlixBSkoKVq1ahT/++APvvfdemf1DQkLg5eWFI0eO4NixY3j//fdhbW0NADh//jz69OmDoUOHIikpCevWrcP+/fvxxhtv1NTDISIy8P777+Pjjz/GqVOn4O/vX6HbLFy4EKtXr8ayZcuQkpKCqVOn4l//+hf27dtXzdFSbcXvC4gq4Oeff9b7yq1v377YsGGDdL1p06aYP38+Xn/9dURHRxu9j8uXL+Pdd99Fq1atAADNmzeX2hYuXIiQkBC88847UtuSJUvQs2dPLF26FLa2ttXwqIiIyjdv3jw8//zzFe5fWFiIjz76CLt370ZAQAAAwNfXF/v378c333yDnj17VleoVIsxmSWqgGeeeQZLly6VrtepUwe7d+/GwoULcfr0aeTm5uL+/fsoKChAfn4+7O3tDe5j2rRpePXVV7FmzRr07t0bw4YNQ7NmzQCUTEFISkpCTEyM1F8IAa1Wi9TUVLRu3br6HyQR0QO6dOlSqf7nzp1Dfn6+QQJcVFSEjh07mjI0IgmTWaIKqFOnDp544gnp+sWLFzFgwABMnjwZCxYsgKurK/bv348JEyagqKjIaDI7d+5cjBo1Cjt27MAvv/yCiIgI/PTTTxgyZAju3LmDSZMm4a233jK4nbe3d7U+NiKistSpU0fvulKphBBC71hxcbF0WbduYMeOHWjUqJFeP7VaXU1RUm3HZJboERw7dgxarRaLFi2CUlky9Xz9+vUPvV2LFi3QokULTJ06Fa+88gpWrFiBIUOGoFOnTjh58qRewkxEZG4aNGiAEydO6B1LTEyU5v+3adMGarUaly9f5pQCqjFcAEb0CJ544gkUFxfj66+/xoULF7BmzRosW7aszP737t3DG2+8gb179+LSpUs4cOAAjhw5Ik0fmDlzJg4ePIg33ngDiYmJOHv2LLZu3coFYERkVp599lkcPXoUq1evxtmzZxEREaGX3Do4OGDGjBmYOnUqVq1ahfPnz+P48eP4+uuvsWrVKhkjp8cZk1miR9C+fXssXrwYn3zyCdq2bYuYmBgsXLiwzP4qlQq3b9/GmDFj0KJFCwwfPhx9+/ZFZGQkAMDf3x/79u3DP//8g6effhodO3ZEeHg4PD09a+ohERE9VHBwMObMmYP33nsPXbt2RV5eHsaMGaPX58MPP8ScOXOwcOFCtG7dGn369MGOHTvg4+MjU9T0uFOIBye/EBERERFZCI7MEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhEREZHFYjJLRERERBaLySwRERERWSwms0RERERksZjMEhE9oGnTpmjatKncYZARvXr1gkKhqNZzKBQK9OrVq9ruf9y4cVAoFLh48WK1nYOoNmEyS0QGLl68CIVCofdjbW2NRo0aYfjw4Th69KjcIVaYscfy4E9tT1xXrlwJhUKBlStXPtLtPv744+oJjIioAqzkDoCIzFezZs3wr3/9CwBw9+5dHDt2DBs2bMCWLVuwe/duBAUFyRxhxZV+LA9ydnau2WCIiMhkmMwSUZmeeOIJzJ07V+/Yxx9/jFmzZmHOnDnYt2+fPIE9AmOPhYiILB+nGRBRpUyYMAEAcOzYMYO2H374AYMGDULTpk1ha2sLV1dXBAcH488//zTou3fvXigUCsydOxcHDx7ECy+8AGdnZ735kEII/PDDDwgMDISjoyPs7e3RpUsX/PDDD9X3AMtRmXjmzp0LhUKBvXv3YsWKFWjXrh3s7Ozg4+ODJUuWSPe3aNEitGzZEra2tmjevDlWr15t9NxFRUVYvHgxOnXqhDp16sDBwQFPP/00tm3bZtBXNyczNTUVS5YsQatWraBWq9GkSRNERkZCq9Xq9R0/fjwAYPz48XrTLx6Vbs7xnTt38Pbbb8PT0xNqtRr+/v7YuHFjmY/viy++QNeuXeHg4IC6deuiTZs2mDZtGrKysso9X+nn+kHlTaH47rvv0LZtW9ja2qJx48Z47733UFBQUOZ58vLyEBERAT8/P9jZ2cHZ2RnBwcHYv3+/0f4pKSkYMGAAHBwc4OTkhH79+uHEiRPlPhYiqjyOzBLRI7GyMnz7CA0NRfv27dG7d280aNAA165dw5YtW9C7d2/873//w6BBgwxuc/DgQXz00Ud45pln8Nprr+Hy5csAShK9kJAQ/Pe//0Xz5s0xatQo2NjY4Pfff8eECRNw8uRJfP7559X+OHUeNZ4vv/wSe/fuxaBBg/Dss89i06ZNePvtt2Fvb4+EhARs2rQJAwYMwHPPPYeffvoJY8eORdOmTfWmcBQWFqJPnz7Yu3cvOnTogAkTJqC4uBg7duzAoEGD8PXXX+ONN94wOPe7776Lffv2YcCAAQgODsaWLVswd+5cFBUVYcGCBQCAwYMHIzs7G1u3bsWgQYPQoUMHkzxfxcXFeOGFF5CVlYWhQ4ciPz8fP/30E4YPH45du3bhhRdekPreu3cPzz//PA4cOIDmzZtj/PjxUKvVOHv2LL755huMGTMGLi4uJolL58MPP0R4eDjc3NwwceJEWFtbY926dTh16pTR/pmZmQgKCkJKSgoCAwPx+uuvIzc3F1u3bsUzzzyDDRs2YPDgwVL/EydOIDAwEHfu3MFLL72E5s2b4/DhwwgMDET79u1N+liIaj1BRPSA1NRUAUAEBwcbtH300UcCgOjfv79B24ULFwyOpaWlCU9PT9G8eXO943/++acAIACIH374weB23377rQAgxo8fL4qKiqTjhYWFYuDAgQKAOHr0aIUfS7NmzURERITRn19++UXvNk2aNBFNmjSpUjwRERECgHB1dRXnz5+Xjl++fFnY2NgIJycn0aJFC3Hjxg2pLT4+XgAQAwcO1Dv37NmzBQAxZ84codVqpeO5ubmiS5cuwsbGRly7dk06PnbsWAFA+Pj4iLS0NOn4zZs3hbOzs3BwcBCFhYXS8RUrVggAYsWKFQ99PkvT3W7hwoV6x5s0aSIAiEGDBumdZ/fu3UZfV9OnTxcAxOjRo8X9+/f12rKzs0VeXp50vWfPnuLBjy7dc/3nn3+WGWPpx3b27FlhZWUlGjVqJDIyMqTjOTk5omXLlgKA6Nmzp979jBo1SgAQy5cv1zuekZEhGjduLBo0aCDu3btnEOfatWv1+s+aNUt63aemphrES0SVx2SWiAwYSwBnzJghnnnmGQFAuLm5iZMnT1b4/t58800BQFy8eFE6pktmO3XqZPQ2/v7+ok6dOiI/P9+gLSkpSQAQ06dPr/BjKe/n7bff1ruNsWS2svHoEqzIyEiD/s8++6wAIFatWmXQ5uvrK7y9vaXrGo1GuLi4iGbNmuklsjrbtm0TAMTXX38tHdMls8b+SNC1JSUlSceqK5k19sdNkyZNhKurq3S9uLhYODg4CCcnJ5GZmfnQc5oimY2MjBQAxKJFiwz6r1mzxiCZvXnzplCpVOLZZ581GtOSJUsEALF9+3YhhBCXLl0SAIS/v79B37y8POHs7MxklsiEOM2AiMp0/vx5REZG6h1zd3fHX3/9hSeeeMKg/4ULF7Bw4UL88ccfuHbtGgoLC/Xa09LS0KRJE71jXbt2Nbif/Px8JCcnw9PTE5988olBe3FxMQDg9OnTFX4swcHB2LVrV4X7myoeY1/be3h4lNt26NAh6fqZM2eQlZUFT09Pg/8LALh582aZ5+7cubPBMS8vLwBAdna2QZspOTs7w8fHx+j54+LipOunT59GXl4eevfubfKpBGX5+++/AQBPP/20QZuxY0eOHIFGo0FhYaHRRYRnz54FUPJYBgwYIN3/U089ZdC3bt266NChg9H5vUT0aJjMElGZSieAN2/exKpVqzBz5ky8+OKLOHz4MOrWrSv1PXfuHLp164bc3Fw888wzGDhwIBwdHaFUKrF3717s27fPILkFADc3N4NjWVlZEELg2rVrRhM4nbt375rgUT5cVeJxdHQ0OKabb1xW2/3796XrmZmZAEoWE6WkpJjs3BqNpsz7MgUnJyejx62srPQWoOXk5AAAGjVqVK3xlKY7Z8OGDQ3ajL0edf8HBw4cwIEDB8q8X93/QXn3X9Y5iOjRMZklogpp0KABZsyYgZycHMyfPx9hYWH48ssvpfYvvvgCWVlZWLNmjUE919dff73MMl7GVs3rkrDOnTubxQYNcsajO/fQoUPLrARgyXQ1fq9du/bI96FUlhTmKf1HgI4usSxNl2jfuHHD4JuCjIwMg/66/4Pp06dXaNFh6fs3xtg5iOjRsTQXEVXK7Nmz4enpiejoaL3tOM+fPw8ABhULhBDljmYZ4+DggNatW+PUqVPV/nW4ucfTunVrODo64ujRo9J0BlNTqVQAqn+01piWLVvC0dERR44ceWgJrrLopicYS4gTEhIMjumqCfz1118GbcaOde3aFQqFQm96RHl092+sZNedO3eQmJhYofshoophMktElWJnZ4eZM2eiuLgYH374oXRcN8L14Af4xx9//Ei1Nd966y3k5+dj4sSJRr9CT01NrdG97eWKx8rKCpMnT8alS5cwY8YMowntiRMnyhwFrAhXV1cAwJUrVx75Ph6VlZUVJk2ahJycHLz99tsGCXVOTg7u3LlT7n3o5l2vXr1abwpDXFwcYmJiDPqPGjUKKpUKixcv1nvecnNzMX/+fIP+7u7uGD58OA4ePIjPPvsMQgiDPocOHUJ+fj4AwNvbG0FBQUhKSjI4/0cffWQWf6ARPU44zYCIKu21117DJ598gtWrV2P27Nlo1qwZXn/9daxYsQJDhw7F8OHDUa9ePcTHx+P48ePo378/duzYUalzTJo0CfHx8Vi1ahUOHDiA3r17w9PTExkZGTh9+jQOHTqEH3/8EU2bNq3Q/Z07d67cHcDef/992Nra1lg8lREZGYnjx49jyZIl2LFjB4KCgtCwYUNcu3YNycnJ+PvvvxEXF1fmHM2HCQgIgJ2dHb788ktkZWWhQYMGAICwsDBTPowyzZs3D/Hx8VizZg3i4+PRt29fqNVqXLhwAbt27cL+/fvLrX/bo0cPBAYG4o8//kBAQACCgoJw6dIlbN26FQMHDsTmzZv1+j/xxBMIDw9HREQE/P39MXz4cFhZWWHTpk3w9/fHmTNnDM4RHR2NM2fO4L333sOaNWsQEBAAZ2dnXLlyBUePHsXZs2dx/fp12NvbAwCioqIQGBiIMWPGYMuWLVKd2SNHjuDpp582OgJMRI9I3mIKRGSOyqszq/P1119LtUF1/vzzTxEYGCgcHByEs7Oz6Nevnzh27JjR0km60lwRERHlxrJu3TrRu3dv4eLiIqytrUWjRo1Er169xKJFi8TNmzcr/Fge9pOVlSXdxlhprsrGU165KF15LGOlmYyVnhJCiPv374tvvvlGBAYGCkdHR6FWq4W3t7fo06ePWLp0qbhz506F7r+suHbs2CG6du0q7OzspOfkYcorzVXW81fW4ysoKBCff/656NChg7CzsxN169YVbdq0EdOnT9f7vynr9rdu3RJjxowRrq6uws7OTvTo0UP8+uuv5ZYdW758uWjTpo2wsbERXl5eYsaMGSI/P99onVkhhMjPzxeffvqp6Ny5s6hTp46ws7MTPj4+YvDgwWL16tWiuLhYr39ycrLo16+fqFu3rnBwcBB9+/YVycnJ5f7/EFHlKYQw8n0JEREREZEF4JxZIiIiIrJYTGaJiIiIyGIxmSUiIiIii8VkloiIiIgsFpNZIiIiIrJYTGaJiIiIyGIxmSUiIiIii8VkloiIiIgsFpNZIiIiIrJYTGaJiIiIyGIxmSUiIiIii8VkloiIiIgs1v8BHApyEGf2aOwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a boxplot for residuals grouped by rare_element_included column\n", + "plt.figure(figsize=(8, 6))\n", + "sns.boxplot(x='rare_element_included', y='residuals', data=test_df_fiora)\n", + "\n", + "plt.xlabel('Rare Element Included')\n", + "plt.ylabel('Residuals')\n", + "plt.title('Residuals by Rare Element Inclusion (Fiora)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "def count_rare_elements_in_smiles(smiles, element=None):\n", + " rare_elements = fiora.MOL.constants.RARE_ELEMENTS\n", + "\n", + " if element:\n", + " # Count only the specified element\n", + " return int(bool(re.search(rf'\\b{element}\\b', smiles))) # Returns 1 if present, 0 otherwise\n", + " else:\n", + " # Count all rare elements\n", + " return sum(1 for elem in rare_elements if re.search(rf'\\b{elem}\\b', smiles))\n", + "\n", + "# Add a new column 'rare_element_count' to store the count of rare elements in each smile string\n", + "test_df_fiora['rare_element_count'] = test_df_fiora['smiles'].apply(count_rare_elements_in_smiles)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a boxplot for residuals based on the number of rare elements\n", + "plt.figure(figsize=(8, 6))\n", + "sns.boxplot(x='rare_element_count', y='residuals', data=test_df_fiora)\n", + "\n", + "plt.xlabel('Count of Rare Elements')\n", + "plt.ylabel('Residuals')\n", + "plt.title('Residuals by Count of Rare Elements (Fiora)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "from rdkit import Chem\n", + "from rdkit.Chem import Draw" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABa0AAAJLCAYAAADkerq3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wT9RvA8c+lI917Udqy95Y9RDayFUURBQQEZSNLUKYiQ0GGypIhCoqA/pCl7L1lCDKEsmdbuneb5H5/nIkUWpYtCfC8X6+8KEku9+Ryd8k999zzVVRVVRFCCCGEEEIIIYQQQgghbIDO2gEIIYQQQgghhBBCCCGEEGaStBZCCCGEEEIIIYQQQghhMyRpLYQQQgghhBBCCCGEEMJmSNJaCCGEEEIIIYQQQgghhM2QpLUQQgghhBBCCCGEEEIImyFJayGEEEIIIYQQQgghhBA2Q5LWQgghhBBCCCGEEEIIIWyGJK2FEEIIIYQQQgghhBBC2AxJWgshhBBCCCGEEEIIIYSwGZK0FkIIIcRT5+LFiyiKgqIo1g7lPzG/h4sXL1o7lMfi7bffRlEUxowZ80jT16tXD0VR+Pbbb3M1rtyybds2FEWhYMGCufq6BQsWRFEUtm3blquvKx7df1mX/+t2kNussV39/PPPKIrC0KFD/9Pr5NU2l5d+/fVXFEXh/ffft3YoQgghhFVJ0loIIcQzx5wIfNjb22+/be3Qs9i3bx/Tp0/nrbfeomTJkuh0uodKdKSkpDB27FjKlCmDi4sLfn5+NG7cmDVr1jxyTObkhjlJoKrqPZ/fqVMny/Pt7e0feb7i6RYXF8eYMWOsmsQzr6f3S9yZk2TP0smGB2X+DOPi4h75NcwJ+ttv9vb2+Pr6Urt2bT7//HOSk5NzL2jx2BmNRkaOHImTkxMDBw686/EH+b5+kpLUd2rdujWlS5dm1qxZXL161drhCCGEEFYjR4dCCCGeOYGBgdneHxUVhclkwtXVFTc3t7se9/T0zOvQHsqLL75IfHz8I00bExND3bp1OXHiBABubm7Ex8ezadMmNm3axIgRI/jkk0/+U3yXLl1i586d1K1bN9vHk5OT+eWXX/7TPMTTJV++fJQoUQI/P78s98fFxTF27FgAm6k+fRQuLi6UKFGC/PnzWzsUqzB/hm+//TZeXl7/6bVu309nZGQQExPDnj172LNnD/PmzWPHjh057usfh5zWZXF/33//PadOnaJnz54EBQXl+DwPDw+cnZ2zfczf3x94Mrc5RVEYNmwYnTp1YuzYsXzzzTfWDkkIIYSwCqm0FkII8cy5efNmtrfQ0FAABg8enO3j06dPt3LkWTk7O1OtWjV69erFwoULqVy58gNP26VLF06cOEFgYCBbt24lMTGRhIQERo8eDcC4ceNYvXr1I8cWFhYGwOLFi3N8zv/+9z+Sk5MtzxViwoQJnD59mj59+lg7lDxRrVo1Tp8+zebNm60dyhPv9v10TEwMcXFxTJw4EZ1Ox5kzZ6y+Dj3t63JemjZtGgDdunW75/OmT5+e4/f5wYMHgSd3m2vXrh3u7u58//33xMbGWjscIYQQwiokaS2EEEI8oa5evcr+/fv5+uuvH6py8eDBg6xatQrQKtrq1asHaEnwMWPG8MYbbwAwYsSIR47t1VdfxdHRkRUrVpCenp7tc77//nsA3nzzzUeejxBCgHYlzAcffMC7774LwMqVK0lMTLRyVOJhHTp0iD///JMiRYo81InYp42TkxOtW7cmPT2dH374wdrhCCGEEFYhSWshhBDiAV2/fp3+/ftTrFgxnJ2d8fb2pk6dOnzzzTcYjcZsp7l9gLRLly7RtWtX8ufPj5OTE8WLF2fMmDGkpaU9Ujx2dnaPNN3SpUsBKFOmDI0bN77rcfPgT8eOHbO0D3lY3t7etGjRgtjYWNauXXvX4zdv3mTz5s3ky5ePhg0b3vf1NmzYQOvWrQkICMDR0ZH8+fPzxhtvcOjQoUeKD+D8+fP06tWLokWL4uzsjKenJzVq1GDGjBlkZGTkOJ3JZOL777/nxRdfJCAgAL1eT1hYGI0aNWLOnDlZ+uk+yCBgY8aMeeSe6REREQwdOpQyZcpY2iVUrFiRTz75JMeEXUJCAmPGjKFixYq4ubmh1+sJCQmhZs2ajBw58oH7MF+4cAFFUXB1dSUzMzPLY0ajEXd3dxRFoWbNmndNe+LECRRFwdPTM8u2k90AdG+//TaFChWy/P/O3rU5tQtJTk5mxIgRFCtWDCcnJ/Lly0eXLl24du3aA72/vHC/9SEjI4NPP/2UkiVL4uTkRHBwMJ07d+bixYsPPKDcrVu36NevHwUKFECv11OgQAEGDBhw3z7S27Zto127duTPnx9HR0f8/Pxo1qzZPa+4OHz4MG+++aZlXh4eHhQtWpQ2bdowZ84cTCYT8O86blaoUKE8Gy/AvD8xGAycPXs22+c8yrYfERHBoEGDKF26NC4uLjg7OxMWFsYLL7zAhAkTuHXrVpbn328wxQsXLvDWW28REBCAi4sLZcqU4fPPP8/xuwTg22+/RVEUy4nG7Nxrvtu3b6dv375UrVqVoKAg9Ho9wcHBvPrqq+zatSvH17yXc+fO0aNHD4oWLYqTkxOurq4UKlSIpk2bMm3aNFJSUh7q9RYtWgRoJz5zw4NsNz/99BONGzfG19cXvV5PwYIFeeeddwgPD8/2+Xd+DosWLaJ27dp4eXmhKApHjx4FIDExkYULF/Lqq69SunRp3N3dcXV1pUyZMgwdOpSoqKh7xm5eBuZlIoQQQjxzVCGEEEKoqqqqBQoUUAF19OjRdz22Z88e1cvLSwVUQPXw8FAdHR0t/2/cuLGanJyc42vOnTtX9fX1VQHV3d1d1ev1lmmrVaumJiYm/uf4GzZsmGP8t3vuuedUQO3fv3+2j5tMJst7/fLLLx8qhhdeeEEF1E8++UT9+eefVUB9+eWX73relClTVEB9//331a1bt6qAamdnl+1rDh061LKsdDqd6uXlpSqKYvn/7Nmz75rmwoULlmmy89NPP2X5DFxdXVV7e3vL/2vVqqUmJCTcNV1MTIxat27dLPH4+Phkea2tW7danm9+bwUKFMhxmY0ePVoF1M6dO9/1mPk1L1y4cNdj27Zty7JOOjk5ZVknS5YsqV67di3LNLGxsWrJkiUtz7Gzs1O9vb0tyxNQZ82alWOsdwoJCVEBdc+ePVnuP3DggOX1HBwc7to2Zs6cqQLqiy++mOX+zp0737UO9+vXT/Xz87O8XmBgYJbb559/bnmuef2bPn26Wr58eRVQnZ2dVScnJ8v0YWFh6q1btx74PZqZp1+4cOE9n2f+zLP73O61PqSkpGRZtxwdHVUPDw8VUH19fdW5c+fmOK15P/Pdd9+poaGhKqC6ubmpDg4Oltd77rnn1PT09LumNZlM6sCBAy3PM+/fbv9/375975pu9erVWbYZFxcX1dXVNct0qampqqqq6ueff64GBgZa7vfz88vyGfbr1++eyzS795rTfm7ZsmWW+Rw4cOCuxx9l279w4YIaFBSUZZ2+fdsD1N9++y3LNNmty2aHDh3Ksow9PDwsn1WbNm3UTp06ZTvtwoULVUB94YUXclw+Oc03MTHxrs/49s9LUZRs96Wq+u92dee6f/DgQdXNzc3yGnq9/q5159SpUznGmh3z/mnVqlU5PudBt0VVvfc2ZzAY1A4dOlhez97e/q59anZx3P459OzZ07IvNX83HTlyRFVVVf3yyy+zvLaPj49qZ2dnuS8kJEQ9d+5cjrFHRkZaPpvY2Nj7vlchhBDiaSOV1kIIIcR9xMTE8PLLLxMXF0eVKlX4888/iY+PJzExkQULFuDk5MTGjRsZMmRIjq8xZMgQ/Pz82Lt3LwkJCSQlJbFkyRLc3Nw4cOAAgwYNeizvRVVVTp8+DUDp0qWzfY6iKJQoUQKAU6dOPfK8WrRogbe3N+vWrburytPcGuStt96652v88MMPfPbZZ4C2DKOjo4mNjeXatWu88cYbmEwmevXqxb59+x44rv3791takowdO5YbN26QlJRESkoKGzdupESJEuzZs4cBAwZkmU5VVdq3b8+OHTvw8PBg7ty5xMXFER0dTUpKCocPH2bAgAE5DgyWmy5cuEDr1q2Jj49nwIABXLhwgZSUFFJSUti/fz/Vq1fn9OnTdOzYMct006dP5/Tp0xQtWpQdO3ZYBrBLTU3l+PHjjBgx4p4Dn93p+eefB2DHjh1Z7jf/393dnczMTPbu3Zvt4zkN0nlnzOb+tHB3T/rBgwffNc3o0aNJTk5m8+bNJCcnk5iYyNq1a/H29uby5ctMmDDhgd/j4zJ69Gh27NiBXq9nwYIFJCUlER8fz6FDhwgODmbo0KH3fY1+/foREBDAwYMHSUxMJCkpie+++w4nJycOHz7M3Llz75pm6tSpfPHFF4SEhPDdd9+RkJBg2b/NnTsXDw8PvvzyS8s2a9a3b18MBgNdu3bl8uXLJCcnk5SURHR0NL/99htvvPEGOp12qGHuP2128ODBPBsv4PbexbdX6MOjb/tjx47l5s2bVK9encOHD5ORkUFsbCzJyckcPHiQAQMGPPBAvWlpabz++uskJCRQtmxZDh06ZFneM2fOZN26dfz666//bSFkQ6fT8dprr7FmzRri4uKIj48nKSmJa9euMXToUFRVpV+/fpw/f/6BX3PIkCEkJSXRsmVL/v77b9LS0oiPjyc+Pp4dO3bQvXt3nJycHvj1YmJi+PvvvwEeS2uQSZMm8cMPP2BnZ8fkyZOJj48nNjaW8PBwGjVqRFpaGm+88QYXLlzIdvpDhw4xZ84cxo8fT0xMDLGxsURERFC4cGFAGwxy5MiRHD58mNTUVKKjo0lLS2PPnj3UqlWLq1ev0qNHjxzj8/f3JywsDFVV2bNnT54sAyGEEMKmWTdnLoQQQtiOnCr4xowZowJqQECAGh0dfdd0X3/9taXS6vLly9m+prOzs3r+/Pm7pv3hhx8sFbtXrlz5T/E/SKV1XFycpcrrXpVsL730kgqobdu2fagYbq+0VlVVfffdd1VAnTNnjuU5f/31lwqopUuXVlVVzbHS2mQyqYULF1YB9Z133rlrXkajUa1evboKqE2aNMny2L0qrWvVqqUC6vfff5/tezh//rzq6uqq2tnZZalU/vXXXy1x7tq164GWR15VWpurA83L+U4xMTFqcHCwCqj79++33N+sWTMVUJcuXfpA8d/PrFmzVEBt3rx5lvtbt26tAuqwYcNUQB01alSWx/Pnz68Cdy3HnKpE71c5b2Ze/+zt7dWTJ0/e9fjUqVPv+3nkxDx/Dw+Pu6q9b795e3s/dKV1XFyc6uzsrALq119/fde8r169aqlovVeltaenpxoVFXXX4/3798+2Qjc2NlZ1dXVVXV1dc6yI/emnn1RALVWqlOW+iIgIS5WywWDIfoFlI6fl8jBy2k/HxcWpkyZNUnU6nQp3V/Gr6qNv+6VKlVIBdd++fQ8cZ07r8vz58y3LLrt9/meffWZZTrlZaX0/3bt3VwF1xIgRdz2WU6W1eZ29efPmQ80rJ+vXr7dcWXAvD7It/vXXX6qq5rzNJSYmqu7u7iqgjhs37q55pKSkqGFhYSqg9ujRI8tj5s8hp+X1IGJjY9WAgAAVUMPDw3N8XqtWrR7p8xRCCCGeBlJpLYQQQtzHzz//DECvXr3w8fG56/Fu3boRGBiI0Whk5cqV2b7G66+/flfVH8Abb7xBwYIFMZlM/O9//8vVuLNze7/le1UEu7i4AJCUlPSf5meupF68eLHlvgetsj5y5Iil6u+jjz6663GdTsfw4cMB2LhxI/Hx8feNJzw8nD179hAUFJTjAJCFChWiRo0aGI1Gtm/fbrnf/B7atm1L7dq17zuvvJKSksLy5ctxcHCgX79+2T7H29ubZs2aAVkrTz08PAC4ceNGrsRirrTetWuXpX+xqqrs2rULb29vevfuDZBlOZ47d45r167h5ORE1apVcyWOO73yyiuUKlXqrvtbtWoFwKVLl7JsCw8jISGBiIiIHG+xsbEP/ZobNmwgNTUVT09P3nnnnbsez58/P+3bt7/v67z33nv4+fnddb/5fd/Zo37FihUkJyfTokULSpYsme1rtm3bFr1ez6lTpyzrjZubG4qikJmZSXR09H3jyguTJ08mKCiIoKAgfHx88PLy4oMPPsBkMhEWFsasWbOyPP+/bPu5ud388ssvAHTo0IGQkJC7Hu/duzeurq7/eT4Pq3nz5gAPddVKbu9PzNX42a3D2bnXtnhnn/07bdiwgcTERFxdXe+qrAft+3HgwIGAtp1kx87Ojv79+z9QrHfy8vKy9Pu/1zI3L4vcWsZCCCHEk0SS1kIIIcQ9ZGRkWBI99evXz/Y5er2eWrVqAVqiNTsvvPBCjvMwt0jIadonWe3atSlUqBC7du3i0qVLmEwmlixZgqIoOSaOzA4fPgxoiaScBtEyfyaqqvLnn3/eNx5zm4qYmBjy5ctnSXrdedu9ezcAV65csUy7f/9+AEsy2FoOHTpEZmYmJpOJ4sWL5/gezANu3v4eXnzxRQA++OADevfuzdatW0lNTX3kWEqXLo2fnx8JCQmWwcf++usvYmJiqFOnDiEhIRQpUoT9+/dbBrgztwapXr06jo6Ojzzveylfvny29+fPn9/y9/0GJszJwoULUVU1x9vWrVsf+jXN627VqlVzXCZ16tS57+vc733f+Z7N28O6detyXI9CQkIsCUDzuuTi4kLdunXJyMigZs2aTJ06ldOnT6Oq6v3fbC5JTk7O9kRBgwYNOH78+F37jP+y7Zu3m06dOjFs2DD27dt336RoTszbSU6tcVxcXPKsNUZGRgYzZ86kQYMGBAQE4ODgYBkM8+WXXwYeLjlqXi5NmzZl3LhxHD161HLy6lGYB7P09vZ+oOffa1usWLHiPac1f79Uq1Ytx5ME5u+XmJgYLl++fNfjRYsWvW+C/cKFCwwYMIDy5cvj7u6OTqezLHNzG5h7LXPzsrhzoE8hhBDiWSBJayGEEOIeYmJiLAfhtye87lSgQAEAoqKisn08ODg4x2nNj+U0bW66/eD8XsnKlJQUQKuo/C/MyWlVVVmyZAnbtm3j6tWrPP/884SFhd1zWvNB+r2Wu4eHB15eXsCDLT9zciAjI+Oe1bJpaWnAv8sBIDIyEuC+cec183swGo33fA/mSuLb30Pnzp3p1q1bluSVh4cHtWvXtvR0fRiKoliSqeZk9J39quvWrUtaWhoHDhzI9vG8kNP2dnt/3UdNOuYF87qeL1++HJ/zIL3G7/e+DQZDlvvN61JSUtI91yXzPvD2dWnevHmUKFGC8+fPM3DgQEqVKoWfn5+lb3JeGz16tCVBGRcXx9q1aylZsiRbtmxh/Pjxdz3/v2z7w4YNo0WLFiQmJjJp0iRq1qyJh4cHDRs2ZM6cOZZpHoT5s36Q74TclJCQQJ06dSwnq6KiotDr9QQEBBAYGGhJjj7MFQiTJ0+mevXqREZGMnLkSCpVqoSXlxetWrXihx9+wGg0PlSM6enpgHYiOK89yPeL+Xsdsv9+8ff3v+c8Nm/eTNmyZZk+fTrHjx8nJSUFLy8vAgMDCQwMtGyX91rm5uc8zDomhBBCPC0kaS2EEEI8IPMB9ZPMw8PDkri+V3WX+TLteyXRHpR5MMAlS5ZYWoPcOUDgveTmcjcn32rXrn3PalnzbcyYMbk279xy+0mUB3kP3377rWVaRVGYN28ef/75JyNGjOD555/Hzs6OPXv2MGTIEEqUKMFff/31UPGYk893Jq3NVxfk9Li5tYiwHvO69NFHHz3QulSvXj3LtEWLFuX48eP8/PPPdOvWjeLFixMTE8Py5ctp1aoVrVq1+k9Vtw/D09OT5s2bs2HDBjw9PZk0aRKrV6/O9r0+yrbv5OTEmjVr2L17N4MGDaJq1aoYDAa2bNnCe++9R7ly5bh+/fpjea+P6pNPPuHgwYN4enqyZMkSoqOjLScrbt68yfLlywEeqlrePLjw77//Tu/evSlfvjxJSUmsWbOGN998k5o1az5UEtzcfutRr4J4FP/l+8XOzi7HxzIyMujUqRMpKSnUq1ePvXv3kpaWRkxMjGUA0ldffRW49zI3X0Xg6+v7yHEKIYQQTypJWgshhBD34OPjg06nfV1md3mw2aVLl4CcK6/uldAwP3a/qq3coCgKJUqUAODUqVPZPkdVVf7++2+AbPsCP6zixYtTtWpVTp48yZIlS9Dr9bRr1+6+05mXx72We2JioiXB8SDLLzAw8L6veb9pzZ/1g7C3twfuXSX3sNXN5jgiIyMfOeFSvnx5PvnkE3bs2EFsbCzLli2jYMGCRERE0L1794d6LXPyeefOnaiqys6dO3Fzc+O5554D/k1ab9++nWvXrnH+/Hns7e0tLXXEg/WtNZ9Iyk3/ZXsAcHBwoG3btsybN4+///6by5cvM3LkSHQ6HWvWrOGbb77JzXDvKzQ0lA8++ACAgQMHZqks/6/vFaBWrVpMnjyZAwcOcOvWLebPn4+vry/h4eEMGjTogV7jQT7rnL4v/sv+xNyXedq0aXTo0OGu8RnMV5I8LEVRaNq0KV999RV//vknERERfPHFFzg7O3Pw4EHGjRv3wK9lXjaP0hf+YT3I98vt+/qH/X7eu3cv169fx9XVldWrV1OjRg0cHByyPOdBlrl5WTxon28hhBDiaSJJayGEEOIeHB0dKVOmDADbtm3L9jnp6ens2bMHgEqVKmX7HHN1aXZ27tx5z2lzm7lactOmTdk+fujQIcuBck59vB+WubI6MzOTli1b4unped9pzMsjIiIixwT7li1bAC1xUqFChfu+Zo0aNQCtX+2dg9I96LS///77A09ze+uSnNpR/PHHHw8VR5UqVbC3tyczMzPHz/BhODs7065dO+bNmwfAgQMHHqrPdaVKlXB3d+fWrVusWrWKGzduULt2bUsVYuHChQkJCWHPnj2Wfs/PPffcQw02Zz5xBA9XCfqkMK+7f/zxh6X3953MvZZzk3md3rRp012tQx5FaGgoH3/8MR06dACyDsAJ2nYKefsZ9unTB09PT8LDw1m0aJHl/v+y7WfH09OTrl27MmnSJODu95oT834tp++E1NRUDh06lO1j5v3JtWvXsn1cVVVLr+Y7maepUqVKto8/Si/27Pj7+/P+++9bkvgPulwAywnVGzdu5PmVTebP4fjx48TExGT7HPMy8fX1fei2UOblXbJkyWzbbKWmplrGSbiXixcvAv8uGyGEEOJZIklrIYQQ4j7Ml/DOmTMn28uW58+fT0REBHZ2dpbBrO70008/ZVuhu2zZMi5cuHDPaXNb+/btAW3AvM2bN9/1+LRp0wCtGrd06dK5Ms833niDQYMGMWjQIIYMGfJA01SqVIkiRYoAWBJDtzOZTEyYMAGAxo0bP1AivFSpUlSvXh2AwYMH37Pn6p3VfubE+y+//GI5SXE/xYsXR6/XYzKZsu3zu2fPHnbt2vVAr2Xm7u5O27ZtAfjwww+z9N69U2pqapbkT04JUdCS16At14fp92xnZ2epmv7000+Bu/tVP//88yQlJTFjxoxsH78fDw8Py9+Ps3XA49KkSROcnJyIi4tjwYIFdz1+48YNy8Caualdu3a4urpy48aNbLex292+PWRmZt4z8Wxel+6sCDZ/jnn5Gbq7u1uuFpg0aZKlLch/2fYfZLt50J7D5v38Dz/8kG1F9axZs3JsqVGuXDkArl69mu3AvUuXLs2xcti87M1X0dzuzJkzLF68+IHiNzOZTPc80fGwywWgTJkyeHl5kZmZybFjxx4qnofVpEkT3N3dSUlJseyXbpeamsoXX3wBwCuvvPLQr29e3hcvXsw2AT9lypT7XmVjMBgsA3fWrl37oWMQQgghnnSStBZCCCHuo0+fPgQGBhIXF8eLL77I8ePHAS1xs3DhQktF2bvvvktISEi2r+Hg4MCLL75oGYzOYDCwdOlS3nnnHQC6deuW47Q5SUpK4tatW5abOdGYkpKS7f1mVatWpU2bNoCWiDVXwqWlpfHxxx+zZMkSgIe6rPt+/Pz8mDx5smXgrgehKAoff/wxAIsWLeLDDz+0HOTfvHmTjh07sn//fnQ6HWPHjn3gWGbMmIGjoyO///675TMxJ+AyMzM5dOgQw4YNo3Dhwlmma968OU2aNMFoNNK8eXPmzZtHUlISoCVwDh06RI8ePbJUzzk6OtKqVSsABgwYwN69e1FVFYPBwP/+9z/atGljGQDtYUycOBFvb2+OHTtG3bp12bJliyUJZzKZOHHiBOPGjaNIkSJZ2hA0atSIAQMGsGvXrizJpMOHD9OnTx9Aq0i9PUn8IMwtQg4ePAj828/azJykNj/+sP2svby8LIPTLVy48KGmfRJ4enrSu3dvAN5//30WLVpk2W6PHj1Ks2bN7tk/91H5+flZtvMRI0bQr18/Lly4YHk8KSmJjRs30rFjxywtfU6cOEG5cuX48ssvCQ8Pt9yflpbGwoUL+e677wBo2rRplvmZr1r57rvvHnqQvofRv39/HBwcOHv2LMuWLbPc/6jbfrly5RgxYgSHDh2yJGpNJhPbt2/nww8/zPa95qRDhw4UKVKEpKQkmjVrZklKZmRkMGfOHIYNG5bjCbgCBQpYKqW7dOnCyZMnAW25z58/n3feeSfH/UnDhg0BLWFv3g+ZTCZ+//13GjdubEkyP6iEhASKFSvGhAkTOHHihOXkgMFgYNWqVUyePBl48OUC2j7ffAIsp2rz3OLm5sawYcMA7btu2rRplitMzp07R+vWrbl8+TKurq6W5z2MWrVq4eTkRHR0NF27drUM5BgfH8/HH3/MqFGj7mrRcqfjx4+TlpaGt7e3ZdsRQgghnimqEEIIIVRVVdUCBQqogDp69Oi7HtuzZ4/q6empAiqgenp6qo6Ojpb/N2rUSE1OTs7xNefOnav6+vqqgOru7q46OTlZpq1WrZqamJj40PF27tzZ8hr3um3duvWuaaOjo9UyZcpYnuPm5qba29tb/j9ixIiHjkdVVfWFF15QAfWTTz554Gm2bt2qAqqdnV22jw8dOtQSl52dnert7a0qiqICqk6nU2fNmnXXNBcuXLBMk53Vq1er7u7uluc4OTmpPj4+qp2dXZZld6fo6Gi1Tp06lsd1Op3q4+Oj6vX6HJf32bNnVR8fH8vjLi4uluc3adJE/eijj1RA7dy5813zM09z4cKFux7bu3evGhgYaHmOo6Oj6uvrqzo4OGR5DxcvXrRMU6FChbtiv3099vPzU48dO5btMruXHTt2WF7D2dlZTU9Pz/L4iRMnLI8riqLGxMRk+zrmdTq7bXDUqFGW13B1dVULFCigFihQQJ06darlOeb1b+HChTnGeq9lei/m6e712qr67/qc3TzMjxUoUOCu6ZKTk9XatWtbptXr9aqHh4cKqP7+/urcuXNVQC1evPhd05r3M9lt66p6/+1h1KhRlm3KvI/y8vLKcl+9evUszz9y5EiWdcy8/dz+/BYtWqgGgyHLfBYsWJBlmrCwMLVAgQLqoEGD7rlMs3uv2a0jt3vrrbdUQC1XrpxqMpks9z/Ktn/7vt/e3l719fXNsr8sXLiwevXq1SzT3GtdPnTokOWzBVQPDw/LdtimTRu1U6dOOU67e/fuLN8f7u7ulm2+S5cuOc739OnTWd6Hi4uL5XWCg4PVRYsW5bhuZrddxcbGZlleDg4Oqo+Pj6rT6Sz3ValSRU1ISLjn53SnhQsXqoDaqlWrHJ/zoNuiqt57mzMYDOobb7yR5bP18vLKsg2uWrUqxxhfeOGFe8574sSJWZaRl5eXZfm89dZb91xHVFVVP/30UxVQ33nnnfu+TyGEEOJpJJXWQgghxAOoWbMmJ06coG/fvhQpUoS0tDScnJyoVasWc+bM4ffff8fFxSXH6YsVK8ahQ4d4++23cXNzw2QyUbRoUUaNGsX27duz7XmZl3x8fDhw4ABjxoyhdOnSGI1GPDw8aNSoEatXr+aTTz55rPHcy6RJk1i/fj0tW7bE29ubpKQkgoKCeP3119m/fz/vvffeQ79my5YtOXPmDMOGDaNChQo4ODiQkJCAj48PdevWZfTo0Zw+ffqu6Xx8fNi2bRvz58+nfv36eHl5kZSURGBgII0bN+abb76hWrVqWaYpWrQoe/fu5bXXXsPX1xej0UjhwoWZNGkSa9eutQyu9rBq1KjB33//zaeffkr16tVxdnYmLi4Od3d3atSowdChQ/njjz8oUKCAZZp58+YxZswY6tWrR2hoKMnJydjb21O2bFmGDh1qqaB9WNWqVcPJyQmA6tWr4+jomOXx0qVLWwYyK1u27CNVl48aNYpJkyZRvnx5VFXl0qVLXLp06alpF+Li4sLmzZv5+OOPKVasGACurq68/fbb/PHHHwQEBAD/9jXOTWPHjuXw4cN07dqVwoULYzAYSElJISQkhJYtW/Lll1+yfPlyy/NLlSrFihUr6NGjBxUrVsTd3d2y/TRs2JBvv/2WVatW3VUd3qVLF8s2Ym9vz5UrV7h06RK3bt3K9fc0ePBgQKtWXb16teX+R9n2V65cybBhw6hVqxZBQUEkJCTg7OxM5cqV+eSTTzh69Cj58+d/4Niee+45jhw5QocOHfD39ycjI4OiRYsyadIkfv75Z0vv7+zUqlWLHTt20KxZMzw9PTEajZQtW5a5c+dm21rGrESJEuzfv5927drh4+ODwWAgX7589OnThyNHjjx0z2YPDw/WrFlD//79qVq1Kr6+viQkJODh4UGtWrWYPn06u3fvxt3d/aFet127dri5ubF+/fo837bt7Oz44YcfWLp0KQ0bNsTNzY2UlBTCwsLo2rUrx48ft1wp8yg++OADFi9eTJUqVSxtoqpUqcKcOXMsVyPcy08//QTA22+//cgxCCGEEE8yRVWfwtFshBBCCBtRsGBBLl26xNatWy0DIAohxMMaPXo0H3/8MZ06dcoywKAQT5sePXrwzTffMH/+fLp27WrtcKzi9OnTlCpVipIlS+Y4ELEQQgjxtJNKayGEEEIIIWxYfHw88+fPB7S+5EI8zYYPH46DgwPTpk2754CfTzPzIJCjR4+2ciRCCCGE9UjSWgghhBBCCCvLyMigffv2bNmyJcsAn7t27aJRo0Zcu3aN0NBQXnnlFStHKkTeKlSoEO+8885drV2eFdevX2fRokVUqFCB119/3drhCCGEEFbzaE0UhRBCCCGEELnGZDLx008/WfrYenl5kZqaSnp6OqD1EP7hhx/u2TtfiKfFqFGjCAgIICMjw9qhPHZXrlxh+PDhNG/e/J79zYUQQoinnfS0FkIIIfKQ9LQWQjwIk8nErFmz+O233zh58iQRERGoqkpoaChNmjRh8ODBWQbVFEIIIYQQ4mkmSWshhBBCCCGEEEIIIYQQNkN6WgshhBBCCCGEEEIIIYSwGZK0FkIIIYQQQgghhBBCCGEzJGkthBBCCCGEEEIIIYQQwmZI0loIIYQQQgghhBBCCCGEzZCktRBCCCGEEEIIIYQQQgibIUlrIYQQQgghhBBCCCGEEDZDktZCCCGEEEIIIYQQQgghbIYkrYUQQgghhBBCCCGEEELYDElaCyGEEEIIIYQQQgghhLAZkrQWQgghhBBCCCGEEEIIYTMkaS2EEEIIIYQQQgghhBDCZkjSWgghhBBCCCGEEEIIIYTNkKS1EEIIIYQQQgghhBBCCJshSWshhBBCCCGEEEIIIYQQNkOS1kIIIYQQQgghhBBCCCFshiSthRBCCCGEEEIIIYQQQtgMSVoLIYQQQgghhBBCCCGEsBmStBZCCCGEEEIIIYQQQghhMyRpLYQQQgghhBBCCCGEEMJmSNJaCCGEEEIIIYQQQgghhM2QpLUQQgghhBBCCCGEEEIImyFJayGEEEIIIYQQQgghhBA2Q5LWQgghhBBCCCGEEEIIIWyGJK2FEEIIIYQQQgghhBBC2AxJWgshhBBCCCGEEEIIIYSwGZK0FkIIIYQQQgghhBBCCGEzJGkthBBCCCGEEEIIIYQQwmZI0loIIYQQQgghhBBCCCGEzZCktRBCCCGEEEIIIYQQQgibIUlrIYQQQgghhBBCCCGEEDZDktZCCCGEEEIIIYQQQgghbIYkrYUQQgghhBBCCCGEEELYDElaCyGEEEIIIYQQQgghhLAZkrQWQgghhBBCCCGEEEIIYTMkaS2EEEIIIYQQQgghhBDCZkjSWgghhBBCCCGEEEIIIYTNkKS1EEIIIYQQQgghhBBCCJshSWshhBBCCCGEEEIIIYQQNkOS1kIIIYQQQgghhBBCCCFshiSthRBCCCGEEEIIIYQQQtgMSVoLIYQQQgghhBBCCCGEsBmStBZCCCGEEEIIIYQQQghhMyRpLYQQQgghhBBCCCGEEMJmSNJaCCGEEEIIIYQQQgghhM2QpLUQQgghhBBCCCGEEEIImyFJayGEEEIIIYQQQgghhBA2Q5LWQgghhBBCCCGEEEIIIWyGJK2FEEIIIYQQQgghhBBC2AxJWgshhBBCCCGEEEIIIYSwGZK0FkIIIYQQQgghhBBCCGEzJGkthBBCCCGEEEIIIYQQwmZI0loIIYQQQgghhBBCCCGEzZCktRBCCCGEEEIIIYQQQgibIUlrIYQQQgghhBBCCCGEEDZDktZCCCGEEEIIIYQQQgghbIYkrYUQQgghhBBCCCGEEELYDElaCyGEEEIIIYQQQgghhLAZkrQWQgghhBBCCCGEEEIIYTMkaS2EEEIIIYQQQgghhBDCZkjSWgghhBBCCCGEEEIIIYTNkKS1EEIIIYQQQgghhBBCCJshSWshhBBCCCGEEEIIIYQQNkOS1kIIIYQQQgghhBBCCCFshiSthRBCCCGEEEIIIYQQQtgMSVoLIYQQQgghhBBCCCGEsBmStBZCCCGEEEIIIYQQQghhMyRpLYQQQgghhBBCCCGEEMJmSNJaCCGEEEIIIYQQQgghhM2QpLUQQgghhBBCCCGEEEIImyFJayGEEEIIIYQQQgghhBA2Q5LWQgghhBBCCCGEEEIIIWyGJK2FEEIIIYQQQgghhBBC2AxJWgshhBBCCCGEEEIIIYSwGZK0FkIIIYQQQgghhBBCCGEzJGkthBBCCCGEEEIIIYQQwmZI0loIIYQQQgghhBBCCCGEzZCktRBCCCGEEEIIIYQQQgibIUlrIYQQQgghhBBCCCGEEDbD3toBCCGEEEIIIYQQQtiSP//8k0WLFhEVFUXlypV55513cHNzs3ZYQgjxzFBUVVWtHYQQQgghhBBCCCGENamqSkpKCitWrGDGjBmcOHGCzMxM3NzcLInrli1b4u7uDoCiKFaOWAghnl6StBZCCCGEEEIIIcQzy2g0kpyczOHDhxk/fjw7d+7Ez8+P6tWrU69ePXbs2MH27dtJSkoiJCSEbt260bFjRzw9PXF2dpbktRBC5AFJWgshhBBCCCGEEOKZYzKZiImJ4dChQyxYsIDVq1cTEhLCCy+8wLvvvkulSpWws7PDaDRy6tQpFi1axJYtWwgPD8fDw4MOHTrQunVrihcvjq+vLzqdDBsmhBC5RZLWQgghhBBCCCGEeKYkJyezfft2/ve//7Fu3TpcXFxo0qQJ7dq1o2bNmuj1+rumMRgMnDlzhg0bNrB161b++OMP7O3tadSoEfXr16d27doULFhQKq+FsDUZGXDpEly9CqoK+fND4cLg4GDtyMQ9SNJaCCGEEEIIIYQQz4TMzEz27t3LggUL2LlzJ0lJSbzyyiu0bduW6tWr4+bmdt+ks6qqXL16lSNHjrBhwwZWrlxJRkYG5cuXp379+rz88suUKFECOzu7x/SuhBA5SkiA776D9evB3V1LWsfHQ6NG0KULeHtbO0KRA0laCyGEEEIIIYQQ4qmlqiqqqnLu3DmmTZvGunXruH79Ok2bNuX999+nYsWKeHp6PnR7D5PJREJCApcuXeLXX39l1qxZJCYmEhISQuPGjenduzfFixdHURSpvhbCGoxGWLkSPv8c+veHmjW1+//8EyZMgPfeg7feAnt7q4Z5P+Z9mHk/8qzsTyRpLcRjYN7BmEymLDej0UhmZiYODg64uLjImXghhBBCCCGEyCWqqpKZmUlMTAwLFy7k66+/Jj4+nvLlyzNq1Cjq1auHg4PDf+5FraoqRqORmJgYfvjhBxYsWMDFixcBaN26Nb169aJcuXK4uLig0+memYSTEFaXkgLt20Px4jBxIphzLunp8OWXcOAATJumtQuxYRkZGbRo0YKaNWsyfPhwnJ2drR3SY2HbpxKEeAKYE8/p6elkZGRY/k5PTyczM5O0tDTS09OJi4vj1q1bREdHExUVRXR0NDdu3ODQoUNUq1aNDz/8kGrVqskPGCGEEEIIIYT4j9LT07l8+TLr1q1j+vTpxMTEUK5cOTp06ECHDh3w9PTMtXkpioK9vT0BAQEMGDCAjh07smbNGpYsWcL27dtZtWoVdevWpXPnzlSqVImwsDAcHR1zbf5CiBwYDHDmDLRunbWa2skJihaF1ashLs7mk9YbN27k4MGD+Pn5Zdtv/2klSWshcqCqKvHx8dy4cQOAtLQ0kpKSSE5OJiUl5a6/Y2NjiY+PJykpibi4OGJjY0lMTLTcr9PpcHFxwdXVFVdXV9zc3HB2dsbHx4e1a9fi6elJ4cKF8ff3t/I7F0IIIYQQQognk8lkIjw8nN9//51ly5bx119/UblyZfr370+rVq0oVKhQnhcK+fr60rlzZ9q2bcvWrVtZu3Yte/bsoXv37lSoUIFWrVpRq1YtKlSogKura57GIsQzLy0NXFzuvt984shgeLzxPKS0tDSWLl2K0Wike/fu//nKkCeJJK2FyIaqqvz99998/PHHXL58GUVRSEtLIyUlhdTUVFJSUix/K4qCm5sbHh4e+Pn54enpiY+PD4ULF8bd3R1PT0/8/f3x9PTExcUFZ2dnXFxccHFxwcnJiVu3bjFnzhzWr19P/fr16dChwzN15kwIIYQQQgghckNkZCQ//fQTP//8M3/99RfFihXj008/pVGjRhQrVuyxJ3vc3d1p1aoV9evX56+//mLbtm38+uuvjBgxguLFi1O+fHnatWtH06ZNcXJyeqyxCfFMUBTw9ITY2Kz3qyokJ2vtQmw8/3Ls2DEOHjxIpUqVqFWrlrXDeawkaS1EDsaMGcPy5cvx9PSkbNmyFC1alMDAQPz9/fHz8yMgIAA/Pz/c3Nywt7fHwcEBR0dH7O3tcXR0tPxtb2+PXq/PtneZude1q6srZ8+eZfLkydSsWZMSJUpImxAhhBBCCCGEuAfzEF3JycmsWbOGr776ipMnT+Lm5sbQoUN5+eWXLa04rHV8pSgK7u7u1KhRgwoVKtC+fXv++OMP5s6dy48//si+ffsoUaIEJUuWtEp8QjzV7O2hQgVt4MXk5H8rrpOS4PBhKFIE/PysG+M9mEwmNm7cyJUrVxg5cuQzV+AoAzEKkY1bt25Rrlw5PDw8+Pbbb6lYsSKKolgSz7f/DY82cqvBYODo0aMEBgYSHBzM999/z9ChQ3nhhRdYtGgRLtldviKEEEIIIYQQAtDGF9q4cSO9e/cmIiICJycnunfvTr9+/fDz88Pe3t7mioFUVcVkMpGQkMDUqVOZNGkSy5Yto1WrVs/UZf9CPBYmE+zeDX37agMyduwIDg6weLF2GzMGWrXSKrJt0Llz5+jduzcXLlxg9+7d+Pr62tw+LS/JHlGIO5hMJubOnUtiYiIdO3akRo0a6PV69Ho9jo6OODg4YG9vnyWB/Sj+/PNPXnvtNfr06UNCQgIvv/wybdq0YdWqVXzzzTcYbLyvkhBCCCGEEEJYU3x8PMOGDSMqKooWLVqwZcsWPv30U/Lly4eDg4NNJncURcHOzg5vb29eeOEFChQowLZt2+T4T4i8oNNB9eowYQLs3KkNyNi0KaxfD6NGQfPmNpuwNplMHD16lMOHD/PWW2/h7u5uk/u0vCRJayHucPnyZX7++WcCAgLo1KkT8fHxrFu3jgMHDmA0GnNtPiVKlKBRo0Zs2bKFOXPmoNfr6d+/PxUrVuSzzz5j+/btyIUQQgghhBBCCHE3VVXJyMjg2rVrNGzYkC+++ILy5cs/UdXKhQsXJiwsjG3btpGZmWntcIR4Ojk6aonqBQvgxx9hxQrtFhYGGzdCXJy1I8xWfHw8W7ZsQa/X07hxYxzNA0c+Q56cvbkQj4HJZGLlypWcO3eOt99+m9DQUP7880+GDRvGr7/+mqtnv93c3BgxYgQlSpRg/vz5bNu2jTJlyjBy5EhSU1P57LPPOH/+fK7NTwghhBBCCCGeJleuXCExMZGyZcuSL18+a4fz0IKDgylWrBhnzpzhypUr1g5HiKfX/v0wZIjWy7pQIe2+//0PRowAG9z2VFXl6tWrrF27lkaNGlGkSJFnrsoaJGktRBaXLl1i/fr1uLm50aVLF5KSkti4cSPXrl3j+eefx8HBIVfnFxoayqRJk4iLi2P27NlcvHiRJk2a8P7777Nr1y4WLFhAcnJyrs5TCCGEEEIIIZ4GR44cwd3dnYIFCz5RFdZmer2e8uXL4+joyLZt26wdjhBPrxs3YO1abUBGk0nra+3uDpcuQUqKtaO7i8Fg4Pfffyc5OZl69erh4+Nj7ZCs4snbqwuRR0wmE/v27ePgwYN069aNwMBArly5ws8//0z9+vUpX758npzZqlWrFkOGDGHDhg0sXboUg8FAz549qV27NosWLWLLli2YTKZcn68QQgghhBBCPMkOHTqEh4cHBQsWtHYoj+y5557D29ub33//XdpDCpFXvLzA21tLUhuNoNdDUBDEx2vtQWxs20tLS2PBggWUKlWKGjVqYGdnZ+2QrEKS1kL8IzIyklWrVuHm5sarr76KoiisW7eO69ev07p1a4KCgnI9aa0oCk5OTrz22ms0btyYGTNmsG/fPry9vRkzZgxOTk5Mnz6d8+fPyw8YIYQQQgghhPiHqqocOnQIT09PCpkv938ClStXjsDAQPbs2UN8fLy1wxHiLiaTidTUVGJjY7lx4wZ///03x44de7Ja2piT1hcvaklr830eHlp7EBsbCHX9+r+IjMygTp26FC1a1NrhWI29tQMQwhaYTCaOHTvG1q1befPNNwkLCyMyMpJ58+ZRtWpVateunWdnthRFISwsjF69enH69GlGjhzJDz/8QMWKFenZsyeffvops2bNYty4cTg7O+dJDEIIIYQQQgjxJElKSiI8PJyqVasSHBxs7XAemYuLC9WqVePkyZPs3buXZs2aWTsk8YzKzMwkMTGR+Ph44uLiiI+PJz4+nujoaK5fv86NGze4du0ax44dIyoqitq1a/P5559Trlw5a4d+f56eWpL68mUtaa0o2n0+Pv/el8vtYB9VejrMn1+JsmUX0aaN3zNbZQ2StBYC0C69WLx4Ma6urjRt2hQPDw/mz5/PjRs36Nq1a56fudfpdNStW5fOnTszceJEJkyYwNSpU3nttdfYv38/CxcupHLlynTo0CFP4xBCCCGEEEKIJ8GJEycwGAwUL14cJycna4fznzRo0ICFCxeydetWSVqLPGUymUhISCAiIoKIiAhu3rxp+TsmJoa4uDhiYmKIjY0lNjaWmJgYEhMT8fLyIjAwkMDAQEqVKoWbmxtbtmxh3LhxzJkzBy8vL2u/tXszV1r/8ce/ldYeHtp9ly/bVKX1/v2wb58TDRvWoXx5a0djXZK0Fs88VVU5ffo0q1atolWrVlSpUoXY2FhmzpxJSEgIbdu2xd4+7zcVZ2dnevTowd69e1m2bBmVKlWiR48eDB48mMOHDzN27FjKly9P2bJl8zwWIYQQQgghhLBlR48exc7OjjJlylg7lP+sTp06uOj1GC9cwJiaip1cYSv+I5PJxK1bt7h06RKXLl3i8uXLXLx4kUuXLnHz5k1SUlJISUkhNTXV8q+dnR358uWjYMGClClThgIFClCgQAHCwsLw9PTE2dkZZ2dn7OzsSEpKYsiQIWzcuJGFCxfSp08fHGykUjlbHh5aVfX161ops6reXWltA1QVvvsOMjOhUyd41ncFkrQWzzxVVZk2bRouLi60bt0aLy8vpk+fTkREBP3796dw4cKPLRZfX1+mTJnC888/z8yZM6lcuTKVK1dmyJAhDBw4kFGjRvHtt9/i4eHx2GISQgghhBBCCFvzNCWtfXx8+LNWLdyOH0d36hQ895y1QxI2zmQykZmZSXR0NNeuXePatWuEh4cTHh7OuXPn+Pvvv0lJScFkMqGqKiaTCZPJBICHhweFChWicuXKFC1alKJFi1KsWDGCg4NxcnLCzs7OcrO3t7e0p7hzjK9Zs2bx4osvMmfOHMqUKUPjxo1zfRywXGNvDwEB2t9Xrmh/m5PW+/drldaqqrUNsaK//oI9e6BgQWja1Kqh2ARJWotn3okTJ1i5ciU1atSgSZMmREZGsmTJEjw8POjRowc63eMbr1RRFIoVK8bkyZPp06cPM2bMYPLkyXTv3p1du3axdu1a5syZQ79+/dDr9Y8tLiGEEELkAlWFxETIyABHR3B1hWe4T6EQQjwyo5GEU6co4OFB6dKlrR3Nf6YAAfXro+zeDUeOSNJa3NeJEyfo1asXe/bsQafT4eLigl6vt9w8PT0pXbo0hQsXplChQhQuXJjChQtToEABvLy8ckwu3y/pbDKZMBgM2NvbExISwpdffkmnTp2YMmUKYWFhlChRwjYT14oCQUFa6XJ4OFSurFVf+/rCtWuo6ena06wYotEIv/0G167BxInaT8VnnSStxTMtIyODL7/8EoAuXbrg7u7ODz/8wPnz53nvvfcIDQ197DEpikLbtm3Zu3cvP//8MzVq1KBr166MGzeO06dP8/3331OtWjXq1KnzTDfkF0IIIZ4oBgPs3g1794LJpA32U6kS1KkDT3gvViGEeOxu3mR6WhpXK1fGz8/P2tHkCqVBA/joI/jzT603gC23WhBWZTKZWLFiBQcPHqRmzZpUqFCBIkWKEBwcTP78+QkODiY4OBjnXO4tYTAYOH78OEeOHKF58+YEBgZSo0YNBg0axPjx45kxYwbjx4/H09PTJhPXar4g8PdFjbiMAigODmRUzEdKAwdc0q/iQD6rxnfjBuzcqbXZbtPGqqHYDElai2fakSNH2Lx5M+XLl6d58+Zcu3aN3377DTc3N7p27Wq1uFxcXOjduzcnT57k66+/pnLlyjz33HN8+OGHDBgwgK+++opixYqRL18+m/wyEEIIIcQdDhyAyZPhlVegUCE4fx5mzwY3N6he3eqXowohxBPl778JuHqVgOeee3r2nwULat8PZ89q2auwMGtHJGxUREQEJ0+exM/PjxkzZlCpUqXHkhcwmUzs3buXcePGceXKFYYPH46rqyvt27fn5MmTLF26lAIFCjBkyBCbzFNklg8kuo8bdqXP4//PfUkvBnGtggv5PcLxpqrVYlNVOHxYu3XsqBWA2+AifOweX98DIWxMZmYmy5cv59q1a/Tt2xcPDw/27dvH/v37efPNNwkLC7PajlZRFIoXL867775LYmIio0aNIi0tjUaNGtGpUyc2b97M4sWLMdjQCLdCCCGEuIe1a6FaNXjzTXjhBe3fkiVh61abGfxHCCGeGGfOQGqqdon/00BRtF4AL7wAFy9qNyFycPLkSQ4cOMDLL7/8WNtxODg40KRJEypVqsRXX33FqlWrUFWVfPnyMXjwYEqWLMnUqVNZtWrVY4nnYakhgcQ0NBITcsJyn+LijeroQHpGuBUjg4QE2LZN+0nYsqW0BjGTpLV4JqmqyrFjx9i+fTvlypWjefPmREVFsXbtWhwdHXnttdesPvKtg4MDrVu3pk2bNuzatYvp06fj6upK586dqVy5MhMmTODw4cOoqmrVOIUQQghxH6oKFy5A6dL/9rB2dIRixbT7/xkYSQghxANQ1X+T1k9T72cHB6hfHy5f1q7GkeM8kY2kpCS2bdtGfHw8rVu3xtnZGZPJREpKCgaDIU/zA4qiULhwYYYNG4anpycDBgzg+PHjABQvXpxJkyZhNBoZOXIkx44ds7lchb19IDqdM+np/yaoHRwC0elcSEs7Z7W4VBWuX9fqG+rVg6JFpcraTJLW4pmUmZnJ1q1bOX36NP369cPZ2ZlTp06xbt062rZtS6FChawdIqC1CRk6dCgVKlRg8uTJbNq0icKFC9OnTx/c3Nzo0qUL58+ft3aYQgghhLgfFxdISvr3/6oKyclaexA5MhFCiAeXlqZVIjs4QIkS1o4m9+h02vvx8oK//tIG7hXiNqqqcvPmTVatWkW9evUoWbIkiqJw/fp1XnvtNUaPHk1cXFyexqDT6ahTpw7Dhw8nJSWFvn37cvXqVRRFoU6dOnz66adcunSJMWPGcP36dZtKXOt0btjb+2MyJWIwRAH/Jq1vT2Q/bkYjbN+uJa6bNAF///tP86yQpLV45qiqyqVLl1i9ejVly5albt26ZGRksHjxYpycnHjxxRdtZuAARVEIDQ1l1KhRODs7M3XqVOLj42nevDn169cnPDycESNGWDtMIYQQQtyLokDFirBjB8TEaAnr6GitcWHZslqiQgghxIO5dg2ioqBcuafrGnpF0UZgq1QJjh6F2FhrRyRsjMlkYs+ePVy4cIEGDRoQFBSEqqr8+eef7NixA71ej9NjGNxZURTefvtt3nnnHY4ePcrnn39OTEyM5f6uXbuyc+dOvvnmGxJt6OSLoijo9QUAhYyMCwDY2weg07n+83/rXPmWlATffqvt0qpW/feiPCEDMYpnkMFgYNeuXRw/fpyRI0cSGBjIyZMn+fXXX2nUqBGVK1e2iYT17Zo0acJHH32Ek5MTOp0OBwcHQkNDURSF9PR0a4cnhBBCiDupqtag8ORJqFIFXnoJ/v4bPv4YAgK0hIu7OzRuLElrIYR4GNeuaSf+6td/+q5UMSet58zRvifCwp6+9ygeWXp6OvPnz6dYsWLUqlULBwcHMjMzmTdvHsHBwTz//PM4Ozs/lljs7OwYOnQoly9fZvny5ZQuXZrOnTvj5OTEwIEDuXz5MgsWLKB48eK0a9fO6u1XzRwdtaR1evoFXF2r/1N97UdKyhEMhmgcHAIeazyqqlVaFywIZcponePEv+QXsnjmJCcns2DBAooWLcoLL7yAXq9n5syZ6HQ6WrRogb8NXouhKArdunWjc+fOeHp6kpiYyJ49e9Dr9XTv3t3a4QkhhBDiTqoK06bBwIHaYIshIfDhh1ryumxZaN0aBg+G4GBJSAghxMO4fh1u3dKuYHnaTvo5O0OpUpCZqbUIkYF6xW0OHDjAoUOHqFq1KmXKlAHg1KlTbNmyhfLly1P5MQ9M6uPjw7BhwyhcuDBffPEFBw8eRFVV8ufPz8CBA/H392fs2LH89ddfNtMmxJy0NldaK4qCo2MYiqIjPf1Cns5bVSE9HfbsgatX+Wf+4OEBffpo47Dq9XkawhPnKdvDC3Fvqqry22+/cejQIV544QXKlCnD6dOn+fnnnylZsiTNmze3uSpr0Hakzs7OODg4oKoq69ev5/Tp07Rq1YpGjRpZOzwhhBBC3E5VYdMmmDJFO/ooXlw7SvHx0UbYadUKGjSA/PnlGlAhcpmqqmRmZhIbG0tCQgImk8lmkiUiF5hMWqV1XJx2Lf3TlrTW6aB6dfjyS6hTR/s+MZlkUEaBqqrMnTsXd3d3mjdvjpOTE6qqsmDBAuzt7WnRogXu7u6PNSadTkfZsmUZOHAg6enpfPDBB0RHR6PT6ahevTq9e/cmPj6eXr16kZiYaBP7YkfHgv8kqC/edl8YoLMksvNSdDS0aaNdeGfuGKeqsG0b/PyzbOp3esr28ELcm8lkol+/fgQFBdG4cWMcHR3ZtGkTPj4+dOnSBS8vL2uHeF8JCQmsXLmSxMREhgwZYjOX2QghhBAC7WgjPBz699cG0xo9WqumnjlTS1SfP68lqm3wJLkQTzqTyURkZCRNmjTB39+fMmXKMGnSJMLDwy0JbPGES0rSktbBwU/naGWqqrWOMplg+nTtu2T+fIiIkGzWM+7MmTOsX7+eokWL0rBhQxRF4caNG6xYsYKQkBBatGhhlQI8Ozs7WrZsSY8ePTh58iSDBw8mJSUFBwcHOnbsyFtvvcWxY8cYMGAAKSkpjz2+O5l7Wqenn7ck0c2V1hkZF/N8/iaTNsbqzp2wYYN2MYWqQkpK1vG6hUZ6WotnSlpaGqmpqfj7++Pj44OiKPTq1YtKlSpRvnx5m6yyvp2qquzbt499+/bx0ksvUbJkSWuHJIQQQojbRUbC2LHa5etjxkDdutqQ8PPmaYlqG/+tIcSTKiMjgyNHjvDxxx9z4MABSpcujZ2dHZ9//jlz5syhdevWNG3alJIlSxIaGorj0zSA37PCXJJYrpyW2PXyevr2qXFxMGMGXLyolWPa2cHq1XDokPbdEhho7QiFFZhMJr7//nvS09Pp2LEjrq6uqKrK0qVLiY+Pp2fPnvj5+VklNm1wQ61t6YkTJ1i2bBlly5alT58+ODs7M3z4cM6cOcP//vc/nnvuObp16/bY+m5nx94+AAeHQFTViKpmoCh6nJxK4eHRDAeH/I8lhuBg7UKKFSu0gRdDQh7LbJ9IkrQWzxRnZ2fat2/PsmXLWLJkCUWLFsXLy4s6depYO7QHkpCQwMaNG0lMTOTtt9+WH9tCCCGELUlOhsWL4fff4ZVXoEcPuHxZS0DEx8PXX0OhQtaOUoinTlJSEqtWrWLq1KlcvXqV999/n9atW+Pg4MAff/zB7t27WbduHd9//z3Vq1fn+eefp06dOlSrVg0nJyebL1wRQFoarFkDJ05opYlhYWAwaEnsp+XzU1Wt0e3x4zBqFDz3nHZ/hQowYoSWuG7e3LoxCqu4fPkyGzduJDAwkJdeegmAyMhI1q1bh6urK2+++aZ1AwQCAgIYNWoUFy9eZPr06RQoUIC2bdvi6+vLpEmTeOutt/jyyy8pVKgQTZs2xd7eOulIRbEjOHgsOp0bqmogI+MWYCJ//k9xdCyYJ/M0GrWfgRkZ2mbu4ADNmsEPP8BPP0G/fnky26eCJK3FM0VRFEaOHElMTAzLly+nTp06tGnTxmo7zIehqioXL17k119/pUGDBpQrVw7d09bDTQghhHhSGY2wbx/MnasNtPjBB9qRyfz52jWg/ftDo0ZPT3JFCBugqirJyclMmzbN0ut18uTJtGnTBjc3NwAqVKhAmzZtOHv2LDt27GDlypV89tlnfP/995QvX95SgW2Lg7GLf6gqfPGFlrR9+WVwdNTGDTh4UDsp+LSMXKaqWhsQR0coUODf7wsfH6008/p168YnrGbTpk2cO3eO9957z7Kv2rlzJ6dOnaJ169aEhYVZOUJNyZIl+eyzz3j99deZOnUqBQsWpFq1apQoUYJx48bx3nvvMWXKFIoUKUKJEiWsdsLQ2/s1jMYEbt2aS0LC74AOVTXg5dWKgIBHzyAbDFrP6itXtC5GV65o56EuX9YuxCtZUhufGyA0FDp0gE8+0YY7Edmz/UydELlIURRCQ0MZPHgwXbt2ZcqUKVSuXJkCBQrYfIVFRkYGv/76K7GxsbRu3dpql/8IIYQQ4g6qqh2NTJgAqakwdCgUKaJVXH/5pZas7twZXFwkaS1ELlFVlZiYGHr16sXvv/9OhQoVGD9+PNWrV8dkMrF3717KlCmDu7s7AQEB+Pv789xzz9GpUycOHjzIt99+y+rVq9m0aROhoaG8/PLLdO3alfz586PT6Wz+2OCZcvYsLFmi3cqW/Xewwpdegj17oH59a0eYu7KrHpf18ZkVHR3N1q1bycjIoFOnTgAkJyezbds2YmJi6N69u03tr2rUqMHEiRPp3bs3X3/9NaGhoQQFBVG/fn0GDx7MyJEjmTZtGp999hnu7u5WiV1VTaSkHCQmZgmBgUNwda2ByZSMqqbd8TxzH/ms/xqNcaSnnyc9/TyrV1djx46CnDuncO2aNu52ZqZ2Mxi0f00m8PODfPn+bU2v02kXTqxZow3KWLHiY3nrTxwp0xTPHJ1OR5UqVejbty8nT55kypQppKamWjuse1JVlVu3bjF//nyqV69OzZo1pcpaCCGEsBGZ6enETZmCevAgvPuulkC5ehV699ZKafr10y5lt6GDSiEehsFgIDMz87YDeOvKyMhg7969NGrUiHXr1tGyZUsWL15MzZo1iY+PZ/DgwbRu3Zrvv//eErOiKDg7OxMcHEybNm34+eefOXToEF27diU5OZmpU6dSvnx5OnXqxM6dO7l16xYZGRk2856faWfOQFAQlCkD9vZaticsTPv/0aPWji73KIqW2crMhBs3/u3hnZCglW/K1QDPHFVV+fPPPzlw4ACvvPIK+fNrPZdPnDjB7t27adKkCcWLF7dylFnZ2dnRunVr3n33XZYvX863335Lamoqer2e9u3b89prr/Htt9+ycOFCDAaDlaI0kZp6Ejs7H9zcauHoGIaTUymcnSuhqplkZkaRkXGFtLQTxMevIjJyOleu9CU8vAUnTpTi2LFg/v77BS5d6s6BA7tYv97ImTPaRXehodC4MfTtq3WF27wZLl3SxuH+9tusF4Y4OWnDn5w5A6tWWWlR2DiptBbPJEdHR9q2bcuePXuYP38+NWvWpH379jadCP7222+Jj4+nSZMmhIWF2dTZVCGEEOJZZTQa+WXlStatXs0n7doR1rmzNiz8oEFaomHQIHj+eUlYiyeWyWTijz/+4PTp05QqVYoiRYpY7Yo/VVVJSEjg119/5dNPPyU5OZn333+fIUOG4OjoyB9//MHYsWPZsWMHL774IrVq1brrN7P5/3Z2dpQuXZrPPvuM999/nzVr1rB69Wr279/PypUrqVKlCq+99hrVqlWjWLFieHp6yu9va0lJubsFiKKAqyskJVknprygKFopZsGCsGwZtGypDcS4datWqlmhgrUjFI9ZWloae/fuJSoqildeeQUnJycyMzM5ePAg58+fZ9CgQbi6utrUvklRFDw9PXnnnXc4ffo0U6ZMoUSJErz88sv4+/vTp08fzpw5w5gxYyhevDhNmzbN8zyMdvLRgNGYjMmUhL29P3p9MTIzrxEV9Q1eXi3Q64tgZ+dLWtpZrl4dSmLiFlQ1Ezs7N3Q6V3Q6N+zsXHFwyIezc1kcHcNwcAihe/eKdOyokD+/dm7NweFecdx9X2goDB+uJblr1syzRfDEUlQ5dSyeYfv27aN79+6kp6fz448/UrlyZWuHlK2rV69Sr149fHx8+PHHHylSpIi1QxK3yczMxGAwoNfrbfrEhxBCiNy3c+dOunTpgpOTE98uWEDZMmWwmzoV+0mTUDp2hEmTwN3d2mEK8cjS09OZPXs2Y8aMwd/fn7p169KgQQNq1qxJWFgYdnZ2jyUOVVW5fv06M2fO5PvvvyckJIQ+ffrQrl070tPTWb16NZMnT+batWt069aNXr16WaoSH1RsbCwHDx5k48aN7Ny5k9OnTxMcHEy9evWoXbs2NWrUoGDBgo/tPYt/7NsHPXvCxo1aJTJoieyWLbWrW15/3brx5QZzWkZV4fRpWL5cG9wXtCxY27bawIw2lJwUecs8plWHDh3w9PRk9uzZFCxYkOvXr9O1a1fi4uL49ttvKVmypLVDzZaqqmzbto0+ffqQmZnJkiVLqFq1Kqqqsn79et577z08PT2ZN28eVatWzbV5mkzJGAy3MBiiMRhuYTTGYTTGkZl5nczMSAyGKPLnH4+DQyAxMT+SkLARozEGvb4ofn7v4OCQn5iYJWRmRmJn54WDgz/29nfefFCUhz/uV1WIidG6yfXurY3NraraubexY6F4cXjnHW0zl01dI0lr8UwzGo38+OOPvPfeezRp0oSZM2cSFBRk7bDuMn78eMaPH8/w4cMZPny4JEZtzL59+5g+fTrvvfcederUkQMZIYSwFlXVBqravBmiorTLx5s1g38GZMttly5dok+fPmzdupX58+fzyiuvsPrXXzkyfjzvBQaSb+5clJCQPJm3EI+LwWDg8uXLHDhwgA0bNrBy5UocHBwoVaoUNWrUoGXLltSsWTPPf/8cP36cjz76iN27d1O/fn2GDBnCc889R3p6Ol9++SWzZ8/G1dWVYcOG8fLLL+P+iCeLVFUlNTWV8PBwDh8+zG+//cZvv/2Gk5MTpUuXpk6dOrRt25by5cs/EYO5PxUSE+Gtt7RRzPr3B2dnWLoUFi/WkrvBwdaO8L9TVa26OiUF3nhDa4Z765Z2v79/nn2PCdtlNBpZsWIF7777LiNHjqRPnz44ODiwefNm2rVrR9++fRk2bBiurq7WDjVHGRkZ/PTTT/Tt25dq1aoxd+5cChYsiMFgYPHixfTp04dmzZrx+eefU7BgwQd+XaPRSGRkJOnp1/HyukJGxjUyM6+TkXEVozEaozERozEBkynxn+rqFFQ1EweHQBwcQggNnYaLy3OAgczMG6SlnSEiYgqKoqNQoR8BHYriiKI45GoVu6pqF03ExYGHx79V2aqq7eZSUrRzc4GB0KCB1g3pWSdJa/HMS0tLo1+/fixdupThw4czePBgHO51Tcdjdu3aNVq0aEF0dDT79+8n+Gn4UfYUUVWVFStW0LFjR3766SdatWolJxWEEMIazAnrXr20UpXSpWHHDu0IYOFCbRDEXJuVSkpKChMnTuSLL76gf//+jB49mvDwcPr06cPF8HDWr1hBsWrVbOqSXSH+C6PRSEJCAlevXmXZsmX8+OOPXL9+HS8vL5577jnefvttmjVrhss/21purPuqqqKqKhs2bGDo0KGcP3+et99+m+HDhxMUFER0dDS9evVi06ZNVKxYkU8//ZSqVavi4JA7iYbMzEzi4+O5cuUKixcvZvny5URHR+Pj40NwcDCzZ8+mUqVK/3k+4gFcvAjjxsEff2iNY0uUgIEDoUaNf0sSn9T9rarCsWPQqpXWHmTpUq0EUzzTUlNTee2117h48SKzZ8+mVq1aZGZm8u6777Jjxw5mzpxJkyZNbP53RlpaGmPHjmXatGl06dKFiRMn4u7uTlpaGiNHjmTWrFkMHDiQoUOH4vbPyRlzmjIlJYUrV65w7tw5zp8/z/nz5zl37hyXLl0iJSWZ6tWdGDo0ClXNwGTKQFUz0emccHQMQ68vjKNjYfT6wjg5FcXRsSA6nSuKov+nUtoR0L6rVFUlNvYnrl8fQbFiW9Drw6yyrE6ehD594PJlWLtW+zlr4x9vnpO8vXjm6fV6Pv30U44cOcJ3331HtWrVqF+/vk0kHk0mEz/99BMXLlxgyJAh5MuXz9ohiTuoqkpiYiImkwkPDw+b/9Egng2qqpKcnExycjJ2dnZ4enra1Mk4IfLMggWQPz+MH68N1PXmm9CmjZYA6No112ZjMpnYuHEjCxcupE6dOgwcOJCUlBTmzJnDwYMHmTx5MgVkGHjxlLGzs8PLywsvLy9Kly7NgAEDWLduHXPnzmXv3r1s3bqVsLAwOnXqxGuvvUZgYCAuLi6P/Jva/Bvr+++/Z/z48WRkZDBx4kTeffddVFXlwIED9O7dm7Nnz9KyZUsmTpyY6+O+ODg44Ofnh6+vL+XKlWPYsGGsWrWKr776ikOHDvHee++xb98++f33OBQoALNnawlr0Pbx9vaQnq4NxujuDqVKafc/SVQVIiJgwABtHITx47We1uKZd+bMGTZu3Ej79u2pWLEiiqJw8+ZNfv75Zxo1akSVKlWeiH2Pk5MTo0aN4tSpUyxfvpxy5crRrVs3nJycGDx4MKdPn2b27NkYjUZ8fX05d+4c586dIzw8nIiICIxGI3Z2dlluDg4OhISEkD9/UXx8iuDsXBi9vghOTkWxs/MFlH+WTdabeXmpqon09L8xGpNxdAxDVQ3Ex/+Gg0M+HBwCrbasSpaEjh21HtddusCaNeDjY7VwbIIkrcUzT1EUfHx8+OSTT+jatSuzZs2iePHihISEWP1L4OrVq/z++++4u7vTtWtXq8cj7paZmUlcXBweHh44OTnJZySsynyAf/bsWRYuXMjy5csJDAxk9OjRNGnS5JEvlc4NyUYjF9PSMP1TOZFPr8dPEukiN6kq/PUXvPLKv9db6nTw4otaQuPSJa0S29lZuzk5Zf3X3v6ByllUVeXvv//ms88+w83NjZEjR+Ll5cXixYv57rvveP3113nppZfQ3zlomBBPgdsHMfT19aVjx4688cYb7Ny5k2XLlrF3714mTZrEl19+SZs2bXjllVcoVqwY+fLlw9HR8YHno6oqFy5cYObMmXz77bcULVqUcePG0aBBAxITE1m9ejXjxo0jKSmJAQMG8MEHH1gq9PKCoijY29vj7+9Pt27daN26NVWrViUqKoqkpCSrfr8+MxRF20/ffr28qsL581o7jUqV4LPPoHDhJytxnZAAU6bA4cPw9tvQoYOUVgpUVWXWrFl4enrSvHlzSwuQb775Bnt7e5o2bYqvr6+Vo3xwTk5OTJw4kY4dO7J06VIaNGhAiRIlCAwMpG/fvhw9epRp06bh6emJm5sbLi4uBAYGUqRIEfz9/QkNDSUsLIywsDBCQ0MpXLgwbm5u/+HY20RS0j6io7/Fzs4NkykVsCN//onodNb7/abTabuzkydh1iwYORI+/RS8vKwWktVJ0loItB/eNWvWpHv37nz99dcsWrSIoUOHPtSP69xmNBrZtm0bR48epVevXvj7+1stFpEzg8FAbGwsHh4eVl1fhEhKSmLPnj1s2LCBtWvXEhUVRXBwMDExMQwePJiuXbvSsWNHwsLCrHIlyaW0NOZcv041Dw8AHHQ6SVqL3JeWBnfui/V6iI+HRYtg5kzw9tbKVu7818sLvLy45e1NuKcn9q6ueHl54enpibu7O3q9HkVRSEpK4vPPP+fcuXOMGjWKypUrs3//fsaOHUvJkiV57733CAy0XpWOEI+bvb099evXp06dOpw9e5YtW7awa9cu1q9fz9KlS6lTpw716tWjZs2aVKpU6b4n+U0mE/v27eOzzz5j+/bttGjRgsGDB1OuXDlu3LjBzJkzWbRoESEhIYwaNYrXXnstz3tLq6pKZmYmSUlJODs74+/vT4kSJTh58iQ3btyQpLU1FSyoJXrnzdOSv2PHaj2gn4TEb0aG1gNg6VKoUwdGjHiyEu4iz1y8eJHVq1dTtGhR6tWrB0BERATLli0jNDSUF1980boBPiRFUShSpAjjx48nPDwcv38GVFVVlfT0dNLT02nTpg0tW7YkODiYgIAAAgIC8Pb2zpP9u6LY4+vbEQ+PRmRkXEVRdOj1RTAYYkhI2ISzc1kcHKwz1pmTE3zwAZw7Bz/+qHVC6t5dq694FknSWoh/eHh40KlTJ/744w++/vprqlWrRuPGja1WORsZGclvv/2Gl5cXbdu2lYFebFRmZqYlaS1VdcIakpKS2LJlC8uWLePAgQNER0dTr149XnnlFYoUKcLNmzeZN28e06dPZ//+/QwdOpTnn3/+se/bDKqKr4MDbwYEyBUJIm8oitYD9MQJeOmlf+8/ckT7xV+3rpbQjor693by5L9/Gwzg6soxPz/GuLmRrNPh6uqKm5sbbm5ueHl54e/vT0REBMuXL6dy5cpUq1aNW7du8eGHH5KUlMSkSZOoVKmSrOPimeTg4EDp0qUpWbIkr776KidPnmTnzp2sXbuWTz75hLCwMCpWrEjz5s1p2LBhtgUZKSkp/Pjjj8ycOZMLFy4wcOBAOnfuTGhoKH/99RejRo1ix44d1KtXj8GDB1OlSpXH8htZVVXWr1/P8uXL6dGjB3Xq1KFEiRIcPXqUy5cvU7x48TyPQWRDUbRMTp8+EB0NK1ZoJyDHjr37BKatUVU4fRqmTQM/Py1h/QRVzoq89eOPP5KQkMDLL79s2Vf++uuv3Lhxg169ehEaGmrlCB+eg4MDDRo0oF69epa2hUlJSWzatAkXFxe6d+9OvXr1HlNxjUpm5k1u3pyEp2dzPDxeBEzExq4gOvpb8uUbi6endZLWoO0SPv1UaxXy9ddQrBg0aQJ5PN6xTZIsmBD/UBSFQoUK0adPH3r06MHgwYNZv349QUFBeXrweftYqOb5mEwmTp06xfr163nnnXcoVKiQHADbKIPBYGkPIklr8bioqkpaWhqbN29m5syZHD58mLi4OFq0aMG7775LxYoV8fHxQVVVbty4wVdffcXcuXOZM2cOb731Fn369KFfv36WytE8i1ML1vL/P5OSGHL+PL729rzi70/xXBwYTwgAXn8dhgzRBmGsWFEbgv2PP7SSlQIFoHJlyMzUbhkZWf+NjoYbNwi4fp06169z8coVrl+/zt9//01ERARpaWk4OjpiMBgwGAwcPnyYMWPGAHDw4EEGDhxI69at5SSzeObpdDqCgoIIDAykRo0adO7cmYMHD/Ldd9+xfPlyfvvtNwoWLMhLL71Ex44dLS35YmNjmT59OnPmzEGn07FgwQIaNWqEi4sL69at46OPPiI8PJx33nmHwYMHky9fPuwe4xF8SkoKa9asoUGDBtSuXZtixYqRmZnJ5cuXH1sMIhuKAoGB2r7/yhXtiprQUOjZ07arrZOT4ZNPtNZVEyZo309SZW09qqrdLl2CyEitWj809IFbh+WmqKgoVq9ejbOzM2+99ZblKq8VK1YA0K1bN5sYf+tRmHtSg3Y8ExUVxcqVK6lTpw6lS5d+rO/LaIwnNnYZ9vbeuLvXR1Ec0elcSUs7g8Fw87HFkZMSJWDiRK239eTJWuK6SBHb3q3lBflVLcRtdDodTZs2pXv37nz22Wd8+OGHzJo1Cycnp0d6PVVVMZlMWW5Go/Gu/ycnJ+Pq6oq/v79lALVFixbh7e1Ns2bN8rRHn/hvbq+0lvYgIq8ZDAZSU1PZunUrU6ZM4eDBgzg7O9OwYUOGDBlChQoVsLe3t/zgmzRpEnPnzmXcuHF88MEH1KxZk8GDB/PJJ5+wf/9+Pv74Y0qUKIGdnV2uJ69VVSVdVbmSlsax5GS87e0p5+rK8AIFUAD7Z+0Xl8hbqqq1BqlcWUsCfPMNzJihDbv+ww9aBba5Ii+n6yv/OWAtraqMNZlQVdVyMxgMxMTEcPXqVa5cuUJ4eDjLly9nw4YNqKpKnTp1+PDDDx/594JVqKqWrFdV7aD8WSzfEXlKURRcXFwoUKAAYWFhtGnThjNnzvDNN9/wv//9j4kTJ/LFF1/QokULOnTowIoVK1i6dCkVKlRg9uzZlC5dmuTkZL766ismTpxIeno6kydPplu3btjb2z/Wgg5FUShatChJSUlERUWhqiolSpQgIyNDkta2QKfTellPmACdOsGHH0JQELRunbUHto0wGQwo06ejrFkD77wDr77671gM4vEzmeDUKRg8GI4f16r0MzKgfHmt5UzJko8tU6iqKhs2bOD8+fO0b9+ewMBAVFVl27ZtnD59mhYtWlCkSJHHEkteM5lMrFy5ksTERF544YXH3FpNQVH02Nv7k5kZgcmUjJ2dHr2+MCZTIgZDNKqqWrVwUFG0rkFDh8JHH2mr4sSJ4OHxbCWubW8PLoSV6XQ6Bg8ezL59+1i7di1LliyhY8eOWRKSJpOJjIwMyy09PT3bv1NTU4mOjiYmJoa4uDgiIyOJiooiOjqaiIgIYmNjiYuLIyMjg1GjRjF06FBAGyl41apVtG3blgoVKkiVtQ0z97QuVKiQVFqLPGFOmF27do0DBw7w3XffsWnTJoKDg3nppZfo1q0bderUyXb9c3Nzw97env79+3P06FG6dOnCunXrGDlypGU08uHDh9OsWTO8vLxyZV9jUlXiDAaupKezJS6ODTExKKC1BQH0iiL7NJH7rl3TktQdOkD9+trtYSkKKAo6QJdNAtfNzY2wsDBA2y6rVatGly5dSEhIYMaMGTg/Sc0Gk5O1NiqnT2uJ6/z5tUHMAgKerSMh8Vgo/+z3HR0dKVu2LFOnTmXgwIEsX76cdevWsX37dn744QdcXFxo3749o0aNIjQ0lIsXLzJz5kwWLlxIkSJF+PTTT2nYsKFVvkMURcHT0xMvLy8iIyNJTU21VFpfuXLF6skNgbbvKl9e+y7o3Fm7wsbdHerVs6mEsNFoZM+GDXjOnEnpWrWw799fy0IJ67l6FXr31k5wz56tfSdeugQff6yVua5bp4198RgkJiayceNG0tLS6Nq1KwBpaWls2rSJ2NhYevTo8dTsa5KTk1m4cCElS5a0SutCnU6Pg0O+f5LWKdjb+2Jv74tO54LBEIWqpqMo1itGUBStv/Xrr2vnUhYtglKltItIbGiXluckaS1ENpydnZk4cSKvvfYac+bMoXz58lSpUgVFUUhNTWXLli0cOHCAhIQEEhISiIuLIyEhgfj4eOLj4y33p6am4uTkhLu7Oy4uLri7u+Pm5oazszP58+enZMmSuLi44OPjQ5UqVQAtIT5t2jRcXFxo1qwZPo/pC1I8mszMTGkPIvKM0Wjk1KlTbN26lbVr13LgwAFCQkLo2bMnzZs3p06dOvdMlPXs2ZPnnnuOGTNmsGDBAg4ePEifPn2YNm0av/zyC3PnzuX999/nwIEDdOnShfLlyz/yD0aTqhJrMHA0KYld8fHsio/HTlGo5ObG856eBOv1mB51QQhxL3FxWk/QOXO0S8QrVszzWSqKQoUKFWjYsCFr1qzJ0urL5mVmagN/rV6tLSs3N/jf/+DAAejVS2ukKEQe0ul0FChQgMGDB9OtWzd2795Nv379CAoKYsCAAYSFhXHt2jUGDRrEtm3baNWqFYMHD6ZMmTJWTdbo9XpCQ0OJiIggKSmJfPny4eLiws2bN0lNTcVFWl7Zhuef18oRhwzBOHEiGQEB6MuVs5l2CkePHqXfRx/hHxrKLyNH4la0qLVDEps2QUKClqQOCdGyhUWKwOjR2kmP336DN998LKEcO3aMgwcP0qhRI4oXL46iKJw+fZo9e/ZQuXJlKleu/FjieBw2bdrE+fPn6dmzp1XGBdDpnHBwyEd6ejgmUyoAiqLHwSE/mZlRmEzJ6HTWv4IuIEA7p3L6NHz6qUqZMok0aOD+1Jy8uB9JWguRDUVRKF26NB999BFDhgzhm2++oWDBgvj7+5OamsqaNWtYtmwZXl5eeHp64uPjg5eXF2FhYXh7e+Pl5YWXlxfu7u7o9Xrc3NxwcnLC1dUVV1dX9Ho9Li4uuLq64uzsnGUU9Q0bNrB27Vpq1qxJgwYNrLwkxP2YK62lPYjITQaDgb/++ovly5ezbds2Tpw4QeHChRk6dCgvvPAClSpVeqA2BDqdjurVq/P555+zbNkyvvzySwYOHMjrr79O165dqVChAnPnzmXevHkcPnyYnj178tJLLz1Uxaj6T2X11rg4dickcDI5GQVo7O1NLU9PSjg74+fgQIaqEiYndkRuMydgly7VqqvfeuuxzdrPz49GjRrx+++/s3jxYiZNmvRkHEBERcH27dpglW3aaG1BTpyAL77Qjojq1LF2hOIZ4u3tTdOmTSlXrhzXr1/HZNJOb9rZ2ZGens6gQYPo1KmTpe+1Nen1ekJCQixJax8fHwoVKkRCQgK3bt2yXIkhbMDLL5OZkMCGL79k64QJ9Jk4kQIFClh9Hbp69SpTp04lPDycnlOm4Pz881aNR/zj7FkIC9MG8bx9HSlUCIKD4eBB7STv8uXa/c7OlquzcHD4t+zV3h7Mv3Xt7Ljp6cmu9HRQFPR6veXEibOzs+VvR0dHy1gYJpOJVatWcfXqVT7++GP0ej2qqnL9+nUiIyMZOXIkzs7OVl+Pc0NGRgazZ8/G09OTl19+2SrjgWgJ6mCSk3djMqX8c58jDg7BGAyRmEzJgG0MjlquHIwaBSNHHmX06Bm4ub1H9erVrR3WYyFJayFyYGdnR4sWLSyX49eoUYOOHTvi4eHBRx99RJ8+fbC3t8fBwSHHW06Dw6SnpxMdHc3ly5eJiooiMjKSW7ducerUKcvlQHXr1sXb2/sxv2vxsKTSWuQmg8HAzp07mT17NkePHuXKlSsUL16cKVOmUK9ePfLly/fQP1Z1Oh0hISG899571KhRg+HDh/Pll1/yxx9/MGLECCZMmECtWrX48MMPGTRoEIcPH2bQoEEEBgbmOB9zVWlsbCwrVqzgT52OU1WqYKcoNPL2pqWvL2F6PW729phfQa8o6G2kykk8JVQVTp6E6dO1S8DHjtXKUR4TnU5nqYRatGgR77//PsHBwY9t/o8sJkZbdkWK/NvrNSREq7i+dUt77Ck4IBZPDnO/6NOnT3Pr1i0AAgMDmTt3Lh4eHri7u1s5Qo250nrXrl0kJSVZ4j5z5gyRkZGStLYV/yQS1fbtuRQVxbdTphDp6Mjs2bOtlvBTVZX09HSWL1/O6tWr6dKlCx06dHisA4mKe0hL+zcRfTtFAU9PSErSfm989pl2v53dv89VlH8H0Lzj75NlytD/778xqmqWSv/bx5LR6XSWv80DrYeEhFCiRAnLNHXq1GH58uUUKVLkqRnsee/evRw9epTq1atTtWpVq8Sg0znh6Bhs6Wmtquo/LUOCSU8/i9GYbJW4sqPTaUX/778fTadOP/LZZwlMnTqV0NDQp+Ikxr08HWu8EHlAURS8vb3p1q0bhw8fZsSIEdSsWZMiRYrg7++Pr69vlgEVVVUlIyODmJgYYmJiuH79Ojdu3CAyMpJr165x69YtoqOjLX+bTCbLDsb8r/m1ypcvT8+ePZ/6HdCTTlVVEhMTMRgMeHh4yA9P8Z+oqsqFCxd4/fXXSUhIoFSpUsyYMYPXX38dZ2fn/zxYoouLCzVq1GDNmjVMmTKFadOm0alTJz766CPatWtHlSpVeP/995k5cyYHDhzgiy++oHz58jjc1jTN3F/71q1brFixgpkzZ3LlyhV8Q0P54LffaBkURD5HR+ylb7XIa6oKsbHacOpnz2qJ67JlH3sYQUFBvPTSS4wdO5YFCxbw0UcfPbnr/pPU4kQ8VRRFoXjx4sTHxxMVFWW5L3/+/FaOLKs724OY4/7jjz8scQsboSg4uLnxWo8e/BEeztKlS8mfPz9jx461ypWRqqqyd+9epk2bRpUqVRg0aBCurq6PPQ6RAy8vbSBGozHriVujEW7cgKpVtau5Nm3S7k9K0h4DLeGdnq79nZkJKVrFLgYDBXQ63k9KwmA0kpKSgvGfaZKSkix/p6amkpGR8c9LpXHq1CnOnTvH9u3bKV68OI6Ojnh6elpaiT6xvzFuYzQaWbZsGcnJyXTv3t2KhV/22NsHoKoGDIZbgIqi6HF0zE9S0q5/Kq1th709tGnzPL1792bOnDnMmzePoUOH4urq+lSsFzmRpLUQ92DuWfnuu+8ydOhQunfvTps2bYiOjubWrVuWQRWjoqKIiooiMTERAAcHBxwdHXF0dLT8rdfrcXBwwNvbm/z58+Pn54evry9+fn74+/vj5+eHg4MDiqLQunVr6Yv3BFBVlcjISJydnZ/6LwvxeBw8eJCYmBjat2/PlClTcn0UbZ1Oh7u7Ox9++CGVK1dmwoQJDBo0iO3bt/PRRx/x/fffM3PmTL777juaN2/OJ598QsuWLQkKCiIlJYUrV66wYcMG5s+fz4ULFyhYsCA9e/akZ8+eFC5YMFdjFeKeDAZYsgR++QW6doXmza0yKo2iKLzxxhvMmTOHxYsX07VrV9uvtvby0g7KL1/WrjfV6bSD8tRU8PWVKmvx2Ol0OooWLUpiYiJRUVE2O6iho6MjISEhxMTEEB8fD0CxYsVITEwkMjLSytGJOymKgp+fH6NHj+bmzZtMnz6dwMBAevTo8ViPs1RV5eLFi4wcORJ7e3uGDBnyTFRHPlEqVYIVK7ST4Oae0UYj7N6tnSBv0EAb7+Ehx3woAgx+yFD++usv+vfvz8iRIylWrBiNGze2DGb7tDh16hS7d++mYMGCNGnSxGpxKIqCnZ0ndnbeZGRcRlUN/1Rah2AwRGEyJdnc95GjoyNDhgwhPDycuXPnUrp0aV555ZUsRUZPG0laC3EfiqLQsmVLZs6cybFjx7h06RJubm6W/tTu7u4EBQVZ/u/q6oqbm5ulz7WbmxteXl54e3vj4eGBj48PHh4eNjMYiHh0qqoSFRWFs7Mzbm5u1g6HkyehWDEtb5ORAVeuQIEC/179LWyfoii4u7tTq1YtVFVl586dFCxYkNDQ0Fydj6OjIy1atKBQoULMmjWLn376iRMnTtCvXz+6d+9OxYoVmTVrFu+//z6bN2+mRYsWnD17lpUrV3Lp0iWqVq1K+/bteemllyhRooRcZSAev61bYdw4qFYN3n3XqoMHBgcH8/rrrzNjxgx+/vln+vTpY1MHOBZXrmgJ68BAqFULVq3SBrF0ddX6dQYHQ4kS1o5SPKPy58+PoihERUWRmZlpk+OE6HQ6vL29cXV15erVqxiNRooWLUpSUpJNJ9ufdQUKFGDChAn06NGDzz//HF9fX9q1a/dAY4PkhqSkJCZMmMCJEycYPnw4zz//vBwH2prnn4e6dWHECHj7be03RUQEfP89tGjxWMd6KFOmDAMHDmTAgAEMGjSIJUuWUL58+cc2/7xmNBrZsmULly5d4pNPPrF6e007O08cdH4Ykq+BrxEUJ1ySQ/DZ7YK9YzyUsq2WaYqiEBAQwAcffEDfvn2ZMGEChQsXpmrVqlb7/jGZTKSkpGBvb58n+1VJZQjxAM6ePUtsbCylSpVi9OjRuLm5WQZSdHFxsdxuH1RBPP1uT1rbwiV+kydrrdb8/LSigAULYNgwrdWreDJERkbi5OSEt7c3e/fuZcKECfTv358382DEcp1OR9myZfn444+pWbMmU6dOZdiwYbz88sv07duX6dOns2jRIhYvXszmzZsxmUzUrl2bgQMHUqtWraeqr554skSdOYPn2LE42NmhDBkCpUtbOyS6du3KvHnzWLduHa+88ortVVvHxMCHH2oJ61GjtAEYfX0hPFx7rEwZ7YDd39/akYpnkKIoODs7ky9fPiIiIkhOTrbJpDWAp6cnfn5+XLp0CYPBQGBgII6OjkRGRpKenv7YEqHi4ZQvX54pU6bQs2dPJk2aREBAAA0bNszz3zFGo5FvvvmGn376idatW9O5c2ebOGYQd/D2huHDtau3tmz5tzd18+bw6quP9UouRVFo3LgxgwYNYsiQIYwePZrp06c/NT3zb9y4wY4dO/Dx8aF58+bWDgd9gifBy31xsL+EMtiA4qLgetUDlzleKMoVlGIGsLHvI51OR+XKlenXrx/Dhw9n+PDhfP/993n621NVVYxGI1FRUdy4cYObN29m+TcuLo633nqLpk2b5nryXI42hbiPzMxMVq1axeXLlxkzZgzNmjWTKgoBZG0PYguV1mfOaK3UQKu0vnDh33Zr4skQGRmJo6MjHh4eXLx4kbNnz+b5/sbX15f27dtbDuiWLVvGkSNHmDVrFkOHDiUjI4Mff/yRjz/+mDZt2hAcHCyV1cJqYmNjGTlxIpnR0Xw1fDjOjRr9O+iRFYWGhvLqq6/yyy+/sHv3btq1a2ftkP5lNMJXX8HKlfDGG9pgUw4O0KyZ1hLEZAInJ7ksR1iVufWGuV+0rQ5G7uHhYUlaZ2Zm4uTkRP78+YmKiiIpKUmS1jZKURRq1qzJ+PHj6dOnD6NHjyZ//vyUKVMmyyB4KSkpZGRkkJycTFpaGqmpqaSlpZGcnExmZiZJSUmW+823tLQ0y3MyMjJISkoiIyODlJQUkpOTOX78OMHBwYwePTrX276J/0BVITIS/vhDa/8REqJduRUdrR1I6fXg46MlLB/zsb+joyMdO3bk9OnTfPPNN3z99deMHDnSJo43/wtVVTl9+jR79+7ljTfeuOeg74+LvckDzz89UCIuQD8juIDi4IRisoPzF7SDaxtLWoM2xsIrr7zCiRMnmDlzJiNGjGDmzJm58h2UkJDApUuXuHjxYpZ/r169mmXfaN7/paen4+3tTb169TAajbl+MlB+nYpHpv4zYI+qqpaBCG//2zyooE6nw8nJ6YlMcqiqyokTJ9iyZQvlypWjWbNm1g5J2BBbq7TOzISFC7VBruPi4NYt68ajqtq4JHq99lvPaNTa0Fr5KjCbFhERgV6vx9PTk9jYWDIzMx/LAY69vT3lypVjxowZVK9enRUrVuDr62tpheTv70/lypUJCQmx+o9L8ezKzMxkyZIlLP/1V15s2hSH7t1t5kDCzs6Od955h8WLF7Nx40YaNmyIj4+PtcPSEtJr1mhfDmFh8OmnWqL688+1quqOHUHG0BA2wDzIYXh4OElJSdYOJ0eenp74+/tbKq31ej0FChQgIiKChIQE/KzYqkjcm06no0mTJgwbNoyPPvqIF198EW9vb1JSUkhLSyMlJcVyfJuTh31cVVUyMzMpVaoUBQoU+M/vQeSi5GQYOhS2b4dp07QrkPR6rVWWDXB1dWX06NGcOHGCRYsWUaZMGTp06PBEX+WYlJTEpk2bSE9Pp3nz5jYxhpfi4QnePnDgoHagqqrg4aFdjXblinafjXJzc2PkyJEcO3aMX375hZIlSzJw4MAs68jtOTqTyYTRaMRkMmEwGIiKiuLChQucPXuW8PBwwsPDOXv2LBERERiNxiz7M3P7K39/f4oWLXrXLTg4OM9yfk/uGi/yjHmlNhgMZGZmkp6ejsFgwGAwkJGRQWZmJhkZGaSnp5OcnEx0dDQ3btwgJiaG2NhYbt68SWRkJFeuXOHChQsULlyY2bNnU7du3Scu2ZGZmcnOnTs5ceIE06ZNw83N7Yl7DyLvmJPWLi4uNnHmW6eD0FDtCjdXV+vnchITYdAg+PprLZaTJ2HxYpg40aZag9kUayWtQatC8vDwoGfPnnTu3BknJydSUlKIjo7G3d0dZ2dn2f8JqzEajezZs4fZs2cTFhbGJ+PGYWdDZ8AURSEsLIyXX36ZrVu3cuLECerUqWPdbUZVtUtwvv5aS1QvWqT1tF6+HGbM0NqBvPqqVmUthJXp9XrCwsLYvXu3zSet/fz8OHz4MJmZmTg7OxMaGsrhw4ctA7IL26QoCo6OjlSpUoUiRYpw8eJFTCYTbm5ulvGGXFxccHR0xM3NDb1ej4uLC05OTri6ulrud3JywsnJydIa0tnZOctz3N3dcXR0xMXFBUVR6NmzJ5s3b+aHH36gY8eOT2Qh11MnJQWmToWlS+Gtt7RxHmyQl5cXX3zxBW+++SZTp06lePHiVKtW7YlsR6qqKjdv3mTVqlXUq1eP4sWL28ZxhZublqCOitIOXn19/01aX75s00lr0BLXc+bMoVmzZsybN4+iRYtStWpVMjIyLFeA3Lx5kwsXLnDx4kXLv5cuXSI5ORm9Xm/Zp5lvxYsXJygoiIIFC1KwYEEKFSpEwYIFKV68+D0rufPq85Sk9TPszJkzXLt2DWdnZ1JTU0lJSbHckpKSSEpKIi4ujujoaBISEkhISCAmJoa4uDjL/XZ2dri6uuLs7Jylt7OLiwtFixalSJEi7N69my+++IKiRYuSP39+a7/tB6aqKtevX+eXX36hdOnSPP/88/IjQ2RhTlr7+PjYRNLazg4aNYJ8+bQTwxs2WDceo1FrUWIyaf9PSdHiEjkztwdxd3cnPj4eo9FIQEDAY5u/+ceG+coBo9FITEwMbm5uODs7P7Y4hLidqqrcuHGDGTNmkJiYyNSpUwkNDbWNg53beHh40Lp1a1avXs3mzZupXLmy9aqIVBXi42HuXDhyROvVWa0aHD8OU6ZoXxQDB2qX5ghhAxwdHQkNDSUqKorExESbHdTQzc0Nf39/IiMjSUxMxMPDg7CwMNavXy9J6ydAWloa27dv5/z583z44Yd06NDBkmzW6/V5ss6NHj2ao0ePMnPmTKpWrUqZMmVyfR7iIaSlwZIl2mBADRpo1daP8bf2w1AUhRIlSjB8+HCGDh3K+PHj+frrr5/IKx9NJhPbt2/n2rVr9OrVi6CgIGuHpNHptM9fr9cOXAsW1JLWPj5w4IDNJ60VRSE0NJQpU6bQo0cPPvzwQ8LCwiyFpdHR0Tg6OuLl5YWnpydeXl6EhIRQtmxZ/Pz8yJcv3103b29vmzoxIknrZ9S2bduYNGkSZ8+excXFhdTUVJKTk0lOTiYlJQU7Ozvc3Nzw9PS0JOQ8PDwoWbIkHh4euLm54evri5eXF66urpYBCc2XkpsT1yaTicmTJzN//nwWLlzI+++/bxNtFB6E0Whk165d/Pnnn3zwwQdP5JeDyFtxcXFcu3aNfPny2UQPwyJF/m1J6uCgXQlu7fMsEREwZ44W18WLNv+9b3URERGWy6sSExOt3nrGaDQSHR2Nh4eHTazjwracOHGCtWvX4unpScmSJfH19cXHxwdfX99cHQ3eaDQyY8YMtm3bRu/evWnYsCEOj3FQpAdlZ2dHxYoVqVmzJkuXLqVz584ULFjQOr8dTCb4+WftwLx5c62XdVoafPwx3LgBn3wCFSvaRD9wIUBrUxUQEIDRaCQyMhKTyWSTxSJ2dnYEBATg4ODAxYsXKVSoEGFhYURFRREfH2+zyfY7pafD+vVagUHTplqXoKQkbRy6Zs2ezjFZVVXl0qVLLFmyhEqVKtG2bVuCgoLy5PMyGAycP38eT09PKlSowNChQxk2bBjffvstI0aMwFNOGFqH0ai1zJowQUtOfvoplChh7ajuydHRkebNm3PixAm++uorxo8fz9SpU5+43+Xp6el88803FC9enDp16thWm5PAQO0y5fBwqF9f+9vPT+u1mZioJbVteL+u0+l47rnnKF26NPv37ycoKIgKFSrQtGlTAgIC8PX1xdvbO8vNy8sLJyenJ+L7yobWFPG4GI1GlixZwubNmylQoADVqlUjNDQUX19ffH198ff3x9XVFXt7e/R6PXq9HgcHBxwcHNDr9Tg6Olr+vt/ORlVVBg4cyMGDB1m4cCFVqlShSZMmNnXmJifp6enMmTOHggULUr9+/Sfui0Hknbi4ONasWcP8+fOJiYnh2LFj/PTTT3Tq1Al3d3erxVWuHJw7px1o6HTabzBr/x5wcYEyZbQkup2dVFrfi8FgIDo6msKFC6MoCqmpqfj7+1v1x4Q5aR0cHCyV1iKLv/76i379+nHw4EFLBYeTk5PlMkN3d3cCAwMJCgoiJCSEoKAggoKCCAwMJDg4+KHabS1btox58+ZRvXp1unXrhoeHRx6/u0cXEhJCgwYN2LlzJ2vWrKF3797W2YZPnYKxY7WeUX36aAdcY8bA5s3apdCvvCJtQYRNURQFLy8vfHx8uHz5MpmZmTaZtAYICgrC3d2dM2fO0LBhQ/z9/bGzsyMyMjJPBqHKC+np2hV5u3dDUBDUqKG1+F22TLso42lMWmdmZrJ8+XKuXLlCr169CAkJ4cqVK5w/f566devm2vGpqqocP36cvn370rJlS/r27curr77K+vXrWbZsGQ0aNKBp06ZPxPHwU0VV4dAhrcI6LQ3mz4dKlawd1QPx9PSkd+/e/PXXX/z4448ULVqUgQMHPhEJRzNzy9XOnTtTqlQpa4eTVUCANkj1+fPa/+3stJ2gvb3WIqRIEevGdx+qqhIbG8uff/5Js2bN+OijjwgMDLS0N7LV79IHZdPfqOam4bf/feegf6qqkpqaiqIoeHt7P1EbrjWoqsqRI0fYs2cPJUqUYNu2bTg7O2NnZ4dOp7Pccms5KopCcHAwY8eOpWPHjsycOZMyZcrYfNWyqqps3LiRP/74gx49elChQgWbjlfkPaPRSHx8PP/73//4+uuvCQ8PR6fT0bBhQ/7++2+GDx/OkSNHGDduHAEBAVb5IbptG2zdCt99pw3EePiwlpewZq7RzQ1q19auuNLrYccO68Vi62JiYjAajXh7e1sGBLLWumQm7UFEdtLS0liwYAH79u0jNDSURo0akZmZydWrV7ly5QoXL14kPT0dRVEsN/NvC0VRsLe3x9/fn5CQEMLCwggJCSE0NNTyb758+SyXaZ8+fZoRI0bg7u7OmDFjCAsLs+nvY3t7exo1asSSJUv48ssveeeddx77tmOIi8OuZ09IS0Pp1087KF+5EmbPhpIlYeRIaQsibJKHhwd+fn5cunSJzMxMmy0YCQgIwNXVlTNnzgD/xn358mUyMjKeiKQ1aL/RXF216uqSJbWcXkaG9u/Txtxm6quvvqJKlSo0btwYOzs7Pv74Y7Zt28b06dNp0aJFrs3Pz8+PgIAApk6dSsOGDalcuTKDBg3izTff5JtvvqFixYp5VuUtsqGqWuXM+PHw998wcybUqWPtqB5KUFAQX3zxBS+++CIzZsygTJkyT0wxoMlkYtasWbi7u9O6detcvRovVwQGapVW4eH/3hcQkLX62oaZTCZWrFiB0WjkxRdfpHTp0k/EevGgrPKNqqralRmZmf/+m5mpXTaekfHv/SbTVW7eDCcmJpqYmBhu3LjBrVu3iIiI4MaNG8TFxREZGUlsbCzDhg1jzJgxebbjN4/8C9olGk+qzMxMVq9ezeXLl5k5cyY+Pj55/mWpKAo1atSgb9++jBs3joULFzJ06FCb/SEKWpX1559/TnBwMO3atXuiP3Px6FRVJS0tjYiICLZt28ZXX33FyZMnCQ4OpkOHDrz//vsUL16cv//+mzFjxrB8+XJ27tzJ1KlTqV27Nh4eHo/9x2jFilrSunFjbV9qTTqddmWVTqfd9HptkEiRvcjISBRFwdfXl+TkZKtXWquqisFgsCStbXmfLR4fg8HAypUrWb58OVWqVGHVqv+zd9ZhUaXvG7/PDAMM3d0IiEqIAYqKYmCyBnZ3Yazrmmvi2t3did2NigoWYhcrFt0Nk8/vj/NjVr/r7uoKzKDnc13nGhjjPBPnPe97v8/z3Cf+UuZc2u8/OTkZiYmJSEpKQkJCApKTk5GQkIC0tDQUFRUhPj4ez58/Vxg8l5o/y+VymJqawtLSEpmZmUhNTcWaNWtQt27dSrHAr169Opo0aYLVq1fj0KFD6N27d4Wdu7CwEGsXLoR/Tg78evQA06MHm3U9dy6bObRyJdvPuhK8jxw/Hvr6+jA1NcXbt28V6y5V5ONMa4AVrc3MzPDu3TuIxWLl9bL/Svh8oG1b4N494Pp1oE4dZUdUfsjlcixYsAASiQQdOnSAvb09oqKiFPeyBmUoYDIMAxsbG/Tv3x/379/H9OnTsX//ftSsWRMDBgzAwoULcfToUQwZMqTSbHBUaoiAvDzWePHyZWD8ePaLr6ZWqe6FDMPA0dERGzZsQEhICObOnQtbW1u4u7urvED5+PFjXL9+HZ6enggICFB2OH/l4/YgpZSK1q9fKy+uL6SgoADbtm2Du7s7/P39Vf778LVU+Cj5+DHw9CmbBZiVxbaIyclh28Xk5QGZmX8+b2OzFfHxyyEQ8BXOvB+79Nrb26Nq1arQ0dGBh4fHf17IyGQyiEQiRT9nkUiEoqIiFBYWQiQSobi4GAUFBUhOTgafz0dAQAA8PT3L9H2pKF69eoXLly/Dzc0NLVu2rJBzMgwDLS0tdO7cGdHR0Vi1ahXq1q2LoKAglV18nj9/Hg8fPkTHjh0rzSKZo+woFaufPn2Kq1evYv/+/Xjx4gWqV6+O0aNHo0uXLvD09FRMNKtWrYrVq1dj+/bt2LlzJ3r16oWhQ4eif//+cHZ2LveSHKmUFYXV1Fix+swZ4MED5WfKCARsuWl6OmBjA+jqslnXHJ8nPT0dPB4PJiYmivuRm5ubUsef/Px8SCQS6OrqcgsrDsjlcjx9+hTr1q2DtrY25s+fDz09PeTl5SE6OholJSXQ0tJSeF/o6enB0tJS0RO99Lssk8lQWFj4iUlMRkaG4vdSg7P8/Hzk5ORAR0cHwcHBleZezDAMunbtiv3792PTpk0IDg6ukP6lYrEYR44cwbLt23HFwwNHp02DelYWaPVq8N69Y9uD+PlVqkU6x49Facbyo0ePVFq0Njc3h46ODl69egUigq6uLkxNTfHhwweVjvtzWFkBvXsD69YB1tbKjqb8uH//PsLDw1GrVi20b98e+fn5WLlyJRiGwdixY8t8jGYYBk2aNMFPP/2ETZs2YceOHQgNDUWnTp0QERGBBQsWICAggDNlrAjEYtaUePNmtgR14EB2UVIJYRgGDRs2xNSpUzF//nysWLECYWFhMDMzU9k5kkwmw+7duyESiTBgwADVTIIxMWGNF9+8YbNn1dTYnudt2wKOjsqO7l85ceIEkpOT0blzZzhWgni/lnJbgWZns62CSlvBSCTscwcPAkuXsmOHgQFbnainx2bf6eqyGxqGhuxzLi7tIJXaQktLqDD709HRUZj9lf6uoaHx2d0EiUSC/Px85ObmIi8vD3l5ecjNzVX8XvpYKg7k5+ejoKBAIVLn5+crDArz8vIgEonA5/PRrl07bN26FYaVLGVQJBIhMjISz549w9y5c6Gvr1+hg5uTkxNGjx6Np0+fYurUqXBycoKrq2uFnf9LycvLw6ZNmyAQCDB8+HAuy/oHQywWIyoqCidPnsSVK1fw7t07eHt74/fff1dMLj9nAGZiYoKxY8fC19cXa9euxaZNmxAbG4sRI0agZcuW5fI9ksnYe+upU2yGtUzGJtD5+bHmOrm5rBdXYSG7UVzRSKXsmC+XAyNGAAkJwMOHrB8Yx1/5ONO69F6k7J7Wqamp0NTUVErVAIdqQUTIz8/HihUr8OrVK8ycORM+Pj7g8Xj48OEDxo8fjw8fPkBXVxdGRkbQ1dWFnp4edHV1YWhoCH19fYX5i4mJCYyMjGBkZARra2t4eHgoelyXtoErFayXLl2KLVu24MSJExgwYICy34YvxsvLC02bNsXx48dx8eJFhISElOv5iAiPHj3CmjVrYGBggFlz5kCupYXTO3dC5+ZNNOjdG2oVmPHNwfFf0NPTg6mpKd6/fw+RSKSypoalY9n9+/dRUFAAXV1dmJmZ4caNGxCLxcoO719JSPjUqDsoiE1AXbtW+QkP5UFhYSGWLVsGsViMESNGwNzcHEeOHMGNGzfQrFkztGjRolzOq6Ojg2HDhuH69etYvnw5/Pz8UKtWLfTv3x+//vorZs6ciW3btkFHR6dczs/BVof9cfIkXJYuBd/Xl82ytrFRdljfBJ/PR9++fREfH4+DBw/Czc0NI0eOVE0xGEB8fDyuXr0KGxubMm3BU6ZoagJjx7JutFIpa1hNBEycyC6uVZji4mJs3rwZRkZGCAkJqfT9qz9HuYnWp04Be/cCa9awmxOpqayBuZcXcPIkm+Shqflnn1MNDUBdnT3+fM4HDOPzl4QQqVSK7OxsZGZm4uXLl8jMzERMTIxisVRUVISMjAzk5uZCJBIpDrFY/Nmf1dTUFCaERkZGMDU1hYuLC4yNjWFiYqJ4XigUYuLEiYiMjMSBAwcwZMiQSpV6n56ejsOHD8PV1RWNGjX6rPBWnpTuDA4fPhwzZoRh167nmDTJVSli2j8RERGB+/fvIygoCLVr11Z2OBwVhEgkws2bN7Ft2zbcvn0bycnJ8PPzwy+//AJfX184ODiAz+f/4+JJTU0NDRo0gKOjI/bv34+VK1di9OjR6N69O6ZMmVJmJo1E7IJjyxbg9GkgLg7o0oXdHFRTAwIC2N7WGRnAoUNsr+uJE1mjxoqEiB3rk5LY0lOJBCgurtgYKhOlmdaq0h4EYIV0DQ0NlTa+46g4tmzZgqNHj6Jz587o2LGjYoFkb2+P5cuX482bN4oWbikpKUhJScGrV6+QkpKCkpIShUljacWcpqam4ndjY2OFWaONjQ38/f3h7u6OoUOH4uDBg9i0aRM6depUIRnLZYGamhpCQ0MRHh6O8PBwtGzZslyFiYyMDKxatQqvX7/G4sWL4eXlhfv372PcokUIcHVFtSFDYKary2VZc6g0GhoaMDU1hVgsRmpqKmxtbZUd0mdRU1NDixYtYG1tDYlEohDbExISUFJSorJiu1gMnD0LrFgBNG785/OamsCvvwLt2rFr8YICdp5pbs5WzVV2Ll26hGvXrqFJkyZo2bIlUlJScPDgQRQWFmLixInlmqDk5uaGiRMnol+/fliyZAnWr1+PTp064eLFizh9+jT27t2LIUOGlNv5f2SICKdPn8biWbMwsEoV9Fu4kHWHr+SUermNHDkScXFxWLx4Mdzd3dGqVSuVHHciIiIQHx+PcePGqXbSZ+vWwJMnwIABrCGjXM6Kku3asYK2iiYyRkZG4unTpwgMDKy03SD+jXITrdPS2DYgW7cC06ezN8mEBLbfvZ8fK2aUHgD7KJezIktCAity5+Ym4P37cKSlJSrKRdPT05Geng6pVPqJKaNMJkNJSYmifFkul0MgEMDQ0FCRyWNlZaUQoa2trWFubg5zc3OYmppCIBCAx+MpDAn/97HUQGj//v1o1qwZtmzZAh8fH9SpU0clB4f/RS6X486dO4iOjsbkyZPh5OSklLjV1dUxYsQIvHjRCJs2ecDKChg6lG1toArk5+fj2LFjyMrKwi+//MKVw3/nyOVyiMVixMTEYOnSpYiMjERBQQF8fX2xZMkSNGzYEDo6Ov8qVn8MwzCwtrbGqFGjULt2bUyYMAGrVq3C7du3sWzZMtSoUeM/mZ2WegEkJLDj6tatbGslc3Ng6lSgRw9WoNbVZaub+vUD7txhexQeOsS2Zpo1C2jVir3nlufl//HYbmYG+PgA164BVaqU3zm/B9LT0z/paV1UVKR00To1NRUaGhpltuHCUTkhIty+fRtz5syBi4sLfv75Z5iYmCj+XEdHB4GBgZDJZH97FBUVITExEW/evEFSUhISExORmJiI+Ph4vHr1Cvn5+QrDRkNDQ8yaNQvu7u6oWrUqWrdujePHj+Ps2bPo2rWrSs+76KM0RU9PTzRt2hSxsbGIjo5G06ZNFbGX5WuQSqU4dOgQDh06hCFDhiA4OBglJSX45ZdfUCIWo0X//jB2dVWdyRYHx9/AMAzMzc2hra2NuLg4lU4eGThwIORyucJo1djYGESEx48fw9bWFmpqagrzWWVSOif78AFYuJCtgCspARo2ZLOtS5PybGyASZPYiuhjx4ATJ9iEhy5dVFar+SIyMzOxf/9+ZGVlYerUqdDQ0MDNmzcRERGBPn36oEaNGuV6fh6Phw4dOuDIkSOIiIjAwYMHMWjQIMyePRuXL1/G2rVrUb9+fVSvXl3p35XvCSJCbGwsFi5ciKcfPsBl9Wq2LPU7eY95PB7c3NwwduxYhIaGIjQ0FBEREbC3ty+X7xER/eWQy+WQSqX48OEDXr9+jT/++AO2trZo0aKFYpM+LS0N165dA8Mw6NmzZ5nHVaa8ewf07MkuXDdtYts/3L7NLrTz8oCwMJX7/shkMhw4cABFRUUYNGjQd9shoFwVue7d2VKjoKA/e2S9fw/ExLCbF+np7JGayj5mZLA3VTU19nBxyURS0howTBHU1NQUR2lpqampKczMzGBmZobCwkJoaGigTp06cHFxgZmZGQwNDb94svClF7ejoyMWLlyIwYMHY/369bC3t1fpHkKlFBYWYuXKlXB1dUXz5s2V6tiqqamJKVNqIyKCwaZN7P3D11f5aykiwq1bt3Dz5k20b98eNWrUUPnPleO/IZFIkJ2djQcPHmD16tW4cOECDAwMUK9ePYSGhiIwMFBRWvNfvgMMw0BDQwMBAQE4ffo0ZsyYgfDwcLRt2xaTJ09G165dYWho+EWVGkSEgoIifPiggd271bBjB9vuw8aG3fTt3ZsVhgFg9OjS87P3Wx8fYPBgoH59YP58oH9/dpNo+HDA1rbsrzkiNps6IwOIjGQNfXg81nD58WPg/n12c1IiYf+uqhlHK5vU1FRFT+tnz54pPdOaiBSidWXJbuUoe4gI79+/x8iRI6Guro7ffvsNVatW/eR7WTrX4vF4f1vFRURwcHCA/2ca28tkMmRnZysMG7Ozs1GrVi0AbBns2LFjceDAAYSHh6NNmzYqu4kil8vx7t07JCcnw9vbG0KhEKNHj0bbtm2xceNGSCQSWFtbQygUQiAQQCAQQF1dXfFz6fE1VXxEhDt37mDy5Mnw9fXF4MGDoampifHjx+PBgwcYM2YMgoODv8tyUY7vEwsLi0/6RavqXFwoFCoSpx48eIArV65AR0cHPXr0QMuWLdGnTx/Url0bxsbGn/T0r0iI2ASHyEi2pf3r12zy2Jw5QO3abBX8x+1AunYFOncGIiKAixeBQYNYX7JRo9iECBX9KP4WuVyOK1euIDIyEn379oWnpydSU1Nx4MABCIVC9OvXr0I+G4FAgLlz56JZs2bYs2ePQqSeOXMmJkyYgA0bNmDu3Lkqe2+rbBAREhISsHTpUjx9+hRLly6Fr7+/8sWGMobH46Fly5YYM2YMZsyYgSFDhmD37t0wK10YfiWl45lYLFZ0JSh9zM/PV4jT8fHxiuP9+/eQSqVQV1eHuro62rdvj/r160NHR0fRtuzWrVvo3Lmz0hNx/hEiYMMGVoRcu5YtPwGAjh3ZgXLCBFbQdndXbpz/w4MHD3Dnzh1Uq1YNgYGByg6n3ChX0drSEggNZQ3LZ8xgn0tJYbP+srIAoZD9PpiYsAKKUMj2uTY0ZB8tLR2hrb0EBgZaMDIygqGhIQwMDL5KjC5r+Hw+mjVrhr59+2Lfvn3w9fXFgAEDKrzVxtdy+3YcHjx4iF69esLT01OpAwbDMLC1ZSdMY8awvghOTqzwpsxxrKCgAJcvX0Z2djb69eunVGGfo/wQi8WIjIzEqlWrEBERASsrK3Tr1g1dunRBQEAAtMuwXw3DMDA1NcXKlStRv359rFq1CjNmzMDjx48xYMAA1KpV62/FCSJCdnY2njx5glOnLuPmzTZ48aIuatZkq5S6dWOzrP/+3OyjmhrrN1K9Ops9s3Ytu2k8eTIrZpdFtXqpWP3iBRAdDRw4wG5OzpvH/rm2NhASwmbs2NsDhw+zwnvbtuxrqOjrXiKRIDk5GQBgY2OjMm2ePm4PUlBQAJFIBBMTE5VoD8ItpH5csrKyMH/+fMTFxWHcuHFo27btf97M+zvU1NRgamoKU1NTeHl5/eXP3d3dERQUhAcPHiAqKgotWrRQuYVP6Zg9b948REdHY8uWLahTpw40NDSgra2NK1eu4MyZMyguLoa2tjZMTEwUFX8fJ2JYWFhAT0/vE+8WLS0txe9CofCT1x4fH4+ff/4Zenp6CA0NhYuLC/bs2YNdu3YhMDAQo0aN4uYzHJUKMzMz6OjoIC4uTtmh/CsikQinT5/GvHnzkJSUhBYtWqCkpAQvXrxA3759Ub16dfz000/w8/ODu7t7hYo2xcWsKfeOHcDu3exaa8oUthLP3JxNKoyIYP2ngoL+zKbm84FmzdjKvTlzgEWL2KSzCROAylawkZaWhmPHjkEgEGDAgAFQU1PDrVu3EBERgcGDB6NKlSoV8nmwa19b/Prrr5g2bRrCw8MxYcIE9OzZE+fPn8fp06fRvHlztG7dmqvy/UZK/TfWrFmDc+fOYcSIEejYseN3+74yDIOhQ4ciLi4OO3bswNKlSzFp0iQYGBj87b8hIhQXFyM/Px95eXmKx9zcXGRkZCAxMVGRRFD6c3Z2NtTU1BReJXp6erCwsIC7uzssLS1hbW0Na2truLu7K85dVFSEmzdvIjc3F8HBwYqqFJVEKmV7WTZsyAqUH48LQUFsplhsrEqJ1lKpFBEREfjw4QOWLl36XScnlPvV+9NPwI0brFmrhgbg5sbeAHk8VizR1mZvijo67MHjffwd0QPQHnK5HMXFxYoL6c2bN8jJyUFBQYHCYLGgoAC9e/eGdQXYHhsaGmLQoEF48OCBom+gr6+vyi2gSikqApYvN4KV1Vx06VILWlpayg4Jamrs9d+jB9v7vFYtYMgQ5ZWfERFev36N48ePIzAwEN7e3iojZHGULXK5HA8fPkRqaipGjhyJFi1awNfXt0zF6v9FTU0N3bp1Q/Xq1bF582YcPHgQ9+7dw7Bhw9C5c+dP+gUTEbKysnD58mVcunQJly9fRn5+IUJCrDFoUB00bszAzu5TA51/Pz/g789mZ+/bB6xfz2ZcDxwoRd++ctjYCP7z+CWRAI8esWWkFy6wwrWbG9sbsW5dtjWUQMBmfffsyS6ijhxh+2zfusVm73h4VMwiSC6XIyUlBSdPnsSZM2fAMAz69u2Ltm3bqsTGY6kRo56eHvLz86GhoQEtLS2VEK25ntY/JiUlJTh48CCOHDmCVq1aYcyYMUq5N/L5fAwbNgxdu3bFpUuXUL9+fZXbSJHL5di5cyeOHDmCLl26wMHBAWlpaZg1axaEQiEGDBgAKysr5OTkICcnB1lZWcjOzkZWVhYSEhKQmZmJnJwcFBUVQSgUwsDAAHp6ejA0NISenh709fWhr6+vSN4wMjKCpqYmjh07hocPH6Jv375o1aoVoqOjsWTJElhYWGD27NmwVHEDIQ6O/8Xc3PyTTOtS5HK5SrTbKCU1NRWbNm3Cxo0boaenh7CwMHTq1AlqamqIjY3FzZs3ERkZiYULFyqq+Ro2bIiAgABUqVKl3ES0Ut+TffuAXbvYhLF+/dgs6rp12VZzR44A27cDUVFs+9ZGjT5dgzEMm5G9YgWwZAmwfz/b+nPSJPb5yqD/yWQyREVF4cKFC+jfvz+qVq2qMBO2srJCu3btKvQ+oq6ujuDgYERERGDnzp0ICAhAQEAAxo4di8GDB2Pz5s3w8fGBtbW1ynzHKyNyuRwbN27Epk2bEBQUhKFDh/6jgPs9oKGhgalTp+L9+/fYtWsX3Nzc0L1790+MGbOzsxEVFYX4+HikpaUhKysLmZmZnxxZWVmQyWQwNjZWdDPw8PBA06ZNYWxsDH19/U984Er/3ueqFYgISUlJOHz4MOrVq4dq1aqptrYiFrMZVR+1vlOgpcVm1+bkVHhY/0RiYiKuX78OS0vLcjOTVRXK/Zajrs5uTPTsyWZP9+zJZvcBbJl4URGbdf36NfuYlcWWlpf+XFj4KxITn6OoqAglJSWKMoXi4mJFuUJJSQmkUil8fX0rRLRmGAbu7u4YNmwYxo8fj8mTJ+PYsWMqWz598SJw86Y92rUbgrp1VccS2tCQLTt78IDdxffzY8VrZdynxWIxTp06hYyMDLRt2/aTXp0c3xcaGhro2bMnWrVqBXt7+woTBdXU1ODt7Y2ZM2eibt26CAsLw5QpU3Dnzh2MGzcObm5uKC4uxokTJ7Br1y7ExsZCJBIhKCgIffv2hYeHB8zN/7u4yzCAgwPbQqRePWDhQsL69Y/w6tUODB3aBX5+fl+1Q1sqVm/fzpad/vEHUKMGuykZEMD2r1ZXB5yd2Q1rHo/NDheJWAHdzAwID2dbhowaBfTtW77CdVpaGnbt2oXjx4/j+fPnyM3NBQA8fPgQDx48QGhoKExNTcsvgH9BIpEgJycH6urqEAqFyM3NhaGhodLF9NL2IJxo/eNBRHj48CHWrl0LBwcHTJ06VakLP29vb/j7++Py5cvo0aMHatasqbRYPkepOOXm5oYRI0bAwMAA48aNw+3btxEaGopff/0Vurq6kMvlEIlEinltcXExiouLFb8XFRUhJycHiYmJSElJQVpaGtLS0vDkyRMkJycjOztbMU6oqakhKysLUqkUUVFRWLBgAZ4+fYqEhARs3LgR3t7eyn5bODi+GnNzc+jq6uL+/fuQyWTg8/koLi7GkiVLoK6ujq5du8Le3l6pMb548QK///47jh8/jpo1a2LOnDmoU6eOQiRq0KABfH190bVrVzx9+hTnzp3DwYMHcebMGTg7O6N+/fro1KkT/P39yzQ7Ti6X49y5R1i71hNRUTx4erLzsoYN2XVXfDwrRB8/zpothoYCvXqxSWSfw8mJ9UNxcACWL2fnkL//DrRo8XXJExUNEaGwsBBr1qyBubm5QqDeunUr7t+/jyFDhqBmzZoVLg5bWlqib9++iI2Nxdy5c1G3bl3Url0bvXv3xvLly3Ho0CGMHDlS6XO/yszevXuxePFiuLq6YvLkybCzs1N2SBWCubk5pk+fjkGDBmHZsmVwd3dH3bp1FUJxqVlzdHQ0ioqKoKGhAUtLS9ja2sLDwwN2dnawt7eHnZ3dX6q9Squ8vkR0lslkyMrKwt27d7Fr1y48f/4cXbt2Vf0NdHV1NsP2c8K0RMIaAZSjmfbXQkR48uQJbt++jaFDhyq9MrfcoXJi6VKi5cuJRCIisZhowwYiHx+iq1eJRo8matCAqEoVIisrIgsLIlNTImNjIkNDIj09Ih0dIi0toipVGpKGhgYZGhqSs7Mz1a9fn0JCQmjo0KE0depUWrNmDYWHh9P169cpLy+vvF7OZykuLqZRo0aRtrY2jR8/nmQyWYWe/0soLiZq25ZIW5vo5k1lR/NXpFKiPXuILC2J6tUjys+v+BjkcjmlpqaSg4MDNW/enP7444+KD4Ljh0IkEtGrV6+oXbt2pKmpSW5ubjRgwADy8fEhAwMDMjIyogEDBtCdO3coJyenzMcWmYwoMVFM06ZtJ2NjE7KxsaH169eTWCwmuVz+t/9OLpeTRCKhhw8f0ogRy8nHJ4uEQqK6dYnCw4nS04lKSoj+4b9QnD8nh2jLFiJbWyIDA6IhQ4iSk//9334pcrmcZDIZJScn07Jly8jd3Z10dXXJzMyMJkyYQI8ePaLr16+Tt7c3aWtrU8uWLSkmJoZkMtk/vgflgVwup7S0NKpSpQp5eXmRSCSiW7du0a5duyg7O7tCY/kYqVRKjo6O1KBBA8rIyFBaHBwVj1wup4yMDAoODiZzc3M6cOAASSQSpcYkkUho9+7dpK2tTatXryaRSKTUeEqRy+WUmJhI3t7eZGZmRidOnCCJREKbNm0iY2NjCggIoMzMzK/6/6RSKZWUlFBBQQHl5uZSZmYmpaamUlJSEsXFxdGVK1do9+7dNG/ePBo5ciRVr16dBAIBaWlpkZaWFk2ZMoUKCgoqfCzj4CgL5HI59ejRgzQ0NOjNmzdERPTw4UOqW7cu6ejokK2tLY0cOZJiYmJIJBJV2H279NqMjo6mhg0bkqamJvXq1YuSk5P/cZ4mk8koPz+f4uPjafny5eTp6UlaWlpkbGxMTZs2pX379lFOTg5JpVKSy+Vf/VpK5zupqak0atQosrLyoHr17tCkSURv37JrraIiov37iby8iIRCosaNie7dIyos/Pd5l1xOVFBAtHUrkZ0dkYkJO3+TSstuzlbWyOVy2rNnD2lpadHYsWOpuLiYsrOzqUqVKuTi4kKxsbFKGx+Liopo9OjRpKWlRUuXLiW5XE4vXrygxo0bk5mZGb169UopcVV25HI5Xbp0iapUqUIWFhYUHR2tktpMeSKRSOjAgQNkaWlJzZs3p7S0NMX3PDc3l44ePUonTpygJ0+eUEJCAqWkpFBGRgbl5uZSYWHhX9aBpeORTCYjmUxGUqmUJBIJicViys/Pp5cvX9KZM2do5cqVNHr0aGrTpg1Vq1aNrKysyNDQkAQCAdnZ2dHx48dVfz4ilxONGUPUsCGRRPLn4CaXE128yC5Y799Xaogfk5OTQ2PGjCFLS0uKjIxU/ff3Gyk30fr5c/aQydjPOjub6Pp1orQ0ojZt2JuekxN782zWjKhXL6KffyaaN4+9EZ46RXTrFtG7d2lUWFhIUqmUpFKp4qIpPUovpv9yk/9WShd1derUIQsLCzp69ChJpdIKjeGfkMuJjh8nsrEh6tBBdScWYjG7kaGlRTRpEit6VSRyuZzmzZtHurq6tHDhwu/+oudQDeRyORUWFtKiRYvI3NychEIhWVpaUu/evenevXufjG/ldX6RSESHDh0ib29v0tDQoE6dOtGzZ8/+IgZJpVLKysqi69evU48ePUhTU5OsrV2pU6cjdPjwly16/np+9njwgKhJE3aj0s+P6PJlMRUX/7N4/m+vq7CwkF6/fk1LliwhV1dX0tHRIUdHR5o0aRK9f//+k/c2KyuLxo4dS0ZGRuTg4EA7duygrKys/3Tu/xKrWCym1NRU2rRpE5mamlKNGjUoOTmZJBJJhd/XSjclxGIxEbGTXx0dHWrWrJniOY4fA5FIRDNmzCChUEiTJk2i/Px8pd8b5XI5PX/+nBo1akT169enxMREpcdERJSXl0cDBgwgbW1tmj59OslkMoqOjiYPDw+ysrKi58+fl2mc/zvvlclkVFxcTKNHjyYAFBQURPHx8Srx3nBw/FdCQ0NJU1OT1q1bpxBSEhISaOXKleTl5UVGRkako6NDTZo0oX379tH79+/LfaMmPz+f9u3bR7a2tmRhYUFLliyhwsLCLzrnx9dsXl4enThxgtq0aUNWVlako6NDLi4uNGvWLHry5AllZWV98XpSJpNRdnY2HThwgNzd3UlHR4cCAgLo2rUbJJMRFReX0MuXMurXT05aWkTOzkQLFhDl5X3dvE0uZ9f0Z88SeXiwwvekSUQZGaq5vszNzSV3d3eqVq0a3b17l6RSKYWFhZG2tjZNmzZNqeOjXC6nP/74g7y8vMjU1FQhoG/bto1MTU0pODiYioqKlBZfZUQmk9GjR4+oQYMGZGBgUDlE0nKgdA00Y8YM0tHRoTFjxii+S/+kmZVuyBUVFVFubi6lp6dTYmIivXnzhh4+fEjHjh2jJUuW0MiRI6lly5bk4uJCWlpais1yfX19MjExISsrK3JwcCBfX19q2bIlBQcH09GjRyvP5sGDB0RubkRz5hC9f0+UmMju7vn5EQ0dyg6CKkDpfNjR0ZF69uxJycnJyg6p3Ck30fqfePuWKCGB3fX9Hrhx4wZZWlpSQEAAPXv2TGUGyZwcosGDifT1ia5dU81JRSkpKUT+/kQODkTR0RV97hRydnam2rVr08uXLyv25Bw/PPn5+XTw4EGaMmUK3bt3Tynjx5MnT6hPnz5kYmJCXl5etGvXLsrIyCCZTEbv37+no0ePKv7czs6OOnToQHv27CmzLODsbKKpU4lcXSVUs+Z5WrFiG7179+6r3gu5XE7Z2dkUHR1NYWFh5OLiQvr6+uTv70+zZ8+m169f/+3/V1BQQDt27KA6deqQjo4ODRs2nB49ekpicfl9FhKJhF68eEE7duygli1bkoGBgUJgb9q0KZ05c6ZCq4fEYjE9e/aMdu7cSRcuXCCpVErp6emkrq5OHTt2rLA4OJSPTCajEydOkJ6eHrVs2ZLi4uKUHZKCkpISmjVrFmlra9OhQ4eUvhAqLi6mtWvXkpmZGbVv354KCwspISGBevbsSaamprR79+4KiVEul1N0dDSZmprSsGHDviqzm4NDFZk2bRoJhUJycnKi7du305MnTxQCcV5eHu3fv5969OhB1apVI01NTapatSpNmTKFLl26RImJiWWaRCSXy+nDhw80a9Ys0tPTIx8fH9q3b983C4symYzu3btHU6ZMoQYNGpCpqSmZm5tT37596dChQ/Ts2bN/PIdYLKbo6GgaNmwYmZqaUrVq1WjmzJmUmZlJUqmU3r59S6tXr6O6dd+SqamcevViE8K+9a2JiSFq3pytkhs0iOjFi2//P8sSmUxGixYtIi0tLZo4cSLJZDJ69uwZVa9enVxdXSkhIUHZIRIR0a5du0hfX59CQkIoIyODCgoKqFevXqStrU0bN25UqUQ4VSchIYG6detGJiYmtHTpUqVXhimbDx8+UKdOnUgoFNKGDRsUyUgymYwKCwspJSWF4uLiKDY2liIjI+n06dO0Y8cO+v3332n48OEUHBxMPj4+ZGZmRnw+n4RCIZmZmZGzszN5e3tTw4YNqU2bNtSvXz+aPHkyrVmzhk6cOEExMTGUnp6u9LnZN3HqFFHLlmyrgq5diZo2JRo5kt2hUxGkUimtWLGC9PX1f5ixgiEi1WlyXEmRSqVYsWIF5s2bh379+mHKlCkwMjJSakxEwLVrwLBhbJ/Z7dvZfmWq3OomKgo4cwYICWGNWTU02NchlbJ9cMsr/kWLFmHWrFkKR2eVNgng4CgncnNzsWfPHmzevBlJSUno0KEDHBwccPv2bURFRUFPTw/NmzdH8+bNERgYWOY9jktKgGvXCrFx43xcvboWTZo0wfDhwxEQEPCPZkX0/30Lr127hvPnz+PChQtITU1Fo0aN0LJlSzRt2hROTk7/angklUpx//59bNu2DQcOHEbTpivRtm1XBAczMDQsu9cplUoRFxeHM2fO4PTp07h//z7s7OzQpk0b+Pn54eHDh9i1axdkMhn69u2LgQMHlqspT0lJCR4+fIgLFy7g8uXLePToEYYNG4bJkycjLi4O/v7+6N69O7Zu3Vou5+dQPe7du4dBgwYhNzcXmzdvRtOmTZUd0idERUVh8ODBMDExwblz55TmRi+XyxEVFYXQ0FAIBAJs27YNjo6OWLlyJZYtW4a+ffti+vTpFWb0lZGRgfHjx+PGjRvYu3cv6tSp8333N+T4romLi8P06dNx5coVFBYWwtPTU2FcV69ePejp6aGgoAAPHz7EjRs3EBkZiTt37kBdXR3+/v6oV68eGjVqBC8vr28yPJRKpbh79y5Wr16NY8eOoUWLFhg3bhzq1atXZkaKUqkU79+/Vxg3XrlyBampqfDx8UGjRo3QoEED+Pv7Q1tbW3FNv3//HgcOHMDevXuRlJSE4OBg9O3bF35+fpBIJDh//jx27tyJK1euIDh4EZo2HYg2bRgYG397vETAmzfAwoXA0aOAry8wdSpQp07FmGr/G8+fP0e3bt0gEolw9uxZWFhYYM6cOVixYgUWL16MoUOHqsTYKBKJMGTIEJw5cwZz5szBgAED8PLlS3To0AFaWlrYvn27ynk3qCqRkZFo2bIl2rRpg9WrV8PMzEwlPmNlcv/+fQwaNAhpaWkYPXo0dHR0kJGRgczMTGRkZPzlICKYmJjAxMQEpqamikcjIyMYGBgo/qz0MDY2VrpZfLlABKSmAq9esQKUmRkrTAkEKiOk5efno2HDhhAKhdi8eTOqV6+u7JDKH+Vq5t8HcrmckpOTqXfv3mRhYUEHDx5U+g5fXh7RlClERkZEJ0+q1g743yGTsVn4kycTrV3L9k+Ty9kd/Zkz2fZCZXMeGWVmZtIff/xBZ86coerVq5OdnR29e/eubE7AwVEJkcvlVFxcTMuWLSOGYUhTU5OEQiHxeDxq2rQp3bhxg7Kzs8s1E1wikVBcXBzNmjWLDA0Nyd3dnebPn0/p6emf/fslJSV07tw56ty5Mzk6OpKBgQG1b9+eDh8+TG/evPlPO89paWm0Y8dhqls3lywsiEJD2XHpW1+2VCqlx4+f0YQJExR9Ob29vWnJkiUUExOjaL9QVFRE586do5YtW5KRkRG1atWKoqKivu3kn0EikdD9+/dp7Nix5OHhQRoaGlSrVi1asWIFvXz5kpKTk6lPnz6kpqZGPXr0KPPzc6gmSUlJ1LVrV9LU1KTNmzcrfS7zOYqKimjgwIGkra1N58+fV0oMpfO+9u3bk7W1NYWHh5NYLKYLFy6QlZUVtWzZkl68eFGhlTNSqZT2799PpqamFBYWRsXFxRV27rLg1atXNHHiROrYsSP9+uuvtGLFCtq3bx9FRETQkydPKCMj44fIJuL4k3fv3lFERAStXbuWmjVrRvr6+uTs7Ext2rSh5cuXK9rgSCQSio+Pp5MnT9Lo0aPJzs6O9PT0yNvbm0aMGEERERFUWFj41ecXiUR09OhRqlu3Lunr69OUKVPKtfVOadvJmzdv0oIFC8jX15d0dXXJycmJ2rVrR2vXrqW4uDg6ffo0tW7dmnR1dalOnTq0b98+Sk1NVbRQGT16NDk4OJCtrS3NmjWLnj9/QTJZ2cYsl7NVsmFhrC+Rjw/bOkTZVb1isZimTp1KWlpatHLlSpLL5XTr1i2qWbMm+fv7U1pamnID/IjSEn93d3fy9/enhw8fklwup61bt5KWlhaNGDFCqb4mlYnIyEjS0tKiPn36cB4s/49cLqcLFy6QoaEhmZubk56eHvH5fNLS0iJXV1cKDAykPn360NSpU2ndunV05swZun79OsXGxlJcXBwlJydTQUFB5c6a/k45evQoaWtr088//6wy/i7lDSdalxEymYyuX79Onp6e5O7u/tWl7WWJXM72E69alah9e6IPH5Q/ifhSEhKIOnZke53fu8cK2ZcuEXXqxJp6lvZUKz2k0j8PsZg1gnvyhOjKlSd04EA4LV++nKZOnUqDBw+m4OBg8vPzoypVqpCtrS1ZWVmRiYkJmZmZUbt27bhBmeOHRywW07p160hfX5/69OlDnTp1Ii0tLZo+fXqFjWel/dguXrxIbm5upKurS507d6YXL14oelEXFRXR+fPnqVWrVmRmZkZaWlrUunVrOn36tELY+JZ4xWIpPXokpy5d2F7bNWsSXbnyp0fDl7+WPzfjJk0Sk5fXTtLW1iFXV1daunQpJSYmUnFx8V9ilUql9P79exo/fjwZGBiQjY0NLV26lIqKir7pdZX2v33y5AkNHjyYLC0tSUtLi3x8fGjXrl2UlJREycnJtGnTJqpduzZpamqSsbExnTp16j+fk6NyIJfLqaSkhBYuXEh6eno0fPhwle6pef78eTI1NaXWrVsr5d4tkUho+vTppKOjQ5MmTaK8vDxKSUkhd3d3cnFxodOnTytFYH39+jUFBQWRk5OTQsSqDJSUlNDkyZNJKBQqSpH19PTIyMiIzMzMyNLSkmxtbalKlSpUr149CgkJofHjx9OyZcvowIEDdP36dYqPj6eSkpLPeuAoy/uG49sp9d9IS0uja9euUd++fUlLS4t0dXXJxcWFQkND6cmTJySRSEgqlVJeXh798ccftGrVKqpRowZpamqSmZkZNWvWjHbs2KEQYf7NdFosFtPq1avJwsKCbGxsaOvWrZSbm1thho/FxcWUlJREx44dU5h26+npkZ2dHVlYWJCuri5NnTqVEhMTSSwWk0gkon379lG1atUUfa0vX778xT23/1ucRPn5ROvXE5mbE9WuzfpSzZjxZ6/rkhI2ier583IJ4X/ikdOdO3eoVq1a5OnpSVlZWVRQUEDTp08noVBI4eHhKrfxJZFIaPv27aStrU1Tp06lvLw8ysnJoY4dO5KlpaVKxqyKxMXFUePGjal169aUlJSk7HBUhqSkJFJXVyc/Pz86evQoPXz4kN68eUOJiYmUlpZG2dnZVFBQ8BcDRg7VRS6XU1BQEFlZWdGVK1eUHU6FwYnWZUhpfxlDQ0Pq2bOn0hZ8YjHR4sVEenp/ujtXFhISWOPWzp3Zx+xsVrTu2JHo0SOivXuJli9nJ0ADBxK1a0fk60tkb0+krU0kEBBpahI5OU0kIyMTMjAwIGNjYzIzMyMLCwuytrYme3t78vHxoZYtW1KnTp3I2tqaTExM6M6dO9yAzfFDU1RURL///jvZ2dlRZGQkbdu2jfT09GjVqlUVHotcLqekpCQaNGgQ6ejoUJUqVejo0aN09OhRatGiBWlra5OpqSm1adOGIiIiFEJ1WVzDpSaRWVmsF4eNDStez5zJmgn/25gqk7ELuXv3iIYNY8diPT051a//nvbvP0tZWVlftGiWSqV04sQJcnFxIV1dXerevbticf6lr7NUqM7JyaHo6Gjq168f6ejokKGhIdWrV4/27NlD6enplJSURNu2bSMfHx8SCoVkbW1N/fv3p5s3b3Lj4g+AVCql8+fPk6OjI9WvX58+fPig0p+7VCqloKAgMjU1pWvXrlXouWUyGZ09e5aEQiG1atWK4uPjqaCggLp27Up6eno0d+5cpYkMcrmcFi1aRLq6urRmzRqV/gxLkUqldPbsWXJyciInJycKDw+niIgI2rlzJ82bN49GjBhBP/30E/n4+JC9vT1ZWVmRmZkZGRsbk4GBAeno6JBQKCSBQEC6urpUtWpVatq0KfXt25emTp1K69evp1OnTlFsbCy9efOGUlJSVLKCgOPfKb0vxsfH09SpU6latWqkr69PGhoa1Lx5cwoPD6fk5GQqKioimUxGJSUldP78eQoJCSFLS0sSCoVka2tL06dPp0ePHn1W0JXJZJSamkpjxowhdXV1ql27Np0/f/6r7rtl+XpLX/OLFy9o7NixZGlpSQ4ODnT27FmFUP/s2TPq378/6evrk6WlJc2ePbsCBXZ2znPuHNHdu0TTphFZWxPt3MlWyBYWEgUGEpVDwdhfKCwspJkzZ5KWlhbt27ePpFIpxcTEkIuLC3Xo0EFlzHs/Ri6XU2JiInXt2pWsrKzo7t27CjNfY2NjqlGjBj2vCMW/kpOZmUnDhg0jZ2dniouLU7nPWVmEh4eTtrY2zZ49m9u8/U64efMmGRgYUMuWLX+ouUzZNOPiAADw+Xz07t0bd+7cweHDh9GgQQMMHDgQAoGgQuMgAoqL2d7QDRoAfH6Fnv6bYRigY0cgPBy4dAkwNGSfO3QIWL8eUFNj+11rarKHhgbg6Mi2G9LTA4yNATu7ltDUtIKhoT6MjY1haGgIY2NjGBsbw8DA4JPP5MCBAwgNDcVvv/2GzZs3w9bWVomvnoNDeUilUmRlZUFXVxdCoRDp6eng8/lK6dHPMAwsLS0xZ84c5Ofn49ChQ+jcuTOkUik0NDTQqlUrjB8/HnXr1i3zMba0ZZmhITBpElC7NjB/PrB0KRAbC/z6KzvOWFqyY45IBOTlAQYGQE4O8PgxcPIkcPgwIJGw/z4khEHnzrYwMfmy8YVhGPD5fLRt2xZubm4ICwvDhQsXEBcXh/HjxyMoKAgGBgb/+H/I5XIkJyfjwYMHOHToEE6fPg0NDQ0EBASgW7duaNasGVJTU7Fnzx5s374dr169gpubG4YPH46+ffuievXq4Fe2GwjHV0NEeP78ORYtWgQAmD59OiwtLVW6TyGfz8fIkSPRo0cP7N27F3Xr1oWmpmaFnPv58+cYN24cbGxs8Msvv8DKygpr1qzB6dOn0bp1a4wYMUJp1w3DMAgKCsLu3buxfv169OzZE/r6+kqJ5UsgIrx9+xbLli2DXC7Hhg0b0LRp08++f0QEkUiEtLQ0pKWlISUlBampqUhLS0NqaipSU1ORm5uLoqIiFBQU4P79+7h+/TpKSkpQVFSEkpISiEQieHp6YuXKlWjQoAHnYVLJKL0vOjo6IiwsDKGhoTh79ixOnDiBp0+fYsCAAXBxcUHnzp3RsGFDVK1aFc2bN0eTJk0QGxuLw4cP4+bNm9i4cSO2bt2KZcuWoUOHDorvm0gkQkxMDGbNmoXo6GgEBwdj2rRp8PT0VNrrBdjxzs3NDTNnzgQR4fjx47CwsACfz0dWVhaWLl2K06dPIygoCBMnTkTNmjUrbPxmGPYICgLEYuDiRXY9du0aULcuYGNTIWFALpfjwYMHOHjwIJo0aYKAgABIJBLs378f2dnZ6NKlC8zNzVXuvlY61x00aBCMjIygrq4OADAxMYGDgwPevn2L4uJiJUep+ujp6cHJyQmJiYlIS0uDs7OzskNSCa5evQotLS3Url1b5b77HF+PVCrF3r17IZFIMGjQoDLzVagM/DivtIIwNDTEhAkT8PjxYyxatAhVq1ZF48aNy/WcmZnA2bOAlxdQvTor6gYFsSYZTk7leupyw9wcGDECmDsX6NuXfa5VK/b1aGkBurqsWKSr++nPf2pXjf//+Hc6deqE2NhYrF+/Hps2bcL48ePL3GSOg6MyIJPJFKK1pqYm0tPTwePxYFwWzj3/ETU1NWhoaMDCwgKtW7fGgwcPkJycjN69e8Pf37/cz8/ns+OpiwuwYQO7ebZ3LzvuensDEycCHz4A16+zprFRUcCFC+y/a9oUaNYMaNECMDX9b/4dDMPAxcUFK1euxIEDB7BhwwaMHj0a3bt3R//+/eHp6fmXiahMJsO7d+9w5coVnD9/HleuXIGenh46dOiAoKAgNGjQAM+fP8eqVatw7tw5xMfHw9vbGzNmzEDz5s1Ro0aNCt9s5VAeMpkMU6dOxZ07d/DLL7+gfv36lWKzolmzZvDw8MDNmzfx+PFj1KlTp9zPmZiYiNmzZyMhIQELFixAQEAALl++jPXr18PV1RVz5sxRukhcrVo1NGnSBLcOH0bq5cvQ79hRqfH8EyKRCCtXrkRMTAzGjx+PevXq/e13j2EYaGpqws7ODnZ2dp/9O1KpFLm5ucjJyUF2djaysrKQk5ODnJwcZGVl4fbt27hw4QLWrl1boRsdHGUPwzCwsLBA//790aVLF9y+fRuRkZG4efMmFi1ahE2bNqFJkyZo2LAh6tevDx8fH9SpUwcJCQmIjIzEkydPYGdnp9i4KCoqwrFjx7B48WKkpaVhzJgxCA0Nhbm5uZJf6Z/o6OjAw8MDmzdvxps3b+Dh4QE9PT306tUL/v7+aNeuHYyMjJQqTjEMK1bL5axJ49ChFXPe4uJi7N69G3FxcRg9ejRMTExQUFCAe/fuKb4HqnpfYxgGjRo1QsOGDaGurg4iwvv37/HmzRvUrVtXqXPwyoKamhrs7Oygq6uLBw8ewNfXV2U/74pCJBIhKioKurq68Pb2VnY4HGXAq1evcP36dTg5OaFFixbKDqdC4UTrcsDDwwNhYWHo3bs3Vq5cCUdHR9jb25fb+dLTgVWrgJo1gbAwNjvw4UPg9WugS5dyO225ExAARESwQpGVFeDjA/j5lf15+Hw+Ro0ahdjYWOzatQt16tRB69atf/ibHcePx8eZ1pqamkhLS1NapnUpJSUlKCgogK2tLaZMmYJly5bh3LlzFS4MOToCv/3GitBaWuxYe/s2EB0N6OgAycnA8+dsdlGnTsBPPwGenoCJCfCtyXwMw8DQ0BD9+vWDt7c3Vq1ahQ0bNuD+/fsYNWoU2rVrpxBfRCIRTp48ibVr1+Lhw4fQ09PDkCFDEBQUhCpVquDp06eYNGkSbt26haSkJPj5+WHUqFHw9fWFq6srN+79gBQUFODs2bPw9PREx44doauri5ycHERHRyMoKEhls1E1NTUxatQoDB48GBcvXoSXl5ciS608KC4uxq5du3D+/Hn06dMHvXv3Rnx8PFauXIn8/HysXLkSVapUKbfzfyl8Ph8j+/ZFn+PHYbtxIztoqehG/I4dO7Br1y60aNECffr0ga6u7jf9f2pqaoqquv9FLpcjPj4excXFuHz5MhISElTi8+L4drS1tdGkSRP4+/vj/fv3ePToES5evIjjx4/j+PHjqFq1KurXr4/g4GDUq1cP3bt3R0lJCfh8PhiGQV5eHhYsWIA9e/bAwMAACxcuRHBwMLS1tZX90j6Bz+fDwcEB5ubmuH37Nlq1agVNTU00bNgQDRo0UJn7t64u0K4dMG4cUAF7iQDY+eurV68AsOK+mpoatLW1MXfuXGhqasLS0rJiAvmPfHzvKikpwdatWxXzNysrKyVGVnmwsbGBubk57t27h0GDBqnM9aAs4uLikJycjFq1aqnU5hvHf4OIcOnSJbx79w4zZ86Ejo6OskOqUFRzJVLJKS3PHDZsGC5cuIC9e/eiuLgYRFSm5yH683BwAJ48AW7eBGQydodbJivT01UIHycHCATA2LFAQUF5n5MtzZo6dSoYhsGyZcuQkJBQ5p8XB4eqI5PJkJ2drVKidXFxMQoKCmBkZAQdHR1kZ2dDU1Pzm8WNr4Vh2IVY06ZArVpsa6IRI4DFi9kximGA4cOBK1eAOXPYv2dm9u2C9cdoamqibt26WLlyJZYvX47nz59j9OjRCAsLQ2ZmJogIampqKCoqQnJyMkaNGoXz589j/PjxAIBRo0ahb9++2LNnDywtLbF9+3bs2LEDPXv2RNWqVX/4Cf6PilAohImJCQoLC5GdnQ0iws8//4yxY8fi3r17yg7vHwkICEDVqlURERGBt2/fltt9Wy6XIzIyEhs3boS7uzsmTpwIIsLOnTtx9epVjB07FgEBAeVy7v+Cc40a8K5XD8LYWLbPmorNZ4gId+7cwZw5c2BsbIxJkyaVu6jE4/Hg5OSE4OBgyGQy7Ny5k5vnfUcwDAMNDQ24uLigffv2mD9/Pq5evYpJkyYhNzcXa9asQefOndG2bVscPnwYMpkMAoEAiYmJ6NOnjyLJaN26dQgJCYG2trZKltPb2trCwcEB0dHREIvFANjvtqrdv6tWBTp0ABYuZNek5Y22tjYGDx4MNTU1XLx4EZmZmRAIBPD19YWXl5fKbr7+L6Vj47Fjx9CoUSMEBgb+UC0AvgVbW1uYmZnh3r17kFVGEaSMuXv3LkpKStCoUaNK8/3n+HuSk5Nx7do1CIVCdOrUSdnhVDjcN7icUFdXx+jRo+Hn54cNGzYgOjr6iyfHRASplCASsb2pCwqA3FwgOxvIyABSU9msvrg44NYt9s+NjNjJwaZN7N+pjBABQiHg7w/Y2rK/m5iwmdZdu5Zvb26GYVC3bl2Ehobizp072LhxI0pKSsrvhBwcKohUKkVmZiZ0dXWhoaGBtLQ0pbcHKRWtjY2NwePxkJaWphTRuhQe708hukYNoH59YMcOdlFmYwM4O7NJjeW11i39PAYOHIgzZ86gatWqWL58OTp16oRHjx5BJpMhJCQEN2/exKhRo5CYmIhevXqhVatWuHLlCmrWrImzZ8/i3LlzCA4OhpmZGQQCgUouzjkqBoFAgGXLluH9+/e4evUqJBIJWrZsiYSEBOzYsQNSqVTZIX4WhmFgbGyMXr164c6dO4iJiYG8HNSR0r7LCxYsgFQqxbx582BpaYlLly5h5cqV+Omnn9CrVy9oamqqzHXEqKmBGTeObbZ/8CBQVKTskBQQEZKTkzF58mTk5uZi3rx58PLyqpD3jsfjoX379rC3t8emTZuQlpZW7ufkqHj4fD709fXh6uqKn3/+GdevX8e2bdtQvXp1xMTEYMCAAahRowZatGiBOnXq4NKlSwgODsbu3bvh5+cHdXV1lbmW/xdbW1s4Ozvj3r17yMvLU/rGS0kJuz79f/1cAZ8PDBjA/vz2bfnHwefzERQUhKFDhyI8PBwRERGQy+VgGEZlP8vPIRaLMW3aNJiYmKBnz55cu8qvwNLSEtbW1njx4gVycnKUHY5SISLcunULYrG43NvUcpQ/RISHDx/izp076N69O0xMTJQdUoXDidblRGmvtYEDByItLQ2LFi3CH3/8AbFYjLy8PGRkZCAhIQHx8fF48eIFHjx4gFu3biEyMhJnzpzFoUMyrF0L/P47a/o1eDDQuTPQvDlr6lWlClCtGtC+PfD/1VBo1ox9fsWKypllTcQK8SdOsBMggBWH6tVjX3t5i9aampro1KkTWrVqhVWrVuHChQtKnwxycFQkanI5qonF8DQ1hYaaGszlcrgaGytNIAZY0To/P/8T0VooFCo1plLU1FjD24QE4P37Pw2JKmJ9pKamhjp16mD37t0YMWIE4uLi0Lp1a2zbtg0vX77ExYsX0a9fP7Ru3RovXrxAmzZtsHv3bhw6dAiBgYEQCATg8XiVajHHUT7weDwEBASgRo0aiIiIwJs3bxAcHAxnZ2fcvHkTz549U3aIf0upsai9vT0OHTqErKysMr9vy2QyHDx4EPfv30doaCjq1KmDV69eYcKECXBycsLw4cNhbW2teteShwc7aYyNZXsZqch8Ji8vDytWrMD9+/cxaNAgdOzYsULfOysrK3Tq1AkFBQXYsWMHN8/7TikVK/l8PgwMDNClSxdcuHABp0+fxtChQ6Gjo4M7d+5AKpUiNDQUW7duVc3r+H8QCoWKyqjo6GilxiKXA6dPA716scMMwLZztLZmf1ZXBxYsYNet5T1lYxgGBgYG6Nq1K9zd3TFjxgwkJCSU70nLGCLCwYMHERMTg8aNG6Nx48Yq/31UJQQCAVxcXKCurq7yVWLlTU5ODl6+fAk9PT2lGclylB2FhYW4fv06iouL0a5dO2hoaPxwYwNXb1KOiMViJCQkQC6X48KFC5g8eTKqV6+OvLw85OfnIzs7GwUFBSgoKEBOTg7y8vKQl5eHkhIRHB3TUVioB21ttl9q6eHqyvZ2Lv3dxIQtQQdYAeXnn4E+fYC0tD+fryxIJGxW9bVrrBCkDOzt7REaGorHjx9jypQpcHFxQbVq1ZQTDAdHRUIEU5kM2yQSMCYmEBQXY7FQiEITE6WWnRYXF6OwsBDGxsbg8/lIS0uDmZmZUnt5MQzb41pNjV2g9e0LxMR8bARbcVhbW2PGjBmoWbMmNm/ejPHjx8PR0REJCQkwNzfHoEGDEBwcjPr166tcf04O1cHAwADdu3dHWFgY7ty5A0dHR4SGhmLChAk4f/48qlatWq79or+WhIQEaGhowMTEBE5OTmjWrBl27tyJkydPwtfXFwYGBtDX14eWltY3l8UyDAN7e3uMHTsWPXr0QEFBASZOnIjs7Gz8+uuv8CsPs42yQE2NzXjo25ftW+TrCyh5DBCLxTh79iz279+Phg0bYuLEiUpZePXu3RubN2/GkSNH0KNHD9jY2FR4DBwVD4/HQ506deDt7Y2QkBDcvn1bMfap0vj2b9SoUQNGRka4fPkyQpS1YAKQkwNcvgw8esQmGTEMYGDAGlVnZLBrVC8vYPNm1gukIvDx8UHPnj0xa9YszJ8/H8uWLas0hquJiYnYuHEjDAwMMGbMmEr1nVQVqlWrBm1tbdy6dQvt2rVTdjhK48WLF0hLS0ODBg2goaGh7HA4vgEiQlJSEk6cOIHGjRvD1dX1h2z3wonW5QQRIT09HQcOHIC3tzckEglOnTqF48ePQyAQoEqVKrC0tISBgQGcnZ1hYGAAAwMDGBkZQU9PD8bG7ACjqcm2zPjcIRCwE4Tnz/88r4MDMHo0e/TqpZzX/l95/hw4dgwIDGSzq5W1gVS/fn38/PPPGDduHObMmYPVq1crtacvB0dFwcvOhnZCAps+k5sL97dvASW7lpdmWpdeg5mZmdDU1FSqACuV/ilaq6uzWhCPV77VIP+Ejo4OunXrBg8PD4SGhuLp06fo3bs3QkJCULNmTZXtzcmhOmhoaKBRo0awtbXF4cOH0apVK7Rs2RKrV69GREQEOnbsCGdnZ2WHCYDNIFqyZAnevXuHTZs2wcjICO7u7tDU1MTs2bNhaWkJHR0daGtrQ1tbG4aGhjAxMYGZmRksLCxgYmICY2NjmJqawsTE5F8n/3w+HyEhISgqKoK6ujrCwsIQERGBwYMHo1u3bhAoY7fqS2AYtgF/3brA+fNA9+5siZ6SICK8fv0ay5Ytg6GhISZMmABTU1OljE12dnbo0qULtm7dinPnzmHQoEEVHgOH8hAIBPDz81PdDad/oVS0joiIgEwmU0rPYyLgwwfgwgW20tfRkW0Rsngxu3Zt2JAVrRkGqEjfbIFAgJ49eyIiIgLh4eFo2rSpUoX9L0Uul+Pw4cN49OgRhg0bBi8vL2WHVClxd3dXiNY/Mi9evEB6ejqaNGnCzf8rOTKZDNeuXUNiYiJGjBgBs8qWlVpGcKJ1OSGXy3H+/Hm8evUK06ZNQ5cuXRAZGYkBAwagWbNmWLp0qcLdWCAQQE1NTXGUull/KUIh4OT05y52y5ZstrWNzZ/VoKo+XhEBq1ezwk9wMDvRURYCgQC9e/fGtWvXcPbsWezcuROjRo1SOZMTDo4yJz0d0NBg6zizs9k+Q8p0nCaCRCSCuKgIxsbGyMvLg0wmg4GBgVKNaUpKgLt3/9wYFImA16/ZKhhlzSV4PB5cXV3h5OSErKwsdO7cGf7+/txkleOLYBgGbm5uaNq0KTZu3IinT5+ibt266NmzJ+bOnYsHDx7A0dFR6dkdMpkMhw8fxp49e1C/fn3o6OggJSUF169fR15eHho2bAgiQmJiIpKSkpCTkwMejweBQACBQAB1dfVPftbX14eVlRWsra1hZWUFGxubTx51dXUVJmc6OjoIDw/Hzp07UaNGDfz222+q3W+UYQBTU7Z07eefgagowMVFOSUhAEpKSjBz5ky8efMGYWFhqFOnjlK/T0OHDsXmzZtx4cIF/PTTTzA1NVVaLBwcX4O5uTlcXFxw9uxZxMXFwd3dvcJjkEqBq1fZrOomTQBDQ+DmTeDePaBfP9abSFmYmppi5syZaNq0KZYvX45atWrBwcFBZedDRIS4uDgcP34c+vr6CA0NVfq9trLi7OwMQ0NDPH36FHl5eap9jy4npFIpXr58qZgTcVQu/rdlmVgsxrZt21ClShX4+fmpbqJEOcOJ1uVEcXExVqxYgapVq6JFixawsbHB6dOnYWBggH79+qFKlSpldvO0t2fXI6X3N21tYPZs4MULYPt2oFUrVndS0Xs1AODpU+DoUcDdHfjpJ+XHKhQKsXjxYsTGxmLr1q3w8fFBgwYNuEkEx/cLEdtXSChkReusLJUQrVsXFCCZCAITE0gyM/GqZk2gWjWlLj6IgMJC1uNMTQ3Iz2d9zsrBA+4r4yJkZ2dDV1cXhoaGKrtA41BNtLS00KxZMxw9ehTr1q1D/fr1ERgYiK1bt+Lo0aNo3LgxjIyMlPa9ksvluHfvHlavXg1DQ0MsWLAARIRDhw7h6NGjGDp0KKZOnQodHR0QEYgI+fn5SE5Oxvv375GQkICEhAR8+PABHz58QEJCAt69e4e3b99CLpdDLpeDiBQ/y+VyhahtZWWF3NxcPHz4EHw+H+vWrVOqQe0Xo6bGloJ4eAC7d7NGKMbGFT7JkslkWLNmDY4fP45evXqha9euSi19ZxgG1tbW6Nq1K86ePYu7d++iVatW3JjJUSng8/lo26QJTBITwb93j108VSClc6A9e9ihpXZtdkhZvx4wMgJat2ar0JQFwzCoWbMmxo0bh4ULF2Lz5s2YPn26yrZJkEqluHDhAu7evYs5c+bAXJnz7kqOuro6vLy8EB8fj8ePH8Pf31/ZIVU4mWlpSI+Ph3fVqrC0sFB2OBx/Q+l8UyaTQSqVKh6lUimysrLw+vVrvH79GlFRUYiJiUHv3r1Ro0YNZYetNDjRupw4dOgQXr9+jVGjRqF69eq4e/cuIiIiUKNGjTKfGDMMuy75+HeJBDh5ki3TKigAhg79s52IqiGRsBMdsZiNUxU2RRmGgbm5ORYuXIiBAwdiw4YNipYu3KKG47slNfXPTOtS0VqZZUhSKfjZ2RAKBIBAALXkZDg8fQq0bau8mP6fggJg3TpW48/IYEVrZVPalkpLS4vrX83x1TAMg/r166NmzZo4deoUXrx4gSpVqqB58+bYt28fQkND4evrq5TYiAhpaWlYtWoVEhMTsXz5cjg6OiI6OhoLFixAvXr1MHjw4L+08tLU1ISpqelnjYiICCUlJcjMzERSUhKSkpKQmpqK1NRUJCcn48OHD8jJyUFxcTH++OMPZGdnw9DQEP369YO7u3vlmAswDGuGEhjIZjF8+FDhLZ/kcjmuXLmCefPmKYQkAwODCo3hc6irq6NHjx4IDw/H5cuX0aBBgx8yK4+jctK7Vi30njwZOHcO6Nnzz8ylCuLOHbaX9ahRQJUqwJs3bCienmxrEGUPjwzDIDQ0FBcvXsTRo0cRGBiIxo0bq1zVLBEhPj4eBw4cQLVq1dCuXTulVhJWdhiGQe3atXH48GHExsb+kKK1SUoKluXnI7VVKxhoaVWOucp3jFwuR3FxMYqKij45CgsLkZGRgXfv3uH9+/d49+6d4ufc3FxoampCS0sLmpqaMDMzQ3Z2NjIyMn5YLYobFcuBrKwsrFu3DpaWlujWrRukUim2b9+OwsJCjB49GloV4EahrQ106MCWbi1ZAtSsCajquP34MWvk4erKZlmrCnw+Hw0bNkT//v2xdetW1K5dGyNHjuSMMTi+T0ozrTU1WdH6/XuVEK2Rnc3uZGloAO/esTt0KtBjXksL6NqVNR16/Zr1OVM2paK1m5sbJ1pz/Cf09fXRoUMHXLlyBatXr8batWvRtGlTHD9+HNu3b0ft2rWVsqCWyWTYtm0bzpw5g4EDB6Jly5ZITk7GpEmToK6ujtDQULi4uHzV/8kwDIRCIWxsbD5rxEdEKCwsRFZWFtLT0/HixQsYGRmhYcOGEAqFZfXSyh8NDaBTJ6B6dbbx/vPnrJO3hUWFpEM+e/YMM2bMgIaGBqZNm6Yy5talLZVatGiB06dPo3fv3vDy8vohF4MclZAaNdheio8fs0kGFdhXkYhNNrKwAFq0YJOidu1ik5A6d67YHtZ/B8Mw0NfXx8SJEzF06FBs374dHh4eSuuj/3dIJBKcO3cOz58/x8yZM2FlZaVS8VVGateuDZlMhgcPHig7lIqHCPwPH6B36xb0fvpJuSUPPxhisRi5ubnIyspCdna24jEjIwMpKSlIS0tTJEakpqYiLS0NRAQ9PT0YGRnByMgI5ubmqFatGiwsLGBhYQFzc3MYGhri+PHjOHbsGLZt24ZRo0b9kBvsnGhdDhw/fhwvXrxA79694enpiTt37iAyMhK1atVC8+bNKywONzdg+HDWlHHyZODgQXaCoUqIxaz54vv37ARIV1fZEX2Kvr4++vfvj5iYGCxbtgw+Pj5o1KgRN6Hg+D4pFa11dFQm0/oT0TotjRVdDA2VF9P/w+cDdnbsOlEsZt82ZSOXy5Genq4wX+Tg+C+0bt0aa9euxblz5/Ds2TP4+/vD29sbR44cwbhx4+Dq6lrhMZ06dQrLly+Hj48PBg8eDIFAgNmzZ+PJkyeYMmUKmjdvXuYZdAzDQEdHBzo6OrCzs0OtWrXK9P+vUDw82J5xq1axY3puLuDsDPTuXa5iV3p6OtasWYNHjx5h9uzZaNGiRbmd679gbGyMVq1a4dKlSzh//jyqVavGJSZwVA6EQqB+fSAiAnjyBGjcuMJO/fQpEBnJerz6+QHJyWyWtaEhuz+mKvD5fPj7+6Nbt27YsWMHmjZtil69eqlMJjMRITk5GWvWrIGXlxeCgoKgqQqTyUpO9erVoa2tjVevXqGgoAA6OjrKDqniEImAly/ZRYqbm9I8LL5X5HI5CgsLkZKSoqjQS05ORmJiItLS0pCTk4Pc3NxPjsLCQhgaGsLKygqWlpbw8vJSGIFbWVlBR0cH+vr6isPAwAC6urqKOS0RoVq1akhPT8eGDRvg5uaG9u3bq8w4VlH8WK+2AsjKysK+ffsgl8sRGhoKmUyGs2fPKoxnKlJI4PPZftY9e7Imh3PnAkuXftpKRJkQEV6+ZOdb1aoBLVuqnhDMMAxcXFwwYsQIjB49Gr/++ivOnz8PAwMDTrjm+L4gYo0YSzOtVaGndaloravLitapqewApmTRWkMDaNSIfQRYTd3DQ/mbbiUlJcjPz4e2tja38OH4zxgZGaFv374YN24c9uzZg7lz56JNmza4ceMGtmzZgvnz51fY/a/UoGratGlgGAaTJ0+Gs7MzVq1ahSNHjiAwMBDDhw+vkAq2Sk1UFBAeDowdyzp3p6ayAraFBWvUWMYLWyKCVCrFqVOnEB4ejpCQEPTr10/lSvPV1NTg5+cHDw8PbNmyBYMHD+b8ADgqD4GBbObPgwdAQECF9OQgIpw9Gw4nJwt06tQAOjp8HD8OxMez601Va8dsYGCA7t274/r16/j999/RvHlzlcpmXr9+PTIyMjBy5Eg4OTkpO5zvAi0tLXh4eCA5ORlv3779sfoAFxQAsbGs6bKqG5pVIp4/f44xY8YgIyMDEokEJSUlEIlEnzwKBAJYW1vDyckJNWrUgKOjIxwdHWFnZwddXV1oaGhAU1MTGhoaUFdXh7q6+l/67H9swlj6M8MwsLOzw5gxYzB69Gj89ttv8PLyKlN/vMoA5ypXlhDh2oULePXsGXr27AlXV1c8f/4cFy5cgK+vLxo1alThIQmFwG+/se1BwsPZbGtlm4WVIpVK8fx5FNLSrmP4cAkMDVVzbOXz+QgODkavXr3w7NkzTJkyBRKJRNlhcXCUPUVFbOsNPT124sPnq1amdWoqG5OS24NoaQEjRrAJ6QBgaQm0a6fctwpgsxp5PB4MDAw401iOb6Jnz54wMzNDREQEXr9+jZCQENjY2GD37t1ISEiokBiICDk5Ofjtt98QHx+P3377DQEBAbhy5Qo2bNgAfX19rF69GvqqUIuuyhABt28Ddeqwh40NUKsWK3I9eMA6yRYWAsXFbNmIVMpOFP/Hwf5refToEebPnw9nZ2dMmDBBZTf7q1SpgiZNmiApKQlHjhxRdjgcHF9OYCBQUgI8fMhetxVAcnIydu/+Henpg9GpUzGKioBLl9hhZNCgCgnhq2AYBj4+PujZsycyMjIwffp0yGQyZYcFAIiLi1NkTnbp0uWHy5wsT/z8/JCTk4O4uDhlh1JxELFrt/v3gapVAVNTZUf0XSCVShESEoKIiAjEx8ejqKgIjo6OaNu2LSZNmoRdu3YhNjYWCQkJiI2NxdGjR7F8+XL8/PPP6NixI+rUqYOqVavCyckJVlZWMDIygpaWFng8HkpKSlBYWIi8vDxkZ2fjjz/+wLlz57BmzRr88ssviI+PBxEpWtaOHDkS2dnZGDhwIPLz85X91lQo3OhYlmRmolFMDIYZGaFjaCgkEglu3LiB58+fY/ny5UqbsOvqsgk1bdqwj9Wrs1mBylw7EBESExOxceMMmJmJEBCwHWpqzsoL6F9QU1PDpEmTcPv2bRw5cgQNGzbkJhgc3xd8PluK8f49u/oICGDLx5WZ1VwqWpuZfZpprWTRmmE+TUz8XzNcZZFelA4DLwOYOFVcb0uO7xMtLS2MGDEC8+fPx4ULFzBs2DD06dMHs2fPxq5duzBp0qRy3xgpKSnB5s2bERERgfbt22PYsGH48OEDVq9ejczMTGzbtg02NjYqKYSqHFlZgL09O1CVvl8mJsC9e2wW9u7d7DhrafnnYWDAVt5oaACamiANDeRoaEBDUxPq6urg8/l/+96npaVh+vTpyM/Px+zZs+Hi4qKynxOPx0O7du2wf/9+rF69Gt26dfuxysk5Ki8mJuyi7t071mS1nDN1iQinT59GQkICRowYAX19bdy5I8KDBwxatRLAyYlRyeQjHo+H3r174+LFizhw4ADatGmD9u3bK3VzXyQSYcGCBZDJZBgyZAgsLS2VFsv3iJ+fH5YvX45Xr16BiFT2/lPmJCay67j+/ZVelfq9cPXqVSQnJ8PDwwPh4eFwcnL6oqoxmUyGkpIShQljcXExiouLUVhYiNTUVIXx4rt37/D27Vu8ffsW+fn50NTUhFAohJaWFtq2bQtHR0cwDAM+n4++ffvi+fPn2LRpE6ZPn46wsDDoKrvMt4JQgWX2d4JcDsTEwPjgQUxq0QJwcEBeRgayzp9Hs3r14O/vD4ES+wp5eABTpgCzZwNbtgDTp1e4gfwnyOVy3Lp1CzExMfj1118rxc3awMAACxcuRJcuXbBmzRpUq1atTEx7iEix01bqJlt6pKenQywWw8fHB66urlz2JEf5IZUCt26x4sbLl2z2TqdOrJitLCQSVrSuUuXTntYqYMSoiqTbpsNsrRnMzVSsPpej0sEwDEJCQrB+/XpcvnwZP/30E3r06IFVq1bh1KlT6NWrF+zs7Mrt/DKZDDdu3MDWrVtRtWpVzJ49GyUlJdixYwdu3ryJkSNHonHjxj/OQvRbYBg2eyEv79NSu7w8thyvpARISGAb1ebn/3moqbGimJERYGICsYUFZurrQ8/ICMbGxtDX14eenh50dXWhq6ur+FlDQwMrV65EZGQkhg8fjqCgIJXf4Pfw8EBAQAB27tyJ06dPo2vXrsoOiYPj3+Hz2V5lZ86w/TnKWbTOzs7G5cuXAQC9evWCWCxGbOxF5OQkoEePrlBXV12RzMjICJMmTcLDhw+xePFieHp6okqVKkqL58aNG7hw4QJq1aqFTqrUCPw7wdPTEwDw5s0biESiH6NlnlwO3LjBitVVqqhGNk0lp7TNmUgkwtixY/9i+E1EkEgkyM3NRXZ2NnJycpCdna0wYCw1XUxOTkZKSgpSUlKQnp4OuVwOAwMDGBoawsDAAGZmZnB1dYWVlZXChNHCwgIeHh6fzHM1NTUxceJExMXFYefOnahatSr69ev3Q3y/uW9zWZGfD5w9+6d1sqYmdI4excCnT5EzahTs7e2VGh6fD3TtyrY5uno1DY0bp6BtW3elCenFxcXYsGED7O3tERgYCKFQqJQ4vpaaNWti4sSJ+O2337BlyxbMmDEDJn9jYlQqRufn5yvcZPPy8pCfn4/MzEzk5uaioKAAGRkZyM3NRVFRkUK0Ln3MyMiAWCxGrVq1cPjwYRhyu6Yc5cXdu8C1a+zOlr4+cOIEsGkTsHix8oRrmYwdW3V12RiystjMvx/QNflLSEQiUjVSoa7DGYlxfBsMw8Dc3BzdunXDli1b8ODBA7Rq1Qq9e/fGhg0bcOHCBQwcOLBcRGMiQlJSEpYuXQqJRIJJkybBzs4Ox44dw6ZNm9CoUSP069eP62P9NXh4sNnUb9+y5kzp6UB0NODpyYpebm6fCtb5+eyGYWYmkJEBZGYiLycH1x8+RFJ6OnJychRGlXp6etDR0VGI1xoaGoiMjES9evUwYsQIGBgYKPvV/yt8Ph8DBw7EgQMHsG3bNrRq1Qp63H2GQ9VRU2Ov3y1bWNFaLgfKMbnl4cOHePDgAYKCguDo6IjU1FScOLEWdnbFqFWrFXg81V6j1K9fH6NGjcLs2bOxbds2TJkyRSmm1dnZ2di9ezdycnIwefJkbqwpYxiGgb6+PlxdXZGQkIC0tLRy3WRXGeRydh1nZcVWynJ8M3Fxcbhx4wacnJzQoUMHxfP37t3DzZs3kZCQoNBxSkXr0qO4uBgGBgawsLCApaUlatSogebNm8Pc3Bx6enowMDD47PFv82pLS0vMmzcPffv2xcqVK+Hk5IRmzZp994mNnGhdFhCxpRiHDrH9xTw9AakUvBUrYK2vD+uGDf907FISDMNmVg8dmoI//gjDtGm34OnJljgoI1PpypUruHv3Lvr161cm2coVBZ/PR6dOnRAbG4u9e/fCysoKnp6eyM7ORnp6OjIyMpCRkYH09HSkp6ejqKgIUqkUYrEYYrEYEokEUqkUIpFI8bNYLIaOjo7CSdbExAQuLi4wNjYGj8fDqVOncO3aNWzatAkTJkxQ9lvA8b1y4wZrA1+6i9y+PbBx4zf3Nf0mrKzYcdXQkM0InDyZnZRxbtifJU2aBjWowYBvoOxQOL4DhEIhgoKCsGfPHpw5cwYNGjRAv379sG3bNkRERKBt27awsLAo8/PKZDIsXLgQt2/fxrhx49CkSRN8+PABkydPhr6+PkaNGgVbW9tKM29QCZo0Af74Axg2jG0DkpcH1KjBunWbmv61IT8RW30jFgMiESASwUAiwf7iYpT8v+lQRkYGUlJSkJiYiOTkZCQlJSE5ORmvX79GUVER6tWrp/SEja/By8sLTZs2xY0bNxAZGYm2bdsqOyQOjn+GYdgNJx0dtkKusLDcHKFFIhFu376NDx8+YMmSJVBTU8OrV69w48YNjBs3DubmpirZGuRjeDwe+vfvj3PnzuHgwYMIDAxEYGBgmd1LxGIxRCIR8vPzIZFIUFhYiJKSEhgZGcHGxkZRcRIVFYUrV66gbdu28Pf3L5Nzc3yKQCCAt7c3YmNjkZKS8mOI1iIRWzHr71/uVRc/AkSEK1eu4PXr15g2bdonbTiioqIwb948ZGVlgYhgZmYGBwcHVKtWDY6OjnBwcICjoyNMTU0V7T6EQiE0NTWhqan5j+3VvoQaNWrg999/x8CBA7FkyRI4OTkptXKkIuBE67JAKgV27WIn961asZP/AwfYUsvBgwFvb5VwGOTxgFq1TNGjhxemTTuIMWPG4PDhw39xLi1vpFIpFi9eDFNTU4SEhFSqkgaGYWBiYoJevXohOjoaYWFh/5itrq2tDSMjI5iamsLS0hJWVlYwNTWFtbU1TE1NFRMZXV1d8Hg8MAwDHo+n+BkABg0ahM6dO2PRokXw8/NDw4YNucU6R9kjk30qBvP5ZWLG9Z8hYsvWr1wBIiLY+Pz9gV9+UU48lYAUSQoEjAAGagbKDoXjO4BhGLi7uyMwMBCHDh3CiBEj4OjoiE6dOuHYsWN49OgRzM3Ny/R+JJfLceTIEWzevBktWrTAgAEDQEQYOXIkMjMzERYWhoYNG35RP0GOj9DWBkaOBHr3ZnteGhr+6RXwuc+vtHG/QMD+WwACAK7//8dEBCKCXC7/y/Hq1Ss0adIE165dQ2FhYaXpD62mpoZx48bhxIkTOHr0KJo2bVppqgA5flAYhr2Wa9cGkpLYzahyEK2JCAkJCbh48SJq164NDw8PiMViHDp0CCYmJvD3968014qxsTGmT5+Ozp07Y9u2bahevbriPpaVlYXIyEgkJSUhPz8fIpEIhYWFij60pdWzIpEIBQUFij61pZWy0s+YYRIRBgwYgJkzZ0JPTw8ZGRk4cuQI8vPzMXr06ErzvlU2BAIBfHx8cOrUKaSkpPwYfa1jYlhDZXd3riK1DEhJScHVq1chFAoREhLyyZ+1aNECLi4usLOzg6WlJdTU1MDn88Hj8RSPpUd5wDAMmjRpgokTJ2LatGlYvXo1wsLCoKOj891+zznRuixITgZ27GBd2Rs1Yne6V6wAzM2Bnj2V2xP2f+Dz+ejZswdu3YrG/v37sW7dOowYMQLq6hVXTn7mzBnExMSgXbt2aNCgQaW8uEqzpd3c3BAUFARzc3OYmpoqsqVLf/5SQf5z70FpFrajoyPCwsLQr18/TJkyBbt374aDg0MZvyKOH546dYCdO4GQELYFx9WrgI9PuZaa/iNErGD97h2wbx8rnvz8MxAezhqMcPyFNGkaBIwAhnzVLtHlqDyYmpqiefPmOH36NHbv3o05c+YgJCQEBw4cQEREBOrVq1dmJjBEhNjYWIwbNw6Ojo6YOnUqDA0NMW/ePFy/fh2dOnXCoEGDOMH6v8AwgLo6W3JXamjyDXMvhmEUm+z/S82aNdGmTRtcvXoVFy9eRPv27SvNPM/LywuBgYG4ffs2YmJi4O/vX2li5/hBMTEB5s9nsyxzctgEKiurMq3wJSI8e/YM9+7dw9SpU2FmZoa0tDQcO3YMjRo1gqenZ6W5Tng8HmrWrIkBAwZg/fr1aNGiBXr06AE1NTUkJiZi7dq1iI2N/UR4+t+fS03ReDwe1NXVIRQKYWpqCnV1dWhoaEBXVxcCgQA6OjrQ0NBArVq1IBAIQES4f/8+Tp8+jZ49e8Ld3b3SvG+VDTU1NdSoUQP5+fn48OEDZDKZynsrfDOXL7ObzD4+KpEsWZkhIjx58gS3b99G165dYWxs/Mm16ubmBjc3N8XvFX0dMwwDoVCIbt264eHDh9i4cSOqVauG/v37K9VDrzz5zq/eCoAIWLeOnSy0agVYW7MCy7NnQMeOQK1aKjdw6OjoYPLkyXj06BGWLVuGGjVqoGnTphVyweXn52PLli1QV1fH8OHDK+UNpLCwEBEREcjKysKiRYvQpk2bMl9ES6VS3Lp1C9HR0ejYsSNat26NYcOGYc2aNVi/fr2iTJqDo8wICGCF6t27AQODPytFlCVay2Rsy5KgILbHNgAMGgT8/jsnWv8NqZJUNtOaaw/CUYb4+/vDy8sLe/bsQWhoKFxdXTF06FAYGBiAyrAS4/3795g1axaKioowZ84c+Pj44OTJk9i5cyc8PT0xd+7cSlWZpZJU0Hx05MiROHPmDE6fPo2mTZtWmp6t6urqGDhwIAYNGoRz587By8urzDZlODjKnNL2lPv2sUbVDMPOnerUYZOmyqjKQSQS4datW7CxsYGfnx80NDRw4MABiEQiNGzYEGb/215IxdHX10f37t1x/fp1LFy4EHXr1oWbmxusrKwwevRoZGVlQSgUQiAQQFNTUyFGlwrUpc+XPlf6d/5pTUtEyM7Oxvr166Grq4sOHTpw67hyhGEYGBsbw9bWFi9fvkRBQUGl8Ff4z5T2s9bRAWrWVHY0lZ7CwkJcu3YNxcXFaN269V8qIlRls8nCwgKhoaGIi4vDtGnTYGdnh6CgIJWJryypfIqhqvH6NbB/P+vS2r49a1yzbx87cRg1SmWdW11dXTFr1iz069cPy5cvh4ODQ4X0wrl69Sru3buHwMBA+Pn5lfv5yhoiwocPH3Do0CE0atQItWrVAsAObmVp5kFEeP36NRYtWoTCwkL88ssvGDVqFB4/fox9+/ahTp06CA4O/m530ziUgJoaMHEiu+FWUgI0bgzY2yt3000iYbO+S9HRYWPj+CypklTo8nU50ZqjTLGxsUGLFi1w69Yt7N69G7/++ivGjRun6NNXFuTl5WHz5s24du0ahg4dim7duuHly5dYvXo1eDwe5s6dCysrqzI5F0f54+3tjcaNGyM6OhoPHz5Ew4YNlR3SF8Hj8eDt7Q17e3scOHAAXbp0gaenp7LD4uD4PBIJsHkzkJsLjB3Ltgp5/hyYO5dt//ORcdi3IBAI0Lp1a9SpUwc1atRAYWEhduzYobg3VEaBpFq1aujVqxemTZuGefPmYdOmTTA2Nv7XXvZyuRwikUjhVVRYWIicnBzFcyUlJZBKpSguLoZEIoFIJIJIJEJOTg5iYmJw/vx59OjRAz4+PpXyfatM6Ovrw8XF5ccQrQFWh8rMBLhq7G+CiJCWlobjx4/D398fVatWVWmTw5o1a2LKlCkYPHgwpk+fDnNzc9T8DjcuVFNRrUzs3Mm6sI8ezWZZHzkCxMYCP/3EGjKqMM2bN8fYsWOxYMEC7NmzB7/88ss39R4Ui8UK99TU1FSFIWFqaipycnKQmJiI+/fvIzMzE7/88kulFFylUimOHTuGtLQ0/PLLLzA3N8elS5ewbt06jB8/Hg0aNCiT86ipqaFJkyZo1KgR1q9fD39/fzRp0gS//vorBg0ahOXLl6NmzZpwdHTkJj0cZQPDsL0QfX2VHQkLw7CmkI8eAU2bsr9HRnIZBH9DsbwY+fJ8WKhbQIunpexwOL4jeDweOnfujE2bNmHbtm3o378/zM3Ny/QcIpEIqampaNasGcaMGYOSkhKsW7cOsbGxCAsLQ7169cr0fBzlR2nZ6qBBg9CjRw9cu3YNtWrVgpaW6o9LpS1P1NTUkJqaiqKiImWHxMHx90il7Lzo99+BatXY50xNgdu3WS+QMhKt1dTUUL9+fUVf4CNHjuDdu3fo27cvnJ2dy+QcFY26ujq6deuG8+fP4+jRo9DS0oKdnR1KSkpQVFQEsVisMFQsKir65HmZTAa5XA6ZTPbJzx8/SqVSEJHi75Sukc3NzREUFFRpqk8qM6Wi9dGjR1FQUKDscMoeIlaDun0bSE1l2wL99FOZtgb6EZHL5bh69Srev3+PQYMGlYvheFnC4/HQvHlzzJo1C6GhoZg/fz6WLVv23SV6cKL1txAfD5w/z/YH7N+f3ek+c4bNth4zRqV6WX8OdXV19O/fH9HR0diwYQN8fX0REBAAHo+nMNkhIohEImRmZiIrKwvp6elITExERkaGwik+KysLKSkpyMzMhEwm++TfAuzFX/pIRAgJCYGXl1elFFvz8/Oxfv16eHp6onHjxgCABQsWIC4uTvE6ywKGYWBjY4OhQ4fiyZMn+Pnnn3HlyhXUqVMHI0eOxLRp07By5UrMmzePM/Hg+D7h84E2bYApU4CpU1nR+tYt1vSW4y8UygtRTVgNTupOYMBAQhLwwQePUd3sAI7Kg62tLVq3bo1169ahS5cu8PX1ha2tLWxsbGBnZwcrKyvo6ekpRL+PHz/uffx3931jY2PMmzcPfD4fOjo62L9/P7Zt24bu3bsjJCQE6urqlXLO8KPCMAw8PT1Rr149nDp1Cl27dkWVKlVU/jOUSqWIiorC06dP0bhxY5VfrHL84JSUsJmVNjZ/PsfjAU5OwP37wPLlwIYNbMWasTFgZMQepT9/9FyOiQkkhobQ+n8jr9IDwCe/y+Vy7NixA3w+X9ELurJiaGiIXr164datW9i+fftfkqlK17Eft8FiGAZaWlrQ0tKCpqYm9PT0oK6uDh0dHQiFQmhra0NTUxO6urrQ0NBQPC+Xy5GWloZ27drB19dX5cfC7wFdXV04OzsjJSUFSUlJcHV1VemM2a9CLgeuXwfGjWN/t7UF3r5lf54/H2jRQnntHSs5EokEmzdvhrOzMxo0aFApxjiBQIBevXrh/v372LVrFzw8PDBu3DgIhcLvZqxR/U9BlbG2Bn77jXVq1dNjd7WvXgU6dwZcXVWul/X/wjAMrKysMH78eAwZMgR9+/aFh4cHdHV1kZ6ejvT0dKSlpSE3Nxc8Hg8CgUBxqKmpQU1NTdHDSyAQwMHBAaampjAzM4OJiQnMzMwUhoSmpqYwNDSEkZERDA0NK+UFRETYvHkzsrKyMHToUDg7OytMJZs1a4b69euX6fl4PB4CAwPRv39/zJ07F1OnTsXy5cvRuXNnREVFYf369ahfvz5CQkK+n5swB8fHODqyC65Hj9jfp0wBKkG2XkVTLC9GsiQZk8wnQZPRxAfJBxzPOY4AnQB4aql2xQ9H5aCoqAhpaWnQ0NDA69evERcXpyiPFovFkEqlEAqFMDMzU4jYlpaWisPW1hZGRkZQV1f/7CEQCGBkZAQAiI2Nxfjx4+Hp6Ynhw4fDzMysUs4ZfmQYhoGlpSV++ukn/Prrr4iKioKjo6PKL/6ePn2KCRMmwNvbG3PmzIG9vb2yQ+Lg+Hs0NAChkE2aKoWIFbL19Ng/09Rkxe1379iWllIp2/daKv3zkMmw18ICU5OSUCSXw9DQEIaGhjAwMFD8XHoUFRXh1q1bqF69eqVs8/gxIpEIZ86cQWFhIYYNG4ZGjRpBU1MT2traUFdXh66uLtTV1aGtrQ2hUAhNTc0y8VXg7mcVA8MwMDc3h56eHs6ePYsGDRpAXV1d2WGVDRkZbJV/27bA5MmsAaNEAsyezbYHsrUFqldXdpSVkjt37iAmJgb9+vWDh4dHpbleNTQ0MH36dLx+/Rrr1q1DtWrVEBwcrPLzri/l+3gVFQ0RkJ/Pml9YWbHOzTIZkJfHlmX16lVphBWGYeDr64tRo0Zh1apVePXqFaytraGlpQUXFxd4enoqdoxLJzDGxsbQ19eHrq4uTExMFJMafX3971o8TUlJwdatW+Hk5ISQkBAUFBRgx44dYBgGoaGh5TIo8Pl8DBgwALdv38b+/fvh5+eHPn36YOTIkXjy5AmmTp2KqlWrcj0XOb4/SicJ+vpAJemHqgzkJMf5vPM4nnMcvtq+KKESvBO/w3vxexTIv8NySI4KRyQSYffu3Thz5gwaNGiAcePGQSQSIT09XdEGLCMjA7m5uSgoKEBBQQGeP3+Ou3fvKn4vKiqCjo4OTExMYGpq+pdHY2Nj6OrqQiaTYfHixZDL5Rg+fDhq1qxZaRYMHJ8iEAhQr149VK9eHVu3bsVPP/0EfX19lf08ExISMG7cOMhkMgwbNgze3t4qGysHBwDWi6R6dTZhqlo1du2Zns62DGnQABgyBOjTh12z5uWxjx8fHz3nLJejZ1oasvPzUVJSApFIhJKSEuTl5SE9PV3xXF5eHoqLi2FhYQG5XF5p131EhOvXryuqWH///fdK0cKI48thGEZhmFnqRdW8efPvw9D5wgU2aXLIkD8NVwUCYPBg9vq/dYsdE7h72FchlUqxZs0aGBoaIjg4uFJtcjAMAzMzM0ybNg0jR47E3Llz4ejo+N3MZTjR+mshAj58ADZuZAcLLS22j1CjRkDr1mxmoJNTpSrJ0NLSQu/eveHm5gaxWAwHBwfo6OhAW1tbUdb0PXzZv5W9e/ciISEBv/zyC6pUqYLz58/jzp07CAgIKLNe1p/D1NQUM2bMwLNnz7B8+XJUrVoV9erVw88//4yxY8dizpw5WLFiBSwtLcstBg4ODtWkUF6Ia/nX0NOoJwJ1A0EgiEmM2cmzlR0ax3cAEeH27dtYt24dLC0tsWDBAtSoUeMvf08ul6OkpAS5ubnIy8v7y2N+fj7y8/ORnZ2NzMxMZGRkIC4uDrdv30ZWVhays7PB5/MhlUohlUrRu3dvroroO6Bq1apo1KgRNmzYgBs3bqBNmzbKDumzFBQUYMmSJYiOjsbYsWPRqVMn8FW8xR8HBwQCYOBAtiJtxgy21UdcHGBgwJqyMQybbS0UssaM/0AQgBb/34O5uLhYcRQVFX3ye3Z2NpYsWYKoqChERkYiMDCwIl5pmZOVlYXw8HDk5uZiypQpXKvF7xQfHx80bNgQhw8fxogRI9C7d2906NABXl5elUqQ/AuPHrHXu63tn88xDJtxbWUFJCWxCZXfSZZtRfHkyRNcu3YN1atXL1dtp7zg8XioXbs2QkNDMX36dPz222/Ytm0bzP5l/K8McN/kr0UiAbZsYftWjxzJitavXwNhYYCdHSteV0IMDQ0RFBSk7DBUlvfv3+PQoUPQ09PD4MGDUVhYiNOnTyM9PR3jxo0r99ILT09PhIWFYcCAAVi3bh0cHBzQrVs3REdHIzw8HDt27MC4ceMq9w2Yg4Pjq8mX5YNAMBeYK/pXa4AzYeEoG96/f49Vq1YhOTkZGzZsQLVSs6//gcfjKfp8/t0GqkQiQUlJCUpKSlBcXKzI3CsuLkZ+fj4SEhIQGxsLNzc3tG7dmst6+w4QCoVo3bo1Dh8+jGXLlqF169YqlwQhk8lw4MAB7N27F/7+/hg3btw3mZJzcFQYPB6bUW1qCrx8CRQWArVqATVqsMLVV8IwDNTU1KCrqwtdXd3P/h0igr6+PkJCQrBo0SJUr169zI15yxsiwt27d3HhwgW0bduWM/r9jrG2tsbcuXPh5+eHkydPYvny5Th+/DiaNm2KESNGVN4+1yIRu2n1v7EzDCtUS6VsoiXHV3HgwAEUFBSgZ8+e0NfXV3Y4/wlNTU106dIFL168wMaNGzFr1iwsW7as0mtElfAqVTISCXDzJtCpE+DuDjg4sKXrvr5sOQbHdwcR4dSpU3j58iX69+8Pa2trPHr0CFevXkXz5s3h7e1dIXG0atUKAwYMwPHjx3H06FHw+XyEhYXB2dkZO3fuxM2bNz8xC+Hg4Pj+EfKEkECCEnnJJwa4HBzfAhGhuLgY+/fvx+nTpzF8+HA0b978mwRHgUAAXV1dmJqaws7ODq6urvDw8EDdunURGBiInj17Yu7cuRg0aBDs7OzK8NVwKJMGDRrAx8cHd+/exfXr15UdzicQEe7du4d169ZBQ0MDq1evhrGxsbLD4uD4ctTVWZG6fXugRw+gWTOgHCsvGYZBYGAg+vTpg6ioKGzfvh0ymazczlfWEBEyMzNx6NAhFBcXY8iQIdDS0lK5zTSOsoFhGDg6OmL48OEIDw/H9u3boaWlhS1btiAwMBCTJ09GcnIypFKpas+fiVghOiOD7VFvY8MmUBYWfvp3xGL2eUNDLsv6K3n79i0uXboEAwMDdO7cWdnhfBP6+vqYOnUq6tSpg3379mH9+vWQy+XKDuub4ETrr0UmA9LS2AlB6Q2Ox2MHj5QU5cbGUS4kJSXh3LlzUFdXx7Bhw1BcXIzLly/j3bt3GDBgAHT+32m7PGEYBtra2hg1ahS8vLywYsUKPHjwAKampliwYAEyMjKwdu1aJCQkqPZNl4ODo0wx4BughmYNnMg9gZeil3gteo0P4g/KDovjO+DGjRtYsGABmjdvjr59+0JbW7vc7nWlGX5aWloQCAScgPAdIRAIMHDgQPB4PKxfvx5isVjZIQFgxavU1FSsW7cOf/zxBxYuXAhnZ2fuu8dR+SjNrizNvCzn7zCfz8e0adNgZ2eH8PBw3L17t9IIIkSEBw8e4OjRo+jatStq1KjBXfM/AOrq6jA0NETnzp1x8eJFLF++HFZWVtiwYQNq166N+fPn49WrVyguLlatdTQR23v+yRPWZLFOHeDUKaBFC1a8PnuWFapLRe2nT9m+9h4eyo68UiGXy3Hx4kW8efMGQ4YM+S6qrQwNDbFlyxYYGxtjzZo1uHz5cqXaYPxfONH6a+Hx2Ib3eXl/PkcE5OSwTs0c3xUymQxRUVG4e/cuBgwYAFNTU7x//x6HDx9G48aN4e3tXWF9DxmGgYODA8aMGYPi4mLMnTsXmZmZ8PX1xbBhw3D58mXs3bsXEolEtW64HBwc5QbDMOhp1BO26rbYnLEZ2zK3IaYoBl5CL5iqmSo7PI5KyqtXrzBu3DiYmZlh+PDhcHR05Bb2HP8JhmHQtGlTeHp6IioqCvfu3VN2SCAiSCQS7Nu3D6dOncLAgQMRFBRU7q3eODi+BxiGgbGxMaZMmYJ3795h9+7dyMnJUXZYX0RhYSFWr14NIyMj/PTTTzAwMODubT8IDMOAYRgYGBhg8ODBOHXqFGbNmgUXFxesWLECISEhWLlyJWJiYiASiZQbLBErPkdEsP3q27QB1q0DXFzYzSlXV6B7d2DTJran/bFjbPvauXOBli3ZDgDc9/qLycrKwrVr18Dj8dC1a1dlh1MmlOpGS5YsQWFhIZYuXYq4uLhKqxFxovXXoqbGlmFdu8YaMQJshnV0NODjo9zYOMqcrKwsnD59GlpaWmjfvj34fD7Onj2LhIQEtGnTBhYWFhUaj5qaGpo1a4Zu3brhypUrWL16NbS1tdG7d2/4+flh1apViOTa1HBw/FDo8fUwxGQIFlgvQJhVGDoadkQ3o25w0XRRdmgclZGMDLxeuRL52dkYNmwYmjRpwi3qOb4JDQ0NjBkzBhkZGTh69KjyBQEAERERWLJkCWrWrImBAwfCwMBA2SFxcFQaStcj7du3x+HDh3Ht2jWVz+IjIly6dAlXrlxBixYtULduXe7e9gNjYWGBUaNGYdu2bQgLC4OtrS3mzp2LoUOH4vfff8ft27crvjKIiG0BEh4OTJgADBgA7N7N9q5fsoQVqdu2BTQ1gXHj2JZAf/wBnDvHZln37w+MGcMmWHJ8EUSEJ0+e4NatWwgODoaNjc13My4wDINmzZphzJgxuH//PlatWoWcnJxKKVwzVBmjViZyOXD7NrBoEevaamzMOrh6ewOTJgGVtGk7x1+Ry+WIiopChw4d0L17d8yePRsymQz16tWDubk5Nm3ahKpVqyoltrdv36Jv3754+fIlNm7ciDZt2uDixYsYNmwYjI2NceLECVhbWyslNg4ODg6OSopYDCxYgPzVq/Goc2dUnzOHE/M4yoScnBy0aNECPB4PGzduhKenp9JieffuHX766SdkZWVh3bp1aNmyZYVVzXFwfC/I5XJcv34doaGh0NTUxOnTp2Fqaqqygk9+PqF//wNITFyLxYvnwd/fX9khcagIEokECQkJiIqKwtatWxEVFQUXFxe0atUKgwcPhpOTU/kbNmZmAvv3A0eOAC9esJpTmzZsRnW1aoC5+V+NF2UyoKCAbRWiqclW/avo9aeqlGYhL126FLt370arVq0qpznn31DaCm3q1Kk4duwYunXrhpUrV1a6Oc/384lUFAzD9hNasQLo3Jl1aZ4/H5g6lROsvzPEYjF27NgBbW1tBAUFQU9PD3v37kVycjKaNWsGFxflZTHa29vj999/R0lJCcLCwhAfH4+mTZuiX79+ePHiBWbMmKEyfSM5ODg4OCoBRMD588D27dAxM0P96dM5wZqjzNDV1cXQoUPx5MkT3LhxA1KpVClxFBYWYuLEiYiLi8PIkSPRokWLSrd44+BQBXg8HurVq4eQkBC8fPkSy5YtU9kMPiJg924Gly+3R926R+Hr66vskDhUCIFAAEdHR3Tt2hUHDhzA+vXrwefzsXr1ajRt2hQzZsxAZmYmZDJZmX3HiQgymQyy1FTQypVAQAAweTIQGwu0asX2rl62DGjShPVS+5yQyuez+pO5OfvICdZfBREhLS0NJ0+ehK+vL6pXr66ym25fAxFBLpcrXkO9SQABAABJREFUvqvm5ubo1asXTE1NsXXrVjx//lzJEX49nGj9tZSaXdjYsE3wO3cGPD25MozvDCJCfHw89u/fj3r16sHPzw95eXlYuXIlbGxs0KVLF6UuchiGgb+/P6ZMmYIXL15g2bJlKC4uxsSJE1G/fn0cP34cu3fvVtqikIODg4OjEkEEvHwJrFoFFBSAWbcOjCnXE52j7ODxeGjSpAmqVKmCM2fOICkpqcIFLrFYjPXr1+PChQsICgrCuHHjIBAIKjQGDo7vCYFAgKFDh8Lb2xtr1qzB9evXVVK4/vCBbf2rpaWJMWOMuf71HJ9FTU0NxsbG6NOnDy5duoQFCxbA0NAQK1asgKenJ5YsWYI3b96gpKTkP3/PiQhFRUV48+YNli9bhvUtW0I8YwZQWAgMGwbcvw9s3Mi2ndXV/bxYzVEmyOVyxMTE4MmTJ2jevDmsra2/C9G6sLAQJ0+exB9//AGA1Y38/PxQpUoViMViJCQkKDnCr4e7Cv4rDPPpwfFdIZfLsWzZMmhpaaFt27YwMjLCrl27kJycjLZt2yqtLcj/MmLECAQFBeHkyZM4ceIE+Hw+li5dCl1dXaxbtw4xMTGVxtGbg4ODg0MJEAH5+cDWrUBMDDBxIltFxs1tOMoQhmFgbm6ODh064NatW3j06FGFzk9kMhkiIyOxdetW2NnZYfHixZxgzcHxjTAMAwsLC0yYMAEaGhqYM2cOUlJSlB3WJ4jFwN69wJs3wIgRgKOjsiPiUGVKDRuNjY0RGhqKkydPYvr06bC3t8fChQvRsWNHrF+/Hg8fPoREIvni/5eIkJubi1u3bmHZsmVo2bIlwubMwWNra2TOnAlcugQsWAA4OLBCNTcHK3dEIhG2bNkCFxcX1K9f/7uZE9y+fRvjx49HWFiYYnMlNjYWb9++hZubG5o0aaLkCL8eTrTm4PgMT548wYkTJ+Dh4YGgoCAkJSUhPDwc+vr6GDJkiErswjEMAy0tLUycOBHGxsZYvXo1Xr58iapVq2LKlCmIi4vDwoULkZiYqOxQOTg4ODhUFSLg8GFgxw62JLVLF0AoVHZUHN8hWlpaaNKkCUxMTLBv3z4UlxqalzNEhA8fPmD16tUoKirC7NmzYW9vXyHn5uD4EWjZsiV69+6Nu3fvYufOnSgpKVF2SApevgROngTs7YF+/ZQdDUdlw9bWFr/88gu2b9+OadOmwcTEBDNnzsSQIUOwYMECxMTE/KN4TUTIycnBsWPHMHXqVPTv3x9Lly6Fm5sb5s6di7GLF8Ns5EjA2ZkTqiuYx48f4+bNm6hVqxZq1Kih7HDKhJKSEly9ehWpqano0qULGIaBRCJBdHQ0Pnz4gAkTJlRKcZ4TrTk4/ge5XI4NGzagsLAQffr0gYmJCc6ePYvnz5+jW7ducHZ2VnaICng8Hjw9PTFixAikp6fjxYsX4PF4aNasGTw8PHD58mUkJSUpO0wODg4ODlXl4UNg1izAygoYNYp95OAoBxiGgaenJ/z9/XHmzBk8f/68QloJlJSUYN26dbh+/ToGDhyIwMBAro81B0cZoqamhrFjx8LZ2Rl79+7F/fv3lR0SAKC4GDh3Dnj8mL29mZtzuiDH18MwDFxdXTF8+HCsW7cOixcvBp/Px++//47Bgwdj9uzZeP369V+qh3JycrB371707NkTY8aMwf79++Hp6YnNmzdj1apVGDp0KKpWrcq1q1ESGzZsgFAoRKtWraCrq6vscMqEN2/e4Pr16/Dy8kLt2rUBAImJibh69SocHR3RuHFjlUi+/Fo40ZqD4yOICLGxsbh8+TKcnZ0REhKC5ORknD17FkSEESNGqNyFrq6ujpCQEJw4cQItWrQAj8eDTCZDQUEBtLW1uRshBwcHB8fnyckBfv4ZyMtjH2vV4voncpQr+vr6aN68OTQ1NTF58mRIpVLWjEomg1wuVxxEVCaCNhHh4sWLWLt2LRo2bIg+ffpAW1u7DF4JBwfHx1hbW2P69Ol49+4d9u7di6ysLKX2tyYC3r5lW4PUqQM0a8b61nFw/FfU1dXh4uKCPn364NixY1izZg0kEgmWLl2KVq1aYdasWUhKSkJOTg527dqF1q1bY9SoUbh27RqaNGmCo0ePYsOGDQgODoa9vT23eapE3rx5g9OnT8Pe3h7NmzdXdjhlgkwmw+PHj3Hv3j106dIFhoaGAICXL1/i5s2b6NChA8zMzFROy/oSODWLg+MjpFIpDh06hMTERKxbtw6ampo4f/48oqOj0a9fP5Vs0M8wDAwNDRUDk1wux4MHD/Dy5UtMmTIF1apVU3KEHBwcHBwqAdGfB4/HruiLioDevYFevTjBmqPcYRgG9evXh7OzM65cuQJjY2M4OTnB3t4etra2sLKygrW1NWxtbWFjYwMtLS2oqal99uDz+f84JyMivHr1CsOHD4ednR3Gjx8PW1tblZvHcXB8D/B4PDRo0ADdu3fHnj170Lx5c7Rt21ZpwpxEAhw/Drx+zWZZ29pyWdYcZYO6ujrMzMzQr18/tGvXDtu3b8f27duxYMECzJ8/H7q6uigqKoKRkRG6dOmCn3/+GVWqVAGPx+PuPyqAXC7H7t27UVRUhF69ekFfX1/ZIX0zH7ehsbe3R/369aGuro78/HycOHECOjo6aNKkCYSVtP0fJ1pzcHxETEwMzpw5AwcHBwQHByM3NxeXLl0CwzDo3LkzNDQ0lB3iZ/n4BlhYWIjVq1fDzc0NzZs3r7SDEwcHB8ePyNu3bxEXFwcNDQ1oa2tDKBQqDu3/Y+++45uo3ziAfy5Jkybpbtl7tey9EaiMsodl770UAUFBQNmyZCkIspeyCpQtSxmKiAzZq+zVlu6Vtmly398fZysI/kQoTdp+3q/XvUivafMkNJe75557HqMRRqMRqtdJLpvNwJUrwP37gCwr10mXKwcEBgJOTkxYU4ZJTSCvXbsWMTExSEpKwoMHD3Djxg0kJiYiISEBJpMJsizDzc0NuXLlSlty5syZdtvT0xOOjo5p7xNHR0cYDIa0r588eYKRI0fCZDJh/PjxqFOnDhMGRG+JJEnw8PBAz5498euvv2LmzJmoXLky8ufPn+Hvu9Qq66VLgbp1AV9fgBeeUnpKHdiYI0cOfPLJJ+jUqRNmzZqFn3/+GVqtFnXr1kXv3r1RpkwZXvVsZ27duoUdO3bA0dER7du3T9s+WSwWxMbGwt3dPVPuK9y9exeHDx9G+/btUbRoUQDAkydPsGfPHtStWxfe3t6Z8nkBTFoTpZFlGefOncPly5cxZswY6PV6mEwmeHt7Y8SIEShRokSmeKMfPXoUp0+fRr9+/VCuXDlbh0NERK9IlmVs374dEyZMgJOTE7y8vODm5pa2eHp6wtPTE+7u7iidIwfquLnB0WAA3NwAV1flXyenF6+BFgLYs0cZuFi8OKDVAnv3AtWrAz17cvAiZbi2bduiVatWiI2NRWxsLKKjoxEdHY2YmBiEh4cjKioKkZGRiIqKSlt/584dnDt3Lu1rk8kEJycneHp6wtXVNe194uXlBVdXV1y5cgVHjx5Fr1690Lt370yxD0eUmUmShEqVKqFLly6YOXMmFi1ahOnTp9uk2vr8eeVcbJs2QOHCGf7wlM0ULFgQixYtwpkzZ6DRaFC6dGm7LXbL7nbt2oWgoCDUrFkTefLkAQCYzWZs3boVp06dwsSJE+Hh4WHjKP8bq9WKzZs3Q61Wo169enBzc4MQArt370Z8fDzq16+PnDlz2jrM18akNdGfJElKu9z02rVrsFqtcHV1xYABA5CSkpIpGvQnJydjzpw58PT0RPv27WEwGGwdEhER/QdNmzaFq6srwsLCEB4ejrCwMISGhuLSpUsIDw/H06dP4eDggB7586OWwQAkJwNGI2AwKIuLC+DlBeTMqSwFCwJFiwIrVwKDBgEtWigPdPIkMHUq0Lw5kD8/r5umDKdWq9PamxUqVOiF71ssFiQlJaVVXptMpudupya7Q0NDERISgrCwMISFheHmzZsIDg5GTEwMypYti7Fjx3J/iCiDODo6onv37vjxxx+xevVqNGzYEH5+fm/t8YRQPgbv3VNagKS2rC9RApgxA6haFXj8WLm4SKtVvhcVpQxpzJmTFdiUfiRJQrVq1WwdBv2LpKQkWK1WhISEwGq1QqPRQKVS4eLFi1i1ahUcHR0xZcqUTHXSISoqChs3bkSpUqXSripLSEjAypUrUaxYMdSvX//1rtK0E9xME/1JkiQ0adIELVq0wMGDB7Ft2zZ069Yt0xzoCCGwb98+XLhwAS1btkSNGjVsHRIREf0HKpUKpUqVgre3NywWC1JSUtL+Tb1tMpkQHBwMQ0gIHB4/Vo7UHz8GHj4EgoKAyEjllzk4KEfj3t5Kv2pJAmrUUErPJEk5khdC+bn8+W36vIleRqPRwMnJCU5OTi98L3VQo9Vqfe79kfqv2WxGXFwc3N3dUaBAARtET5R95cuXD2PHjsV7772HadOmoUKFCm91ANiDB0DbtsCoUUC/fspH3KFDykVHefIAu3cDw4cD+fIp9z92DLhwARg2DPhzJBARZRNdunTBjh07cOXKFaxYsQKDBg2CRqPBRx99hOPHj2PNmjXw8fFBnz59MsUVWkIIbNmyBTExMWjQoAHy/bmh27t3Lx4+fIhBgwahWLFiNo7yzTBpTfSMggULYuLEiQgKCsInn3yCihUrokyZMplig2UymbBs2TJIkoQPP/wQ2tRyAiIiyjRSr/rRaDRwdHR84ftCCJQsWfKvgYrKyr8WkwkIDVWO4h89AqxWpW2IRvN82xAHB+XrxMSMeWJE6Si1n6hKpYKDg8ML3xep7w0gU+zDEWUlkiTB19cX/fr1w4oVK7BkyRKMHz/+pe/V9JCSAjx5Ahw5AtSsCZQtC8TGKh9zZjMQHa18FKZKTARiYpTxDkSUvRQtWhTr169Hy5YtMX36dBQtWhSNGjVCzpw5sWrVKjRq1AhfffUVSpQogTp16th9hXJiYiKWL18OLy8vtGvXDiqVCikpKVi6dClcXV3RsWPHTN9X3b7/B4gymCRJqFixIj766CMkJydjzJgxCA0NtXVY/0oIgUOHDuHixYto2LAhq6yJiLKo1GSdpFJBUquVxLNGoxyda7VKgtrHB2jcGOjTB+jfX6mwTkhQKrJT3bunXFP9krYMRJld2vuECWsim1CpVBg7diyKFSuGbdu24bfffoP8D1liIUTaFRKJiYmIi0tGTIxARATw9CkQHKycg71/H7hzR7mo6Pp1Zbbw9evK+dpixYAiRZTxDQkJz//+xETlZ2/dUpbQ0L/O+RJR9iJJEkqVKoV58+YhOTkZM2fOxPXr1wEA3t7emD9/PkJCQjB//nzcv3//uZPg9uiHH37A/fv34evrqxS1APj5559x6dIlVK1aNUu0rMncKXeit6R79+74448/8N1332HVqlUYPnw4jKlN0uxQdHQ09uzZA5PJhI8++sjW4RARkT3Jmxdo0ACYNw/o0EFJbh86BFSrpjT1ZGKPiIjSmYeHB8aPH4+hQ4fiq6++wt27dyFJEqxWK5KTk9Na+6SkpMBsNqctLi4t8PRpLSQkaJCSolRLm83KeVaLBUhKQtp6Nzdg1ixlBnGrVsBXXwFnzz6flA4JUeYQu7oqX1++rLQNIaLsq3nz5hg5ciTmzJmDRYsWYfLkyciRIweaNm2KwYMHY8mSJfj222/x+eefw2g02uVJ8ISEBGzbtg0WiwX9+/eHJElpQyVNJhMGDRpkk0G46Y1Ja6KX0Ol0GD16NC5evIjVq1ejcuXK8PPzs9vLQ86fP4/jx4/Dz88PlSpVsnU4RERkT9RqYOBAYP9+5WhdlpVq7EaNlCN9IiKidKZSqVCnTh3UqVMH+/btw7FjxyDLMmRZTus/b7VaYbFYoNVqodPpoNPpUKZMUYSG1ki7iEivB3S6vxZX179u58ypjGoAgNKlgXr1lLnDOXL8NXgxZ05lBnHu3Mo5WqNRaSdCRNmXRqNBnz59cPfuXQQEBKBUqVIYOHAgnJyc0L9/f9y8eROrVq1CiRIl0K9fP1uH+1Lnz5/HuXPnULNmTVStWhUAcO3aNZw8eRKlSpWCr6+vbQNMJ0xaE/2D/PnzY8KECejVqxeWLFmCMmXKIH/+/HZ3li0uLg6HDx9GaGgo+vbtC71eb3cxEhGRjXl6Ap06AfHxStLaYFCO+Pl5QUREb0lCQgJu3LgBb29vdOvWDfnz54dOp4OTkxMcHR1hMBig1+uhVquhUqkgSRJ0Oi9YrQ5pc4NVqheX1PVqtTJPGFA6ZXXtCvzwA3D+PNCunbLeaFTO0xYsqHx96ZJSfU1E2ZckSfDy8sIHH3yA69evY+rUqShXrhzq16+PfPny4eOPP8a1a9fw+eefo1y5cqhevbpd5VgsFgt++ukn3L9/H9OmTYNWq4UQAseOHcPt27cxa9Ys6PV6W4eZLpi0JvoHkiShdu3a+PDDDzF16lSsW7cOo0aNgk6ns5sNlhAC9+/fx7Zt29C4cWOUK1fObmIjIiI7o9Eo11ITERG9ZRaLBRs2bMDDhw8xe/Zs9O3b97lL1Z89Znnd4xchlOS1Tqd87eICTJ4MtG6tfOSpVErF9bO/Xq1WKrh5yESUvalUKpQtWxYjR47EiBEj0L9/f/z0008oUKAAKlWqhPHjx+ODDz7A4MGDsX37dhQuXNhuci13797F8ePH4ePjg/r16wMAHj16hKNHj8LDwwMtW7a0m1jflH32OiCyA5IkwWAwoEOHDmjYsCHmzZuHX375xdZhPSclJQV79uxBaGgoWrVqhVy5cmWZjRMREREREWVODx48wNKlS1GrVi00btwYDg4OUKlUaUt6DUzNmVOZOZyaiK5YEViwQBnlULQo0KbNX/2sAaB8eaBZM6XtCBFlb5IkoUWLFnj//fcRHh6ODz/8EE+fPoVKpUL79u0xbNgw3L59G5MmTUJ4eLitwwUAWK1WnD9/HufPn0eXLl3g7OwMIQSuXLmCU6dOoVOnTvDw8MgyeSEmrYn+RdGiRfHBBx/Aw8MDY8aMwd27d20dEgClyjo0NBSrVq1C1apVUadOnSzRaJ+IiIiIiDIvq9WKuXPnIjExEf7+/ihSpMhbeRxJUrpfde6sJK1T17VrB9SqBRQqBDRurFRgpypZEvD1ZdKaiBRqtRqDBw9Gly5dcOTIESxatAgxMTGQJAkjRoyAv78/fvjhB6xZswZxcXG2DhexsbE4ePAgXFxc4OvrC51OB5PJhCNHjkAIAT8/vyzTGgRg0proX0mSBF9fXwwcOBDXr1/H9OnT7WJjBQCbNm3C06dP4efnh8KFC9s6HCIiIiIiyuZOnjyJ7du3o3LlynjvvfeyTMUfEWVNTk5O+Oyzz1CrVi2sXr0au3btgtlshtFoxLhx41ChQgUsWbIEx44dg8VisVmcQgg8fPgQe/fuha+vL4oVKwYACA0Nxfbt2/HOO++gVKlSUKmyTqo36zwTordIp9Nh0KBBaNSoEQIDA7F+/XrIsmzTmKKiorB48WLkz58f/v7+0GjYop6IiIiIiGwnKSkJCxcuRFxcHIYPHw4vLy9bh0RE9K/y5s2LadOmwdnZGXPnzsXly5cBAMWKFcPo0aOh1WoxYcIEPHjwAEIIm8RotVqxc+dOWCwW+Pr6wsPDA7Is4+DBgwgLC0PdunWRK1cum8T2tjBpTfSKXFxcsHDhQri4uGDlypU4ffq0zTZWQgisWrUKYWFhaNeuHYoWLWqTOIiIiIiIiADlGGX//v04ceIE6tWrh+bNm7PKmogyjUqVKmHSpEl48uQJJk+ejLCwMKhUKvj6+mLo0KF48OABPvroIyQmJtokPpPJhNWrV6N06dKoXbs2VCoVzGYzli1bhhIlSqB+/fpZrmUsk9ZE/0G+fPkwa9Ys3Lt3D8uWLcPTp0/fauJaCIGUlBQkJiY+9zhPnjzBxo0b4e7ujr59+3JnkIiIiIiIbCoiIgIBAQFISEjAxIkTs9Ql6kSUtUmSBI1Gg2bNmqFfv344fPgw5syZg8TERDg4OKBHjx7o0KEDDh48iNmzZ8NkMmV4jDt27EBISAjq1KmTNivg+PHjuHbtGqpXr47SpUtneExvG/sJEP0HarUajRs3Rrdu3bBx40ZUq1YNffv2hVar/c+/y2q1wmQyIS4uDklJSWm3TSYTEhMTER8fj7i4OMTExMBqtWLkyJFwcHCALMsIDAzEnTt38MEHH6BQoUJv4ZkSERERERG9GqvViuPHj+P48ePo3LkzKlSowMIaIsp0XFxcMGDAAFy/fh3ffvstvL290bt3b7i6umL06NEICgrCwoULUbRoUXTp0gUOqVNg3zKTyYQVK1YgZ86caNu2LVQqFVJSUrBkyRK4ubll2ZaxWe8ZEb1lbm5uGDBgAC5cuIA5c+agcuXKqFatWtpOmcViQVRUFKKjoxETE/Pc7ejo6LTFZDIhISEB8fHxSE5OhslkQnx8PJKSkpCYmIiEhAQkJCRAo9EgT548GDZsGBwcHPDo0SPs378fTk5O6Nu3r41fDSIiIiIiyu7CwsIQEBAAR0dH9OjRAzqdztYhERG9lqJFi+Kzzz7DzZs3MWPGDOTNmxfNmzdHkSJFMGPGDHTt2hVz585FgQIF4OvrmyEn6H755RdcunQJTZs2RYUKFQAA586dw8mTJ1GpUiXUqlXrrcdgC0xaE/1HkiShVKlSGDhwID755BN88skn2Lt3L5ycnAAo07I//fRTREZGIiUlBWazGSkpKS/cliQJLi4uyJ07N3LmzIm8efMid+7c8PDwgLu7O3Lnzo1cuXLB1dUVOp0OOp0OQgicPHkSp06dQv/+/ZE/f34bvxpERERERJSdWa1WnD59Gvv27cPAgQNRtmxZtgYhokytUqVKmDdvHjp06IC5c+eiSJEiKFWqFKpUqYLZs2ejf//++Prrr1GoUKEMmTHm5OSEunXrpl3pL4TAxo0bERcXh169esFgMLz1GGxBEraaJEeUySUnJ2PUqFFYvXo1hg0bhqlTp0Kj0eD06dMYPnw49Ho9cuTIkZZ8zpkzJ3LlyoU8efIgZ86ccHJyglqthkqlgiRJUKlUL+zcSZIEIQRkWYYQAvfu3cPw4cNx9epV7N27l5fdERERERGRTcXFxaF169YICwvDkiVL8M477/AYhYgyvZSUFCxatAjjxo1D7969MXXqVHh6eiIxMRELFizAF198gY8++ghjxoyBk5PTW93uWa1WJCcnQ6fTQa1W48aNG+jatSuioqJw+fLlLJu0ZqU10WvSarWYOHEizpw5g1WrVqFGjRpo1aoVqlatihMnTrxwfyEELBYLLBYLUlJSkJycjMTExLQK7NQq7Li4OISHhyMsLCzt37CwMDx9+hQXLlxAREQE/P39kTt3bu4MEhERERGRTe3duxcnT57E+++//1zbRCKizMzBwQG9evXC5cuXsXnzZpQpUwb9+/eHXq9Hjx49cPnyZSxcuBA+Pj7o2rUr1Gr1W4tFrVanJaYtFgsOHz6Me/fuYcyYMdDr9W/tcW2NldZEb+jo0aPo1q0bChQogE8//RRFixaFxWJBQkICTCZT2pI6WDF1uGJkZCRiY2MRGxuLyMjItF7XCQkJcHR0hNFohMFgSFtSN0S5c+fG8OHDUbNmTV52R0RERERENhMaGoqmTZsiOTkZ69atQ9WqVW0dEhFRuhFC4MqVK/jwww9x9+5dLF26FH5+fgCAU6dOYfjw4TAajdizZ89br3ZOLYS8cOECPv30U5w+fRq///47vL29s+zJQiatid6QxWLB9OnTMXnyZOTLlw/58+dHSkpK2iDF1CUpKQlGoxFubm5wcXGBh4cHnJ2d4ezsDA8PD7i6usLJyQleXl5wcnKCk5MTDAYDjEYjjEYj9Ho9JEmCm5sbcuTIwYQ1ERERERHZjBACs2bNwrRp0zB8+HBMnjwZGg0v5iairMVisWD//v346KOP4OLigu+//x4lS5aExWLBjz/+CJVKhXfffTddt39msxmRkZEICQlBaGgoQkJCEBISggcPHuDixYs4ffo0GjRogA0bNsDNzS3dHtfeMGlN9IaEEHj06BGmTp2K/fv3w9vbG4UKFYKXlxdy5MgBLy8veHl5wc3NDVqtNm3R6XRwcHCAg4MDdDodtFotNBoNdDpdlj1LRkREREREWcPVq1fRtWtXREdH48SJE8iXL5+tQyIieiuSkpKwZMkSTJw4EfXr18fatWvh4eEBq9WaNqfsv5JlGZGRkbh//z7u37+Pe/fupd0ODQ1FUlISEhMT0xaTyYSkpCQ4ODigYsWKmDlzJt5555232pbE1pi0JkoHQggkJSUhOTkZGo0mbajis4skSUxGExERERFRpme1WjF58mTMmzcPM2fOxAcffMBjHSLK0pKSkjB48GBs3boVQ4YMwbRp06DT6dK+L4SAEAKyLEOW5bTbKSkpCA8Px927d3Hr1q205fr163j69CmsVmvaz6YuWq0WBQsWRLFixVC8ePG0pUSJEjAYDHBwcIDBYHjthHlmwaQ1EREREREREb0SIQTOnDmDwYMHQwiBI0eOwMXFJUsnToiIhBCIjY1FixYtcOPGDYwZMwatW7eGWq1GcnIyEhMTERISgrt37+LevXu4c+dO2m2TyQSdTgdHR8fn/nV1dUWhQoVQpEiRtKVw4cIoVKjQP1ZQZ6dtLZPWRERERERERPRKEhISMHfuXHz11Vf46quv0LlzZ/ayJqJsQQiB3377De+99x7i4+ORK1cuODo64unTp4iOjk5LRD+7uLu7I3fu3MibN+9zS548eeDk5MR5Zf8Hk9ZERERERERE9K+EEDh//jy6deuG4sWLY8mSJcibN2+2qvwjouzNZDLhu+++w9q1axETE4MqVaogf/788PLygqurKzw8PODu7g5PT0+4u7vDw8MDjo6O3E6+Bp4OJSIiIiIiIqJ/lZycjE2bNiE8PBxjx45Frly5mIghomzFYDCgZ8+e8PX1RXJyMnLlygUnJyc4OjqyajqdsdKaiIiIiIiIiP4vIQRu376N6tWro27duli8eDHy5ctn67CIiCiL4ikAIiIiIiIiIvpXFy9eRLFixdCpUyfkzZvX1uEQEVEWxkprIiIiIiIiIvpXsiwjODgYzs7OcHFxsXU4RESUhTFpTURERERERERERER2g+1BiIiIiIiIiIiIiMhuMGlNRERERERERERERHaDSWsiIiIiIiIiIiIishtMWhMRERERERERERGR3WDSmoiIiIiIiIiIiIjsBpPWRERERERERERERGQ3mLQmIiIiIiIiIiIiIrvBpDURERERERERERER2Q0mrYmIiIiIiIiIiIjIbjBpTURERERERERERER2g0lrIiIiIiIiIiIiIrIbTFoTERERERERERERkd1g0pqIiIiIiIiIiIiI7AaT1kRERERERERERERkN5i0JiIiIiIiIiIiIiK7waQ1EREREREREREREdkNJq2JiIiIiIiIiIiIyG4waU1EREREREREREREdoNJayIiIiIiIiIiIiKyG0xaExEREREREREREZHdYNKaiIiIiIiIiIiIiOwGk9ZEREREREREREREZDeYtCYiIiIiIiIiIiIiu8GkNRERERERERERERHZDSatiYiIiIiIiIiIiMhuMGlNRERERERERERERHaDSWsiIiIiIiIiIiIishtMWhMRERERERERERGR3WDSmoiIiIiIiIiIiIjsBpPWRERERERERERERGQ3mLQmIiIiIiIiIiIiIrvBpDURERERERERERER2Q0mrYmIiIiIiIiIiIjIbjBpTURERERERERERER2g0lrIiIiIiIiIiIiIrIbTFoTERERERERERERkd1g0pqIiIiIiIiIiIiI7AaT1kRERERERERERERkN5i0JiIiIiIiIiIiIiK7waQ1EREREREREREREdkNJq2JiIiIiIiIiIiIyG4waU1EREREREREREREdoNJayIiIiIiIiIiIiKyG0xaExEREREREREREZHdYNKaiIiIiIiIiIiIiOwGk9ZEREREREREREREZDeYtCYiIiIiIiIiIiIiu8GkNRERERERERERERHZDSatiYiIiIiIiIiIiMhuMGlNRERERERERERERHaDSWsiIiIiIiIiIiIishtMWhMRERERERERERGR3WDSmoiIiIiIiIiIiIjsBpPWRERERERERERERGQ3mLQmIiIiIiIiIiIiIrvBpDURERERERERERER2Q0mrYmIiIiIiIiIiIjIbjBpTURERERERERERER2g0lrIiIiIiIiIiIiIrIbTFoTERERERERERERkd1g0pqIiIiIiIiIiIiI7AaT1kRERERERERERERkN5i0JiIiIiIiIiIiIiK7waQ1EREREREREREREdkNJq2JiIiIiIiIiIiIyG4waU1EREREREREREREdoNJayIiIiIiIiIiIiKyG0xaExEREREREREREZHdYNKaiIiIiIiIiIiIiOwGk9ZEREREREREREREZDeYtCYiIiIiIiIiIiIiu8GkNRERERERERERERHZDSatiYiIiIiIiIiIiMhuMGlNRERERERERERERHaDSWsiIiIiIiIiIiIishtMWhMRERERERERERGR3WDSmoiIiIiIiIiIiIjsBpPWRERERERERERERGQ3mLQmIiIiIiIiIiIiIrvBpDURERERERERERER2Q0mrYmIiIiIiIiIiIjIbjBpTURERERERERERER2g0lrIiIiIiIiIiIiIrIbGlsHQEREZHMpKcCjR0BkJJArF5AvHyBJto6KiIiIiIiIKFti0pooExNCKP/+w/clABITb0QvJ4SyXLoEjBsHnD8PqNWALAN16wKTJwMlSjB5TURERERERJTBJJGa9SKiTMcqBIJMJoSYzS/9fnGDAfl1ugyOiiiTEAIIDgbatwfKlAFGjwYKFQKuXwc+/1xJYC9cqFRdExEREREREVGGYaU1USZmEQKbnj7Fj9HRyKXVQvu3itBeuXMzaU30/+zeDSQkAJ9+ChQrpqwrVw6YNAkYMgQ4eRJo147V1kREREREREQZiElrsmvW/3MhgEqSwDSSooBOh965cyPf3xLUubVaG0VElEmcOAEULAgUKfLXOkkCcuZUelvfvw9YLICDg+1iJCIiIiIiIspmmLQmuxVrseDzu3cRb7W+8D0XjQb98uRBWaPRBpHZH4NKheJ6PYrq9bYOhShziY4G3NwAler59Q4OgLMzEB8PWK1MWhMRERERERFlICatyW5ZhMAVkwmOKhWqODk99z2jWg3HvyeZsjkBQH6mMj21Cp2DGIn+Dzc3ICJC6W/97HvFbAZiYgAnJ0DDj0oiIiIiIiKijMQjcbJ7pQwGTCpc2NZh2LUYqxVn4+LwKDk5LVntptHA22CAI5PWRP+sXj1l2OLt20pPa0n6a0BjZKSyTq22dZRERERERERE2QqT1mTXWC38aoLNZmx8+vS5QYzlnZwwSKdjRTrR/9OyJRAQAMyZA/TsqVReP30KrFkDFC0KVK3KIYxEREREREREGYxJa7Jr4s/F8reBjCoogxhJUUCnQ69cuZDnmUGMzmo1XFghSvQ8IYDLl4E7d4B33wVy5ACmTAG++w5YtEjpXW02A3nzAr16Afny2TpiIiIiIiIiomyHSWuyb0LgfHw8PggKSlslAajv6oouuXLZLi478Gz/aqNKBW+DgYMYif5NRASwbBlw+DCwcSNQoQJQrZrSBiQ4WElYOzoqSWt3d1tHS0RERERERJQtMWlN9k2SoJUkeDwzCE2SJBizYQWxAAAhkCTL+DEqChcTEjCUVaBEr85qBU6eBL7/HmjfHihQ4K/vubkBnp5sBUJERERERERkB5i0JrtXxmjE9CJFXvq9FFmGAOAgSVm677UQAilC4HZSEtaGhODXmBi4Ozigo9ls69CIMofU4YpTpvzV+sPDA5Bl4NgxYMcOYORIoFAhJq6JiIiIiIiIbIxJa8oUXpaQloXAmbg43E9KQhmjET4GA7RZcOigEALBZjOORUdjS1gYkmQZjdzd0TlnTuR3dLR1eESZg8UCfPUVcPMmMHasMmARAEJCgEmTgPBwpfq6UCGbhklERERERERETFpTJmb5s/J4dXAwvBwc8K67O951c0NxvR7qLFIpGW+14rfYWOyLiMDvsbEo7+SE1l5eqO3iAheNBhYhUMPFBT4WC1w1fDsT/aODB4HVq4E6dYBu3QCdTqmyXrwYuHgRGDVKSWRnkW0HERERERERUWbGLBdlWhpJQmN3d+RycMCuiAisDwnBLzExeMfVFW08PZFbq820LUOEEHiYnIwNoaE4FhMDWQgMyJsX77q5IZ9Ol5aUVwNo4O4OAUCbSZ8r0Vv34AEwfbqSkP7kEyB/fmX9oUPA8uVApUpA796AwWDTMImIiIiIiIhIwaQ12TU1ANU/JGNVkoRcWi0auLujmosLTsTEYG1ICL4LDcWPUVFonyMH3vPygoMkAZKEzJDSFUJABnA4KgpLnzxBWEoKqjo7Y2CePCiq10P3t/YnkiRBx2Q10T+zWIClS4Hz55Vq6rp1lfVhYUoiOzkZGD/+r0Q2EREREREREdmcJIQQtg6C6GVSZBnn4+PhotHA518qIFP/jGMsFuyIiMDu8HCEmM0o7OiIPnnyoKqzM5zVarttGyKEgFkI3E9KwvLgYJyIiUEurRYdc+ZEK09PGP9MVmfWynEim5BlpS3IsGGAszNw5Ajg4gKYzUrCet48YNAgYPZstgUhIiIiIiIisiNMWlOWIwDcS0zEjvBwnIyNxdM/q5VbenqivNEId43GrpK/shAI+XPQ4uawMCTKMqo7O6NzzpwobTRmigpxIrsjBBAcDHz8sZKsXrMGaNxY+d6xY8DQoYBeD+zbB+TMadNQiYiIiIiIiOh5bA9CWY4EoIhej2H586NBQgKOREfjl+hozHzwANWcndHAzQ3VXFzgpFbbOlQkyzJ+jYnBrogIXIqPh4/BgOaenmjg5ga9HcRHlGmlpAC7dgE//gj07QvUqgWoVEBICLB2LRAdDcyYAXh62jpSIiIiIiIiIvobJq0py1JLEsobjSih1+NdNzccjorCvogInIuLQ0UnJ7T28kIlJydo/9YnOiMIIXAtKAiBkoTfkpIgC4FuuXKhobv7c4MWiei/E0Ig9P59yAEByFuyJNC1q9IeJCUF2L8f2L0b6NULqF8f4MkhIiIiIiIiIrvD9iCULQghYJJlPEhKwpqQEPwcEwMXjQb1nJzQzdUV+d3coFKp3mrbkNS3mslkQkBAAObNn4+iw4cjf506GJw/P4rr9dBJkl21LiHKjKxWK7p364bgU6cwd+pUVOncWUlOP3wINGoEeHgA33wDVK7MXtZEREREREREdijjS0yJbECSJBjVapQ0GDCtSBEsKF4cRR0dcfbSJdStWxcff/wx7t+/j6SkJLyt8zhmsxlXr15F3759MXToUMTHxaGlSoV5xYujjMEAx7ecNCfKDmRZxoYNG7Bj507krlEDPm3aABoNUlJSIE+ZAkREAD16AJUqMWFNREREREREZKdYaU3ZVqzFgt1792LNN9/g3Nmz8PLywqBBg+Dn54cSJUpAq9WmSxLZarXi0aNH2L17N2bPno3k5GT4+flh5MiRKF++PNRsT0CUbq5du4b27dsjOTkZmzdvRpUqVSDLMnZu2waHzz9H/YoV4fzNN+xlTURERERERGTHmLSmbO/JkyfYtWsXdu3ahd9//x3FixeHv78/WrZsiVKlSr1R4jo2NhaHDx/G+vXrcfDgQdSsWRO9evVCixYt4MmkGVG6ioqKwrhx47B+/XrMmDEDQ4cOhSRJuHr1Knr06IG4qCgc2bYN+SpVsnWoRERERERERPR/MGlNBKWlwL179/DTTz9h9erVuHLlCkqXLo127dqhS5cuyJs373/6fUIIBAUF4auvvsKePXsgSRIGDhwIf39/eHt7Q2WD4Y9EWZksywgICMDIkSNRs2ZNrFq1Cq6uroiLi8Nnn32GZcuWYcaMGRg2bBjff0RERERERER2jklroj8JIZCSkoKQkBDs2rUL06dPR3x8PEqXLo1hw4ahTZs2MBgM/7fyWggBi8WCrVu3YvLkyXj8+DHq1auH8ePHo2LFitDr9exbTZTOhBC4ffs2PvjgA1y7dg2BgYGoXLkyAGDHjh0YPnw4ypQpg02bNsHV1dXG0RIRERERERHRv2G5GdGfJEmCVqtFgQIFMGTIEJw/fx5Dhw7Fw4cPMWDAALRq1Qo///wz4uLiIMvycz8rhIDZbMaFCxfQsWNHDBgwAImJiZg8eTI2btyIWrVqMWFN9BYIIZCUlIStW7fil19+wciRI1GmTBkAwL1797Bq1SpYLBZMmTIFLi4uNo6WiIiIiIiIiF4Fk9ZEfyNJEtRqNXLmzIkpU6Zgz5496NatGx48eICmTZvigw8+wLFjxxAZGQlZliGEwKNHj7B8+XJ06tQJJ0+eRMuWLbFnzx6MHDkSLi4ukCSJCWuit+T8+fP45ptv0LBhQ7Ru3RqOjo4wm83YsWMHfv75ZwwdOhSlS5fme5CIiIiIiIgok8h+7UGEACwWwGwGdDpAo7F1RJQJmEwmnDhxAlu2bMHhw4dhsVjQunVrNGvWDImJidi8eTOOHj2KChUqoHv37ujQoQOMRiOTZJQtpLbFOX/+POLj45E7d24YDAbodDpotVpotVrodDpoNJp0f09ERUWhc+fOuHbtGhYsWIC2bdtCkiScOnUKXbt2RfHixbFw4UL4+Pik6+MSERERERER0duTfTK2Vivwxx/A3r3AtWtK0trJCShXDmjXDihSBEhNppw+DXz3HdCmDdCgwYu/5/hxYM8eoFcvoHz5jH8ulOEMBgMaN26MatWq4bfffkNAQAC2bt2KAwcOwGQyQQiB999/Py1JpuHJEMpmpk6dit27dyMxMREeHh5wdHSEVquFg4MDNBoNHBwcoFarodVq4eTkBJ1OB4PBAL1e/9w6vV4Pg8Hwf9fp9XrodDoAwNKlS/Hrr7+iX79+aNy4MVQqFUwmE6ZMmQKz2Yx+/fqhWLFiNn51iIiIiIiIiOi/yB6ZtZQUYOtWYPp0ICwMqF4d8PAAHjwADh9WEtTLlinrJQm4fx/YsgXw8XkxaS0EcPMmsG0b0LAhk9bZjJubG/z8/FCtWjU0bdoUo0ePhtlsxr59+1CqVCk4OTmxupqyFSEErly5goULF8JkMiF//vwQQiAhIQGhoaGIj4+HyWRCXFwczGYzAKRVXKvVaqhUKqhUqrTbL1uXeluSJGg0GqhUKuj1ejg6OuLq1atITk7GwYMHkTdvXgwYMABr167F8ePH0bFjR7Rs2ZInkYiIiIiIiIgymax/JC8EcO4cMHUq4OUFbNgAeHsryWlZBg4dAoYNU6qmf/wRyJdP+ZnU5Z9+ZzbrqkJ/UalU8PT0hJ+fH+bOnQur1YqqVatCpWKLeMp+kpOTMX36dJjNZgwfPhyTJ09+7sRNageq1H+TkpIQFRWFpKQkxMbGIiEhASaTCdHR0UhMTERcXFxaovvv6xITExEVFYWEhAQ8ffo07XcaDAbcu3cPkydPRnx8PNasWYPcuXPj888/h8FgyPgXhYiIiIiIiIjeSNZPWicmKq08YmKA+fOBMmWAZ5OLrVoB9+4B48YBq1cDn31ms1Apc0nt0ZuYmMjqasqWLBYLNm7ciAMHDqBhw4aYMmUKHB0d/+/PGAwGeHh4vNHjCiGQnJyMhIQEJCYmIjQ0FEePHsXixYsxb948SJKEb7/9FkWKFHmjxyEiIiIiIiIi28j6paEmE3DsGFCpktLu42XVsJ07Aw4OSq/q5OSMj5EyJa1WC7VajaSkJMiybOtwiDLctWvXsHLlSri6umLq1KlwdHSEEAJve76vJElwdHSEp6cn8ufPjypVqmDgwIHo3LkzrFYrKlSogHbt2r3VGIiIiIiIiIjo7cn6ldYpKUoltZ8f4Ob28vt4eQG5cgGRkUBU1F/rAwOVn32WLAOXLr2lYCkzUalU0Gq1sFqtMJvN0Ov1tg6JKMNER0fju+++w5UrVzB9+nSULVsWAHD9+nUcPXoUfn5+KFq0aIZdheDs7Iw2bdpgz549iI6ORnJy8r9WfRMRERERERGRfcr6SWshlBYhWq1STf1PnJwAi+X5Suvbt4GEhBd/39OnbydWynR0Oh0ApU8vk9aUXciyjHPnzuG7776Dn58f2rZtC5VKhYSEBAQEBGDhwoXIlSsXChcuDLVanWFxVaxYEY0aNcLSpUuxefNmDBgwgK17iIiIiIiIiDKhrN8eRKVSEtJJSYDZ/PL7CAFERwMaDfDs0K5hw5ThjM8uhw4BI0ZkROSUCej1ekiShMTERFuHQpQhhBCIiIjAjBkzoNPpMGDAAOTOnRtCCJw7dw7Lly9HnTp1UKNGjQwfTqrVajFw4EDkypULc+fORXh4eIY+PhERERERERGlj6yftNZqgZIlgQcPgLCwl9/n0SMgOBjImxfw9Hz+Zw2G5xe9XllPBCatKfuRZRlr1qzBiRMn0K1bN9SuXRsAEBERgS+//BIqlQqDBg1Cnjx5bFLl7OPjg+7du+PJkydYsWIFLBZLhsdARERERERERG8m6yetDQagYUPg2jXg9OkXq62TkoCVK5WK7ObNXz6okegfpPbMZdKasoszZ85g3rx5qFatGrp16wbDn1enbNiwAUePHkXHjh1Ru3btDK+yftbgwYORJ08ebNu2DTdv3rRZHERERERERET0erJ+hlanA5o1A4oXB+bNA77/HnjyROlVfesWsGiRkrSuWxfw97d1tJTJODo6QpIkmEwmW4dC9NY9ffoUkydPRnJyMoYOHQpvb28AwOnTpzF37lyULl0affv2haurq03jzJ07N0aMGIGbN28iMDAQSUlJNo2HiIiIiIiIiP6brJ+0liTA2xuYOhVwcQHGjweaNgXq1wdatwZmzQLq1AG+/hrIkcPW0VImw0pryi5S24L88ssv6NKlC1q2bAmVSoW4uDhMmzYN0dHRGDFiRFoi29batm2L0qVLY8+ePay2JiIiIiIiIspkNLYOIEM4OCiJ6cBA4LffgF9/BWJilB7WdesC5copwxpTVakCfPml8u/fqVRKwtvFBShbNuOeA9ml1EprJq0pKxNC4OTJk/j+++/h5eWFiRMnQq/XQ5ZlrFy5Ej///DNatmyJdu3aQa1W2zpcSJKEnDlz4v3338eQIUNw+PBReHv7wNFRZ+vQiIiI6FUJobR2vH5dOYaLjQVKlADq1QPc3NjWkbIcIQRkyEgRKRAQkCDBQXKARVhwxnQG7hp3lHYsbeswiYgyTPZIWgOAWg24ugJNmgCNGgF37yo7O15eyvefHRhWpIiyvIxKpQx2LFnyrYdM9o+V1pTVCSEQERGBtWvX4t69e1i1ahW8vLwghMDZs2exfv16eHh4YPbs2XBwcLB1uGnUajXeeecdNGzYE3v3eqJNG4GiRZ/f1BMREZGdEgKIj1daOW7cCBQtCri7A9u2KVfITpsG1KihHOMRZRGxciwOxR7CwdiDiLJGwU3thpauLVHFUAWrI1ajvL48k9ZElK1kr9PTkqQsUVFK/+pVq5Qdor9nMVLv90/ZjX/7PmUbrLSmrM5iseDQoUPYs2cPOnfujAYNGkClUiEyMhLr16/H/fv3MXHiROTJk8fWoT5HkiQUKFAQrVsvwMWLXbFxoyOsVltHRURERK/s11+BLVuAL74AAgKUY7e9e5XiocWLgdBQW0dIlG6swoqvnn6FScGTkMchD9q4tkEJXQmsiFiBkJQQW4dHRGQT2afS+llWK3D7NvD4sXKbl5bRa9Lr9QBYaU1ZkxACjx49wvz585EnTx706dMHrq6usFgsOHr0KAICAtCqVSs0b94cKjvcjjo4aNCwoQYVKwJLlwKdOilXFRMREdF/ZzabER4eDovF8so/owHgJUnQCvHfHix3bqW1Y/HiylWyqVdzeXgoH+jjxwN37ijtHomygOtJ17EsfBnG5R6HgV4DoZE0EBB4L+k9uKhdbB0eEZFNZM+ktSQBOh2QkgJYLH/tBBH9R6y0pqxMCIG5c+fi9u3bGD9+PCpVqgRJkhAREYE5c+YgR44c6Nu3Lzw8PCDZ6ZUnBQsqF9aMGwfMmwcsWWLriIiIiDKnW7duYdSoUQgODoYkSRB/JqL/fhtA2tfF9Xos9/SE9tEj5Rgs9SrX1CR26v7Ds1e/ShKwe7eSlC5XDvizSCTtex4eSluQ6Oi3/pzJtpKSkmA2m+HikvWTticTTsIszOjg3gEaSUnTSJBQwrEEIiwRNo6OiMg27K80LiNIkrLzk5q0JnpNer0eapUKyUlJtg6FKF0JIXDkyBGsXr0a1apVQ7du3aDT6SDLMubNm4crV66gU6dOqFGjhl1WWadSq4EuXQAfH6UN5rlzfx0nExER0atTqVTQarXQ6XRp/77s9rNfaxwcYFWplIIhrfb5f1NvP7s+9TagfGC/7EP7n9ZTliGEwP3799G8eXPMmzcvWxQIPbU8hZPKCV5qL1uHQkRkN7JvpbWjI5PW9Ma8nZ3Rv2RJVOAQGMpinjx5go8//hju7u4YM2YMcubMCSEETpw4gUWLFqFOnTro3bu3XQ1f/CeursDIkUC/fsD8+cDy5cpHABEREb06Hx8f7NixI2MeTJaBwoWVdo5ms5LMBpRkdUyMctvVNWNiIZswGo1wcHDAli1b0LBhQ9SpU8euCyXelFFlhEk2IVkkw1HijioREZCdK62ZtKZ0UFmtxqxr19Do6VNbh0KUbhISErBw4UIEBQWhd+/eqF+/PiRJwuPHjzFhwgS4uLhgxIgRyJcvn922BXmWJAFt2gDVqwO//AIcP84CLSIiov9KkqTXXvA6S8uWwL17wJEjSuJaCCAsDNi/H8iXDyhSxNYvCb0lkiTB3d0d77//PiIjI7FhwwbExcWltZ3JiiroK0CGjDOmM7YOhYjIbjBpbbXaOhrKzBwdlb+nbHDJGmUPsizj2LFjCAgIQNWqVTFs2DCoVCokJSVh2bJlOHPmDHr16oXGjRvbOtT/RKsFxo5VirO2bgWiomwdEREREf0jSQJ8fZUhjPPnA2PGABMnAh9/DJw/r1w+lSePraOkt0itVqNWrVpo2bIltm/fjpMnT2bppHU1QzXUMNbAzNCZOBF/AuGWcNxNvoud0TuRIlJsHR4RkU0wac1Ka3oTqYNhmLSmLOLRo0dYtWoV4uPjMWnSJOTIkQMA8Msvv2DLli0oV64cPvroo0zRFuTvqlcHmjcHDh4EzpxhtTUREZHdkiTAxUXp7zVypDJZ2dERaNgQmDMHqFdPGVxBWZqXlxc6deoEV1dXfPHFF0jKwnOEDCoDZuebjRyaHBjxaARa3W6Frve6Ylv0NsTL8VBJKkiw/ysciYjSE3taM2lNb4KV1pRFCCGQkpKCAwcOYP/+/RgxYgSqVq0KQOlvvWbNGgQHB2PhwoVpiezMRJIAJyegf3/g8GFgxw6gWjXAzU35HhEREdkZSQI8PZVq6/r1lbPNGg2QlARs2ADkzq0ksTPhiXR6NSqVCvXq1UOTJk2watUqrF27FoMHD84U7elelRACZmGGBAk+Oh98nf9rRFujESfHwUXlAqPKCGe1M77M9yU02TR9Q0TZV/astFaplApZJq3pTaVOczOZbBsHUTq4efMmZs+ejWrVqqFbt24wGo2wWCw4cOAAdu/ejcGDB6NmzZqZ9kBBkoCyZZX+1lu2AFeu2DoiIiIi+lcqFaDTKfvdGg3w4IEyVXnCBOD+fV46lcVptVoMHToUBQoUwKxZs3D37l1bh5SuEkUiPn3yKbrf645oazSc1c7I75AfpXSlkM8hH9w17tBIGriqXWFUG20dLhFRhsqeSWtWWlN6YaU1ZREmkwkzZsxAXFwcevfujRIlSgAAgoKCMH/+fJQpUwZdu3aFk5NTpk5ae3oCbdsCRYsCFy5wrAEREVGmU7w40LkzEBQErFvHD/MsTpIk+Pj4YMiQIQgPD8fXX38NUxYpGJKFjF/if8G+mH2ItkZDK2kBPD/0lIgoO8u+SWudjoMY6c2lVlozaU2Z3Lp167B79240b94cLVu2hEajgdlsxpw5cxAaGoo+ffqgVKlSmX7nWZKAmjWVoYwVKz7fGsRqVYq34uJYtEVERGS3tFqgZUugRg1g2TLlLDRleb169UKVKlWwe/du/Pzzz1liKGO4JRybojYhQU7AqFyjYFAZbB0SEZFdyb5Ja0dHpcqaldb0JvR6VlpTprdv3z7MmjULbm5uGD58ODw9PQEAAQEB2LZtG3x9ffHee+9Bq9XaONL04e4OPHwIjB4N/PzzX+tNJuDTT4FffrFdbERERPQKChUCevVSjuWmTQOSk20dEb1lrq6umDBhAqKiorBp0yaEhYXZOqQ3YhVW/JrwK3ZF70J79/aoYawBlZQ90zNERP8ke24V2R6E0ktqe5CkJJZmUqa1Z88eBAcHo169eihbtiwAICUlBVu3boWzszPGjBmTlsjOKh49Aq5eVZLU8fHKOqtVWRcZadvYiIiI6F+oVMB77wF16wLHjgHbt3NfPBuoVq0aOnXqhD179uDEiROQZdnWIb0WIQTirHGYEzoHeR3yor1be7iqXG0dFhGR3cm+SWsOYqT04OAAqNVKdQdbzVAmpdfrIUkSHjx4kHappUajwcaNGxEQEIBKlSpl+rYgL9O8uXK+af585eOAiIiIMhGdDpg6Vbn9zTfA48e2jYfeKkmS4OzsjL59+8LDwwMrVqxAcHBwpmwTIiCwOnI1zpnOoY1bG1Q3VM+S+9pERG8q+yatWWlN6SH1BIgsA2azraMhei3Dhw9H+fLlcfv2bZw5cwaAcmCg1+tRq1atLLsTbTAA48crxVmnTv21XgggJAS4eFGpvL55E7h7V2kpEhwMhIcDUVFAQoKS9ObHCBERkQ1IElCmDPD++8C1a8CmTWwTksVJkoTSpUuja9eu+Pnnn7Fv375MWW0dlByEeaHzUF5fHt08ukGryhot+IiI0pvG1gHYxJ9Ja2GxALKMrJmOoQxjMCgnQJKTldtEmUzBggUxduxY9OjRA6tWrUKZMmXg7Oxs67AyRKNGwJEjwKpVynBGQElCb9sGrFunFHFptcp5Tq1W+VqnUy6y0OuVdanf1+lk6HQrodWaodPp4OjoCAcHBzg6OkKn00Gr1cLR0THtX51OB7VaDa1Wixw5ckCn09n2xSAiIsqMBg4E9u8HAgKAhg1fnLRMWYrRaMR7772H/fv3Y+7cuWjYsCGKFi1q67BemUk2YXbobERbo/F5ns/h4+hj65CIiOxWtkxap0gS9jo6YldKCoanpKCCrQOizM1gUMouWdlBmZifnx/q1auHn376CSdPnoSfn5+tQ8oQej3Qu7eSsD5yROnyI0lAvnzKMa/JpLy14+KUt3liolJhnZys9MJOTFSWlBTAaEyGEDOhUoVBo9HAwcEBarUaDg4O0Gg0L12nUqng4OAAf39/9OvXD05OTrZ+SYiIiDIPSQLy5AE+/BAYORIIDASKFweyycn37KpUqVLo2LEjJk+ejDlz5mDRokVQqTLHReT7Y/fjh9gfUN+pPjq5d4LEEjqiDHft2jV8++23MJlMKFiwIIxGIwwGA4xGI5ydnWE0GtPWOTs7w8nJCQaDAQaDAWq12tbhZyvZMmktJAkPHR2x32xGZ17XTW9KrwciIpQ+AUSZlMFgwCeffIJWrVph165dqF69Otzc3Gwd1lsnSUD58kCzZkp1dUiI0qa+WTOgQQOl848QSjJbCOXr1HWpt1O7AyUlOSAm5jvEx0fBZDIhLi4u7d9nb5tMJsTHxyMuLg6RkZEICgrC1atX0axZM5QoUSLLtmMhIiJ6KzQaoEEDCF9fiJUrIfz9oapQgZ+nWZiDgwN69eqF7du3Y9u2bejUqRPq1atn1//nQgiEWkKxPmI9YqwxmJRnElzVHL5IlNFkWUb//v3T2mJqtVqoVCpIkgSVSvWvi7OzM1xdXeHs7Jx228XFBTqdDrGxsejXrx/Kly9v19ujzCRbJq1Te7WmpKTAwqQ1vSmDQclasdKaMrmKFSuiXbt22LVrF/z9/eHr65tpqlbehE4HtG0L/PgjEBmpJLJ1OqXlx6tSZgCpAdT88+sXhwL9fZ0QAikpKfj6668xceJEBAYGYtSoUdBosuVHMxER0euRJCB/fsT16YOvIiPxeOFCzFu4EAa27cvS3N3dMX78eHTs2BGzZ89GhQoV7Lrgwmq14tj1Y7gQegFDfYaigoHXexNlNFmW8d133+HChQsoV64cRo8eDRcXF8TGxqYVGsXExCA6OjqtyCj167i4OCQkJCAyMhLh4eGQZRlCCMiyDFmWYbVaERcXh1OnTmHp0qWowJOn6SJbHhlLkgRHR0cmrSl96PVKxopJa8rEJEmCq6srunbtikOHDiEgIABVqlSBi4tLlvyw9fRUCrMkSVmKFQO6dwdCQ4HX6dChvETSM1+/2mum0Wjg7++PgwcP4ptvvkHnzp1RqFCh/x4AERFRdiZJkN95B7e3bsXmDRvQvE0btG7d2tZR0VskSRL8/Pzg7++PH374AYGBgejRo4ddnvwXQuDWrVtY8uESFM5bGEMWDIEme6ZiiGzqxo0b+Oqrr+Dh4YHly5ejUqVK/+nnZVlOu3o2ISHhuStoQ0JC8N133+HMmTM4f/48ypQpAwcHh7f0TLKPrF9C9xKSJEGn0zFpTemjXDmgcmWlNJMoE1OpVKhUqRKaNWuG7du348KFC7YOKd1ZrcCdO0CNGkDXrkriGlCSzq1bA199BVSrlrExFStWDG3btkVsbCwWLlwIWZYzNgAiIqIswM3NDf369UOePHnwxRdf4MmTJ7YOKfOKjAQOHACWLgW+/RbYswd4+jT10jK7IUkSRo0aBScnJ2zevBn37t2zdUgvlZycjB07duDKlSvwr+2P3C65s2RRCJE9i4yMxLfffotbt25h1KhRqFix4n/+HSqVCk5OTsiTJw+KFy+O8uXLo3bt2mjSpAl69uyJWbNmoVChQti8eTPCw8NfevUt/TfZNmnNSmtKN/37AzNmAAUL2joSojfm5eWF1q1bQ6/XY968eVluG/n4MTB5stK/Ondu4NnuJ87OQN26QN68qZXTGUOlUqFjx44oXbo0Nm/ejPPnz2fcgxMREWUhNWvWROfOnXH58mUsW7aMJ4Jfx+PHwNSpwMKFwLVrwK1bwIoVwPjxwJMndpW4liQJ3t7eGDx4ME6dOoV9+/Yhyc7mDAkhEBQUhCVLlqBatWpo3rw5HP9LDzoiemNWqxVHjx7Ftm3b0LRpU3Tv3j3dH0OSJPj4+KBt27b47bffcPToUSat00G2TlpbLBZYLBb+IdF/I4SyhIUB69cDX3wBfP65MrF8/XqlMiH1PkSZjEqlQsOGDVGrVi0cPnwYx44dyzLbSLMZ2LlTSVjnyqW0o7cXOXPmxPvvv4+IiAgsWbIky50sICIiyggODg4YOXIk8uXLh23btuHcuXNZZj8mQ6SkKDtK588DEyYAEycCn32mHOvcvw+sWgXY2T6KVqtF69atUaFCBSxfvhwPHz60q/9zIQRmzJiB5ORktoEjsgEhBB49eoRvvvkGOp0OI0aMgLu7+1u52sFgMKBZs2YoWLAgZs+ebXcn0TKjbJm0BpQ+omq1GikpKXb1oUaZgCwDv/wCtGoFjBgBHD+uNMI9fhwYPhxo1Ag4e9bWURK9NqPRiP79+8PZ2RmTJ09GYmKirUN6Y0IAQUHKOaZatYD27ZV29PZCkiR06tQJlStXxpEjR3D8+HF+NhEREb0GT09PTJ48Gbdv38aaNWuQkJBg65Ayj9RjmjZtgIoVATc3ZalcGWjaFAgMVBLbdkSSJBQvXhw9evTA48ePsWLFCpjNZluHBUBJlu3duxc7duxA7dq14e/vD7VabeuwiLIVs9mM9evX47fffsPgwYNRqVKlt9aeR5IkVK1aFU2aNMGNGzewceNGHtO9oWyZtJYkCWq1GlqtFsnJybxsjF6dEEpD3PHjAZNJ6fH2xx/A0aPA778rl9GZTECvXsqldUSZkCRJ8PX1RaNGjXDp0iVs27Yt03/YxscD48YpbT969gR8fDK2Bcir0Gg0GDduHMLDw7F161bExcXZOiQiIqJMR5IktGzZEk2aNMGBAwdw4sQJWK1WW4eVOcTFKVeT5s8PODj8tbMkSUChQkBwMGCHxQxqtRp+fn6oX78+li1bhosXL9o6JABAaGgoZs6cCXd3d4wcORJOrzPtm4jeyO+//4758+ejYcOGaNeuHRwdHd9qT3m1Wo2uXbuiQIECmD9/PsLCwt7aY2UH2TJpDYBJa3o9Viuwfz9w/bpSVd22rTKAUZIAoxHo3BkYOhR4+BBYvtzW0RK9NrVajY8//hiOjo74/vvvM/UwI1kG1q0DDh8GWrZULpKwt4Q1oBxk161bF35+fjh06BBOnz7NzyciIqLXYDAY8P777yMpKQkbNmxAZGSkrUPKHIRQdpJUL0kTpCax7fQEQIECBdCzZ084OjpiypQpiI2NtWk8KSkpWLNmDS5duoRu3bqhdu3aNo2HKDsKCQnBuHHjYDQa0a9fPxQpUiRDHrd8+fJo164d7t+/j3Xr1vGY7g1k+6R1UlIS/4Do1VkswN69QLFiQI0ays7bs9RqoGNHZaLbvn1KE12iTKps2bLo3r07zpw5gx9++CHTVimdPg0sWgQUKACMGqVc5WqvDAYD+vTpA5PJhJ07d9r8gIuIKKsRQuDy5cu4fv16pv1co3+nVqtRtWpVtGvXDvv27cPx48f5//0qDAblOCYs7MXk9OPHgLu7fQ0F+Rs/Pz80adIEx48fR0BAgE1jOX/+PLZu3YoiRYpg2LBhUL3sRAARvTUWiwVff/01zp07h+7du6Nx48ZvtcL6WSqVCkOGDEGOHDmwdetWBAUFZcjjZkXZdsupUqlYaU3/ndUK3LgB5MgB5M798vvkyAHkyweEhysLUSalUqkwcOBAuLi4YPfu3XY32ObfCAFERwNLlihdfT7/HPD2tnVU/1/qQXaTJk2wadMm3Lx5M1O95pR5yLIMIUTaQpSdTJo0CYMHD8aNGzdsHQq9RW5ubmjXrh1y586NGTNmICEh4bntni0Wu5crl9LL+sAB5Tgmdbh8eDhw7Bjg6wtotbaO8h8ZjUaMGzcOWq0Wy5cvx+3bt23y/xwfH4/AwEBcu3YNY8aMQd68eW390hBlK0IIHDhwABs2bIC3tzdGjhwJQwafcMufPz8GDx6MK1euYOfOnTxx+po0tg7AVtRqNRwcHJi0pv8uPl6psP6nHTZJAlxcgJAQgINfKJMrUKAA+vXrh1mzZuHEiRPInz8/NJrM8dEhy8COHcAPPwAdOgDt2r38ald74+XlhTZt2uDw4cNYtGgRli1bBkdHR1uHRVmIEAKBgYFYuXIlRo0ahQYNGtg6JKIMc//+fRw6dAhVq1ZFsWLFbB0OvUWSJKFmzZpo3rw5Fi5ciKJFi6JAgQLw8vL6159VqVQwGo1vXB0bHByMp0+fom/fvhgxYgT09jQF+mUcHYEuXYCRI4GBA5Weag4Oys7UkyfAxIkvXmlqZ0qUKIGRI0di6tSpGDVqFHx9fdP196vVauj1+v87UPHBgwdYt24dWrRogUaNGmVYdScRKfu5jx8/xtKlSxEREYHvvvsOnp6eNomld+/eWLNmDfbt24eWLVuiVKlS3B78R5kj85COhBBISEjAjRs3EBcXh+Tk5Mxx1ttG4uPjkZiYCC8vL765ACUh7eqqtP1ISlKS038ny0p5p0ajXF5HlElJkgS9Xo9WrVph27ZtWLt2LXx9fZE3b1673x4IoVwUsWaNciXrp58q7eczA0mSUK9ePdSrVw9bt27FwIED8c4779g6LMpCkpOTcerUKfz888+YOHGircMhylCBgYEQQqBly5bQZZYPBnptDg4OaNOmDS5duoQbN24gKSkJoaGhr/SzVqv1jY8Tk5OTER0djRkzZsDNzQ2DBg2y7zYRkgSULq0Mm9+wQWl3KARQoQIwdSpQvLh9Dgb5mxYtWmDWrFk4deoUTp06le6//1X+NqxWKxo2bAh3d3e7328mykqSkpKwefNmnDhxAsOHD0f16tVt8h6UJAlubm4YMmQIPv/8cxw5cgTFihXjvsd/lK2S1rIs4/Lly9i8eTO+++47REREsNL6H5jNZpw9exZ79+7F48ePUbNmTdSvXx8lS5a0dWi2pVIBJUsCT58q07Nz5nzxPiEhSiVCoUKAjc7oEaWn4sWLo23btpg3bx4OHz6MHj162P3Od2Kicqx1+TIwaVKmOcZK4+7uji5duuCnn37CzJkzsWnTJk6cp3Tz4MEDnDt3DpUqVUKxYsXs/v1MlF5MJhP2798PrVaLFi1a2DocyiC1a9fGqlWrcO3aNTg7O8P5FYpKhBDpcpwYHR2NmzdvYvLkydi0aROaNGmCokWLvtHvfOuCg4FLl5Qq608/VY5/btwAzp4FvLyUagA7/tywWCz46quvoNFo0KNHD1SuXDldP+dkWYbZbP6/fxshISFYu3YtAgMD0bJly0xR8EGUFciyjD/++AOrVq1ChQoV0KdPHzjY8OoQBwcH+Pn5YfPmzdi4cSOaN2+OwoULc3vwH2SbpHVkZCQCAgLw3Xff4ezZsyhXrhxUKhWT1n8jhEBiYiICAgLw9ddf4+LFi7Bardi0aRPeffddDB48GA0bNoTRaLR1qBkrOVmpnNZogJYtgfHjgd9/VyoRnt0IyjIQEKC0EEm9nI4okzMYDGjZsiV27tyJuXPnolWrVvDw8LB1WP9ICIHffjuJAwfuo1mz1mjd2ojM2F3D19cX7777Lvbu3YsffvgBHTp0sHVIlAUIIXD79m1cuHABo0aN4skQylYuXryImzdvonr16mwNks3kzp0buf9pHs1bVr9+fYSHh2P27NkICAjAiBEj7LvS7to1YPJkZbh8qVJK0vrYMWDcOOCnn5SktR07cOAAAgMDUa9ePYwePfqV2sGkt4SEBFgsFsyfPx+BgYEYMmTI/20nQkRvLrWrwoIFCxAXF4eJEyeiYMGCNk0QS5KEQoUKwd/fH1988QV++OEHDBw4MNO027QHdnxtUvqQZRlXrlzBhx9+iHHjxuHOnTtYsGABvvjiC7i5uSEsLAxmsznbtwhJHRrx6NEjDB48GJ988glu3bqFDz/8EAcPHkTt2rXx66+/YvDgwejZsyd+//33zDNQ5HWlDh65fx/45BNg7VolKd24MVC2LLBggXLJnMWi3C85WUlYf/MNULAg0L+/rZ8BUbopV64cmjZtirt372LdunV2/d6Pj4/HmDEjYDItQPfuN5E/v60jej1GoxGjRo2CLMtYtmwZIiIibB0SZQEmkwmnTp2CWq1GjRo17DtxQpSOhBA4duwYwsPD0aVLFyaQKMNIkoRevXrBx8cHW7duxZUrV+x6PwpmMxAVpVy2lioxEYiIUIbS27GIiAjMmTMHsixj5MiRaX1sM3rYpsFgQPv27VGyZEnMnDkTwcHBtnxZiLKN9evXY//+/WjRogWaNGli0yrrVI6OjvDz84OPjw/mz5+P2NhYW4eUqWTZ9L4syzCZTNi0aRMmT56MmJgYtGjRAlOnTkXhwoVx7do1yLKM3bt3Q5IkfPPNN/D09MyWZzxkWUZCQgK2b9+Ozz77DDExMahXrx4mTpyIChUqQKPRoHbt2rh+/TpmzJiBw4cP4+DBg+jQoQM+/fRTFCpUCFqtNmtd4iAEYDIBBw8CEyYAd+4oldOdOgFFigDTpyuJ7N69gfz5gbx5lUvpHj0CihUDVq4EcuSw9bMgSjcODg4YMGAAAgIC8NVXX6FDhw7Ily+frcN6gdVqxYwZM3D16hUMGjQIDRuWyxTDF/9JxYoV0aVLFwQGBmLnzp3o3bu3fffCJLsmhEB0dDQOHTqEypUr8/JESneyLCM5ORmSJEGr1drV9ioyMhK///47tFotmjVrZutwKBuRJAm5c+fGqFGj0K9fP2zbtg3e3t4wGo32vQ1+WWx2HK/VasXq1atx/vx59OnTB++8807a6/vDDz9g1qxZSElJea3frdfrodVq//V+nTp1Qs+ePaFSqeDj44NOnTph4sSJ+OKLL7Bw4cJsmWsgyghCCFy7dg2TJk1C0aJFMXToULi8bP6YjZQuXRrNmzfHrFmzsGLFCnzyySf2vf23I/azJ5lOhBCIi4vDzz//jPbt22Po0KHInTs3vv76a6xYsQLFixeHRqOBj48Phg8fjsKFC2PPnj1o0KAB1q5di3v37sFsNtv6aWSI1FYgJ0+exIABAzBs2DA4Oztj6tSp2Lx5M6pVq5Z2wGEwGFC5cmWsX78e69atQ82aNbFnzx74+vpixowZuHz5MpKSkuy7auBVJSYCV64oSemuXZVK6gkTgCVLAKNRuUSuTh1g61Zg9mygWjXAyQmoUUP5+ocfgHLl7Hqnjuh1FC5cGP369UNYWBiWLl362jv+b0tqFd3q1atRunRpjB49OtMfHEiShE8++QRqtRrbt2/Ho0ePbB0SZXL37t3DhQsXUL16deTNm9fW4aQri8WCqKgoBAUF4dq1a4iPj88a+yV2KrXnb3h4OO7cuYPz589j3759+PDDD/HZZ5/h0qVLdtWC79q1J3jwwIy2bTvCyYmDsiljaTQa1KlTBy1atMDatWtx6dIlW4f0+uzwGEcIgStXrmDr1q3w8vLCJ5988txJs5SUFCQkJCA+Pv61ltDQUNy/f/9fl5iYmLTHVKlU6N27N6pUqYLNmzfjyJEj/EwiekuSkpLQr18/xMfH48MPP0SZMmXsKimsUqnQpUsXFCtWDIsWLeIx3X+QuY/m/8ZqteLmzZvYtGkT1qxZA0mS8P7776Nnz56oUKHCc3+0Wq0W3bt3R1JSEqZNm4arV69i2LBhqFWrFjp27Ag/Pz8UKlTIrv7Q09vdu3exefNmrFu3DgkJCejatSsGDRr0wmv1LEdHR7Rq1QrvvPMOduzYga1bt2LJkiXYuXMnOnfujKZNm6Js2bKZ85JLWQYePgR27ACWLQNCQ5Vebn37ArVrv9ifOm9eYMAAZSHKJvr164f169dj586d8Pf3R8WKFdO+FxYWhv3798NkMkGn08HBwQEODg7Q6XTQaDRp6569rdVq//F+Op3uP22DHz16hK+//hpmsxmTJ0+2We/K9CRJEvLnz4/+/ftj2bJlOHLkCLp27WoXl7pR5iPLMg4cOIGcOXOicuXKmbo1SGrCNDQ0FMHBwQgODsbDhw9x8+ZNnD59GvHx8ejTpw8GDhxoV5U2mZksy4iKikp7vYODg/Ho0SPcunULt2/fRlBQEKKjo6HVahEXF4eLFy/im2++QfHixW2+P52SAly54g2TaSr8/R25DSWbyJs3Lzp37ozffvsN8+fPx+rVq+1zTlBqYjX1fZsJEq3x8fHYunUrgoKCMGvWLOTKleu57zds2BCVKlV67aRxSkrKKxVreHl5Pbe9c3V1xejRo9GlSxcsWrQIFSpUQM6cOV8rBiL6Z7GxsYiJiYFWq0XdunVtHc5LFStWDN27d8ekSZOwZMkSTJw4MVPvi2eULJO0Tm0Fsm7dOly5cgX169dHz5490bhxY+j1+ufuK4RATEwMtm7dig0bNiAmJgZt2rRB1apVERgYiPHjxyMwMBD+/v5o37493O182MR/FRcXh927d2P9+vU4ceIEatWqhf79+6Nx48ZwdXV9pQMLd3d39OrVCw0aNMDhw4exYcMGTJs2DTt37kSrVq3QoUMHFCtWzOYHKa/MYlFagSxbBvzyC1CmDDB2LNCkCdt8ED3D09MTH3/8MYYNG5Z2eavBYAAAPHjwAGPHjsWTJ0+eS1prtdqXJq3/bZ2joyOMRiN0Oh30ej0cHR2h0+ng4eGB2rVrPzdEKykpCVu3bsXx48fRt29fNGrUyFYvUbrT6XRo164ddu7ciS1btqBRo0Z22ZqF7F9iooQdOxrA27sIKlasZutw/hNZlhEZGYmgoCDcunULQUFBuHfvHp4+fYqQkBCEhIQgOjoa+fPnR44cORAeHo6ZM2ciR44c6N69e+Y8mW5jKSkpCA4ORlBQEIKCgnDjxg08ePAg7fUOCQlJGzBUokQJdOvWDT4+PnBycsKvv/6KDRs2YN68eZg8ebLNkzSRkcDPP+sgSRVRogQyddsoyrxUKhV8fX3h5+eHLVu2YO/evejYsaOtw3o1dpy4lmUZly5dwsaNG1G3bl00b978hdZETk5ONhs83KBBA7Rv3x6BgYHYtWsX+vTpw88konTm5uaGRo0aYdWqVdi1axc+/vhjW4f0Uj179sTixYuxefNm1K1bl+3KXkGWSFpfvnwZU6dOxZEjR+Do6Ihx48ahQ4cOyJMnzwsfCEIIXL9+HZMnT8aPP/4IT09PfP3112jSpAk8PT3Rtm1bbNu2DUuWLMHp06cREBCA999/H02bNoWjo6ONnmH6EELg1q1b+PLLL7F7924kJydj7Nix6Nq1K/LmzfuPVScPHz5EYmIivL29n1uvUqlQqFAh9OjRAw0bNsRPP/2E2bNnY/r06di5cyd69eqFbt26wdnZ2b6T1yEhwLRpwK5dyuCRwYOBHj2A4sUB7lAQvaBZs2aoVKkS9u3bh7Zt26JKlSoAAB8fH+zatQsmkwlxcXFITExMu52UlPSP60wmE2JjY19YFx8fD7VaDZVKBY1GA5VKBbVajXz58mH69OlpSWshBK5evYo1a9agVKlSGDx4cJaqopMkCd7e3ujQoQPmzJmD48ePo2PHjjzgof/s119VuH27Cvz8KiFfPjv+XIbS6uPx48e4ePEiLly4gPPnz+P27dtp24q4uDgIIVCiRAlUrFgRPXr0QOXKlZEzZ044OjriypUrmDBhAsaPH48CBQqgQYMGGRp/RARgMACOjkquJzYW0OmAv9VR2BWTyYSbN2/i/Pnz+OOPP3Dp0iWEhYUhNjYW8fHxiIuLg5ubG0qXLo1WrVqhYsWKKFOmDJydndP29R49eoTKlSujfv36SElJwaZNm5AjRw6MHz/eptVEoaHAr78CTZsqtQj2vFtKWZubmxsGDhyIgwcPYtq0afD19bX5SZ2XEuLFN4qdvnFMJhOWL1+OpKQk9OrVC7ly5bKrY0+NRoNRo0bh8OHD2LJlC+rVq/fCcTURvRmdToePP/4YW7duRUBAAPz9/VG0aFFbh/WCHDlywMfHB7///jtu3rzJpPWrEJmRLAthtQpTRIRYsmCBKFSokDAYDKJdu3bi6tWrwmw2C1mWn/sRq9UqYmJixIIFC0SOHDmEq6ur6Ny5s7h8+bJISUlJu78syyI5OVncunVLDBo0SLi4uAhXV1fh7+8vzp49KxITE1/43fZOlmWRkJAg1q9fL0qUKCEMBoNo3ry5uHTpkkhOTv6/z0eWZTF48GCRI0cOMWLECHH37t3nXq9npaSkiNDQUDF9+nRRsGBBYTQaRfXq1cW+ffuEyWQSVqv1bT7N/0aWhTCZhNi2TYhSpYQwGoWoWVOIQ4eESEpSvk9EL5WSkiI2bdokDAaDmDp1qkhISHju+7IsC6vVKiwWi7BYLCIlJUWYzWaRnJwskpKSRGJiojCZTMJkMomEhAQRHx8v4uLiRGxsrIiJiRHR0dEiKipKhIWFiVu3bokLFy6IEydOiP3794tt27aJrVu3irt376Y9VnR0tBgwYIBwd3cXGzduFCkpKTZ4Vd4uWZbFqVOnROXKlUWVKlVETEyMrUOiTEaWhejdW4hcuYTYt8/W0fxFlmWRlJQkQkJCxIkTJ8TXX38tunXrJkqWLClcXV2Fi4tL2pIvXz7RrFkzMWHCBLFnzx7x9OlTERsbK0wmU9q+nyzLIiYmRoSGhopt27aJfPnyiUKFComzZ89m6H7IhAlC/Pij8rrHxgoxZ44Qx49n2MO/spSUFLFgwQJRsGBBkTNnTuHi4iKcnZ2Fs7Oz8PDwEDVq1BAffvihWLdunbh69aoICwsT4eHhIjw8XAQFBYmAgAAxevRo4evrK3Lnzi1cXFzE9evXhSzL4vbt26J169ZCr9eLxYsX22zbnJIixMqVQjg5CbF+vRD2tDtK2ZPFYhFjx44VRqNRTJgwwb6OkYQQYu9eIYoUEWLaNOUNJMtCzJsnhCQJcf68raN7jizL4sCBA0Kv14u+ffuKyMhIW4f0gtT8woIFC4TBYBBfffWVSEpKsnVYRFmOLMti2rRpwtnZWcycOdPutq2yLIsbN24IT09PUaZMGfH777/bOqRMIXMmrePjhfjlF2Ht1El8U6iQqF2lili+fLmwWCwvJFNlWRZxcXHiyJEjomnTpsLJyUlUqFBBLFu2TJhMpn9M2MqyLCwWi/jtt99Ex44d03bEP/jgA3H+/HkRGxubKZLXCQkJ4uzZs6J79+5Cq9WKMmXKiK+//lrExMS8UvxWq1WsXr1aVK1aVbi7u4uSJUuKRYsWiZs3bwqz2fzC/VOTVTdu3BAffPCBKFq0qNDpdKJNmzbi0KFDIiIiwrYbD1kWIjlZiD/+EGLgQCHc3IQoXFiIyZOVo0pZZsKa6BXcu3dPtGrVSvj4+IgTJ06Ip0+fisjISBEdHS3i4uKEyWQSSUlJL90uv6rUBNQ/Lan32b59uzAajWLAgAHi6dOn6fk07UpKSooYN26c0Ov1YtmyZZniM4jsR2ioEPnzC1GxohD2dM4jKipKfPTRR0Kr1QqtVivc3d1FwYIFRbly5UTr1q3FhAkTRGBgoLh7966wWq0v3Q6kSj2J1aVLF9GxY0dx9+5dsWLFCuHl5SVq1KghLl68mGH7IGPGCLF7txAJCcprP3WqED/9lCEP/Z/89ttvQqPRCFdXV1G1alXRqVMn8cUXX4h9+/aJO3fuiLCwMHHnzh1x8eJFsXv3bjFlyhTh7+8vihQpIhwcHISTk5PInTu3KF68uKhRo4bo3bt3WtJalmXxxx9/iFq1agknJyexceNGmyRq4uKEaNNGiKpVhTh7NsMfnuilIiIiROnSFUXFih3F6dMh9nX48U9Ja5XK7pLWUVFRokqVKsLHx0ccOXLErveNbt26Jd59911Rrlw5cenSJbuOlSgzkmVZPH36VHh7e4t69eqJa9eu2dX7LCoqSrRt21a4ubmJVatW2VVs9ixztQexWIAbN4Bt24Bly6BycEDXbt3QqV8/uBcu/ELvKvHnJeNbt27FunXrAAD9+/fH0KFDn+uF+jKSJEGtVqNGjRpYvnw5Dh48iC1btiAgIAB79+5Ft27d0KJFC1SoUAF6vd6uLkEClKGUd+/eRWBgIL799lskJiaiZ8+e6N+/P6pVq/bCa/VPVCoVevXqhebNm2PLli3Yvn07xo8fj/Xr16N3797w9fVFiRIl0i5TlyQp7VL2+fPno2PHjli/fj2OHj2K7t27o02bNnjvvfdQp04dODtn7OR2IQQSHj+GcedOSCtWAMHBQKtWwKBBQK1abHBI9B/ky5cPjRs3xi+//IJPPvkExYsXh5OT03P9px0dHWEwGNJ6VacuqV//vd916vrU4YzP3vfZgY3Pbr/u3buHiRMnolixYujduzdyZOEe9BqNBp06dcLu3bsxf/58tGjRAnnz5rV1WJRJ7N8PxMUp3a/sZS6hEAIPHz7EypUrUbx4cTRu3BilSpWCj48PvL29kTt37lfeX0mlUqmQK1cufP/99/jqq68wduxYREREYM6cOZg0aRJmzpyZYYMBT51SXvOkJODOHaBOnbf+kP/Z7t27odPpMHToUHz00UeIiIjAw4cPERwcjA0bNiAoKAg3b97EzZs3kZCQgFy5ciFXrlwoW7YsGjdujCJFiqBEiRLw9vZG0aJFYTAYnnttK1asiGnTpmHYsGEYO3Ys9Ho9mjdvnmEtnIRQusD98ouyy/cvu/9EGcbd3R1TpizDhAklsW6dM4oXB9zcbB2VwuKuhrmaKzQFtHD48+1syecIc11P6I1q2MsRk9VqxdKlS3Ht2jUMHToUtWvXtrtj8mcVLFgQ3bt3x5gxY7Bq1SrMnDkTWq3W1mERZRmSJMHV1RVDhgzB1KlT8eOPP6JIkSJ2MezQbDan5cVatGiBLl262PX2yp5knqR1dDSwYwewdq1yFNCoETBgANzq1QNcXV+4e+qgxXXr1uHixYt499130bt3bzRs2DBtaNircnFxQfv27VG3bl0cPXoUAQEB+Pbbb7F79274+fmhQ4cOqFatmt380SUnJyMwMBCrV6/GmTNnULVqVfTr1w9NmzaFy2scqUqShJw5c2Lw4MHw8/PD/v37sWXLFowaNQo1a9ZE27Zt4e/vj7x58z73Gjg4OKBu3bqoUqUKfv75Z+zcuRM7d+7E4cOH0ahRI7Rr1w716tXLkF7hJpMJhw4dwuENG/Dlb7/BsUABYNYsoHlzwMvLbnu0Edkri8UCk8kESZIQExODmzdvIjExEcnJyUhKSkJiYiLMZnPaOkmS0pLWjo6OaYno1GR06pDF1ER1ajI79b7PDmc0GAxwcHCA2WzGtWvXcO/ePUyaNAnVqmWuwXKvo0yZMmjfvj1mz56NlStX4rPPPrObzx6yX2azkrROSQE6dLB1NH9JHZ4lSRIGDBiAIUOGvNGBhSRJcHJywqhRoxATE4Pvv/8eRqMRI0eOREJCApYsWYJZs2bhiy++QM6cOd/6e8fFBfD0BBITld7W9iYhIQEHDx6Ep6cn+vXrB5VKhQULFmD//v0ICQmBVqtF4cKFUbx4cdStWxclSpRAvnz5kCdPHuTNmxeenp6v1Fv/3XffxZdffomhQ4diypQpcHFxQb169TKsL//evYAsA9Wr288JGyJAQqNG1bB5M7B7N9CsmTL/3R5qaBKLA6FDJbjmleClAgCB2BrAU3cViuSSYC+bs3PnzmH16tUoVqwYhgwZYvcJYAcHBzRt2hR79+7F+vXr8d5776Fu3bq2DosoS3FwcECzZs2wZcsWbNq0Cc2aNUORIkVserwkhMD58+exdu1a5M+fHxMmTMj08/Iykv0nrYUArl8HZs5UjricnID585VP9vz5X/hkl2UZ586dw5w5c/DTTz/B0dERU6dORdu2bV86mPG/yJUrFzp06IB33nkHv//+OxYvXoylS5diz549aNeuHQYOHIiCBQu+6TN+I0FBQfjiiy9w6NAhqNVqjB49Gu3atUPRokXf+I2q0Wjg7e2NQoUKoVmzZtizZw8WL16MiRMnYtu2bejbty+6dOnyXPWMJEkwGo3w8/NDtWrV4O/vjzVr1mD9+vU4dOgQ3n33XQwdOhTly5d/KwcvqVVc8+fPx/bt25EQF4fe48ahSps2QKFCgJ3v3BDZIyEEgoKCsGXLFpQoUQKzZ89Gnjx5YLFYYLVaYbVaYbFYIMty2rqUlJS0QYyJiYmIi4tDcnLyC8MZn10XExPzwhDHZ4czWq1WyLKMKlWqoE+fPllq+OI/UavVGDRoENavX4+tW7fC398fZcqUsXVYZOeCgoArV4AyZZTFXlgsFgQGBqJgwYKoXr06tm3bhsjISHTv3h1ur1lyKEkS8ubNi08//RQhISFYvHgx3N3d8f777yMiIgIbNmyAq6srZsyY8dYTHBUqAI0bK9XWV6++1Yd6LadPn8b9+/fRoEEDFCxYEFarFSVKlECOHDlQvnx5FChQAM7OznBxcYGLiwucnJxea19SkiQ0btwYM2bMwIgRIzB58mQsWbIEJUuWzJCDyKNHgVy5lEp3nuMjeyFJgLOzMv/9t9+A778HqlQB7GEmo6y1INEtCkZDSto6i2MiTB7hkNUWG0b2l4SEBKxcuRL37t3DypUrUahQIVuH9Ery5MmDnj174sSJE5g0aRL27NkDvT1P6CXKZCRJQuHChdGhQwdMnjwZhw8fRt++faHR2C71GRERgbVr1+LWrVtYsmTJv3Z9oL+xZW+S/8tqVRoBLl4sRJ48Qjg7C9GhgxCXLwthNr/Qd1iWZZEQEyMWLVokihQpIgwGg/D39xe3bt0SycnJ6Rpaar/rqKgo8f3334sSJUoIo9EovL29xTfffCPCw8PT+i5mhNS+3evWrRPe3t7CYDCIRo0aiVOnTomkpKS3EkfqQIk7d+6I0aNHi9y5cwsnJyfh6+srDh8+/I+Pa7VaRXx8vDh69Kho3Lix0Ov1Im/evOLjjz8WoaGh/zjk8XXj27VrlyhbtqwwGAyifv364tcTJ0RyYiL7VhO9JlmWRWxsrPjggw+Eu7u7WLdu3SsN13p2OOM/DWaMj48X8fHxLwxkjIyMFBERESI8PFyEhoaKGzduiLNnz4qNGzeK9evXi8jIyGzVE0yWZfHNN98Ig8Egxo0bJ5KTk4XFYhFWq/W5nr9EqVavVgYwzpljXx9/wcHBwsnJSbRr1048evRINGrUSOTMmVNERUW98e+2Wq3i8uXLonz58sLT01N899134s6dO6Jt27ZCr9eLefPmCYvF8uZP4h9Mny7E0aPK6x0XJ8SiRUL8+utbe7j/TJZlMXr0aGEwGMT27dvT1iUlJaXNI0jvxzOZTGLRokXC3d1dNG/eXISHh7+VbZXVqvQRj4xUXv+wMCEOHBAiMTHdH4rojcXECDFypBAGgxCBgfYxKDQ6eo+4eLGwePJkupDlFCHLVhESMkecOaMWCQm272kty7LYtWuXKFy4sGjVqtULA8HtndlsFj179hTOzs5i6dKl3GcjSmeyLIuLFy+K2rVri5IlS9r0WNFisYjAwN3Czc1NDBw48K3t+2Rl9pe0lmVl0OLPPwvRrJnyCV6unBBLlijr/z4o78+x7PKvv4rfO3QQuf8cJLNp06a3lrD966HltATO7NmzRalSpYTRaBRVq1YV27ZtE8HBwW/1gEiWZZGYmChOnz4tunbtKpydnUWxYsXEvHnzhNlszpA3Q+prcP78edG9e3eRN29e4eLiInr06CFOnDjxjwMfZVkW8fHxYv369aJOnTrCxcVFFChQQMybN0/cvXv3jQb1JCYmisuXL4shQ4YIrVYrihUrJqZOnSrCwsKYzCF6Q7Isiz179gij0Sh69eolQkJCMvQ99f+GMmYXqcPmypcvL4oXLy4mTJgg1q9fL7Zt2yb2798vTpw4Ic6dOycuXrwoLl++LK5evSpu3LghgoKCxJ07d8S9e/fEgwcPxOPHj0VwcLB4+vSpCA8PF5GRkSImJua5QZoZ9VlC6S85WYjgYCEsFiEuXRLigw+EuHXLvpLWixcvFi4uLmLu3Lnixx9/FMWKFRMdO3ZMt785WZbF77//LgoXLiyKFCki9uzZk3YQYzQaxapVq0TiW8pkHjsmxMaNSp1FQoIQx48Lcf/+W3mo1xISEiLq168vcufOLeLi4jLkMWVZFjExMeLTTz8VTk5Ook+fPiIyMjLdHyc+XoixY4Xo0UOIkBAhoqOF6NvXvl5/olSyLMSJE0JUqCBElSpC2MM86b+S1jPsLmkty7J48uSJ6Natm8iRI4f49ddfM91+iizL4tatWyJPnjyiYsWKIigoyNYhEWU5VqtVTJs2TRiNRjF37lybbCdkWYj79y2iceOfRO3a3cRvv/2W6bZX9sC+2oPIMnDzpjJocdUqwGoFevcGhg0DfHxevH9KinLN6+bNkJYuRWknJywbMwbF27bNkEsOU3+/s7MzRo4ciVatWmHdunXYv38/unfvjsaNG6N79+6oU6fOaw0T+n9kWcb9+/cRGBiIJUuWwGQyoVOnThg6dCjKlSuXro/1/6S+BhUqVMCaNWtw+PBhrFu3DseOHcPRo0fRsWNHtGnTBpUrV4bRaHzu54xGI7p3744GDRpg06ZN2LVrFyZPnoyAgAD06NEDfn5+KFKkyCs/F1mW8fjxY+zevRtLlixBaGgo/P39MXDgwAztnUj02uLjgZgYQK1WpvHYYa+rhw8f4rPPPkPBggXRp08f5MqVK0Mfn/2bkdYfvHjx4jhw4AAWL14MIQQsFgssFguSk5NhtVqhUqnSBlwajUbodDoYDAbo9fq0dVqtFkajMa2n+LP3Sx2m6eLiktZTPHUBlFkBxYoVQ6lSpbJFa5bM5v59YOJEYMwYpU1F6dJAQoKto/qLxWJBQEAAPDw8UK9ePRw6dAhPnz5Fp06d0u0xJElC1apVsXDhQnz44YeYOnUq5syZgxkzZuCDDz7A5MmT4eLigpYtW6b7kJ5ffwW2bwfy5AHKllW+VqsBG3eRS5PaGsTf3/8/z3p5XZIkwcXFBcOHD0doaCg2btwILy8vjBkzBp6enun6WJ6eygicY8eUMThE9kqSlLYgbdsCc+YAK1Yo223b9rYWabE9z/b7YBaLBT/99BMOHjyIPn36oEyZMplu31CSJBQtWhQjRozA9OnTsX79eowZMybDtsVE2YFKpUK7du2wfft2fPPNN+jQoQMKFCiQoTGYzcDs2WqcO+eLSZNqoWJFVabbXtkD+0lax8cre/dr1wLnzwPvvAP07Kn0rv57nychlPtv2wasWQNcvAi8+y6MvXujla+v0iAsg6nVapQsWRITJkxA27ZtsXv3bmzduhXvv/8+GjRoAH9/f7Ro0QJGo/GN/1BjYmLwww8/YMOGDfjxxx9Rq1Yt9O/fH40bN4aHh4fN3ghqtRp+fn6oXr06jh49isDAQKxcuRJ79+5FixYt0K5dO1SpUuWFHpJ58+bFRx99hJYtW2L37t3Yvn07Pv/8c+zYsQOtWrVChw4d/jUxZrFYcOjQIaxYsQLHjx9HqVKl8NFHH6Ft27bw8PB4m0+b6M2ZTMDBg8CBA0BEhHKkUriwMjGtQgXAhj24npWUlIQvv/wSQUFB+Oyzz1CrVi1bh5QtCSHw448/4vjx46hXrx66desGlUoFs9mMlJQUJCcnIyUlBSkpKTCbzUhOTn5hMKbZbIbJZEJKSgqePHmSdr+EhISX3tfBwQFarTYteS1JEuLj41G6dGnMmDED9erVy7CTpfRq4uOVPsrbtimJ0lu3gHLlbB3VX65evYqLFy+iZs2a8PLywtmzZ5EzZ07UrFkzXR9HkiT4+fnh888/x5QpUzBlyhQsWLAAs2fPxvDhwzFt2jS4urrC19c3XfodCqHUXMgy0L49sHw5MHZsOjyRdGQ2m3HmzBmEh4fD398/w/cbc+fOjc8//xyRkZFYtmwZXF1dMXToULi+ZLD6q7BYgLAw4O5dZZEkZWRJx47Avn1AiRLp/ASI0plOB/TooYxv+vZboGlToFIl28UjBKAkrqW/rbMtIQRCQ0OxaNEiFCxYEB06dICzDY7700uvXr2wZ88ebN++HX5+fqhduzYTWm+ZEAIXLlzADz/8ABcXF3h4eECv10Ov16cVbDz7tV6vTyvs4P9N5uPj44OOHTti6tSpWL58OSZNmpShxys7dijzCnx9JbRr54h0ro/INiQhbPwRJISSdJ4zBzh8GHBwAD76CPD3B/Lle3my5tIlYNo04PhxJUE9YgTQsiVQoIDdTFhJSEjAlStXsHnzZmzYsAEqlQo1atTABx98AF9f39eq+hVC4Pbt25g3bx527twJq9WKkSNHwt/fH4ULF7Zpc/m/s1qtCAsLw9mzZ7F48WIcOXIERYoUQbNmzTBkyJCXDoYUQsBsNuP27dvYu3cvlixZgpiYGFSsWBG9e/dG27ZtX7pjcv/+fcydOxd79uxBXFwc+vXrhx49esDHxwdqtZofMGTfLBZgyxZg0SJlO1ajhlIOuXu3cvS9cCFQsqRdbNsCAgIwbNgwlCxZElu3bk33yjh6NaGhoWjSpAmio6OxatUqvPvuuy/dzsmy/NxgzGf/TR2OmTos89mBmalDNFNSUmC1WmE2mxEfH//cQMzw8HAcOHAA58+fR926dbF37950r1Sl1xMfDzx6pPw7cyZQvTpQvLiyy9SunVITYAebE3zxxReYOXMm5s6di5IlS6adfJ89e/ZzV2alByEEEhIS8O233+LLL79E1apVsWrVKhw7dgyjRo1C4cKFsWzZste6Sk+WgadPlUGXFy8qu6h58ijDFxs1AoKDlYsIc+QA6tUDatdO16f2Wu7du4cPP/wQT548wZ49e5A7d26b7CsFBQWhb9++uHXrFqZMmYIePXrA8RWuMEpOVj4eU1/vK1eAx4+B6GjlYiUfH+XjtEIF5f9hxw7l8GLSJPupdCf6OyGA9euBIUOUw+Bly16s28oo0dF78PDhUOTIMQS5co0CoEJo6Dw8eTIOJUuegcFQ3iZxCSEwbdo0zJ8/H5988gk++uijV9pm2Cur1Ypdu3Zh4MCB6NGjByZMmPDaQ4jp1Vy4cAFjx47F0aNHodPp4OjoCI1GAwcHB2g0mueWZ9dptVo4OzvDyckJRqMRRqMxbUCxk5MT4uPj4eHhge7du9tVToaAp0+fol69enBwcMCGDRtQLoMqOIKCgM6dlf2THTuUQ3x72P/OlGzVlyTNxYtCNGwohKOjEO3aCXHjhhBJSS82XZRlZVLFggVC5MsnhJOTEO3bC3H+vNK40Q57w8iyLBISEsTvv/8u2rdvL5ycnESOHDlEjx49xMWLF1956KAsy8JsNouAgIC0oY/NmzcXZ8+efaPezxnBYrGIyMhIERAQIKpUqSIMBoMoUKCAmDRpkoiKihIWi+WF1yB1ENCdO3fEJ598IpydnYWrq6to2rSp+Pnnn9N6lZtMJhEYGCgqVaok9Hq9qF69uvjpp59EQkICewVR5nHnjhAtWwrx5ZdCxMYq2zKrVYiHD4Vo3lyIjz9WmqLakCzL4u7du6JRo0bCyclJnD17lu8xG7FYLOKjjz4SRqNRfP755680BPNNPTtEM3WApslkEjdv3hTNmzcXWq1WnDlz5q3HQQplGLQszGZld+nxYyH27BFiwgRlFEihQspu0sGDSh/fkyeF+PxzZRfr+HH72F2Kj48X7777rnB1dRUPHz4UixcvFnq9XuzYsUNY39IUstRe8EOHDhVGo1F06tRJREZGiq+//lp4enqKxo0bi4iIiJfuk1itVpGSkvLn336SuHBBFitWCDFokNKDNlcuIdzdlZnher0Q774rRM+eQuzaJcSTJ0L06SNEx45K31pbk2VZ/PTTTyJfvnxi7NixIj4+3qaxnD9/XpQvX14ULlxYHDx4MG2/8NntTXh4uDh06JCYMWOG6N9/rahQIV54eQnh6qocDhiNQvj4CNG1qxDz5wtx5IhyuHDwoPLx2bOnELVqKT2t7eHvn+ifJCUJ0bSpsg3futV2f69RUbvFxYuFRHDwrD97WltEcPCX4uxZB5GQcME2QQkhbty4ITw8PETt2rXFvXv3bBZHepFlWYSGhoqePXsKT09Pcfz48bf2GUhCJCUlia+++koYDAZRo0YNsWDBArFgwQIxbdo08cknn4gBAwaITp06iebNm4t33nlHlCtXThQsWFC4u7sLnU4nHB0dhV6vFwaDQRiNRuHs7CxcXFyEq6urMBqNwsnJSXTv3p3HSHZGlmWxZMkSodfrxdixYzPk2MlkEmLoUCXFOXeuMl+GXt/bPw0khFJJGBurlEYAyjV7zs7KtVA+PkoTrwEDlNPKGs3zpyCEABITgT/+AKZPV0qF8udXbnfp8uL97YgkSTAYDKhatSo2b96MI0eOYNq0adi7dy8OHz6Mfv36oXv37ihUqNBLzxILIZCUlIRr167hiy++wN69e1G4cGHMmDEDvXr1yhSXQ6nVari5uaFdu3Zo2LAhtmzZgiVLluDLL7/Ehg0bMGrUKLRo0QI5c+aERqOBJEmQJAk6nQ6FCxfGzJkz0atXL3z55ZfYv38/mjZtCn9/f/Tv3x8bN27Exo0b4erqijFjxmD06NFwdHRkZTVlLsHBQHg4ULUq4OSkbM8kSbnSpHp1YO9e5VpzG/YMTkpKwvr16/H7779j7NixqFChAt9nNiDLMvbu3YvNmzejbNmyGD16NDQaDcxmM8LDw+Hh4fFWLl9M3S4DeO4qoeLFi2PAgAH4448/MGXKFGzZsoXV1ulM/HkFUmJiIkwmExITE/HgQTCuXy+Nn3/2wNmzSu9qtVqpyNPrAXd3oFQpZdcrtVfqL78o1ahWq62fkeLUqVO4d+8e/Pz84ODggB9//BFly5aFt7f3W9u2pPZTnjx5MkJDQ7Fr1y7kyZMHo0ePxpMnT7Bo0SK8//77WLx4MXQ6XdrrHRcXh6tXr+LcuXM4e/Ysbt4MRnj4T9BovKDXSzAYgEKFgPLllc141arK6//tt8pmO2dOpU3InDlK56ekJGX311ab0OTkZJw7dw5xcXGoV6+ezXuolitXDl9++SWGDh2KDz/8EMuXL4dGo8H58+dx9uxZnD17FteuXYNarYZer0exYu9Br2+MKlWMqFIFqFxZ+RvPn195HwDKa/z0KeDiohwmTJoETJ2qtBCRZeW+LIQje6TVAjNmAO++C3z3HVCrFpA3ry0isYNeIH+TmJiIzz77DEIIDB48GAWzwGUTkiQhR44c6NatG3755Rd8+eWXqFChAlxcXGwdWpYjhMDFixexZMkSVKlSBWvWrEGhQoXw8OFDqFQqqNVqqFSqtNt//1oIgfj4+LQlLi4OsbGxiI6ORnx8PP744w8EBgbip59+wu3bt1G8eHFbP+WXEkIgOTkZYWFhAACdTvfCc/7788/s7f8kSUK3bt2wYsUKHDp0CO3atUPlypXf2v6m1Qrs2QPs3AnUqaNcPcPRam/m7e+y3b0LHDqkJJsfP1aS0LlyKden+vkB3t7A0KEv/9nUwYwBAcDKlcq6Xr2UdiDFitltsvrvUg/4GzRogOrVq2P79u3YtGkTvvnmG2zduhUDBgxA48aN4e3tnXbAL8sy7t27h507d+Lbb79FXFwcOnfujEGDBqFmzZqZKmGUGqu7uzsGDRqEJk2aYM2aNdi3bx8+/fRTbNmyBb1790bdunVRsGDBtPunvm5lypTB4sWL8dNPP2H9+vU4ePAgAgMD4eDggGbNmmHYsGGoVq0aL8WhzCkxUdnWGY3Pb9MkSbmePDz8r0aCsvxXUjuDyLKMs2dPYcOGDahWrRp69eqV6XdeMquHDx9i+fLlsFgsmDlzJoxGI2RZxtGjRzF9+nSMHj0azZo1e6sxiD/bLAgh4OzsjCZNmqB27do4dOgQDh48iFatWr3Vx8/qhBCIi4tDcHAwwsPDERYWhnv37uH69eu4fv06rl27hvh4C2rV2o/wcA8UKKAkSYsWVRKlJUsq/XudnIAbN5TknIODUhNw+rQy2/XOHaWb2t/GS2QYq9WKX3/9FWFhYejcuTNCQkJw8uRJtGvXDnny5Hmr+zeSJMHDwwPz5s1DbGwsvvvuOxQoUAADBgzA06dPsXHjRjg5OSFv3rxpr/etW7eg0+ng5eUFLy8vlCtXGGXKSChQQHm9S5ZUdmv/vgtSt64yDFClUhJPY8cqidQlS5SRLbbqrhQTE4MDBw6gcuXKKFKkiE33J61WKyRJQv369TFq1ChMnDgRLVq0QGJiIlxdXZEjRw54eXmhdevW8PHxQcmSJVGqVFmUKOGedo73ZfR6pZ91qiJFgPnzgS++AH7//a+2OfwoI3sjSco25cMPlRON4eG2SVprNO4wGCrDwSEflL7WEhwc8sBorAWVKuNPdAkhsGvXLvz444+oV68e2rVrl6mOhf8fSZJQs2ZNNGvWDKtWrcKePXvQtWtXW4eVpQghEBsbi/nz5yMmJgYTJ05EwYIFERcXBz8/PxiNRjg5OaX1sU5t+WEwGGAwGNK+n/q1TqeDVquFg4MD8uTJg4IFC6Jfv34oXbo0xo4di+XLl2Pq1KkvzPGyB0IIrFy5EitXroQQAgULFoTBYICzs/MLz9doNKb19E59vv/0b2repkCBAnbZskev12Po0KEYOXIkDh48iFKlSr2Vk/ZCAA8eKGP61Gpgyv/YO+vwKK4uDr+zu7GNOxJIcHco7hLcghV3h2LF3R0Kxd29uH24U0pxh1IcAnFPdnfu98c0KRSqJNkF5n2eeTY7u9k5Y3fuPfec8xur9L1VPo6UrWl986YS3nDqlCKomCOH0kN88ECJHixUCEaOVHqOfyQ4GHbtUiqX//gjVK6sOKyrVOEve6qfALIs8/TpUw4ePMj27ds5efIkBQsWpHbt2jRo0ICMGTOyb98+li9fzoULFyhSpAgtW7akQYMGODg4mNv8ZEGWZW7cuMHOnTv54YcfePr0KaVLl6ZRo0b4+/vj5eX1wf8LDg5m9erVjB49Gn9/f2bPnp3ig1wVlRTl+HEYPFgZUf9R2HD2bCVc7/JlxSNy6pRStNPfH/T6FG8HhRAYDKEcPNiX5cuv0bHjWPz9a6gTRGYgJiaGhQsXMnHiRLp3787w4cOxtrbm8ePH9O/fn1OnTrF27VqqVKmSou3h48ePmTVrFnnz5qVDhw5IksSZM2eoU6cOpUqVYsWKFXh6eqbY9j93jEYj27dvZ+HChTx9+pQXL16g0WjIkCEDmTJlws/Pj2zZcpAzZy1cXTPj46NE8n7oloyOhsBAxaEthFJb7949pUlp21ZJcjPHrfzy5Uu6d+/O1atXOXXqFDt27GDkyJHMmjWLli1bpsqkmBCCW7du0bNnTyIiIli4cCHe3t5UqVKFZ8+e4ebmRpYsWfDz88PPzw9fX198fHySFkdHx399nxmNirN0xgzo2BGGD4f/qDv4nxFCcPHiRfz9/enQoQOjR49O9vrh/4bTp09z+vRpGjRoQEREBB06dECWZVq3bk26dOnw8fEhQ4YM+Pj4YG1t/VFtW0wMbNyoDEuyZoV585SJHhUVS0MIJQnvwgVIk0apzZ5Y2zo4WIkHy5FDSVpOKUymKIzGQDQae4zGUGQ5GknSIklW2NhkRaNJXS/Mr7/+Srdu3bhy5Qp79+6lSJEiqbr91ODixYu0atUKKysrdu/eja+vr7lN+mwQQrBo0SIGDx5M8+bNGTduHO7u7oSHhzNkyJCkbLa4uDji4uLeex8XF5eUfZWQkJCU+WNjY4ONjQ1du3ZlwIABxMTEUKVKFQwGA8uWLaNYsWLm3vX3uHXrFqVKlUIIQYECBbC3t//L/Y2Pj0eSJGxtbZMEKRNrgb99DCRJQqfTJemQ2ZmrIP+fIITg6dOndOzYkaCgINasWUPu3LmTfcwkBPzyi+KsLlpU6e+ZOaHtsyDlhiuRkTB/Phw8qAiJ1az5e1hJaChUrarEyi9cqIRAJA5yTSZFVWX2bEXy29ZW6eXXqqWEBn0GsfUajQZfX1/at29P5cqVOX78OIsWLWLy5Mns2LEDLy8vrl69iizL9O/fn0aNGpEpU6bPylGk0WjIly8fWbNmpXbt2uzatYsFCxZw/vx5tmzZQocOHahWrdp7DZ67uztVqlRhyJAhpE2blnTmyZlTUUk+nJ0Vz1FiRHXiw9NkUib4smZVJvvevFFUec6eVdrToUNTQVFKEB6+ibRp9zJqVCeyZi33WbVDnwpCCG7fvs2SJUsoWLAgrVu3xsrKivj4+KRyU926daNMmTIpboudnR1bt27l4sWLVKpUicyZM1O8eHHq16/P3r17OXDgAK1atUpxOz5XNBoNQgicnZ0pWrQoefPmJUOGDDg7O+Pq6oqrqytOTk7/qJNtb684rEFpVrJnVxx3ly8riW9ubkoKemrP+d69e5ebN29So0YN9Ho9W7ZsIUuWLBQoUCDVsjgkSSJXrlzMmDGDmzdvkjlzZuzs7IiPjydjxozMmzcPHx8fXF1dcXFxSYoi+hi0WmjRQmnClyxR4i8GDkxdoTVZljlw4AA2NjYUKVLE7KVBli1bxtGjRylVqhT379/nxYsXDBw4kAEDBiT7taDXK2VaAgNh2jT45htYudJcpRdUVP4cSVLah6tXFcfHvHmKgJdGo0w+Ll6stB05c6acDVqtAyZTBC9fjiM29jparSOyHIeX1zfY2qbubI/BYGD37t2cP3+e3r17U6BAgVTdfmpRsGBBWrVqxYQJE/j++++ZPHnyOyXZVP47N27cYPLkyWTIkIEuXbrg5uYGgKOjIxMmTMBoNCYJkb/9mvi30WgkISEhaX1sbCwRERFERUURHR1NkSJF0Ol0uLi4MHDgQDp06MDOnTvJkyeP2Z+zbxMTE8OYMWOQZZkRI0ZQt25drKysPri/ie8NBkOSEHtiaZTo6Oh3SqVER0fz/Plzrly5QmxsLF999RVZsmQx9+6+gyRJpE2blqZNmzJ48GD27NlDtmzZkiUa/tgxePpUETu3soJHj6BpU0V428J8958uKVYt+8wZIfLmFaJpUyGio9/9TJaVdT17CpElixCHDyvrDAYhVqwQws9PUVZp1ep3YcbPlESRxadPn4rvv/9eZMqUSbi6uory5cuLn376ScTExHz2xfwTRRXv3LkjunTpIpycnISbm5to2LChuHHjxnv7/+DBA2FtbS06d+5sJotVVJKRkBAhunVTVLpevFCUGgwGRUmqYEEh1q37fd2FC4pCj4ODENmyCbFq1YeFa5MFWcTF/SKuXPEWt24VFjEx1z77tsgSkWVZREZGiubNmwtvb2+xcePGJKGyGzduiFy5cokyZcqI27dvp8r5MZlMYsyYMcLR0VFMnz5dmEwmIcuyuH37dlK7/fz5c/Va+QhiY2NFaGioiIqKSnaxGINBiO3bhXBzE6J8eSFu3kxdoa+EhAQxZ84cYWdnJ3bv3i1u374tbG1tRevWrUVsbGzqGfIbJpNJJCQkCFmWxb59+4STk5Po0qVLCopBCvHkiRD58wuRJo0QS5Yo5yS1zkF8fLzImzevKFmypLh7927qbPRPCAoKEunTpxcFChQQL168EF27dhX29vbi7t27Kdp+REUpww87OyEaNxYiOFgVZ7RMZCHLCSIsbL8IDJwj3rxZLmJjHwhZ/jLUrEJDhejVSwh3d6V7mKiXeuyYIrh77VpKWyCLFy/Gidu3S4qYmBsiIeGliIm5KRISXqbq812WZXHt2jVRokQJUbRoUfHw4cPPun8RFhYm8uXLJ7JkySJOnDjxWe9rahEVFSUaNGgg7O3txYoVK4TxIxXx/ijOHBsbm9SPSBTWrFSpkihcuLBFCdcnihG6urqKevXqifDwcBEREZE0pvir/0vc34SEBBEXFydiYmJEVFSUiIiIEOHh4SI0NFS8fPlSTJo0Sej1erFs2bJUETv8t8iyLO7fvy+qVKkivL29xYgRI8T8+fPFunXrxO7du8WJEyfEpUuXxMOHD0VQUJCIjY0TCQmK8HlCgtJfS1yMRmUxmRTh5zx5hPjxR6WtnjtXiB07zL23nxcpF9Lyyy9KKE/t2orizNtIkhJBXasWPHumTEckrnd0VCKy589XorCzZXv//z8jJEnCysqK9OnT0717dxo2bEhsbCyTJk2iSJEi2NnZffalLyRJws7OjuzZszN37lz27dtH6dKlOXnyJBs3bnzv+3Z2dsiyTHyisKeKyqeMi4uSdRIVBY0bK6VCevaEfv2Uuv81aigR2Dqdkme0dSuMH68I2/bqBV26KNkpCQm/175OBmQ5hmfPBiJEPB4eXbC1zfvZt0WWyp49e9i2bRv169enevXqaDQaoqOjmTFjBm/evKFLly5ky5YtVc6PJEl07tyZdOnSsWfPHu7evQuAn58fnTp14tSpU5w8eRJZllPcls8VW1tbXFxcsLe3T/bMBq0WqldXmpBr12DEiN/lRlKD4OBgTpw4Qd68ecmWLRubN29Gr9dTvnx5s4h4ajQarKysEEKwfft2hBA0bNgwxSK+JUmpM75hgyKYOWUK7N+fegKZipDkvaRMN3Oyd+9eIiMjqVmzJq9fv+by5ctUrlwZb2/vFN2uXq9EWteuDQcOKPdCRETq3QMq/wxZjuXXX1vw9Ok3REf/SFjYdgIDZ2AyhZvbtFSlcWO4c0eRd/rjYzU+XhEd/ftFYDCYkOW4v1kSEMLw2yKIi7uHjU02rK19sbJKg61tLnQ65f78/Xv/fDGZDO9EbxqNRkwm018u0dHRbN++nRs3btCjRw98fHw+676ok5MTEydO5OXLlyxZsoSQkBBzm/RJYzQaWbZsGcePH6dGjRq0atXqo6PXJUlCo9Gg0+mwtrbG1tb2nZrObm5udOnShbt373Lw4EHi4uKSaW/+O0IIrly5wuLFi7G1tWXGjBlcunSJGjVqsHHjRgwGw5/+79v7a2VlhY2NDXZ2dtjb2+Po6IiTkxMuLi54e3tTs2ZNChUqxNy5cwkJCUFY2INVkiS8vLySRFznz5/PsGHD6NatG19//TU1atSgVKlS5MyZkzRp0pArVw+yZAkma1ZF9LlcOaXv0Ly5Mvz+9lslcy4oSFk/d65SbMJker+9Vvk4Ui7POyxMOWt+fh9WOtFolJIgVlZKgS6DQVEFqlVLiaVPk+aTrlv9b0l8ADs4OKDRaJLqB31JJDrwS5cuzfr169m/fz/lypV773t6vT5J+VZF5ZNHkiBfPlixQskvun9fKVLbuDGUKKEINa5fr4jX+vkpOf+9eytPzqlTlVH3xYtKrnPt2snSdgphJDh4HZGRh3F0rIa7e4svrj2yFO7fv8/w4cPJmTMnHTp0wNnZGSEE+/btY8uWLTRq1Ihq1aqlWgqpJEm4urrSvXt3Ro8ezdGjR8mcOTM2NjY0a9aM7du3s3nzZsqVK6fqDVggiTEDTZsqMQPffw9jxsDEib9XaUsphBC8fPmS8+fP07hxY5ydndm+fTuenp6UK1fOrNfKixcv+PHHH0mTJk2Kl9mRJKUe7axZSrM9diy4u8uUKCGh0aTsMdi4cSNOTk5UrVrVrIK6CQkJHDhwACEE9evX5+7du9y7d482bdqkeLCGJCmxMN9/r9Sa3Lo1jixZntO2bVrs7S0njftLJyrqLJGRJ8iW7X/o9QUAgSzHI0mWJ2yWkmTKBPnzK7XwS5X6fb0QsHSp0kX8O5Ru5j0KFNj7N9+zRZJ0aDROODqWRa8vxJs383jzZgEODqWxscmGTueO0RhCWNgOwPiv9uXePWtu3zZhNCoCrDY2Nn87MRsWFsayZcuoWrUqlSpVSppkjI+PJy4uDmdn50+6nyGEICEhASEEtra2SJJEpUqVqFKlCjt27KBChQq0bdtWLRPyHxBCcPXqVdauXYunpycTJ05MleOo0+n46quvqFixImvXrqVevXrkypXLrNdpaGgoy5cv59GjR0yZMgUHBwfmz5/P48ePcXJySpbjklh2rXr16kyePJlNmzbRs2fPZLA++TAYDBw8eJBDhw5RsGBBvv7666TJscQyJzExMUllT2xtixERYUtEhBIbZjAoVY5fv/79/ZMn4OurDNMvX1bKjn0KwotCCEymcIzGIDQaG6ys0iFJltvOpJzTWojfowP/DElSnNey/HuIg60tpE2bYmZZOjY2Nmg0GmJiYt5ZbzQa+fHHH3F2diZv3rxmsi71cHBwoHHjxh/8LDEaKz4+HiHEJ91ZUVFJwstL8ST9kX37lMjrihWhfXtFlNbBAQoWVEbdP/ygOLwHD0YcP47o3hlKlkCj+e9Ri7Gx1wgKWopO50G6dKPRaMwn1PUlEx4ezoQJEwgMDKRfv34ULlwYgHv37jFmzBgyZMhA586d/1S4NqWwtrbG39+fzZs3s3btWmrUqEGmTJnIkiULjRs3ZuHChZw+fZqAgAB1oGWhuLlB9+5Kx3v9eoGzs4nhw+NxcUm5e91kMnHu3Dni4uIoWrQod+/e5ddff6V27dpkypQpxbb7Tzh16hSvXr2iffv2qSIepNUq845DhsDEibFMm/YD48cXJk+elKsVGxwczMGDB/H29qZs2bIptp1/woMHD7h+/To5c+Ykc+bMrF+/HicnJwoXLoyVlVWKb1+SwMMDJk6UGTHiHAsXzsDRsSlff90sVbav8vcIYQRk4uPvYWOTFa3WPtXF/yyFZs2UmIapU6FBg9/Xz5+vOFD+Do1G0LbtbdKkmfmX31Miok1JkdVubi2QJGuiok4QEbEfG5tseHp2ByRevhyJLP+7CNI9e1xYtSqWuLj434S+DZj+Js1ECIFOpyN37tykSZMGgLi4OFatWkVQUBAdO3ZMWv8pkpCQwMaNG4mMjKRp06Z4enpiZWWFv78/u3bt4vHjx8THx1tUXeRPhZCQEFauXMmjR4+YNm1aqvYzfHx8qFevHkOGDGHDhg2MHj3abP1hg8HA0aNH2b59OzVr1qRhw4asWbOGw4cP06FDB8qWLZtstllZWREQEMAPP/zAvHnzaNiwIenTp0+W3/5YxG9CjIsXL8bBwYERI0ZQsmTJv5zAN5kU53RcnDJB+KHsFr0ejh5V+hU9eyoR2O7uiiPbkjEYnhMaug0QSJIWd/e2aLUpqO77kaSc01qvVyqPBwa+Ky6WiBCKtH1cHDg5mUfC3gJJdFrH/mHqPD4+np49e1KsWDEWL15sJussA61Wi42NTZJIQHIU0FdRsViKFYNBgxQlnqtXoV496NNHibp2d4fWrRWFnvXrYdkigiuGkOBXCE/Prlhb/3uhRqMxlODgtcTF3SFDhpnY2qag0o/KnyKE4IcffmDfvn34+/vTsmVLtFotsbGxTJs2jUePHjFp0iSKFi2a6rZJkoSfnx8BAQGMGzeO3bt306NHDxwcHKhVqxa7d+9m9uzZVK9eHScnp1S3T+WfkT69Uh4kJCSeo0cn4+RkxYABfVNscJyQkMDWrVvJmjUrefPmZfXq1RiNRrNPbsTHx3PmzBkiIiL+dLI8JbCzg4YNISLiClOmjKd/f18WL16clLaa3Jw8eZLAwEBatGiBl5cXUVFRxMfH4+LikurH/8yZM7x8+ZIhQ4YQFRXFkSNHKF68OBkyZEi1QASNBnLmlBgwwJF+/d4wcuQIPD09qF69uhoMYQHY23+Fs3Ntnj0bgr39Vpyda+LsXAedzs3cpqU69vYwbBi0a6cMrxNZulSJ9Ps7FAGyMnh7v19y8V1MCCGj0dhha5sDnc4dT8+uuLjUIzb2Bm/ezCckZB1eXt+QKdM6hPh3+e/t2umoVk1OKh9mMpn+tpRYaGgoo0eP5qeffuLx48dky5Ytyfm0ZMkSsmfPTsOGDT9JkXAhBI8ePWLUqFEUKlSIhg0bAkqg2unTp7G1tSVdunTqOPc/YDQaOXHiBJs2baJOnTrUrFkzVZ9zOp2OatWqsWnTJpYuXUqbNm3MUpJLCEFgYCDfffddUtmSRCd+tmzZaNu2Lc7Ozsm6zcR7cvLkySxevJgxY8Yk6+//VwwGA8uWLePy5csMGjSIQoUK/W3GmVar9NXs7JSSbn/G2bPKq4cHdO2qtNe1aiWj8cmMUv7pLvHxd/Hy6gfISJKFTwqnWLXsffsUQcXBg5XK5X8kIUGImTOF8PJSVIEspEi9ufn++++Fs7OzWL169TvrExIShJ2dnahUqZLFFPQ3F/Hx8cLd3V3UrFlTRCUqk6iofK4kCteePauIMNrbK2oPmzcr6g+yrCyRkcLw01Fx58pX4tIlvbhzp7yIiDgpZNnwj9sMWTaJsLC94sqVNOKXX5qLhITXX3x7Yw5kWRbXr18XZcuWFZ6enuLOnTtJ69euXSu8vb1FpUqVzNr+ybIsbt26JUqXLi0yZMggXr9+LYQQIi4uTvTv31/o9XqxatUq9fqxcGRZiOfPY0TZshWEt7e3WLhwoYiPj//o85YoSJQo4GM0GsX169eFra2taNu2rQgODhYBAQHCx8dHREZGJtPe/Ddu3bolypUrJ0qUKCEiIiJSffvR0dFi4MBBwtbWVjRp0kS8fv3f2t23j3eiaNLTp0/F9u3bxbBhw0SBAgWEtbW1OHDggIiIiBBjx44VlSpVEr/88kuq3qeRkZGiU6dOSaKLu3fvFnZ2dmL69OlmEW4yGAxi9+7dImPGjMLX11dcvHhRbbdSkd/bCqNISAgUwcEbRFTUOSHLsjAYQkRk5Fnx5ElvceNGTvH4cXdhNIYKIT7/85MoxDhlihDx8coyfboQ3t5CFC2aGkKM77bjsmwQL19OFb/80lgkJLxK+Y3/RmxsrJgxY4bQ6/Vizpw5Ii4uTsiyLM6fPy9y5colqlWrJl68ePFJ3rMmk0m0aNFCeHl5ieXLlycJ4p04cULo9XrRoEED8ezZM3Ob+cmRKIZYoEABkT9/fnHq1KkUE1f+K0wmk5g/f75wcXERPXv2NMs1ajAYRP/+/YWzs7OYPHmyCA4OFv7+/sLFxUWsWbPmo0Up/4zXr1+LzJkzi1y5cptd9FkI5Zo4c+aMcHJyEjVr1hSPHz9O1vNx4YIQd+/+PmTfsUNpo81w2f0jZFkWUVHnxb17NcTr10uEwRD6h/be8trTlCtoV6AA5M0Lq1fDr7++qzIjy4ryz5IlSop73rxfVP3qv8LW1vaDkdY6nQ6dTkdCQsLfplJ9CdjZ2WE0GklISDC3KSoqKYskKVO8JUoo0dQjRihZKm3aQKdOSg1sgwHs7dEWqUCWPPvx9h5AfPx9HjyoyfPnQzEYAn9Ltf1zhBAYDC8IDJyBVuuAl1d3dDoPNeLMDERHR7NhwwYuXbrE2LFjyZIlC0II7t+/z7JlyzCZTMydO9es6aKSJJEzZ04aNGhAeHg433//PbIsY21tTcuWLcmYMSPjx48nLCzMbDaq/D2SBGnT2rJkyULSpEnDpEmTOHDgACaT6V8J6AghMBqNREdHExISwsuXL7l9+zZbtmxh0KBBVKlShZIlS+Lk5IS7uzsODg5s3LiRs2fPYm9vvvJDQghu3rzJnTt3aNiwIbZmKESo1+sZP34cTZs2Zf/+/Un3zd8df/FbLdTIyEiCgoJ4+vQpZ8+eZf78+bRv354CBQqQJUsWWrZsyYIFC3j58iUAq1atIi4uDhcXF65du0bbtm158+ZNauwqoJQGuXr1KpUqVcLDw4Nt27aRMWNGChcubJaIe51OR61atRg1ahRRUVF06NCBGzduqGKyKYgQAiGMGI1hJCQ8JizsBx49asXNm9l4/LgT4eEHECIOrdYFe/sS+PjMJF26MURE/A+jMfiLFM20soJGjSBPHkU2KqURQiYy8jAxMT9jMLwgJuYq0dHnsLHJgUaTen0PGxsbatWqRfHixZk/fz5PnjwBoECBArRs2ZJTp06xY8eOT+5+Fb9pk2zfvp0SJUrQuHFjtFot0dHRDBo0CC8vL7p27Uq6dOnMbeonh9FoZOzYsfz666+0aNGCEiVKmEXDQaPR0KJFC3LmzMnGjRu5fPlyqm5fCMHp06eZP38+pUqVolmzZixdupSzZ89Sp04dmjVrlmLPXA8PD/r1G0BERGb279dg/Hfl75OdsLAwevbsmaTJk9xZXUWLQrZsv7//+WcYPRp++cUyRZ4lSUKvL0r69JOJj7/Dgwe1iI+/R2joFiIjj2E0vkGW4y1KSDPlcmnSpYO2beHuXWjVSklv9/VVRkgvX8LMmUpxmJYtIXPmFDPjU8PGxgZJkt6raQ2Ko1aWZRISEj7JNKjkRK/XYzKZ/lLtVkXlsyHxwerqCgMHKmoPU6bArl3w88+Iwd8i1/ZHY++OTudGmjRDsbcvzuvX3/PmzUKiok7g7d0fB4eKf+GINhEcvJro6J9Ik+Zb7OwKqg5rM2AymTh79izr16/H39+f+vXro9PpiIqKYtOmTVy5coWhQ4eSLVs2s58fSZJo2rRpUvpj8+bNyZEjBwUKFKB+/frMnTuXpUuX0q9fP7W2tQUjSRJZs2Zl+vTp9O7dm2HDhuHu7k6pt1W//oAQgri4OMLCwggJCSEoKIjHjx9z69Ytbt68yc2bN3n27BmOjo64ubnh6upK6dKlefbsGXv27KFcuXJUr16dDBkypOKevk90dDSXLl3CZDJRvnx5s/WtdDod06dPJyoqio0bN5IuXTp69OiBvb190n1uMpmIiooiJCSEkJAQ3rx5w6NHj7h9+zY3btzg9u3bhIaG4urqipubG+7u7uTLl49cuXKRJ08eMmTIwKxZs9izZw8+Pj707NmTFy9eMG/ePL755htmzpxJ2hTWlDGZTNy+fZv79+/Tvn174uLiOHjwIEWKFCFPnjxma9MkSaJdu3aEhIQwefJkhg4dyowZM8iaNatZBSs/NxRHdTAJCU+Jjb1ORMRhoqKOYzJFYWWVBnv7kjg4lMXZuTayHIsQkeh0Hig1N61+c5ZaziA6JdHpIHt2Re5EkpQlfXqlOtyuXYq0SUoiRDwxMdeIiNiPRmOHLMdiY5MZd/eWqVr3VJIksmTJQrNmzRgyZAgLFy5k8uTJ2NraUqdOHfbt28fUqVOpUaMGfn5+qWbXx/Lq1SumTp2Ks7Mz/fv3x8HBAZPJxNKlS7l27Rrt2rWjYsWKZu/nfWoIIdi/fz+rVq2ifPnytGrVyqw+EycnJ3r37k3nzp1ZtGgRs2fPThXdDIBnz54xaNAgPDw86N27N8+fP2fNmjWkT5+e8ePHp+hxkSSJFi3asXZtZ9au1VK2LBQqZJ4Y1djYWKZOncrdu3fp0aMH/v7+yX5fvf1zGo3SPh8/DidPKtU8LU8qQwAmbG2zkj79FB4/7kRk5DFCQtYTE3MVvT4/Li4BODiUxNo602++A/P2hVL2Lq5bV3ldvRqGDlXkuiUJYmIga1YYP14p6Kd2CJP4s0hr+N1Rm5CQ8EULMkiSlBRprTqtVb44JEmRkF+xAjZsgA3rid4zmfBcJ3HM1BhHx4poNDY4O9fEzi4vISEbCQnZwJMnvXBxaYiHRzv0+sJI0rvNf0LCU968mY+DQwlcXb9Gq1XFF1MbIQTBwcHMmjULnU5Hp06d8PT0RJZlLly4wKpVqyhdujRNmza1mIlLHx8fOnXqRN++fZk3bx7Tpk3DxsaGLl26sHXrVtavX0+dOnXImVOtjW7JaLVaypQpw+DBgxkxYgTffvst8+bNo1ChQgDIskxoaChPnz7l6dOnPH78mCdPnvDkyRMePXrE48ePiYyMJE2aNGTMmJFy5crh6+tLxowZ8fX1xdfXl/Tp03P8+HEGDBjAhAkTcHNzo2TJkmad0AgMDOTkyZOULFmSdOnSmdVp6u7uzpgxY+jVqxffffcd9vb2lCxZkrCwMJ4+fcqzZ894/vx50jF//vw5VlZWZMiQgYwZM9KoUaOkv/38/PD19cXb2/udfZo+fTrx8fGsWrUKb29vOnfuTFRUFCtWrMDLy4shQ4akqKhZVFQU58+fx8nJiaJFi3L8+HEiIiL46quv8PT0TLHt/hMkSaJnz56Eh4ezcOFCFi9ezLBhw3D9q0KWKn+LkoXxmtjY68TGXiUm5goxMT8TH/8rNjZZcHSsjF5fGL2+IHZ2BdHpXACIjDxOaOgWrKyU6zE6+gIODmXQat0/e0eeyQTXr4OzM1So8Lvsk04HNWtCtWop7wQRwoiLSx2cnasjhBGNxgZJskOIWGQ5LlVFMROzIfbu3cuqVato0KABZcqUIXfu3DRt2pQRI0YwdepUZs+e/UnUfzYYDKxdu5arV6/SuXNnypQpA8CNGzdYsWIFGTJkoE+fPqoo7H/g7t27TJw4EWdnZwYOHJjiE7H/hHr16rF48WKOHj3Kjz/+SIUKFVJ8m9HR0cyZM4cbN24wYMAA8ubNy6hRowgMDGTu3Ln4+PikuA2OjrZ07gz9+8P+/ZAz57s1+VMDIQRHjhxh3bp1FC5cmL59+6b4+MnGRmmnt26FdevA31+ZcLSUx5Ysx5GQ8BSAiIj//bZWwsGhNNbWGYiKOkd09HlevBiFlZUXDg6lsbcvhb19cWxtc6HRmKeNTdmzZmWlOKWLFIFHjyA8XImRd3RUph0yZVId1n8gMdL6Q05rOzu7JKf1l07isVCd1ipfJJKkiDB27owoV5rYyHUEmVYQ9vQEbm4t8fDoiJVVGqytM+Lt3RcHhzIEBS0hNHQL0dHnyZhxAfb2xd8Z+Gm1TqRNOwJr64zY2KjZL+Zi6dKlnD9/nm7dulG6dGk0Gg0RERHMnDkTIQSdO3cmbdq0FjVob9KkCcuXL+fgwYM0adKEMmXK4OvrS69evRg6dCibN29myJAh6gDMwrG1taVhw4aEhoYyatQoevToQbVq1dBoNDx48IDAwECCgoIIDg4mODgYOzs7smfPTv78+WnatCmZMmXC09MTd3d3PDw8cHV1fc8hXalSJQYPHsyoUaMYPHgwy5cvN1vWgCzL/Prrr1y/fp0hQ4bg4eGR6ja8jSRJeHp6kjFjRo4fP86ECRNImzYt0dHRBAUFERsbS5o0aciVKxc1a9YkR44cZMyYEQ8PDzw8PHB3d0ev1//lsUyMsOrfvz+zZ8/Gy8uLb7/9lrCwMFavXo27uzvffPNNsgszJRIUFMTRo0eTJglGjx6Ni4sLlStXtog2zcbGhp49e2JjY4O3t/cn4QCzVEJDQ7lw4QIZMlxHpztAQsITDIZXWFtnwNGxImnTjsTGJvNvUVxuSNK7bYWNTTacnKoSH/8LspyAq+vXODqWQat1xmgMQ5IktNqUuU7NiRAQGakIeWm1iha3l9fvn2u1ypLSxMRcIjBwBm5uLXB1bQQIgoPXERy8Aj+/ZdjYZEl5I94iXbp0dOzYkbNnzzJu3Di2bt2Ko6MjzZo1Y+fOnWzbto169erh7++fqnb9F65fv87WrVvJmDEjvXv3RqPREB0dzerVq7l//z5z5swhS5bUPb6fA1FRUSxatIhr164xZswYSpcubW6TAMVnMXDgQJo2bcoPP/xAoUKFUuwZC4qj9vDhw2zdupXixYvTpUsXjhw5wq5du2jatGmqiQ1rNFC5shJhvX07NGgAuXKlrvP2119/ZcmSJcTExDBu3LgUnZRPRJIgSxaoVw+mT4dDh6B169Rpt/8OIWTevJlPePhBvL37YmdXACHicHQsh61tHuzs8uHoWJmEhCfExt4gImI/4eEHCQvbiY1NFvT6Mty7V5VSpSqkfmm/1C6irfLXHDx4UHh7e4v+/fu/s16WZVGkSBFRuHBh8fTpUzNZZxkkJCSIihUrihIlSlhEcX8VFXMiyyZhNISJsLA94saN3OLSJXtx505FERFxPEmEUZZNwmAIEkFBq8W9e/4iPv6RCAvbL54+/VY8efKNePNmmTAYQoXJFC9Mpnhz79IXiSzL4vLly8LDw0MUK1ZMPHjwIEkMY+bMmcLBwUH07t3b7KJ1H0KWZbFr1y5hY2MjevfuLaKjo4UQihBLvnz5RMmSJcWVK1csUthD5X2ioqLE8OHDha2trdDr9cLe3l5YW1sLPz8/ERAQICZOnCj+97//ifv374sXL16I0NDQJHGsf0J0dLSYMmWKcHNzE+XKlRPBwcFmuTZiY2PFt99+K/z8/MT+/fvNfn0mCrDmzZtX5M+fX2TOnFnodDrh6ekpxo8fL37++Wfx6NEjERgYKCIiIoTB8M9Fdt/GaDSKU6dOiUKFCon06dOL48ePi19++UVUrVpVuLu7i+XLlyeLGOcfMZlMYs+ePUKv14tZs2aJO3fuCC8vL1G6dGkRFxeXrNv6GBSBoigRHR1t9mviU+Bt4SaDwSB+/PFHMWjQIFGkSBHh5eUlJk0qKa5c8RQPH7YSoaE7RVzcr8JoDBOy/PcCYLJsEiZTrDCZooUsG4QQsoiJuSXu3CktXrwY849+41NDloWYPVsIBwchBg0SIjbWPHaEhPwgrl71EYGB3wlZNgpZThAvXkwUly7Zi5iYVFCB/ABxcXGiVatWwtnZWSxatCjpujty5Iiws7MTtWrVEqGhoWax7Z+Q2LaMGDFC2NnZidWrVyeJLx46dEhkzZpV+Pv7W/Q+WCqyLIsdO3aIjBkzWtwxlGVZhISEiAYNGogcOXKIU6dOpdizRZZl8csvv4g6deoId3d3cfbsWfHw4UORL18+UaxYsVQXGk5IEGLpUiGcnRUh2bg4pY1LaWRZThJxtbe3F6NGjRKxqdiYyrIQP/8sRJEiQuTOLYQlDN2U63CLuHo1vbhxI7eIi3v8N983CYMhVMTG3havX88Tt24VEYcPfyV8fdOIokWLigkTJoiHDx8Kk8mUKteU6rS2MI4fPy7Spk0runXr9s56WZZF2bJlRYECBcQvv/xiJussg4SEBFGrVi1RrFgxcePGDXObo6JiESgPlxDx5El/cfmyu7h82V08fz5KJCS8/G3AoTivlYHHBHH1qo949KirePZssLh3z1/Exf2iDtDNSFhYmKhcubJwc3MTmzdvThqM3bhxQ7i5uYmiRYuKO3fuWOQ5kmVZhIeHi1q1aomcOXOK48ePJzkw1qxZI/R6vZg8eXKqdhhVPo74+HgxYcIE0aRJE7F+/Xrx7NkzERcXJwwGQ9Ig+79ei4mDib59+wp7e3vRsGFDERQUlKrXtizLIjg4WGTPnj1JSd7cGI1GsWXLFmFraysWLVok7ty5I+zt7UXVqlVFTExMsiq6m0wmsWPHDpE1a1aRPn16ce3aNXHp0iVRsmRJ4enpKfbt2yeMxuR1CMbFxYl27dqJnDlzimPHjonZs2cLR0dHMWPGDIts11T+nMRrMSYmRgQFBYlz586JIUOGiGzZsglbW1vh7Ows/Pz8RJs2bcSRI/uE0Rj52yT6xw9ujcZQcfNmfnHtWmYRGrr7s3NcP3okRJo0QhQsKMSdO6nj4PkQitM6/R+c1hN+c1pfN49RQohHjx4JT09P8dVXX4l79+4JWZaFyWQS7du3F56enmLRokXJ3nYlF7IsizNnzohMmTKJgIAA8fLlSyHLsnjz5o3o2LGjcHNzE8ePHxcmk8ncpn5yXLt2TeTPn194enqK8+fPC5PJJBISEoTBYDC3aUII5Zm7f/9+4eLiIr799lsRHh6e7NtI7FvNnDlT2Nvbi/Hjx4vQ0FDRoUMH4erqKubPn5/qx0OWhbh3T4hq1YTw8xPiyZPUc1qfP39eZM2aVVSqVEn8+uuvqd7PMJmEGDZMCL1eiDlzzNeWC6H4CKKizoubNwuKy5fdRWTkmX98PBL9ByZTrLh06YRo2bKFSJMmjXBwcBCenp6iXbt24vTp0yIoKEjExsam2HFWa3NYGLa2tn8qxJhY0zo+Pt4MllkOak1rFZX3kSQNOp0r6dNPwM9vBXp9YQIDZ/DLLw2IiDiAyRT6WzqYIChoKZ6eXfD1XUD69JPIlu0ANjaZLSI9+0skISGBJUuW8NNPP1G/fn0aNmyIJEmEhoYyYsQIZFmmd+/e5MiRwyLPkSRJ2Nvb0717d16/fs2ePXuIjIxEp9NRtmxZSpYsyZYtW/jll18sSola5c+xtrZm6NChbNq0ia+//pr06dNjY2ODTqdDq9UiSdJ/vhYlScLW1paxY8cSEBDA4cOHGTduHMHBwcm8F3/NpUuXePLkCQULFiR9+vSpuu0PERsby+7du8maNSv58uVj7969aDQaatWqhZ2d3Ucd8z+i0WioXbs2AwcORJZl2rVrh0ajYcSIEXh5edG1a1fOnTuHLMvJsj2A8PBwDhw4QI4cOciUKROHDh1Cq9VSt25di2zXVN5HCEF0dDS//PILR48eZcqUKdSsWZOqVauycuVKnJycaNy4MXPmzOHMmTOsWLGCSpVqoNU6IEk6JEnz0edao3EmQ4bvECKO16/nEh9//7N5rsTEKHJP0dHQpQvkyGEJdVD/aIB5DcqYMSPffvst9+7dY/369cTFxSFJEoMHD8be3p7NmzdbZF9DCEFkZCRLliwhPj6eNm3a4OXlhSzLnDlzhp07d9KyZUvy58+vir/+B8LDw3n48CH58+fHx8eHN2/esGHDBn766SeLuBY0Gg358+enevXqbNq0iXv37qWIXZcvX2bevHmUKVOGpk2bcuTIEdavX0/VqlUJCAhIdT2cxFIZtWtDWBgsW5by2xRCEBoaysyZM4mJiaF79+5kyJAh1fsZGg20aKFURP7+e3j5MlU3n4QQgoSER7x6NR2D4Tk+PtOxty/xj4+H0vfUoNHYUqhQOVatWs2ZM2cYNWoUBQsW5MiRI1SuXJnatWszZ84cLl269MEyxx+L2ipaGDY2Nn8qxGhnZ4csy2pNa9T63ioqf4ZGY4OLS218fReRJs1AjMZgHj1qR1DQUmQ5FiFMSJI18fEPiI//BSFM5jb5i0YIwc8//8zatWvx9fVl2LBhaLVaDAYD69at49ixY9SvX59GjRqZ29S/RKvVUrhwYWrUqMG2bdu4desWQgjSpk1Ls2bN+PXXX9m1a5c60aiShIODA1OmTKF69eps2LCBZcuWERERkWrbX7t2LZ6enpQpU8asYpDw+yDryJEj5M2bl3Tp0rFv3z5sbW2pWbNmimxTq9XSpk0bvv32Wx4+fMiwYcNIly4dgwYNwmQy0bt3b86fP59sA+sjR44QERFB0aJFefHiBffv3+err74ic2ZVQ+FTIDIykh07djB69Gi6du1KQEAAS5YswdXVle7duzNr1iw2bNjAypUrad26dYoJmyqTpMXx8upLbOzl3/o2qddupBRCwOHDsHevorXdvLnZLTK3AX9KonN3+/btXL16FVCc2T179uTKlSvs2bOHuLg4M1v5PkePHmXXrl3UqVOHUqVKIUkSQUFBzJo1C29vb5o0aYKLi4u5zfwk8fDwIE+ePDx+/JjQ0FCePXtGv379WLVqFeHh4Wa1LTY2loSEBNKkSUO9evVISEhg3rx5nDhxggsXLnD9+nXu3bvH48ePefXqFeHh4cTFxf3rSePw8HAmTpxIQkICHTp0ICYmhjFjxpA+fXp69+6N19vF8VMRjUZxWufLB6tXQ2rEJ2zYsIEDBw4QEBBAxYoVzdbHy5kTvv5aRoifWLfuACZT6o65hRCYTBG8fj2XqKgTeHp2w9W1EZL0313AGo2GzJkz079/f9atW8e8efPo3bs3er2e6dOn06ZNGx48eJCMe6GQutMtKn9LYqT1h5zWiZHWqqP292OhOkBUVD6EhI1NJry9B+DgUI6QkPUoc5RaNBpr0qT5lsDAGTx61BEHh1K4ujbGzi4fkqRFlmMxGALR6TzQah3MvSOfPW/evGHVqlU8e/aM+fPn4+fnByjREqtXryZNmjQMGzYMOzs78xr6D/D09KR+/fqcOHGCVatWUahQIWxsbKhUqRLFihVj0aJFSYJ9amSlCoC3tzejR4+mf//+zJ07F09PT1q2bJmsAnhCCF68eMHz58/x9fXF29uboKAgDh06hJ+fH1999VWybetjOH78OJGRkRQtWpSnT5+milPX2tqaLl26JIm9zpkzh6FDhzJ69Gj69evH6NGjmTFjBvny5fvobQUHB5MvXz4qVKjAuXPnePnyJcOHD1fbgk+Eu3fv0qdPH8LDwylWrBj9+vWjZMmSZM6cOSkTI7XOpSTZ4ubWnNjYawQHr8HOriBubs0/aiBubp4/Vxw6cXEwciQ4OZnbokQSz6n4bTHv/ZooWNu9e3d69+7Nli1byJ07N46OjtStW5f9+/ezfPlyqlevTq5cuSymfQkLC2PcuHG4u7vTvHlz3NzcAFi9ejVXrlzhm2++oVChQhZj76dG5syZadu2LSNGjOCHH36gV69eVKlShUOHDtGoUSOziv0uXbqUR48e0b9/f4oVK0bu3LnZuXMnFy5cwNraGmtra6ysrJJebWxskt7b2dnh6OiIXq9PWhwcHLC3t096b29vj4ODAzt27ODEiRO0adOGkiVLMnbsWO7fv8/UqVMpXry4WfY9ET8/6NULnjxRnNgACQnKotf/vi45uHTpEtOmTSNr1qx07tw56V4zB5IEHTvCvn1T2b79BTVrZiBPnjypaIEgKGgRISFrcXauiYdHJzSa5BFQTGyLa9euTbVq1Xjw4AELFixgwYIFKTJRpDqtLYzESOsPlQdRo4sV1PIgKir/DI3GDgeHctjZ5UeStGg0NgC4ubXAwaEUkZEnCQnZSFjYTjJnXoetbX5iY6/z9Gk/bG1zkC7dGKys0qud6BTCZDJx5swZNm/eTOPGjalSpQqSJBEWFsbGjRu5ffs2CxcuJFOmTOY29R+h1WqpUKECJUuWZN26dXTq1InChQvj6+tLnTp1+Omnn5g/fz7Tpk0zt6kqFoIkSWTPnp1hw4bRp08fhg4dio+PD1WrVv1H7c6HooBlWebx48f8/PPPXLp0iQsXLvDkyRPs7e0ZMWIEAQEBHDp0iIiICMqXL2/WAc3brF+/njRp0lCqVCmOHTtGcHAwzZo1S/EIITs7O3r06EFwcDArVqzAy8uLfv36ERYWxogRI5g6dSqTJk0iffqPexa0aNGCunXrotPpWLBgAXZ2dlSsWDEZ90QlJYmMjOTp06cMHjyYLl264OnpiV6vN4stkiRhZZUGL68exMZe4/nzIdjbF8HGJucn2V8xmeDQITh2DNq3hyJFzG2RZZPY1/D392fVqlUEBARQsmRJMmXKRPPmzRk8eDBLly5l8uTJyToB+l8RQjB37lzu3btHz549KVGiBAAPHz5k5syZZMqUiVatWpntfvocsLa2pmbNmmzbto158+bRpk0bOnXqxNGjR9m7dy9FixbF2dk5VdsHIQQXLlxg7ty5aLVaBg0axPXr17l//z7p06enbNmyxMTEEB4eTmRkZNISHh5OREREUgCjVqtFo9G885q4vP0+MbuxT58+PHv2jLNnz1K5cmXatWuX6mVB/ogkQd26UKUKODtDhw5w7RqcPQvt2oGjY/JsJyoqinHjxhEUFMT48ePJlStX8vzwR+DtLdG8eXkGDx7Mjh07yJEjR6qcDyEEJ0/uR6tdhIdHdry9B2FllbwZUEIIXr16hU6nI2vWrPj5+WFvb4+VlVWybSMR1WltYSRGKvxZTWu1PIhCotNaPRYqKn+NJEnodK7vrNNobLGxyYmNTXacnevw8GETQkI2ky5dPjQaB3Q6V0JDNxMZeQQfnxk4Ofmj0eg/6SgmSyMx+nP8+PFkzJiR9u3b4+rqiizLnD59mtWrV9O0aVOqV6/+SdU3dHd3p2nTppw+fZpx48axZcsWdDodTZs2TSoB0b59e3Lnzm1uU1UsBK1WS8mSJRkxYgT9+/endevW7N27l0KFCn3w2pdlOWnSOiEhgbCwMK5du8ZPP/3ExYsX+fnnn4mJiUGr1SbV4Pbx8aF06dL4+PiQkJDA1q1b0Wq11K9f3yKcXG+ePuXm+fMUKFmSjBkz8uOPP2JjY0ONGjVSfNuSJOHu7k7//v15/fo1s2fPxtvbm3bt2vH69WvmzZtHmjRpGDJkCK6urv/6eAkhkGUZW1tbtFotR44c4fTp01SrVk1Nhf+E0Gq12NrakjFjRtKnT28BThANen0xvLx68Pz5EB4/7kqWLDvR6VzMate/RQh4+FCJsk6TBjp1Agvws/7GHycFLaNkiCRJeHl50aRJE06dOsWECRPYsmULer2e2rVrs2fPHhYuXEizZs3MnkkjhODSpUssW7YMHx8f+vbti7W1NQkJCYwdO5aYmBh69OhBlixZzGrn50CGDBmoX78+Fy9e5LvvvmPgwIHUrFmTjRs30qJFC4qk8mxQaGgoM2bM4NmzZ6xcuZLIyEgWL16M0Whk6dKlFC5cGPh98v3tV6Wsg4no6GjCwsKSHNmJTu3E94lLSEgIx48fT3IWFitWjBUrVpA+fXrs7ZMnsvZjsbGBV6/gwAEoWxZiYyEkBAwGJeJao1Gc24ndvn/bNTOZTCxZsoQTJ05Qu3btVJn0/6c0a9aMZcuWsW/fPurUqUO+fPlStO8pyzIXLlygdevuZM7swZYt07C1Tf7ME5PJRJMmTbh//z4PHz4kNjYWvV6fIv0D1WltYfxVTWu1PMjvJEadq5HWKir/DiFkDIaX6HQeSJI1kmSFJFmRKHFgZ5cbP79VBAcvJzh4DY8etcbFpQFeXr2xs8uHRmOLudNDPwdiY2MZMWIEDx48YPjw4RQqVAiAFy9eMHnyZLy9vWnbti3u7u4W4VT7p0iSRI0aNShevDiHDx/m8OHDVK9eHQ8PD7p06ULPnj2ZMWMG8+bNw9bW1tzmqlgIGo2GOnXq8ObNG4YPH06nTp1YsWIF+fLlQ6PRIITg8ePHBAUFERQUxL1797h+/TpXrlzhzp07SJKEs7Mzzs7OSUJ/+fLlI3/+/OTKlQu9Xk9ERARhYWHMmzeP06dP4+HhkTRoNDcuO3ZwPEcOXgUEEPzoEQnPn9Oofn0cHFKnRJMkSfj6+jJo0CBev37NyJEj8fb2pmvXrrx8+ZJly5ZRunTpfySaKIQgKioqaWAdFhbGkydPks7XhQsXiIuLo2TJklhbW39S7ZuKcq9KkoQsywQHBxMWFka6dOnM4hiRJA1ubm2IiblKcPBKAgOnkSbNULRay3DS/BMMBti9Gy5dgrFjwdfXEsQXIdFBnXh//p7UYhHGIUkSFStWpHr16qxYsYJt27bRsmVLvLy8aN26NT/++CMjRoxgy5YtOJmx1kpkZCQLFiwgNDSUyZMn4+XlhRCCffv2cfDgQb766itatGihtoPJgCRJNGnShHXr1rF27VratWtH/fr1OXToEIsXL+a7775LtVJ7CQkJbNmyhRMnTtC4cWNq1qzJggULOHv2LIMGDSJv3rz/KBrVwcEBb2/vf7TN2bNnM3LkSFavXs2wYcMoVqzYx+5GsmNlBW3awPLlUKGCsu70aaVsiL29EnHt6Ai2tqDTKd/X6cDOLgJ4iVYrodPp3lu0Wi1Xr15l7dq1xMfHM2HCBLNPrCaS2D/t1q0bAwcO5MiRI2TPnj3FxkBCCO7du8fgwYOJjo6mY8eJeHiUSpFtxcbGEhsbi42NDbIsEx0drTqtvxRsbW3/sjyIGmmtoDqtVVT+GyZTOK9eTcLKyhut1oW4uFsIkYCdXS4SEh5hY5MZnc4Nb+/+ODhUIChoIeHhB4iNvY67e1tcXRurJUOSgaNHj7J+/XqKFStGkyZNsLa2RgjBli1buHHjBgMHDqRo0aKf5HHW6/X07t2bkydP8v333/PVV1/h5uZGgwYNWL58Of/73/84c+YMlStXNrepKhaEJEm0adOGiIgIJkyYwPDhw5k6dSo5c+ZElmVmzpzJtm3bCA0NxdXVlXTp0pE+fXqKFy9OpkyZyJIlC5kyZcLNzY3IyEieP3/OixcvuHTpEg8fPuSXX37h4cOHBAYGYmdnR6tWrSxjUBMbi/WOHWR+9IjMJUoQfe4cQ6KjcWrQIEVSLP+KggULMnLkSPr27cvAgQOZPXs2/fr1I3PmzPj6+r7XHiVGUb958yapbvizZ8/eOd6//vorBoMBb29v0qdPT8WKFcmXLx8NGjSwiNR9lf+G0Whk586d7Ny5kxEjRpgtolWjsSZt2hHExt4gOHg1dnYFcHVtiCRZwL39NwghuH8/lvnz7ShZUqJmTcVZYwlo46zRB3qic7QGD2WdVaQ9DoFeaLJaxrG1t7enffv2HDt2jKlTp1K2bFn8/Pzw9/enevXqbNq0iY0bN9KxY0ezZKyZTCaOHj3K4cOHqVKlCvXr1wfg+fPnrFq1ClmWGT169CehWfKp4OnpSbdu3ejevTsLFixg8ODBlCtXjq1bt9KhQ4dUqe0shOD27dusXLmSdOnSMXDgQC5fvsz3339PqVKlaNy4cYpM8rVq1Yrly5ezb98+GjZsSIECBZJ9Gx+LRqMIzV66BMePK9HXR47Ali0QH6/U9I+PV75ra6vUu9brIVu2y0REjEGni0ev12Nra4udnR12dnZJ5SiuXLnC1atXsbKyIigoyKKyF6ysrKhUqRKFChViw4YN1KlThyxZsiT7GE8IwcuXL5kxYwY3b96kd+/eNGvWLFm38TYxMTEYjUacnZ0xmUzExMRgZ2enOq2/BN6OtBZCvHMxJ0ZaxyfezV8okiSh1+vVmtYqKv8BSbLG2bkGsbHXMRheYW2dGWfn+oSErCU4eA0eHu1xdq6FRqNHry9C+vTTcHSszJs3C3n5cgKRkUfx8OiCs3MNJMky0q4+RX766SdkWcbV1RUfH5+k9fny5aNXr160bNnykx7IlClThlq1anHgwAH27dtHixYtcHBwYMiQIQQEBLBhwwaKFCmilgdQeQedTkeXLl2Ijo5m1qxZTJkyhfHjx5MuXToKFCiAi4sLmTNnJk2aNHh5eeHp6YnJZOLXX3/l3r17nDhxgkePHvH69Wtev35NYGAgRqORDBkykCNHDho3bky2bNnw8vKiatWq5t5dhatX4f59KFYMXFywP3qUcjqdIjufypNWkiRRrlw5pk2bRseOHRk7diyTJ09m0KBBSVFBsbGxScf73r173L17l5cvXyYd89evX6PX68mWLRv58uWjSZMm+Pn54e3tjbe3N56enri6uqoO60+Qt8clibUsb9++TVRUlFnt0um8SJ9+Ir/+2pqHD5fh51cAd/fsFj/pK8sy06ePQa/PTosWX5Mpk+XUNNbfFvjMNqJtB2QESQbnUzL260xYLQWSqQbtx1K4cGHatGnD+PHjWbBgAePHj8fOzo5vv/2Ww4cPs3z5csqVK0fOnDlT3baXL1+yYcMGhBD0798fW1tbDAYD+/fv59SpU7Rr184io2E/dRo0aMDSpUs5dOgQTZs2pVGjRkkTG5s2bUrxyeqoqCiWLl3Kw4cPmThxIl5eXvTs2RMhBB07dkwxnRoXFxf69u1Lnz592LdvH9mzZ7fIcYSLC1SsCNOmgY+PEnldvfrvwozx8coSE6MsUVFgY+PI69dFiIh4Q1RUFDExMbx584aYmBju379PeHg4Tk5OlC1blsuXLzNlyhQ2bdqU6hP/f0WGDBmoXr06Y8eOZdeuXfTu3TvZr8Xo6GiWLVvG9u3badasGT169EjRCbtEp7WLiwtGo5GYmBg10vpLQavVYmVlRWRkJEaj8Z2bTRVi/B31WKio/HOEECQkPCIi4n84OlbGyakmjo6VEcLwW3kQHfHxd3nxYhSxsVeJiDhKmjSDsLb2RadzxdW1EXp9UYKCFvHmzWLiQ27gcKMXulotwMtL2YiFDw4tjbZt2zJz5kxevHjB3bt3k8RCKlWqxFdffWXWdNbkQKfTMWjQIHbv3s327dupVKkS6dKlo3Tp0lSrVo1du3ZRrVo1GjdubPGOBZXUxc7Ojm7duhEWFsaSJUvw8vJi5MiRNGvWjPj4eJ4/f87Vq1c5dOgQFy9eJDAwkOjoaKKjo4mKisLe3p48efJQvXp1ChcuTL58+XBxccHe3h57e3v0ej1ardYyrjsh4PBhCA2Fpk0hMBDOnYPatcHDwyztqkajoWLFisydO5f27dvTr18/GjZsiF6v59q1a9y7d4/IyMik4x0fH0+2bNkoVKgQzZs3p0CBAnh7e+Pg4IC9vT2Ojo5Jei0qnxeJNVjNfW4lCfT6ouh0Yxk/fjzp03/PiBFjcXFxMbttf0ZiiYjt2xdTtWpN6tZtiSUkfiSiC0lAdzkEahuVFQKsXsRgdSkEYk3mNe4ttFotXbt2ZdOmTezcuZNatWpRtmxZsmfPzjfffMPw4cNZt24dw4cPx8bGJtXsMhqNnDp1igMHDtCzZ8+kqNdHjx6xdu1aMmbMSLt27SzKqfa5YG9vz+DBg2nQoAHbtm1LygQ5duwYx44dSxI9TwkU8buTrF69mjp16lCrVi0WLFjATz/9RLt27ahRo0aK1VnWaDRUqVKFQoUKsWPHDurWrUvu3Lktog18WzNbo4GiRaFwYXj2DHLlUsQZ30aWFYHaxEWW82A0DsNkMmIymd5Zfv75Z5o1a0alSpUYP348gwYN4vjx4xw7duwfi3qnNEIIoqOjefr0KbGxscyYMQONRkOJEiVwcHDAwcEBZ2dnHB0d//P1IYTg4MGDzJ49m9KlS/PNN9/g5uaWovsfGxuLyWRSI62/RCRJws7ODiEEcXFx7zzM1JrWv5MoxKhGWquo/D1CxBMWtoMXL0aRPv0EPDy6/FabOjEPVeDp2Q0Hh3I8fz6UkJDVREUdJ336STg5VUOS7LCxyUq6dBNxdqqNYf0ctANHwbJtMG4clCyp5HFZQMfgU8HX15cJEyYwdOhQfvjhBwYNGoSVlRVarRbnP/bePkEkSSJLlix07dqVixcvEhwcTLp06bCzs6Ndu3Zs376d3bt3U758+X9cr0/ly0CSJNzc3Pjmm294+vQpc+bMYdu2baRPn547d+4QExOTVFdXp9OROXPmpMmeYsWK4evri1arTVoSo0wsYeDyHiEhcP68orxWrRrs2AFBQUr+rBknrjQaDdWqVWPs2LH079+fGTNmYG1tjVarxcbGhmzZsiUd79KlS+Pu7v7O8ZYkyTKPt0qyYxnnWUKSrPD2roaHx2kWLlxGvnyFLacE0AdIrHFsZaWjX7+eODlZeOaBsAwRxg/h4uLCxIkTCQgIYO3atRQoUAAnJyfatWvHtm3b2LVrF9WrV6dUqVKpcr0KIXj9+jUzZ84kZ86cNGrUCHt7exISEti9ezc///wz06dPJ2vWrBZy/3x+JAZIHD58mEaNGvHNN99w4sQJZs2aRenSpdHrUyarITg4mH79+uHj40Pnzp25desWixcvxtfXl6FDh6Zo5LMkSaRNm5Z27drRo0cPDh48SNasWVN1subPCAlRksrWrlXe29lB//6KGOOHpDs0GmX53Q1m89vyLkIIXF1dqVmzJrdv3+bNmzf07duX48ePM3fuXEqXLm0RQpSyLHP69GnWr19PunTpiIiIYODAgUn1uOHdSWAHBwfc3Nxwc3NLCrZIfO/g4ICdnR1ubm64urri7OyMra0tYWFhdO3alYwZMzJo0CCyZs2a4hPLiZHWTk5OSU5rNdL6C+Jtp7Wjo+M769Wa1gqJ5UHUY6Gi8tcIIYiNvc6bN/Oxty+Bs3NNNJo/Do6UAZ9eX5BMmdYSFLSU4OBVPHzYDHf3tnh69sDWNhsajS2OjuWhaQF4NgPWrVOiAzt3htatIUsWLCpUyIKRJIlmzZqxevVq9u3bR926dVNcTTq1sbGxYfjw4cTHx+Pm5gaQ9GyTJAkrKyuz1JlUsXwkSSJDhgx069aN169fc/36dbRaLVmzZiVjxozkyZOHAgUKUKBAAXx9fc1t7n8nsTRIvXpK27lnD+TOrYQemfHekCQJGxsbAgICiI6O5sqVK1SoUIHixYuTPXt2ixgEq6Q+fyxbKCzIkalMdnnQoUNHrly5ytChQ8mfPz9FihQxt2nvYTAYWLp0KTdu3KBdu3aULFnS3Cb9OZ9AnySxrFFAQAAHDx6kdu3a1KpVCycnJwYOHEjbtm3ZsmULefLkSZWSZLIss3TpUu7evcvw4cPJmzcvAPfv32f27NlUqFCBqlWrqiWSUohEp1+3bt1o3rw5e/fuZdiwYfj7+3P69Gn27dtHQEBAsve3Y2NjGT58OM+fP2fw4MFkzpyZ7t27ExUVxeLFi0mbNm2ybu9D6HQ6SpUqRalSpVi2bBkNGjTAz8/PrGOL+HhYtQomToQJE6BAAaVZcXL6+Ln5xHPduXNnWrZsyd69exk+fDj+/v6cOXMm6Vybc6whhOD58+dMmDCBdOnSMWPGDDZu3Mj69etJmzYtJUqUwGAwEBUVRUREBAaDAZPJhNFoJDQ0lDdv3iS9NxqNSX+/vS5xsbe3p02bNpQqVYqXL19y7do1KlSokGKijzExMe9FWtvb26dINoHqXbBA3nZav40aaa2QGI2uCjGqqPw9shzFq1fTkeVYPDw6YG391w4eRYSxHw4OZXjzZhGhoVuIjj6Ph0cnXFzqY2WVFsnVFYYPh7JlYdkymDsXjh6Fbt2UaME0aVJp7z5dJEnCxcWFzp07M3jwYP73v/+RLVs2i6w/91+RJCmpJEMib968Yfr06aRNm5aaNWsmObNVVD5EhQoVSJs2LadOnSJ//vzkyZPHIqJmkgWDAa5cgZcvFad1YCCcOQMNGkAK1bz8t3h5eTFgwABzm6Fi4VjSZGvBggXp1asX/fr1Y+DAgaxcuZIMGTKY26x3uHHjBlu3bsXHx8dy76/ECYm3z60QFuvE1uv1dO7cmbNnz7JmzRq++uorvL29KVGiBHXr1mXr1q3Url2bSpUqpbgD6/r16yxcuJCiRYvSqFEjrKysiI+PZ8qUKSQkJNC0adMUq2usoqDRaChYsCDVq1fnhx9+oHHjxvTt25djx47xww8/UK5cObwSyxsmA7Iss3v3brZu3UrZsmVp3bo1W7Zs4ezZs7Rp0yZVNTQyZcpErVq1GD16NOvXr2fIkCFma6NlWenmrF8Pvr5QpUryb0Or1VKoUCGqV6/Otm3baNSoEf379+fEiRP88MMPlC9fPlnP9b/FaDTy/fffc/fuXQYPHkz27NkJCQnB3t6ecePG0bx586TvJvr/YmNjiY2NJTo6OunvP76PiYlJWhK1Rnbt2pVU63vDhg1MmjSJuXPn0qxZsxS5Bv4YaR0dHY2Hh4caaf2l8FdOa1mWv3ghRkB1Wquo/ENCQtYREXEAN7evfyv18ffNviTpcHAohY1NNhwdKxAUtIyXz8divf8SzplbQ+mySjmQatWUiMAKFWDePOjXD+rWVZzXhQqpUdd/Q6KadJEiRVi9ejX16tX7rNNFhRB8//333L59m549e1K1atUUq+2n8vmQI0cOcuTIYW4zkp+gILhwATJmhPz5YedOZf1XX5m1NIiKyof4UJqxJUVaJ6LRaKhbty43b95kxowZTJ8+nXHjxlmMTkRERARbtmzhwYMHzJw5M1WiL5MVC+2fJDopmzZtyuLFizl06BDNmzfH09OTZs2acebMGb777jtKlCiBvb19iqbLT5w4kZiYGNq3b5/knN63bx+7d+/G39+fWrVqqVlmqYCXlxf16tXjxIkTrFu3jjFjxhAQEMCePXs4e/YsdevWTbbzcPv2bebNm4eVlRVjxozh1atXrFy5kty5c9OjR49ULVOk0+moU6cOW7duZfHixTRr1owsWbKk2vbfJjRUiW169gxmzVIc1ylx63l7eyed67Vr1zJu3DgCAgLYvXs3586do06dOma75/bu3cvy5cspVaoUTZo0YevWrRw/fpyWLVvSoEGDd76bGJj5XwKYXr16xdOnT9m8eTNly5alTJkyODs7M3nyZPLly5eU8ZGcJNa0frs8SErVtFZbTAsk8UL9o9NaFR/8HbWmtYrK3xMbe5NXr6ZgZZUWL6+e6HQu/+r/dToP3N1b4eu7iAwxXbBbfAxat4WxYyEsTOl5ZMwIHToo0+h168K2bYoU9Pz5igy0yp8iSRK+vr4EBATw4sULNm3ahMlkOQJHyc3Ro0dZunQpuXPnplu3bp9F7W4Vlf+MRqNEVH/9Nbi7w8aNkC6dUs/aQh1DKl82luik/hB6vZ6+fftSrlw5Nm7cyJYtW5Bl2dxmIYTg5s2bbNiwgYoVK+Lv72/Zzss/nm8LP/+Ojo40bNgQPz8/Jk2aRGhoKBqNhrJly+Lv709YWBgREREpasOrV6949OgRVatWpUGDBkiSxOvXr5k2bRo6nY4+ffqoGWaphFarpWLFipQoUYJVq1bx+PFj2rRpg1arZdeuXQQHByfLdqKioli/fj0//fQTAwcOJGvWrMybN4/AwEB69OhB5syZUz0Yxc/Pj0aNGhEaGsqCBQtSdduJmExw5Ahs3gz16ytxTikVp6LVapO0TdasWcPjx49p1bIlmb28MJ09iyk0NGU2/Dc8efKEiRMnAjB48GCeP3/O2rVryZAhA0OGDEnW7Fpvb2/GjBlDeHg4K1euJE2aNPTv35+7d+8ye/ZsoqKikm1biXyoprXqtP6C0Ov1anmQv+HtSOtPpROtopKayHIML1+Ow2h8TZo032Jrmxv4d50mRUxLh61tbly/Gob1sLlI9vYwfTrUrKn0RhISFBGx/Pnhu+9g4ULF4fLDD2A0KoMcWVb+NpksftCT2lhZWVGjRg0KFizI7NmzCQwMNLdJKUJQUBATJkwgJiaGMWPGkD59enObpKJiPoQAZ2cYMEDJTDEYIEMGKFwYcuY0t3UqKv+IP9a4tiRcXV2ZM2cOdnZ2LF68mJ9//tms4wUhBJGRkSxatIj4+Hjatm2Lt7e3xR6/D5YHsXAkSaJw4cI0bNiQZ8+e8d133yHLclIa/p49e0iTJk2KHnNfX1/279/PnDlzsLe3x2QysWzZMm7cuEHHjh356quvUmzbKu/j5eVFw4YN0el0TJ8+nRw5clC/fn22b9/OzZs3P3oyS5Zlzp8/z5o1a/D39+frr7/m4MGDbN68mQYNGlCtWjWzZBRqNBratGmDn58fmzdv5urVq6luw+vXMGSIInfUrh24uaVsc+Lp6Unjxo2xsbZm3owZfJUrF3vLl6fOkiXorl9XxqKpiCk+nsVz53L71i369etHjhw5WLNmDQ8fPkyqb53cFC9enG7durF7924OHDhAy5YtqVKlCnv37mXHjh3JPnmbGGmdWNM6Ojo6xYQYVae1BaLWtP5r3hbwSkhIsIjoCRUVS8JoFAQG7iEi4iSOjlVxd2+DJP335l6SJCSdNVKNmnDyJHTqBE+eQMuWMGkSPHigdAYcHaFZM8VhvXSpIvv84AHs3QvLlytR2DdvQkxMMu7tp0/GjBlp2LAhRqORadOmYTQazW1SshIfH8/ixYu5fPkyHTp0oGrVqpY7UFdRSWmEUEZzU6ZA797QqxesXAkrVih5tGrJHBULRpnMtvz2W5IkMmfOzJQpU7h//z4LFiwgMDDQrI7r06dPs3XrVurWrUvp0qUtO8o6kcRzLYRF17RORKvV0r59e/LkycOCBQu4fPkykiTh6uqKs7Nzih9zrVaLm5sbadKkQQjB5cuX2bJlC2nTpmXAgAFqSbRURpIk6tWrR6FChdi+fTt37tyhbt26eHh4sGnTpo8quSqE4OXLl8ycOROtVkvv3r2Jiopi0KBB5M6dmw4dOuDq6mq29tLZ2ZkBAwYQEhLCkiVLUrW8bEyMYPBgQXCwMlQsVizlmw5Jkqhbty6D6tWj/08/obtzB4datbByc0OaNy91x54mE5oDB+h86RKdypWjR/fuHD58mK1bt9KuXTvKlSuX7G1Roo5Q06ZNKVasGFOmTOHRo0dMmjQJGxsbVq5cyb1795L1GZgYaf22EKMaaf0F8WdOazs7O2RZ/uKd1qDcmLa2tkkKqyoqKgpCwJ07sHhxWh4+rEXatJOAZOgkS5KyuLnB1KmweLHSC5k9WykP8sMPSvEySYIcOZSp9f/9D7p3V757/jxs2QKdOyuOmejoj7fpM0GSJBo1akT+/PnZtGmTWSIiUgpZlvnpp5/YuHEj2bJls1zRKRWV1GTHDuV12TIlO+XBAzh8WNEBsHCnkMqXyx8Hux+qc21J6HQ6qlSpQps2bdi5cyfr1q0z26RwUFAQo0ePJkOGDDRv3tzyS0TY2yvZH46OyntJAhcXpSittbVZTfs70qZNS58+fTAYDMyYMYOwsLBUvUYTJ3YiIyPZunUrjx8/ZtiwYZZ/zj9THB0d6dmzJxqNhu+//57s2bPTq1cvSpcu/VHONSEEZ8+e5fz587Ru3Zps2bIxevRowsPDad++PYULF07Gvfj3SJJEQEAA+fPn59ixY1y8eDFVtivLMtu3n+TUqWtUrizTurVSDS01cHR0pE+dOmR7/hzmzUPKmRMqVYIDB5RxaGpMWgoBT58iLV9Oxl9+YfrgwegCAzm3bBk5smWjdevWuLi4pNjmc+TIQYcOHYiNjWXixImkSZOGPn36cOXKFTZs2EBMMjrvP1QeJKUirVWVLAvkz5zWNjY2ACQkJFh0Sl5qoNFosLGxISEhQXVaq6i8RUQErFsnsWRJWebMKYCNjUPytxVWVlC9upLGvm2b4pTu3RsaNlSc0gUKwPPnMHw41KgBPXqAtzdERcG+fTBhglLLtXbt5LXrE8bLy4uePXvSrl07FixYwJw5c9Dr9eY266MJDg5m5cqVBAUF8f3336d4aq6KisUjBJw5A127KoK2trZKO3nkCPxBlEdFxVL4Mwe1pbXnkZGRREdH4+HhgU6nw83NjU6dOnHlyhW+++47njx5gnUyO10lSUKr1f7p78bExPD06VNu3rxJ7969P40SEYULK9kg2bJB4ni0Vi3Ilw8+AfHIunXrsnXrVg4dOsTEiRPfE/OVJAlra+sUi3wWQvDo0SM2bdpEpUqVqF69usXdK18SVatWpVy5cpw8eZKrV6/SrVs3tFrtR0W7JmZzjBgxgpo1a7J371727t1LzZo1adGihUVkUtjZ2dG/f386duzI7t27yZ8/P46JE1EpxLVr15g7dzBubukZPnw97u6pPMlVtSqUK6dkBl+5Ak2aKE7rSZMUzZCUHlvFx8OmTUo/r08fNPnyYde/Pz1evSLwm2/Ily9firYFWq2W2rVrc/z4cTZv3kz58uVp2LAhp0+fZvny5ZQpU4YqVaokiw0xMTFJQowJCQkYDAZsbW1TpF1VndYWyIec1m93iAwGA0ajESsrKzNaaV40Go0aaa2i8gdkGX7+Wckyr1wZypd3SrlMc40GMmdWHNKVKysR13v3QpUqitP68GF49Qq++UZxWIMSpVO3rqLK8b//KY4aNVUyidq1a1OiRAmOHTvGmTNnqFq1qrlN+iiMRiNHjhxh27ZttGzZkooVK1pEJ15Fxexote9H/KRAZIqKSnLydqS1EMLiNGWMRiN79uxhyZIlDB8+nAoVKqDRaPD19SVTpkxcuHCBefPmpci2NRrNnz7fjEYjJpOJ3Llz07lzZ2xtbVPEhmTF21tJ2xs8WMkE0ekUh3XXrinv9EkGbG1t6dq1K3v37mX58uXvfS5JEhqNJkWdR4kBZg0aNMDd3V11WpsRGxsbBg8eTOXKlRk9ejS//vor2bNnx8HBAQcHBxwdHXFycsLe3h5bW9t/dK4kSaJQoULkyZOH69evs2zZMhwcHBgzZkyKRtL+GyRJokyZMpQtW5Zdu3bRsGFDihUrlmLXYkREBCtWrODq1SvMnt2WAgXM0K+xtlbaLX9/2LpVCZSqWFHJcNuzR3FipxRCKGUw58yBIkWUbe3ciWbbNnJWqULOxo2RfgtCTUlcXV3p378/J0+eZPbs2RQtWpS2bdty+fJlRo4cSYkSJZJl8iI2Nhaj0YijoyMvX75Eq9ViY2OTIteX2kO2QBKj6/4Yaf12SYwv3WktSZIaaa2i8geiomD0aHBygvbtlWCYFO8j6/VQqBB8/z3cv6+UBgG4dQs8PcHL693vW1srkTuPH0NkpOLIVgGUCcuRI0dSvXp1tm7dSvHixXFycjK3Wf8JIQSvX79mxIgRZMmShVatWuHi4qIO2lRUJAlKloRDh5RBjSwrE35q5onKJ8CH2nBLaNeFENy+fZvZs2cTEhKSJHIoyzJHjx7l+PHj5MqVixUrVqRIFpPBYPjTtOvw8HBiY2MpXrz4p1EiQgjYvx9GjlSiFjt2VMRiN2xQnNbLlyuZdhZw3v8MWZZZvXo1NjY2NGnShOLFi7/zuRCC2NhYDAZDitlw79491qxZw8WLF6lduzaOjo4Wca98qeTNm5d8+fJx5coVhg4dilarTTofb9fqt7KywsnJCRcXF5ycnHBycsLR0REXFxecnZ2THNzOzs44OzsTFRXF4sWLuXr1KkuWLCFr1qzm3M13kCQJDw8P2rVrR/v27dmzZw958uRBr9cn+7Uoy3JS3eY6derQrFkz813vBQoomWvHj8P169C3L+zaBfPmQbVqKTf2jI+Hb79VArs6dFD6d1Ongr090qhR4OqaMtv9ADlz5mTEiBF06dKFGTNm8P333xMQEMD8+fOZPn06o0aN+qhAosQ2VJZlnJycuHfvHtbW1kmVIZIb1WltgfxZeZBEp7XRaPzshLr+LYmR1gkJCV/8sVBRATAa4bvv4OJFpVJH+fKpV0MMSVLqHr5dv81kUhzUH+qw2NoqD3ILi9IyN5KkKN83aNCAI0eOcP78eapUqfJJRicnJCQwcuRI3rx5Q48ePShatKg6WFNRSaRxYxg1Cvr3VwY5Xl5K5omKyieEpZQqFEIQEhLCjBkzuH//PjNnziRbtmwA3L17l9mzZ2MwGJg1axZ58uQxq82WcLz+ltevlfR2f38YMgQcHJT1BQooTutly2DiRIutbS2E4MiRI2zdupVKlSoxadIkswQAvH79mqioKFatWkW9evUoV65cqtugoiBJEo6Ojvzwww8sXLiQhIQEtFotkZGRSUtERAQRERHExcVhMpmIiIggNDQUk8n0l0ui1ljp0qXx9/e3uD67RqOhaNGiVKpUiVWrVtGsWTNy5cqVrNsQQvDw4UPmzZuHra0t3377LU5OTuZp7yRJCajq3FkpC7J9u1IapGlTpaTlDz9A27bJP0hOHIifO6f8fsWKMHQoPH2qlFrKly9VJ/o0Gg0tWrRg//79HD16lO3bt9OzZ09OnDjB/PnzKV++PBUrVvzP50gIQa5cuahRowZ6vZ6IiAisra1TLJNIdVpbIH/ntE6MtP6SUWtaq6i8y7lzSrBzkSLQqZPiF05V/vjQ8/WFwEAlmvrtFCRZhocPFUFHe/vUtfETwN7ennbt2nHs2DF27txJsWLFcE3FmfnkQAjBnj172Lx5M5UqVeLrr7+2uE68iorZkCQl2mbGDKWN1OmUrBS1VJKKhWMpTuo/Issya9euZfv27bRq1YpatWphZWVFVFQUCxcu5OrVqwwfPpwiRYqoz6J/wuvXSjZco0aKwzrxnHt5KZ3MffuUwAQLJTAwkKlTp+Lo6Ei/fv1wdnY2ix1eXl40a9aM06dPM2XKFAoWLGg2W1QUP4qPjw/jx4//y+8lZk1ER0cTHR1NbGzsO+9jYmKSlqioKIKCgpAkiRYtWuDh4ZFKe/PPkSSJ9OnTU7t2bU6dOsWsWbP45ptvcHNzw9ra+p3lv7aPBoOBdevWcfnyZYYMGULu3LnN+6yQJCUbpEEDpSTI118r5SovX4bwcKX9Su5nwblzMH8+5M4NvXop2XT79ytlM9u0MUtmikajYcSIEVy7do1Vq1bx1VdfMXLkSNq0acO0adPIli0bGTJk+M+/3aNHD3r06IHRaOTNmzdotdoU0wlQndYWyF85re3s7FSnNe868FWntcqXzosXyiRufLwSuJcli7ktQnlIT58OW7YoD+vEh9jNm3DjBvTpY7FROuZEo9FQsGBBateuzY4dO2jatCllypT5pAbad+7cYfr06Tg5OTF48GC8E2uaq6io/I6VFfj4mNsKFZX/jKXUtD548CBTpkwhf/78dOvWDU9PT4QQrFu3jnXr1lGzZk2aNGnyWYgbpwpxcUqAgb39+44WDw8IDlY+t0CMRiMbNmzg4sWLtG/fnrJly5rNFkmSKF26NNWrV2flypVs3bqVDh06mM0elX+GlZVVUumPzwWNRkPlypXJlSsXK1eu5O7du3h6emJjY4ONjQ22trZJr3Z2duj1euzs7JLef2hdYv1vKysrzp8/z8KFCylTpgyNGjXC3hKCktzcFB2l//1PcVyPHQsLFkCmTEr/K7l59UoJ0ho+XBnzLlum1OscMsRsOgCSJJElSxa++eYbRowYwZo1axg2bBgdOnRg8eLFrF+/nl69ev3nZ2N8fDy//vorV65cYfPmzRgMhqTMg+RGdVpbIGp5kN9JFHr5o8NGjbRWUfmdAwfgxx+VbCSLyTDPkQP69VNqed29C/nzK971LVuUMiJ165rbQovF3d2dunXrcvjwYRYuXEjx4sVTrEZYchMTE8Py5cu5cuUK48ePp1ixYuY2SUVFRUUlBTFnRN29e/cYM2YMRqORESNGJKW9nz17lgkTJuDj40Pfvn1Jmzat2Wz85EgMMvhQvefYWCWVzwIj7gFu3LjBli1b8PLyom/fvujMLHDr6OhI165dOXjwIDNmzKBixYpkzpzZrDapfJn4+PgwcuRIhg8fTkhISFLkeFRUFJGRkURFRQGg0+mwsrJCp9O9s1hZWaHVat95r9Pp0Gg0vH79Gq1WS9euXfH19TXznv6GRgOlSilRXZkyKZltmzZBUJCSNdK+PWTNmnxtWfXqkD27kmk8bZoS1T16tDL+NWN7aW1tTd26dTl16hSrVq2iQoUKdOvWjXPnzrFq1SpKly5N6dKl/9FzPLGO9YULFzh16hQXLlzgyZMnvHnzhsDAQMqVK0fRokVTZD9Up7UFYmdnB/y9EOPnjCzLhIeHM2fOHIxGI2PHjn3nZlIjrVW+NIT4PRtTq/39+SfLUK+e8tqwoQUFL2s00KUL5MmjOKrXr1dmnHv0UAxNrJGo8h4ajYby5ctTpkwZtm7dSrdu3cwaLfRPEUJw7Ngxtm7dStmyZenYsWOKpYmpqKioqKQeiUEkbwuWmdueiIgIJk6cyNWrV5k0aRKVKlVCkiRevnzJ4MGDiYyMZPbs2eTPn98ibP5kcHFRIgafP1fqtCZ2Oo1GePBACUqwwGd7TEwMu3bt4sqVK8ybN4906dKZ2yQAcufOTceOHRk7dixz585l+vTpat9IJdXRaDRUqFCBffv2JbXlsiwjhECWZWRZJjo6moiICMLDwwkPDyciIoLIyMj33kdERBAWFkZ4eDivX78mLi6Ozp07U7VqVcvKDHVxUUqEgKIl0rIlVKgAhw8rjuWZMz+cUfJPEEJpEy9fhhMnlAF4jRpgYwPe3hAQoGzbzEFHkiTh5eVF27Zt+emnnxg4cCCnTp3i22+/pVu3bvz8888ULVr0vVrUQoikuu2vX7/m1KlTHDx4kBMnThAREYHBYECSJPLkyUOnTp0oX748BQsWxCWFRC5Vp7UF8meR1omfGQyGFFU7NieJndATJ04wZswY7t27R6lSpQgODn6nTlRipHV8fPxn78BXUQFlYnjpUsUX3LGjkvUkSXDpklI2q00bpUyqxYzLJEmJxqlSRVk+9LnKn+Lo6EiLFi04fvw4I0eOZN++fUkTmpaIEIKnT5+ydOlSEhISGD16tFmEj1RUVFRUUgdz1rhOSEhg7dq17N27lzp16tCjRw90Oh2RkZFMnjyZK1eu0K1bNxo2bKg6rP8t6dMr/bb165X6rImRwadPK2rfw4enTHr9RyDLMleuXGHNmjX4+/tTo0YNi3GeaTQaevXqxaZNm9i9ezd169alQoUK6nWpkupotdo/1clJjnJPFndNS5LSVv38sxL5FRCgrG/UCFavVibmsmf/779/6hTMmaNEbUdHKwP0JUugZ08lmuztKDMzotFoqFixIs2bN2fatGlMmDCBoUOHcuTIEXx8fLCxsUEIgcFgSBImffToEceOHePw4cNcvXo1SczU1dWVChUqUKVKFSpUqEDatGnfaWtT6hpQndYWiF6v/6DTWqfTUaBAAUwmE9YWE06ZfJhMJq5cucLatWvZsGEDzs7O9O7dm169er0nbJDotI6MjFQjrVW+CGJi4MwZOH8e/PyU561WCy9fKs/MgACLeC6+i8UZ9OkgSRIVK1akfPny7Nq1i127dtGkSRPL6xD+hsFgYMeOHZw4cYLevXuTL18+i7VVRUVFReXTxWQyce7cORYuXEimTJkYN24cVlZWxMfHs23bNrZt20a5cuUYNmyY+hz6L9jYQLNmiiDj+PFK7X1JUhw8TZpAuXLJL2L2EQghiI6OZtmyZcTExNCmTRs8PT0t6tzb2dkxevRo2rVrx/r168mfPz/u7u7mNktFJQlLul+SnZAQRfAalLZMp1Oiv0JC/vtvyjJs2KBkFSfW5oyKgpUrYdIki2ojQfGdde3alZMnT7Jq1SrKly9PrVq1khzUT58+5e7du1y8eJELFy7w9OlTPDw88PHxoW7duhQsWJBixYpRpEgRswQlqU5rC+TPIq1tbW3p06cPoCgSf068fv2aTZs2sW7dOn755Rdq1KhBy5YtqVChAlZ/mM0XQhAWFkZQUBCvXr3i9u3bZMqU6b3vqaikFI8ePWL37t2EhIQkCVNYW1tjZ2eHjY1N0t/W1tZJ4hbKOj02Nu7Y2Dhja6tkEv2brCFra6U01qJFUKKEUjZL5fPFxsaGPn36cPDgQZYuXUr58uVJkyaNuc16DyEE169fZ/bs2RQsWJAmTZrgoJZ/UVFRUfms+GNkdWJkXmo6O4QQvH79mpkzZxIVFcWoUaPIkiULQghu3rzJ/Pnz8fT0ZNSoUTg6OqaaXZ8d6dIpEdXXr8OzZ0qURKZMkDMnWGDW19GjR9m5cycNGjSgTJkyFll+o2LFitSrV48DBw5Qq1Ytateubfaa2yoqXwQZM8KTJxAfr2QBh4dDRAR87Jjq5ct3B+PZs8Px4x/3mymIl5cXI0aMICAggFGjRnH27FnevHnD/fv3uX//PrGxseTIkYNSpUqRO3dusmfPTvbs2fHz8zN7tq/aUlogGo0GWZYJCwt7Z71WqyVjxozmMSqFMBgMnDx5kjlz5nDq1CnSp0/P9OnT8ff3x8vL673ULiEEhw8fZsqUKfz8888YjUYGDhzIyZMn6dmzJ5kyZTLTnqh8KcTFxbF8+XK+++47YmJisLa2RqfTodVqk0Qq3v47UbBCq9Wi19tjY9Mdg6EFOp0yBrC2Vvr/er1SVsvWVnnV65X1Dg5KacFcuZRJ20aNYPdumDEDvvvO3EdDJaUpVKgQzZo1Y/369ezatYtOnTpZXDREQkICo0aNIiYmhvbt25M9e3aLs1FFRUVFJXkxR3kQIQRTp07l9OnTdO/enWrVqqHT6YiIiGDy5Mk8ffqUyZMnU7BgQYspD/HJ4uAAJUua24q/JSIigrFjx+Lq6krLli0tMoJZkiTs7e1p3749p0+fZtWqVZQoUcIiAxFUVD47MmWCggVhyBAoUwbOnVOiwLy9P+53PTzg1SuljBIoE3wf+5spTOnSpWnYsCFLlizh+vXreHt7U6xYMfr370+hQoVImzYtXl5euLm5odFoLGY8pzqtLZBEp3VERASyLFuM6ElyIoQgJCSEBQsWsGjRIkJCQmjevDkjR44kTZo070RNJ4q/vHnzhtmzZ7NixQpiY2Np06YNBQsWZN68eSxatIgffviBLl260L59ezw8PD7L46ZiXoQQXLlyhZ07d2I0Gtm1axcODg6Eh4cTExOTpMAcExNDREREkipzVFQU0dHRxMcbiY/X8eYNREYqJT9iYpRMJY1Gef3jotGAszPMm6fY4O4Ow4bB119DrVrmPR4qKY9Go6Ffv35s2bKFXbt24e/vT8aMGZPaNlmW3yuR9Md2748itv/ke/8UIQSLFy/m+PHj1KtXj4YNG6qRQyoqKiqfKX98hqTmoFYIwZYtW1i6dCmlSpWiW7duODo6IoRg3rx57Nu3j/bt21O/fn01+/ILQQjB/IXzuXv3Lt26daNUqVIWO/bTaDQUKlSIpk2bMnPmTA4fPszXX39tkVHhKiqfFdbWMGIEXLgAT5+Cvz8ULqxEh/3X9kKjUWpzLl+uRFtHRcGyZTB7drKantxotVomT55MtWrVCAsLo3Llyri6uiZliFtq+6mOLC0QFxcXbGxsuHXrFsuWLaNhw4a4urp+FhEDQgiioqL48ccfGTx4MLdv36ZQoUIsX76cihUrotVq30s9jIyM5NSpU4wbN46bN2+SM2dOxo8fT9WqVZEkicaNG7N69WrmzJnDhAkT2LBhA99++y2VKlXCy8tLdaCoJAtCCMLDw9m4cSO//vor8+fPp0qVKn96ff25oMXb17eiCxEVpTivIyKU16iod9eZTEqmZiKlSyvlBidPhlatknEnVSwOSZJIly4d3bt3Z/bs2Rw9epRWrVolXXdXr15l4MCB3Lt3DycnJ+zt7bG3t8fR0RG9Xo+jo+N76xwcHD74uVarRaPRvLdIkoRWq8XJyQmbt+rZCCG4evUq3333Hd7e3owbN87s6WMqKioqKslPYgBJIjqdDn9/f7JkyYJvKtQqE0Jw7do1hgwZgqenJ2PGjCFdunQIITh27BgTJ06kSJEi9OrVCycnJ4sdeKskHwLBtZhrHLU6il9eP/r372/xkxV6vZ4GDRrwv//9jzFjxlC1alW8LTwyU0Xls8DJSRGYfZuPfU5UrQoGA0ycqNT7HDUK8ub9uN9MYSRJwtXVlYBEUUo+jXrmqjfPAnF1daVDhw5s2bKFb775JslJ8dVXX70nSPgpER8fz+3bt1m3bh2LFy8mTZo0fPPNN3Tq1Ak/P7/3bhiDwcDNmzdZs2YNa9euxc3Njd69e9O7d2+8vLySvu/o6Ej37t2pW7cuy5YtY9euXXTv3p1ixYrRsWNHSpQoQcaMGdWZbJWPQpZljh07xoYNG2jSpAk1atT4y87xP30AaLWKFoSb219/7/Hjd9/37QstWsDGjf9oMyqfMNbW1gQEBLB161Y2b95M5cqVyZAhA5IkYWdnR/bs2dFoNBgMBgwGAzExMYSHh2MymZLWGY3GpCVxXeLniev1ej02NjZJddrt7Oywt7fH1tYWR0dHhgwZQsm3UoVDQkKYM2cOb968Yc6cOWTOnNmMR0lFRUVFJaVJ7NvodDrKly9P+fLlU2W7z58/Z+zYsYSFhTF9+nRKlCgBwK1btxgwYADu7u4MGTKEbNmypYo9KuYn0hTJguAF/FjpR5Y1XvZJlNqQJIkCBQrQsGFDJkyYwOzZsxk3bpwaYKWiktIkt2NWkpSang0bKssnxKfgpP4jagtpoUyaNInSpUtz7NgxDh48yMmTJ6levTr16tWjQoUKZlHt/K8kiqZs3bqVNWvW8ODBA+rVq0erVq0oV67cO5F7id9//vw527dvZ926ddy5c4e6devSrl07SpYsia2t7XvbkCSJDBkyMHToUOrUqcPu3bvZu3cvnTt3pmLFijRs2JDq1avj7e39Sd6oKubn5cuXTJo0CU9PT1q3bo1nogqxGZAk8PKCTp1gwADIkMFspqikApIk4efnR5MmTZg1axbHjx+nefPm6HQ6smfPztSpU4mPj09aEhISiIuLw2AwEBcXl7Tu7dfEz9/+n9jY2Pf+J3GdLMvIspxkk8FgYO/evRw4cIA6derQqFEjMx4hFRUVFZXU4I/lqFKDiIgIVqxYwbFjx2jdujUtWrQAlH7Z9OnTefDgAePGjaNq1aqpbpuKeZCFzImoExyMOEhFx4rUSFfD3Cb9Y7RaLc2bN2ffvn2sXLmS2rVrU7p0aXObpaKiomKxqE5rCyQxeq5Ro0ZUq1aNr7/+mi1btrBy5UoOHz5MhQoV6NSpE8WLF7f4NCghBGfOnGHatGmcPXsWHx8fZsyYkeRA/iMGg4HTp08zZ84cjh8/ToYMGZg/fz4VKlQgbdq0f+twtra2pkiRIuTKlYuGDRuyY8cOVqxYwfnz59m2bRutWrWiQYMGFn/cVCwLWZaZOnUq9+7dY9CgQRQrVszskx9arZLl5O8PV66Y1RSVVECv11OzZk127tzJtGnT3hGrTSzv8TEIITAaje9EX5tMJhISEjCZTJhMpqSJGiEEjx49Yvny5bi7u9OvXz/0en1y7KaKioqKigWSqBMza9Ysfv31V2rWrEmhQoVSPELUZDJx5swZli1bRqlSpejTpw/W1tbExsayadMmdu7cSbNmzWjfvr2aUfkF8dLwko0hG0kQCQzwHoC95uP6QKmNj48PAwYMoFmzZsyaNYs8efLg4uJibrNUVFRULBJJ/HnhVRULIbEO9K1bt5g6dSoHDhzA2dmZunXrMnz4cNKlS2dRooOJl1RoaCizZ89myZIlxMXF0aJFC3r16kXmzJnR6XTv1a6OiIhgypQprFixgvj4eNq0aUOfPn1Ily7df3IyCyGIi4vj4cOHLFy4kPXr1yOEoHTp0gwePJiSJUta1HFTsUyEEOzZs4e2bduSN29etm7dapYo69hYuHUL0qb9vb61LMOTJ4qmRMGCitC7ejl/vhgMBvr06cOSJUsoXbo0TZs2JX/+/Dg4OKDX63FyckKv17+XjfKhNu6frvvj+sR2ddKkScyePZsJEybQuXPn9zJmVFRUVFQ+Hx49esQ333zD/v37sba2xtHRkaxZsxIQEEC9evXw8fFJ0qVJrn51YuZlo0aNCAkJYdGiRZQvXx5Jkjh79ixt27bFy8uLVatWkSVLFrU//4VgFEZ2hO2g/eP2dPPoxvC0w3HQOiDxaZ3/hIQEWrZsycmTJ5k2bRotW7ZUr2EVFRWVD6A6rT8REk9TXFwcR44cYdq0aVy9ehWdTkfv3r1p3bo1adOmNbvqpxCC6OhoTp8+zejRo7lx4wbZsmVjzJgx1KpV6z2V8USH/NmzZxk4cCAPHjwgf/78jBgxgipVqmBlZfXR+yOEwGQycf78eSZNmsSPP/4IwOCWLenVsSM2mTN/nHqsymfN8+fPady4Mffu3WPnzp1mUyZ/u6V+e/OPHsG4cVCiBLRtC2oSweeLEIIjR47Qp08f7t27h0ajQavVIssyQoikV41Gg62tLXZ2djg7O6PX67G3t8fJyQlbW1tcXFzQ6/VJju63v6fX63F2dsbW1hY3NzdsbW3fEWTUaDTcunWLBg0aULVqVWbNmoWPj4860FJRUVH5jEl8xrx8+ZKTJ0+ydetWzp8/T0xMDEajkQIFCtC4cWNq1aqFm5sbjo6OH92Hj4mJoXv37uzYsYORI0fSs2dPrKysePHiBW3btuX27dssWrSI6tWrq1HWXwhCCF4YXtDwYUNMwsQi30UUtiv8SfZBhBDcv3+fsmXLUqhQIebPn0+mTJk+yX1RUVFRSUlUp/UnSnBwcFKN6Fu3bpExY0Y6depE5cqVyZYtm1k6byaTiVu3brF27VpWr16No6MjdevWZcCAAe+JYwgh3hFaXLVqFR4eHjRp0oRu3bqRLjGUNJkxGo3s3buXTatXU/vWLb6Oi0Nq2xbq1YOcOZWC+ioqvxEdHc2UKVOYM2cOvXr1YuzYsRbXmbxzB7p3h+fP4X//g4wZ1fmXz52TJ0+ydu1arKyscHR0JCYmhtjYWKKiooiLi3unpMcfRRj/zbqEhASsra2xtbVNEmS0t7fnxYsX2NraMnv27HfUp1VUVFRUvgxkWebhw4ccPnyYY8eOcffuXZ4+fYosy5QtWxZ/f38KFCiAr68vadOm/ddlRAwGA8uXL6dPnz4EBAQwY8YMvL29iY2NZcyYMcyfP58BAwbQr18/HBwcUmgvVSwNWchMCZzCpFeTGJpmKH29+mKj+XQzveLj45k6dSqzZ89m7NixdOzYUc1cU1FRUfkDqtP6EyaxruiOHTvYuXMn169fp0CBAgQEBFCjRo1Una19+fIlu3btYvXq1dy8eZMaNWrQoUMHypYt+8GH75s3b9i4cSNr167l0aNHVK1alTZt2lCpUqUUd7gLIYgJCkIcOIDDDz/A0aOQLRvUrw+1akHevGq4qgqyLHPs2DF69OhB2rRp2bBhg0UKeRqNMHcujBkDvXrB2LGq0/pLR5ZlDAbDO0KKieKLH1pnMBiIiYl5b110dDQxMTHviThevHgRk8nE999/j7+/v7l3V0VFRUXFjMTExHDnzh0uXrzIzz//zM2bN7l9+zaOjo4UKVKEQoUKkTdvXgoXLkz69On/UT8/PDycJk2aELE8DL0AABsLSURBVBwczLJlyyhQoABCCNasWUPv3r2pVKkSs2bNwtfXNxX2UMVSuBpzlZq/1CSbTTaWZlxKVtus5jbpoxBCcO/ePdq3b4/BYGDVqlXkzJnT4sYaKioqKuZEdVp/BhgMBn755RcOHjzIkiVLePbsGUWKFKFp06YEBATg7u6eots+c+YM8+bN48iRI6RNm5b+/ftTrVo10qVLh0ajeef7JpOJEydOMHv2bM6dO4efnx89evRIEmZM1Ye0yaSEp545A8uXw9mzkDs31K0L7dpB+vSq9+8L5tWrV/Tr149Tp06xZMkSqlatarHpp0+fQpMm8OyZEm2dK5e5LVL5HPiQOGOiWG67du1o2bIlEyZMUMWDVFRUVFQQQhAZGcnTp0958OAB58+f58iRI1y7dg0vLy8yZ85MgQIFqFSpEhUrVsTJyelPf8tgMHDlyhViY2MpW7YskiRx8uRJunTpQkJCAhs3bqRo0aKqc+8LIk6Oo83jNhyMOMi8DPP42vVrNJLm7//RwomPj2f58uWMGDGCrl27MnLkSKytrc1tloqKiorFoDqtPxOEEMTHxxMYGMiaNWv47rvvMBgMFClShAEDBlClSpX3xA8/dnsRERHMmjWL5cuXExYWRqtWrejfvz8+Pj7vPGwTL7HAwEDmzJnDunXreP36Ne3bt6dv375kzJjRvA9noxHevIEDB2DWLPj1V/D1hZ49lSLBiZHiasf4i8FoNLJu3Tp69OhBjx49GDZsGI6OjhY7OBICliyBfv2gRQtYsAA0n34/XsUCEUIQHh5Ox44duXz5MsuWLUsSxlJRUVFRUQEl4ycmJobw8HDu37+flBUaGBiIvb093t7eVK1alSZNmlCoUKEkTZ4/6t4IIZAkiRcvXtClSxcOHTrEunXraNCggcUGEqgkP0IINoZupPez3pSwL8HmTJux09iZ26xk4+nTp3Tp0oXz589z6tQp8uTJY26TVFRUVCwG1Wn9mZEolPL48WOmTZvGjh07CAsLw9/fn2HDhpErVy70ev17EdD/5vdjYmK4ePEi/fr1486dO+TJk4eRI0dStWrV94QgE79/7tw5Ro0axdWrV8mePTtTp06lYsWK7wkzmg0hlCUwUPH+rVyp/J07NwwdChUqgJOT4gm0BHtVUgwhBI8fP6ZChQr4+Pgwf/588uXLZxnX6V8QFwdly0JQEKxZA6VLq5eqSsogyzLHjx+ncePGtGrVijFjxuDk5GTx94iKioqKSuqSOMyUZZno6GjOnj3L5s2bOXLkCJGRkcTHx5M5c2Zq1apFQEAAmTJlwt7eHhsbm6SxSnR0NFOnTmXWrFl07dqViRMn/usa2SqWjRACGRmDMCAhYSVZISERK2KJkWOIlWNp97gdF2Mucjr7afLa5TW3ycmKEIKNGzfSt29fvvrqK7Zs2aLWtlZRUVH5DdVp/RmTkJDAuXPnWLRoEadPnyYyMpIWLVrQuHFjChQogLOz879yMsTHx3Pv3j3Wrl3LokWL8PDwoHHjxnTv3p0MGTJ88Pv3799n7dq1LFy4EE9PT5o2bUrPnj0tsjbwO9y5A/PmwaFD8Po1VK4M7dtD4cLg5fW+N9BkgtBQCA6GhASlJrabG7i7gxoJ8kkRHR1N586dOXjwIBMmTKBTp07/eZIntdm+Hdq0UaKtp00DVZtIJaUIDAxk8ODB/O9//2PLli2ULFnSstt0FRUVFRWLIDFj5+TJk+zbt48rV67w7NkzgoKCyJMnD3Xq1KFUqVL4+fnh7OzMoUOHGD58ODlz5mTFihWkSZNGfd58RshC5n78fS7FXOJRwiNsJVvy2uWluH1xdobtZEXwCqo6VWVG4Ay6e3ZnVNpRaKXPb2wVExNDu3bt2Lt3L0uXLqVp06bqda6ioqKC6rT+IoiKiuLQoUNs27aNEydOoNPpqF+/PrVr16Zs2bL/qDSHEIIbN27Qu3dvbt26RaVKlWjdujVVqlTB6g+ihUIIXr58yc6dO1m+fDn37t2jZs2atGvXjrJly2Jn9wmkcwmhOKLPnYOtW2HfPoiKgmrVoGFDJaTVzU35blyc4i08cgTu34foaLC1hezZoUoV8PdXnNcqFo8QglWrVtGrVy/q1KnD3LlzU7QmfHITHa3Utn7wQCkRUrGiGm2tkjLIssyuXbvo3bs3FStWZPHixWpUkIqKiorKv8JkMvHkyRMuXrzI+fPnuXLlCjdu3MBgMJA/f34yZMjAmTNn0Gg0LFiwIFUE21VSl/PR5xn9YjTWGmty2ebCKIzcjrvNAO8BPE14ysI3C/F38udi7EXm+szFz9rvs3Xm/vTTT9SvX59MmTKxZs0aMmXKZG6TVFRUVMyO6rT+QhBCEBQUxLlz59i6dSt79uzBy8uLatWq0bJlS4oUKfKXnUAhBPfv32fx4sXkzp2bmjVrfjBa2mg0cvLkSRYsWMCxY8fw9fWld+/eVKlShXTp0n16nQwhICICLl2Cbdtg/Xqwt1dCWfv3V5zREycqJUWyZIH69cHbG0JCYO9euHIFundXFlWszOK5cuUK7dq1IyQkhN27d5M/f35zm/SvkGU4eFCJtm7eHEaNAldXc1ul8rkSHBxM79692bdvHzt37qRcuXLmNklFRUVF5RMkUZvnyZMn/PLLL/z888/s3LmTn3/+GTs7O/r168fAgQNxdHQ0t6kqyUiUKYpOTzoRagplYYaFZLDOgFEYuRl3Ew+dB8cij7EmZA2LMy7GJEz42fhhJVn9/Q9/osiyzNixY5kxYwaDBw/m22+/VUUZVVRUvnhUp/UXhslkIiwsjPPnzzN58mR++uknMmbMSEBAAD179iRdunQAH3QuG41GoqOjsbOzw8rK6r3a1ZGRkUyZMoWVK1cSGxtL69at6dq1K1myZHkvGvuTQwgID1dCWBcvBmdnGD8eTpxQPIQFC8LChZA2rVIaxGiEp09hwgQlSnvtWiXs9RMpM/ElEhUVxaBBg1i6dClz5sz5pMqCJCKEoinavz8cParMsxQvrkZbq6QMQgj27NlD586dyZ8/P/v27VMj4FRUVFRUPgohBLGxsQQHB/Py5UsMBgO5c+fGVZ2F/+y4GnOVVo9aMSrtKBq6NHxnbCkLmbUha1kTsoYfMv+Ao/bLmLB49eoV1atXx8rKigULFlCkSJFPL+hLRUVFJRn5tDwyKh+NVqvF3d2dGjVqcOjQIVauXIler2fu3LmUL1+eefPmERYWhtFofO9/dTodzs7O74gtJgotHjp0iPLlyzN79my8vb1ZuXIlU6ZMIUeOHJ++wxoUr5+LCxQpotS6njBBcU6vXg2RkTB2LGTMCNbWynetrCBTJmjbVonM3r0bYmLMvRcqf4Isy+zfv5+dO3dSq1YtWrZs+ck5rEG59Dw9oWlT5f2aNYLYWBl1blIlJZAkiRo1alC2bFnOnz/Pjh071GtNRUVFReWjkCQJvV6Pj48PxYoVo1SpUqrD+jPljfEN0XI0ue1ym9sUi8HT05Phw4fz//buPDjKAk/j+PP2nYMkTSSJMAmFoJAgxYwHKIKWoA6HICqoAXTLozgUdNfi8IjrDisDq5FDl6OUClTIMkMRuUQBDeiIBbVYOEOhDEKIqIGETAiBhHSnO+l3/+jR2i0dy9UO75vu76eqi1D886TqJZV+8svv53A4dPHiRavjAIDlOl8rg5hwOBzy+Xy6//77tWvXLr3wwgvy+/2aN2+eRo8erQ0bNujrr7/+wfJaipbV4XBYhw8fVlFRkaZMmaLz58/riSee0I4dOzRu3Dh5vd74+8nwt4W0xxM9vHj8eLQlvPba74+zGka0yC4oiK4XCQSsyYwfZZqmvvzyS5WUlMjr9erZZ59VcnKy1bF+NsOQBg2SfvvbC6qo+EhHjhy1OhLimMvl0tNPPy23261Vq1apoaHB6kgAgDhgGMZ3L8Qnh+GQw3Cozfzh95uJyOl0aty4cdq5c6duueUWnn8ACY/SOsEZhqHs7GzNmTNHa9eu1ezZs9XW1qaZM2dq1qxZWr9+vWpra783PVdXV6eSkhJNnz5dZWVlGj58uFasWKGFCxcqOzvbos/mEjt7NnqEsWfPf7x/ITU1erCxtja6MgS2EwqFtGHDBh04cEBTp05VQUFBp/8GMStLKiz8UqHQ4/r974sUCoWsjoQ4NmjQIN1zzz06ceKI/vKXD2SaEasjAQAAm8tx5yjVkapDgUNWR7EVj8fDbxcAwN+5rA4Ae3A4HOrfv7+Kioo0duxY7dixQ+vXr9fcuXNVXl6uCRMmaNSoUUpOTtbu3btVWlqqPXv2qGfPnlqwYIHGjBmjnJycTrlS4Wczzejrxz5nw4i+IpQ4dmSapg4ePKjly5dr8ODBmjBhQqeesv7fbrjhCg0ePEA7d+5URUWFxowZY3UkxCnDMDR37j+rX7//Vnr6JoVC18vr7Wl1LAAAYGO9PL10bfK1erP+Td2YcqN6e3tLks6EzyjNmWZxOgCAHXCIEd/z7Z7q48ePq6SkRGvXrpXH41Fubq6Sk5NVVVWlxsZGzZgxQzNmzFBeXp68Xq/VsS+9mhpp7FipuVn6619/eNq6ulp68knp1KnoXuusrEufE/9QMBjUyJEjVVlZqWXLlmn8+PFxdUju448/1p133qnrrrtOW7ZsUWpqqtWREIdM05Rptur06UWqr39NeXn/Kb//fhlG/PxfAgAAsVcZrNQT1U/oVOiUfpP0G0UU0dHWo1rYfaFqwjUqayhLqEOMAID/K4HGYvFTGYahlJQUDRw4UMXFxdq3b59ycnJ07NgxHTx4UIZhaM2aNVq4cKH69OmTmIW1JGVnS7m50jffSCdOfP/fTVM6fVqqrJR+/WvJ57vkEfGPtbe3a/Hixfrkk080evRojR07Nq4Ka0kaMmSIxo0bp0OHDmnz5s0cyUOHiO4c9Soz81653TlqaPijwuEanjcAAPCjent7a8sVW7T4V4t1Xcp1ujn1Zq3KXaWbU2/WTak3aU72HPkM3kMBQKJi0ho/SUtLi8rLy1VdXa2JEyeqT58+nX7vb0z84Q/SzJnSxInSggXR/dWGES2sz52Tli2TVqyQVq+W7rxTirNStLMyTVP79+9XYWGhunTponfffVd5eXlWx+oQR48e1dChQ3XDDTfojTfeUPfu3a2OhDjV3n5RZ84U68yZV9Wz52r5/fcybQ0AAAAA+FnYaY2fJDk5WQ899JDVMexn3DjpT3+S3norutv6ttukjAypqUnau1fauFF64AFp8GAKaxs5c+aMli9frgsXLujVV1+N28Jaknr37q2HH35Y69atU0VFhSZNmiSXiy/9iD2nM0Xp6aPU2LhFdXXLlJY2XC7XZVbHAgAAAAB0QjQXwC+RkiL97ndS797Stm3S++9Hy+tIRLrsMmnGjGhpnZ1tdVL8XSgU0rZt2/Tee+/pgQceiPsDhS6XS1OmTNHbb7+tzZs369Zbb1Vubq7VsRCnkpIGKD19lOrqXte5c5vUrdtUqyMBAAAAADoh1oMAv5RpSsFg9DDj+fNSa6vk8Ujp6VJOTrTYhm1UVVVp2rRpamhoUGlpqQoKCuJ+1c3FixdVXFysxYsXa/Xq1br77ruZtkaHCQQ+04kT90gy1Lfvx3K7u1kdCQAAAADQyVBaA7HU2CgdOiQlJUnXXx/dbw1baWtr0759++R0OjVo0CC53W6rI3U40zR14MABTZ8+XX6/Xxs3blTXrl3jvqyHNUwzotOnX1Rd3RLl5DynnJxnZBjcfQYAAAAA/HS8iwRiqbJSevxxacmS6AQ2bMflcmnYsGEaMmRIQhTWkmQYhgYOHKhRo0Zp//792r59u9WREMcMw6GsrJlyubLU0FCm1tZjVkcCAAAAAHQylNZALHk80YOLLS1WJ8GPMAwj4aaMfT6fxowZo7y8PM2fP1+RSMTqSIhjLleWsrP/RaHQKTU0/FGRSNDqSAAAAACAToTSGoilb0vrQMDqJMD31NfXKxAI6OzZs1ZHQQLw+++Xz9dX58+/q2DwiNVxAAAAAACdCKU1EEtMWsOmGhoatG3bNtXW1mru3LlyOPjyj45jGIZcrq7Kzp4jr7eXDMNndSQAAAAAQCfisjoAEFeYtIYNtbe368MPP9T27ds1adIkzZgxw+pISAhO+f3jlZ4+WobhVltbo0Khb2QYTnk8uXI4kmUYTqtDAgAAAABsiNIaiCWPR3I4mLSGbZimqZMnT+q1115T165dNWvWLGVkZCTcTm9cetFnzC3DiKihoUx1da/LNMOSpKSk/rr88n9TUlK+tSEBAAAAALZEaQ3EkscjuVxMWsM22tratG7dOh06dEjPP/+88vPzKaxxSQWDR3X2bKkyM/9JmZkPSYooHP6bPJ4eVkcDAAAAANgUpTUQS0xaw2Y++ugjrVq1SkOHDtWECROUnJxsdSQkmPb2RrW3N8nnu0pOZ4YMwyGX6zKrYwEAAAAAbIxLXEAssdMaNtLQ0KCioiI5HA5Nnz5deXl5VkdCAvJ4esnjyVV19bOqqfl3BQKfSzKtjgUAAAAAsDFKayCWnE7J7ZbCYamtzeo0SGCRSERLly7V4cOHVVhYqDvuuEMOB1/ycel5PL9Sbu5Sde1aqMbGTTp+fKSqq+eora3B6mgAAAAAAJuiwQBiyTAkrzf6MdPWsEgkEtHu3btVVlamK664QkVFRXK73VbHQoIyDIc8np7KyZmn/PxP1KPHSzp//l1duFBhdTQAAAAAgE1RWgOx5vNFy2tKa1ikpqZGq1evVlNTkxYuXKiMjAyrIyGBmWZ0FYhhGDIMj1JTb5Xb3UPt7Y3WBgMAAAAA2BaHGIFYo7SGhYLBoLZv3649e/bowQcf1PDhw62OhAQXDB5Vc/NeeTw95HB0UXPzPrW3X5DH09PqaAAAAAAAm6K0BmKN0hoWMU1TVVVVWrFihfr27atHHnlEPp9PhmFYHQ0JzDDcCodPqanpA0UiLXI4UpWd/ZRSU2+0OhoAAAAAwKYorYFY8/mif7a0WJsDCae1tVVLlizRqVOn9PLLL6tfv34U1rBMJBJSa+sX8vn6KTt7jkyzVaYZkWG45XSmyDDYsw4AAAAA+GHstAZijUlrWMA0Te3atUulpaUaNWqU7rrrLjmdTqtjIUGZZkT19at07NgdOnfuLTmdqXK5MuV2d5PLlUFhDQAAAAD4UUxaAzF2Pj1dFzMz1aW1VV2sDoOEcfLkSRUVFalXr16aOnWqMjMzrY6EBBYIHFJt7cvyePKUlDTA6jgAAAAAgE6GSWsgxipSUzU3JUV/DgatjoIE0dzcrFdeeUVVVVV69NFHdeON7AqGdcLhv6mmZoHa25uUlfWkkpIKrI4EAAAAAOhkKK2BGPs6EtHbp07pdHOz1VGQAEzT1DvvvKOtW7dq2LBheuyxx+Ry8Us0sIZptuvcuQ1qatotv3+i/P67JbFXHQAAAADw/0NpDcSY1+uVJLVwiBEdzDRNVVZWqqSkRIFAQIsWLVJGRobVsZCgTNNUS8ufdfbsOjmdfnXv/q9yOJKtjgUAAAAA6IQorYEYS0pKkmEYCnCIER0sEAho48aN2rdvn5577jkVFBTIMJhqhRVMRSLn1dDwXwoGj6h795fkdvewOhQAAAAAoJOitAZizOv1Ulqjw0UiEX366adas2aNbrrpJt13333yeDxWx0KCMs2Impr26ty5jfL771Va2u0yDKfVsQAAAAAAnRSlNRBjPp+P0hodyjRNXbhwQUuXLlUoFNLUqVPVvXt3q2MhQZmmqXC4RrW1/yGnM12ZmQ/L5cq0OhYAAAAAoBOjtAZijPUguBRKS0tVUVGh8ePHa8SIERxfhKXq6l5XMHhEXbtOUkrK9TIMvr0AAAAAAPx8vKsEYszn80niECM6hmma+uKLL7Ro0SLl5uZq2rRpSktLszoWElR06n+P6uvfVFLSAGVmPsLxRQAAAADAL0ZpDcTYt+tBKK3REZqbm/XMM8/o4sWLmjNnjvLz8zm+CMvU1dWpqKhE33yTrcsvL5LbnWN1JAAAAABAHKC0BmKMndboKOFwWGVlZdq7d69GjhypwsJCCmtYJhAIaOXKlSot3a4DB+5RWtptPI8AAAAAgJigtAZijNIaHcE0TX322WcqLS1Vt27d9OKLL8rtdlsdCwkqEolo//792rBhg/r376/HH58picIaAAAAABAbXO4CYozSGh3BNE199dVXamxs1Lx583TVVVdZHQkJ7MyZM1qzZo0aGxtVXFys7OxsqyMBAAAAAOIIpTUQY5TW6AiGYWjEiBEqLy9XXl6enE6n1ZGQoMLhsN5//31t3bpV06ZN09ChQ1kLAgAAAACIKUprIMZ8Pp8kcYgRMWUYhrp06aKCgoLv/g5caqZpqrq6Wi+99JKuvvpqTZ48WWlpaTyPAAAAAICYYqc1EGNMWqMjGYZBQQjLBINBzZ8/X/X19Zo8ebIGDBjA8wgAAAAAiDlKayDGPB6PHA6HWltbFYlErI4DADFhmqa2bNmi8vJy3X777Zo4cSJragAAAAAAHYLSGogxp9Mpn8+n9vZ2hcNhq+MAQEx8/vnnKi4ult/v1+zZs5WVlWV1JAAAAABAnGKnNdABVq5cKY/HwxQigLjQ0tKilStXfldcX3PNNVZHAgAAAADEMcM0TdPqEEC8+XYtCPuHAcSDDz74QE899ZR69OihTZs2KSkpyepIAAAAAIA4RmkNAAB+VCgU0o4dO5Sfn68rr7ySH8YBAAAAADoUpTUAAAAAAAAAwDY4xAgAAAAAAAAAsA1KawAAAAAAAACAbVBaAwAAAAAAAABsg9IaAAAAAAAAAGAblNYAAAAAAAAAANugtAYAAAAAAAAA2AalNQAAAAAAAADANiitAQAAAAAAAAC2QWkNAAAAAAAAALANSmsAAAAAAAAAgG1QWgMAAAAAAAAAbIPSGgAAAAAAAABgG5TWAAAAAAAAAADboLQGAAAAAAAAANgGpTUAAAAAAAAAwDYorQEAAAAAAAAAtkFpDQAAAAAAAACwDUprAAAAAAAAAIBtUFoDAAAAAAAAAGyD0hoAAAAAAAAAYBuU1gAAAAAAAAAA26C0BgAAAAAAAADYBqU1AAAAAAAAAMA2KK0BAAAAAAAAALZBaQ0AAAAAAAAAsA1KawAAAAAAAACAbVBaAwAAAAAAAABsg9IaAAAAAAAAAGAblNYAAAAAAAAAANugtAYAAAAAAAAA2AalNQAAAAAAAADANiitAQAAAAAAAAC2QWkNAAAAAAAAALCN/wEeDgR6ZEG/YQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "top_10_error_smiles = test_df_fiora.nlargest(10, 'residuals')['smiles']\n", + "\n", + "molecule_images = []\n", + "\n", + "# Create a molecule image for each smiles\n", + "for smiles in top_10_error_smiles:\n", + " mol = Chem.MolFromSmiles(smiles)\n", + " img = Draw.MolToImage(mol)\n", + " molecule_images.append(img)\n", + "\n", + "# Plot the images in a grid\n", + "fig, axes = plt.subplots(2, 5, figsize=(15, 6))\n", + "axes = axes.ravel() # Flatten the 2x5 grid of axes\n", + "\n", + "# Plot each molecule image in the grid\n", + "for i, img in enumerate(molecule_images):\n", + " axes[i].imshow(img)\n", + " axes[i].axis('off') # Turn off axes\n", + "\n", + "plt.suptitle('Top 10 Molecules with Highest Residuals (Fiora)', fontsize=17)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bottom_10_error_smiles = test_df_fiora.nsmallest(10, 'residuals')['smiles']\n", + "\n", + "molecule_images = []\n", + "\n", + "# Create a molecule image for each smiles\n", + "for smiles in bottom_10_error_smiles:\n", + " mol = Chem.MolFromSmiles(smiles)\n", + " img = Draw.MolToImage(mol)\n", + " molecule_images.append(img)\n", + "\n", + "# Plot the images in a grid\n", + "fig, axes = plt.subplots(2, 5, figsize=(15, 6))\n", + "axes = axes.ravel() # Flatten the 2x5 grid of axes\n", + "\n", + "# Plot each molecule image in the grid\n", + "for i, img in enumerate(molecule_images):\n", + " axes[i].imshow(img)\n", + " axes[i].axis('off') # Turn off axes\n", + "\n", + "plt.suptitle('Bottom 10 Molecules with Highest Residuals (Fiora)', fontsize=17)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rare element count mean for all 4389 rows: 0.3616\n", + "Rare element count mean for top 30 errors: 0.3667\n" + ] + } + ], + "source": [ + "rare_element_ratio_all = test_df_fiora['rare_element_count'].mean()\n", + "print(f\"Rare element count mean for all {len(test_df_fiora)} rows: {rare_element_ratio_all:.4f}\")\n", + "\n", + "top_30_errors = test_df_fiora.nlargest(30, 'residuals')['rare_element_count']\n", + "\n", + "# Calculate the ratio of rare elements included in the top 100 errors\n", + "rare_element_ratio_top_30 = top_30_errors.mean()\n", + "print(f\"Rare element count mean for top 30 errors: {rare_element_ratio_top_30:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import Counter\n", + "\n", + "element_counts = Counter()\n", + "\n", + "for _, row in ccs_df.iterrows():\n", + " elem_distr = row[\"Metabolite\"].calc_abs_elem_distr()\n", + " element_counts.update(elem_distr)\n", + "\n", + "element_df = pd.DataFrame.from_dict(element_counts, orient='index', columns=['Count'])\n", + "element_df = element_df.sort_values(by='Count', ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R² Score for Positive Precursor Adduct: 0.4089\n", + "R² Score for Negative Precursor Adduct: 0.6181\n" + ] + } + ], + "source": [ + "# Check if pos and neg have similar R2 scores for Fiora\n", + "\n", + "positive_df = test_df_fiora[test_df_fiora[\"precursor_positive\"] == True]\n", + "negative_df = test_df_fiora[test_df_fiora[\"precursor_positive\"] == False]\n", + "\n", + "# Compute R² Score for each group\n", + "r2_positive = r2_score(positive_df[\"targets\"], positive_df[\"predictions\"])\n", + "r2_negative = r2_score(negative_df[\"targets\"], negative_df[\"predictions\"])\n", + "\n", + "# Print results\n", + "print(f\"R² Score for Positive Precursor Adduct: {r2_positive:.4f}\")\n", + "print(f\"R² Score for Negative Precursor Adduct: {r2_negative:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Charges were rearranged\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Charges were rearranged\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Charges were rearranged\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:01] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:02] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged; Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Charges were rearranged\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] WARNING: Omitted undefined stereo\n", + "\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n", + "[19:35:03] DEPRECATION WARNING: please use MorganGenerator\n" + ] + } + ], + "source": [ + "# Weight vs. CCS (target) of test set\n", + "# extract weight from SMILES\n", + "\n", + "test_df_fiora[\"Metabolite\"] = test_df_fiora[\"smiles\"].apply(Metabolite)\n", + "test_df_fiora[\"Weight\"] = test_df_fiora[\"Metabolite\"].apply(lambda x: x.ExactMolWeight)\n", + "\n", + "test_df_fiora[\"MSE\"] = (test_df_fiora[\"targets\"] - test_df_fiora[\"predictions\"]) ** 2\n", + "test_df_linear[\"MSE\"] = (test_df_linear[\"targets\"] - test_df_linear[\"predictions\"]) ** 2\n", + "test_df_mlp[\"MSE\"] = (test_df_mlp[\"targets\"] - test_df_mlp[\"predictions\"]) ** 2\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Test Set: CCS vs. Weight\n", + "\n", + "top_100_mse_fiora = test_df_fiora.nlargest(100, 'MSE')\n", + "top_100_mse_linear = test_df_linear.nlargest(100, 'MSE')\n", + "top_100_mse_mlp = test_df_mlp.nlargest(100, 'MSE')\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_fiora,\n", + " x=\"Weight\",\n", + " y=\"targets\",\n", + " alpha=0.5,\n", + " color=\"blue\",\n", + " label=\"Other Points\"\n", + ")\n", + "sns.scatterplot(\n", + " data=top_100_mse_fiora,\n", + " x=\"Weight\",\n", + " y=\"targets\",\n", + " alpha=0.8,\n", + " color=\"red\",\n", + " label=\"Top 100 MSE (Fiora Preds)\"\n", + ")\n", + "plt.xlabel(\"Weight\")\n", + "plt.ylabel(\"CCS\")\n", + "plt.title(\"Scatter Plot of CCS vs. Molecular Weight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Fiora\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_fiora,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.4,\n", + " color=\"blue\",\n", + " label=\"Other Points\"\n", + ")\n", + "# Plot the top 100 MSE points in red\n", + "sns.scatterplot(\n", + " data=top_100_mse_fiora,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.8,\n", + " color=\"red\",\n", + " label=\"Top 100 MSE (Fiora Preds)\"\n", + ")\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot with Top 100 MSE Points in Red (Fiora)\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Linear\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_linear,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.4,\n", + " color=\"blue\",\n", + " label=\"Other Points\"\n", + ")\n", + "sns.scatterplot(\n", + " data=top_100_mse_linear,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.8,\n", + " color=\"red\",\n", + " label=\"Top 100 MSE (Linear Preds)\"\n", + ")\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot with Top 100 MSE Points in Red (Linear)\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# MLP\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_mlp,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.4,\n", + " color=\"blue\",\n", + " label=\"Other Points\"\n", + ")\n", + "sns.scatterplot(\n", + " data=top_100_mse_mlp,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " alpha=0.8,\n", + " color=\"red\",\n", + " label=\"Top 100 MSE (MLP Preds)\"\n", + ")\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot with Top 100 MSE Points in Red (MLP)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Fiora Ground Truth vs. Prediction\n", + "\n", + "plt.scatter(test_stats_fiora[\"targets\"], test_stats_fiora[\"predictions\"], alpha=0.4)\n", + "plt.plot([global_min, global_max], [global_min, global_max], 'r--')\n", + "plt.xlim(global_min, global_max)\n", + "plt.ylim(global_min, global_max)\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Ground Truth vs. Prediction for Fiora Predictions\")\n", + "plt.show()\n", + "\n", + "# LoRA + Fiora Ground Truth vs. Prediction\n", + "\n", + "plt.scatter(test_stats_lora_fiora[\"targets\"], test_stats_lora_fiora[\"predictions\"], alpha=0.4)\n", + "plt.plot([global_min, global_max], [global_min, global_max], 'r--')\n", + "plt.xlim(global_min, global_max)\n", + "plt.ylim(global_min, global_max)\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Ground Truth vs. Prediction for LoRA + Fiora Predictions\")\n", + "plt.show()\n", + "\n", + "# Linear Model Ground Truth vs. Prediction\n", + "\n", + "plt.scatter(test_stats_linear[\"targets\"], test_stats_linear[\"predictions\"], alpha=0.4)\n", + "plt.plot([global_min, global_max], [global_min, global_max], 'r--')\n", + "plt.xlim(global_min, global_max)\n", + "plt.ylim(global_min, global_max)\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Ground Truth vs. Prediction for Linear Model Predictions\")\n", + "plt.show()\n", + "\n", + "# MLP Ground Truth vs. Prediction\n", + "\n", + "plt.scatter(test_stats_mlp[\"targets\"], test_stats_mlp[\"predictions\"], alpha=0.4)\n", + "plt.plot([global_min, global_max], [global_min, global_max], 'r--')\n", + "plt.xlim(global_min, global_max)\n", + "plt.ylim(global_min, global_max)\n", + "plt.xlabel(\"Ground Truth\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Ground Truth vs. Prediction for MLP Model Predictions\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Fiora\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_fiora,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " hue=\"precursor_positive\",\n", + " alpha=0.6,\n", + ")\n", + "plt.plot([global_min, global_max], [global_min, global_max], color=\"red\", linestyle=\"--\", linewidth=2)\n", + "plt.xlabel(\"Targets\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot of Targets vs. Predictions (Fiora)\")\n", + "plt.legend(title=\"Precursor Positive\")\n", + "plt.show()\n", + "\n", + "# LoRA + Fiora\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_lora_fiora,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " hue=\"precursor_positive\",\n", + " alpha=0.6,\n", + ")\n", + "plt.plot([global_min, global_max], [global_min, global_max], color=\"red\", linestyle=\"--\", linewidth=2)\n", + "plt.xlabel(\"Targets\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot of Targets vs. Predictions (LoRA + Fiora)\")\n", + "plt.legend(title=\"Precursor Positive\")\n", + "plt.show()\n", + "\n", + "# Linear\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_linear,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " hue=\"precursor_positive\",\n", + " alpha=0.6,\n", + ")\n", + "plt.plot([global_min, global_max], [global_min, global_max], color=\"red\", linestyle=\"--\", linewidth=2)\n", + "plt.xlabel(\"Targets\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot of Targets vs. Predictions (Linear)\")\n", + "plt.legend(title=\"Precursor Positive\")\n", + "plt.show()\n", + "\n", + "# MLP\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(\n", + " data=test_df_mlp,\n", + " x=\"targets\",\n", + " y=\"predictions\",\n", + " hue=\"precursor_positive\",\n", + " alpha=0.6,\n", + ")\n", + "plt.plot([global_min, global_max], [global_min, global_max], color=\"red\", linestyle=\"--\", linewidth=2)\n", + "plt.xlabel(\"Targets\")\n", + "plt.ylabel(\"Predictions\")\n", + "plt.title(\"Scatter Plot of Targets vs. Predictions (MLP)\")\n", + "plt.legend(title=\"Precursor Positive\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 230)\n" + ] + } + ], + "source": [ + "# Find 2 Molecules with Similar Weights but Different CCS Values\n", + "\n", + "threshold_weight = 1\n", + "\n", + "def find_rows(df):\n", + " for i in range(len(df)):\n", + " for j in range(i + 1, len(df)):\n", + " if abs(df['Weight'][i] - df['Weight'][j]) < 1 and abs(df['targets'][i] - df['targets'][j]) > 20:\n", + " return (i,j)\n", + " return None\n", + "\n", + "# Find the rows\n", + "result_rows = find_rows(test_df_fiora)\n", + "\n", + "# Print the result\n", + "if result_rows is not None:\n", + " print(result_rows) # 1,230\n", + "else:\n", + " print(\"No such rows found.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "first_molecule = test_df_fiora.iloc[result_rows[0]].copy()\n", + "second_molecule = test_df_fiora.iloc[result_rows[1]].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw Example Molecules that have similar weight but different CCS\n", + "\n", + "first_smiles = first_molecule[\"smiles\"]\n", + "second_smiles = second_molecule[\"smiles\"]\n", + "\n", + "first_weight = first_molecule[\"Weight\"]\n", + "second_weight = second_molecule[\"Weight\"]\n", + "\n", + "first_ccs = first_molecule[\"targets\"]\n", + "second_ccs = second_molecule[\"targets\"] \n", + "\n", + "first_pred = first_molecule[\"predictions\"]\n", + "second_pred = second_molecule[\"predictions\"]\n", + "first_mse = (first_ccs - first_pred) ** 2\n", + "second_mse = (second_ccs - second_pred) ** 2\n", + "\n", + "mol_images = []\n", + "\n", + "mol1 = Chem.MolFromSmiles(first_smiles)\n", + "img1 = Draw.MolToImage(mol1)\n", + "mol_images.append(img1)\n", + "\n", + "mol2 = Chem.MolFromSmiles(second_smiles)\n", + "img2 = Draw.MolToImage(mol2)\n", + "mol_images.append(img2)\n", + "\n", + "\n", + "# Create side-by-side plots\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 6)) # 1 row, 2 columns\n", + "\n", + "for i, ax in enumerate(axes): # No need to use flatten()\n", + " ax.imshow(mol_images[i])\n", + " ax.axis('off')\n", + "\n", + " # Annotate with CCS, Weight, and MSE\n", + " if i == 0:\n", + " text = f\"CCS: {first_ccs:.4f} | CCS Pred: {first_pred:.4f} | Weight: {first_weight:.4f} | MSE: {first_mse:.4f}\" \n", + " # text = f\"CCS: {first_ccs:.4f} | Weight: {first_weight:.4f}\" \n", + " else:\n", + " text = f\"CCS: {second_ccs:.4f} | CCS Pred: {second_pred:.4f} | Weight: {second_weight:.4f} | MSE: {second_mse:.4f}\"\n", + " # text = f\"CCS: {second_ccs:.4f} | Weight: {second_weight:.4f}\" \n", + "\n", + " # Add the text below each image\n", + " ax.text(0.5, -0.05, text, ha='center', va='top', transform=ax.transAxes, fontsize=15)\n", + "\n", + "plt.tight_layout(pad=0.9, w_pad=2.0)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "precursor_positive\n", + "True 2575\n", + "False 1814\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_df_fiora[\"precursor_positive\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mae': tensor(9.9885, device='cuda:0'),\n", + " 'mse': tensor(208.3741, device='cuda:0'),\n", + " 'pearson': tensor(0.7389, device='cuda:0'),\n", + " 'r2': tensor(0.4877, device='cuda:0'),\n", + " 'predictions': array([[216.16374],\n", + " [212.87979],\n", + " [185.73608],\n", + " ...,\n", + " [199.29155],\n", + " [176.3978 ],\n", + " [201.50449]], dtype=float32),\n", + " 'targets': array([[215.24],\n", + " [210.65],\n", + " [169.89],\n", + " ...,\n", + " [192.13],\n", + " [170.42],\n", + " [198.31]], dtype=float32),\n", + " 'smiles': ['Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc1cccs1',\n", + " 'COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1',\n", + " 'Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1',\n", + " 'O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc2c(c1)OCO2',\n", + " 'O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2',\n", + " 'N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2',\n", + " 'CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1',\n", + " 'COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)C',\n", + " 'O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1',\n", + " 'Clc1ccnc(c1)C(=O)Nc1nccs1',\n", + " 'COc1cc2c(cc1OC)CCN(C2c1ccccc1)C(=O)COC(=O)C1CC1',\n", + " 'O=S(=O)(c1cccs1)N1CCN(CC1)Cc1csc(n1)c1ccccc1',\n", + " 'O=C1Nc2ccccc2N(C1)C(=O)C(Sc1nnc(n1Cc1ccco1)c1ccccc1)C',\n", + " 'Cc1ccc(cc1)S(=O)(=O)N1CCCCC1C(=O)Nc1cccc(c1)C(=O)C',\n", + " 'O=C(C(c1ccccc1)Sc1nnc(o1)c1ccc2c(c1)OCO2)N1CCOCC1',\n", + " 'OC(CN1CCN(CC1)S(=O)(=O)c1c(C)c(C)cc(c1C)C)COc1ccccc1',\n", + " 'O=C(c1cccnc1Sc1ccccc1)N(C1CC1)Cc1nnc(o1)c1ccccc1Cl',\n", + " 'COc1c(OC)cc(cc1OC)C(=O)NC(C(=O)Nc1cccc(c1)C(=O)C)C(C)C',\n", + " 'O=C(Cc1ccc(cc1)c1ccccc1)OCC(=O)NC1CC1',\n", + " 'Fc1ccc(cc1)C(N(C(=O)Nc1noc(c1)C)C)C',\n", + " '[O-][N+](=O)c1ccccc1S(=O)(=O)N(Cc1cccs1)C',\n", + " 'COc1cc(CNC(=O)c2ccc(cc2)F)ccc1OC',\n", + " 'O=C(C(NS(=O)(=O)c1ccc2c(c1)cccc2)Cc1ccccc1)N1CCN(CC1)Cc1ccccc1',\n", + " 'CC(=O)NC(C(=O)Nc1ccc(cc1C)Cl)C(C)C',\n", + " 'O=C(c1ccc(cc1)S(=O)(=O)N1CCOCC1)Nc1c(oc2c1cccc2)C(=O)N1CCOCC1',\n", + " 'O=C(N1CCOCC1)CN1CCN(CC1)C(=O)c1ccc(cc1)n1cnc2c1cccc2',\n", + " 'CN1CCC(CC1)N(C(=O)c1sc2c(c1)c(nn2Cc1ccccc1Cl)C)Cc1ccco1',\n", + " 'Clc1ccc(cc1)c1nnc(o1)SCC(=O)N1CCCC1c1ccc2c(c1)OCCCO2',\n", + " 'Cc1cc(C)n2c(n1)nc(n2)Sc1nc(CN2CCOCC2)nc2c1c(cs2)c1ccccc1',\n", + " 'CC(C(=O)NCc1ccc2c(c1)OCO2)Sc1nnc(n1Cc1ccco1)c1cccnc1',\n", + " 'CCOc1ccc(cc1)n1c2nnc(n2c2c(c1=O)ccc(c2)Cl)COC(=O)c1cocc1',\n", + " 'COc1ccc(cc1)C1=NN(C(C1)c1ccco1)C(=O)CSc1nnnn1C1CCCC1',\n", + " 'CCS(=O)(=O)N1CCC(CC1)NC(=O)CCC(=O)c1ccc(cc1)c1ccccc1',\n", + " 'COc1ccc2c(c1)c(CC(=O)OCC(=O)N1CCCCC1)c(n2C(=O)c1ccc(cc1)Cl)C',\n", + " 'O=C(NCc1ccc(cc1)C(=O)N1CCCCC1)COc1ccc(cc1)C(=O)c1ccccc1',\n", + " 'COc1ccc(cc1)S(=O)(=O)N1CCN(CC1)C(C(=O)N1CC(C)CC(C1)C)C',\n", + " 'O=C1c2ccccc2NC(N1Cc1ccc2c(c1)OCO2)c1c(C)nn(c1C)C1CCS(=O)(=O)C1',\n", + " 'O=C(CN1C(=O)NC(C1=O)(Cc1ccccc1)Cc1ccccc1)NCc1ccc(cc1)Cl',\n", + " 'Clc1ccc(cc1)c1nnc(n1Cc1ccco1)SC(C(=O)NCc1ccco1)C',\n", + " 'COc1ccc(cc1)c1noc(n1)CSc1nc(=O)c2c([nH]1)n(nc2)c1ccc(cc1)C',\n", + " 'CC(Oc1ccc(cc1)C(=O)NCC(=O)N1CCN(CC1)Cc1ccc2c(c1)OCO2)C',\n", + " 'O=C(N1CCCC1c1nc2c(s1)cccc2)c1ccc(cc1)OCC1CCCO1',\n", + " 'COc1ccc(cc1)CN(C(=O)C1CCN(CC1)S(=O)(=O)c1ccc(c(c1)F)F)C1CC1',\n", + " 'O=C(c1ccc(cc1)NS(=O)(=O)c1cccs1)OCc1nc2c(s1)cccc2',\n", + " 'COc1ccc(cc1)S(=O)(=O)N1CCN(CC1)CC(=O)N(C(C)C)C(C)C',\n", + " 'O=C(N(C1CCS(=O)(=O)C1)CC1CCCO1)CSc1cc(C)c2c(n1)cccc2',\n", + " 'O=C(C1CCCN(C1)c1ncccn1)NCc1ccccc1c1ccc(cc1)CN1CCCC1',\n", + " 'Fc1ccc(cc1)CN(C(=O)c1ccc(cc1)S(=O)(=O)Nc1ccccc1F)C1CC1',\n", + " 'O=C(c1cccnc1N1CCCC1)N1CCN(CC1)Cc1ccc2c(c1)CCO2',\n", + " 'O=C(C(c1ccccc1)OC(=O)c1sccc1S(=O)(=O)N1CCCC1)N1CCOCC1',\n", + " 'O=C(Nc1ccc(cc1)c1ccccc1)CN1CCN(CC1)C(=O)c1ccco1',\n", + " 'COc1ccc(cn1)NC(=O)NC(c1cccc(c1)C(F)(F)F)CN1CCCC1=O',\n", + " 'O=C(N1CCCC1c1cccs1)CSc1nnc(n1Cc1ccccc1)C1CC1',\n", + " 'O=C(NC(c1ccc(cc1)n1cncc1)C)CSc1nnc(o1)c1ccc2c(c1)OCO2',\n", + " 'COc1cccc(c1)c1nnc(n1Cc1ccco1)SC(C(=O)NCc1cccs1)C',\n", + " 'O=S(=O)(c1ccc2c(c1)cccc2)N1CCN(CC1)CCOc1ccccc1',\n", + " 'Cc1ccc(cc1)S(=O)(=O)N1CCCCC1C(=O)N1CCN(CC1)c1ncccn1',\n", + " 'O=C1Nc2ccccc2SC1CC(=O)N1CCN(CC1)CC=Cc1ccccc1',\n", + " 'O=C(C(NS(=O)(=O)c1ccccc1F)Cc1ccccc1)N1CCN(CC1)c1ncccn1',\n", + " 'O=C(c1ccccc1SCc1ccccc1F)NCc1ccc(cc1)S(=O)(=O)N',\n", + " 'CCOC(=O)C1CCN(CC1)C(=O)CN1C(=O)NC(C1=O)(CC)c1ccc(cc1)F',\n", + " 'O=C(Cn1c2ccccc2nc1C(F)(F)F)NC1CCN(CC1)Cc1ccccc1',\n", + " 'O=C(C1CCCCC1)NCC(=O)N1CCC(=CC1)c1ccc(cc1)C',\n", + " 'CCC1(NC(=O)N(C1=O)CC(=O)Nc1ccccc1C(=O)C)c1ccccc1',\n", + " 'COc1ccc(cc1)C1CCCCCN1C(=O)c1ccc(cc1)n1cccn1',\n", + " 'O=C(N1CCc2c(C1)cccc2)CSc1nnc(o1)c1ccccc1Br',\n", + " 'COc1cc(ccc1OC)C(=O)Nc1sc2c(c1C(=O)N)CCC(C2)C',\n", + " 'CCCCCCCCn1c(NC(CC)C)nc2c1c(=O)[nH]c(=O)n2C',\n", + " 'Clc1cccc(c1)N(S(=O)(=O)c1cccc(c1)C(=O)NC(C1CC1)C1CC1)C',\n", + " 'COc1cc(OC)ccc1C1CCCN1C(=O)c1cc(nc2c1c(C)no2)c1ccco1',\n", + " 'COc1ccc(cc1)SCC(=O)N1N=C(CC1c1ccco1)c1cccs1',\n", + " 'O=C(c1sc2c(c1)CCCCCC2)NCc1nnc2n1cccc2',\n", + " 'Clc1ccc(cc1)c1cnc(n1Cc1ccccc1)Sc1ccc2n(n1)nnn2',\n", + " 'O=C(N1CCc2c(C1)cccc2)CN1C(=O)NC2(C1=O)CCOc1c2cccc1',\n", + " 'COC(=O)c1ccoc1COC(=O)c1ccc(cc1)n1cncn1',\n", + " 'COc1ccc(cc1S(=O)(=O)N(C)C)C(=O)N(Cc1ccc(cc1)OC(F)F)C',\n", + " 'O=C1CCCN1c1ccc(cc1C)NS(=O)(=O)c1c(C)c(C)cc(c1C)C',\n", + " 'CCOc1cc2CC(Oc2cc1NC(=O)c1nn(c2ccccc2)c(cc1=O)C)C',\n", + " 'CN(CC(=O)Nc1cc(nn1c1ccccc1)C1CC1)Cc1ccccc1',\n", + " 'CC(C(=O)NC1CCCC1)N(CC(=O)Nc1cccc(c1C)C)C',\n", + " 'O=C(C1CN(C(=O)C1)Cc1ccccc1Cl)Nc1ccccc1N1CCCC1=O',\n", + " 'O=C(Cc1sc(c(n1)c1ccc(cc1)F)C)NCc1ccccc1',\n", + " 'O=c1n(CCNS(=O)(=O)c2ccc(cc2)c2ccccc2)nc2n1cccc2',\n", + " 'COc1ccc(cc1NC(=O)COC(=O)C1CN(C(=O)C1)c1ccc(cc1)C)C',\n", + " 'O=C(NC1CCCC(C1C)C)COC(=O)c1ccc(cc1N)Cl',\n", + " 'COC(=O)c1c(C)[nH]c(c1C)C(=O)CSc1ccc2c(c1)OCCO2',\n", + " 'C=CCn1c(SCc2nc3ccccc3c(=O)[nH]2)nc2c(c1=O)scc2',\n", + " 'N#CC1(CCCCCC1)NC(=O)CN(Cc1ccc(cc1C)C)C',\n", + " 'COc1ccc(cc1)CC(=O)Nc1ccc2c(c1)NC(=O)C(O2)C',\n", + " 'COc1ccc(c(c1)CN1CCN(CC1)C(=O)Cn1ccccc1=O)OC',\n", + " 'CC(c1onc(n1)C1CC1)N1CCCC(C1)c1nc2c(o1)cccc2',\n", + " 'COc1ccccc1c1scc(n1)Cn1nnn(c1=O)c1ccccc1',\n", + " 'O=C1N(CCSc2nnnn2Cc2cccs2)C(=O)c2c1cccc2',\n", + " 'COc1ccc(cc1)OC(C(=O)N(c1ccccc1)Cc1ccco1)C',\n", + " 'Cn1ncc2c1ncnc2NCc1ccccc1COc1ccccc1',\n", + " 'COc1ccc(cc1)OCC(=O)c1[nH]c(c(c1C)C(=O)OC)C',\n", + " 'O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccccc1O',\n", + " 'COC(=O)C(Cc1c[nH]c2c1cccc2)NC(=O)COc1ccc(cc1)F',\n", + " 'Cc1cccc(c1)OCCCNC(=O)Cn1cnc2c1c(=O)n(C)c(=O)n2C',\n", + " 'O=C(c1cc(nn1c1ccccc1)C1CC1)NCC1CCCO1',\n", + " 'COc1ccccc1CN(C(=O)c1ccc(cc1)S(=O)(=O)C)C',\n", + " 'Cc1cc(C)c(c(=O)[nH]1)CNC(=O)Cn1cc(ccc1=O)C(F)(F)F',\n", + " 'O=C(Nc1ccccc1F)CCSCc1nc2c(s1)cccc2',\n", + " 'N#CC1(CCCCC1)NC(=O)COc1ccc2c(c1)oc(=O)c1c2CCC1',\n", + " 'C=CCn1c2nnc(n2c2c(c1=O)cccc2)SCC(=O)OCC',\n", + " 'CC(CNC(=O)CC1(CCCC1)CC(=O)NCC(O)C)O',\n", + " 'Fc1cccc(c1)C(NC(=O)c1cc(ccc1C)S(=O)(=O)N)C',\n", + " 'CCC(NC(=O)C1CCCN(C1)C(=O)c1ccc(cc1)Cl)(C)C',\n", + " 'N#Cc1ccccc1NC(=O)CN(Cc1ccc(cc1)C)C',\n", + " 'Fc1ccc(c(c1)C(=O)NCc1ccccc1S(=O)(=O)N(C)C)F',\n", + " 'COc1ccc(cc1)OCCOC(=O)Cn1cnc2c1c(=O)n(C)c(=O)n2C',\n", + " 'CC(NC(=O)C(Sc1nnc(o1)c1ccoc1C)C)C',\n", + " 'COc1ccc(cc1C(=O)NCCCOC(C)C)S(=O)(=O)N',\n", + " 'CN(S(=O)(=O)c1cccc(c1)CSc1ncnc2c1scc2)C',\n", + " 'COC(=O)CCN1CCN(CC1)c1ccc(cc1)OC',\n", + " 'CCc1nnsc1C(=O)NC1CCOc2c1cccc2',\n", + " 'COCCn1c(C)cn2c1nc1c2c(=O)n(c(=O)n1C)CC(=O)C',\n", + " 'O=C(C1CCCN(C1)c1ccc(nn1)Cl)NCc1cccs1',\n", + " 'CNC(=O)c1ccc(cc1)NC(=O)c1cccc(c1)Cl',\n", + " 'COC(=O)c1nn(cc1O)c1ccc(cc1)c1ccccc1',\n", + " 'COc1ccc(cc1NC(=O)C1CCCCC1)OC',\n", + " 'CCNC(=O)NC(=O)CSc1nnc(n1C)c1ccco1',\n", + " 'CCC(c1ccccc1NC(=O)c1ccc2c(c1)OCO2)C',\n", + " 'Oc1ccc(cc1)NC(=O)c1ccc(cc1)C(C)(C)C',\n", + " 'O=C(c1ccccc1OCc1ccccc1Cl)Nc1nccs1',\n", + " 'O=C1NC(=O)C(N1)(C)c1ccc(c(c1)Cl)Cl',\n", + " 'O=C(Nc1ccc(cn1)C)CNC(=O)c1ccc(o1)Br',\n", + " 'CCC1c2ccsc2CCN1S(=O)(=O)c1cccc(c1)Br',\n", + " 'COc1ncccc1CNC(=O)C1(C)CC1(Cl)Cl',\n", + " 'COc1cccc(c1OC)C(=O)OC(C(=O)Nc1ccccc1SC)C',\n", + " 'N#Cc1ccccc1CSc1nnc(n1C)c1cccnc1',\n", + " 'COc1cc(ccc1OCc1ccccc1)C(=O)OCC(=O)NC1CC1',\n", + " 'FC(Oc1ccc(cc1)C=CC(=O)c1ccc(cc1)O)F',\n", + " 'O=C(Cc1c[nH]c2c1cccc2)NCc1ccccc1F',\n", + " 'CCCCNC(=O)CN1C(=O)c2c(C1=O)c(N)ccc2',\n", + " 'CC(NS(=O)(=O)c1cccc(c1)F)Cn1cccn1',\n", + " 'CN(S(=O)(=O)c1cccs1)CCS(=O)(=O)N1CCCC1',\n", + " 'O=C(COC(=O)C1(C)CC1(Cl)Cl)NCC(F)(F)F',\n", + " 'N#Cc1ccc(cc1)OC(C(=O)N1CCOCC1)c1ccccc1',\n", + " 'CC(c1ccc(cc1)Br)NC(=O)NC(C)C',\n", + " 'Oc1ccc(cc1)C(=O)C=Cc1ccc(cc1)F',\n", + " 'NCCCn1c2ccccc2c2c1cccc2',\n", + " 'N#CCCn1nc(c(c1N)C(C(F)(F)F)(O)C)C',\n", + " 'c1ccc(cc1)c1ccc(cc1)CSc1nnnn1C1CC1',\n", + " 'O=C(C1CCN(CC1)S(=O)(=O)c1ccc2c(c1)OCCCO2)OCC(=O)N(Cc1ccccc1)Cc1ccccc1',\n", + " 'COc1cccc(c1)OC1OC2COC(OC2C(C1NC(=O)C)O)(C)C',\n", + " 'COc1ccc(cc1)C1CC(=NN1C(=O)Cn1nnc(n1)c1ccc(c(c1)OC)OC)c1ccccc1',\n", + " 'CN1CCN(CC1)c1ccc(cc1NC(=O)c1oc2c(c1C)cccc2)S(=O)(=O)N1CCOCC1',\n", + " 'COc1ccc(cc1)c1nn(cc1C(=O)N1CCN(CC1)CC(=O)N1CCCC1)Cc1ccccc1',\n", + " 'COc1ccc(cc1)NC(=O)CN(C(=O)CCOc1ccccc1)C',\n", + " 'COc1ccc(c(c1)[N+](=O)[O-])NC(=O)COC(=O)[C@H](C(C)C)NS(=O)(=O)c1ccc2c(c1)OCCO2',\n", + " 'COC(=O)c1cccc(c1)NC(=O)CC1Sc2ccccc2NC1=O',\n", + " 'O=C(NC(=O)NCc1ccco1)COC(=O)c1ccc2c(c1)OCCO2',\n", + " 'O=c1c2ccccc2nc(n1Cc1ccco1)COc1ccc(cc1)S(=O)(=O)N1CCOCC1',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCO2)CN1CCN(CC1)S(=O)(=O)Cc1ccccc1',\n", + " 'COc1cc(ccc1OC(F)F)C(=O)N1CCN(CC1)CCOc1ccc(cc1)OC',\n", + " 'CCOc1cc(ccc1OCC(=O)N1CCCCC1)C(=O)NCc1ccccc1',\n", + " 'O=C(C1CCCN(C1)C(=O)c1cccc2c1cccc2)NC(c1ccncc1)c1ccccc1',\n", + " 'CNC(=O)CNC(=O)c1ccc2c(c1)OCO2',\n", + " 'O=C(c1ccc(cc1)S(=O)(=O)NC1CC1)OCc1cc(Cl)c2c(c1)OCCO2',\n", + " 'COc1ccc(cc1)C1CC(=NN1C(=O)c1ccccc1)c1ccc(c(c1)OC)OC',\n", + " 'CC(=O)NC12CC3CC(C1)CC(C2)(C3)C(=O)NCC(=O)Nc1c(C)cc(cc1C)C',\n", + " 'O=C(Cc1ccccc1)NCC(=O)Nc1ccccc1Br',\n", + " 'COc1cc(cc(c1OCc1ccccc1)Br)C(=O)NCc1ccncc1',\n", + " 'COc1ccc(cc1)c1csc2c1c(ncn2)N1CCN(CC1)CC(=O)N1CCCC1',\n", + " 'COc1ccc(cc1S(=O)(=O)N1CCOCC1)CC(=O)Nc1cc(Cl)ccc1n1cncn1',\n", + " 'O=C(N1CCN(CC1)S(=O)(=O)c1ccc2c(c1)CCCC2)CSc1nnc(n1C)C1CC1',\n", + " 'Cc1ccccc1n1c(SCc2nnc(o2)c2ccccc2)nnc1N1CCOCC1',\n", + " 'Clc1ccc(cc1)n1nnnc1SC(C(=O)Nc1ccccc1c1ccccc1)C',\n", + " 'O=C(Nc1ccccc1N1CCCC1=O)CSc1nc(c(n1CC1CCCO1)C)C',\n", + " 'O=C(NC(c1ccc(cc1)n1cncc1)C)Cc1ccc(s1)S(=O)(=O)N1CCOCC1',\n", + " 'O=C(N(Cc1cn(nc1c1ccccc1)c1ccccc1)C)C1CCN(CC1)C(=O)c1ccco1',\n", + " 'O=C(Nc1ccc2c(c1)CCN2C(=O)C)COc1ccccc1c1ccccc1',\n", + " 'O=C(Nc1noc(c1)C)COC(=O)c1c(C)nn(c1C)Cc1ccccc1Cl',\n", + " 'CCN(CC(=O)Nc1c(C)cc(cc1C)C)CC(=O)Nc1ccc(cc1)OC',\n", + " 'CC1OC(C)CN(C1)C(=O)C(N1CCC(CC1)c1c[nH]c2c1cccc2)C',\n", + " 'CN(C(=O)c1cc2ccccc2oc1=O)Cc1ccc(cc1)N1CCOCC1',\n", + " 'CCOCCCNCC(=O)N1N=C(CC1c1ccc(cc1)OC)c1ccc2c(c1)cccc2',\n", + " 'Cc1ccccc1n1c(SCc2noc(n2)c2cccs2)nnc1N1CCOCC1',\n", + " 'Cc1sc2c(c1C)c(NC1CCN(CC1)C1CC1)nc(n2)c1cccnc1',\n", + " 'CCN(C(=S)SCC(=O)Nc1c(C)n(n(c1=O)c1ccccc1)C)CC',\n", + " 'O=C(NCc1ccco1)CSc1ccccc1C(=O)N1CCN(CC1)c1cccc(c1C)C',\n", + " 'CC(OCCCNC(=O)N1CCN(CC1)S(=O)(=O)c1c(C)cc(cc1C)C)C',\n", + " 'CCN(S(=O)(=O)c1cc(ccc1C)C(=O)Nc1scc(n1)C)c1ccccc1',\n", + " 'Clc1ccc(c(c1)NC(=O)C(=Cc1ccco1)n1nnnc1c1ccccc1)C',\n", + " 'Cc1ccccc1OCc1nnc(n1c1ccccc1)SCC1CCOCO1',\n", + " 'O1CCN(CC1)Cc1c(ccc2c1cccc2)Oc1ncnc2c1c1CCCc1s2',\n", + " 'NC(=O)CCN(C(=O)Cc1ccc(cc1)c1ccccc1)Cc1ccccc1',\n", + " 'O=C(N1CCN(CC1)Cc1csc(n1)c1ccccc1)CSc1nc2c(o1)cccc2',\n", + " 'O=C(c1ccc(cc1)c1ccccc1)COC(=O)c1ccc(c(c1)S(=O)(=O)N1CCOCC1)Cl',\n", + " 'Fc1ccc(cc1)n1cncc1C(=O)OCc1onc(n1)c1cccc(c1)Cl',\n", + " 'O=C(Nc1ccc(cc1)N1CCOCC1)COc1ccc2c(c1)OCO2',\n", + " 'CCOc1ccc(cc1)Nc1nnc(s1)SCCN1CCOCC1',\n", + " 'CCCCn1nnnc1CN1C(=O)NC(C1=O)(Cc1ccccc1)c1ccccc1',\n", + " 'O=C(CN1C(=O)NC(C1=O)(C)c1ccccc1C(F)(F)F)NC(C(C)C)C',\n", + " 'CCC(NC(=O)C1CCN(CC1)S(=O)(=O)c1ccc(cc1)C#N)CC',\n", + " 'O=C(c1ccc2c(c1)c(on2)c1ccccc1)N1CCN(CC1)c1ccccn1',\n", + " 'O=C(NCc1ccc2c(c1)OCO2)CCNC(=O)c1ccc(cc1)Br',\n", + " 'O=C(C1CCC=CC1)NCc1ccccc1c1ccc(cc1)CN1CCCC1=O',\n", + " 'Cc1ccc2c(c1)oc(=O)cc2CN1C(=O)NC2(C1=O)CCOc1c2cccc1',\n", + " 'CSCCC(C(=O)Nc1ccc(cc1)C)NC(=O)c1ccc(cc1)OC',\n", + " 'Clc1ccc(cc1)c1csc2c1c(ncn2)Sc1nnnn1CC1CCCO1',\n", + " 'C=CCn1c2nnc(n2c2c(c1=O)cccc2)SCC(=O)NC(CC)C',\n", + " 'COc1cc(ccc1OCc1ccccc1)CN(C(=O)CN1CCN(CC1)C(=O)c1ccccc1)C',\n", + " 'FC(Oc1cccc(c1)C(=O)Nc1cccc(c1C)n1cnnn1)F',\n", + " 'CC1CCCN(C1)C(C(=O)Nc1ccc(cc1)N1CCCCC1)C',\n", + " 'Clc1cccc(c1)N1CCN(CC1)C(=O)c1ccc2c(c1)scn2',\n", + " 'O=C(NC12CC3CC(C2)CC(C1)C3)COC(=O)c1ccc(o1)Br',\n", + " 'CCc1nn2c(s1)nc(cc2=O)CSc1nnc(n1Cc1ccccc1)N1CCOCC1',\n", + " 'CCNC(=O)NC(=O)CSC1CCCC1',\n", + " 'O=C(NC1CCSc2c1cccc2F)CSC(C(=O)Nc1noc(c1)C)C',\n", + " 'O=C(NC1CCCc2c1cccc2)CN1C(=O)CC2(C1=O)CCCCC2',\n", + " 'O=C(NC(c1cccs1)c1ccccc1)CSc1nnc(o1)c1cccnc1',\n", + " 'CCCCOCCCNC(=O)CC1Sc2ccc(cc2NC1=O)Cl',\n", + " 'O=C(c1ccccc1c1ccccc1)NCC(N1CCOCC1)C1COCC1',\n", + " 'COC(=O)CC1N(CCc2c1cc(OC)c(c2)OC)Cc1ccc(cc1)F',\n", + " 'O=C(c1ccccc1COc1ccccc1)NCc1ccc(nc1)n1ncnc1',\n", + " 'COc1ccc(cc1)SCc1nnc(o1)c1c(C)onc1c1ccccc1',\n", + " 'COc1cccc(c1)C(N(C)C)CNC(=O)c1ccc(cc1)COc1ccccc1',\n", + " 'COc1c(Cl)cc(cc1OC)C=C1CS(=O)(=O)c2c(C1=O)cc(cc2)F',\n", + " 'CCN(CC(=O)NC(C)(C)C)CC(COc1cccc2c1cccc2)O',\n", + " 'O=C(N1CCN(CC1)S(=O)(=O)Cc1ccccc1)CCCN1C(=O)NC2(C1=O)CCCC2',\n", + " 'N#CC1(CCCCC1)NC(=O)CSc1nnc(o1)c1ccoc1C',\n", + " 'O=C(C(Sc1ccc2c(c1)OCCCO2)C)Nc1sccc1C(=O)N',\n", + " 'CCC(CN(S(=O)(=O)c1ccc(cc1)S(=O)(=O)C)CC(=O)OC)CC',\n", + " 'C=CCn1c(nnc1c1cccc(c1)S(=O)(=O)N1CCOCC1)SCc1ccccc1',\n", + " 'O=S(=O)(c1ccc2c(c1)cccc2)NCc1cccnc1n1cncn1',\n", + " 'CNc1snc(c1C(=O)NCCNC(=O)c1cccc(c1)OC)C',\n", + " 'COc1ccc(cc1OC)CNC(=O)c1ccc2c(n1)cccc2',\n", + " 'COc1ccccc1N1CCN(CC1)C(=O)CN(Cc1cccs1)CC1CCCO1',\n", + " 'Cc1ccc(cc1)S(=O)(=O)N1CCN(CC1)C(=O)c1ccc(o1)Br',\n", + " 'Fc1cccc(c1)n1c(nnc1N1CCOCC1)SCc1ccccn1',\n", + " 'NC(=O)NCc1ccc(cc1)C(=O)Nc1ccc2c(c1)CCC2',\n", + " 'COc1ccc(cc1OC)CCNC(=O)CN1C(=O)CC2(C1=O)CCCCC2',\n", + " 'CC(Sc1nc2scc(c2c(=O)n1c1ccccc1)c1ccco1)C',\n", + " 'O=C(N1CCOCC1)CN1CCN(CC1)c1ncnc2c1sc(c2)c1ccc(cc1)F',\n", + " 'O=C(N1CCN(CC1)Cc1ccc2c(c1)CCO2)Cn1cnc2c(c1=O)c(cs2)c1cccs1',\n", + " 'CCCNC(=O)CN1C(=O)NC(C1=O)(C)c1ccc(cc1)OC(F)F',\n", + " 'N#CC1(CCCC1)NC(=O)CSc1nc(NC)c2c(n1)cccc2',\n", + " 'Clc1ccc(cc1)c1nn(c(=S)n1C)CN1CCCCCC1',\n", + " 'O=C(C1CCCN1S(=O)(=O)c1c(C)noc1C)Nc1cccc(c1)S(=O)(=O)N(C)C',\n", + " 'O=C(C(N1CCN(CC1)CC1CCCO1)C)Nc1ccc(cc1)F',\n", + " 'COc1ccc(cc1)C(=O)C=Cc1cc(OC)c(c(c1)OC)OC',\n", + " 'O=C(N1CCN(CC1)C(=O)C1CC1)CC(c1ccccc1)NC(=O)c1ccccc1',\n", + " 'Cc1ccc(cc1)c1nnc(o1)C(Nc1ccc2c(c1)OCCCO2)C',\n", + " 'O=C(NC1CCCc2c1cccc2)CCCOc1ccccc1',\n", + " 'O=C(CN(C(=O)c1cc2c(o1)cccc2)C)Nc1ccc(cc1)N1CCOCC1',\n", + " 'CCCN(C(=O)c1ccc(cc1)S(=O)(=O)N1CCCCC1C)Cc1nnc(o1)c1cccs1',\n", + " 'O=C(N1CCCCCCC1)COC(=O)c1n[nH]c(=O)c2c1cccc2',\n", + " 'Cc1nnc(o1)CSc1nnc(n1Cc1ccccc1)c1ccco1',\n", + " 'O=C(Nc1ccc(c(c1)Cl)Cl)NCC1(CCCCC1)N(C)C',\n", + " 'COc1ccc(cc1)S(=O)(=O)N1CCN(CC1)C(=O)[C@@H]1CCCN1C(=O)c1cccs1',\n", + " 'COc1ccc(c(c1)OC)C(=O)N(Cc1cccs1)Cc1ccco1',\n", + " 'COc1cccc(c1)Cn1cc(ccc1=O)S(=O)(=O)N1CCCC1\\t',\n", + " 'COc1cc(CCNCC(COc2c(C)cccc2C)O)ccc1OC',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCO2)COc1ccc(cc1)c1ccccc1',\n", + " 'CCN(CCNC(=O)c1ccc(cc1)NC(=O)c1cccc(c1)Cl)CC',\n", + " 'O=C(c1ccc(cc1)CNS(=O)(=O)c1ccc(cc1)C(=O)C)NCc1ccccc1C',\n", + " 'O=C(COc1ccccc1c1ccccc1)NCc1ccccc1Cl',\n", + " 'CN(C(C(=O)NC(C)(C)C)C)Cc1ccc(cc1)OC(F)(F)F',\n", + " 'CCN(C(=O)Cc1c(C)noc1C)CC(=O)Nc1ccc2c(c1)OCCO2',\n", + " 'Cc1onc(c1C(=O)N1CCN(CC1)c1ncccn1)c1ccccc1',\n", + " 'CCc1cccc(c1)n1c(SCc2nnc(o2)c2ccco2)nnc1N1CCOCC1',\n", + " 'CCC(C(c1nc2c([nH]1)cccc2)NC(=O)c1ccccc1)C',\n", + " 'N#Cc1c(NC(=O)CCN2CCCCCC2)sc2c1CCC2',\n", + " 'Cc1onc(c1)OCC(=O)N1CCC(CC1)C(=O)Nc1ccc2c(c1)OCO2',\n", + " 'O=C(Nc1cc(Cl)ccc1N1CCCCCC1)CCNC(=O)C',\n", + " 'COc1cccc(c1)n1ccnc1SCc1cccc(c1)S(=O)(=O)N1CCOCC1',\n", + " 'CCN(c1ccccc1)C(=O)CSc1nnc(n1c1ccccc1F)c1cccnc1',\n", + " 'COC(=O)C(Cc1ccccc1)NC(=O)CCc1c[nH]c2c1cccc2',\n", + " 'O=C(Nc1ncc(cc1Cl)Cl)COC(=O)c1ccccc1Cl',\n", + " 'O=C(CN1C(=O)NC(C1=O)(C)c1ccccc1Cl)Nc1ccccc1c1ccccc1',\n", + " 'COc1ccc(cc1)NC(=O)c1cc(OC)c2c(c1)OCCO2',\n", + " 'CC(=O)NC(C(=O)NCc1ccccc1S(=O)(=O)N(C)C)Cc1c[nH]c2c1cccc2',\n", + " 'O=C(N1CCSC1c1ccccc1F)CSc1nc(CN2CCOCC2)nc2c1cccc2',\n", + " 'COc1ccc(cc1C(=O)COC(=O)c1c(C)nsc1NC)F',\n", + " 'CC(C(C(=O)NC1CCN(CC1)C(=O)C(C)C)NS(=O)(=O)c1ccc(cc1)C)C',\n", + " 'Clc1ccc2c(c1)ncn(c2=O)CCN1C(=O)c2c(C1=O)cccc2',\n", + " 'FC(Oc1cccc(c1)C(=O)NCC(=O)N1CCCCCC1)F',\n", + " 'O=C(c1cc(ccc1N1CCCC1)S(=O)(=O)N1CCOCC1)NCc1ccncc1',\n", + " 'CCOc1ccccc1n1nnnc1SCC(=O)Nc1ccccc1N1CCCC1=O',\n", + " 'O=C(NCc1nnc2n1cccc2)CSc1nnc(n1Cc1ccccc1)C1CC1',\n", + " 'O=C(C1CSC2(N1C(=O)CC2)c1ccccc1)OCc1nnc(o1)c1ccccc1',\n", + " 'NC(=O)CCSc1nc(Nc2ccccc2)c2c(n1)cccc2',\n", + " 'Cc1cc(C)n2c(n1)nc(n2)SCN1C(=O)c2c(C1=O)cccc2',\n", + " 'Cc1ccc(cc1)S(=O)(=O)N1CCCC1C(=O)N1CCN(CC1)Cc1ccncc1',\n", + " 'O=C(Nc1cc(nn1c1ccccn1)C)Nc1cccc(c1)Cl',\n", + " 'Cc1ccc(c(c1)C(=O)COc1ccc(cc1Cl)S(=O)(=O)N1CCOCC1)C',\n", + " 'O=C1NC2(C(=O)N1Cc1nnsc1Cl)CCOc1c2cccc1',\n", + " 'O=C(c1csc(n1)c1cccs1)NC(c1ccccc1)CN1CCOCC1',\n", + " 'O=C(c1ccc(cc1)CN(Cc1ccco1)Cc1ccco1)Nc1ccccc1',\n", + " 'CC(CN(C(=O)CN1C(=O)NC(C1=O)(C)c1cccc2c1cccc2)CC(C)C)C',\n", + " 'N#Cc1ccsc1NC(=O)C1CC(=O)N(C1)C(c1ccccc1)C',\n", + " 'CCN(S(=O)(=O)c1ccc(c(c1)NC(=O)CC(C)C)N1CCCCC1)CC',\n", + " 'Clc1cccc(c1)C(Nc1nc(CN2CCOCC2)nc2c1c1CCCc1s2)C',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCO2)Cc1nc(oc1C)c1ccccc1',\n", + " 'CCOc1cc(ccc1OCc1cccs1)C1NC(=O)c2c(N1)cccc2',\n", + " 'Clc1ccccc1S(=O)(=O)Nc1ccc(cc1)S(=O)(=O)N1CCCCCC1',\n", + " 'Cc1ccc(cc1)C1(C)NC(=O)N(C1=O)Cc1ccccc1Cl',\n", + " 'C=CCN(c1scc(n1)c1ccccc1)C(=O)CSc1nncn1c1ccccc1',\n", + " 'COc1ccc2c(c1)c(C)c(o2)C(=O)NCC(c1cccs1)N1CCOCC1',\n", + " 'COCCOC(=O)C1=C(C)NC(=O)NC1c1c(F)cccc1F',\n", + " 'COc1ccc(cc1)C(c1c[nH]c2c1cccc2)CNC(=O)C1CCN(CC1)C(=O)C',\n", + " 'O=C(C(Oc1ccc(cc1)c1nnco1)C)Nc1ccccc1c1ccccc1',\n", + " 'CSc1ccccc1C(=O)NCCCn1ccc2c1cccc2',\n", + " 'CSc1ncc(n1c1ccc(cc1)F)C(=O)OCc1nnnn1c1ccccc1',\n", + " 'Cc1occc1c1nnc(o1)Nc1cccc(c1)S(=O)(=O)N(c1ccccc1)C',\n", + " 'NC(=O)COc1ccc(cc1)C(=O)N1CCN(CC1)c1cccc(c1)Cl',\n", + " 'CC1CCC2(CC1)NC(=O)N(C2=O)CC(=O)N1CCCC1',\n", + " 'COc1nc2ccccc2c(c1)C(=O)Nc1ccc(cc1)O',\n", + " 'CC1OC(=O)C(C1)Sc1nnc(n1c1ccccc1)C1CC1',\n", + " 'O=C(NC1CCCc2c1cccc2)CN1CCN(CC1)Cc1ccco1',\n", + " 'O=C(Cn1cnc2c(c1=O)c(cs2)c1cccs1)NCc1ccc(cc1)CN1CCCC1',\n", + " 'Cc1ccc(c(c1)Cn1cnc2c1c(=O)n(C)c(=O)n2C)C',\n", + " 'O=C1CCCN1CCCNC(=O)c1cc2c(o1)cccc2',\n", + " 'O=C(N1CCN(CC1)c1ccc(cn1)S(=O)(=O)N1CCOCC1)C1CC1',\n", + " 'O=C(c1cc(nc2c1cnn2C(C)C)c1cccs1)NC1=NCCS1',\n", + " 'COc1ccc(c(c1)C(=O)NC1CCC(CC1)C)Br',\n", + " 'Fc1ccccc1OCCOC(=O)c1c[nH]c2c1cccc2',\n", + " 'O=C(N1CCN(CC1)c1ccccn1)C1CCN(CC1)C1=NS(=O)(=O)c2c1cccc2',\n", + " 'COc1cc(cc(c1OC)OC)C(=O)OCc1cccc(c1)C',\n", + " 'Brc1ccc(cc1)S(=O)(=O)N1CCCC1C(=O)N(C)C',\n", + " 'FC(COc1ccccc1NS(=O)(=O)c1ccc2c(c1)CCC2)(F)F',\n", + " 'COCc1c(oc2c1cccc2)C(=O)Nc1ccc(cc1)S(=O)(=O)C(F)F',\n", + " 'COc1ccc(cc1)c1[nH]c2c(c1CCC(=O)N1CCOCC1)cccc2',\n", + " 'COc1cc(ccc1OCc1c(C)noc1C)C(=O)N1CCCC1c1ccccc1',\n", + " 'Fc1ccc(cc1)c1noc(n1)COC(=O)C1(CCCC1)S(=O)(=O)c1ccccc1',\n", + " 'O=C(CCN1C(=O)NC2(C1=O)CCCC2)NCCc1c[nH]c2c1cccc2',\n", + " 'Nc1nc(COC(=O)c2sc(nc2C)C)nc(n1)Nc1ccccc1',\n", + " 'COCCn1c(SCC(=O)N2CCOCC2)nnc1c1ccncc1',\n", + " 'CC1CC(C)CN(C1)C(=O)C1CCN(CC1)C(=O)c1ccc(cc1)Cl',\n", + " 'O=C(C1CCCN(C1)S(=O)(=O)c1ccc(cc1)F)NC(C1CC1)C1CC1',\n", + " 'O=C(c1sccc1C)NCCCn1ccc2c1cccc2',\n", + " 'O=C(N1CCCC1c1nnc2n1cccc2)Cc1ccc(cc1)c1csc(n1)C',\n", + " 'COc1ccc(cc1Cl)NC(=O)C(c1ccccc1)O',\n", + " 'COc1ccccc1OCCNCC(COc1ccccc1C(C)C)O',\n", + " 'O=C(NC1(CCCC1)C(=O)N1CCN(CC1)c1nccs1)NCc1ccccc1',\n", + " 'COC(=O)c1sc2c(c1NC(=O)c1ccccc1Br)cccc2',\n", + " 'CC1CCC(CC1)NC(=O)c1cc2c(o1)cccc2',\n", + " 'CCC(NC(=O)CN1C(=O)NC(C1=O)(CC)c1ccc(cc1)F)(C#C)CC',\n", + " 'COc1ccc(c(c1)C(=O)Nc1sccc1C(=O)N)Br',\n", + " 'O=C(c1cc(nn1c1ccccc1)c1ccco1)Nc1c[nH]nc1',\n", + " 'Fc1ccc(cc1)C(=O)Cn1cnc2c(c1=O)scc2',\n", + " 'COc1ncccc1CNC(=O)NC(c1ccccc1)CN1CCOCC1',\n", + " 'O=C(c1c(C)onc1C)Nc1ccc(cc1)c1cc2c(o1)cccc2',\n", + " 'CCN1CCCC1CNC(=O)c1ccccc1OC',\n", + " 'CCOC(=O)c1sc(nc1C)NC(=O)c1ccsc1',\n", + " 'CC(N(S(=O)(=O)c1ccc2c(c1)OCCCO2)C)c1ccccc1',\n", + " 'Clc1ccc(s1)c1csc(n1)c1cccnc1',\n", + " 'O=C(N1CCCC(C1)c1nc2c(s1)cccc2)CSc1nnc(o1)c1cccs1',\n", + " 'CC(N(C(=O)COC(=O)c1cc(=O)[nH]c2c1cccc2)C(C)C)C',\n", + " 'Clc1cccc(c1)c1occ(n1)CSc1nncn1Cc1ccco1',\n", + " 'COc1ccc(cc1)CNC(=O)c1ccc(cc1)N1CCCC1=O',\n", + " 'O=C(CSc1nnc(n1C1CC1)N1CCCC1)NCc1ccc(cc1)Cl',\n", + " 'O=C1Nc2cc(ccc2SC1CC(=O)N1CCCCC1C)C(F)(F)F',\n", + " 'O=C(C1CC(=O)N(C1)c1cccc(c1C)C)N1CCN(CC1)c1nccs1',\n", + " 'CCOC(=O)C(C(=O)OCC)Oc1ccccc1',\n", + " 'CCCn1c(C)cc(c1C)C(=O)Cn1cnc2c(c1=O)cccc2',\n", + " 'N#CCSc1nnc(o1)c1ccc(cc1)OC(F)F',\n", + " 'CN(Cc1cc(=O)oc2c1cc1CCCc1c2)Cc1nc2ccccc2c(=O)[nH]1',\n", + " 'COc1ccccc1C(=O)COC(=O)c1nn2c(n1)nc(cc2C)C',\n", + " 'COc1ccc(cc1)COCC(CN1CCOCC1)O',\n", + " 'Fc1ccc(cc1)NC(=O)N1CCC(CC1)C(c1ccccc1)O',\n", + " 'OC(CN(Cc1ccc(cc1)C)C)COc1ccc2c(c1)cccc2',\n", + " 'CN(Cc1ccc(cc1)c1ccccc1CNC(=O)OCc1ccccc1)C',\n", + " 'Cc1ccc(cc1)CNC(=O)C1(CCN(CC1)C(=O)C)c1ccccc1',\n", + " 'CC(=O)N1N=C(CC1c1ccccc1Cl)c1ccccc1NS(=O)(=O)C',\n", + " 'Brc1ccc(cc1)S(=O)(=O)NCCCn1cnc2c1cccc2',\n", + " 'CCn1c(SCC(=O)N2CCc3c2cccc3)nc2c1cccc2',\n", + " 'O=S(=O)(c1ccc2c(c1)cccc2)N1CCCC1',\n", + " 'COC(=O)CC1C(=O)NCCN1S(=O)(=O)c1ccc(cc1)Br',\n", + " 'Fc1ccc(cc1)c1ccc(o1)CNCc1ccc(cc1)CN1CCOCC1',\n", + " 'CC(CN1C(=O)NC(C1=O)(C)c1ccccc1Cl)C',\n", + " 'N#Cc1ccc(cc1)S(=O)(=O)N(Cc1nc2c(s1)cccc2)C',\n", + " 'COC(=O)c1sccc1NS(=O)(=O)c1cc(ccc1C)C(C)(C)C',\n", + " 'O=C(N(Cc1cccs1)C)CSc1nc2ccsc2c(=O)n1C',\n", + " 'COc1cc(ccc1Oc1nc(Cc2ccc(c(c2)OC)OC)nc2c1c1CCCc1s2)C(=O)C',\n", + " 'O=C(NC(=O)Nc1ccc2c(c1)OCCO2)COC(=O)C1Cc2ccccc2CN1S(=O)(=O)c1ccccc1F',\n", + " 'O=C(c1ccccc1)N1CCN(CC1)C(=O)c1ccccc1Br',\n", + " 'CCC1(NC(=O)N(C1=O)Cc1ccc(cc1)Cl)c1ccc(cc1)F',\n", + " 'Fc1ccc(cc1)OCCN1C(=O)NC(C1=O)(C)c1ccccc1',\n", + " 'CSCc1ccc(o1)C(=O)Nc1ccc(cc1)C(=O)N',\n", + " 'Brc1ccc(c(c1)F)Cn1cnc2c(c1=O)oc1c2cccc1',\n", + " 'CCC1(C)CC(=O)N(C(=O)C1)CC(=O)Nc1ccc(c(c1)C)C',\n", + " 'CCCNS(=O)(=O)c1ccc(c(c1)Cl)Cl',\n", + " 'O=C(N(C)C)CN(c1nc2c(Cl)c(nn2c2c1cccc2)C)C',\n", + " 'O=C(c1cc(nc2c1cnn2C(C)C)C1CC1)N1CCN(CC1)Cc1ccc2c(c1)OCO2',\n", + " 'O=C1CCCN1Cc1ccccc1CNS(=O)(=O)c1ccccc1',\n", + " 'COCCNC(=O)NC(=O)CSc1ccc2c(c1)OCCO2',\n", + " 'CCC(NC(=O)C=Cc1oc(c(c1)C(=O)OC)C)CC',\n", + " 'c1ccc(cc1)Oc1ccccc1CSc1nnnn1C1CC1',\n", + " 'O=C(Nc1ncc(cc1Cl)Cl)CN1CCCCCCC1',\n", + " 'O=C(NCc1ccc(cc1)C)CSc1nnc(c(=O)[nH]1)Cc1ccc(cc1)C(C)(C)C',\n", + " 'CCc1ccccc1n1c(SCC(=O)N2CCN(CC2)c2ncccn2)nnc1N1CCOCC1',\n", + " 'CCN(S(=O)(=O)c1cccc(c1)c1nnc(o1)SCc1noc(c1)c1ccccc1)CC',\n", + " 'COc1ccc(cc1C(=O)CSc1nnc2n1cccc2)OC',\n", + " 'CCN(S(=O)(=O)c1ccc(c(c1)C(=O)N1CCN(CC1)c1ncccn1)N1CCOCC1)CC',\n", + " 'CC(C(c1ccc(cc1)O)O)NC1CC2CC1C1C2CCC1',\n", + " 'O=C(c1ccc2c(c1)scn2)Nc1cc(ccc1N1CCOCC1)S(=O)(=O)N1CCOCC1',\n", + " 'O=C(c1nc(n(n1)c1ccccc1)c1ccccc1)N1CCN(CC1)Cc1ccc2c(c1)OCO2',\n", + " 'Fc1ccc(cc1)CNC(=O)c1onc(c1)C',\n", + " 'CC(NC(=O)c1ccccc1c1ccccc1)Cn1cccn1',\n", + " 'CN(CCOC(=O)CC12CC3CC(C1)CC(C2)(C3)Br)C',\n", + " 'O=C1NCCN(C1)C(=O)CCSc1ccc(c(c1)C)C',\n", + " 'Cc1cc(cc(c1)C)NC(=O)c1c(C)onc1c1ccccc1',\n", + " 'O=c1n(nnn1c1cccs1)Cc1nnc(o1)c1cccs1',\n", + " 'O=C(Nc1ccc(cc1F)F)CN1C(=O)NC2(C1=O)CCCC2',\n", + " 'COc1cc(ccc1OC)c1nnn(n1)CC(=O)NC(c1ccccc1)c1ccccc1',\n", + " 'Cc1ccc(c(c1)c1nc2c([nH]1)cccc2)O',\n", + " 'NC(=O)COc1ccc(c(c1)Cl)Cl',\n", + " 'O=C(N1CCCC1)CN1CCN(CC1)c1nc2ccccc2c(c1)c1nc2c(s1)cccc2',\n", + " 'O=C(c1ccc([nH]c1=O)C(F)(F)F)NC1(C)CCS(=O)(=O)C1',\n", + " 'COc1cc(cc(c1Br)OC)C(=O)NCC(C)C',\n", + " 'FC(Oc1ccccc1NC(=O)c1cc2ccccc2oc1=O)F',\n", + " 'Cc1ccc(cc1)N(S(=O)(=O)c1ccc(cc1)S(=O)(=O)N1CCOCC1)Cc1ccccc1',\n", + " 'Cc1ccc(cc1)S(=O)(=O)N1CCCN(CC1)C(=O)c1ccc(cc1)OCC1CCCO1',\n", + " 'COc1ccc(cc1S(=O)(=O)N1CCOCC1)NC(=O)C12CC3CC(C1)CC(C2)(C3)Cl',\n", + " 'CN(S(=O)(=O)c1c(Cl)cccc1Cl)C1CCN(CC1)C',\n", + " 'COc1ccccc1Nc1nnc(s1)SCC(=O)N(C(C1CC1)C)Cc1ccccc1',\n", + " 'O=C(NC12CC3CC(C2)CC(C1)C3)CN1C(=O)NC(C1=O)(c1ccccc1)c1ccccc1',\n", + " 'O=C(N(C1(CCCCC1=O)c1ccccc1Cl)C)CSc1nnc(n1C1CC1)c1cccnc1',\n", + " 'O=C(Cc1c[nH]c2c1cccc2)Nc1ccc(cc1C)Cl',\n", + " 'CCc1ccccc1NC(=O)CN(C(=O)CSc1nnc(o1)c1ccc(c(c1)C)C)C',\n", + " 'O=C(N(C(C)(C)C)Cc1ccccc1)CSc1nnc(n1c1ccccc1)c1ccccc1',\n", + " 'COc1cccc(c1OC)CN(C(=O)c1cccc(c1)S(=O)(=O)N1CCN(CC1)c1ccc(cc1)F)C',\n", + " 'O=C(c1cc(ccc1C)S(=O)(=O)N1CCOCC1)Nc1ccccc1C(=O)N1CCCC1',\n", + " 'CCC1(NC(=O)N(C1=O)Cc1noc(c1)C)c1ccccc1',\n", + " 'CCCn1c(SCC2CCCCC2)nnc1O',\n", + " 'N#CCSc1nc2ccccc2c(=O)n1c1ccc(cc1F)F',\n", + " 'OCc1ccc(cc1)C(=O)Nc1ccccc1OC(F)F',\n", + " 'O=C(c1ccc(cc1)C(F)(F)F)NCc1ccc2c(c1)OCO2',\n", + " 'COc1ccc(cc1)N1CCN(CC1)C(=O)CN(S(=O)(=O)c1ccc(cc1)C)Cc1ccco1',\n", + " 'CCCCNC(=O)COC(=O)c1ccc(cc1)NC(=O)C',\n", + " 'O=C(N(Cc1cccs1)CCc1cccs1)c1ccc(cc1)S(=O)(=O)N1CCOCC1',\n", + " 'Clc1cccc(c1)CNC(=O)c1cc(sc1C)C',\n", + " 'CCCN(C(=O)CSc1nnc(n1c1ccccc1)C1CC1)Cc1nnc(o1)c1cccs1',\n", + " 'CC(=O)N1CCCc2c1ccc(c2)S(=O)(=O)N1CCCCC1c1nc2c(s1)cccc2',\n", + " 'O=C(C(Sc1nnnn1C1CCCC1)C)Nc1ccc(cc1)N1CCOCC1',\n", + " 'O=C(Nc1ccccc1C)CN1CCCCC1C(=O)N',\n", + " 'Cc1cc(C)cc(c1)n1nnnc1SCC(=O)N1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'O=C(N1CCN(CC1)Cc1ccccc1)CN1C(=O)NC(C1=O)(C)c1ccc2c(c1)CCC2',\n", + " 'CCOc1cccc(c1)CNC(=O)CC1C=CCC1',\n", + " 'O=C(C(c1ccccc1)Sc1ccc(cn1)S(=O)(=O)N1CCCC1)N1CCOCC1',\n", + " 'O=C(N1CCN(CC1)Cc1ccc2c(c1)OCO2)C1CCN(CC1)S(=O)(=O)c1ccccc1F',\n", + " 'CSc1nc2n(n1)c(C)c(c(n2)C)CC(=O)N(Cc1cccs1)CCc1cccs1',\n", + " 'Oc1ccc(cc1)c1ccc(cc1)C(=O)OCC(=O)N1CCc2c(C1)cccc2',\n", + " 'COc1cc(OC)ccc1C1CCCN1Cc1nnc(o1)c1c(C)onc1c1ccccc1',\n", + " 'COc1ccc(cc1)NC(=O)CN(C(=O)c1cccc(c1)Oc1ccccc1)C',\n", + " 'O=C(COc1ccccc1c1ccccc1)OCC(=O)Nc1cccc(c1)S(=O)(=O)N1CCCC1',\n", + " 'N#CC(C1CC1)(NC(=O)CSc1ccc(cn1)S(=O)(=O)N1CCCCC1)C',\n", + " 'CN(C(=O)c1cc(nn1c1ccccc1)c1ccco1)Cc1nc2ccsc2c(=O)[nH]1',\n", + " 'CN(C(=O)C(c1ccccc1)Sc1nnc(n1c1ccccc1C(C)C)c1cccnc1)C',\n", + " 'COc1ccc(cc1)c1nnc(n1CC)SCC(=O)N1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'COC(=O)c1ccc(cc1)NC(=O)COC(=O)c1cccc2c1cccc2',\n", + " 'COC(=O)c1ccccc1OC(=O)c1cccnc1',\n", + " 'Clc1ccc(cc1)OCCCSc1nnc(s1)N',\n", + " 'O=C(NC1(CCCC1)C(=O)NCc1ccc(cc1)N1CCCC1=O)NCc1ccccc1',\n", + " 'CN(C(=O)CCc1c(C)nc([nH]c1=O)N1CCOCC1)Cc1c(C)nn(c1C)c1ccccc1',\n", + " 'COc1cc(N)c(cc1C(=O)OCC(=O)NCc1ccc2c(c1)OCO2)Cl',\n", + " 'N#Cc1ccccc1n1cnc2c1cc(C)c(c2)C',\n", + " 'O=C(CN1C(=O)NC(C1=O)(Cc1ccccc1)Cc1ccccc1)NCc1cccs1',\n", + " 'Cc1ccc(c(c1)C1C(=O)c2c(C1=O)cccc2)C',\n", + " 'COc1cc(ccc1OC)CN1CCN(CC1)C(=O)c1cc2c(o1)cccc2',\n", + " 'Cc1cc(cc(c1)C)NC(=O)C(n1cnc2c1c(=O)n(C)c(=O)n2C)c1ccccc1',\n", + " 'O=C(Nc1c(Cl)cccc1C(F)(F)F)CN1C(=O)NC2(C1=O)CCOc1c2cccc1',\n", + " 'O=C(N(C1CC1)Cc1nnc(o1)c1ccccc1Cl)c1ccc(cc1)C(F)(F)F',\n", + " 'COc1ccc(cc1)CN(C(=O)CSc1nc2ccccc2c(=O)n1Cc1cccnc1)C1CC1',\n", + " 'COc1cn(nc1C(=O)NCC(c1ccccc1)N(C)C)c1ccccc1',\n", + " 'C=CCn1c(SCC(=O)c2ccc(s2)Cl)nnc1COc1ccccc1F',\n", + " 'C1CCC(CC1)n1nnnc1Sc1nc(nc2c1cccc2)c1cccnc1',\n", + " 'O=C(Cn1c(nc2c1cccc2)c1ncsc1)NC1CCN(CC1)Cc1ccccc1',\n", + " 'NC(=O)COc1ccccc1C(=O)Nc1nccs1',\n", + " 'Clc1ccc(cc1)c1nnc(o1)CN(S(=O)(=O)c1ccccc1Br)C1CC1',\n", + " 'O=C(C1CCCN(C1)C(=O)c1ccc(cc1)Cl)NC(c1ccc(cc1)n1cncc1)C',\n", + " 'O=C(Cc1csc(n1)NC(=O)c1cccs1)NCc1ccccc1C',\n", + " 'O=C(CN1CC(Oc2c1cccc2)C(=O)N1CCOCC1)NC(=O)NC1CCCC1',\n", + " 'O=C(C=Cc1ccc2c(c1)OCO2)NCCCCCc1onc(n1)c1cccs1',\n", + " 'COCCN(c1c(=O)[nH]c(=O)n(c1N)Cc1ccccc1)C(=O)c1nccc(c1)Cl',\n", + " 'Clc1cccc(c1)N1CCN(CC1)S(=O)(=O)c1ccc2c(c1)OCCCO2',\n", + " 'O=C(c1ccc(cc1)c1ccccc1)Oc1ccc(cc1)n1cnnn1',\n", + " 'O=C(N1CCc2c(C1c1ccccc1)ccs2)CCc1onc(n1)c1ccco1',\n", + " 'O=C(Nc1c(C)cccc1C)CN1CCN(CC1)C(=O)CCn1ccc2c1cccc2',\n", + " 'Fc1ccc(cc1)C(c1cccs1)NC(=O)Cn1nnc(n1)c1ccsc1',\n", + " 'O=C(c1ccccc1)NC1CCN(CC1)C1CC(=O)N(C1=O)Cc1ccccc1',\n", + " 'O=C1NCCN(C1)c1nc(nc2c1cc(s2)c1ccccc1)c1cccnc1',\n", + " 'CC1CCCCN1S(=O)(=O)c1cccc(c1)C(=O)N1CCN(CC1)c1ncccn1',\n", + " 'CC1CCCC(N1C(=O)CSc1nn(c(n1)C(C)C)c1ccccc1)C',\n", + " 'O=C(NCC1(CCCC1)c1ccccc1)CNC(=O)COc1ccccc1',\n", + " 'Clc1cccc(c1)Cn1c(CN(Cc2ccccc2)Cc2ccccc2)nc2c1c(=O)n(c(=O)n2C)C',\n", + " 'O=C(Nc1ccccc1N1CCCC1)CN1CCCC1c1ccc2c(c1)OCCCO2',\n", + " 'O=C(Nc1cc(nn1c1ccccc1)C)CSc1nnnn1CC1CCCO1',\n", + " 'O=C(c1ccccc1OCc1ccccc1)C=Cc1ccc2c(c1)OCCO2',\n", + " 'COc1ccccc1NC(=O)COC(=O)c1cc(cn1C)C(=O)C',\n", + " 'CN(c1ccccc1C(=O)NCc1ccco1)C(=O)CN1CCC(CC1)c1nc2c(s1)cccc2',\n", + " 'CCOC(=O)C1CCCN(C1)C(=O)CN1CCCC1c1ccc(cc1)OC',\n", + " 'O=C(c1ccccc1NC(=O)c1ccco1)N1CCN(CC1)c1cccc(c1)C(F)(F)F',\n", + " 'O=C(c1cc(n(c1C)CC1CCCO1)C)CSc1nnc(o1)c1ccco1',\n", + " 'CC1CCN(CC1)C(=O)c1ccc(cc1)S(=O)(=O)N1CCCCCC1',\n", + " 'COc1ccc(cc1)C1(C)NC(=O)N(C1=O)CC(=O)NC1(C#N)CCCCC1',\n", + " 'O=C(c1ccc(cc1)S(=O)(=O)N(C)C)NCCCn1ccc2c1cccc2',\n", + " 'O=S(=O)(Nc1ccccc1c1ccccc1)C=Cc1ccccc1',\n", + " 'COc1cc(ccc1OC)c1nnc(o1)SCc1cc(=O)oc2c1ccc(c2)C',\n", + " 'O=C(Nc1scc(n1)c1ccc(cc1)c1ccccc1)Cn1cnnn1',\n", + " 'O=C(CN1CCc2c(C1)cccc2)NC(=O)Nc1ccc2c(c1)OCCO2',\n", + " 'O=C(Nc1sc(c(c1C(=O)N1CCOCC1)C)c1ccccc1)Cn1nnc(n1)c1cccs1',\n", + " 'CCCN1CCCC1C(=O)Nc1ccc(cc1)C(=O)NC(C)(C)C',\n", + " 'FC(Oc1ccccc1C(=O)N1CCN(CC1)S(=O)(=O)c1c(C)noc1C)F',\n", + " 'CCC(=O)Nc1cccc(c1C)NCC(=O)NC1CCCCC1C',\n", + " 'COc1ccc(cc1)CNC(=O)C12CC3CC(C1)CC(C2)(C3)Br',\n", + " 'COCC(=O)N1CCC(CC1)NC(=O)C(C(C)C)NC(=O)OCc1ccccc1',\n", + " 'O=C(C(c1ccccc1)Sc1nnnn1Cc1cccs1)N1CCCCC1',\n", + " 'O=C(N(C1CCCCC1)C)CSc1nnc(n1c1ccccc1)C1CC1',\n", + " 'CCC(N(C1CCS(=O)(=O)C1)C(=O)CSc1cc(C)nc(n1)C(C)C)C',\n", + " 'CCOc1ccccc1OC1CCNCC1',\n", + " 'CC=CC=CC(=O)NCc1ccccc1c1ccc(cc1)CN1CCCC1=O',\n", + " 'COc1cc(C)c(cc1OC)CN1C(=O)NC2(C1=O)CCCc1c2ccs1',\n", + " 'N#Cc1ccc(cc1)C1NC(=O)N(C(=C1C(=O)N1CCOCC1)C)C1CC1',\n", + " 'O=C(C1CC(=O)N(C1)c1ccc2c(c1)OCCO2)N1CCN(CC1)c1ncccn1',\n", + " 'O=C(CN1C(=O)NC2(C1=O)CCc1c2cccc1)NC(c1ccccc1)C',\n", + " 'Fc1ccc(cc1)N1CCN(CC1)C(=O)c1cnn(n1)c1ccccc1',\n", + " 'Clc1cccc(c1)N1CCN(CC1)C(=O)CN1C(=O)NC(C1=O)(C)C1CC1',\n", + " 'COc1ccc(cc1C(=O)N1CCC(CC1)C(=O)c1ccc(cc1)O)C',\n", + " 'O=C(Nc1ccc(cn1)Cl)CSc1ncnc2c1c1CCCCc1s2',\n", + " 'O=C(c1ccco1)C=c1[nH]c(=O)c(=Cc2ccc(cc2)N2CCOCC2)s1',\n", + " 'CC1CC(C)CN(C1)S(=O)(=O)c1ccc(cc1)NC(=O)C1CCC1',\n", + " 'O=C(N1CCN(CC1)Cc1ccccc1)CSc1nnc(n1c1ccccc1)N1CCCCC1',\n", + " 'O=C(CN(C(=O)c1cc(C)cc(c1)C)C)Nc1ccc(cc1)F',\n", + " 'CCCCC(=O)Nc1ccc(cc1C)N1CCN(CC1)CC',\n", + " 'O=C(c1cccc(c1)S(=O)(=O)N1CCCC1)N(Cc1nc2ccccc2c(=O)[nH]1)CC1CCCO1',\n", + " 'O=C(N1N=C(CC1c1ccccc1O)c1ccncc1)c1ccccc1',\n", + " 'O=C(CSc1nnc(n1Cc1ccccc1)c1cccs1)NCC1CCCCC1',\n", + " 'O=C(C(NS(=O)(=O)c1ccccc1)C)NCCOc1ccc(cc1)C',\n", + " 'COc1cc(NC(=O)COC(=O)c2cc3ccccc3oc2=O)cc(c1)OC',\n", + " 'O=C(c1ccc2c(c1)nc1n(c2=O)CCC1)Nc1ccc(cc1)N1CCOCC1',\n", + " 'O=C(N1CCCC1)CSc1nnc(o1)C12CC3CC(C2)CC(C1)C3',\n", + " 'Fc1ccc(cc1)C(=O)N1CCCCC(C1=O)Sc1nc2ccccc2c(=O)n1Cc1ccco1',\n", + " 'COc1ccc(cc1)c1nc(sc1C)NC(=O)C1CCS(=O)(=O)C1',\n", + " 'COc1ccccc1c1nnc(n1C1CCCCC1)SC1CC(OC1=O)C',\n", + " 'CSc1nc2n(n1)c(C)c(c(n2)C)CC(=O)NCc1ccccc1C',\n", + " 'O=C(NCc1ccccc1CN1CCCC1=O)NCC1(CC1)c1ccccc1',\n", + " 'COc1cccc(c1)C(=O)N(C1CCCC1)Cc1ccc2c(c1)OCO2',\n", + " 'O=C(C(NC1=NS(=O)(=O)c2c1cccc2)C)NCCc1c(C)cc(cc1C)C(C)(C)C',\n", + " 'COc1ccc(cc1)C1=NN(C(C1)c1ccco1)C(=O)Cn1cnc2c(c1=O)cccc2',\n", + " 'O=C(Nc1sc2c(c1C(=O)N)CCC2)CN(Cc1sccc1C)C',\n", + " 'O=C(N1CCN(CC1)C(=O)C1CCCO1)Nc1onc(c1)c1cccc2c1OCCO2',\n", + " 'O=C(N(C1CC1)Cc1ccccc1F)Cn1nnc(n1)c1ccccc1C',\n", + " 'Cc1cc(C)n2c(n1)nc(n2)C(=O)OCC(=O)c1cc(n(c1C)C)C',\n", + " 'O=C1Nc2c(C1)cc(cc2)S(=O)(=O)Nc1cc2OCOc2cc1Cl',\n", + " 'CCCCCn1c(=O)n(C)c2c(c1=O)n1cc(n(c1n2)CCO)C',\n", + " 'COc1ccccc1c1noc(n1)COC(=O)c1ccccc1Oc1ccccc1',\n", + " 'COC(=O)C(C(C(F)(F)F)(c1nccn1C)O)(COC(=O)c1cccc(c1)Cl)O',\n", + " 'O=C(C1CCN(CC1)C(=O)C(C)(C)C)Nc1sc2c(n1)c(C)cc(c2)C',\n", + " 'CCOC(=O)NNC(=O)c1cc(OC)c(c(c1[N+](=O)[O-])OC)OC',\n", + " 'CCNC(=O)Nc1ccc(cc1)S(=O)(=O)Nc1nc(C)cc(n1)C',\n", + " 'O=C(Nc1cc(ccc1n1cncn1)C(F)(F)F)CN1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'CC(c1onc(n1)CSc1nnc(n1C1CC1)N1CCCC1)(C)C',\n", + " 'O=C(N(c1ccccc1)C1CCCCC1)CSc1nnnn1C1CC1',\n", + " 'O=C(Nc1cccc(c1)S(=O)(=O)N1CCCC1)CNc1ccccc1C(=O)Nc1ccccc1',\n", + " 'COc1ccc(cc1)NC(=O)c1ccccc1NC(=O)CN1CCCC1c1cccs1',\n", + " 'COc1cc2c(cc1OC)ncn(c2=O)CC(=O)Nc1noc(c1)C',\n", + " 'O=C(C(c1ccccc1)c1ccccc1)Nc1nnc(s1)C1CC1',\n", + " 'Clc1cccc(c1)Cn1nccc1NC(=O)c1cccc(c1)S(=O)(=O)N1CCCC1',\n", + " 'CC(C(=O)NC1(CCCCC1)C#N)Sc1ccc(cc1)NC(=O)C',\n", + " 'CC(=O)Nc1ccc(cc1)NC(=O)C(NC1CCCCC1C)C',\n", + " 'CC(c1nnc(o1)c1cccs1)Sc1nnc(n1C)c1ccoc1C',\n", + " 'O=C(c1cc(ccc1N1CCCC1)S(=O)(=O)N1CCOCC1)NCc1ccco1',\n", + " 'Fc1ccc(cc1)C(=O)NC(C(=O)NC1CCS(=O)(=O)C1)Cc1c[nH]c2c1cccc2',\n", + " 'C=CCn1c(SCC(=O)NC2(C)CCS(=O)(=O)C2)nc2c1cccc2',\n", + " 'COc1ccc2c(c1)ccc(c2)CNC(=O)C1CCC1',\n", + " 'CC1OC(C)CN(C1)S(=O)(=O)c1ccc(cc1)C(=O)N1CCC(CC1)C(=O)N1CCCCCC1',\n", + " 'COc1ccc(cc1)C(=O)C(n1cnc2c1c(=O)n(C)c(=O)n2C)C',\n", + " 'CN1CCN(CC1)c1ccc(cc1)NC(=O)C1CCCCC1',\n", + " 'O=C(Nc1ccc(cc1)N1CCCS1(=O)=O)CC1C=CCC1',\n", + " 'CCOc1cc2CC(Oc2cc1NC(=O)c1ccc2c(c1)OCO2)C',\n", + " 'CC(C(=O)N(c1ccccc1)C)N1CCN(CC1)c1ccccc1',\n", + " 'CCc1ccc(cc1)CN(C(c1ccccc1)C(=O)NC1CC1)C',\n", + " 'O=C(Nc1cc(Cl)ccc1Sc1nncn1C)Cc1cccs1',\n", + " 'O=C(CCc1nc2c(s1)cccc2)NCc1ccc2c(c1)OCO2',\n", + " 'Clc1ccc(c(c1)C(=O)N)OCc1cc(=O)oc2c1cc(C)c(c2)C',\n", + " 'O=C(N1CCCC(C1)c1nc2c(s1)cccc2)Cn1c(C)cc2c1cccc2',\n", + " 'O=C(c1cccnc1Oc1ccccc1)Nc1ccnn1C1CCCC1',\n", + " 'CC(c1nnc(o1)c1ccccc1)Sc1nnc(o1)c1ccco1',\n", + " 'COc1ccc(cc1)c1csc(n1)NC(=O)COc1noc(c1)C',\n", + " 'CC(=O)NCCc1ccc(s1)C(=O)CSc1nnc(o1)c1ccoc1C',\n", + " 'CC(N(C(=O)C1CC(=O)N(C1)C1CCCC1)Cc1nnc(o1)c1ccccc1Cl)C',\n", + " 'C=CCN(C(=O)c1cccnc1OCC)c1scc(n1)c1ccccc1',\n", + " 'CC(CC(C(=O)N)NS(=O)(=O)c1ccc(cc1)C)C',\n", + " 'O=C(C1CC(=O)N(C1)Cc1ccco1)Nc1cccc(c1)c1csc(n1)C',\n", + " 'CCC1(NC(=O)N(C1=O)CC(=O)NC1CCCC(C1C)C)c1ccc(cc1)Cl',\n", + " 'Brc1ccc(cc1)SCC(=O)c1ccc(cc1)S(=O)(=O)N1CCCC1',\n", + " 'O=C(CN1C(=O)C(=O)N(C1=O)Cc1ccccc1)NCCc1ccccc1',\n", + " 'O=C(COC(=O)c1cc2c([nH]1)cccc2)NCCc1cccs1',\n", + " 'COc1ccc(cc1C1CCCN1C(=O)Nc1ccc(cc1F)F)OC',\n", + " 'CC(=O)Nc1ccc(cc1)CNC(=O)c1cccc2c1cccc2',\n", + " 'OCCC1CCCCN1CC(COC(c1ccc(cc1)Cl)C)O',\n", + " 'CC1CC(C)CN(C1)C(=O)C(Cc1c[nH]c2c1cccc2)NC(=O)N',\n", + " 'COC(=O)c1c(C)[nH]c(c1C)C(=O)NCc1ccc(c(c1)C)F',\n", + " 'O=C(N1CCN(CC1)c1ccccc1)CN1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'CCCCOc1cccc(c1)CNC(=O)c1ccccn1',\n", + " 'O=C(NC1CC1)CSc1ccccc1C(=O)Nc1cccc(c1)c1nc2c([nH]1)cccc2',\n", + " 'O=C(N1CCNC1=O)COC(=O)c1sc2c(c1C)c(F)ccc2',\n", + " 'COCC(=O)NC(c1nccn1C)c1cc(OC)cc(c1)OC',\n", + " 'CC(C(=O)NC1(CCCCC1)C#N)OC(=O)c1csc(n1)NCc1ccccc1',\n", + " 'O=C(c1cccc(c1)S(=O)(=O)Nc1ccc2c(c1)OCO2)N1CCN(CC1)C(=O)c1cccs1',\n", + " 'Clc1ccc(cc1)C(=O)c1ccccc1C(=O)OC(c1nc2ccccc2c(=O)[nH]1)C',\n", + " 'CC(C(=O)c1ccccc1)OC(=O)c1ccc2c(c1)C(=O)N(C2=O)Cc1ccco1',\n", + " 'O=C(c1ccccc1c1ncc(o1)c1ccccc1)NC1=NCCS1',\n", + " 'Cc1ccccc1c1noc(n1)CSc1nnnn1C1CCCC1',\n", + " 'Cc1ccc(c(c1)C(=O)CSc1nnc2n1CCCCC2)C',\n", + " 'O=C(Cn1ccccc1=O)NC(C12CC3CC(C2)CC(C1)C3)C',\n", + " 'Cc1ccccc1n1nnnc1SCc1coc(n1)c1ccccc1',\n", + " 'CC1OC(C)CN(C1)C(c1nc(N)nc(n1)Nc1ccccc1)C',\n", + " 'O=C(Nc1cccc(c1)C(=O)C)COC(=O)c1cscc1',\n", + " 'O=c1n(nnn1c1ccccc1Cl)Cc1nc(N)c2c(n1)cccc2',\n", + " 'Cc1cccc2n1c(=O)cc(n2)CSc1nnc(o1)c1cccc(c1)S(=O)(=O)N1CCOCC1',\n", + " 'COc1c(Cl)cc(cc1OC)C(=O)N1CCSc2c1cccc2',\n", + " 'O=C(Nc1cccc(c1)C(F)(F)F)CN1CCN(CC1)C(=O)C',\n", + " 'O=C(N1CCCC1)C1CCN(CC1)C(=O)c1occc1COc1ccccc1',\n", + " 'CC(=O)Nc1cccc(c1)C(=O)NCCN(C(C)C)C(C)C',\n", + " 'CCONC(=O)CCCCCn1c(S)nc2c(c1=O)cccc2',\n", + " 'COC(=O)c1ccc(cc1)C(=O)Nc1ccc2c(c1)OCCO2',\n", + " 'CC(=O)Nc1cccc(c1)C(=O)Nc1ccccc1c1ccccc1',\n", + " 'CCOC(=O)c1cccc(c1)OCC(CN1CCOCC1)O',\n", + " 'COc1cc(SC)ccc1C(=O)OCC(=O)c1ccccc1',\n", + " 'CN(C(c1ccccc1)CNC(=O)c1ccc(cc1Br)F)C',\n", + " 'COc1cc(ccc1OCC(=O)N1CCOCC1)C1Nc2ccccc2C(=O)N1CC1CCCO1',\n", + " 'O=C1NCCN(C1)c1ncnc2c1c(cs2)c1ccc(cc1)C',\n", + " 'CCCCn1c(=O)[nH]c(=O)c2c1nc(n2C)CNc1cc(F)ccc1C(=O)OCc1nc2c(n1C)c(=O)[nH]c(=O)n2CCCC',\n", + " 'O=C(N1CCN(CC1)c1ncccn1)COc1ccc(cc1)c1nnco1',\n", + " 'O=C(N1CCCC1c1nc2c(s1)cccc2)C=Cc1ccc(cc1)S(=O)(=O)N1CCOCC1',\n", + " 'CCC1(NC(=O)N(C1=O)CC(=O)NC1CCCCCC1)c1ccc(cc1)F',\n", + " 'CCN(c1c(=O)[nH]c(=O)n(c1N)Cc1ccccc1)C(=O)C1OC(=O)c2c(C1)cccc2',\n", + " 'CCCCCCNCC(=O)NCC1CCCCC1',\n", + " 'CCOc1ccccc1CN1C(=O)NC2(C1=O)CCC(CC2)C',\n", + " 'COc1cccc(c1)CN(CC(=O)Nc1cccc(c1)Cl)C',\n", + " 'O=C(c1cc(ccc1Br)S(=O)(=O)N)NC1CCCC1',\n", + " 'CCOc1ccc(nn1)n1ncc(c1C)C(=O)NC1CCCCCC1',\n", + " 'O=C(N1CCN(CC1)CC(=O)N1CCOCC1)CCC(=O)c1ccc(cc1)c1ccccc1',\n", + " 'CCCc1ccc(cc1)S(=O)(=O)NC1CCN(CC1)CC',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCO2)c1csc(n1)c1ccccc1',\n", + " 'CN(Cc1sccc1C)CC(=O)NCc1ccc(cc1)F',\n", + " 'COc1ccc(cc1C(=O)N1CCN(CC1)Cc1cscc1)S(=O)(=O)N1CCCCCC1',\n", + " 'CCCCCC(Nc1ncnc2c1c1CCCc1s2)C',\n", + " 'CCC1(NC(=O)N(C1=O)C(c1ccccc1Cl)C)c1ccccc1',\n", + " 'O=C(Nc1ccccc1C(=O)c1ccccc1)CSc1nnnn1C1CC1',\n", + " 'CCc1cccc(c1NC(=O)C(C(C)C)NC(=O)C)C',\n", + " 'OCCc1ccc(c(c1)n1nc2c(n1)cccc2)OCC(=O)N1CCN(CC1)c1ccc(cc1)OC',\n", + " 'OCCSc1ncnc2c1sc(c2)c1ccc(cc1)Cl',\n", + " 'c1cnc(nc1)N1CCN(CC1)Cc1ccc2c(c1)OCO2',\n", + " 'COCCn1c(C)cc(c1C)C(=O)CSc1nnc([nH]1)c1cccs1',\n", + " 'Cc1ccc(c(c1)O)C(=O)OC(C(=O)Nc1ccccc1c1ccccc1)C',\n", + " 'O=c1oc2cc(ccc2c2c1CCCCC2)Oc1ncccn1',\n", + " 'O=C(Nc1ccc2c(c1)OCO2)CSc1nnc(n1c1ccccc1)C1CC1',\n", + " 'Cc1ccc(c(c1)NC(=O)c1nc2n(n1)c(C)cc(n2)C)F',\n", + " 'CC1CC(C)(C)CC2(C1)NC(=O)N(C2=O)CC(=O)Nc1ncccc1C',\n", + " 'COc1ccc(cc1c1ccc(cc1)OC)NC1CCCCNC1=O',\n", + " 'COc1cccc(c1O)C=C1C(=O)Nc2c1cc(Cl)cc2',\n", + " 'CC(CC1NC(=O)N(C1=O)CCCOc1ccccc1)C',\n", + " 'COc1c(cccc1OC)CN(C(=O)c1ccc(s1)Br)C',\n", + " 'O=C(Nc1ccccc1Cl)COC(=O)c1ccc2c(c1)OCO2',\n", + " 'O=C(c1noc(c1)c1cccs1)Nc1cccc(c1C)C',\n", + " 'COc1cccc(c1)N1CC(CC1=O)C(=O)N(Cc1cnn(c1)Cc1ccccc1)C',\n", + " 'O=C(CN1CCSC1=O)NCc1cn(nc1c1ccccc1)c1ccccc1',\n", + " 'FC(Oc1cccc(c1)C(=O)NCc1ccccc1S(=O)(=O)N1CCOCC1)F',\n", + " 'O=C(C(c1ccccc1)Sc1ccccc1Cl)NC1CC1',\n", + " 'O=C(N(Cc1ccccc1)Cc1ccccc1)COC(=O)c1cccn1C',\n", + " 'N#CCC(=O)N1CCN(CC1)C(c1ccccc1)c1ccccc1',\n", + " 'O=C(N1CCN(CC1)S(=O)(=O)Cc1ccccc1)CN1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'CCOc1ccccc1NC(=O)CC1(CCCCC1)C(=O)O',\n", + " 'CC(C(C(=O)N)Sc1nnc(o1)c1ccccc1Br)C',\n", + " 'Cc1cnc(cn1)C(=O)OCc1ccc(cc1)c1ccccc1',\n", + " 'O=C(c1cccnc1Sc1ccccc1)Nc1ccnn1Cc1cccs1',\n", + " 'O=C(NCc1c(C)nn(c1C)c1ccccc1)CSc1nccn1c1ccccc1C',\n", + " 'CCC(NC(=O)CN1C(=O)NC(C1=O)(C)c1ccc2c(c1)OCO2)(C)C',\n", + " 'O=C(c1cc2c([nH]1)cccc2)OCCOc1ccccc1F',\n", + " 'CN(C(=O)CN1C(=O)NC2(C1=O)CCCC2)c1ccccc1',\n", + " 'CCOc1ccccc1NC(=O)C=Cc1cccc(c1)F',\n", + " 'COCC(NCC(COc1ccc(cc1)Br)O)C',\n", + " 'O=C([C@@H](NC(=O)c1cccs1)Cc1ccccc1)Nc1scc(n1)C',\n", + " 'COC(=O)C1=C(C)NC(=S)NC1c1ccccc1Br',\n", + " 'O=C1CN(C(=O)N1CCCC(=O)N1CCCC1c1nc2c(s1)cccc2)C',\n", + " 'O=C(N(C1CC1)Cc1ccccc1F)Cn1nnn(c1=O)c1ccccc1',\n", + " 'O=C(CSc1ccccc1C(=O)Nc1ccc(cc1)c1nccs1)NCC1CCCCC1',\n", + " 'Cc1ccc(cc1)Cn1c(=O)c2cccc3c2c(c1=O)ccc3',\n", + " 'CCN(C(=O)CN1C(=O)NC(C1=O)(C)c1ccc(c(c1)Cl)Cl)CC',\n", + " 'CCOc1ccc(cc1)S(=O)(=O)N1CCNC(=O)C1',\n", + " 'O=C(N1CCN(CC1)S(=O)(=O)Cc1ccccc1)COc1ccccc1C(=O)Nc1ccccc1',\n", + " 'O=C(N(C(c1ccc(cc1)n1cncn1)C)C)C(c1ccccc1)Sc1ccccc1',\n", + " 'O=C(C1(CCCC1)c1ccc(cc1)Cl)OCC(=O)NC1CCCC1',\n", + " 'CCOc1ccc(cc1)c1nnc(o1)SCC(=O)N1CCCC1c1ccc2c(c1)OCCO2',\n", + " 'Fc1ccc(cc1)C(=O)Nc1cc2OCCOc2cc1Br',\n", + " 'O=C(Nc1ccc(nc1)N1CCOCC1)CCCNC(=O)C12CC3CC(C2)CC(C1)C3',\n", + " 'CCOc1cc(cc(c1OC)Br)C=C1C(=O)N(c2c1cccc2)C',\n", + " 'CC1CCC(CC1)NC(=O)c1cc2cnn(c2nc1C)C(C)C',\n", + " 'CCOC(=O)c1c(NC(=O)N2CCN(CC2)c2ncccn2)sc(c1C)C',\n", + " 'CCCN(C(=O)CN1CCN(CC1)C(=O)c1ccccc1)Cc1nnc(o1)c1cccs1',\n", + " 'O=C(CN1C(=O)C(C)Oc2c1cccc2)NC(c1ccccc1)C1CC1',\n", + " 'CC(=O)c1ccc(cc1)OC(=O)c1ccccc1OCC1CCCO1',\n", + " 'CCCCCCNC1=NS(=O)(=O)c2c1cccc2',\n", + " 'CCOc1cc(ccc1OCC(=O)N1CCOCC1)C(=O)N=c1sccn1Cc1ccccc1',\n", + " 'Cc1cccc(c1)N(C(=O)CN1CCCC1c1nnc2n1cccc2)Cc1ccccc1',\n", + " 'COc1ccc(cc1)CN(CC(COc1ccc(cc1)C#N)O)C',\n", + " 'O=C(c1ccc(c(c1)N1CCCC1=O)Cl)Nc1sc2c(n1)CCC2',\n", + " 'COc1ccc(cc1)C(=O)N1CCCC1C(=O)NC1CC1',\n", + " 'O=C(NC1CCCCCC1)CSc1ncnc2c1cccc2',\n", + " 'COc1ccc(cc1)c1nn(cc1CSc1nnnn1CC1CCCO1)c1ccccc1',\n", + " 'CN(C(=O)c1ccc(cc1)S(=O)(=O)NCC1CCCO1)Cc1cnn(c1)Cc1ccccc1',\n", + " 'O=S(=O)(c1ccc(nc1)Sc1nc2c(n1c1ccccc1)CCCC2)N1CCOCC1',\n", + " 'CN1CCCN(CC1)C(=O)C(NC(=O)C(c1ccccc1)c1ccccc1)Cc1ccccc1',\n", + " 'O=C(Nc1c(C)cc(cc1C)C)CN(C(=O)CCC(=O)c1ccc(cc1)Br)C',\n", + " 'O=C1CCCN1Cc1cccc(c1)C(=O)N1CCN(CC1)c1ncccn1',\n", + " 'O=C(Nc1ccccc1c1ccccc1)COC(=O)[C@@H]1CCCN1S(=O)(=O)c1ccccc1F',\n", + " 'CCc1ccccc1n1c(SCC(=O)Nc2ccnn2C2CCCC2)nnc1N1CCOCC1',\n", + " 'O=C(Nc1cc(nn1c1ccccc1)C)CN1CCCC1c1ccc2c(c1)OCCCO2',\n", + " 'CCOc1ccc(cc1)CN1CCN(CC1)C(=O)c1ccc(cc1)CNC(=O)C',\n", + " 'COc1cn(nc1C(=O)OCc1onc(n1)c1cccs1)c1ccccc1',\n", + " 'O=C(C1CCS(=O)(=O)C1)NC1CCSc2c1cc(Cl)cc2',\n", + " 'Cc1ccc(cc1)Oc1ccccc1NC(=O)c1cccc(c1)N1CCCS1(=O)=O',\n", + " 'COCCCNCC(COc1ccc(cc1)C)O',\n", + " 'COc1ccccc1N1CCN(CC1)C(=O)CSc1nnc(n1C1CC1)c1cccnc1',\n", + " 'CC(CCn1cnc2c1c(=O)n(CC(=O)N1CCCCCC1)c(=O)n2Cc1ccccc1)C',\n", + " 'O=C(NC1=NCCS1)Cc1ccc(c(c1)Cl)Cl',\n", + " 'CC(NC(=O)C(N1CCN(CC1)Cc1cccc(c1)Cl)C)C',\n", + " 'O=C(Nc1c(=O)n(n(c1C)C)c1ccccc1)COc1ccccc1C(=O)Nc1ccccc1',\n", + " 'CC(C(=O)N1CCN(CC1)Cc1ccccc1)Sc1nnc(n1c1ccccc1)C1CC1',\n", + " 'CCCCNC(=O)COC(=O)c1oc2c(c1C)cc(cc2)OC',\n", + " 'Cc1ccc2n(c1)c(CSc1nnc(n1c1ccccn1)CN1CCCC1=O)c(n2)c1ccccc1',\n", + " 'O=C(Nc1c(C)cccc1C)CNC(=O)C(N1CCCCC1)C',\n", + " 'COc1cc(ccc1OC(F)F)C(=O)NCc1ccc(cc1)C',\n", + " 'O=C(N1CCCC1=O)CSc1nnc(s1)Nc1ccccc1',\n", + " 'CNS(=O)(=O)c1cccc(c1)S(=O)(=O)N(C)C',\n", + " 'COc1ccc(cc1)NS(=O)(=O)c1cccc(c1)C(=O)N(C1CC1)Cc1ccc(cc1)F',\n", + " 'O=C(N1CCCCCC1)Cn1c(nc2c1cccc2)C1CN(C(=O)C1)c1c(C)cccc1C',\n", + " 'O=C(N(C1CCCC1)Cc1ccc2c(c1)OCO2)c1ccncc1',\n", + " 'CN(C(=O)c1cn(nc1c1cccnc1)c1ccccc1)Cc1ccc(cc1)N1CCOCC1',\n", + " 'COc1ccc2c(c1)cc(c(=O)o2)C(=O)OC1CCCCC1',\n", + " 'Fc1ccc(cc1)c1noc(n1)CN1CCCC1c1cccs1',\n", + " 'CN1CCCN(CC1)C(=O)c1cc(nc2c1cccc2)c1cccc2c1cccc2',\n", + " 'Cc1ccc(c(c1)C(=O)NCCc1ccccc1)O',\n", + " 'C=CCN(C(=O)c1ccc(cc1)I)CC=C',\n", + " 'O=c1cc(C)n2c([nH]1)nnc2c1ccc2c(c1)OCO2',\n", + " 'O=C(N1CCCC1C(=O)Nc1ccccc1)NCc1ccccc1',\n", + " 'COc1cc(N)c(cc1C(=O)OCC(=O)NC1CCCCCC1)Cl',\n", + " 'CC(=O)Nc1ccc(cc1)C(=O)CSc1cccc(c1)C(F)(F)F',\n", + " 'O=C1CCCN1c1ccc(cc1)C(=O)OCC(=O)c1cc(C)c(cc1C)C',\n", + " 'O=C(C1COc2c(O1)cccc2)N1CCN(CC1)C(=O)c1c(C)nn(c1Cl)c1ccccc1',\n", + " 'CC1CCN(CC1)S(=O)(=O)c1ccc(cc1)C(=O)NC1CC1',\n", + " 'COc1ccc(cc1)C(c1ccc(cc1)OC)OCC(CN(C1CCCCC1)C)O',\n", + " 'O=C(NCc1ccc(cc1)F)CNC(=O)c1ccccc1Br',\n", + " 'O=C(Nc1ccc(cc1Cl)F)CN1C(=O)NC2(C1=O)CCCC2',\n", + " 'O=C(c1nn(cc1C1SCC(=O)N1Cc1ccccc1)c1ccccc1)c1ccccc1',\n", + " 'O1CCN(CC1)Cc1nc(Sc2nc3c([nH]2)cccc3)c2c(n1)scc2c1ccccc1',\n", + " 'CC(=O)NCCNC(=O)c1cc(C)cc(c1)C',\n", + " 'O=C(c1cc(n(c1C)CC1COc2c(O1)cccc2)C)Cn1cnc2c(c1=O)scc2',\n", + " 'O=C(N1CCN(CC1)C(=O)c1ccco1)COc1ncnc2c1cccc2',\n", + " 'COc1ccc(cc1S(=O)(=O)N1CCOCC1)C(=O)N1CCN(CC1)c1ncccn1',\n", + " 'O=C(c1cc(c(cc1Cl)Cl)S(=O)(=O)N1CCOCC1)Nc1ccccc1c1ccccc1',\n", + " 'Brc1ccc2c(c1)C(=Cc1ccc3c(c1)OCCO3)C(=O)N2C',\n", + " 'CCc1ccc(cc1)CN(C(=O)c1c(C)nn(c1C)Cc1ccccc1)Cc1cccnc1',\n", + " 'O=C(Nc1nc(C)c(cc1Cl)Cl)COC(=O)c1sccc1C',\n", + " 'CN1CCN(CC1)c1ccc(cc1)NC(=O)c1csc2c1CCCC2',\n", + " 'COc1ccc(cc1S(=O)(=O)N(C)C)C(=O)Nc1cc(Cl)ccc1N1CCCC1',\n", + " 'COc1ccc(cc1)N(C(=O)c1cccc(c1)S(=O)(=O)N1CCOCC1)Cc1cccs1',\n", + " 'CC(CN(c1c(=O)[nH]c(=O)n(c1N)CC(C)C)C(=O)CN(C(=O)c1sccc1C)C)C',\n", + " 'COc1ccc(cc1)CNC(=O)CN1C(=O)NC(C1=O)(C)c1ccc(cc1)C',\n", + " 'CC(CCn1cnc2c1c(=O)n(CC(=O)NC(C)C)c(=O)n2Cc1ccccc1)C',\n", + " 'COCCn1cnc2c1c(=O)n(CC(=O)Nc1ccccc1C)c(=O)n2CC(C)C',\n", + " 'COc1ccc(cc1)C(c1c[nH]c2c1cccc2)CNC(=O)CN1C(=O)NC(C1=O)(C)C',\n", + " 'COc1cc(ccc1OC)C(=O)NCc1ccc(cc1)CN1CCOCC1',\n", + " 'Cc1sc(c(c1)c1cc(C(=O)N2CCOCC2)c2c(n1)n(nc2)C(C)C)C',\n", + " 'O=C(NC1CCCc2c1cccc2)CN1C(=O)NC2(C1=O)CC(C)CC(C2)(C)C',\n", + " 'O=C(c1cc(Br)ccc1O)NC1CCCC1',\n", + " 'O=C(C(Sc1nnc(o1)c1ccccc1Br)C)Nc1ccc(cc1)C(=O)C',\n", + " 'N#CC(Sc1ncnc2c1c(cs2)c1ccc(cc1)C)C',\n", + " 'CSc1ccc(cc1)CN(Cn1nc(n(c1=S)C)c1cccs1)C',\n", + " 'O=C(Nc1ccccc1Oc1ccccc1)CSc1nncn1c1ccccc1',\n", + " 'Oc1ccc(cc1)c1ccc(cc1)C(=O)OCC(=O)c1ccc[nH]1',\n", + " 'O=C(c1ccc(c(c1)S(=O)(=O)N1CCOCC1)C)OCc1ccc(cc1)n1cccn1',\n", + " 'Clc1ccc(cc1)c1nn(cc1CC(=O)N1CCN(CC1)C(=O)C)c1ccccc1',\n", + " 'COc1ccc(cc1)CNC(=O)CSc1nnc(o1)c1ccccc1Br',\n", + " 'O=C(Nc1ccc(c(c1)Cl)C)CNC(=O)c1ccc(cc1)C',\n", + " 'CCCCOc1ccc(cc1)C(=O)N(c1ccc(cc1)Cl)C1C=CS(=O)(=O)C1',\n", + " 'O=C(N1CCN(CC1)c1ccccn1)CSc1nnc(o1)c1ccc2c(c1)OCO2',\n", + " 'O=C(NC1CCSc2c1cccc2)CCc1ccsc1',\n", + " 'CCCOc1ccc2c(c1)OCC(=C2)C(=O)O',\n", + " 'Clc1ccc(cc1)c1noc(n1)CN1CC(Oc2c1cccc2)C(=O)N1CCOCC1',\n", + " 'CC(NC(=O)CN1C(=O)NC(C1=O)(C)c1ccc2c(c1)cccc2)CCc1ccccc1',\n", + " 'CCOc1ccc(cc1)C(=O)C1=C(O)C(=O)N(C1c1ccc(cc1)OCC)CCN1CCOCC1',\n", + " 'COc1ccc(cc1)C(N1CCCCC1)CNC(=O)c1coc2c(c1=O)cccc2',\n", + " 'O=c1n(nnn1c1ccccc1)Cc1coc(n1)c1ccccc1',\n", + " 'Cc1ccc(o1)CN(C(=O)CSc1nnc(n1Cc1ccccc1)c1cccnc1)C',\n", + " 'CCN(CCNC(=O)c1ccc(cc1)NC(=O)CC1CCCC1)CC',\n", + " 'COc1ccc(cc1OC)CNC(=O)CSc1nnc(n1c1ccccc1C)c1ccncc1',\n", + " 'O=C(c1c(Cl)cccc1Cl)NC1CCOc2c1cccc2',\n", + " 'COc1ccc(cc1)N(S(=O)(=O)c1cc(C)ccc1C)Cc1noc(c1)c1ccco1',\n", + " 'O=C(N(Cc1nc2ccccc2c(=O)[nH]1)CC1CCCO1)CCOc1ccccc1c1ccccc1',\n", + " 'O=C(c1ccc2c(c1)S(=O)(=O)N=C1N2CCCCC1)NCC1CCCO1',\n", + " 'CCC(=O)N(c1nnc(s1)SCCCc1onc(n1)c1ccc(cc1)Cl)C1CC1',\n", + " 'O=C1N(Cc2ccc3c(c2)OCO3)C(Nc2c1cccc2)c1ccc(cc1)n1ccnc1',\n", + " 'CCCCCNC(=O)[C@H](Cc1c[nH]c2c1cccc2)NC(=O)c1ccc(cc1)F',\n", + " 'COc1ccccc1c1nn(cc1C(=O)NC1=NCCS1)Cc1ccccc1',\n", + " 'Clc1ccc(cc1)c1nn(cc1CN(C(=O)C1CCS(=O)(=O)C1)C)c1ccccc1',\n", + " 'O=C(NC(C12CC3CC(C2)CC(C1)C3)C)CCNC(=O)c1cccs1',\n", + " 'Fc1ccc(cc1)CNC(=O)c1ccccc1O',\n", + " 'CCC(NCC(=O)Nc1cccc(c1)C)C',\n", + " 'O=C(c1ccccc1OCc1cccc(c1)S(=O)(=O)N1CCOCC1)Nc1ccccc1',\n", + " 'COc1ccc(cc1S(=O)(=O)N1CCOCC1)C(=O)Nc1cc(Cl)ccc1N1CCOCC1',\n", + " 'CC1CCN(CC1)C(=O)c1n[nH]c2c1cccc2',\n", + " 'O=C(c1ccc2c(c1)OCCCO2)NCCc1ccccc1',\n", + " 'CCc1ccccc1Nc1nc(CSc2nnc(o2)c2ccccc2F)nc(n1)N',\n", + " 'O=C(NC1(CCCC1)C(=O)N(Cc1ccccc1N1CCOCC1)C)NCc1ccccc1',\n", + " 'CC(NC(=O)C(N1CCN(CC1)C(=O)c1ccccc1)C)CCc1ccccc1',\n", + " 'O=C(C1CCCN(C1)C1=NS(=O)(=O)c2c1cccc2)NC(c1nccn1C)c1ccccc1',\n", + " 'O=C(N1CCCC(C1)N1CCCC1)Nc1ccccc1OCCc1ccccc1',\n", + " 'OC1CCC(CC1)Nc1nc(nc2c1cccc2)C(F)(F)F',\n", + " 'COc1cc(Cl)c(cc1NCC(=O)N(C1CCS(=O)(=O)C1)C1CCCCC1)C',\n", + " 'Cc1nnc(s1)NC(=O)c1sc(nc1C)c1cscc1',\n", + " 'O=C(c1cnc2c(n1)cccc2)Nc1ccc2c(c1)OCO2',\n", + " 'CC1CCC2(CC1)NC(=O)N(C2=O)CC(=O)NCCc1c[nH]c2c1cccc2',\n", + " 'Clc1ccc(s1)S(=O)(=O)N1CCN(CC1)S(=O)(=O)Cc1ccccc1',\n", + " 'O=C(c1ccc(cc1)c1ccccc1)COc1ccc(cc1)C(=O)N',\n", + " 'CCOC(=O)C1=C(CN(Cc2ccc(c(c2)OC)OC)C)NC(=O)NC1c1ccccc1',\n", + " 'CCc1ccc(cc1)C(NC(=O)C1CCN(CC1)C(=O)N)C',\n", + " 'COC(=O)c1c(C)[nH]c(c1C)C(=O)N1CCN(CC1)Cc1cccs1',\n", + " 'CC(c1onc(n1)CSc1nnc(n1Cc1ccccc1)N1CCOCC1)(C)C',\n", + " 'Clc1c(cn[nH]c1=O)NCc1cccnc1',\n", + " 'COCCN(c1c(=O)[nH]c(=O)n(c1N)Cc1ccccc1)C(=O)CSc1nc2sc3c(c2c(=O)n1CC1CCCO1)CCC3',\n", + " 'CC(C1NC(=O)N(C1=O)Cc1noc(c1)c1ccccc1)C',\n", + " 'O=C(Cn1cnc2c1c(=O)n(C)c(=O)n2C)Nc1ccc(cc1)c1ccccc1',\n", + " 'CCC1c2ccsc2CCN1S(=O)(=O)c1ccc(cc1F)Cl',\n", + " 'N#CC1(CCCC1)NC(=O)CN(Cc1cccc(c1)F)C',\n", + " 'O=C(NCC1(CCCCC1)N1CCOCC1)CCCn1c(=O)oc2c1cccc2',\n", + " 'O=C(N(C1CCS(=O)(=O)C1)C1CCCCC1)CNc1ccccc1OC(F)(F)F',\n", + " 'CCCCCn1c(SC(C(=O)N)C)nc2c1cccc2',\n", + " 'O=C(N1CCC(=N1)c1ccccc1)CN(C1CCCC1)Cc1ccc2c(c1)OCO2',\n", + " 'C=CCn1c(nnc1S)Cc1csc(n1)NC(=O)c1cc(C)ccc1O',\n", + " 'CC(=O)COC(=O)[C@@H]1CCCN1S(=O)(=O)c1ccc(cc1)Cl',\n", + " 'NC(=O)C1CCN(CC1)C(=O)Cc1ccc(cc1Cl)Cl',\n", + " 'Fc1ccc(c(c1)F)C1NC(=O)c2c(N1)cccc2',\n", + " 'O=C1CCCN1c1cccc(c1)NC(=O)c1ccccc1OCc1csc(n1)C',\n", + " 'O=C(c1ccoc1C)NCC1(CSCC1)N1CCOCC1',\n", + " 'CCn1c(Cn2nnc(n2)c2ccc(cc2)F)nc2c1ccc(c2)S(=O)(=O)N1CCOCC1',\n", + " 'CCCn1c2nn(c(=S)n2c2c(c1=O)cccc2)CN1CCCC1c1cccs1',\n", + " 'O=C(NC1CCCc2c1cccc2)CN1C(=O)N(C2(C1=O)CCCCC2)C',\n", + " 'CCN(C(=O)CC1Sc2ccc(cc2NC1=O)Cl)CC',\n", + " 'O=C(c1cc2c(o1)cccc2)N1CCN(CC1)Cc1ccc(cc1)C(F)(F)F',\n", + " 'O=C(N1CCCCCC1)CN1CCN(CC1)C(=O)c1cc2c(o1)cccc2',\n", + " 'O=C(CN1CCCC1c1nc2c(s1)cccc2)Nc1ccc2c(c1)OCO2',\n", + " 'O=C(Cn1nnc(n1)c1cccc(c1)C(F)(F)F)Nc1cccc(c1)C',\n", + " 'CCN(S(=O)(=O)C)c1ccc(cc1)c1csc(n1)N1CCN(CC1)C',\n", + " 'O=C(C1CCCN1S(=O)(=O)c1ccccc1F)Nc1scc(n1)c1ccccc1',\n", + " 'O=C(N1CCCC1)COC(=O)C12CC3CC(C1)CC(C2)(C3)c1ccccc1',\n", + " 'CCOc1ccccc1N1CCN(CC1)Cc1onc(n1)c1cccc(c1)Br',\n", + " 'C#CCNC(=O)N1CCC(CC1)n1c(=O)[nH]c2c1cccc2',\n", + " 'c1ccc(cc1)Nc1nnc(s1)SCc1ccccn1',\n", + " 'CSCCC(C(=O)NC1CCC(CC1)C)NC(=O)COc1ccccc1',\n", + " 'CCC(NC(=O)COC(=O)COc1ccc(cc1)Cl)C',\n", + " 'COc1ccc(c(c1)c1nn(cc1C(=O)N1CCOCC1)c1ccccc1)OC',\n", + " 'CNC(=O)C(OC(=O)c1ccc(cc1)N1CCCC1=O)C',\n", + " 'COc1ccccc1C(NC(=O)c1cc(nc2c1cccc2)c1ccccn1)C',\n", + " 'Clc1ccc(cc1)c1nnn(n1)CC(=O)N1CCN(CC1)c1ccccc1',\n", + " 'O=C(N(C1CC1)Cc1ccccc1F)C1CN(C(=O)C1)c1ccccc1Br',\n", + " 'COCCn1c(SCc2noc(c2)c2ccccc2)nnc1Cc1ccccc1',\n", + " 'CCN(S(=O)(=O)c1cccc(c1)C(=O)NCc1ccccc1F)CC',\n", + " 'Cc1ccc(cc1C)S(=O)(=O)NCC1(CCCCC1)N1CCOCC1',\n", + " 'O1CCN(CC1)c1nc(nc2c1nccn2)N1CCN(CC1)c1ccccc1',\n", + " 'O=C(N1CCc2c(C1)cccc2)COC(=O)C1=NN(C(=O)CC1)c1ccccc1',\n", + " 'CN(S(=O)(=O)c1ccccc1)c1ccc(cc1)OCc1nnc(o1)c1ccccc1',\n", + " 'N#CC(=Cc1ccco1)c1onc(n1)c1ccc(cc1)C',\n", + " 'CC(N(C(=O)CN1C(=O)NC(C1=O)(C)c1cc2c(o1)cccc2)C(C)C)C',\n", + " 'COc1cccc(c1)n1ccnc1SCC(=O)N1CCN(CC1)C(=O)c1ccco1',\n", + " 'O=C(Nc1c(C)nn(c1C)c1ccccc1)CN1CCCC1c1ccc2c(c1)OCCCO2',\n", + " 'COc1ccc(cc1NC(=O)CN1C(=O)NC(C1=O)(C)c1ccccc1Cl)C',\n", + " 'Clc1ccc(cc1)c1ccc(o1)CN(C(=O)CSc1nnc(o1)Cc1csc(n1)C)C',\n", + " 'O=C(Nc1cc(nn1c1ccc(cc1)C)C)CSc1nnnn1CC1CCCO1',\n", + " 'O=C(Nc1ccc(cc1F)c1ccccc1)CCNC(=O)c1cocc1',\n", + " 'O=C(Nc1cc(F)ccc1C)CNc1ccccc1C(=O)NCc1ccco1',\n", + " 'NC(=O)COC(=O)c1ccccc1OCc1ccccc1Cl',\n", + " 'CCn1c(=O)n(c2c1cccc2)CCC(=O)N(Cc1ccc(c(c1)Cl)Cl)C',\n", + " 'C=CCN(C(=O)c1nc(Cl)c2c(c1)cccc2)c1scc(n1)c1ccccc1',\n", + " 'CCC(NC(=O)c1cc(OC)c(c(c1)OC)OC)C',\n", + " 'CCOC(=O)c1c(NC(=O)CCNCc2ccco2)sc2c1CCC2',\n", + " 'O=C1C(=O)N(C(=O)N1Cc1ncc(o1)c1ccccc1)Cc1ccccc1',\n", + " 'CCN(S(=O)(=O)c1ccc(=O)n(c1)Cc1ccc(cc1)SC)CC',\n", + " 'O=C(CN1C(=O)NC2(C1=O)CCCCC2C)NCCc1c[nH]c2c1cccc2',\n", + " 'Oc1ccc(cc1C(=O)NCC=C)Br',\n", + " 'COc1ccc(cc1)N1CCN(CC1)C(=O)CC1Sc2ccccc2NC1=O',\n", + " 'COc1ccc(cc1)n1ccnc1SCC(=O)N1CCCC1c1cccs1',\n", + " 'COc1ccc(cc1NC(=O)CNC(=O)Cn1c(=O)cnc2c1cccc2)C',\n", + " 'COc1cc(OC)cc(c1)C(=O)NCC(=O)N1CC(C)CC(C1)C',\n", + " 'O=C(N1CCN(CC1)C(=O)c1ccccc1)C1CCN(CC1)S(=O)(=O)c1ccc2c(c1)OCCO2',\n", + " 'CN1CCN(CC1)c1scc(n1)c1ccc(cc1)C1CCCCC1',\n", + " 'CCN1CCN(CC1)C(=O)c1cc2c(s1)n(nc2C)c1ccccc1',\n", + " 'O=C(Nc1ccc(c(c1)F)F)CNC(=O)c1ccc(cc1)N(C)C',\n", + " 'COc1ccccc1CN(C(=O)c1ccc(cc1)N1CCCS1(=O)=O)C',\n", + " 'COc1ccc(cc1C1CCCN1C(=O)CSc1nnnn1C1CC1)OC',\n", + " 'Fc1cc(F)cc(c1)C(=O)OC(C(=O)N(c1nccs1)C1CCCCC1)C',\n", + " 'O=C(C1CCCN(C1)C(=O)c1cccc2c1cccc2)N1CCN(CC1)c1ncccn1',\n", + " 'COCc1ccc(cc1)C(=O)N(Cc1ccc2c(c1)OCCO2)CC',\n", + " 'COc1ccc(cc1)C=C1C(=O)Nc2c1ccc(c2)Cl',\n", + " 'O=C(c1cc(ccc1N1CCOCC1)S(=O)(=O)N1CCOCC1)Nc1ccccc1F',\n", + " 'Fc1ccc(cc1)N1CCN(CC1)C(=O)CSc1nnc(n1Cc1ccccc1)N1CCOCC1',\n", + " 'O=C(Nc1ccc(cc1)N1CCOCC1)COC(=O)c1cn(c2c1cccc2)C',\n", + " 'C=CCc1ccc(c(c1)OC)OCC(CN1CCN(CC1)C(=O)C)O',\n", + " 'O=C(NCc1ccccc1CN1CCOCC1)CCc1ccc(o1)c1ccccc1F',\n", + " 'O=C(c1ccc(cc1)CN1CCCCC1)N(Cc1cccnc1)Cc1ccco1',\n", + " 'OC(CSc1nnc2n1cc(Cl)cc2Cl)COc1ccc(cc1)c1ccccc1',\n", + " 'CCC(=O)N(c1nnc(s1)SCCOc1ccc(cc1)OC)C1CC1',\n", + " 'O=C(NC(c1ccc(cc1)Cl)C1CC1)Cc1ccc2c(c1)OCCO2',\n", + " 'O=C(C1CCCN1C(=O)c1cccs1)N1CCN(CC1)Cc1c(F)cccc1Cl',\n", + " 'COCCn1c(=O)[nH]c(=O)c(c1N)C(=O)CN1CCCc2c1ccc(c2)C',\n", + " 'CCOc1ccc(cc1)C1CCCN1C(=O)C1CCCN(C1)S(=O)(=O)c1cccs1',\n", + " 'O=C(c1ccc(nc1)Oc1ccc(cc1)c1ccccc1)NC1CC1',\n", + " 'CC(C(=O)c1c[nH]c2c1cccc2)OC(=O)c1cccc(c1)N1CCCS1(=O)=O',\n", + " 'Clc1cccc(c1)c1noc(n1)CSc1ncnc2c1cccc2',\n", + " 'CCOC(=O)C1CCN(CC1)C(=O)COC(=O)c1ccc(cc1)C',\n", + " 'COCCOC(=O)C1=C(C)NC(=S)NC1c1ccc(cc1)NC(=O)C',\n", + " 'O=C(c1nc2n(c1)cccc2)NCC1(CCCCC1)N1CCCCC1',\n", + " 'N#CCCN(C(=O)COC(=O)c1ccc2c(c1)OCO2)C',\n", + " 'O=C1NC(C(=O)N1CC(=O)C12CC3CC(C2)CC(C1)C3)(C)c1ccccc1',\n", + " 'O=C(c1nc(n(n1)c1cccc(c1)C(F)(F)F)c1ccccc1)OCC(=O)N1CCCCC1',\n", + " 'Cc1ccccc1n1c(SCC2CCCO2)nnc1c1ccncc1',\n", + " 'COC(=O)c1ccc(cc1)CNC(=O)COc1ccc(c(c1)Cl)F',\n", + " 'O=C(c1ccc2c(c1)cccc2)CN1C(=O)NC2(C1=O)CCCCC2C',\n", + " 'O=C(Cc1cccc2c1cccc2)NCC(=O)N1CCN(CC1)c1ccccc1',\n", + " 'Clc1ccc(s1)S(=O)(=O)N1CCN(CC1)C(=O)CCc1cccnc1',\n", + " 'O=C(NC(c1ccc2c(c1)OCO2)C)CCSc1ccc(c(c1)F)F',\n", + " 'O=C(N1CCN(CC1)c1ccccn1)CSc1nnnn1C1CCCC1',\n", + " 'O=C(N1CCN(CC1)c1ccccn1)C1CCN(CC1)S(=O)(=O)c1ccccc1',\n", + " 'O=S(=O)(c1ccc(nc1)SCc1ccc(cc1)n1cccn1)N1CCOCC1',\n", + " 'O=C(CN1C(=O)NC2(C1=O)CCOc1c2cccc1)NCc1ccc(o1)c1ccc(cc1)Cl',\n", + " 'CCC(NC(=O)c1cc(ccc1Br)S(=O)(=O)N(OC)C)CC',\n", + " 'O=C(CSc1cc(C)c2c(n1)cccc2)NCCCn1nc(cc1C)C',\n", + " 'COc1ccc(cc1C(=O)N1CCN(CC1)c1ccccc1C)S(=O)(=O)N1CCCCCC1',\n", + " 'COCCn1c(nc2c1c(=O)[nH]c(=O)n2CC(C)C)c1ccccn1',\n", + " 'O=C(C(NC1=NS(=O)(=O)c2c1cccc2)C)NCCCSc1ccccc1',\n", + " 'CCOc1ccc(cc1NC(=O)c1cnn(n1)c1ccccc1)OCC',\n", + " 'O=C(N1CCCC1c1cccs1)c1cccc(c1)S(=O)(=O)N1CCCC1',\n", + " 'CCOC(=O)c1c(NC(=O)CN2CC(C)CC(C2)C)oc(c1C(=O)C)C',\n", + " 'Cc1cccc(c1)NC(=O)C(=Cc1ccco1)n1nnnc1c1ccccc1',\n", + " 'N#CC1(CCCC1)NC(=O)CSc1nc2ccccc2c(=O)n1C1CC1',\n", + " 'COc1cccc(c1O)C1CC(=NN1C(=O)C)c1ccccc1NS(=O)(=O)C',\n", + " 'O=C(N(C1CCCc2c1cccc2)C)CN1C(=O)c2c(S1(=O)=O)cccc2',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCCO2)CN1C(=O)NC(C1=O)(C)c1ccco1',\n", + " 'OCCCn1c(SCc2nc3n(c2)cccc3)nc2c(c1=O)cccc2',\n", + " 'Clc1ccc(c(c1)Cl)C(=O)CSc1nnc2n1c1ccccc1s2',\n", + " 'CC(=O)N1CCN(CC1)C(=O)c1ccc(cc1)S(=O)(=O)C',\n", + " 'CCOCCOC(=O)CC1Sc2ccccc2NC1=O',\n", + " 'Cc1onc(c1)CSc1ncccc1C(=O)Nc1ccnn1C1CCCC1',\n", + " 'CCOc1c(Cl)cc(cc1OC)C(=O)NC1CCN(CC1)CC',\n", + " 'COc1ccc(c(c1)OC)C(=O)OC(C(=O)Nc1ccc(cc1)F)C',\n", + " 'Cc1cnc2c(c1)cccc2S(=O)(=O)N1CCc2c1ccc(c2)S(=O)(=O)N(C)C',\n", + " 'O=C(N1CCOCC1)CN1C(=O)NC(C1=O)(C)c1cccc2c1cccc2',\n", + " 'Fc1ccc(cc1Cl)Oc1nc(CN2CCOCC2)nc2c1c(cs2)c1cccs1',\n", + " 'O=C(C1(CCCC1)S(=O)(=O)c1ccccc1)Nc1ccc(cc1)c1nccs1',\n", + " 'COc1ccc(cc1)C(=O)N[C@H](C(=O)Nc1cccc(c1)C#N)C(C)C',\n", + " 'CC(NC(=O)Nc1ccccc1C(=O)OCC(=O)N1CCCCC1)C',\n", + " 'O=C(c1cccc(c1)S(=O)(=O)N1CCOCC1)NCc1c(C)nn(c1C)Cc1ccccc1',\n", + " 'CC(CCNC(=O)CN1C(=O)NC(C1=O)(C)c1ccc(cc1)C)C',\n", + " 'Cc1ccc(cc1)C1(C)NC(=O)N(C1=O)CC(=O)N1CCOCC1',\n", + " 'COc1ccc(cc1)C(=O)COC(=O)c1ccccc1C(=O)c1ccccc1',\n", + " 'CC1CC(C)CN(C1)C(=O)CNC(=O)c1ccc2c(c1)cccc2',\n", + " 'O=C(Nc1ccc(cc1)N1CCCC1=O)CN(C1CCCCC1)C',\n", + " 'O=C(c1ccc2c(c1)scn2)Nc1ccc(cc1)n1cnnn1',\n", + " 'CCOC(=O)Cc1csc(n1)SCc1cc(=O)n2c(n1)ccc(c2)C',\n", + " 'COc1ccc(cc1)C(=O)C1CCN(CC1)c1ccc2n(n1)nnn2',\n", + " 'CCOc1ccc(cc1)OCC(=O)Nc1ccc(cc1)OCC',\n", + " 'O=C(N(c1ccccc1)C1CCCCC1)CN1CCCC1c1nnc2n1cccc2',\n", + " 'COc1cc(ccc1OC)c1csc2c1c(nc(n2)C)Sc1nnnn1CC1CCCO1',\n", + " 'FC(Oc1ccccc1C(=O)N1CCN(CC1)C(=O)c1nc2n(n1)c(C)ccn2)F',\n", + " 'COc1ccccc1N(S(=O)(=O)c1ccc(cc1)C(=O)N1CCN(CC1)CC(C)C)C',\n", + " 'O=C(c1c[nH]nc1c1ccc2c(c1)OCCO2)NC1CCCCCC1',\n", + " 'O=C(C(c1ccccc1)N1CCN(CC1)S(=O)(=O)c1ccc2c(c1)OCCO2)Nc1ccc(cc1)F',\n", + " 'O=C(N1CCOCC1)CN1C(=O)NC2(C1=O)CCCc1c2cccc1',\n", + " 'Cc1ccc(cc1)S(=O)(=O)Nc1ccc2c(c1)c1C(=O)CCCc1o2',\n", + " 'O=C(c1cccc(c1)N1CCCS1(=O)=O)OCc1ccccc1F',\n", + " 'O=C(C1CC(=O)N(C1)c1ccc2c(c1)OCCO2)Nc1cccc(c1)S(=O)(=O)N1CCOCC1',\n", + " 'O=C(C(c1ccccc1)Sc1nnc(o1)c1cccs1)N1CCCC1',\n", + " 'O=C(C1CCCN1C(=O)c1cccs1)NC(c1ccc(cc1)n1cncc1)C',\n", + " 'Clc1ccc(s1)CN(C(=O)Cn1cnc2c(c1=O)cnn2c1ccccc1)C',\n", + " 'O=C(N1CCCC1c1ccc2c(c1)OCCO2)c1ccc2c(c1)OCO2',\n", + " 'O=C(c1cccn1C)CSc1nnc(n1c1ccccc1)c1ccco1',\n", + " 'CCN(S(=O)(=O)c1cc(NC(=O)c2cccs2)c(c(c1)C)C)CC',\n", + " 'CCOc1ccccc1N1CCN(CC1)c1nnnn1c1ccccc1',\n", + " 'O=C(Cc1ccc(cc1)c1ccccc1)NCC1COCC1',\n", + " 'CCCN(C(=O)c1cccc(c1)OC)Cc1nnc(o1)c1ccco1',\n", + " 'O=C(c1ccc(c(c1)S(=O)(=O)N1CCCCC1)N1CCCCC1)N1CCC(CC1)C(=O)N1CCCCC1',\n", + " 'CN(c1ccccc1)CCNC(=O)c1cnc2n(c1=O)cccc2',\n", + " 'N#Cc1cccc(c1)S(=O)(=O)N1CCCC1c1nc2c(s1)cccc2',\n", + " 'Cc1cccc(c1)c1nnc(n1C)SCC(=O)N1CCC(=N1)c1ccccc1',\n", + " 'COCCn1c(SCc2cn3c(n2)c(C)ccc3)nc2c(c1=O)cccc2',\n", + " 'CN(C(=O)c1ccc(cc1)S(=O)(=O)N(C1CCCCC1)C)Cc1ccccc1N1CCOCC1',\n", + " 'COc1cc2CN(CCc2cc1OC)CC(=O)Nc1ccc(cc1)N1CCCCC1',\n", + " 'CN(Cc1cc(=O)n2c(n1)ccc(c2)Br)Cc1ccccc1',\n", + " 'COc1cc(ccc1OCC(=O)N1CCOCC1)C(=O)OCC(=O)Nc1ccc(c(c1)Cl)Cl',\n", + " 'O=C(c1sc(c(c1)Br)Br)NCCc1ccc2c(c1)OCCO2',\n", + " 'O=C1COc2c(N1)ccc(c2)C(=O)Nc1ccc2c(c1)nc(o2)C',\n", + " 'CCCc1nc2ccccc2c(c1CC)C(=O)O',\n", + " 'COc1cc(ccc1OC)CN(C(=O)CSc1scc(n1)C)C',\n", + " 'O=C(N1CCCC1)CCc1c[nH]c2c1cccc2',\n", + " ...],\n", + " 'precursor_positive': [tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " ...],\n", + " 'ring_counts': [tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(1),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(6),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(6),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(6),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(6),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(6),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(6),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(6),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(6),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(6),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(6),\n", + " tensor(1),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(6),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(6),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(1),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(1),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(5),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(5),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(5),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(4),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(3),\n", + " tensor(4),\n", + " tensor(2),\n", + " tensor(2),\n", + " tensor(3),\n", + " ...],\n", + " 'presence_rare_elements': [tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(True),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " tensor(False),\n", + " ...]}" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_stats_fiora" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot ring_count vs. Residual (Fiora)\n", + "\n", + "ring_counts = [tensor.item() for tensor in test_stats_fiora[\"ring_counts\"]]\n", + "\n", + "predictions = test_stats_fiora[\"predictions\"].flatten()\n", + "targets = test_stats_fiora[\"targets\"].flatten()\n", + "residuals = np.abs(predictions - targets)\n", + "\n", + "ring_count_res_df = pd.DataFrame({'Ring Count': ring_counts, 'Residuals': residuals})\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "sns.boxplot(x='Ring Count', y='Residuals', data=ring_count_res_df)\n", + "\n", + "plt.xlabel(\"Ring Counts\")\n", + "plt.ylabel(\"Residuals\")\n", + "plt.title(\"Boxplot of Residuals vs. Ring Counts\")\n", + "\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "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", + "
predictionstargetssmilesprecursor_positivering_countspresence_rare_elementsrare_element_includedresidualsrare_element_countMetaboliteWeightMSE
0216.163742215.240005Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc...True5FalseFalse0.9237370<Metabolite: Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2...479.1085820.853289
1212.879791210.649994COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1True4FalseFalse2.2297970<Metabolite: COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c...412.1423074.971996
2185.736084169.889999Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1True3FalseFalse15.8460850<Metabolite: Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccc...344.038626251.098404
3213.806793203.990005O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc...True5FalseFalse9.8167880<Metabolite: O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c...470.12600596.369324
4187.023651180.759995O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2True4FalseFalse6.2636570<Metabolite: O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)...339.10414839.233395
5181.252243167.710007N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2True3TrueTrue13.5422361<Metabolite: N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)...304.034020183.392166
6175.756470165.429993CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1True3TrueTrue10.3264771<Metabolite: CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OC...292.088163106.636131
7210.745056180.089996COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)CTrue2FalseFalse30.6550600<Metabolite: COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(...359.173273939.732666
8187.511887183.139999O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1True3FalseFalse4.3718870<Metabolite: O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1cc...307.09569119.113398
9165.144241147.960007Clc1ccnc(c1)C(=O)Nc1nccs1True2FalseFalse17.1842350<Metabolite: Clc1ccnc(c1)C(=O)Nc1nccs1>238.992010295.297913
\n", + "
" + ], + "text/plain": [ + " predictions targets smiles \\\n", + "0 216.163742 215.240005 Cc1ccc(cc1)n1nnnc1SCC(=O)N(c1ccc2c(c1)OCCO2)Cc... \n", + "1 212.879791 210.649994 COc1ccc(cc1)c1nn(cc1C(=O)OCC(=O)c1ccccc1)c1ccccc1 \n", + "2 185.736084 169.889999 Clc1ncccc1S(=O)(=O)Nc1ccccc1c1ccccc1 \n", + "3 213.806793 203.990005 O=C(C1CCN(CC1)C(=O)CCn1nc(oc1=O)c1cccs1)Nc1ccc... \n", + "4 187.023651 180.759995 O=C(N1CCCC1c1cccs1)Cn1cnc2c(c1=O)cccc2 \n", + "5 181.252243 167.710007 N#Cc1ccc(cc1)S(=O)(=O)N1CCc2c(C1)ccs2 \n", + "6 175.756470 165.429993 CCCn1c(=S)[nH]c2c(c1=O)cc1c(c2)OCCCO1 \n", + "7 210.745056 180.089996 COc1cc(OC)cc(c1)C(=O)N(CCc1ccc(c(c1)OC)OC)C \n", + "8 187.511887 183.139999 O=C(c1ccc(cc1)NC(=O)c1ccco1)Nc1ccncc1 \n", + "9 165.144241 147.960007 Clc1ccnc(c1)C(=O)Nc1nccs1 \n", + "\n", + " precursor_positive ring_counts presence_rare_elements \\\n", + "0 True 5 False \n", + "1 True 4 False \n", + "2 True 3 False \n", + "3 True 5 False \n", + "4 True 4 False \n", + "5 True 3 True \n", + "6 True 3 True \n", + "7 True 2 False \n", + "8 True 3 False \n", + "9 True 2 False \n", + "\n", + " rare_element_included residuals rare_element_count \\\n", + "0 False 0.923737 0 \n", + "1 False 2.229797 0 \n", + "2 False 15.846085 0 \n", + "3 False 9.816788 0 \n", + "4 False 6.263657 0 \n", + "5 True 13.542236 1 \n", + "6 True 10.326477 1 \n", + "7 False 30.655060 0 \n", + "8 False 4.371887 0 \n", + "9 False 17.184235 0 \n", + "\n", + " Metabolite Weight MSE \n", + "0 238.992010 295.297913 " + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_df_fiora.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [], + "source": [ + "# Analyze clusters in test_df_fiora\n", + "\n", + "# Standardize the data\n", + "X = ccs_df[['weights', 'CCS_AVG']].values\n", + "X_scaled = StandardScaler().fit_transform(X)\n", + "\n", + "# DBSCAN clustering\n", + "clustering = DBSCAN(eps=0.3, min_samples=10).fit(X_scaled)\n", + "ccs_df['cluster'] = clustering.labels_ # -1 is noise, 0/1 are clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[122], line 28\u001b[0m\n\u001b[1;32m 26\u001b[0m superclasses\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 27\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m superclass \u001b[38;5;241m=\u001b[39m \u001b[43mclassify_np\u001b[49m\u001b[43m(\u001b[49m\u001b[43ms\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 29\u001b[0m superclasses\u001b[38;5;241m.\u001b[39mappend(superclass)\n\u001b[1;32m 31\u001b[0m test_df_fiora[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msuperclass\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m superclasses\n", + "Cell \u001b[0;32mIn[122], line 13\u001b[0m, in \u001b[0;36mclassify_np\u001b[0;34m(smiles)\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mclassify_np\u001b[39m(smiles):\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 13\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mrequests\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhttps://structure.gnps2.org/classyfire?smiles=\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43msmiles\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m response\u001b[38;5;241m.\u001b[39mstatus_code \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m200\u001b[39m:\n\u001b[1;32m 15\u001b[0m data \u001b[38;5;241m=\u001b[39m response\u001b[38;5;241m.\u001b[39mjson()\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/requests/api.py:73\u001b[0m, in \u001b[0;36mget\u001b[0;34m(url, params, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget\u001b[39m(url, params\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 63\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Sends a GET request.\u001b[39;00m\n\u001b[1;32m 64\u001b[0m \n\u001b[1;32m 65\u001b[0m \u001b[38;5;124;03m :param url: URL for the new :class:`Request` object.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;124;03m :rtype: requests.Response\u001b[39;00m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 73\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mget\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/requests/api.py:59\u001b[0m, in \u001b[0;36mrequest\u001b[0;34m(method, url, **kwargs)\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;66;03m# By using the 'with' statement we are sure the session is closed, thus we\u001b[39;00m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;66;03m# avoid leaving sockets open which can trigger a ResourceWarning in some\u001b[39;00m\n\u001b[1;32m 57\u001b[0m \u001b[38;5;66;03m# cases, and look like a memory leak in others.\u001b[39;00m\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m sessions\u001b[38;5;241m.\u001b[39mSession() \u001b[38;5;28;01mas\u001b[39;00m session:\n\u001b[0;32m---> 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/requests/sessions.py:589\u001b[0m, in \u001b[0;36mSession.request\u001b[0;34m(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)\u001b[0m\n\u001b[1;32m 584\u001b[0m send_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 585\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimeout\u001b[39m\u001b[38;5;124m\"\u001b[39m: timeout,\n\u001b[1;32m 586\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m: allow_redirects,\n\u001b[1;32m 587\u001b[0m }\n\u001b[1;32m 588\u001b[0m send_kwargs\u001b[38;5;241m.\u001b[39mupdate(settings)\n\u001b[0;32m--> 589\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msend_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m resp\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/requests/sessions.py:703\u001b[0m, in \u001b[0;36mSession.send\u001b[0;34m(self, request, **kwargs)\u001b[0m\n\u001b[1;32m 700\u001b[0m start \u001b[38;5;241m=\u001b[39m preferred_clock()\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# Send the request\u001b[39;00m\n\u001b[0;32m--> 703\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43madapter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[38;5;66;03m# Total elapsed time of the request (approximately)\u001b[39;00m\n\u001b[1;32m 706\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m preferred_clock() \u001b[38;5;241m-\u001b[39m start\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/requests/adapters.py:667\u001b[0m, in \u001b[0;36mHTTPAdapter.send\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m 664\u001b[0m timeout \u001b[38;5;241m=\u001b[39m TimeoutSauce(connect\u001b[38;5;241m=\u001b[39mtimeout, read\u001b[38;5;241m=\u001b[39mtimeout)\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 667\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 668\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 669\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 670\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 671\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 672\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 673\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 674\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 675\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 676\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 677\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 678\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 679\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 681\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (ProtocolError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m 682\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m(err, request\u001b[38;5;241m=\u001b[39mrequest)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/urllib3/connectionpool.py:789\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)\u001b[0m\n\u001b[1;32m 786\u001b[0m response_conn \u001b[38;5;241m=\u001b[39m conn \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m release_conn \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 788\u001b[0m \u001b[38;5;66;03m# Make the request on the HTTPConnection object\u001b[39;00m\n\u001b[0;32m--> 789\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 790\u001b[0m \u001b[43m \u001b[49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 791\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 792\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 793\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 794\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 795\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 796\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 797\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 798\u001b[0m \u001b[43m \u001b[49m\u001b[43mresponse_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresponse_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 799\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpreload_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 800\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 801\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 802\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 804\u001b[0m \u001b[38;5;66;03m# Everything went great!\u001b[39;00m\n\u001b[1;32m 805\u001b[0m clean_exit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/urllib3/connectionpool.py:536\u001b[0m, in \u001b[0;36mHTTPConnectionPool._make_request\u001b[0;34m(self, conn, method, url, body, headers, retries, timeout, chunked, response_conn, preload_content, decode_content, enforce_content_length)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[38;5;66;03m# Receive the response from the server\u001b[39;00m\n\u001b[1;32m 535\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 536\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 537\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (BaseSSLError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 538\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_raise_timeout(err\u001b[38;5;241m=\u001b[39me, url\u001b[38;5;241m=\u001b[39murl, timeout_value\u001b[38;5;241m=\u001b[39mread_timeout)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/site-packages/urllib3/connection.py:507\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 504\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mresponse\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m HTTPResponse\n\u001b[1;32m 506\u001b[0m \u001b[38;5;66;03m# Get the response from http.client.HTTPConnection\u001b[39;00m\n\u001b[0;32m--> 507\u001b[0m httplib_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 509\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 510\u001b[0m assert_header_parsing(httplib_response\u001b[38;5;241m.\u001b[39mmsg)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/http/client.py:1375\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1373\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1374\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1375\u001b[0m \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbegin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1376\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m:\n\u001b[1;32m 1377\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclose()\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/http/client.py:318\u001b[0m, in \u001b[0;36mHTTPResponse.begin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;66;03m# read until we get a non-100 response\u001b[39;00m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m--> 318\u001b[0m version, status, reason \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m status \u001b[38;5;241m!=\u001b[39m CONTINUE:\n\u001b[1;32m 320\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/http/client.py:279\u001b[0m, in \u001b[0;36mHTTPResponse._read_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 278\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_read_status\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 279\u001b[0m line \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadline\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_MAXLINE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124miso-8859-1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 280\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(line) \u001b[38;5;241m>\u001b[39m _MAXLINE:\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m LineTooLong(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstatus line\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/socket.py:717\u001b[0m, in \u001b[0;36mSocketIO.readinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m 715\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m 716\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 717\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrecv_into\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 718\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m timeout:\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_timeout_occurred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/ssl.py:1307\u001b[0m, in \u001b[0;36mSSLSocket.recv_into\u001b[0;34m(self, buffer, nbytes, flags)\u001b[0m\n\u001b[1;32m 1303\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flags \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1304\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1305\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnon-zero flags not allowed in calls to recv_into() on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[1;32m 1306\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m)\n\u001b[0;32m-> 1307\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnbytes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1308\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mrecv_into(buffer, nbytes, flags)\n", + "File \u001b[0;32m~/anaconda3/envs/fiora/lib/python3.10/ssl.py:1163\u001b[0m, in \u001b[0;36mSSLSocket.read\u001b[0;34m(self, len, buffer)\u001b[0m\n\u001b[1;32m 1161\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1162\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m buffer \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1163\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sslobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1165\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sslobj\u001b[38;5;241m.\u001b[39mread(\u001b[38;5;28mlen\u001b[39m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# TODO: find superclasses of metabolites and analyze them according to superclass clusters\n", + "\n", + "# ClassyFire\n", + "# test_df_fiora[\"group_id\"] = test_df_fiora[\"smiles\"].astype(\"category\").cat.codes\n", + "# test_df_fiora.drop_duplicates(\"group_id\", keep=\"first\")[[\"group_id\", \"smiles\"]].to_csv(f\"../../data/ccs/benchmarking/classyfire_input.csv\", header=None, sep=\" \", index=False)\n", + "\n", + "#NPClassifier (doesn't work)\n", + "\n", + "import requests\n", + "\n", + "def classify_np(smiles):\n", + " try:\n", + " response = requests.get(f\"https://structure.gnps2.org/classyfire?smiles={smiles}\", timeout=10)\n", + " if response.status_code == 200:\n", + " data = response.json()\n", + " return data.get('superclass', None)\n", + " else:\n", + " return None\n", + " except Exception as e:\n", + " return None\n", + " \n", + "superclasses = []\n", + "for i, s in enumerate(test_df_fiora['smiles']):\n", + " if pd.isna(s):\n", + " print(\"smiles NA\")\n", + " superclasses.append(None)\n", + " continue\n", + " superclass = classify_np(s)\n", + " superclasses.append(superclass)\n", + "\n", + "test_df_fiora['superclass'] = superclasses\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}