From 706346518cf31c1bf222c91f8abb623350cda6c4 Mon Sep 17 00:00:00 2001 From: gbg141 Date: Tue, 30 Apr 2024 13:21:27 +0200 Subject: [PATCH] Refactoring + Improving Tutorials --- .../graph2hypergraph/knn_lifting.yaml | 2 +- modules/{io => data}/__init__.py | 0 modules/{io => data}/load/__init__.py | 0 modules/{io => data}/load/base.py | 0 modules/{io => data}/load/loaders.py | 8 +- .../{io => data}/preprocess/preprocessor.py | 2 +- modules/data/utils/custom_dataset.py | 15 ++ modules/{io => data}/utils/utils.py | 16 +- modules/io/utils/split_utils.py | 228 ------------------ modules/models/cell/cwn.py | 10 +- modules/models/hypergraph/unigcn.py | 6 +- modules/models/simplicial/san.py | 6 +- .../transforms/liftings/graph2cell/base.py | 2 +- .../liftings/graph2simplicial/base.py | 2 +- modules/utils/utils.py | 216 ++++++++++++++++- .../feature_liftings/test_projection_sum.py | 2 +- .../liftings/graph2cell/test_cycle_lifting.py | 2 +- .../graph2hypergraph/test_khop_lifting.py | 2 +- .../graph2simplicial/test_clique_lifting.py | 2 +- tutorials/graph2cell/cycle_lifting.ipynb | 178 +++++--------- tutorials/graph2hypergraph/knn_lifting.ipynb | 156 ++++++------ .../graph2simplicial/clique_lifting.ipynb | 178 +++++--------- 22 files changed, 450 insertions(+), 583 deletions(-) rename modules/{io => data}/__init__.py (100%) rename modules/{io => data}/load/__init__.py (100%) rename modules/{io => data}/load/base.py (100%) rename modules/{io => data}/load/loaders.py (95%) rename modules/{io => data}/preprocess/preprocessor.py (98%) create mode 100644 modules/data/utils/custom_dataset.py rename modules/{io => data}/utils/utils.py (95%) delete mode 100644 modules/io/utils/split_utils.py diff --git a/configs/transforms/liftings/graph2hypergraph/knn_lifting.yaml b/configs/transforms/liftings/graph2hypergraph/knn_lifting.yaml index dc5c93c0..645e2357 100755 --- a/configs/transforms/liftings/graph2hypergraph/knn_lifting.yaml +++ b/configs/transforms/liftings/graph2hypergraph/knn_lifting.yaml @@ -1,5 +1,5 @@ transform_type: 'lifting' transform_name: "HypergraphKNNLifting" -k_value: 2 +k_value: 3 loop: True feature_lifting: ProjectionSum \ No newline at end of file diff --git a/modules/io/__init__.py b/modules/data/__init__.py similarity index 100% rename from modules/io/__init__.py rename to modules/data/__init__.py diff --git a/modules/io/load/__init__.py b/modules/data/load/__init__.py similarity index 100% rename from modules/io/load/__init__.py rename to modules/data/load/__init__.py diff --git a/modules/io/load/base.py b/modules/data/load/base.py similarity index 100% rename from modules/io/load/base.py rename to modules/data/load/base.py diff --git a/modules/io/load/loaders.py b/modules/data/load/loaders.py similarity index 95% rename from modules/io/load/loaders.py rename to modules/data/load/loaders.py index d652085d..4669e0e2 100755 --- a/modules/io/load/loaders.py +++ b/modules/data/load/loaders.py @@ -5,8 +5,9 @@ import torch_geometric from omegaconf import DictConfig -from modules.io.load.base import AbstractLoader -from modules.io.utils.utils import ( +from modules.data.load.base import AbstractLoader +from modules.data.utils.custom_dataset import CustomDataset +from modules.data.utils.utils import ( load_cell_complex_dataset, load_hypergraph_pickle_dataset, load_manual_graph, @@ -102,7 +103,8 @@ def load(self) -> torch_geometric.data.Dataset: dataset = datasets[0] + datasets[1] + datasets[2] elif self.parameters.data_name in ["manual"]: - dataset = load_manual_graph() + data = load_manual_graph() + dataset = CustomDataset([data], self.data_dir) else: raise NotImplementedError( diff --git a/modules/io/preprocess/preprocessor.py b/modules/data/preprocess/preprocessor.py similarity index 98% rename from modules/io/preprocess/preprocessor.py rename to modules/data/preprocess/preprocessor.py index 3a8d6073..65b46546 100644 --- a/modules/io/preprocess/preprocessor.py +++ b/modules/data/preprocess/preprocessor.py @@ -3,7 +3,7 @@ import torch_geometric -from modules.io.utils.utils import ensure_serializable, make_hash +from modules.data.utils.utils import ensure_serializable, make_hash from modules.transforms.data_transform import DataTransform diff --git a/modules/data/utils/custom_dataset.py b/modules/data/utils/custom_dataset.py new file mode 100644 index 00000000..a579935a --- /dev/null +++ b/modules/data/utils/custom_dataset.py @@ -0,0 +1,15 @@ +import torch_geometric + + +class CustomDataset(torch_geometric.data.InMemoryDataset): + def __init__(self, data_list, data_dir, transform=None): + self.data_list = data_list + super().__init__(data_dir, transform) + self.load(self.processed_paths[0]) + + @property + def processed_file_names(self): + return "data.pt" + + def process(self): + self.save(self.data_list, self.processed_paths[0]) diff --git a/modules/io/utils/utils.py b/modules/data/utils/utils.py similarity index 95% rename from modules/io/utils/utils.py rename to modules/data/utils/utils.py index 9ff2db09..15e453a0 100755 --- a/modules/io/utils/utils.py +++ b/modules/data/utils/utils.py @@ -50,16 +50,16 @@ def get_complex_connectivity(complex, max_rank, signed=False): ) except ValueError: if connectivity_info == "incidence": - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] ) else: - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx], n=practical_shape[rank_idx] ) connectivity["shape"] = practical_shape return connectivity diff --git a/modules/io/utils/split_utils.py b/modules/io/utils/split_utils.py deleted file mode 100644 index 9579608c..00000000 --- a/modules/io/utils/split_utils.py +++ /dev/null @@ -1,228 +0,0 @@ -# # Generate splits in different fasions -# def k_fold_split(labels, parameters): -# """ -# Returns train and valid indices as in K-Fold Cross-Validation. If the split already exists -# it loads it automatically, otherwise it creates the split file for the subsequent runs. - -# Parameters -# ---------- -# labels : torch.Tensor -# Label tensor. -# parameters : DictConfig -# Configuration parameters. - -# Returns -# ------- -# dict -# Dictionary containing the train, validation and test indices. -# """ -# data_dir = parameters.data_split_dir -# k = parameters.k -# fold = parameters.data_seed -# assert fold < k, "data_seed needs to be less than k" - -# torch.manual_seed(0) -# np.random.seed(0) - -# split_dir = os.path.join(data_dir, f"{k}-fold") - -# if not os.path.isdir(split_dir): -# os.makedirs(split_dir) - -# split_path = os.path.join(split_dir, f"{fold}.npz") -# if not os.path.isfile(split_path): -# n = labels.shape[0] -# x_idx = np.arange(n) -# x_idx = np.random.permutation(x_idx) -# labels = labels[x_idx] - -# skf = StratifiedKFold(n_splits=k, shuffle=True, random_state=42) - -# for fold_n, (train_idx, valid_idx) in enumerate(skf.split(x_idx, labels)): -# split_idx = {"train": train_idx, "valid": valid_idx, "test": valid_idx} - -# # Check that all nodes/graph have been assigned to some split -# assert np.all( -# np.sort( -# np.array(split_idx["train"].tolist() + split_idx["valid"].tolist()) -# ) -# == np.sort(np.arange(len(labels))) -# ), "Not every sample has been loaded." -# split_path = os.path.join(split_dir, f"{fold_n}.npz") - -# np.savez(split_path, **split_idx) - -# split_path = os.path.join(split_dir, f"{fold}.npz") -# split_idx = np.load(split_path) - -# # Check that all nodes/graph have been assigned to some split -# assert ( -# np.unique( -# np.array( -# split_idx["train"].tolist() -# + split_idx["valid"].tolist() -# + split_idx["test"].tolist() -# ) -# ).shape[0] -# == labels.shape[0] -# ), "Not all nodes within splits" - -# return split_idx - - -# def load_split(data, cfg, train_prop=0.5): -# r"""Loads the split for generated by rand_train_test_idx function. - -# Parameters -# ---------- -# data : torch_geometric.data.Data -# Graph dataset. -# cfg : DictConfig -# Configuration parameters. -# train_prop : float -# Proportion of training data. - -# Returns -# ------- -# torch_geometric.data.Data -# Graph dataset with the specified split. -# """ - -# data_dir = os.path.join(cfg["data_split_dir"], f"train_prop={train_prop}") -# load_path = f"{data_dir}/split_{cfg['data_seed']}.npz" -# splits = np.load(load_path, allow_pickle=True) - -# # Upload masks -# data.train_mask = torch.from_numpy(splits["train"]) -# data.val_mask = torch.from_numpy(splits["valid"]) -# data.test_mask = torch.from_numpy(splits["test"]) - -# # Check that all nodes assigned to splits -# assert ( -# torch.unique( -# torch.concat([data.train_mask, data.val_mask, data.test_mask]) -# ).shape[0] -# == data.num_nodes -# ), "Not all nodes within splits" -# return data - - -# def assing_train_val_test_mask_to_graphs(dataset, split_idx): -# r"""Splits the graph dataset into train, validation, and test datasets. - -# Parameters -# ---------- -# dataset : torch_geometric.data.Dataset -# Graph dataset. -# split_idx : dict -# Dictionary containing the indices for the train, validation, and test splits. - -# Returns -# ------- -# datasets : list -# List containing the train, validation, and test datasets. -# """ -# data_train_lst, data_val_lst, data_test_lst = [], [], [] - -# # Go over each of the graph and assign correct label -# for i in range(len(dataset)): -# graph = dataset[i] -# assigned = False -# if i in split_idx["train"]: -# graph.train_mask = torch.Tensor([1]).long() -# graph.val_mask = torch.Tensor([0]).long() -# graph.test_mask = torch.Tensor([0]).long() -# data_train_lst.append(graph) -# assigned = True - -# if i in split_idx["valid"]: -# graph.train_mask = torch.Tensor([0]).long() -# graph.val_mask = torch.Tensor([1]).long() -# graph.test_mask = torch.Tensor([0]).long() -# data_val_lst.append(graph) -# assigned = True - -# if i in split_idx["test"]: -# graph.train_mask = torch.Tensor([0]).long() -# graph.val_mask = torch.Tensor([0]).long() -# graph.test_mask = torch.Tensor([1]).long() -# data_test_lst.append(graph) -# assigned = True -# if not assigned: -# raise ValueError("Graph not in any split") - -# datasets = [ -# data_train_lst, -# data_val_lst, -# data_test_lst, -# ] - -# return datasets - - -# Load splits for different dataset -# def load_graph_tudataset_split(dataset, cfg): -# r"""Loads the graph dataset with the specified split. - -# Parameters -# ---------- -# dataset : torch_geometric.data.Dataset -# Graph dataset. -# cfg : DictConfig -# Configuration parameters. - -# Returns -# ------- -# list -# List containing the train, validation, and test splits. -# """ -# # Extract labels from dataset object -# assert ( -# len(dataset) > 1 -# ), "Torch Geometric TU datasets should have more than one graph in the dataset" -# # labels = np.array([data.y.squeeze(0).numpy() for data in dataset]) - -# # split_idx = k_fold_split(labels, cfg) - -# # train_dataset, val_dataset, test_dataset = assing_train_val_test_mask_to_graphs( -# # dataset, split_idx -# # ) - -# return [train_dataset, val_dataset, test_dataset] - - -# def load_graph_cocitation_split(dataset, cfg): -# r"""Loads cocitation graph datasets with the specified split. - -# Parameters -# ---------- -# dataset : torch_geometric.data.Dataset -# Graph dataset. -# cfg : DictConfig -# Configuration parameters. - -# Returns -# ------- -# list -# List containing the train, validation, and test splits. -# """ - -# # Extract labels from dataset object -# assert ( -# len(dataset) == 1 -# ), "Torch Geometric Cocitation dataset should have only one graph" - -# data = dataset.data -# labels = data.y.numpy() - -# # Ensure labels are one dimensional array -# assert len(labels.shape) == 1, "Labels should be one dimensional array" - -# # splits = k_fold_split(labels, cfg) - -# # # Assign train val test masks to the graph -# # data.train_mask = torch.from_numpy(splits["train"]) -# # data.val_mask = torch.from_numpy(splits["valid"]) -# # data.test_mask = torch.from_numpy(splits["test"]) - -# return data diff --git a/modules/models/cell/cwn.py b/modules/models/cell/cwn.py index 1afd8595..caf4521e 100644 --- a/modules/models/cell/cwn.py +++ b/modules/models/cell/cwn.py @@ -15,9 +15,13 @@ class CWNModel(torch.nn.Module): """ def __init__(self, model_config, dataset_config): - in_channels_0 = dataset_config["num_features"] - in_channels_1 = dataset_config["num_features"] - in_channels_2 = dataset_config["num_features"] + in_channels_0 = ( + dataset_config["num_features"] + if isinstance(dataset_config["num_features"], int) + else dataset_config["num_features"][0] + ) + in_channels_1 = in_channels_0 + in_channels_2 = in_channels_0 hidden_channels = model_config["hidden_channels"] out_channels = dataset_config["num_classes"] n_layers = model_config["n_layers"] diff --git a/modules/models/hypergraph/unigcn.py b/modules/models/hypergraph/unigcn.py index ad93337c..c5cb240b 100644 --- a/modules/models/hypergraph/unigcn.py +++ b/modules/models/hypergraph/unigcn.py @@ -15,7 +15,11 @@ class UniGCNModel(torch.nn.Module): """ def __init__(self, model_config, dataset_config): - in_channels = dataset_config["num_features"] + in_channels = ( + dataset_config["num_features"] + if isinstance(dataset_config["num_features"], int) + else dataset_config["num_features"][0] + ) hidden_channels = model_config["hidden_channels"] out_channels = dataset_config["num_classes"] n_layers = model_config["n_layers"] diff --git a/modules/models/simplicial/san.py b/modules/models/simplicial/san.py index af7a6e40..fbdd26c6 100644 --- a/modules/models/simplicial/san.py +++ b/modules/models/simplicial/san.py @@ -15,7 +15,11 @@ class SANModel(torch.nn.Module): """ def __init__(self, model_config, dataset_config): - in_channels = dataset_config["num_features"] + in_channels = ( + dataset_config["num_features"] + if isinstance(dataset_config["num_features"], int) + else dataset_config["num_features"][0] + ) hidden_channels = model_config["hidden_channels"] out_channels = dataset_config["num_classes"] n_layers = model_config["n_layers"] diff --git a/modules/transforms/liftings/graph2cell/base.py b/modules/transforms/liftings/graph2cell/base.py index d40af5bc..689a3dd9 100755 --- a/modules/transforms/liftings/graph2cell/base.py +++ b/modules/transforms/liftings/graph2cell/base.py @@ -2,7 +2,7 @@ import torch from toponetx.classes import CellComplex -from modules.io.utils.utils import get_complex_connectivity +from modules.data.utils.utils import get_complex_connectivity from modules.transforms.liftings.lifting import GraphLifting diff --git a/modules/transforms/liftings/graph2simplicial/base.py b/modules/transforms/liftings/graph2simplicial/base.py index 8f4416b7..1500a229 100755 --- a/modules/transforms/liftings/graph2simplicial/base.py +++ b/modules/transforms/liftings/graph2simplicial/base.py @@ -2,7 +2,7 @@ import torch from toponetx.classes import SimplicialComplex -from modules.io.utils.utils import get_complex_connectivity +from modules.data.utils.utils import get_complex_connectivity from modules.transforms.liftings.lifting import GraphLifting diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 9c592332..7335a971 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -7,8 +7,10 @@ import omegaconf import rootutils import torch +import torch_geometric from matplotlib.patches import Polygon +plt.rcParams["text.usetex"] = True rootutils.setup_root("./", indicator=".project-root", pythonpath=True) @@ -31,6 +33,7 @@ def load_dataset_config(dataset_name: str) -> omegaconf.DictConfig: dataset_config = omegaconf.OmegaConf.load(dataset_config_path) # Print configuration + print(f"\nDataset configuration for {dataset_name}:\n") pprint.pp(dict(dataset_config.copy())) return dataset_config @@ -60,6 +63,10 @@ def load_transform_config( ) transform_config = omegaconf.OmegaConf.load(transform_config_path) # Print configuration + if transform_type == "liftings": + print(f"\nTransform configuration for {transform_id}:\n") + else: + print(f"\nTransform configuration for {transform_type}/{transform_id}:\n") pprint.pp(dict(transform_config.copy())) return transform_config @@ -81,12 +88,107 @@ def load_model_config(model_type: str, model_name: str) -> omegaconf.DictConfig: model_config_path = f"{root_folder}/configs/models/{model_type}/{model_name}.yaml" model_config = omegaconf.OmegaConf.load(model_config_path) # Print configuration + print(f"\nModel configuration for {model_type} {model_name.upper()}:\n") pprint.pp(dict(model_config.copy())) return model_config +def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): + r"""Describe a data sample of the considered dataset. + + Parameters + ---------- + data : torch_geometric.data.Data + Data object. + idx_sample : int + Index of the sample to describe. + """ + assert isinstance( + dataset, torch_geometric.data.Dataset + ), "Data object must be a PyG Dataset object." + num_samples = len(dataset) + if num_samples == 1: + print(f"\nDataset only contains {num_samples} sample:") + else: + print(f"\nDataset contains {num_samples} samples.\n") + print( + f"Providing more details about sample {idx_sample % num_samples}/{num_samples}:" + ) + data = dataset.get(idx_sample % num_samples) + complex_dim = [] + features_dim = [] + # If lifted, we can look at the generated features for each cell + for dim in range(10): + if hasattr(data, f"x_{dim}") and getattr(data, f"x_{dim}").shape[0] > 0: + complex_dim.append(getattr(data, f"x_{dim}").shape[0]) + features_dim.append(getattr(data, f"x_{dim}").shape[1]) + # If not lifted, we check the classical fields of a dataset loaded from PyG + if len(complex_dim) == 0: + if hasattr(data, "num_nodes"): + complex_dim.append(data.num_nodes) + features_dim.append(data.num_node_features) + elif hasattr(data, "x"): + complex_dim.append(data.x.shape[0]) + features_dim.append(data.x.shape[1]) + else: + raise ValueError("Data object does not contain any vertices/points.") + if hasattr(data, "num_edges"): + complex_dim.append(data.num_edges) + features_dim.append(data.num_edge_features) + elif hasattr(data, "edge_index"): + complex_dim.append(data.edge_index.shape[1]) + features_dim.append(data.edge_attr.shape[1]) + # Check if the data object contains hyperedges + hyperedges = False + if hasattr(data, "x_hyperedges"): + hyperedges = data.x_hyperedges.shape[0] + hyperedges_features_dim = data.x_hyperedges.shape[1] + + # Plot the graph if it is not too large + if complex_dim[0] < 50: + plot_manual_graph(data) + + if hyperedges: + if len(complex_dim) == 1: + print( + f" - Hypergraph with {complex_dim[0]} vertices and {hyperedges} hyperedges." + ) + features_dim.append(hyperedges_features_dim) + print(f" - Features dimensions: {features_dim}") + else: + print( + f" - {len(complex_dim)}-Complex with dimensions {complex_dim} and {hyperedges} hyperedges." + ) + print(f" - Complex features dimensions: {features_dim}") + print(f" - Hyperedges features dimensions: {hyperedges_features_dim}") + else: + if len(complex_dim) == 1: + print(f" - Set with {complex_dim[0]} points.") + print(f" - Features dimension: {features_dim[0]}") + elif len(complex_dim) == 2: + print( + f" - Graph with {complex_dim[0]} vertices and {complex_dim[1]} edges." + ) + print(f" - Features dimensions: {features_dim}") + # Check if there are isolated nodes + if hasattr(data, "edge_index") and hasattr(data, "x"): + connected_nodes = torch.unique(data.edge_index) + isolated_nodes = [] + for i in range(data.x.shape[0]): + if i not in connected_nodes: + isolated_nodes.append(i) + print(f" - There are {len(isolated_nodes)} isolated nodes.") + else: + print(f" - {len(complex_dim)}-Complex with dimensions {complex_dim}.") + print(f" - Complex features dimensions: {features_dim}") + print("") + + def plot_manual_graph(data, title=None): - r"""Plot a manual graph. + r"""Plot a manual graph. If lifted, the plot shows the inferred + higher-order structures (bipartite graph for hyperedges, + colored 2-cells and 3-cells for simplicial/cell complexes). + Combinatorial complexes are plotted as simplicial/cell complexes. Parameters ---------- @@ -212,11 +314,11 @@ def sort_vertices_ccw(vertices): plt.figure(figsize=(5, 5)) # Draw the graph with labels if max_order == 0: - labels = {i: f"v_{i}" for i in range(n_vertices)} + labels = {i: "$v_{" + str(i) + "}$" for i in range(n_vertices)} for e in range(n_hyperedges): - labels[e + n_vertices] = f"he_{e}" + labels[e + n_vertices] = "$h_{" + str(e) + "}$" else: - labels = {i: f"v_{i}" for i in G.nodes()} + labels = {i: "$v_{" + str(i) + "}$" for i in G.nodes()} nx.draw( G, @@ -279,7 +381,7 @@ def sort_vertices_ccw(vertices): G, pos, edge_labels={ - tuple(corr_nodes): f"e_{edge_idx}" + tuple(corr_nodes): "$e_{" + str(edge_idx) + "}$" for edge_idx, corr_nodes in edge_mapper.items() }, font_color="red", @@ -292,10 +394,108 @@ def sort_vertices_ccw(vertices): if title is not None: plt.title(title) if max_order == 0: - plt.title("Bipartite graph. Top nodes represent the hyperedges.") + plt.title("Lifted Graph - top nodes represent the hyperedges") elif max_order == 1: - plt.title("The original graph.") + plt.title("Original Graph") + elif max_order == 2: + plt.title("Lifted Graph with colored 2-cells") else: - plt.title("Graph with colored faces.") + plt.title("Lifted Graph with colored 2 and 3-cells") plt.axis("off") plt.show() + + +def describe_simplicial_complex(data: torch_geometric.data.Data): + r"""Describe a simplicial complex. + + Parameters + ---------- + data : torch_geometric.data.Data + Data object containing the simplicial complex. + """ + edges2nodes = [[] for _ in range(data.incidence_1.shape[1])] + indices = data.incidence_1.coalesce().indices() + for i in range(data.incidence_1.shape[1]): + edges2nodes[i] = indices[0, indices[1, :] == i] + edges2nodes = torch.stack(edges2nodes) + + triangles2edges = [[] for _ in range(data.incidence_2.shape[1])] + indices = data.incidence_2.coalesce().indices() + for i in range(data.incidence_2.shape[1]): + triangles2edges[i] = indices[0, indices[1, :] == i] + triangles2edges = torch.stack(triangles2edges) + + incidence_2 = data.incidence_2.coalesce() + indices = incidence_2.indices() + + print(f"The simplicial complex has {incidence_2.shape[1]} triangles.") + for triangles_idx in torch.unique(indices[1]): + corresponding_idxs = indices[1] == triangles_idx + edges = indices[0, corresponding_idxs] + nodes = torch.unique(edges2nodes[edges]).numpy() + print(f"Triangle {triangles_idx} is composed from nodes {nodes}") + if triangles_idx >= 10: + print("...") + break + + incidence_3 = data.incidence_3.coalesce() + indices = incidence_3.indices() + + print(f"\nThe simplicial complex has {incidence_3.shape[1]} tetrahedrons.") + for tetrahedrons_idx in torch.unique(indices[1]): + corresponding_idxs = indices[1] == tetrahedrons_idx + triangles = indices[0, corresponding_idxs] + nodes = torch.unique(edges2nodes[triangles2edges[triangles]]).numpy() + print(f"Tetrahedron {tetrahedrons_idx} is composed from nodes {nodes}") + if tetrahedrons_idx > 10: + print("...") + break + + +def describe_cell_complex(data: torch_geometric.data.Data): + r"""Describe a simplicial complex. + + Parameters + ---------- + data : torch_geometric.data.Data + Data object containing the simplicial complex. + """ + edges2nodes = [[] for _ in range(data.incidence_1.shape[1])] + indices = data.incidence_1.coalesce().indices() + for i in range(data.incidence_1.shape[1]): + edges2nodes[i] = indices[0, indices[1, :] == i] + edges2nodes = torch.stack(edges2nodes) + + incidence_2 = data.incidence_2.coalesce() + indices = incidence_2.indices() + + print(f"The cell complex has {incidence_2.shape[1]} cells.") + for cell_idx in torch.unique(indices[1]): + corresponding_idxs = indices[1] == cell_idx + edges = indices[0, corresponding_idxs] + nodes = torch.unique(edges2nodes[edges]) + print(f"Cell {cell_idx} is composed from the edges {nodes}") + if cell_idx >= 10: + print("...") + break + + +def describe_hypergraph(data: torch_geometric.data.Data): + r"""Describe a hypergraph. + + Parameters + ---------- + data : torch_geometric.data.Data + Data object containing the hypergraph. + """ + incidence = data.incidence_hyperedges.coalesce() + indices = incidence.indices() + + print(f"The hypergraph has {data.incidence_hyperedges.shape[1]} hyperedges.") + for he_idx in torch.unique(indices[1]): + corresponding_idxs = indices[0] == he_idx + nodes = indices[1, corresponding_idxs] + print(f"Hyperedge {he_idx} contains the nodes {nodes.numpy()}") + if he_idx >= 10: + print("...") + break diff --git a/test/transforms/feature_liftings/test_projection_sum.py b/test/transforms/feature_liftings/test_projection_sum.py index 108cb9fb..c2a3d3cd 100644 --- a/test/transforms/feature_liftings/test_projection_sum.py +++ b/test/transforms/feature_liftings/test_projection_sum.py @@ -2,7 +2,7 @@ import torch -from modules.io.utils.utils import load_manual_graph +from modules.data.utils.utils import load_manual_graph from modules.transforms.feature_liftings.feature_liftings import ProjectionSum from modules.transforms.liftings.graph2hypergraph.khop_lifting import ( HypergraphKHopLifting, diff --git a/test/transforms/liftings/graph2cell/test_cycle_lifting.py b/test/transforms/liftings/graph2cell/test_cycle_lifting.py index 07d91de6..3dec9fd8 100644 --- a/test/transforms/liftings/graph2cell/test_cycle_lifting.py +++ b/test/transforms/liftings/graph2cell/test_cycle_lifting.py @@ -2,7 +2,7 @@ import torch -from modules.io.utils.utils import load_manual_graph +from modules.data.utils.utils import load_manual_graph from modules.transforms.liftings.graph2cell.cycle_lifting import CellCycleLifting diff --git a/test/transforms/liftings/graph2hypergraph/test_khop_lifting.py b/test/transforms/liftings/graph2hypergraph/test_khop_lifting.py index d3151dda..a5d40cab 100644 --- a/test/transforms/liftings/graph2hypergraph/test_khop_lifting.py +++ b/test/transforms/liftings/graph2hypergraph/test_khop_lifting.py @@ -2,7 +2,7 @@ import torch -from modules.io.utils.utils import load_manual_graph +from modules.data.utils.utils import load_manual_graph from modules.transforms.liftings.graph2hypergraph.khop_lifting import ( HypergraphKHopLifting, ) diff --git a/test/transforms/liftings/graph2simplicial/test_clique_lifting.py b/test/transforms/liftings/graph2simplicial/test_clique_lifting.py index a3c4bdaf..208cc580 100644 --- a/test/transforms/liftings/graph2simplicial/test_clique_lifting.py +++ b/test/transforms/liftings/graph2simplicial/test_clique_lifting.py @@ -2,7 +2,7 @@ import torch -from modules.io.utils.utils import load_manual_graph +from modules.data.utils.utils import load_manual_graph from modules.transforms.liftings.graph2simplicial.clique_lifting import ( SimplicialCliqueLifting, ) diff --git a/tutorials/graph2cell/cycle_lifting.ipynb b/tutorials/graph2cell/cycle_lifting.ipynb index 2274f601..2fe22132 100644 --- a/tutorials/graph2cell/cycle_lifting.ipynb +++ b/tutorials/graph2cell/cycle_lifting.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# CellCycleLifting Tutorial" + "# Graph-to-Cell Cycle Lifting Tutorial" ] }, { @@ -45,30 +45,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "# With this cell any imported module is reloaded before each cell execution\n", "%load_ext autoreload\n", "%autoreload 2\n", - "import torch\n", - "from modules.io.load.loaders import GraphLoader\n", - "from modules.io.preprocess.preprocessor import PreProcessor\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", "from modules.utils.utils import (\n", " load_dataset_config,\n", " load_model_config,\n", " load_transform_config,\n", - " plot_manual_graph,\n", + " describe_data,\n", ")" ] }, @@ -95,44 +85,28 @@ "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Dataset configuration for MUTAG:\n", + "\n", "{'data_domain': 'graph',\n", - " 'data_type': 'toy_dataset',\n", - " 'data_name': 'manual',\n", - " 'data_dir': 'datasets/graph/toy_dataset',\n", - " 'num_features': 1,\n", + " 'data_type': 'TUDataset',\n", + " 'data_name': 'MUTAG',\n", + " 'data_dir': 'datasets/graph/TUDataset',\n", + " 'num_features': [7, 4],\n", " 'num_classes': 2,\n", " 'task': 'classification',\n", " 'loss_type': 'cross_entropy',\n", " 'monitor_metric': 'accuracy',\n", - " 'task_level': 'node'}\n" + " 'task_level': 'graph',\n", + " 'max_dim_if_lifted': 2,\n", + " 'preserve_edge_attr_if_lifted': False}\n" ] } ], "source": [ - "dataset_name = \"manual_dataset\"\n", - "\n", + "dataset_name = \"MUTAG\"\n", "dataset_config = load_dataset_config(dataset_name)\n", - "dataset = GraphLoader(dataset_config)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'data_domain': 'graph', 'data_type': 'toy_dataset', 'data_name': 'manual', 'data_dir': '${oc.env:PROJECT_ROOT}/datasets/${data_domain}/${data_type}', 'num_features': 1, 'num_classes': 2, 'task': 'classification', 'loss_type': 'cross_entropy', 'monitor_metric': 'accuracy', 'task_level': 'node'}" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset_config" + "loader = GraphLoader(dataset_config)" ] }, { @@ -144,53 +118,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 188 samples.\n", + "\n", + "Providing more details about sample 0/188:\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = dataset.load()\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The graph is undirected and has 8 nodes and 13 edges.\n", - "The nodes have features have dimension 1.\n", - "There are 0 isolated nodes.\n" + " - Graph with 17 vertices and 38 edges.\n", + " - Features dimensions: [7, 4]\n", + " - There are 0 isolated nodes.\n", + "\n" ] } ], "source": [ - "print(\n", - " f\"The graph is undirected and has {data.x.shape[0]} nodes and {data.edge_index.shape[1]} edges.\"\n", - ")\n", - "print(f\"The nodes have features have dimension {data.x.shape[1]}.\")\n", - "\n", - "connected_nodes = torch.unique(data.edge_index)\n", - "isolated_nodes = []\n", - "for i in range(data.x.shape[0]):\n", - " if i not in connected_nodes:\n", - " isolated_nodes.append(i)\n", - "print(f\"There are {len(isolated_nodes)} isolated nodes.\")" + "dataset = loader.load()\n", + "describe_data(dataset)" ] }, { @@ -217,13 +181,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Transform configuration for graph2cell/cycle_lifting:\n", + "\n", "{'transform_type': 'lifting',\n", " 'transform_name': 'CellCycleLifting',\n", " 'max_cell_length': None,\n", @@ -254,71 +221,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/1820307683\n" + "Transform parameters are the same, using existing data_dir: /Users/gbg141/Documents/TopoProjectX/challenge-icml-2024/datasets/graph/TUDataset/MUTAG/lifting/1820307683\n", + "\n", + "Dataset contains 188 samples.\n", + "\n", + "Providing more details about sample 0/188:\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = PreProcessor(data, transform_config, dataset.data_dir)\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The cell complex has 6 cells.\n", - "Cell 0 is composed from the edges tensor([0, 2, 7])\n", - "Cell 1 is composed from the edges tensor([2, 5, 7])\n", - "Cell 2 is composed from the edges tensor([2, 3, 5, 6])\n", - "Cell 3 is composed from the edges tensor([0, 1, 4])\n", - "Cell 4 is composed from the edges tensor([0, 2, 4])\n", - "Cell 5 is composed from the edges tensor([0, 1, 2])\n" + " - 3-Complex with dimensions [17, 19, 3].\n", + " - Complex features dimensions: [7, 7, 7]\n", + "\n" ] } ], "source": [ - "edges2nodes = [[] for _ in range(data.incidence_1.shape[1])]\n", - "indices = data.incidence_1.coalesce().indices()\n", - "for i in range(data.incidence_1.shape[1]):\n", - " edges2nodes[i] = indices[0, indices[1, :] == i]\n", - "edges2nodes = torch.stack(edges2nodes)\n", - "\n", - "incidence_2 = data.incidence_2.coalesce()\n", - "indices = incidence_2.indices()\n", - "\n", - "print(f\"The cell complex has {incidence_2.shape[1]} cells.\")\n", - "for cell_idx in torch.unique(indices[1]):\n", - " corresponding_idxs = indices[1] == cell_idx\n", - " edges = indices[0, corresponding_idxs]\n", - " nodes = torch.unique(edges2nodes[edges])\n", - " print(f\"Cell {cell_idx} is composed from the edges {nodes}\")\n", - " if cell_idx >= 10:\n", - " print(\"...\")\n", - " break" + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" ] }, { @@ -337,13 +276,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Model configuration for cell CWN:\n", + "\n", "{'in_channels_0': None,\n", " 'in_channels_1': None,\n", " 'in_channels_2': None,\n", @@ -365,11 +307,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "y_hat = model(data)" + "y_hat = model(lifted_dataset.get(0))" ] }, { diff --git a/tutorials/graph2hypergraph/knn_lifting.ipynb b/tutorials/graph2hypergraph/knn_lifting.ipynb index cc84b5b9..acf2ef10 100644 --- a/tutorials/graph2hypergraph/knn_lifting.ipynb +++ b/tutorials/graph2hypergraph/knn_lifting.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# HypergraphKNNLifting Tutorial" + "# Graph-to-Hypergraph KNN Lifting Tutorial" ] }, { @@ -45,21 +45,29 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "# With this cell any imported module is reloaded before each cell execution\n", "%load_ext autoreload\n", "%autoreload 2\n", - "import torch\n", - "from modules.io.load.loaders import GraphLoader\n", - "from modules.io.preprocess.preprocessor import PreProcessor\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", "from modules.utils.utils import (\n", " load_dataset_config,\n", " load_model_config,\n", " load_transform_config,\n", - " plot_manual_graph,\n", + " describe_data,\n", ")" ] }, @@ -79,30 +87,35 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Dataset configuration for MUTAG:\n", + "\n", "{'data_domain': 'graph',\n", - " 'data_type': 'toy_dataset',\n", - " 'data_name': 'manual',\n", - " 'data_dir': '/challenge-icml-2024/datasets/graph/toy_dataset',\n", - " 'num_features': 1,\n", + " 'data_type': 'TUDataset',\n", + " 'data_name': 'MUTAG',\n", + " 'data_dir': 'datasets/graph/TUDataset',\n", + " 'num_features': [7, 4],\n", " 'num_classes': 2,\n", " 'task': 'classification',\n", " 'loss_type': 'cross_entropy',\n", " 'monitor_metric': 'accuracy',\n", - " 'task_level': 'node'}\n" + " 'task_level': 'graph',\n", + " 'max_dim_if_lifted': 2,\n", + " 'preserve_edge_attr_if_lifted': False}\n" ] } ], "source": [ - "dataset_name = \"manual_dataset\"\n", + "dataset_name = \"MUTAG\"\n", "dataset_config = load_dataset_config(dataset_name)\n", - "dataset = GraphLoader(dataset_config)" + "loader = GraphLoader(dataset_config)" ] }, { @@ -114,53 +127,43 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 39, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 188 samples.\n", + "\n", + "Providing more details about sample 0/188:\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIeCAYAAAAveKxoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdQUlEQVR4nOzdd3xUVfr48c+dll5IIKEL0jvSpATpXWoAFVAB0VXXtuu6Rd2vZVdX3f25WLa4IoiSBAgdFQQRTOidhNCb9CQkIX0y5d7fH0MigQQSmOROkuf9evHS3Ln3nGcQmWfOec45iqZpGkIIIYQQ1xj0DkAIIYQQnkWSAyGEEEIUI8mBEEIIIYqR5EAIIYQQxUhyIIQQQohiJDkQQgghRDGSHAghhBCiGEkOhBBCCFGMJAdCCCGEKEaSA1Gjbdq0CUVRWLJkid6h3NaZM2dQFIUvv/zyjp5XFIU333zTrTHdqH///vTv379C+6hIiqLw3HPP6R2GELoz6R2AEO6mKEqZ7tu4cWMFRyKEEFWTJAei2vn666+L/fzVV1+xfv36m663adOGw4cPV2Zod+Wee+4hPz8fs9l8R8/n5+djMsn/8kKI25O/KUS1M23atGI/b9++nfXr1990HagSyYHD4UBVVSwWC97e3nfczt0860lyc3Px8/PTOwwhqjWpORACUFWVd955h4YNG+Lt7c2gQYM4ceLETfft2LGD4cOHExQUhK+vL/369WPLli1l6iMlJYUnnniC8PBwvL296dSpE/Pnzy92T2FdwT/+8Q9mz55Ns2bN8PLy4tChQ6XWHMTGxtK2bVu8vb1p3749y5cvZ/r06TRp0qTYfTfWHLz55psoisKJEyeYPn06wcHBBAUFMWPGDPLy8oo9O2/ePAYOHEhYWBheXl60bduW//znP2V63yXJz8/nhRdeoHbt2gQEBDBmzBguXLhQaoyHDh1iypQp1KpVi4iICAASEhKYPn069957L97e3tStW5eZM2eSlpZWrK/CNo4cOcLkyZMJDAwkNDSUF198EavVWmJ8K1asoH379nh5edGuXTvWrl17x+9ViKpIRg6EAN577z0MBgO/+93vyMzM5IMPPmDq1Kns2LGj6J4ff/yRESNG0LVrV9544w0MBkPRh2Z8fDw9evQotf38/Hz69+/PiRMneO6552jatCmxsbFMnz6dq1ev8uKLLxa7f968eVitVp566im8vLwICQlBVdWb2v3222956KGH6NChA3/729/IyMjgiSeeoEGDBmV+75MnT6Zp06b87W9/Y+/evcyZM4ewsDDef//9onv+85//0K5dO8aMGYPJZGL16tU8++yzqKrKr3/96zL3VWj69OksXryYRx99lJ49e/LTTz8xatSoUu+fNGkSLVq04N1336XwlPn169dz6tQpZsyYQd26dUlKSuJ///sfSUlJbN++/abak8mTJ9OkSRP+9re/sX37dj7++GMyMjL46quvit23efNmli1bxrPPPktAQAAff/wxkZGRnD17ltDQ0HK/VyGqJE2Iau7Xv/61Vtof9Y0bN2qA1qZNG62goKDo+kcffaQBWmJioqZpmqaqqtaiRQtt2LBhmqqqRffl5eVpTZs21YYMGXLLGGbPnq0B2oIFC4qu2Ww2rVevXpq/v7+WlZWlaZqmnT59WgO0wMBALSUlpVgbha/Nmzev6FqHDh20hg0batnZ2UXXNm3apAHaPffcU+x5QHvjjTeKfn7jjTc0QJs5c2ax+8aPH6+FhoYWu5aXl3fTexo2bJh27733FrvWr18/rV+/fqX+Pmiapu3Zs0cDtJdeeqnY9enTp5ca4yOPPHJTOyXFFBMTowFaXFzcTW2MGTOm2L3PPvusBmgHDhwougZoFotFO3HiRNG1AwcOaID2ySef3PJ9CVGdyLSCEMCMGTOwWCxFP/ft2xeAU6dOAbB//36OHz/OlClTSEtL48qVK1y5coXc3FwGDRpEXFxcid/sC3333XfUrVuXRx55pOia2WzmhRdeICcnh59++qnY/ZGRkdSpU+eWMV+8eJHExEQee+wx/P39i67369ePDh06lPm9P/3008V+7tu3L2lpaWRlZRVd8/HxKfr3zMxMrly5Qr9+/Th16hSZmZll7gsoGqJ/9tlni11//vnnyxzjjTFZrVauXLlCz549Adi7d+9N9984wlHY33fffVfs+uDBg2nWrFnRzx07diQwMLDoz4IQNYFMKwgBNG7cuNjPtWrVAiAjIwOA48ePA/D444+X2kZmZmbRczf6+eefadGiBQZD8Xy8TZs2Ra9fr2nTpreNufCZ5s2b3/Ra8+bNS/yALMmt3ntgYCAAW7Zs4Y033mDbtm031SNkZmYSFBRUpr4K4zYYDDe9x5LeR6GSfj/S09N56623WLhwISkpKTfFdKMWLVoU+7lZs2YYDAbOnDlT7PqNvx/g+j0p/LMgRE0gyYEQgNFoLPG6dm1+u3BU4O9//zudO3cu8d7rv73freu/FVe02733kydPMmjQIFq3bs2HH35Io0aNsFgsfPfdd/zzn/+85YiJu5T0+zF58mS2bt3KK6+8QufOnfH390dVVYYPH16mmErbD+N2vx9C1ASSHAhRBoXDzIGBgQwePLjcz99zzz0kJCSgqmqx0YMjR44UvX4nbQIlrqoo6dqdWr16NQUFBaxatarYt+o73UTqnnvuQVVVTp8+XezbfHlizsjIYMOGDbz11lv83//9X9H1whGekhw/frzYCMSJEydQVfWmVR1CCFnKKESZdO3alWbNmvGPf/yDnJycm15PTU295fMjR47k8uXLLFq0qOiaw+Hgk08+wd/fn379+pU7pvr169O+fXu++uqrYjH99NNPJCYmlru90hR+k77+m3NmZibz5s27o/aGDRsGwL///e9i1z/55JO7iglg9uzZpT7zr3/9q8T+RowYUeZ+C+Xl5XHkyBGuXLlS7meFqApk5ECIMjAYDMyZM4cRI0bQrl07ZsyYQYMGDbhw4QIbN24kMDCQ1atXl/r8U089xWeffcb06dPZs2cPTZo0YcmSJWzZsoXZs2cTEBBwR3G9++67jB07lj59+jBjxgwyMjL49NNPad++fYlJzJ0YOnQoFouF0aNH86tf/YqcnBw+//xzwsLCuHTpUrnb69q1K5GRkcyePZu0tLSipYzHjh0Dyrb9dWBgIA888AAffPABdrudBg0asG7dOk6fPl3qM6dPn2bMmDEMHz6cbdu2sWDBAqZMmUKnTp3K/R527tzJgAEDeOONNyr8vAoh9CAjB0KUUf/+/dm2bRvdunXj008/5fnnn+fLL7+kbt26/OY3v7nlsz4+PmzatImpU6cyf/58Xn75ZdLT05k3b95NexyUx+jRo4mJicFms/HHP/6RZcuW8eWXX9KqVSu37YjYqlUrlixZgqIo/O53v+O///0vTz311F3F/dVXX/HrX/+ab7/9lj/84Q/YbLaiUZWyxh0dHc2wYcP417/+xZ/+9CfMZjNr1qwp9f5Fixbh5eXFH//4R7799luee+45vvjiizt+D0JUZ4omVTZCVDudO3emTp06rF+/Xu9Qymz//v3cd999LFiwgKlTp7qt3TfffJO33nqL1NRUateu7bZ2hajOZORAiCrMbrfjcDiKXdu0aRMHDhzw6KOT8/Pzb7o2e/ZsDAYDDzzwgA4RCSGuJzUHQlRhFy5cYPDgwUybNo369etz5MgR/vvf/1K3bt0SNw7yFB988AF79uxhwIABmEwm1qxZw5o1a3jqqado1KiR3uEJUeNJciBEFVarVi26du3KnDlzSE1Nxc/Pj1GjRvHee+959DkAvXv3Zv369fzlL38hJyeHxo0b8+abb/Laa6/pHZoQAqk5EEIIIcQNpOZACCGEEMVIciCEEEKIYiQ5EEIIIUQxkhwIIYQQohhJDoQQQghRjCQHQgghhChGkgMhhBBCFCPJgRBCCCGKkeRACCGEEMVIciCEEEKIYiQ5EEIIIUQxkhwIIYQQohhJDoQQQghRjCQHQgghhChGkgMhhBBCFCPJgRBCCCGKkeRACCGEEMVIciCEEEKIYiQ5EEIIIUQxkhwIIYQQohhJDoQQQghRjCQHQgghhChGkgMhhBBCFCPJgRBCCCGKkeRACCGEEMVIciCEEEKIYiQ5EEIIIUQxkhwIIYQQohhJDoQQQghRjCQHQgghhCjGpHcAQgghysepaaRZnaTkO0jNd5LrUHFqGkZFwc9koI6PkTAfE6HeRoyKone4ogqS5EAIIaqILJuTpPQCEtKt5No1VE3DoCiomlZ0T+HPBkXBz6zQMcSbdiFeBFqMOkYuqhpF0677UyWEEMLjFDhVtlzKIyG9AKemgQYmg4IBUEoYGdA0DRVwqBooYFQUOoZ40aeeL15GmU0WtyfJgRBCeLCz2XbWnc8h0+bEgIJJKTkhKI2maTg0UNEIthgZ0tCfxgHmCoxYVAeSHAghhIdKSLOy4UIuqqZhVhQMd1E/oGoa9mvTDYMa+NEx1NuNkYrqRsaXhBDCAyWkWdlwPhdV1bDcZWIArloEi6KgqhobzueSkGZ1U6SiOpLkQAghPMzZbHvRiIHFoJRrGuFWFEXBYnAVLG64kMvZbLtb2hXVjyQHQgjhQQqcKuvO57g9MSh0fYKw/nwOBU7Vre2L6kGSAyGE8CBbLuWRaXNiVtyfGBRSFAWzonDV5mTLpbwK6UNUbZIcCCGEh8iyOUlIL8DA3dcY3OhM4h5eG9SW1wa1JTczA4OiYEAhIb2ALJvTrX2Jqk+SAyGE8BBJ1/YxMLl5wEBVVb755B0s3r7FrpsU126LSekF7u1QVHmSHAghhAdwahoJ6VbQyrePQVns+mYxmamX6TYysth1RVFAg4R0q2tzJSGukeRACCE8QJrVSa5d42j8Ol4b1JbTB3bddM/O1Yt4bVBbLp8+VuZ287Iy+WHexwya/hze/oE3vW4yKOTaXWc1CFFIkgMhhPAAKfkOVE2jdc9+ePn4kbhp7U33JG5aS3iTFtRt2rLM7f4w72MCQurQ48GHSnzdgGsXxdR8x52GLqohSQ6EEMIDpOY7XRsVefvQqmc/kuLWoTp/+TafnZbKmQO7aN9/eJnbvHzqKLu+WcyIZ36PwVjywUvKtVURKfkyciB+IcmBEEJ4gFyHWnS6YscBI8m5mlZsaiEpfh2qptJxwIgSntZwqjd/uH/zybu07NGXFt363LJvVdPIc8h+B+IXkhwIIYQHuL4gsEWPCLz9AkjcuKboWsLGNdRr1praDZsUe05DI/XKFVJSUkjPSCcvPw9VU0ncuIazh/Yz4pnfl6l/hxQkiutIciCEEB7AeN0KBZPZQts+gzi0+QecDgdZV5I5m7SPDiWMGhQUFOBwOFBwPZ+dlUVqairf/Ps9WvcZhMFkIuPyBTIuX8CakwVAZsplstJSirVjqqANl0TVZNI7ACGEEOBnMhTb+Kh9/+HsXbeCU/u2k/LzKTRNo0P/m5OD/Px8LBYLDocDLy8vgoOCsFoLyLqSQuKP35G48TsUru22eK35fz0dSd17W/H858sB16FMvib5rih+IcmBEEJ4gDo+RlRNQ7u2z0HzLr3wDQgiYeMarpw9TcPWHQmp17DYM6qqYrPZCAgIwG63k5eXh6+vL76+vjz6l09xqk5sNht2uw2n08mxrRs5vm0jE/7wDiHh9QHXSgVN0wjzKblgUdRMkhwIIYQHCPMxYVAUVMAIGM1m2kYMIXHTGmzWPIb/6pWbnrFaXccue3t7Yzabyc/Px1Zgw8vLi7YRg667U8PucJB58SzHtv1IaLO2BITUJic3B4uXN4rBSB0f+TgQv5BxJCGE8ACh3kb8zAoO9ZfCwA4DRlCQn+v69xKWMOZb8/GyWDAoBswmM2azmbz8kg5SUjCbzHh5eWMwGAgODnbdm5tLTl4+V1MusiLqS1JSUkp4VtREiqZJiaoQQniCbZfz2Jqch6UMJzI6nA6uXLlCcHAw3l7egCtZyMzMpHbt2piMtx8JUDWVfLuTlO3fs+SDP+N0OunTpw8TJkxg5MiRBAQEuOV9iapHkgMhhPAQWTYnc49cRdPAbLh1cpCdk01+fj516tQpWqmgoZGamoq3tzeBATdvlXwju6qhKDCzdTBafg7ffPMNy5cvZ9u2bVgsFoYOHcr48eMZOHAgFovFLe9RVA2SHAghhAf58XwO+9KsmJWSj2122u3kZmWQnp6OxctCgF/xb/c5uTloBhP1GjRAUUqfOVY1DbumcV+oNwMb+hd77eLFi6xYsYLly5eTlJREUFAQDz74IBMmTOD+++/HYJAZ6epOkgMhhPAgBU6VBccyuWpzlji9cGr/Tr747XRUVXV9SJcwwDDoqVfoOeYhfH18b34R1woFm6YRbDEyrWUQXsbSP+yPHTvGsmXLWL58OefOnaNevXqMHz+eCRMm0KZNG7efICk8gyQHQgjhYc5m21l6OgtV1bAYiicI+dlZHNu/A4fdQVBQECVlB94hdfAODKZ2aOhNr2uahk3VMBgUIpsG0jjAXKaYNE1jz549LFu2jJUrV5KRkUHLli2ZMGEC48ePp1GjRnfzloWHkeRACCE8UEKalQ3nc1G14gmCpmmkpKbg5+eHv59/ic/abAWkZ2QQEhKCxfxLrUBRYqAoDGroR8dQ7zuKzW6389NPP7F8+XLWrl1Lfn4+3bt3Z9KkSUybNu2O2hSeRZIDIYTwUAlpVjZccCUIhTUIhSsS6tSujbHUFQkaV9LSMJlMBAcFA7/UGBgUhUEN7jwxuFFubi7ff/89y5cvZ+/evSQlJbmlXaEvSQ6EEMKDnc22s/58DldtTgwo5GReRUMjpFbILZ/Ly88jOyub0Nq10RQDKq4agyEN/cs8lVBe6enphITcOq4yWbQI/u//oHCqIjgYliy5+3ZFmcmWWEII4cEaB5iZ1jKILZfyOHAlH81kxstiwalpGKDEgkBN0zB7eWPxdWK1O/D2snBfiDd96vnesvjwbrklMSjUuzfMm+e+9kS5yHoUIYTwcF5GAwMb+mPe/Q17l3xBoLcJpwY21VVDYHWqRb8Kr2koGB029i//ksea+zOwoX+FJga3tX8/TJoEw4fDkCGwerV+sYjbkpEDIYSoAjRNY2nUV7Rq1Yqn2oWSZnWSmu8gJd9JnkPFoWmYrp2uGObjOish41w6n375CXE92jBu3Dj9gs/KgldegQULIDwc0tNh6FDo3h3q1i35mZ07YfBg8PGBp56C0aMrN+YaTpIDIYSoApKSkjh69Civv/46RkUhzMdEmI+Jdrd4JqxlCyIiIpg7d66+ycGuXXD2LEydWvz6iRMlJwdDhsCYMa7E4PhxePhhqF8funatnHiFJAdCCFEVxMbGUrt2bfr161eu52bOnMnMmTNJTEykQ4cOFRTdbWgatGxZ9qmE62sXWrSAQYNcCYaHJAdOTSPN6iQl30FqvpNch4pT0zAqCn4mA3V8jIT5mAj1NmKsoptESXIghBAezuFwsHz5csaPH4/JVL6/tgcPHkz9+vWZN28eH374YQVFeBvdu8O5cxAfD337uq4lJbkSBnMJKycuX/5lRCE1FTZvdo0k6CzL5iQpvYCEdCu5dg312tJQ9bpFf4U/GxQFP7NCxxBv2oV4EWgx6hh5+clSRiGE8HAbNmzg0UcfZd26dbRv377cz3/yySd8+OGH7Nu3j+DgYPcHWBaJifD22656A4cDGjRwrUbw8rr53r/9Db7/Hkwm16jDo4/C9OnFbtE0rdK2bi5wqmy5lEdCegFOTQMNTAbllqtFVHAdv62AUVHoGOJV4atF3EmSAyGE8HBPP/00x44dY8OGDXf0gZiWlkaXLl344x//yDPPPFMBEVY+u93Orl27qF+/Pk2aNKmwfs5m21l3PofMa/tMmJSSE4LSaJqGQ6NS9plwp6qRwgghRA2VlZXF2rVrmThx4h1/Uw4NDWXs2LHMnz8fp9Pp5gj1oSgKu3btonfv3owePZq5c+dy5coVt/aRkGZl6eksMm1OzIqC2XDzQVhlidNsUDArCldtTpaeziIhzerWOCuCjBwIIYQHi46O5pVXXmHPnj3ULW3ZXxns27ePUaNG8dVXXzF48GA3RniHkpLgxRdvvj55smvpYhnYbDbWrFnDsmXL2LhxI5qm8cADDzB+/HiGDx+Ov3/JZ0+URWlnW9wNd51tURkkORBCCA82fvx4vLy8WLhw4V23NXLkSGrVqkVUVJQbIvMsGRkZrF69mmXLlrFz5068vb0ZNmwYEyZMoH///phLKnwsxa1Oxbxbd3oqZmWT5EAIITzU2bNn6dmzJ5988gmRkZF33V5sbCwvvvgiW7ZsoWnTpm6I0DOdP3+eFStWsGzZMo4cOUKtWrUYPXo0EyZMoFu3bhgMpc+oFzhVvj6WSabNiUVxb2JQSNM0bJqrBmFayyCPLFKU5EAIITzUP//5T/71r3+RkJCAr6/vXbdXUFBA165diYyM5K233nJDhJ7v8OHDLFu2jOXLl3Px4kUaNmzIuHHjmDBhAq1bt77p/h/P57AvzVp0CmZFKTwl875QbwY2vPPpj4oiyYEQQnggTdPo06cPPXr0YPbs2W5r99133+Wrr75i7969bkk4qgpVVdm5cyfLli1j9erVZGZm0qZNGyIjIxk7diwNGjQgy+Zk7pGraBqYDXefGOxYGcOp/Ts5d/gAmamX6TJ0HJF/eLfodbuqoSgws3Wwx+2D4HljGUIIIdi7dy9nzpxh4sSJbm33scceIycnh2XLlrm1XU9nMBjo2bMnH3zwAQkJCXz55Ze0aNGCv//973Tv3p0JEyaw4McdOFQNk5sGDOIWfcGpfdsJb9ICo/HmzatMimu3xaT0Avd06EayQ6IQQnig2NhY6tWrR69evdzabsOGDRkyZAjz5s1j6tSplbaRkCcxm80MHTqUoUOHkpOT41rxsGIFZx1e+Oblku904OPjg5eXFwp3/vsz68P5BIfXR1EU3hrV7abXFUUBVSMh3UqPcB+P2mpZRg6EEMLD2Gw2Vq5cSWRkJEaj+4ebZ86cyeHDh9mxY4fb265q/P39mTRpEh/NmU+dho05tX0jH4zvzcGtm0hNSSEzK5MCWwEaGjtXL+K1QW25fPpYmdquVbfBbZMvk0Eh1+46q8GTSHIghBAe5ocffiAzM9PtUwqFIiIiaNasGV9++WWFtF8VpeQ70FDo2HcIPn7+XDiwA18/P+x2OxkZGaSmprLvh9XUuacZdZu2cFu/Blz1Jan5Dre16Q6SHAghhIeJjY2lU6dOtGzZskLaVxSFmTNn8t1333H58uUK6aOqSc13YlAULN4+tOrZj0PxP+Dr7UPt0FBCQ0Nx5ufwc+JemnaL4EpaGjm5OTicd/+BrlxbLpmSLyMHQgghSpGens6GDRsqbNSg0MSJE/Hy8mLBggUV2k9VketQi05X7DhgJDlX0zh9YBegYDaZ+XnvNhQFug8fj9lsJi83lytXrpCWnkZeft5d9a1qGnkO1Q3vwn0kORBCCA+ycuVKAMaOHVuh/QQEBDBp0iQWLFiA3W6v0L6qAud1q/pb9IjA2y+AxI1riq4lbFxDvWatqX9vS4ICg6gTFkZwUDBOp5OszMy7HkVweNiuApIcCCGEB1myZAkDBgygdu3aFd7X9OnTSUlJ4bvvvqvwvjzd9SsFTGYLbfsM4tDmH3A6HGRdSeZs0j46DBhR7BlrgRVVVdEo30mNJTF50EoFkORACCE8xokTJ9i3bx+TJk2qlP5atmxJREQEc+fOrZT+PJmfyVBsR8T2/YeTm5XBqX3bSdz0PZqm0aG/KzlQNZWMjAwKCgrw9vbGZDJhNNz5qhKDouBr8qyPY8+KRggharAlS5YQGBjIkCFDKq3P6dOns2vXLpKSkiqtT09Ux8eIqmkUbhrcvEsvfAOCSNi4hoOb1tKwdUdC6jXEqTpJT0/H4XBQq1YtNE3DZLrzLYO0a32G+XjWDomyCZIQQngAVVVZunQpY8aMwcvLq9L6HTp0KPXq1WPevHn84x//qLR+PU2YjwmDoqACRsBoNtM2YgiJm9Zgs+Yx/Fev4HA6yMjIACAkJAST0USm/So+pWxDfWTbRi6dOAqA02Hn8qmjbPz6vwC06TOAuve2QsU1JVHHx7M+jj0rGiGEqKG2b9/OhQsXKm1KoZDJZOLxxx9n9uzZvP766wQHB1dq/54i1NuIn1khx6ZiNLqmFzoMGMHuNUtQFIXWfQaRnp6OwWCgVq1aGA1GnKoTp6qWOnKQFLeevetWFP188cRhLp44DEBgnXDq3tsKh6rhbzEQ6u1ZIwdy8JIQQniA3/zmN2zfvp2tW7dW+pbGV65coWvXrvzpT3/i6aefrtS+Pcm2y3lsTc676ajmAlsBV69exWw2ExwcjEExFF3PyMigTp06d1RzUHh0c+9wX3rV9axDsKTmQAghdJafn88333zDxIkTdTnroHbt2owZM4b58+ejqp613r4ytQvxwqgoOK77ypxvzedqxlW8LF7UqlWrKDEAsNvtGAwGjIY7+yh1aK5VEu1CKm8aqawkORBCCJ2tXbuW3NzcCt/46FZmzJjBzz//zMaNG3WLQW+BFiMdQ7xQ0VA1ldy8XDIzM/Hx8SEoOAgFBafdTnZaKtlpqVxNvYw1O5PstCtF17LTUrEXWG/bl6ppqGh0DPHyuOOaQaYVhBBCd1OmTCE3N7doAyQ9aJrGyJEjCQ0NrdG7JhY4Vb4+lklqdj65WVfx9/fH388Prp3OeGr/Tr54eTrgKiJVbpiCAJjwyjt0HT6+1D4KpxOCLUamtQzCy+h539OlIFEIIXSUnJxMXFwc7733nq5xKIrC9OnT+c1vfsOZM2do0qSJrvHoRXE6SFz8GbUGTMY/OAQ/ixmuO7a5XrPWzPjgCzRUMjKu4u/nh8VSfFogrEmzUtvXNA2bqmEwKAxp6O+RiQHIyIEQQujqv//9L++99x4HDhwgKChI11isVitdu3Zl8uTJvPHGG7rGoofs7GyeeOIJdu7cyV/nLSY1pBmqpmEx3Dw6YLMVkJ6RQe3atTEZy/Y9uygxUBQGNfSjY6h3RbwNt/DMlEUIIWqI2NhYhg0bpntiAODt7c2UKVOIiYkhL+/uDhOqalJSUoiMjCQhIYGFCxcybUAPBjX0w2BQsGla0aFMhewOB4qiYDSWrV5AvTaVYDB4fmIAkhwIIYRuDh06xOHDh3UtRLzRY489RnZ2NsuXL9c7lEpz5swZxo4dS2pqKsuXL6dnz54AdAz1JrJpIMEWI3ZNw67+soOiw27HbDKjcOvVJdq15+zXagwimwZ6fGIAkhwIIYRuYmNjCQkJoX///nqHUqRRo0YMGTKEuXPnUhNmnQ8cOMDo0aMxmUysXr2aNm3aFHu9cYCZaS2DuC/UG0UBm6ZR4FRxaBomc8nTCZqm4bx2n03TUBS4L9SbaS2DaBxgroy3ddckORBCCB04HA6WL1/O+PHjMZs96wNj5syZHD58mF27dukdSoWKi4sjMjKSe+65h5UrV9KwYcMS7/MyGhjY0J+ZrYPpHe6Lr0kBxYDRywebqmF1qkW/bKqrrsCpgb/FQO9wX2a2DmagBxcflkRWKwghhA7i4+NJSUmp9O2SyyIiIoJmzZoxd+5cevTooXc4FWL58uW89NJLPPDAA3z22Wf4lnI+wvUCLUZ61fXFeP4QT7zyMv/4bC6W0LrkOa6NJFw7XTHMx0gdHxOh3sZiR0FXJZIcCCGEDmJjY2nZsiUdOnTQO5SbGAwGpk+fzltvvUVycjLh4eF6h+RW//vf/3jzzTeZPHkyf//738s9cpOUmEjWxTMMbNPY40Z93KXqjHEIIUQ1kZ2dzZo1a3TbLrksJk2ahMViqVYbIqmqyl//+lfefPNNnnvuOf75z3/e0Yd7YmIirVu3rraJAUhyIIQQle67777DZrMxYcIEvUMpVWBgIJMmTeLrr7/GbrfrHc5ds9vtvPTSS/z73//m7bff5tVXX73jxCwxMZH27du7OULPIsmBEEJUstjYWPr06UP9+vX1DuWWpk+fTkpKCmvWrNE7lLuSm5vL9OnTWblyJf/5z3+YNWvWHbdls9k4duyYR04HuZMkB0IIUYnOnz/P1q1bPbIQ8UatWrWid+/ezJ07V+9Q7lh6ejqTJ09m586dLFiwgLFjx95Ve0ePHsVut0tyIIQQwn2WLl2Kj48PI0eO1DuUMpkxYwY7d+7k0KFDeodSbufOnWPMmDGcO3eOZcuW0bdv37tu8+DBgxgMhpv2Q6huJDkQQohKomkasbGxjBw5Ej8/P73DKZNhw4ZRr1495s2bp3co5XLo0CFGjx6NqqqsWrXKbd/0ExMTad68eZmWPlZlkhwIIUQl2b9/P6dOnaoSUwqFTCYTjz76KEuXLiUzM1PvcMpk69atjB8/nvDwcFauXOnWEyZrQjEiSHIghBCVZsmSJYSHh9OnTx+9QymXqVOn4nQ6Wbhwod6h3NY333zDI488QufOnVm6dCl16tRxW9tOp5OkpKRqX28AkhwIIUSlsNvtLF++nMjIyDKf5Ocp6tSpw+jRo5k/fz6qquodTqm+/PJLfvWrXzFq1CgWLFiAv7+/W9s/efIkVqtVRg6EEEK4x4YNG7h69apHncBYHjNmzODMmTNs2rRJ71BuomkaH3zwAa+++iqzZs3i008/rZANig4ePAggIwdCCCHcIzY2lvbt29O6dWu9Q7kjXbp0oUOHDh5XmOhwOHjllVeYPXs2r7/+Om+++SYGQ8V8tCUmJtK4cWMCAwMrpH1PIsmBEEJUsKtXr/LDDz9UqULEGymKwsyZM/nxxx85c+aM3uEAYLVamTVrFosWLeKjjz7i2WefrdDtqA8ePFgjRg1AkgMhhKhwK1euRFVVxo0bp3cod2Xs2LEEBQXx1Vdf6R0KV69e5aGHHiI+Pp758+dXeOKlaRqJiYmSHAghhHCPJUuWMGDAALdWzuvB29ubKVOmEB0dTX5+vm5xXLx4kXHjxnHixAliY2MZOHBghfd59uxZsrKyakQxIkhyIIQQFerUqVPs2bOnyhYi3uixxx4jOzub5cuX69L/sWPHGD16NHl5eaxatYouXbpUSr81qRgRJDkQQogKtWTJEgICAhg6dKjeobhF48aNGTx4MPPmzUPTtErte/fu3YwdO5bg4GBWr15Ns2bNKq3vxMREwsPDq/zoT1lJciCEEBVEVVWWLl3K6NGj8fb21jsct5k5cyZJSUns3r270vpct24dkyZNok2bNixfvpzw8PBK6xtqVjEiSHIghBAVZufOnZw7d65Kr1IoSd++fWnatGmlndYYExPDzJkzGTRoEDExMbosJawp2yYXkuRACCEqSGxsLI0bN6Z79+56h+JWBoOBGTNm8O2335KcnFxh/WiaxkcffcTLL7/Mo48+ymeffYaXl1eF9Vea5ORkUlNTZeRACCHE3bFarXzzzTdERkZW2KY8epo8eTIWi4WoqKgKad/pdPL666/z/vvv88orr/Duu+/qtu10YmIigIwcCCGEuDvr1q0jOzu72qxSuFFgYCATJ07k66+/xm63u7XtgoICnnnmGebPn8/f//53fvOb31To5ka3c/DgQYKCgmjYsKFuMVQ2SQ6EEKICxMbG0rVrV5o2bap3KBVm+vTpJCcns2bNGre1mZWVxdSpU1m/fj1z5sxh6tSpbmv7ThVufqRnglLZJDkQQgg3S0lJYdOmTdWuEPFGrVu3ZvPmzW4bbk9OTmbChAkcPHiQRYsWMXz4cLe0e7dq0s6IhUx6ByCEENXNihUrMBgMjBkzRu9QKty9997rlnZOnz7Nww8/jN1uZ+XKlbRq1cot7d6tq1evcv78eUkOhBBC3J3Y2FiGDBlCcHCw3qFUCZqm8cUXX+Dt7c2yZcto0KCB3iEVKdwZsSYVI4JMKwghhFsdPnyYpKSkaj+l4E5Op5MhQ4awcuVKj0oMwDWl4OvrW61rR0oiIwdCCOFGS5cupVatWpVyGFB1YTKZiIiI0G2p4q0kJibStm1bj4ytIsnIgRBCuInT6WTp0qWMGzcOs9msdzieYeVKGDwYBgxw/frvf0u8zVM/fGvatsmFJDkQQgg32blzJwaDgSlTpugdiueoXx+io2HjRlei8NVXsHWr3lGVSW5uLidPnqRjx456h1LpZFpBCCHcpFevXuzZs0fvMCre/v3wzjuQnQ1OJ7zwAoweXfK9128dHRgIzZvDuXOVEubdOnToEJqm1bhiRJDkQAghRHlkZcErr8CCBRAeDunpMHSoKwmoW/fWzx47Brt3w/vvV06sd+ngwYOYzWZatmypdyiVTpIDIYQQZbdrF5w9CzfuXHjixK2Tg0uXYPp0V2JQr16FhuguCQkJtG7dukbWj0hyIIQQouw0DVq2hNWry/5McjJMngwvvVT69IMHOnjwIJ06ddI7DF1IQaIQQoiy697dVTMQH//LtaQkKO3wpeRkmDQJnnvOlSBUETabjaNHj9bIegOQ5EAIIdwrLw9+8xsYOBD69nUV7mma3lG5T1AQfP01fPwxDBoE/fq53qOqlnz/3/8OFy7A55+7ljQOHgyLFlVuzHfg6NGjOByOGrmMEUDRtOr0p1YIIXT23ntw8SJ89BE4HK559ocfrlLD6QKio6P5/e9/z/Hjx/Hx8dE7nEonIwdCCHE7+/e7hsaHD4chQ249337okGuzH0UBsxkeeACWLKm0UIV7JCYm0rx58xqZGIAUJAohxK2Vd+lex46u5GHUKNc8/Nq1rjaqs6QkePHFm69PngxPPVX58bhBTd0ZsZAkB0IIcSvlXbr33HOuOfiRI12b/tx3H2zeXDmx6qVdO/jhB72jcBun00lSUhIPPvig3qHoRpIDIYS4lfIu3fP2hr/85ZefP/0UWrWqmNhEhXA4HKxZs4ZGjRrpHYpupOZACCFupbxL97KzIT/f9e9nz8L8+fD00xUfp3AbLy8vWrVqha+vr96h6EZWKwghxO0kJsLbb7vqDRwOaNAA5s0DL6+b701Kcs2zm0yuXy+/7JpiqGaSk5P5wx/+QGZmJn/7299o3bp1ife99NJLKIrCP//5z0qOUNwNSQ6EEEKUy5EjR5gyZQoWi4WYmBiaNm1a6r2rVq3i6aefZsOGDbRp06YSoxR3Q6YVhBBClNmOHTsYN24cISEhrFq16paJAcCIESMIDw/nyy+/rJwAhVtIciCEEOWVlPTLbn/X//rf//SOrEKtXbuWhx56iA4dOrBs2TLCwsJu+4zZbObRRx9lyZIlZFXVJZ2zZ0OvXq5f772ndzSVQqYVhBBC3Nby5cv505/+RL9+/fjkk0+wWCxlfjYlJYXu3bvz5z//mVmzZlVglBVg+3b44x/hu+9cNSRjxsDvfudKBqsxSQ6EEEKUiaqqKIqCoijlfvaZZ54hISGB+Ph4DAadB63373ftRZGdDU4nvPBC6dtbv/oq1K/v2r8C4MsvYfdu1xLVakymFYQQohwKCgo4d+4cVqtV71AqncFguKPEAGDmzJmcPn2a+OuXhOqhcMfLTz917V65aBG89RZcvlzy/RcuQMOGv/zcqJHrWjUnyYEQQpTD66+/zoQJE8o1rC6gW7dutGvXjrlz5+obyPU7Xg4e/Msx0idO6BuXh5EdEoUQoowKCgpYvXo1M2bM0H9ovIpRFIWZM2fyu9/9jrNnz9K4cWN9AinvjpcNGsD587/8fO6c61o1J3+6hRCijNatW0dWVhYTJ07UO5Qqady4cQQGBvLVV1/pF0R5d7x88EHXqZp5eWCzwcKFMHZs5cSqI0kOhBCijJYsWUKXLl1o1qyZ3qFUPKsV+vVza1W+j48PjzzyCNHR0frVbAQFwddfw8cfw6BBrvf4zjugqiXf37u3a4XCwIGu47cfeMB1bHc1J6sVhBCiDK5cucJ9993HX/7yF6ZPn653OBXv9dddCcL+/W49cfHMmTP06dOHDz/8kIceesht7Qr3kpEDIYQogxUrVmAwGBhbFYeU9++HSZNg+HDXt97bzbfHx7uq9ydMcHsoTZo0YeDAgcydOxf5buq5pCBRCCHKYMmSJQwaNIhatWrpHUr5FC7dW7AAwsNdh0cNHeqae69bt+T7//IXiI6GY8cqJKQZM2Ywbdo09u7dS9euXSukj3JJSoIXX7z5+uTJrkO0aiBJDoQQ4jaOHj1KQkICL5b0AeLprl+6d70TJ0pODl591bUpUO3aFZYc9O/fnyZNmjBv3jzPSA7atXPr1El1IDUHQghxG++88w5RUVHs37+/6u1v8MMP8NFHZV+616PHL/9eUABXr7o2/tm82a1h/e9//+Odd95h9+7d1KlTx61ti7snNQdCCHELTqeTpUuXMnbs2KqXGED5l+7t3PnLr//8B1q0cHtiAPDQQw9hNBqJiopye9vi7klyIIQQt7B161YuX75cdfc2KO/SvUoLK4jIyEi++uorHA6HrrEATJkyhX/+8596h+ExZFpBCCFu4cUXX2T37t1s3rz5js8VECU7dOgQgwcP5vPPP2fUqFG6xZGbm0vLli1leeV1ZORACCFKkZuby7fffsukSZMkMagAbdu2pUePHsybN0/XOA4dOoSmaXTo0EHXODyJrFYQQohSrFmzhry8PCIjI/UOxb08aOnezJkzefrppzly5AitW7eu1L4LJSYmYjabadGihS79eyJJDoQQohSxsbH07NmTRo0a6R2Ke3nQ0r0RI0YQHh7O/Pnz+dvf/qZLDImJibRp0waz2axL/55IphWEEKIEly9fZvPmzUyaNEnvUKo1s9nMtGnTiI2NJSsrS5cYEhMTad++vS59eypJDoQQogTLli3DYrHoWih3pw4fPsyhQ4dISUmpElsUT5s2DZvNRmxsbKX3bbPZOHbsmNQb3ECSAyGEuIGmaSxevJjhw4cTGBiodzhlpmkaf/3rXxk0aBDLly+nTp06VaKQMjw8nJEjRzJv3jzUSl5ieeTIERwOh4wc3ECSAyGEuMHBgwc5duxYlZpSsNvtvPTSS/z73//mrbfe4rXXXqsSiUGhmTNncurUKTZXwIZLt3Lw4EEMBgNt27at1H49nSQHQghxg9jYWOrUqcMDDzygdyhlkpeXx4wZM1ixYgX//ve/efLJJ/UOqdy6d+9O27ZtmTt3bqX2m5iYSPPmzfHx8anUfj2dJAdCCHEdu93OihUrGD9+PCaT5y/oSk9PZ9KkSezYsYOvv/6acePG6R3SHVEUhRkzZrB+/XrOnTtXaf0mJiZKvUEJJDkQQojr/PTTT1y5cqVKTCmcO3eOsWPHcu7cOZYuXVplRjpKM378eAICAvjqq68qpT+Hw8GhQ4ckOSiBJAdCCHGdJUuW0KZNG4+fgz58+DBjxozB4XCwatUqOnbsqHdId83X15dHHnmE6OhorFZrhfd38uRJrFarFCOWQJIDIYS4Jisri7Vr1zJx4kSPLubbtm0b48ePJywsjFWrVtGkSRO9Q3Kbxx9/nIyMDFauXFnhfR08eBBAkoMSSHIghBDXrF69GofDwYQJE/QOpVTffvstjzzyCB07dmTp0qXUqVNH75DcqkmTJgwcOJB58+ZV+B4NiYmJ3HPPPVVquWplkeRACCGuWbJkCX379iU8PFzvUEo0f/58nnrqKUaMGMGCBQvw9/fXO6QKMWPGDBISEti3b1+F9nPw4EGpNyiFJAdCCAH8/PPP7NixwyMLETVN4+9//zt/+tOfeOKJJ/jXv/6FxWLRO6wKM2DAAO65554KPa1RVVXZNvkWJDkQQghg6dKl+Pn5MXz4cL1DKcbhcPD73/+ef/7zn7z22mu89dZbGAzV+69ug8HA448/zqpVq7hy5UqF9HH27Fmys7Nl5KAU1ftPmBBClIGmaSxZsoRRo0bh6+urdzhFrFYrTz75JAsXLmT27Nn8+te/9uhCSXd6+OGHMRqNREdHV0j7Uox4a5IcCCFqvD179nDmzBkmTpyodyhFMjMzefjhh4mLi+PLL79k8uTJeodUqYKDg5kwYQLz58/H4XC4vf3ExETCw8OrXUGnu0hyIISo8ZYsWUL9+vXp3bu33qEAcOnSJcaNG8fx48eJjY1l0KBBeoekixkzZnDp0iXWrVvn9rYPHjxYLfaGqCiSHAghajSbzcaKFSuIjIz0iLn848ePM3r0aHJycli1ahVdunTROyTdtGvXju7du7u9MFHTNClGvA39/08QQggdrV+/nqysLI+YUti9ezdjxowhKCiIb775hmbNmukdku5mzpzJli1bOHbsmNvaTElJ4cqVK1KMeAuSHAgharTY2Fg6depEixYtdI1j/fr1TJ48mTZt2rB8+XKP3Wuhso0cOZKwsDC+/PJLt7WZkJAASDHirUhyIISosdLS0vjxxx9139tg4cKFzJw5k4EDBxITEyM79l3HbDYzbdo0YmNjyc7OdkubBw8eJDg4mAYNGrilvepIkgMhRI21atUqAMaOHatL/5qm8dFHH/Hb3/6WqVOn8tlnn+Hl5aVLLJ7s0UcfpaCggCVLlrilvcJ6g5qyLPROSHIghKixYmNjGThwIKGhoZXet9Pp5PXXX+f999/nd7/7HX/7298wGo2VHkdVEB4ezsiRI5k7d65bzltITEyUlQq3IcmBEKJGOn78OPv379dlSsFms/Hss88yf/58PvjgA37729/Kt9jbmDFjBidPnmTz5s131U5GRgYXLlyQYsTbkORACFEjLVmyhMDAQIYMGVKp/WZlZTF16lS+//575syZw7Rp0yq1/6qqR48etGnThrlz595VO7IzYtlIciCEqHFUVWXp0qWMHTu2Ug8wSk5OZsKECSQmJrJ48WKPO8fBkymKwowZM1i/fj3nz5+/43YSExPx8/OjadOmboyu+pHkQAhR42zbto2LFy9W6pTC6dOnGTNmDOnp6axYsYIePXpUWt/VxYQJE/D39+err7664zYSExNp27atR2x45cnkd0cIUeMsWbKEJk2a0LVr10rpb//+/YwePRovLy9Wr15N69atK6Xf6sbX15eHHnqIqKgoCgoK7qiNgwcPSr1BGUhyIISoUfLy8vjmm2+YOHFipRQBbtq0iYkTJ9K0aVNWrlwpa+vv0vTp08nIyChahloeOTk5nDp1SpKDMpDkQAhRo6xdu5bc3FwiIyMrvK+lS5fy2GOP0adPHxYvXkytWrUqvM/qrmnTpgwYMOCOzls4dOgQmqZJclAGkhwIIWqUJUuW0KNHD+65554K7ee///0vzz//PJGRkXzxxRf4+PhUaH81yYwZM9i/fz/79u0r13MHDx7EbDbrvlV2VSDJgRCixkhOTiYuLq5CCxFVVeXtt9/m7bff5oUXXuDDDz/EZDJVWH810YABA2jcuHG5Rw8SExNp06YNZrO5giKrPiQ5EELUGMuWLcNkMjF69OgKad9ut/PCCy/w2Wef8de//pU//vGPsrlRBTAajTz++OOsXLmStLS0Mj+XmJgoUwplJMmBEKJG0DSN2NhYhg8fXiEHG+Xm5vLYY4+xevVq/vOf/zBz5ky39yF+8cgjj2AwGIiOji7T/TabjWPHjsnmR2UkyYEQokY4dOgQR44cqZBCxCtXrjBx4kT27NlDVFQUY8aMcXsforjg4GDGjx/P/PnzcTgct73/yJEjOBwOGTkoI0kOhBA1wpIlSwgNDaV///5ubffs2bOMGTOGixcvsmzZMiIiItzavijdjBkzuHjxIuvXr7/tvYmJiRgMBtq0aVMJkVV9khwIIao9h8PBsmXLGD9+vFuL0ZKSkopGCVatWiVD1pWsQ4cOdOvWrUyFiQcPHqRFixayaqSMpIRWCFHtxcXFkZqa6tZVCps3b2bmzJk0a9aMr7/+mtq1a7utbVF2M2fO5Nlnn+X48ePc27w5aVYnKfkOUvOd5DpUnJqGUVHIrtea7mObkpLvINTbiFEKRW9J0dxxOLYQQniwZ555hsOHD7Nx40a3rB5YtWoVzz//PL1792bOnDn4+fm5IUpxJ+x2O32HDGfEzOep2+0Bcu0aqqZhUBTU6z7e8nJzsXh5YTGb8TMrdAzxpl2IF4EWo47Rey6ZVhBCVGtZWVmsXbuWSZMmuSUxmDdvHs888wyjR4/mq6++ksRARwVOlfjkAsZ9MB9Diy5k21SMCngZFCwGBW+jAW+jARMqtvxczAYwKpBjU9manMfcI1f58XwOBU5V77ficWRaQQhRrX333XfYbDYmTJhwV+1omsb777/Pxx9/zK9+9Sv+/Oc/y8l+OjqbbWfd+RwybU7MFi9yr1zBy2jA6ON70712ux0As8mEQVEwGhU0TcOhwb40K6ez7Qxp6E/jANkcqZBMKwghqrXIyEhMJhOLFi264zYcDge///3vWbhwIX/+85955pln3BihKK+ENCsbLuSiahpmRcGgKFzNvIrD4aB2aChQfIQoOyebAquV2rXr3NSWqmnYr01DDGrgR8dQ70p6F55N0l4hRLV17tw5tm3bdleFiPn5+TzxxBMsWbKEjz/+WBIDnSWkWdlwPhdV1bBcSwzAdZyzw+HAZrPd9IzdbsdUyioVg6JgURRUVWPD+VwS0qwVGn9VIdMKQohqa+nSpfj4+DBixIg7ej4jI4PHHnuMw4cPM3/+fAYMGODmCEV5nM22F40YWAxKsRoSi9mMyWQiLz8fi8Wr6LqGhsPuwM/v5umGQoqiYDGATdXYcCGXYIuxxk8xyMiBEKJa0jSNJUuWMGrUqDsqGrx48SLjxo3j9OnTxMbGSmKgswKnyrrzOSUmBi4Kvr6+FFitOFVn0VWn04mqqaWOHBQ9rbiKGFVNY70UKUpyIISonvbt28epU6fuaErh6NGjPPjgg1itVlatWsV9991XARGK8thyKc9VfKiUlBi4+Hh7oygG8vLyiq4Vbq1svuFkzN3fLWX29Ad5Y3hnPnx0ONuWR6EoCmZF4arNyZZLedRkkhwIIaqlJUuWULduXXr37l2u53bu3MnYsWMJCQlh1apV3HvvvRUUoSirLJuThPQCDPxSY1ASRTHg7eNNfn4+Gq5ae7vdjtFoxGD4ZT+DnasXsfz//ZmwJs158PnXaNyuM998+g5xC+dgUBQMKCSkF5Blc5bWVbUnNQdCiGrHZrOxYsUKpk6ditFY9k1uvv/+e55++mm6du3K3LlzK+T0RlF+SekFODVXAeLt+Pr6kpeXh9VqxcfbB4fDgem6UQN7gZX1cz+i1f39mPLmbAC6j5qEqqps/Pq/dB81GW//AGyaRlJ6Ab3qll6rUJ3JyIEQotrZsGEDV69eZeLEiWV+JioqiieeeIIhQ4YQHR0tiYGHcGoaCelWDv20jtcHt+P0gV033bNz9SJeG9SWy6ePYTKa8PLyuja1oGG324udp3Fq3w7ysq5y/5iHi7XRc9wUbNY8jm7f5Jq20CAh3Yqzhq72l+RACFHtLFmyhA4dOtCqVavb3qtpGh9++CGvvPIKjz/+OP/5z3+wWCyVEKUoizSrk1y7Rpte/fDy8SNx09qb7knctJbwJi2o27QlAL4+vtjtdgpsNlRVLTZycOnEEQAatCp+SFaDFu0wKAYuXnvdZFDItWukWWvm1IJMKwghqgynppV6sI6fyUAdHyPe9jx+3LiJ11790+3bczp5/fXXmT9/Pn/4wx944YUX3LLFsnCflHwHqqbh5eVNq579SIpbx4PPvYrh2nRRdloqZw7sYsDjvy56xuJlwWg0kpubC1Bs5CA7PRWDwYh/rdBi/RjNZnwCg8m+kgy4vjk7NI3UfAdhPjXvo7LmvWMhRJWTZXOSlF5AQrq11IN1Cn92Ouw89PFimrS9hyybs9SDdQoKCvj1r3/N2rVr+X//7//xyCOPVNbbEeWQmu/EcG2FQscBI0nY+B2nD+yiWZeeACTFr0PVVDoO+GUvC+XassbsrCwMBgPG67a5thdYMZpKXtZosliw2wpcbSgKigIp+U7aVeD781SSHAghPFaBU2XLpTwSrhWkobmGe39Zzlb8W76mQUZ+PgF1wjmQDQePXKVjiBd96vniZfzlAyIrK4sZM2awd+9e5s6dy9ChQyv5nYmyynWo15JAhRY9IvD2CyBx45qi5CBh4xrqNmtNcL2GFNgKUFUVVVVxOlwjDiaDgev/nJi9vHE67CX25bDZMF+3gZKqaeQ5auZ+B5IcCCE80vUH6xhwbXGrGG495O9UndgKrAT7eGNRlBIP1klOTmbKlClcvHiRxYsX071790p6R6I8VFUlLS2N9AwrTtWLfHsBTqeT5t37khj3PX0efZacq2mcSdhDr4dnceXKlaJnDQZD0WiD7w0bYAWE1EFVneRkpBWbWnDa7eRnXSWgdnix+x01tCBRkgMhhMcp6WCdsrBarRgMBry8vFBQMCuganDV5mTp6Sw6mHN59fGJOJ1OVq5cScuWLSv4nYgb2e12rly5QnJyMikpKcX+Wfjvly9f5sqVKzidTgb/5i+0iBhKQW42BoOB5j37kfjjt5w/tJ+MCz+DAt2GjyMkJASjwYDBaERBIS8/j+ysLLy8vIr1X7e5q0j1wtGDtOrZr+j6hWMHUTWVes1aF7vfVENrUCQ5EEJ4lKKDdUrdJrdkGhr5+fl4X0sMChkUBQtgdTjZmq3Sov8o/vGbp6hXr14FvQMPsn8//PnPkJQE/frBvHkV1lVBQQEpKSlFH+43fuAX/jMtLY3rDwM2GAzUqVOHsLAwwsPDadeuHQMHDiQ8PJzw8HAywlpwXvEm2N8XBYXQ/sNZ9693ObUzjitnT9OoTSfq3dPspnjy8/OxeHlhNBSvOWl2X098A4LYuXpRseRgx6qFWLx8il0zKAq+ppq5qE+SAyGEx7jVwTq3Y7fbcTqdePv43PSazW4j6+pVvP0C6Dr119j9g9wZtucKD4e334aDB+HHH++oidzc3BK/4d/4wZ+ZmVnsObPZXPSBHxYWRvfu3Yv9XLduXcLCwggNDb3lRlUH062cP5sDrrIDjGYzbSOGkLhpDTZrHsN/9cpNz9gddux2O8HBwTe9ZvbyZtCM51n98V+Jees3tOjWhzOJe9j/w2qGzHwR30DXnw1N09A0jTCfsm+iVZ1IciCE8Ai3P1jn1vLz8zEajVhuOGAn35pPVmYWFi8LAb7e2DVYfz6HaS2DihUpVhn798M770B2Njid8MILMHp0yffWq+f6dexYqc1pmsbFixdZuXJliUlA4XLAQt7e3kXf6sPDw2nVqlXRB/71/6xVq5ZbloWG+ZhcK1GAwo/pDgNGsHvNEhRFoUP/4Tc9k5+fXzS9VJKeY6dgNJnZvPhLDm/9keCweox85o/0jny06B4V14qFOjVwGSNIciCE8BBlOVinNBoaBVbrteIzpehqbl4e2dnZ+Pj4EBgY6KpDQCs6WGdgQ3+3v48KlZUFr7wCCxa4RgXS02HoUOjeHerWveNmExIS+Oijj4o+2MPDw+nUqdNNH/hhYWEEBARU6l4Qod5G/MwKOTYVo9HVb/OuvXhnw6ES79fQXFsn+/gUm166UfdRk+g+qvRDuRyqhr/FQKi3jBwIIYQuynqwTmkKrAWomoa3tzeZKZfYvWYph7ZsJO3CzxhNJurd24r+056medderoN1NEhIL6BbmE+p+yB4pF274OxZmDq1+PUTJ+4qORg6dChHjx69y+AqhlFR6BjizdbkPDRNu21iUlDgWs7oU8L0UllpmgYKdAzxxigFiUIIoY/yHKxTknxrPhazBZPRxKGtP/JT9ByadutNx8EPYjaa2Ld+JfN+/wQTXnmHrsPHY1LwiIN17Hb7TQV8hf987bXXCAkJKf6ApkHLlrB6tdtiUBSlXIdT6aFdiBc7UvJxaGAu5Y+I024nL+sqVzOvogH5ppvfk7d/AGYv79v259BcSUm7kJKnJWoCSQ6EELoqPFgHjdvuY1Di86oTW0EBAYGBqJpK7aatmPmvRdRtdA/e1z4Ieox5iE+fnMCGeZ/Qdfh417dP1dVvj3Aft387zM/PL7GA78YEICMjo9hzJpOJOnXqEB4eXvI35O7d4dw5iI+Hvn1d15KSXAmDueRd/6qDQIuRjiFe7EuzomqUOLr0c9I+vnh5OqpTRTEYKOm3rzA5vBVV01DRuC/Eu2qNKrmZJAdCCF0VHqxzNH4di/7yW2Z9OJ+mnYpvTLRz9SJWzn6L5+esKDpcp5DVagVFwWKxkJGRQVC9xgTXCsZi/uXwJJPZQsv7H2DLki8pyMvBy9e/2ME6Zdk7X9M0srOzb/qAL+mbf3Z2drFnvby8is3dN2vWrKhav3COPywsjFq1amEw3KJIMigIvv7atQLhzTfB4YAGDUpfonjyJEyaBPn5YLVCly6uAsbp02/7fj1Nn3q+nM62c9XmxAI3JU/1mrXm4bc/pcCaT3BwLW7cPRMgrMnNSx6vp2kadk0j2GKkT72aeVRzIUkOhBC6KjxYp3XPX07duzE5uPHUvetZ811TClczMtCAWiG1MJewd35OeioWLx/MXq656MKDdVLyHJit2SUO7d+YAFit1mJt+vv7FyvWa9++fbEP/MJfbi3i69ABYmPLdm+zZrB3r3v61ZmX0cCQhv4sPZ2FTdWwGIonCN4BAdRt1QEvi9cdHbetaRo2VcNgUBjS0L9qrmRxI0kOhBC6KjxYx+LtU+ZT9wrZHXbsDgeK4sRoNBJSq1bRpjcaWtE++1fO/8zBuPW0jhhETl4uqlPFqToxmL34y+wvif/iw2LtBgcHF33gN27cmG7duhX7hl/4T78btuYVFatxgJlBDfzYcD73pgTBZrPhdDrx8S1/IWJRYqAoDGrgR+OA6jtFU1aSHAghdHX9wTplPXUPXB/+2dnZqKqKyWTCbDKTlZVVlBCoThUNDXuBldg3X8JgMtNz8hPYbTYMRiMmkwmjxUyvfgN5vFfbog/8sLCwUtfHe6SkJHjxxZuvT54MTz1V+fFUsI6hrjqSDRdysWkaZlw1CPn5+df+HJTvY029NpVgMLgSg8L2azpJDoQQunJet5Vuaafu1WvWmtCG92Cz27DZXL8Kd0QE1+yyw+nAYDBgNpkxGA0YDAYUDRZ/9CZXL53jsb/9l3tbtS3Wt9Wp0rR5c0Y26VJp79ft2rWDH37QO4pK1THUm2CLkfXnc7hqc6KoGgUFBQT4+1NSrUFJNE3DoYGKq8ag8GAu4VKzJ1WEELq7fqWAyWyhbZ9BHNr8Aw6HnbTLF/j54F6a39+P1JQU0tPTycvNQ1EUvL29URQFg8FArZAQQkNCqRVci8DAQPz9/PH18eW7T9/h+M54Iv/wLs279Cqx/5p6sE5V1zjAzLSWQdwX6o3dVoDZxw+Dlw/Oa9sel0TTNJyaRoFTxaZpKArcF+rNtJZBkhjcQEYOhBC68jMZri1N03A4nbToPYA9a5ezd+P3pJ0/jaqqtOwzCD8/PywWCyazGQWFjKsZWCwWnE4neXl5BAYUL0Jb+9k/2Pv9ckY9+yc6DRxVYt81+WCd6sDLaGBAAz/e//VjdB4xkfAHhpNr13Bc++BXrz/gSVGKNlHytxjoGOJNuxCvGr1c8VYkORBC6CY5OZmfDx6nIOReMnOycTqd1L63NV7+AZza+RMZF8/SuG0n7m3dvthzTtVJQUEBQYFBOFUnubm5+Pv7Y1BcH/RxC78gfvFc+k15qth++der6QfrVBd79+4lcdd2Xnv5Jfq0qUWa1UlqvoOUfCd5DhWHpmG6lgSG+Rip42Mi1NtYY3c+LCtJDoQQlSYrK4tt27YRHx/P5s2bOXbsGKFNWjD5H1/j5e2Dl9mM2WKmY7/htzx1Lz8//9rUgheqppGbm0t+fj5+vn4kxf/A95//P0Ib3ENY43vZv35VsWebde1NQEjtGn+wTnURHR1Nw4YNiYiIwKAohPmYCPMx0U7vwKo4+b9CCFFhrFYru3btKkoGEhISUFWVxo0bExERwW9+8xt69urNiitGcmxq0dryW526p6GRn5+Pj7cPimLAqLhOCszLy8PX15fLp1xnBKRd+JnY9/54U0xP/L8vCQipXeMP1qkOcnNzWbVqFU8//fStN48S5aZopVVuCCFEOTkcDg4cOEB8fDxbtmxh165d2Gw2ateuTZ8+fejbty8RERE0bty42HPbLuexNTkPSxlOZCywFZCRkUFoaGjRZkd2h520tDSCg4OLtky+FU3TsGkavcN9dT1bQdydhQsX8vLLL7Nz504aNGigdzjViowcCCHumKqqHD16lM2bN7N582a2bdtGTk4OAQEB9OzZk9dff52IiAhatWp1yw/9shysUyg/Lw+z2VxsPbvZZMZisZCXl1em5EAO1qkeoqKi6NevnyQGFUCSAyFEufz8889s3ry5aHQgLS0Ni8VCjx49eO6554iIiKBjx46YyrEZTVkO1nHa7WRnppF+JR3/AH+y09Rir6u2AqwOJwEBASVun1x0nxysUy0cP36cPXv28Nlnn+kdSrUkyYEQ4pZSUlLYsmVL0ejAuXPnMBgMdOrUiSlTptC3b1+6deuGt/fd7Sx3u4N1fk7ax5zfPo6maaXOLw95+g8EDBtHUGBQia/LwTrVR0xMDLVq1WLYsGF6h1ItSc2BEKKYrKwstm/fXlREePSoq8CvVatWRERE0LdvX3r27HlHh9vcztlsO0tPZ6GqGhZD8fqDvOxMDu3aitlsws/Xv8Tn/cPqoXj5UKd2nZsSiOsP1olsGiib3lRhdrudLl26EBkZyZtvvql3ONWSjBwIUcNZrVZ2795dlAwcOHAAVVVp1KgRERERvPjii/Tu3ZuwsLAKj+VWB+sYvbxp2O4+QkJCih3HfD1VU0lNTSUvPw9/v18SCDlYp3pZt24daWlpPPLII3qHUm1JciBEDVO4oqBwmuDGFQVTpkwhIiKCe+65R5f4bnewjsVc+ge7QTHg4+NDfl4efn5+KChysE41FBMTQ5cuXWjVqpXeoVRbkhwIUc1pmla0oiA+Pp7t27eTnZ2Nv78/vXr14rXXXiMiIoLWrVvfdhlhZSntYB3/Mhys4+vrS15eHvlWK2aLtxysU81cvHiRTZs28cEHH+gdSrUmyYEQ1dDZs2eLrSi4cuUKZrOZHj168OyzzxIREUGnTp3KtaKgshUerLPlUh67LmZi9vHDeO1gHQM3FyyCKxFSDEZ8AgKxOTUsCtwX4k2fer5FGyyJqm3RokV4e3szZswYvUOp1qQgUYhqIDU1lS1bthQlA2fPni1aUVC4+VD37t3vekWBHjRNY+iY8XR98CGa9h1Grl0rOkCntIN1FLuVH7/+D7+fNoG+3avwccyiGFVV6dWrF7179+af//yn3uFUa577tUEIUarCFQWFdQNHjhwBoGXLlgwePJi+ffvSq1evCllRUNl27NhB0p6dvPWn33N/GQ/WqWUJZulLm1hgTaVvd1kHX11s3bqVc+fOMWXKFL1DqfYkORCiCigoKGDXrl1FycCBAwdwOp1FB848//zz9OnTp1JWFFS2qKgomjZtSq9evVDKcbDOrFmz+POf/8yFCxdkB71qIioqiubNm9OtWze9Q6n2ZFpBCA/kcDhISEgoSgZ27tyJzWYjNDSUPn36EBERUbSiwFOKCCvC1atX6dy5M7///e959tlny/Vsbm4uXbt2Zdq0abz++usVFKGoLIV/Fv7whz/wzDPP6B1OtScjB0J4gOtXFBSeUZCdnY2fnx+9evXi1VdfpW/fvrRq1apGnT63dOlSVFVl0qRJ5X7Wz8+PKVOmEBUVxW9/+1t8fWVHxKps2bJld/xnQZSfjBwIoZNz584VW1GQmpqK2Wyme/fuRTsRduzYEfMt1vVXZ5qmMWjQIJo1a8bnn39+R22cO3eOXr168e677/LYY4+5OUJRWTRNY/DgwTRt2pQ5c+boHU6NICMHQlSSK1euFK0o2Lx5c9GKgo4dOzJ58uSiFQU+Pj56h+oR9u7dy5EjR/i///u/O26jUaNGDB8+nC+++IJHH320Wk/BVGcJCQkcPnyYV199Ve9QagxJDoSoQLm5uXzwwQds3ryZw4cPA9CiRQsGDRpUtKIgKKjkQ4JquqioKBo2bMgDDzxwV+3MmjWLCRMmEBcXR79+/dwUnahMMTEx1K1bl/79++sdSo0hyYEQd2rbNnj7bcjPB02DDz+Erl2L3XL58mW+++47IiIi+PWvf02fPn0IDw/XKeCqIzs7m5UrV/L888/fdY3F/fffT/v27fn8888lOaiC8vPzWb58OU888QRGoxyxXVkkORDiTiQnw4svQlQUtGgBNhtYrTfd1rhxY3bu3CnD2eW0fPlyCgoKePjhh++6LUVRmDVrFi+99BInT56kWbNmbohQVJZvvvmG7OxsHnroIb1DqVFqTtmzELezfz9MmgTDh8OQIbB6den3fvkljB/vSgwALBYoYcMhs9ksicEdiIqKYtCgQdStW9ct7Y0bN47atWszd+5ct7QnKk9MTIyuB4HVVJIcCAGQlQWvvAKffgpr18KiRfDWW3D5csn3HzvmGimYPBkGD4bXXoO8vMqNuZpKTEwkMTGRadOmua1Ni8XC448/zqJFi8jKynJbu6JinT59mu3bt8vRzDqQ5EAIgF274OxZmDrV9WE/ebLr+okTJd/vcMD27fD557BmDWRmwj/+UXnxVmNRUVGEh4czYMAAt7b76KOPYrfbiY6Odmu7ouLExMQQFBTEyJEj9Q6lxpGaAyHAVVDYsuWtpxKu17AhtG8PhSsNxo2DTz6psPBqiry8PJYtW8aTTz7p9hMjw8LCGDduHHPnzmXWrFkefSKlcO0SunjxYiZMmICXl5fe4dQ4MnIgahSbzcbVq1dvfqF7dzh3DuLjf7mWlAR2e8kNjR8PW7a4ChEBNm6Edrfb7V/czurVq8nNza2wYeRZs2Zx/vx51q1bVyHtC/f58ccfSUlJkUOWdCI7JIpqzel0kpiYWLQT4c6dO/n666+JiIi4+ebERNfSxPR017RBgwYwbx6U9q3l3/921SYYja5Rhw8+KLEoUZTd6NGjCQgIqNCh/3HjxmEwGFi2bFmF9SHu3vTp07l8+TJr167VO5QaSZIDUa1omsbx48eLzijYunUrWVlZ+Pr60rNnTyIiIpg2bRr+/v56hypucOTIEQYOHMjnn3/OqFGjKqyfb7/9lieffJJ169bRvn37CutH3Lnk5GS6devGX//6Vx5//HG9w6mRZNJNVHnnz58v2pZ4y5YtJCcnYzab6dq1K0899RR9+/alc+fONfaMgqoiKiqK2rVrM3To0ArtZ9iwYTRo0IA5c+Ywe/bsCu1L3JnY2FhMJhPjx4/XO5QaS5IDUeWkpaWxZcuWotGBM2fOoCgKHTp0IDIysuiMgrs+hS8pybXR0Y0mT4annrq7tkUxBQUFLFmyhKlTp1Z4EmcymZgxYwbvv/8+r732GnXq1KnQ/kT5aJpGTEwMDz74IIEyTacbmVYQHi8nJ4ft27cXJQOHDh0CoHnz5kRERBAREUHv3r0JDg7WN1Bxx5YtW8Zzzz3Hli1baNq0aYX3l5mZSZcuXXj22Wd5+eWXK7w/UXbbt29nwoQJLF26lF69eukdTo0lyYHwODabjd27dxdNFezfvx+Hw0G9evXo27dvUULgrt3zhP4iIyMxGAzExsZWWp9/+tOf+O6779i1axcWi6XS+hW39sILLxT9/y+7i+pHphWE7pxOJwcPHiy2osBqtVKrVi369OnDX//6V/r27UuTJk3kL4tq6NSpU2zbto1///vfldrvE088wfz581m1ahUTJ06s1L5FybKysvjmm2/4zW9+I/+v60ySA1HpNE3jxIkTRcnAjSsKXnnlFfr27Uvbtm3v+kQ+4fmioqIIDg5mxIgRldpv8+bNGTBgAJ9//jmRkZHyYeQBVqxYgd1uZ3LhDqVCN5Ic6MypaaRZnaTkO0jNd5LrUHFqGkZFwc9koI6PkTAfE6HeRoxV+C+vCxcuFNUMbN68uWhFQZcuXXjyySfp27cv9913n6woqGHsdjuLFy9m0qRJuuyCN2vWLKZOncquXbvo0aNHpfcviouOjmbgwIFyrLkHkORAJ1k2J0npBSSkW8m1a6iahkFRUK8rASn82aAo+JkVOoZ40y7Ei0CL559pnp6eXrSiID4+vmhFQfv27YmMjCQiIoIePXrc/YoCUaWtXbuWtLQ0pk6dqkv//fr1o1mzZsyZM0eSA50dOnSIhIQE5s2bp3coAkkOKl2BU2XLpTwS0gtwahpoYDIomBXl2rBm8dEBTQMVyLGpbE3OY0dKPh1DvOhTzxcvo+cMuefm5hatKIiPjy9aUdCsWTP69+9Pnz596N27N7Vq1dI5UuFJoqKi6N69Oy1bttSlf4PBwKxZs3jttdc4f/48DRs21CUO4Ro1CAsLY+DAgXqHIpDVCpXqbLaddedzyLQ5MaBgUijXPKemaTg0UNEIthgZ0tCfxgH6DMPbbDb27NlTtKJg3759OBwO6tatW2xFQb169XSJT3i+s2fP0rNnT2bPnq3rHHNeXh5dunRh2rRpvP7667rFUZMVFBTQuXNnpk2bxmuvvaZ3OAIZOag0CWlWNlzIRdU0zIqC4Q7qBxRFwayAqsFVm5Olp7MY1MCPjqHeFRBxcU6nk6SkpKKRgR07dmC1WgkODqZPnz785S9/oW/fvjRt2lQKu0SZxMTEEBgYyOjRo3WNw9fXl6lTp7JgwQJ++9vfylSXDtasWUNmZmaFHbglyk9GDipBQpqVDeddiYHFoLjlw1PTNGyqqx5hUEP3JwiapnHy5Eni4+OLzijIzMzEx8eHnj170qdPH/r27Uu7du1kRYEoN4fDQffu3RkxYgTvvvuu3uFw/vx5evbsyTvvvCN7+etg8uTJ2O12li9frnco4hoZOahgZ7PtRSMG7koMwDWKYDGATdXYcCGXYIvxrqcYLl68WHQ+QXx8PMnJyZhMJrp06cKsWbOIiIigS5cusqJA3LUNGzaQnJysWyHijRo2bMiIESP44osvePTRRyXhrURnz55l8+bNfPTRR3qHIq4jyUEFKnCqrDuf4/bEoFBRgqBprD+fw7SWQeUqUszIyCi2ouD06dMoikK7du2YMGFC0YoCPz8/t8YtRFRUFJ06daJdu3Z6h1Jk1qxZjB8/nri4OPr37693ODXGwoULCQgI4MEHH9Q7FHEdSQ4q0JZLeWTanNetRLgz9gIrqz/+K+ePJJKZcglVVQmp15CuIyK5f8zDmE0mrtqcbLmUx8CGpR9FnJuby44dO4qtKNA0jXvvvZcHHniAP/3pT/Tp00dWFIgKdenSJX788Ufef/99vUMppkePHnTo0IHPP/9ckoNK4nQ6WbRoEePGjcPHx0fvcMR1JDmoIFk2JwnpBRi4s+LD69kLCkj5+SQt7+9LcHh9FMXAuUP7+e4/73Hu8AEeev0fGDRISC+gW5hP0T4IdrudPXv2FG08tHfvXhwOB+Hh4fTt25cnn3ySiIgI6tev7463LESZxMTE4O3tzdixY/UOpRhFUZg1axYvvvgiJ06coHnz5nqHVO399NNPXLp0iSlTpugdiriBFCRWkG2X89ianIflLkcNbmX1x39l+8po/rj4J/xDamPTNO4li0tb1rJ582Z27NhBfn4+QUFB9OnTh4iICPr27cu9994rKwqELpxOJz179qRfv3784x//0Ducm9hsNrp3786oUaM8olCyups1axanT5/mhx9+kL+TPIxU3VQAp6aRkG7l0E/reH1wO04f2HXTPTtXL+K1QW25fPrYHfdTq2590CAjLYXMrEzycvPYfi6dD2fPBuDll19m7dq1HDx4kDlz5jB9+nSaNWsm/xMK3fz0009cuHDBYwoRb2SxWHjsscdYtGgRmZmZeodTrV25coV169YxZcoU+TvJA8m0QgVIszrJtWu06dUPLx8/EjetpWmn7sXuSdy0lvAmLajbtOw7wzntdnJzMsnLyebcoQQ2xXyBX2gdzAHBqKqKxWygdv1GxO1JoH5Axe99IER5RUVF0aZNGzp37qx3KKV67LHH+Pjjj4mOjuaZZ57RO5xqa8mSJSiKwoQJE/QORZRARg4qQEq+A1XT8PLyplXPfiTFrUN1Ootez05L5cyBXbTvP/y2bamairXASlZ2Ftu+W8rfxkfw0aMjWPbeHwmqE860v/6LunXrEVIrBD8fHwwGIxn2inx3QtyZlJQU1q9fz7Rp0zz6m2KdOnUYP348c+fOxeFw6B1OtaRpGjExMYwcOVIKoD2UJAcVIDXfieFarUHHASPJuZpWbGohKX4dqqbScUDJR9QW2ArIzskmLT2NlJQUrl69is1mo9l99/Poe5/xyJuz6Tn2YSwWb3A6UBTXf0blWp8p+c4S2xVCT4sXL8ZoNBIZGal3KLc1a9YsLly4wPfff693KNXSnj17OH78uBQiejBJDipArkMtOl2xRY8IvP0CSNy4puj1hI1rqNesNbUbNrnpWWuBlazMTKxWKyaTiaCgIOrUqUPt0NrUa9yUtj370bH/cMa+9AatevXjy98/SXZaatHzqqaR51Ar/D0KUR6qqhIdHc2YMWMIDAzUO5zbat++Pffffz9z5szRO5RqKTo6mkaNGtGnTx+9QxGlkOSgAjivWwBiMlto22cQhzb/gNPhIOtKMmeT9tGhlFGDvNxcTGYzdWrXJigwCB9vH4yGko9obt9vGAX5uRze+mOx6w5ZgCI8zNatWzlz5ozHFiKW5Mknn2THjh0kJibqHUq1kpOTw6pVq3j44YdlJ0oPJv9lKoDxhvnU9v2Hk5uVwal920nc9D2aptGh/83Jgaqp2O0OvLy8uPHo5pLYC6wAWHNzil03efB8rqiZFixYQIsWLejevfvtb/YQw4YNo2HDhjJ64GarVq0iPz+fhx56SO9QxC1IclAB/EyGYhsfNe/SC9+AIBI2ruHgprU0bN2RkHo3nxtvt9nQ0LBYLMWu52ZmUNJ2FLu/XQJAg5a/bEFrUBR8TfKfVXiO9PR01qxZU+WWrBmNRmbMmMGKFStISUnRO5xqIyYmhv79+8vmax5OljJWgDo+RlRNQ9NcRYJGs5m2EUNI3LQGmzWP4b96pcTnCmw2jEYjJmPxaYT961ezc/Ui2vYZSEj9RhTk5XJ89xZO7NlK6579adalJ+CqANY0jTCfkqchhNBDbGwsAJMmTdI5kvKbMmUK/+///T++/vprXn75Zb3DqfKOHj3Knj17+N///qd3KOI2JDmoAGE+JgyKggoUfkx3GDCC3Wtc63o7lLKE0WazXRs1KP7t6p4OXTh3aD8JG78jJyMNg9FE7UZNGPnMH+g57pc5XBVXMlLHR/6zCs+gaRpRUVGMHDmSkJAQvcMpt6CgICZPnsz8+fN5/vnnbxrVE+UTExNDSEgIw4YN0zsUcRuyfXIFcGoacw5nkGNTy3xKolN1kpqaSnBwMN5ed7aBUYFTxd9iYFabWjfVPQihh507dzJu3DgWL15MRESE3uHckZMnT9K3b18++uijKjn64Snsdjv33XcfkyZN4o033tA7HHEbMjldAYyKQscQb1AosVagJDabDeCOv5lomgYKdAzxlsRAeIyoqCiaNGlC79699Q7ljjVr1oyBAwfy+eefl/n/Z3Gz77//nvT0dB555BG9QxFlIMlBBWkX4oVRUXDc4u8Sp91Odloq2WmppCdfpCAni9z0tKJr2WmpRSsSbsehuZKSdiFebnoHQtydzMxMVq1axZQpU6r8krVZs2Zx8OBBdu7cqXcoVVZMTAxdu3alZcuybxkv9COT0xUk0GKkY4gX+9KsqBolHtv8c9I+vnh5OuDaJEYp4QTHCa+8Q9fh42/Zl6ppqGjcF+JddFyzEHpbtmwZTqeTyZMn6x3KXevXrx/Nmzdnzpw53H///XqHU+VcuHCBTZs2eeRJnKJkkhxUoD71fDmdbeeqzYkFbvrgr9esNTM++AKn6iQzM5OAgADMJnOxe8KaNLtlH5qmYdc0gi1G+tTzdfdbEOKOaJrGggULGDJkCGFhYXqHc9cURWHWrFm8+uqrnDt3jkaNGukdUpWyY8cOhg0bxrhx4/QORZSRFCRWsLPZdpaezkJVNSyGm0cGAPLy88jOziasTli51oFrmoZN1TAYFCKbBtI4wHz7h4SoBPv27WPUqFFERUUxYMAAvcNxi7y8PLp06cLUqVP585//rHc4QlSoqj0RWAU0DjAzqIEfBkXBpmolFjQVFBRgNpvvLDFQFAY18JPEQHiUqKgoGjRowAMPPKB3KG7j6+vLtGnTiIqKIjc3V+9whKhQkhxUgo6h3gxq6IfBoGDTtKJDmQA0NOxF+xuUjapp2DTXiMGghn50DL2zpY9CVIScnBxWrFjBI488gtFYvWpgZsyYQW5ubtHGTkJUV5IcVJKOod5ENg0k2GLErmnYr40i2O12VE3DqwzJgXbtucIag8imgZIYCI+zYsUKrFZrtVyy1qBBA0aMGMEXX3yBqsrpp6L6kuSgEjUOMDOtZRD3hXqjKGDTNGxODZPZgtFUcm2opmk4NY0Cp4pN01AUuC/Um2ktg2QqQXikqKgoBg4cSL169fQOpULMmjWLkydP8tNPP+kdihAVRgoSdZJlc5KUXsDag6ex+Afh7e2NoijFphwMioKmaSiKgp/ZtbFSuxAvWa4oPFZSUhJDhgxh3rx51XaLXE3TGDFiBCEhIURHR+sdTtWwZg384x+gKGC3w4gR8Ic/uH4WHkmSAx3l5ubSvkNH/vTO+/QZ9iAp+U7yHCoOTcN07XTFMB8jdXxMhHobZedD4fFeffVV1qxZw65duzCVMhpWHZw6dYpt27bx4IMPEhQUpHc4ni8nB3x9wWBwJQdjx8Lzz7uSBOGRqu//vVXAjh07KLDmM6jHfTQL8abd7R8RwmPl5+ezbNkyZsyYUa0TA4CmTZvSqFGjKr/z413Zvx/eeQeys8HphBdegNGjS77X3/+Xf7daoaBARg08XPX+P9jDxcfHU69ePe699169QxHirq1evZqsrKxqWYh4I0VRMJtrcM1PVha88gosWADh4ZCeDkOHQvfuULduyc/s3g2//z2cOgWPPw7VdNqpupDkQEdxcXE88MAD5drfQAhPtWDBAh544AEaN26sdyiiou3aBWfPwtSpxa+fOFF6ctCtG/z4I6SlwaxZsGMH9OxZ8bGKOyLJgU5SU1M5fPgwv/71r/UORYi7dvToUXbv3s1nn32mdyiiMmgatGwJq1eX/9nQUBg0yPWsJAceqwZPmOlry5YtAFX2jHshrhcdHU1oaCjDhw/XOxRRGbp3h3PnID7+l2tJSa5iw5KcOAGF+0Lk5MAPP0DbthUfp7hjMnKgk7i4OFq3bl0tDqURNVtBQQGxsbFMmTKlZs/DX89qdc2vJya6fm7cGD780PWtuToICoKvv4a334Y33wSHAxo0gHnzSr5/5UpYtQpMJleS8OCDMGVKpYYsykeWMupA0zS6d+/OqFGjeOutt/QOR4i7smLFCp599lk2b94sxbWFPv8cdu6E//3PVZX/u99BcDC8/rrekQlRJjKtoIMzZ85w8eJF+vbtq3coQty1qKgoevXqVf0Tg/37YdIkGD4chgy59Xy7okB+vusbtcMBublQTXeMFNWTTCvoIC4uDpPJRE8pxhFV3OnTp9myZQuffvqp3qFUrPIu3Xv0UdfSvQ4dXBv/dOkCM2ZUftyVKSkJXnzx5uuTJ8NTT1V+POKuSHKgg/j4eLp06YL/9RuDCFEFRUVFERQUxKhRo/QOpWKVd+neTz+55tYPHHAlBy++CH//u2vL4OqqXTtXoaGoFiQ5qGROp5PNmzfz5JNP6h2KEHfFbrezePFiJk6ciJeXl97hVKzyLt1bsADGj4fC35cJE+DjjysuPg+gaVrRWTCyd0vVJzUHlSwxMZGsrCweeOABvUMR4q6sW7eOK1euMPXGb9PVUXmX7jVu7Bo90DTXrw0boHXryolVB5qm8dNPP5GYmCiJQTUhyUEli4+Px8/Pj86dO+sdihB3JSoqiq5du9K6Gn/oFSlcuvfxx64NfPr1c50rULh2/0a/+52rCHHAANev1FT44x8rN+ZKtG3bNqZMmUJ+fr7eoQg3kWmFShYfH0/v3r1lPbio0s6dO8dPP/3Ehx9+qHcoladDB4iNLdu9wcGu5Yw1RExMDE2bNuX+++/XOxThJjJyUIny8/PZsWOHLGEUVd7ChQvx9/dndGmn8IkaIysri2+++YYpU6bIlEI1IiMHlWjXrl3Y7XZJDkSV5nA4iI6OZvz48fj6+uodjn5k6R4Ay5Ytw+FwMGnSJL1DEW4kyUEliouLIywsjJYtW+odihB3bOPGjSQnJ9eMQsRbkaV7gGtKYdCgQbIVfDUj0wqVKD4+nr59+8rQm6jSFixYQMeOHenQoYPeoQidHTx4kMTEREkUqyFJDipJeno6Bw8elCkFUaVdvnyZDRs2yIfBbaSnp/P888/z008/6R1KhYqJiSE8PJwBAwboHYpwM0kOKsmWLVvQNE2SA1GlLVy4EC8vL8aNG6d3KB4tJCQEm83Ga6+9hlracscqzmq1snTpUiZNmoTJJDPU1Y0kB5UkPj6e5s2bU08OXxFVlKqqREdHM3bsWAICAvQOx+PNmjWLU6dOsWnTJr1DqRBr1qwhKyuLRx55RO9QRAWQ5KCSFNYbCFFVxcXFcf78eZlSKKNu3brRqVMnPq+m+x1ER0fTq1cvmjZtqncoogJIclAJfv75Z37++WfZMllUae3atWP37t106dJF71CqBEVRmDVrFj/99BPHjx/XOxy3OnPmDFu2bJFRg2pMkoNKsHnzZgwGA7169dI7FCHuWJ06dahfv76stimHMWPGEBYWxhdffKF3KG61aNEiAgICqv9pnDWYJAeVID4+nvvuu4/AwEC9QxFCVCKz2czjjz/O4sWLuXr1qt7huIXD4WDRokVMmDABHx8fvcMRFUSSgwqmqqrUGwhRgz366KM4nU6io6P1DsUtNm3axOXLl2VKoZqT5KCCHTp0iIyMDEkOhKihateuzYQJE5g7dy4Oh0PvcO5aTEwMbdu2lU2wqjlJDipYXFwcPj4+dO3aVe9QhLg7H30Egwf/8qtlS3jzTb2jqhKefPJJLl68yJo1a/QO5a6kpqayfv16pk6dKrUn1ZyiaZqmdxDVWeFJZVFRUXqHIoT72GzQuTMsXAgdO+odTZUQGRmJw+Fg5cqVeodyx/7973/zwQcfcODAAYKCgvQOR1QgGTmoQDabje3bt8uUgvBc+/fDpEkwfDgMGQKrV5ftubVroX59SQzK4cknn2TXrl0cOHBA71DuiKZpxMTEMHLkSEkMagBJDirQ7t27sVqtsr+B8ExZWfDKK/Dpp64P+0WL4K234PLl2z8bHQ1TplR8jNXIkCFDaNy4MXPmzNE7lDuye/duTp48yRT5714jSHJQgeLj4wkJCaF169Z6hyLEzXbtgrNnYepUVw3B5Mmu6ydO3Pq58+dh506YMKHiY6xGjEYjM2bMYNWqVSQnJ+sdTrlFR0fTuHFjevfurXcoohJIclCB4uPjiYiIwGCQ32bhgTTNVVT4ww+//Nq9GyIibv3cokUwbBgEB1dKmNXJI488gsVi4auvvtI7lHLJzs5m1apVPPzww/L3WQ0h/5UrSFZWFvv375cpBeG5uneHc+cgPv6Xa0lJYLeX/oyquooQZWj5jgQGBjJ58mS++uorCgoK9A6nzFatWkVBQQEPPfSQ3qGISiLJQQXZunUrqqpKMaLwXEFB8PXX8PHHMGgQ9OsH77zjSgBKEx8PBsPtRxdEqZ544gnS0tJYsWKF3qGUWUxMDAMGDJBTZWsQWcpYQV577TU2btzI1q1b9Q5FCOFhHnvsMS5evMj69es9fr+AI0eOMHDgQObMmcPIkSP1DkdUEhk5qCBxcXEyaiCEKNGsWbM4dOgQ27dv1zuU24qJiSE0NJQhQ4boHYqoRJIcVICLFy9y8uRJSQ5E1ZOUVHwXxMJf//uf3pFVK3379qVly5Yev6zRZrOxZMkSJk2ahNls1jscUYlMegdQHcXHx6MoCn369NE7FCHKp10716oFUaEURWHWrFn84Q9/4OzZszRu3FjvkEr0/fffk5GRIYcs1UAyclAB4uPj6dChA7Vq1dI7FCGEh4qMjCQoKIh58+bpHUqpoqOj6datGy1atNA7FFHJJDlwM03T5IhmIcRt+fj4MHXqVGJiYsjJydE7nJucP3+euLg42RGxhpLkwM2OHj1Kamqq7G8gqpzjx4/TvXt3Nm3apHcoNcaMGTPIzc0lNjZW71BusmjRInx9fRk9erTeoQgdSHLgZvHx8VgsFrp37653KEKUy5dffondbpdamUpUv359Ro0axZw5c1Bvtb9EJXM6nSxcuJCxY8fi5+endzhCB5IcuFl8fDw9evTA29tb71CEKDOr1crSpUt56KGHpCq9ks2aNYvTp0+zceNGvUMpsnnzZi5cuCCFiDWYJAduZLfb2bp1q0wpiCrnm2++ISsrSz4MdNC1a1c6d+7M559/rncoRWJiYmjVqhVdunTROxShE0kO3Gjfvn3k5eVJMaKochYsWEBERARNmjTRO5Qap3BZY1xcHMeOHdM7HNLT01mzZg2PPPKIx+/eKCqOJAduFB8fT1BQEO3bt9c7FCHK7Pjx4+zcuZNp06bpHUqNNXr0aMLDw/niiy/0DoWlS5cCMHHiRJ0jEXqS5MCN4uLiiIiIwGg06h2KEGUWHR1NSEgIw4cP1zuUGstsNvP4448TGxvL1atXdYtD0zRiYmIYNmwYISEhusUh9CfJgZtkZ2ezd+9emVIQVYrNZmPx4sVMnjwZi8Widzg12qOPPoqqqkRFRekWw/79+zly5IjsbSAkOXCX7du343Q6pRhRVClr164lIyNDPgw8QGhoKOPHj2fu3LnY7XZdYoiOjqZ+/fryJUdIcuAu8fHxNGzYkHvuuUfvUIQoswULFnD//ffTvHlzvUMRwJNPPsmlS5dYs2ZNpfedl5fHypUrefjhh2VqVEhy4C6FWyZLda+oKs6cOcPmzZuZOnWq3qGIa9q2bUvv3r11Oa1x9erV5Obm8tBDD1V638LzSHLgBsnJyRw9elSmFESVEh0dTWBgIA8++KDeoYjrPPnkk+zevZv9+/dXar/R0dH07duXRo0aVWq/wjNJcuAGmzdvBpBtZ0WVYbfbWbRoERMnTpTdPD3M4MGDady4caWOHpw4cYJdu3ZJ7YkoIsmBG8THx9O2bVtq166tdyhClMkPP/xAamqqTCl4IKPRyMyZM1m9ejXJycmV0ufChQsJDg6W5ayiiCQHd0nTNOLi4mRKQVQpUVFRdOnShTZt2ugdiijBww8/jMViYf78+RXel91uZ/HixUycOFGWs4oikhzcpZMnT3L58mVZ+iOqjAsXLrBx40YZNfBggYGBPPTQQ3z99dcUFBRUaF8//PADV65ckXM1RDGSHNyl+Ph4zGYz999/v96hCFEmMTEx+Pr6MmbMGL1DEbfwxBNPkJ6ezooVKyq0n5iYGDp37iyjSKIYSQ7uUlxcHN26dcPX11fvUIS4LafTSUxMDOPHj8fPz0/vcMQtNG3alMGDB/O///0PTdMqpI/Lly/z448/SiGiuIkkB3fB4XCwdetWmVIQVcbGjRu5dOmSTClUEbNmzeLw4cNs27atQtpftGgRXl5ejB07tkLaF1WXJAd34cCBA2RnZ0tyIKqMqKgo2rdvT8eOHfUORZRBREQErVq1qpBljaqqsnDhQkaPHk1AQIDb2xdVmyQHdyE+Pp6AgAA6deqkdyhC3FZycjI//PADU6dOlZ08qwhFUZg1axbff/89P//8s1vb3rZtGz///LMUIooSSXJwF+Lj4+nduzcmk0nvUIS4rUWLFmGxWBg/frzeoYhymDBhAkFBQcybN8+t7UZHR3PvvffSo0cPt7YrqgdJDu6QpmnMnTuX//73v3qHIsRtqapKdHQ0Y8aMITAwUO9wRDn4+Pgwbdo0YmJiyMnJcUubmZmZfPvtt0yZMkVGkUSJJDm4Q4qiEBQUhJeXl96hCHFbmzdv5uzZs1KIWEXNmDGDvLw8Fi9e7Jb2li1bhtPpZOLEiW5pT1Q/khwIUQNERUXRsmVLunbtqnco4g7Uq1ePUaNG8cUXX6Cq6l23FxMTw5AhQwgLC3NDdKI6kuRAiGouLS2NtWvXMm3aNBlCrsKefPJJTp8+zY8//nhX7SQmJnLw4EEpRBS3JMmBENXc4sWLURRFhpCruC5dunDffffx+eef31U7MTExhIeHM2DAADdFJqojSQ7uxP79MHo03HsvzJhx8+uzZ0OvXq5f771X2dEJUUTTNKKjoxk1ahTBwcF6hyPuQuGyxvj4eI4ePXpHbVitVpYtW8ZDDz0kq6zELUlycCfCw+Htt+Gtt25+bft2WLECNmyAn36CTZvghx8qO0IhANixYwcnT56UQsRq4sEHHyQ8PJwvvvjijp7/9ttvycrK4uGHH3ZzZKK6keSg0P79MGkSDB8OQ4bA6tWl31uvHtx3H5R0vOmqVTBxIvj6ul5/+GFXsiCEDhYsWEDTpk3p1auX3qEINzCbzUyfPp3Y2FgyMjLK/XxMTAy9e/emSZMm7g9OVCuSHABkZcErr8Cnn8LatbBokWtU4PLl8rd14QI0bPjLz40aua4JUcmuXr3KN998IzsiVjPTpk1D0zSioqLK9dyZM2fYunWrFCKKMpFJJ4Bdu+DsWbhx6PXECahbV5+YhLhLS5cuRdM0Jk+erHcowo1CQ0OZMGEC8+bN41e/+hUGk4k0q5OUfAep+U5yHSpOTcOoKPiZDNTxMRLmY2LhokUEBgYyatQovd+CqAIkOQDQNGjZ8tZTCWXVoAGcP//Lz+fOua4JUYkKv1kOGzaM2rVr6x2OcLMnn3ySb9Zv5OvNCdjDm5Jr11A1DYOioF53vHPhzwYFsjsO4+FXW2IzmPHWMXZRNci0AkD37q4P8fj4X64lJYHdXv62HnwQliyBvDyw2WDhQpDjUEUl27t3L0eOHJFCxGqowKlyKaARj322gks+4eTYVIwKeBkULAYFb6Oh6JfFoOBlUHDaHXgF1sKvQx/mHrnKj+dzKHDe/WZKovpSNO26NLMmS0x0rUBITweHw/Vtf948KGl75JMnXcWL+flgtUKtWvDCCzB9uuv1Dz+Ewm1Ox4yBV1+ttLchBMBvf/tbtmzZwrZt2zAY5DtAdXE228668zlk2pyoDgeZGemEhoZiNplv+dzVq1dxqk5CaoXg0EBFI9hiZEhDfxoH3PpZUTNJciBENZOdnU3nzp15/vnneemll/QOR7hJQpqVDRdyUTUNs6KgKJB25Qpms5mgoOBSn3OqTq6kXiEgMABfH18AVE3Dfm0aYlADPzqGykSDKE6+UghRzSxfvpyCggJZy16NJKRZ2XA+F1XVsCgKBkVBQcHH1xdrQQFO1Vnqs1arFRTw9v4lATAoChZFQVU1NpzPJSHNWhlvQ1QhUpBYmqQkePHFm69PngxPPVX58QhRRlFRUQwePJi6stKmWjibbS8aMbAYlGLLUn18fMjNySE/Lw9//4ASntbIz8/H28sLg1L8u6CiKFgMYFM1NlzIJdhilCkGUUSSg9K0ayc7G4oqJzExkcTERH73u9/pHYpwgwKnyrrzOSUmBgAGxYC3jw95+fn4+fujUPx1m92Ow+EgMCCwxPaLEgRNY/35HKa1DMLLKAPKQqYVhKhWoqKiqFu3rhyqU01suZRHps15rcag5I2sfH19UVXVNX1wg/z8fExGI2ZL6SMCiqJgVhSu2pxsuZTntthF1SYjB0JUE3l5eSxbtownn3xSDtWpBrJsThLSCzDgqjEojclowsvLi7zcXHy8veHa6IGquRIGPz8/9q5dwbK/v1ZqG5P+9D7tBj5IQnoB3cJ8CLQY3f12RBUjf4OUwdWrV+nWrRvvvfeeHHsrPNaqVavIzc2V7XGriaT0ApyaqwDxdvx8fUnPyMBms2O5duaL1WoFTcPHx4emHbsx6Y83nxC7ZelXXD55lGb39cSkuKYXktIL6FXX1+3vR1QtkhyUwZYtW8jLy5PDa4RHi4qKol+/fjS8/mwPUSU5NY2EdCtooBhunxxYLBZMJhN5eblFyUF+fj4WLy+MBiMh9RsRUr9RsWfsBVZWffxX7r3vfgJC67guqq5+e4T7YJTzOGo0qTkog/j4eO69914ayDbIwkMdOXKEPXv2MG3aNL1DEW6QZnWSa9c4Gr+O1wa15fSBXTfds3P1Il4b1JbLp48BCn7XljU6nA7sDjt2ux0fH59S+ziydSMFeTl0GvRg0TWTQSHXrpFmLX1ppKgZJDkog7i4OB544AG9wxCiVFFRUdSpU4chQ4boHYpwg5R8B6qm0bpnP7x8/EjctPamexI3rSW8SQvqNm0JgLePDwaDgfy8PPLz8zEYDHiVtMPrNfs3fIPZ4k27voOLrhlwncuRmu9w+3sSVYskB7dx7tw5zpw5Q9++ffUORYgSFRQUsGTJEiZPnozZLOvUq4PUfKdroyJvH1r17EdS3DpU5y/f5rPTUjlzYBft+w8vuqag4HNtWaM134qPj89NSxsL5WVlcnzXZlr3HoCXr/8vbVxbFZGSLyMHNZ0kB7exefNmDAYDvXv31jsUIUr07bffkpmZKYcsVSO5DrXodMWOA0aSczWt2NRCUvw6VE2l44ARxZ7z9fVFU1WcqvOWUwpJcd/jdNiLTSkUUjWNPIccylTTSXJwG3FxcXTq1ImgoCC9QxGiRAsWLKBPnz40adJE71CEmzivO/KmRY8IvP0CSNy4puhawsY11GvWmtoNm6ChYbPZyM7JJiM9HQ1XkmAyll5vvn/DN/gGBNGye0SJrzvkyJ0aT5KDW1BVlc2bN8uUgvBYJ0+eZPv27TJqUM1cv1LAZLbQts8gDm3+AafDQdaVZM4e3EebiCFkZl4lNTWV9Ix0rFYrFosXISEhBAaWvCMiwNXki/ycuIf2/YZhLGUayiQrFWo8Wcp4C0eOHCEtLU2SA+GxoqOjqVWrFiNGjLj9zaLK8DMZim181L7/cPZ+v4JD2zZx6fRxnKqThvfdj8PpxNfXFy8vL0wmU6k1BtdL2PgdmqaVOKUArkOZfE3yvbGmk+TgFuLi4vD29qZbt256hyLETex2O4sXL2bSpEm3rEoXVU8dHyOqplFgt2MrKCC4SQssvn7s3/AtVy+fo2GrDjRv1wmjofw7GR744RuCw+pxT4euN72maRqaphHmIzsk1nSSHt5CfHw8999/v/zFKzzS2rVrSUtLkymFaiQvL4/vv/+e+Z/+k7zcXDIzs1ynKvr40rbvEE7tjif5xGE6DRp1R4nB5dPHuHz6GB0HjirxrAYV14qFOj7yvbGmk+SgFDabje3bt8uUgvBYUVFRdO/enRYtWugdirgLycnJLFiwgMcff5x27doxY8YMdmz4HrNqxz8omDp16hAUGMR9g0djy3cdjNThuiWM5XHgh28A6DRoVImvO1QNP7NCqLeMHNR0iqZJWWpJtm3bRmRkJOvWraN9+/Z6hyNEMT///DO9evVi9uzZTJ48We9wRDlomsbhw4f5/vvvWb9+Pfv378dgMNCjRw+GDh3K0KFDuffee9l2OY+tyXlYbnEio7vjsmkavcN95WwFITUHpYmPj6dWrVq0bdtW71CEuElMTAyBgYGMHj1a71BEGdhsNrZt28a6detYt24dFy5cwN/fnwEDBvDEE08wcOBAatWqVeyZdiFe7EjJx6GBuRIWDzg01yqJdiEyjSokOShVfHw8ffv2xWCQmRfhWRwOB4sWLSIyMvKWG90IfWVkZLBhwwbWrVvHpk2byMnJoUGDBgwdOpRhw4bRq1evW+5oGWgx0jHEi31pVlSNEo9tdtrt5GVdvWUc3v4BmL28b3mPqmmoaNwX4i3HNQtAkoMSZWVlsW/fPh5++GG9QxHiJhs2bCA5OVkKET3QqVOniqYLdu7ciaqqdO7cmWeffZahQ4fSpk2bck0R9Knny+lsO1dtTixw07M/J+3ji5en37KNCa+8Q9fh40t9XdM07JpGsMVIn3oynSBcJDkowbZt21BVVYoRhUeKioqic+fOMuXlARwOB3v27CmaLjh58iReXl488MADvP/++wwePJjw8PA7bt/LaGBIQ3+Wns7CpmpYDMUThHrNWjPjgy9u2UZYk2alvqZpGjZVw2BQGNLQHy+jjJQKF0kOShAXF8c999xD48aN9Q5FiGIuXrzIjz/+yPvvv693KDVWTk4OmzZtYt26dWzYsIGMjAxq167NkCFD+POf/0zfvn3dOt3TOMDMoAZ+bDife1OC4BMQSPOuve6o3aLEQFEY1MCPxgFyaJf4hSQHJSisNxDC08TExODt7c3YsWP1DqVGuXDhAuvWrWP9+vVs2bIFu91O69atefTRRxk6dCidO3eu0PqkjqGumoENF3KxaRpmSq5BKCv12lSCweBKDArbF6KQJAc3uHTpEidOnOCVV17ROxQhinE6ncTExDBu3Dj8/f1v/4C4Y6qqkpiYWDRdkJSUhMlkomfPnvzf//0fQ4YMqfSRxY6h3gRbjKw/n8NVmxODBibl5jqEW9E0DYcGKq4agyEN/WXEQJRIkoMbxMfHoygKffr00TsUIYr56aefuHjxItOmTdM7lGrJarWyefPmohGC5ORkAgMDGTRoEM8//zz9+/e/5YFGlaFxgJlpLYPYcimPhPQCbJoGqobJoGCg5ERB0zRUXBscobiWK94X4k2fer5SYyBKJcnBDeLj42nfvj0hISF6hyJEMVFRUbRt25ZOnTrpHUq1kZqayoYNG/j++++Ji4sjPz+fJk2aMHbsWIYOHUr37t1vudxQD15GAwMb+tMtzIek9AIS0q3k2jUcmoaiuKYMChkUBU3TUBQFf4uBjiHetAvxkuWK4rYkObiOpmnEx8czceJEvUMRopiUlBTWr1/PW2+9VSm75VVXmqZx7NixoumCvXv3AtC1a1d++9vfMnToUJo3b14lfo8DLUZ61fWlR7gPaVYnqfkOUvKd5DlUHJqG6drpimE+Rur4mAj1NhY7ClqIW5Hk4DrHjx8nJSWFBx54QO9QhChm8eLFmEwmIiMj9Q6lSnvnnXf497//ja+vL/369ePDDz9k0KBB1K5dW+/Q7phRUQjzMRHmY6Kd3sGIakOSg+vEx8djsVjo0aOH3qEIUURVVaKiohg9erTuc95VXZs2bViwYAF9+vSR01aFuAWpRrlOXFwcPXr0wNtblvUIz7F161Z+/vnnmr0j4v79MHo03HsvzJhR/LWVK2HwYBgwwPXrv/8ttZnIyEgGDhwoiYEQtyEjB9fY7Xa2bdvG888/r3coQhSzYMECWrRoQffu3fUORT/h4fD223DwIPz4Y/HX6teH6GgIC4OsLBg+HDp2hN699YlViGpARg6uOXDgADk5ObL5kfAo6enprFmzhqlTp1aJIrly2b8fJk1yfZgPGQKrV5d+b716cN99YLHc/Fr37q7EACAwEJo3h3PnKiRkIWoKGTm4Ji4ujsDAQDp06KB3KEIUiY2NBah+K2iysuCVV2DBAteoQHo6DB3q+qCvW/fO2z12DHbvBtleWoi7IsnBNfHx8URERGA0yvpf4Rk0TSMqKoqRI0dWv303du2Cs2fhxjqKEyfuPDm4dAmmT3clBvXq3XWIQtRkkhwAubm57Nmzh7/85S96hyJEkV27dnHixAneffddvUNxP02Dli1vPZVQHsnJMHkyvPSSq3BRCHFXpOYA2L59Ow6HQ/Y3EB5lwYIFNGnShN7VsbCue3dXXUB8/C/XkpLAbi9/W8nJrtqF555zJQhCiLsmyQGuKYUGDRrQpEkTvUMRAoDMzExWr17N1KlTK/S0P90EBcHXX8PHH8OgQdCvH7zzDqhqyfefPAldusCbb8KmTa5///JL12t//ztcuACff+5a0jh4MCxaVElvRIjqSdG06zbirqEGDRpEp06d+PDDD/UORQgA5s2bxxtvvMGePXuoU6eO3uHcMYfDwYkTJ2jdurXeoQghyqEafiUpn5SUFA4fPixTCsJjaJrGggULGDp0aJVMDLKzs1m9ejXPP/88HTt25O2339Y7JCFEOdX4gsQtW7YAyBHNwmPs37+fw4cP8/rrr+sdSpmdP3+e9evX8/3337Nt2zbsdjtt2rTh8ccfZ+zYsWVrJCkJXnzx5uuTJ8NTT7k3YCHELdX45CAuLo42bdpUyW9oompxahppVicp+Q5S853kOlScmoZRUfAzGajjYyTMx0RUdAwNGjTw6NEsVVVJSEhg3bp1fP/99xw+fBiz2UyvXr144403GDJkCI0aNSpfo+3awQ8/VEzAQohyqdHJQeERzaNl6ZOoQFk2J/+/vbsNjqu68zz+vbef1Hpoyy1ZtrAAM7bVBoOw4wf8gIMdWzYxkGyAQIrAQhIY19bOhMkGqpJls5nNJKnd7DKbnZlid2og2d2kNjWTwCSbrTGWMfZIho3tLMaSxSD5QbYsRyBbQo/9fO/ZFy131Mg2tpGtlvr3qeIF996+fdrgvr8+53/Oae1L0NwXZyRlcI3BtizcMeU+5/7dtsC3/gs8dMcmRhwI5dGyG/F4nKamJhoaGti5cyc9PT3MmDGDTZs28fTTT7N+/XptDCUyTRR0OOjo6OB3v/udlkyWqyLhuLzRHaW5L4FjDBjw2hY+yxpdCjl3OWRjIJqIEyyvwJp7PT96t5+6cIC11cUEPJNTHtTT08OuXbvYsWMHjY2NxONx5s2bx/333099fT0rVqzA6y3orxGRaamg/1Y3Njbi8/m44447JrspMs10DqVo6BpmIOlgY+G3LCz74nsjWJZFPBrFtm0Ctk3awMHeOB1DKeprSrmhzHfV222Moa2tjYaGBhoaGnjrrbewbZvly5fzzDPPsHnzZubPnz/99nkQkRwFHQ6amppYtmwZJSUlk90UmUaae+PsOj2Caww+y8K+xAdpKp0ilUoxs7wcy7LwWeAa6E86vNwxyMa5JdRVTPx24qlUin379rFjxw4aGho4deoUxcXFbNiwgR/+8Ids3LiRioqKCX9fEclfBRsOHMfhjTfeYNu2bZPdFJlGmnvj7OrKBAO/bV3WL+xYLIbH48EfCGSP2ZaFH0i6hl1dIwATEhAGBgZ4/fXX2bFjB7t372ZoaIjq6mq2bNlCfX09a9asITCmHSJSWAo2HDQ3NzM4OJjXFeEytXQOpbI9BpcbDAyGeCxOcXEQ60O1CJZl4bdHA8LpEcr9nisaYjhx4kR2uGDfvn04jkNdXR3btm1j8+bNLF68WMMFIgIUcDhoamqitLSU22+/fbKbItNAwnFp6Bq+omAAmZkArnEJBoPnPZ8NCMaws2uYR2tnfGSRouM4HDx4MDtccOTIEfx+P+vWreP73/8+9fX1zPk42yOLyLRV0OFgzZo1qrSWCfFGd5SBpDNmJsLliUVjBAIBPB4vz2285bzXbH7ya6z7wpP0Jx3e6I7yqZrScdeMjIzQ2NiYnW7Y19dHRUUFmzZt4pvf/Cbr1q1TjY2IfKSCfDLGYjH279/Pt7/97cluikwDg0mH5r4ENpdefDhW2kmTTCUpLy/PHluwbA1L6z+Tc131gpuxLQvbQHNfguVVQUJ+D93d3ezcuZOGhgb27t1LMpmktraWRx55hM2bN7N06VI8njxaMEFE8l5BhoP9+/eTSqW0voFMiNbRdQz8VzheHzs3fXFMAWBlzTyWfCgcnOO1DHHH5b/979fY9Td/TktLCx6Ph1WrVvHcc89RX1+vHUZF5GMpyI2XmpqamD17NgsWLJjspsgU5xhDc1+cd/6xgX+zaTEdhw6Mu2b/r/+W5zbewnsd7ePOGQyxeJxgcHwhYioRJ5VMZK9LJBMMDg1ytreXWDTGB8VV/MH8BbzwwgscPnyYn//85zz11FMKBiLysRVkz0FjYyPr1q1TZbZ8bL1xh5GU4ebVdxEIltCy51Vuun1FzjUte15l9ryFzLmpdtzrE/E4rju+EPGtHb9k369+hmsMFXNvZPnnHiWydiMej4dAIIA/EKC09Hq+9vx/oSpYkH+NReQqKrieg76+Pg4fPqwhBZkQPbE0rjEEAkVEVt1Fa2MDruNkzw/1nuHEoQPcuv7u874+Govh9/vxeryAIe2kmRu5jTVfeJKt/+o7rP/y01i2zY6/+i7H33yNWZWVhMpCBHw+jIEzsfQ1+qQiUkgKLhzs3bsXQOFAJsSZmIM9OkOhbsNWhvt7c4YWWpsacI1L3YZPj3tt2kmTTCbx+3wMDQ9x9uxZzp49ywN/+hesuO9hlm7cyqZHnuTpF3/JnJtq2fXjvySVyAwzWKPv2RNzxt1XROTjKrhw0NTUxMKFCzW/WybESNrN7q64cOWdFJWU0bJ7e/Z88+7tVM9fRGXNPAyGVDpFLB5jaHiI/v5+jOsyPDJCPB7H7w8wc+ZMqqqqKC+fSbAoiG178Ph8rPpnjxAfGeJ0e2v23q4xRNPuNf/MIjL9FWQ4UK+BTBRnzLbLXp+fW9Zu5J29rxGPx+jpOsnJlrdYcMd6zvaepef99+nt7WVgYIB4PI7H46EsFKKiooLKykpCoRABf2BcYSLAjFmZMBsbGsw5nh7z/iIiE6WgKplOnjxJZ2enlkyWCZFKpRgeHMRxfAzHo6TTaW74xGp+u/0VDjXupO/0SVzjElm7kYDfj7e4BI/Xg9frxbYuL5d/8F4XACXlM3OOe1VUKyJXQUGFg6ampux8cJFLlUql6OjooK2tjfb2dtra2mhra6Ojo4OVj/0RdVsfwknE8Xi9LFi+huJQOZ1vvUlv10luuGUJNy1afMnvNdLfR0l5OOdYIjrMmy//hJLQTOYu/P29bMui2FtwnX8icg0UXDhYsmQJoVBospsieSidTnPixInsw/9cEDh+/DipVAqAyspKIpEId955J1/5yleYcfMyjvhKCZSVZafG3vrJzbTs2U4yHuXubc9eVht+86uf8c7e17h59QZmzK5mqPcM/+/VVxjo6ebBb/x7PL7MhkvGGIwxVAW18qGITLyCCQeu69LU1MSXvvSlyW6KTDLHcejs7KStrY133303GwSOHj2aDQHhcJhIJMLq1at5/PHHiUQiRCIRwuHcX/U9sTTH2gdwgXOP6ds2fJrfbv8FlmVx2wWmMF7IjYuX0tl6kN9uf5noYD++QBE1i+q4/5nvMv8Tv+/xcsnMWJilNQ5E5CqwjCmMiqaWlha2bNnCK6+8omGFAuG6Lp2dnTlDAW1tbRw9epTE6JTA8vLy7IM/EolQW1tLJBKhsrLykt7DMYYX/+kDhpPuR+6SOJESjkup3+bJm2fiUd2BiEywgvnZ0dTURDAYZNmyZZPdFJlgruvS1dU1ribgyJEjxONxAEKhELW1tSxZsoSHH344GwSqqqo+1kqZHsuiLlzEm+9HMcZck1U3jTFgQV24SMFARK6KggkHjY2NrF69Gt/omK1MPcYYTp8+Pa4m4MiRI0SjUQBKS0uJRCLceuutPPDAA9kegdmzZ1+1B/ficIB9PTHSBnwXeAsnlSI62H/R+xSVluELFH3k+6VNJpQsDgc+8loRkStREOEgkUiwb98+vvGNb0x2U+QSGGPo7u7OGQpob2+nvb2dkZERAEpKSqitrWXRokV89rOfzYaA6urqa75nRsjvoS4c4GBvHNdw3m2bT7Ye5KWvP3HR+9z/7PdYdvfnLnqNawwuhqXhIkJ+FSOKyNVREOHgwIEDJBIJrW+QZ4wx9PT0ZAPAu+++mw0BQ0NDAASDwWwdwD333JMNAddddx22nT/T+NZWF9MxlKI/6eCHcQGlev4ivvSDly56j6p58y963hhDyhjK/R7WVhd/3CaLiFxQQYSDvXv3ZqegyRV6+2341regtRXuugt+/ONLO/chL730Uk6PwOBgZsW/QCDAwoULiUQibNmyJVsTcP311+dVCLiQgMemvqaUlzsGSboGv50bEIJlIRYsW33F9zfGkHQNtm1RX1N6TYsfRaTwFMRshXvuuYcbb7yRF154YbKbMnV1d8N778Hhw/D667kB4GLnPmTevHksWLAgZ4ZAJBLh+uuvx+OZ+t3kzb1xdnWN4BqD37YmZIgjGwwsi401JdRVfHRdgojIxzHtew4GBgY4dOgQjz322GQ3Jf+8/TZ873swNASOA1/9Ktx33/mvra7O/NPefnnnPuTo0aN4vdP3f7tzD+5dp0dIGoOP89cgXCp3dCjBti02zlUwEJFrY8p/SzvG0Bt36ImlORNzGEm7OMbgsSxKvDbd7W3MvGE+a+/UZks5Bgfh2Wfhpz+F2bOhrw82b4YVK+Aq7lg5nYPBOXUVRZT7PezsGqY/6WAb8Frj6xAuxhhD2oBLpsagvqaUG8o000ZEro0p+009mHRo7UvQ3BdnJGVwTabb1R0zSmJbFonS63noP/1P/mEwSN17URaHA6ryBjhwADo74YtfzD1+9OhVDQeF4oYyH4/WzuCN7ijNfQmSxoBr8NoWNucPCsYYXCDtZtYx8FgWS8NFrK0uVo2BiFxTUy4cJBw3+4XrGAMGvLaFzzo3vpv7pTs4MoQ/UMRw0uXN96Ps64lRFw7oC9cYqK2FX/96slsybQU8Np+qKWV5VTAnyKaNwbIYF2TPLaJU6repCxcpyIrIpJlS4aBzKEVD1zADSQcbC79lYdkX7qp1XId0Ok1pqZeAx8521R7sjdMxlJrWXbUjIyPZaYE33ngjy5cvz+3SX7ECTp2CpiZYNzrk0tqaCQxaKGpChfweVs8pZuXsIL1xhzOxND0xh2jaJW0M3tHdFauCHmYFvVQUebTyoYhMqikzW6G5N86u05kqcJ9lXVKRVyweY2BggKqqKmzr970E2SIva+oXeUWjUY4cOTJu6eCuri4g0339/PPP8+CDD44f729pge98J1NvkE7D3LmZmQaB86y8d+wYfP7zEItBPA4zZ2YKGJ944uLnRERkypkS4eBKp4cNDPSTdhwqwhXjzk216WHxeDwbAsYGgVOnTnHuP2FNTc24KYILFiyguFgL5oiIyKXL+2GFzqFUtsfg8uaNGxLJJMFg8LxnLcvCb0PSNew6PUK535MXQwyJRIJjx47lLBTU1tbGyZMnsyHguuuuIxKJsHXr1uxiQbW1tZSUlExy60VEZDrI656DhOPyk/YBBpJOpr7gMsZhU+kUvb29hGfOxO+/8AY1xhiSo0vSPlo745oVKSaTSY4dOzZuO+ETJ07gui4Ac+bMGbedcG1tLWVlZVenUa2t8PTT448/9BD84R9enfcUEZG8k9fh4PWuYQ72xi+5xmCskegIw8PDmS15x8xgGOo7y67//le0/WYP0cF+SsOV/MGSO7j3mT9jaUURn6opndDPkEqlOH78+LiagI6ODhzHAWD27NnZ/QPGBoFQKDShbREREbkUeTusMJh0aO5LYHP5wQAyv8z9Pn9OMBjo6eavv5qZ17/ivoeZUTmbwbM9dL3bjI1Fc1+C5VXBK5o+lkqlOHHixLiagOPHj5NOpwGy+zt88pOf5KmnnsqGgPLy8st+PxERkaslb8NB6+g6Bv4rCAYGQzKZpLQ0txfgl//5T/F4vPyL//p3FIfKc18zOrzQ2pdg9ZwLF/Cl02lOnjw5bjvhY8eOkUqlAAiHw0QiEdasWcMTTzyR7Q0Ih8OX/VlERESutbwMB44xNPfFwUBrUwM/+87XePLP/wc33b4i57r9v/5bfvXDf8cfv/hL5txUmz2eSqUwxuD3+7PHznQep31/E5/56rcoDpWTSiawLRvP6Jx+K7MqDc19cVbODoLrcurUqexWwueCwLFjx0gmkwCUl5cTiURYuXIljz32WHZooLKy8hr8KYmIiFwdeRkOeuMOI6nMUrORVXcRCJbQsufVceGgZc+rzJ63MCcYQGZIwbbtnHn9x976vwCUhiv50TNf5tjB32DbHuYvW829f/wcZZVzSLkOvQl48PFnebvpdRKJBAChUIhIJMKyZct45JFHssMBs2bNmpBd90RERPJJXoaDnlg6u9iRJ1BEZNVdtDY2cO8f/Wvs0W19h3rPcOLQATY8/i/HvT6ZSOL359YbnO06CcDfP/9vqV5wC/d9/c/of/93vPl3P+LFr3+ZL/7gJQJFxQRKy7hl5Vq2rluVHQ6oqqpSCBARkYKRl+HgTMzBHjN1sW7DVpp3/wMdhw4w/xOrgMxwg2tc6jZ8Oue1rnFJppIU+4oZiY6QTqdJp9P0957FdVyKymZwzzPfxef34/V6CVfX8KsfPEd3835W3vt5ki6s+dzDbJirNQNERKQw5eXOQyNpN2dTmoUr76SopIyW3duzx5p3b6d6/iIqa+blvNYYg23bRKNRhoeHSafTeL1eikvLsG2bJZvuZc6cOVSEK5gRmsHy+s/g8Xo59c4hILOrYzTtXqNPKiIikn/yMhw4H1p6wevzc8vajbyz9zWcdJrBs+/T2XqQ2z7UawDgsT2Ew2FmVVZSVVWVDQHhOdeBBaHwLMbu3Gh7PARD5cSHB7PH0vm79IOIiMhVl5fh4Hw70t26/m5GBj/g+MHf0LJnB8YYbls/PhwAeD1ePB5vTs3B3NrFAAye7cm51kmliA58QMmM308z9Kq+QEREClhehoMSrz1u4aMFn1hNcdkMmndv5/CeV6lZVEe4uuaS73nTkpWUlldwaNf/IZVMZI+/tePvcV2H+ctWA2CPbp8rIiJSqPKyIHFW0INrDMaQLUr0+Hzccmc9LXu2k4xHuXvbs5d1T6/Pz93bnuEX/+GbvPgn/5wl9Z9hoKebN1/5CfNuW8bidfUYYzDGUBW8/BUSRUREpou8DAdVQS+2ZeECYx/Tt234NL/d/gssy+K29Xdf9n2Xbv4sHp+Pf/xff8Orf/0fKSoNseKez7P5yT/B9nhwjMGyLGYF8/KPRURE5JrIy42XHGN48Z8+YDjpXrNdEiGzC2Sp3+bJm2eet+5BRESkEOTl4LrHsqgLF4GVmZp4LRhjwIK6cJGCgYiIFLS87T9fHA6wrydG2oDvIs9qJ5UiOth/0XsVlZbhCxRd9Jq0yYSSxeHAFbRWRERk+sjbcBDye6gLBzjYG8c1XHDb5pOtB3np609c9F73P/s9lt39uQued43BxbA0XHRF2zWLiIhMJ3lZc3BOwnH5afsA/UkH/5jllMeKDQ1yur31ovepmjefUEXVec+d26q53O/h0doZ17TGQUREJB/ldTgA6BxK8XLHIK5r8NvnDwhXyhhD0jXYtsUDN4W4ocw3YfcWERGZqvL+Z/INZT42zi3BtiySrpmwAsVsMLAsNs4tUTAQEREZlbc1B2PVVWSKCXedHiFpDD4uXINwKVxjSJlMj8HGuSXZ+4uIiMgUGFYYq3Moxc6uYfqTDjYWXovLGmYwxpA24JKpMaivKVWPgYiIyIdMqXAAmSLFN7qjNPclMrs3GvDaFjbnDwrGGFwg7WbWMcisoRBgbXWxig9FRETOY8qFg3MGkw6tfQma++KMpDK1CJZl4Y75OLZlZY+X+DILKy0OBzRdUURE5CKmbDg4xzGG3rjDmVianphDNO2SNgbv6O6KVUEPs4JeKoo8WvlQRETkEkz5cCAiIiITS4PuIiIikkPhQERERHIoHIiIiEgOhQMRERHJoXAgIiIiORQOREREJIfCgYiIiORQOBAREZEcCgciIiKSQ+FAREREcigciIiISA6FAxEREcmhcCAiIiI5FA5EREQkh8KBiIiI5FA4EBERkRwKByIiIpJD4UBERERyKByIiIhIDoUDERERyaFwICIiIjkUDkRERCSHwoGIiIjkUDgQERGRHAoHIiIikkPhQERERHIoHIiIiEgOhQMRERHJoXAgIiIiORQOREREJIfCgYiIiORQOBAREZEcCgciIiKSQ+FAREREcigciIiISI7/DxhyaHUdwSRvAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = dataset.load()\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The graph is undirected and has 8 nodes and 13 edges.\n", - "The nodes have features have dimension 1.\n", - "There are 0 isolated nodes.\n" + " - Graph with 17 vertices and 38 edges.\n", + " - Features dimensions: [7, 4]\n", + " - There are 0 isolated nodes.\n", + "\n" ] } ], "source": [ - "print(\n", - " f\"The graph is undirected and has {data.x.shape[0]} nodes and {data.edge_index.shape[1]} edges.\"\n", - ")\n", - "print(f\"The nodes have features have dimension {data.x.shape[1]}.\")\n", - "\n", - "connected_nodes = torch.unique(data.edge_index)\n", - "isolated_nodes = []\n", - "for i in range(data.x.shape[0]):\n", - " if i not in connected_nodes:\n", - " isolated_nodes.append(i)\n", - "print(f\"There are {len(isolated_nodes)} isolated nodes.\")" + "dataset = loader.load()\n", + "describe_data(dataset)" ] }, { @@ -187,16 +190,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Transform configuration for graph2hypergraph/knn_lifting:\n", + "\n", "{'transform_type': 'lifting',\n", " 'transform_name': 'HypergraphKNNLifting',\n", - " 'k_value': 2,\n", + " 'k_value': 3,\n", " 'loop': True,\n", " 'feature_lifting': 'ProjectionSum'}\n" ] @@ -224,66 +230,43 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2814608829\n" + "Transform parameters are the same, using existing data_dir: /Users/gbg141/Documents/TopoProjectX/challenge-icml-2024/datasets/graph/TUDataset/MUTAG/lifting/557134810\n", + "\n", + "Dataset contains 188 samples.\n", + "\n", + "Providing more details about sample 0/188:\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIbCAYAAAB/tT3bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9eXgUVdr96T1bd2chJGTBkEACSQChhxEyURYJ6aA4jJMAowwOxMDIN7KIAiJLBBRZ/AbCN+PPoIwyKiA4KDiyhEVFDKJExSQEJGFJ2ALZl+5OL/X7o6myq7uqurq7AgHrPM88I53OfW8tue97zz33XAlBEAREiBAhQoQIESJuQXqnOyBChAgRIkSI6FoQiwMRIkSIECFCBA1icSBChAgRIkSIoEEsDkSIECFChAgRNIjFgQgRIkSIECGCBrE4ECFChAgRIkTQIBYHIkSIECFChAgaxOJAhAgRIkSIEEGDWBzcBixYsAAhISGc39HpdJgxYwbts4MHDyIhIQESiQQLFiwQpC8lJSWQSCS8vz9jxgyEhIRAIpEgISEBM2bMQFVVlSB94UJGRgbWrFnT6XHuZnj6LEUIi854R+/29158J+8diMVBF8GLL76InJwc6t+NjY3IycnBjh07QBAEXnzxxdvan6qqKiQkJKCqqgo7duxAQ0MD3nzzTdTX12Pnzp23tS8iRIgQIeL2QiwOugiys7MxevRo6t8HDx5EaGgoBg8eDAAIDg6mmITbgZycHMTHx6OoqAijR49GcHAwRo8ejR07dmD+/Pm3pQ+didt5L0V0LXj67MV3RcSvEfI73QERXQ87d+5ESUkJKisr73RXRIgQIULEHYDIHHQRZGRkULqCBQsWICcnB1VVVZBIJJgxYwZycnKQkZFBfSaRSNDY2Ej9PqkNSEhIQGFhIfV5Y2MjMjIyIJFIoNPpcPDgQbd92b59OwYPHoz4+Hi3383JyUFhYSEKCwuRkJBAtb9z507odDpKq+C8FDFjxgwsWLCA6ndISIjLd+rq6mjXxafvfODuXi5YsAAJCQkICQlx0YHw6TdbzDVr1nBeD1dcgN+zZHsPSN0L3/eA7blyxXB3b7xpk6vfbL/Dda/dPXum+8D1fXfvKFsfucDW5owZM5CRkUH7ruMaP993k+u+efp83L2T5PJoSEgIdDod9Y7rdDq3bXv6zooQGISITsf8+fOJ4OBgzu+MHj2amD9/PvXvHTt2EPHx8bTvMH1GEASRnZ1NjB49mmhoaCAqKyuJ4OBg4uTJk1S7gwcPJiorK4mGhgYiOzubcPfYBw8eTEyfPp3XtZHtx8fHEzt27KA+f/PNN6k+FBUVEQCof5O/FxwcTBQVFRENDQ3E9OnTCQBEZWUl9XMA1M+zs7MZr91buLuXjvdr9OjRvPvNBnfX4y4u2QbXs2R7D4qKioj4+HiioaGBIAj783B8Fmz9ZXqu7t41d8/Ukza5+u2uH1z3mu3Zs4Ht+3yfKVMfue47W5snT54kAFD3gyAIYvr06UR2djb1u+7eTT5jhafPnOudnD59OjWWvPnmmy73Uch3VoSwEIuD24DOLA4qKytdBow333yTmD9/PvUzx8GBHGC4EB8fT+uLu34HBwfT4rO1uXr1atrvOcdwjEsOOiTIAkMoMN1LpsGXIAhqwOXTbzZwXQ+fuO6eJdd7sGPHDrfvH1N/nZ8rVwzyd9w9U0/aZOs3n35wvTtCFgdscdz1kQ3u+u78dxQcHEwlcnf3n8998+T58BlfnAsix+8L/c6KEBai5uAuR0lJCQCgV69etM9/85vfoKSkBMHBwbyWBxwRHx9PtUsiJyeHoihHjx6NoqIi6mekYNEZhYWFKCoqQlVVFa/tj6NHj6Z97ze/+Q3136GhoR5dgzf47rvvEB8f73Itv/nNbyhhJhOc+80GtuvhE9fds+R6D1588UWEhoZCIpFg9OjRmDFjBrKzs9321/m5csXgasPx3njSJlu/+fTjdr07bHG8uVfu2gTsFPz27dsxf/58lJSUoLGxkfNZOt5/Pn3y5Pl4O76Q19QZ76wI4SBqDu4BDB48GA0NDbT/OSZvT5GRkYGDBw/S1lbJLZVMOxWYBgedTocdO3ZgxowZOHnyJLXrwhMwFRxsIPUN5P+82SvOtfYsBNiuR6i4bO9BcHAwKisr8eabbyI4OJhak3cHpufq67vmSZtc/XbXD0/eHV/AFcfbe8XV5vTp01FSUoKqqips377d44Tprk9CP/PRo0dj1apVAIA1a9Zg8ODBtOsT+p0VIRzE4uAux+DBg6kZhDPi4+PR2NjosWnR/PnzER8f77XxUlVVFUpKSjhn20w4ePAghgwZ4lXMkydPgrAvk7EWMe5AzrKc7+V3333H2S9f+s03rrtnyfUekJg+fTp27NiBN998E9u3b/e4n3xiOMPdvfGm397043ajs/pIbik+ePAgdu7cyShcdYTj/femT76OL+TvJSQkoKioCIcOHeLVNglf31kR3kMsDu4ixMfHU0nk4MGDqKqqQnx8PKZPn07tbgDsOwXIKn3w4MHIycmh/ojz8vJ4xdqxYwc+/PBD5OTkUH/A5IzFHUjakFQek1sjnVFYWEi1TfZ/+vTpfG+HT2C6l4MHD8bo0aPx8MMPUz8j/R4cZ2hC95tPXHfPkus9IP+/sbERjY2NKCoq8pgKdhfD23vjTb/59MPddTg/eyG/7+66fMWMGTOwY8cO1NfXuxTfXPffmz75Or5UVVVh4sSJKCoqolgAPm0L9c6K8B5icXCb0NjYSKO9+Wyjcgb5x9irVy+sXr2a+vzNN9/E4MGDodPpEBISgjfffJMaNA4dOoTQ0FBqe9yMGTN4/ZENHjwY58+fR2hoKPLy8hASEkI5OLpjFIKDgzF//nxqi5KjkZIjSMqxV69eqKqqwsmTJ28bHcx2L8m+6nQ69OrVC6GhoTh58mSn95tPXHfPku09IM2sevXqhZCQEDQ2NmLTpk1e9ZPrXQO8uzfe9NtdP7jA9uyF+r676/IV2dnZ+O677zBhwgSXn7m7/970yZfxJT4+Hjk5OUhISKCs4B2dYG/HOyvCO0gIgiDudCdE/PqQkZGBwYMHezTYdgXcrf2+HRDvze2DTqfD6tWraYm9q93/nTt3Ii8vD+fPn6cKlJKSEjz88MNYvXr1bWMJRXgHkTkQIUKEiLsIJIUvBAvRmfj2229dGMPBgwdjwoQJLqyYiK4HsTgQIUKEiLsA5BLkqlWr7opZ98SJEynhJNn3nTt3UlomEV0bos+BCBEiRNwFOHjwIHJycjB48OC7YuY9ePBg7NixA6tXr6aEivHx8di0aVOXZz1EiJoDESJEiBAhQoQTxGUFESJEiBAhQgQNYnEgQoQIESJEiKBBLA5EiBAhQoQIETSIxYEIESJEiBAhggaxOBAhQoQIESJE0CAWByJEiBAhQoQIGsTiQIQIESJEiBBBg1gciBAhQoQIESJoEIsDESJEiBAhQgQNYnEgQoQIESJEiKBBLA5EiBAhQoQIETSIxYEIESJEiBAhggaxOBAhQoQIESJE0CAWByJEiBAhQoQIGsTiQIQIESJEiBBBg1gciBAhQoQIESJoEIsDESJEiBAhQgQNYnEgQoQIESJEiKBBLA5EiBAhQoQIETSIxYEIESJEiBAhggaxOBAhQoQIESJE0CAWByJEiBAhQoQIGsTiQIQIESJEiBBBg1gciBAhQoQIESJoEIsDESJEiBAhQgQNYnEgQoQIESJEiKBBLA5EiBAhQoQIETSIxYEIESJEiBAhggaxOBAhQoQIESJE0CAWByJEiBAhQoQIGuR3ugO+wkoQqDNaUWuw4IbBijaLDVaCgEwiQaBcinB/Gbr7yxHmJ4NMIhHjiHG8jnMvXYsYR3wHxDhdP86dxF1bHDR3WFFWb8KpeiPazARsBAGpRAIbQVDfIf8tlUgQqJBgQKgfUkJV0ChlYhwxDu8499K1iHHEd0CM0/XjdAVICMLhqu4CmKw2HLvajlP1JlgJAiAAuVQCKQAJQ4VGEARsACw2ApAAMokEA0JV+F2PAKhk7KsqYhwxzr10LWIc8R0Q43T9OF0Jd1VxcKnFjAM1rWjqsEIKCeQS5gfDBoIgYCEAGwgEK2XIiAlCT7VCjCPGcYlzL12LGMe7OPfStYhxun6croa7pjg4VWfEocttsBEEFBIJpD6s49gIAuZbtM/D0YEYEOYnxhHjUHHupWsR43gX5166FjFO14/TFXFXFAen6ow4VGN/QEqpxKOqjQ0EQaDDdutBxdgflBhHjAPgnrkWMY53cQDxHRDj3L44XRVdvji41GLGR+ebYbMJ94BIUA9KKkF6ZAC+utYuxvkVxwHZJIG7/lrEON7FEd8BMc7tjPPHXpouu8TQpYsDk9WGf59tQlOHFUqJsA+IBEEQMNkIEACkEohxfqVxbDYb2m32/w6QAVKJ8KKhe+2e3WtxxHdAjHM743QQdg3C5ERtlxQpdr0eOeDY1XY0dVih6KQHBNwSlhCAlQAIwjOhiRjn3oljJpj/W0jca/fsXosjvgNinNsZRyGRoLHDimNX2zslhq/ossVBc4cVp+pNkIJbBFL6xX7846/Z+Ph/872KYyMIWG79N6kovVNxfI0hxvEujl0o9Mu/zbbOiyO+a8LFEaJtxxhs74DQcdju2b0UR8gY92IcwO6HIIUEp+pNaO6wCtauUOiyxUHZrf2kcjeFW+rwTPirteitG+ZVHIvTeGax3bk4vsYQ4/j+bMjXrbPjsMW4XXHulmfDFUeItpliOL8DnRXHMca9FkfIGPdiHBJyid1tsazeJGi7QqBLFgdWgsCpeiPAk9a5fKYUCV48NIIgYLbZ3wYyitlGgGCZ0d2OON7GEOMI92xuVxzxXfM9ji9tc8W4XXGc79m9FEeIGPdiHEeQyxin6o12c6UuhC5ZHNQZrWgzE5BL3RcG9VeqEaAJhn+QxuM4NsBlKCNufX4n4vgSQ4wj3LO5XXHEd823OL62zRXjdsVxvGf3UhyhYtyLcZwhl0rQZraf1dCV0CXPVqg1WCjTCXeoLClGwuBhKP1iPwDgp8/3ITPvOYRGxbr9XZvTmyDBrZeBAGROoW9HHF9iiHGEeTa3K474rvkex9e22WLcrjjO9+xeiiNUjHsxjjOkACwEgRsGC7r7d52U3HV64oAbBiukPHconDtZDENrM1KH51Ofnfh0O/TTn3f7u+RhGc5RbHaZ6m2P40sMMY6wz+Z2xRHfNe/j+Nq2uxi3Kw55z+6lOELFuBfjOEMikUAiAWoNVqT43Jpw6JLFQZvFdutB8SkOvsb//L+d1L/rr9bA2NrCKw7bCg/T0s/tiMMco5VXDDGOd3G4VvluRxz+75qwce6GZ+Mujq9tu4txu+KQ9+xeiiNUjHsxDhNsBIF2NoXyHUKXLA74CjPqr1QDAI3aqan4CeG9k9HQ2ICQ4BCKBjK0NCGkRyxNbcovCnOcS+U/IiIxFQajAf5+/jC0NuPbT3cAAB6alEv7fT5xmGJcPlOK6JRBuHrtKrp3747TRw/C0NKEy2fLkTo800U560ucyL4DcO36NURGRKD0iwMI7RGLy2dLAQBDHp0gWJzwPim4cfMGwruFU5+XfrEffkEawa6n5sxPCO+dgsamRgRrg7H15bkY/qc8AMCpzz+jVftCvANGkxF+KrsN6pfb3kZojxgAdoWzEHHOl5Ygqu/9IEBAAgm2vjwX4+e9zLj+6es7UFtbi+7du1N/NyQcr8XXOOF9UlBXX4ew0DB8++mH8FdrUX+1Br0HD0NUYjKvOA0sbZPvEAECly+cR+nh/8Lf3496/gBcxoTo+x9gvQZ3cYwmI2ov1+Bc8SHIZXLa377zmMB1z9juFRmnpbUFDTdqcf74YUgkUlqc0i/208YFrutxF+dm3U0YW1tQVXyY6rdjHMdxITUrmzGGu3sGAFcvX8L3+3YhMCCA9mwcY5FjgrfvAABcvngepw7tQYC/Py0O05jgbRyL1YKr1ZdQ/vln8FOpXK6HbUxwhkUUJLqHjKfxRGVJMXrr0miflR09gD7DRsJgMODaxUqcO1mM1OGZGPLoBHy57S3ad/naWzDFOf3VQfQeOgKNjY0gQKDyZDHamxsYf59PHKYYpV/uR+rwTBAEgdPfFQOwJ+rM6c9h68tzBI2T9LtRsNlsuHn9Kr7YuglRiclIHaHHx3/PFzRO4tARMJvNsNrs4htDazO+2LoJxtZmweKUfXkAvR8YDoPBAACov1qNt5+fin2bXsfwJ6Z7HIMtDvkOtN6aQWx+IRdDHs1B6vBMfLF1k2Bxzhw7jN5Dh6O9vR31V6pR+uV+rHsiAyseewAvPZyML7e97VEctmfT+4HhsFgtaG9tRv3VGqQOz0Tq8EycO1ns0oavcTo6OnDlbDn19/nQpFzs2/Q67zhV3x9n/nsZoad+r/L7b9DSUAdHE9j6K9UuYwLXtbiLYzabcf7Hb9HaUO96/U5jAlcc1r//W3FMJhPO/3ACbU30MebK2XIA9HHBlzhmsxlV3x93GcvIv1PHccHbZwPY701bYz3t2TjHIscE7+MQOFdyHK0NrnGYxgRv49jv2TdoqbvpEodrTHCGvJMMl7xFlywOAuVSXqdfnTtZTKsSz50sRlSfZPSI7Ynqn07ip6OH4BcURP3cP0hDG+jYIjiHZoyTmIyQ8O64dOo7NNTXI3V4JsKiejK3xyMO27WEhkfgctn3aGtswJkTR6nrCNAEUwODEHEio2NR/dNJmAkJZv4/+2yn4UoNEga7bt3xJU63HlGo/ukkGhsbAQCln+9D/xFZzO35ECcoOASXTn0HU4cJw/+UhyW7v8G0tW+7zLa53jK3cRKT4RekRuXJ47h8toxq+8rZchoFyfdauK5HFRiEim+Oov5qDRZ/chxLdn+DJbu/wfi5+bTZna/3rPqnk5AqlPj20w+p98vxb0iIOH5Balw69R3OlRQjpEc07ff5vtPnS5jb/uVvXILEYSOgjehB+73KkmKXMeF8iWvxwz8O0GfocIQ6XQcAlzGB656x3Ssyjs1mQ5+hwxHSgy6Aa29povpBjgvXfqbfQ/5xvgZBEEgaNtJlLPMP0lDvNDkueP9sgKS0UdBGRDH+vvOY4G0cgrA/m2CndwAA45jgbRyr1Yo+Q4dDG+n6LnONCY6QSiQIkHetdNy1enML4f4y2AiCsap0xJWfyxGdmEr7d/8RWVApVbCZTWi8fhmE7JdDLfzVWtoMlSxAnKM4FyZscbRaLUztrTCaTDB1sJtY8InDFgMA5BICsf11+N2Uv1F7btubG10oWF/iSCVSWDtMIAgCLS0t+PbTD/HF1k3407K/C3o9/v7+MLW3wmQyoeZsKWPxIUQctVoNY1srmpubUXPmJ5R+sR/ffvohvv30Q14x+MZRKBQwtrXgQtkPqL9ajYYrNQDg4qTmy7s2YNRYAEBbUwN664ZSA863n35Im43xjcP6d6NSwdjWCoPBgMy85/CPZ7Lxj79mu7AtvsaRSqUwtrUiODIKDVcvUz9vuFqD+qvVvOJcO3ea9e+FmnEyTDDqrlxCgCaE+re/WgtTWwtjDF5xbo1RfAhhrnvG9fdvbG0GwbSlAkBv3TCMfy6f+nd7cyOiE1O8itPW3Gj/nkzGeg2O44Ivz0Yqtace5yH+ytlylzHB2zg2wsaa8JnGBG/jWC3MWxAvny3lHBNIELdyXXd/9vt+J9Ali4Pu/nJIJRLGPeDOcEyQvQcPQ3tzA0q/2I+hj/wRgAQWqxXt7b94Vxtamqj/drZRIFg+Z4tT9sUBDNGPBwA0NDSwGtrwjcN2LYMefhRyuRw2mw2tra34+H/z8Yd5ywWP88DYPwAA2traoHskG0MenYD9hf8raJyyLw5gwK0/rMvnznJuBfIlzs/HP0fiMPsSRsbTcx1o5LdhoBWIrnE9iXOx5Gv0GToczfU34a/WIioxGVGJybh8tpQ2C/b1Xav69ih6PzAcZovd3LX+SjUMrS0uTIgv9+xs8RH0GToc5g4zas78hP95Yyf81Vpsfn6aSx99iXPumy/QZ+hwJA4bCcBOI5MzSj+e18PWdukX+6l1Xb6++CaHMcHTOOT3+CwXu7tnXHFshPvRkBwXvI3TZ+gIAICMozgY8ugEalzw5dn8UhzQr6v+arXLmOBtHOKWqJ3p0einP+8yJngbh1widYahtYVzTCBhg/1dDe9C2xiBLipIDPOTIVAhQWuHDTLnTeAOmPceXTRFPgQS0QmJqKu9hqamRihVSkqAREKKX/aykpDAtWJyF6dV0Qqz2Yz29nbGaotPHHcxQkJCcOPGDXxf9CniBz/AKGwRIo5SqURLQz1a/P3RWzcMW1+e4yJ+9DWOxWrB0Q83Q9u9B059vg+Xz5Si/ko1QnvE0vria5z6+nr89MV+nKiuwvhZLwEA/ILUaLhSA/9b32GK4Ukcq82K69evIzCsO0JuiY4A3BLZVVN98fVda2hsgMFggMFggEKtwIlPt6O37ndwhi/3zEbYcO3aNVR8fQi9dWmISkzGtLVv4+P/zXeho32J09jUiPb2dnR0dOBPy/6OK2fLEZ2UAr8gNaKT6Ju52OLMe28fY9uOYCoOwqJ6wuCwy8jQ0oSwqFjWd8BdHGpGz6M64LpnXO8xAfcsaukX+9FbN4xKit7EaWxqBMBeHBham+F/SyRoHxfGoMfAoV49G5nUHsPmwIiQwr3SL/bTxoQeffp59Q7YbDbGtYLSL/aj5sxPlDCZHBO8jWO1WhnftdAeMQh1yDfOYwIJi41AkFKKMD+ROXALmUSCAaF+gARu/yi40Pe3D6LuwjkQAOrr6lB/tZo2wEkkEiikdCpJIZVAwls+ZkdwcDAAoKOjAxarxeXnQsRRyBW4WnEKqsAgRA/4La6cLaeUx0LG+fmrA/juk/fR3m6A1WpBgCYYAWqtoHHkMjmG/mEyej8wHHGD0xDSIxq9da5KdV/jBAQGQBvRA1H97qdYHWNrCy0OUwxP4sikMshkMsSm6nCz5gL1ecPVGprVqq/XolKp7P03GgEAZV8WUQpoR/gSRyqRQiKRwNjaDIV/IPV5b90wQd8BMvm0NDZg68tzEZWYDENzE6ITU101Ib5cz63Zqc1hDEkYPAyXz5RS/7aPCWlevwPkjN7GY5zy9lqsVvvMlO17504Wwy9Ig9ThmbhythwNV2u8imO5xUoxFQfffvohvvigkPq3fVwI9v7ZyMhn8wtz8NCkXEoE6zgmeHvf2HJHaI9YWmFNjgnexrHZmJcvEnTDaMtkzmMC1UcJMCDUj7cQ/3ahSzIHAJASqsI3tQZYCEDh5T0LjYrF4DGP4dw3X8DY2ozfPPaEy3fkEqDD8d9elEsKuQK1P5eh+qeTMLW3oVv0fRjgtBbsa5z6K9X47O/LqD9gi9GAVw67UlS+xrn/4Udhk8px6afvcPz0Dxjy6ASXpC1EnMCgIDQ2NuL0N1+i8mQxGq5etgswnShFX+KoVCpExCfhbPHnKCnagxvnz2LqmrdcvucYgxwUPI1jDQxCyqhH8e2nH8LQ2oLMvOdcEp0v16JQ2LUzVosVVpsVfkFq+Gu0jN/1JY5MJkPqw+NQduBj1FadAQCKGhUqjuxW0par/NBbZ3edq79aQ1s7FyJO9U8nUf3TSdjMJnSPiUPq8EyERsWi/wg9tf2P3Hbm7TtAEASqfzqJCz+egK3DhNAeMRSrd+5kMWWeQ37uzbWQxcGl0pOoKjkOU3sr1V79lWraziVjWwteOVQOG0F4GIegxpZLp75z6XfqCD0qb13PuZPHqHHB8zh2XPjxBKp/OgmL0YDSuN40JvTcyWJUlhynjQne3DebzYZLt94BWMzoFn0fUodnIioxGaVf7KcYBMcxwdM4BAjYbDbUlJbg0k/fAeYOKo5/kAa/fXQC55hgIeyT4ZRQlfsLus2QEL5MzTsZh2ta8X2dEQoJ97HN7tBuaKfU8SEhIfD386f93GixwQL7i+En845MsdlsqK29DhtBwN/fHyHBIS7fESJOfUM9jEYjZDIZuoeHQyJxbcfXOAajAQ0NDZAACOvWDUqFkvF7vsSxETZcv34dBEFArVZDHaRm/a4vccj7pZDLER4eDjZNsslqo47sVUgBlZR/HKPRgPqGBvu6YXg45DL2mtvbayFA4Nq1ayAIAlqtFoEBgZzf9zYOeb9USiXCwrq5/b43caj3SyJBREQEpAzvsBBxyOULjUaDoEDXHRfO8OYdqKuvg8lkgp+fH0JDQnn1y9NrIccviUSCbt26QSFXuP0dT+NYbVbU1taCIAiEhoZSvh1CxyFhMBjQ0NgAlUqFsNCwTonTbmhHU1MTCIJAeHh4p943mUwGm82GsLAw3nHsx4QTGBTmh1Ex7t/P240uuaxA4nc9AhCslMHMY+cCFwL8/aFS2hNcU1MTjfonaR2ZxL7Vx9s4UqkUQWp7gjMaDDCajLSfCxVHrVZDAgmsVitaGBy6hIjj5+cHmUwGAkBzczOj0NLXOFKJFP7+9iKtra2NVXDlaxwyhsVqRUdHB+v3HNkpT5kqhVIJiUQCgiAo2p8JvlyLBBLI5faigyuGr3HIGGaLhVVg62scx2KAnK12ShxyWcHK70Abb94Bsi98++TNtVh59t+XOBaL5ZZWQcKrWPM2DgnJLfqe77PxJo7NZqO0AJ31fMhnI/VgMkHGMRMEgpUy/K5HgEe/e7vQpYsDlUyKjJggSCUSdNh8KRAk0AYHQyKRwGazUTsLCIJAh42ATCrBiKhAn+MEBgZCLpODgL0IIVWsQsZRyBXw87dX9W1tbTBbzNTPhIojgQRBgfaZqbnD7JKMhIoT4O9PPZO2tjaXnwsRR6VSUYm7ra2d8Tv2P1T7bFEhBcw2zxKqTCqjkmp7eztrMeXrtZBLC+aODs5iypc45HozQRAwm82s3/MljkR669wUgnBbHPgU51ZisNrcK/29fQeIW20TPGN4cy2/aA74wZs4FrPZ3r7kl8TdWdcDeP5svIlDEIRHxYE3caxWK0B4VhyQcaQSCTJigqDykkXubHTNXjmgp1qBh6N9T9xymRzqWzN7s9mM5uZm6gE9HB2IId39fY4jgQQarQYSiX1m39zcDIKwCR4nKCiISnhNTU20QkeoOP4BAZBKpSBg9z0gE56QcRRKJZWMnNkDoeJIJdJfxHwmo4tg1PkP1dtiVKVUUYyOuYOeVIW6FoVCYX/usDvmOUOIODKZjBpQ2ZgWX+NQym6JhFcB4mscd7NTX94B262dAe4Eib5cyy9qePdJ29s4Zocijc8SrlDPhiAIzm2avsSx2WwOWyY75/lYrVZ7QcVz2ds5Tk81vyWIO4EuXxwAwIAwPzwcEwipVIIOguClDGZCYGCgfYCVSmGFFFaLBQ/HBGJAmJ9gcfxUKiiVSkgAmDo60N5hgVQqETSOQq6An58fJLAPru0GAzoIQtA4UonUPrO/lfDa29rs4iMB40ggQUBAgMPM3s4eCB3Hz8+P+uN19LxgiuNtDKVSSY3dBqOBM4a316KQ/6JlMDmxOULFcVSqMxUHQsShZlmEfcbKBEHi8Jid+vYO3Eoat95fT2J4ci3UsoKb/ONLHHuRZlfmS9zMgoV4No7JlK148zUOjTnw8B3gG4daVuBRHLDF6arosrsVnDEgzA/BShmKalrR2GGFlLALRvhWbAAAAgjSBsNgNKLh8iV8/fbryHnj70BYLwHjSBCkVqNFIoNUJsON6vOYOCAWA8Loohtf4wQFBdmFdip/dFhs0PrbMDYuxKUS9SVOQGAg2trbAQIwWqyQ2WwIUcmRERMkWBw/Pz+0trSAIOyJW+UfCEICBCtlgsVRqeyzegIEDAYDAgODYIMENhCMcbyJoVAqqBhGoxFBQWrOGN7EkZPMAUHAZOqwszmEXfEsVBySOSAIAuaODuqwJ4IgBItjP6LWfq9IbQO5XUzQOKTmwGajxeATh08Mx1RBEITHMfjEIdXwXPA1DkHYqBkw1yxYyGfjCKvVBoe6V7A4hM1G6SeYErsQcWxWq72g4tBp8InTFdGldyswwWS14djVdpyqN9lPbyQAuVRiNxhheAEJgoANdqMJu9BEgrpTX+Mfc59Gh6ENQ4YMwb59+yjqWag4xvZ2nNj1Hr56pwAPpg3Ff/7zH8Z1KV/imEwmGA3tOLV3J7o1XcJb/+8Nwe9ba7sBVqsVFnMHJJfPYtGkLM41Mm/iNDY3w3YrYShkMjwQHYzf9QgQNE5dfR0sNhvkShVUKj/4KRUYEKrijONpjJt1N2ElCMiVKvj5+UGlcB/D0zg3bt6AxWKBVC5HkCYYcrnsli+IcHGu116n9m4Hh4VBIpVTfzvCxCFw7dZOFYlEgtCwMMhkctrfqBBxjCYj6uvrIZFI0L17d0glUpexwJd3wEbYcOPGDeo6unfvDgkkHsfgimOzWlF386a98JBIKDU807jmbRzCZkFjXR0I2FmdiO4R1PeFjOP4bMwWM27cuAGJRAKtVgt/P3/B49Q31EMqlcJgMFA7VoS+noa6mzBbLAgKCkJbW5vPz6cr4a4rDkg0d1hRVm/CqXoj2swE9QfqWCFKb82AJBIJAhV2Y6WUUBWsbc0YOnQorly5AolEgpkzZ+K1114TNE6oqR4jh/0Wzc3NkMvlWL16NWbMmCHo9URYmjBnwqO4WXMRSqUS27Ztw5gxYwS9b1KzEfs2F+DUvv/A2taMzz//HP369RP0+VgsFtRdqcaPe3fgyrdf4osDnyE0lN+2ML5xOsxmmIwGtDXcxOUTR/B/i+YgxJ95i6a3MUwdJnSYTGhvrENrRQlWzcqFRsnf9YxPHJPRCBtBwGa1QGbtwMNJsUgJVQkax2QywWoxQyKVQiGXIyTQj/rbESqO0Wi0D6BWK/z8/aGQy2l/o0LEsVitdjGtRAJ/lRJSqcxlLOAbhykGQdhgMJpAwD7p9vf3uzWL9C4GUxyL1QpDezt13oHKTwW5VMY4rnkbp7HdBFOHGQRhg0wmh5+fne5mGz8FeTY2K4wGIyQSCeQymX0pVuA47YZ2e9FpsUChUEClVAp+PW3t7bBZrVD5qWA2WwR7Pl0Bd21xQMJKEKgzWnHDYEGtwYp2iw0WgoBcYj/lqru/DOH+coT5yWgOVDt37kReXh4sFguUSiU2b96M3//+94LGWbVqFdasWQObzQa1Wo1Dhw4hKSlJ0OvJzc3F7t27YbPZEBcXhy+//BKBgdx74D2JE6KUYNSIETh79iwIgsDIkSOxbds23ssffOIEEh14+IHBaLy1933evHl48cUXebXPN46loRazpj6J61VnIQGBLVu24JFHHhE0RnX5j1i58DncvHAOSoUcx48fR1xcnEcx3MX56eS32L/zA9RWnYGkvQk/lJRQOyWEinP82DFcOHsaNy/8jMhAJd75x3qf3NuY4uzdfwAtzU0wNNajf1w0ZjyZ4/I36mucS9dqse9AESSEDQ8NHYIH709hHAu8jXHq/GX8t+gQpHIFbFYLxmdlol9Md59jOMb5z4Ej2P/1dwgK7Qa5UoWHR45AdHgY67jmTZzFr67Fd2eqEHpfH3SPvQ+jx4xxO356ez3ks7l8ow579x+AXCpBZGgwpvzhEcHjvPaPQvRJGYCKsz8jqU9vPDT0t4Jez9ma6/jrC4sQel8fPPjwGPxUVib487mjIH6lsNlsRHZ2NhEWFkaEhIQQvXr1IqqqqgSN0dzcTKSkpBDh4eFEeHg4kZGRQXR0dAgao7S0lAgPDyeCg4OJsLAwIj8/X9D2CYIg3n33XSI0NJTQarVEeHg4cfDgQcFjPPvss0R0dDQRERFBJCQkEHV1dYK2b7PZiGHDhhFxcXHEfffdR/z+978XtH2CIIhr164RERERRLdu3YiIiAhi7dq1gsf49NNPibCwMCI0NJQIDw8nvv76a8FjLFmyhIiPjyeioqKIuLg4wmg0Ch5jzJgxRFJSEtG3b18iJydH8PYJgiB+/PFHQiaTEREREcTrr78uePsHDx4kunXrRoSFhRHh4eFEcXGx4DFWrFhBxMXFEXFxcUSPHj2IU6dOCR5j7Nix1LP4wx/+IHj7TDh16hTh7+9PxMXFEZmZmYK3b7PZiNjYWGLlypWEUqkkZs6cKXiMEydOUGP7+++/32nP507h7lj86ARIJBKsXr0a/v7+kMlkaGtrQ15eHuMWMW+hVquxcOFC+/Y2sxnff/891q9fL1j7AJCSkoJx48YhMDAQUqkUb775JkpLS93/ogfIzs5GeHg4NBoN/P398fLLL3NuQfMGEyZMQEdHB8xmM1pbW/Hmm28K2r5EIoFer4fFYkFbWxuOHz+OH3/8UdAYERER6NOnD8LDw6HVavHhhx+6FZN5ipSUFCgUCsjlcvj7+2Pfvn3uf8lDxMbGoq2tDR0dHTAYDPj+++8Fj6HVaimdT2lpqddblLlACh8DAwNRXV3t/hc8RHOz/XRPcocH+W8hUVNTg6CgIGobttCwWCwoLy+HzWaDQqGARqNx/0sCQSqVQiqVdsqzMRgMsNzSAkgkErQyGMb5iurqahAEAZlMhqCgrudw6Ct+tcUBAMTHx+O5554DYN/Kc+rUKSxbtkzQGJMmTcLAgQOh1WqhUCiwfv16lJSUCBrjueeeg8VigVwuh1KpxAsvvOCVqxobAgIC8Oc//xlWqxVtbW2oqKjA+++/L1j7AJCWlob77rsPkZGRCAoKwubNm1FfXy9oDL1eD7PZDJlMhoCAALz1lus5C74iLS0NVqsVjY2NqK6uRnFxsaDt9+zZE2q1GhEREQgNDcW+ffsET6yxsbEgCAJSqd0j4uuvvxa0fQDQaDSQy+UwGo1obGzE1atXBY8B2AsEf39/1NTUCN52U1MT5HI5JTRuamoSPEZ1dTX8/Px4LRV6g/Pnz8NoNKK1tRVSqRRarbZT4jCB3BXT0NAgePImC7XOLg4CAwMhkUjE4uBexP/8z/+gX79+CA4OhkwmwzvvvINPPvlEsPblcjmWLVsGg8EAiUQClUqFWbNmwWAwuP9lnkhJScEjjzwCf39/tLe3o6SkBO+++65g7QPA1KlTIZFIEBISgm7dumHdunWCzpSkUikmTJiA5uZmtLS0wGAwCM4e6HQ6hIeHIzo6Gn5+fti9ezeuX78uaIy0tDTqHA+NRoMPP/xQ0PalUimSk5MRGBiIpqYmVFdX4/Tp04LGiI2NhVQqRUBAACIjIwUvcABQM9T29nYQBIGysjLBYwD2+6VQKDqNOSCTj1Kp7BTmoLq6GkqlstOYg7KyslviSvv/bjdzQDpkCl28kYVaUFAQpFJppxUHpHC6s4q3O4lffXGgVCqxZs0atLe3w8/PD0FBQXj++edx/vx5wWIMHz4cGRkZ9j39ra2oqqrCK6+8Ilj7gJ09aG9vp5L3a6+9JuhsLCoqCo8++iikUinq6urQ1NSEgoICwdoHgJycHFgsFnTv3h0RERGCswcymQxjxoyByWSi2hW6iBo6dKj9COfYWISGhuLTTz8VfGBKSUmBwWCAwWCAn58f9u7dK2j7sbGxkEgk6NGjB1QqFb777jtBl9sA+7KC1Wq1n0kSFCT4UhgJicR+JsWVK1d4nePgCZqbm6mkoFarBWcODAYDbt68CalU2mnJp7S0FGFhYfbthWbzbWcOyPdK6OLtdjEHGo0GMpmMOsPlXsKvvjgA7AP6E0884WB5TAiuP1i6dClMJhMiIiKgVquxefNmHD16VLD2U1JSMHbsWCp522w2LFmyRLD2ASAvLw/Nzc0IDw9HREQENm3ahIsXLwrWflxcHIYOHYqgoCBcuXIFZrNZcPZAr9ejrq4OWq0W9913H7Zs2eL2ICNPEBERgYSEBISEhODq1aswGAz473//K1j7AJCamora2looFAr06tVLcN2BRqOBRqNBcHAwWlpaYDKZBNcdaDQamM1mSCQSREVFdSpzANjX1oVmiZqamqgZfWBgoODMATmbJgii02jrsrIyRETYfQ1MJtNtZQ7Ic1XkcnmnMQekFovp7BZfQS4raDQaz8z47hKIxcEtLFmyBBqNBj179oTBYEBFRYWg+oPExET8+c9/RmtrK1paWhAREYE5c+YIOqA899xzaGxsRM+ePeHv74/PPvsMBw4cEKx9nU4HnU4HjUaDy5cvw9/fH6+++qpg7QPAxIkTcfHiRWg0GsTHxwvOHjz44IMIDAxEQkICrl+/joaGBuzatUuw9oFflhY6OjqQmJiI7du3C9p+SkoKALtmRqFQoKysTPCZV0xMDJRKJa5fvw61Wi247kCr1aKtrQ1yuRyhoaGdVhyQCQjonNkpOaMnl3mEBNlfUlgnNAiCQGlpKYKDgxEUFASDwXBbmQOpVAry2O7OYg7UanWnMAc2mw2XL1+GSqW6rffsdkIsDm4hJCQE+fn5uHz5MsLCwhAWFoYtW7YIqj+YN28elEol+vTpg5s3b6KxsRGLFy8WrH2SPTCZTLh58yZ69eqFRYsWCVo15+Xl4fz584iKikJERAT27NmDb7/9VrD2H330Ufj7+yMpKQkXL16E1WoVlD3w8/PDyJEj0dbWhpaWFqSkpGDTpk2CivrS0tJQU1OD2NhYaDQaHD9+HBcuXBCs/aSkJMhkMkRGRuLSpUtQKBTYv3+/YO0D9qUFkoZPTEwUXHeg0WjQ0dGBqKgo+Pn54eLFi52yZk/S5YDwxYEjc6BWqwXvf3V1NSXa7IzioLa2FnV1dZDL5YiMjASA284cAEB4eHinPBulUkmZK7W2tgr6N15bWwuz2Xzbd3jcTojFgQP++Mc/4sEHHwRBEFRyFVJ/0K1bN8yePRvnzp1DaGgoIiMjsXPnTkFp5+eeew43btzA/fffj5s3b6Kurg7r1q0TrP2xY8eiR48eiI6OxtmzZxEXF4f8/HzBtuwFBQXhkUcewdWrV2E2mzFw4EDB2QO9Xo+ff/4ZiYmJUCqVqKiowLFjxwRrf+jQoZBIJOjTpw8qKysRFBSEnTt3Cta+SqVCnz59IJfL0djYiPvvv1/wpYXY2Fg0NTVBoVCgW7dugusOyNlWREQE9e4ILawE7LPT9vZ2dOvWrdOZg84oDqKioijho9Ag2Rqz2Yzu3bsDuL3FAbnkExYW1inPhnzHpFIpbDYb7dA1X0H2VyKRiMXBrwESiQSvvfYaWlpaMHDgQFy8eBGBgYGC6g9yc3MRExODiIgIVFVVITk5GfPnz0dtba0g7aekpCArKws3btyA2WxG//79sWnTJsEEXwqFAtOmTcOPP/6I++67D1qtFt9//72gDMuECRNw+fJlDB06lNpLLCR7MHr0aMhkMiQkJODHH39E7969sWnTJsHaJ3UHcrkcDQ0NGDJkiOCeBykpKaivr4dCoUBkZCSOHz+OhoYGwdqPjY3F5cuX0adPHwAQXHdADqhhYWHULK8zlhYkEgna2toQGxvbKbNTMml3hiCxpqYG0dHRncYclJWVQa1Wo76+nlLd325BImB/FzqjOCDfMTKOkMUb2V+bzSYuK/xaEB8fj9mzZ+Onn35CXFwc5HI5fv75Z8H0ByqVCi+99BJKS0sxZMgQXLlyBQDwwgsvCEZ7Pffcc7hy5QrS0tKoJC6k98GTTz4JmUyG5ORk/Pjjj/jtb3+LV155RTBhX1paGqKjo+Hv748rV64gPT1dUPZAq9Vi2LBhaGxshFQqRb9+/VBUVCToDpW0tDRUVlYiPDwcQUFBqKmpEZSaT0lJwdmzZzFw4EAYDAYQBIGioiLB2o+NjYXRaERCQgKuXbsGrVYrqO6AHLhDQkJw+fJl9O3bt1N2LEilUlitVvTo0UNw0ZvjjL6zmIPw8HAA6LTiIDk5GdXV1QgODgZwZ5iDoKAgwb0OmpqaaMwB+ZlQqK6uRkhICNrb20Xm4NeE//mf/0GvXr2gVCpx8+ZN6HQ6QfUH48aNg06nQ0NDA6xWK5KTk1FUVCSYcI1kD37++WcEBwejR48eOHXqlGDb9kJCQpCTk4OTJ0+iV69ekEqlqK2tRWFhoSDtk54Hx48fx+DBg1FXVyc4e5CVlYXvvvsODz30ECorKxEWFiaoKRJZHDz44IM4deoU4uLiBPU8SE1NRXt7O/r164fvv/8eOp1O0KWF2NhYAED37t1RUVGB3/72t4IWN+TArdFoUFdXh8TExE5jDgDhqWuCIGjLCkFBQZ0iSAy7ddR7Z2xlLC0tRXx8PIxGI9X+7Z4Fy2Qy6qAnIYu328EckEtvInPwKwLpfVBRUYFRo0ahuLgYDzzwgGD6A4lEgvz8fFRWVmLkyJE4duwYRowYgSVLluDSpUsCXIGdPaiursaIESPw9ddfY8yYMYJ6H+Tm5uLGjRtIS0vD8ePHkZWVhY0bNwq2PJKTk0Mt75w8eRKPPPKIoOxBZmYmzGYzEhISUF5eDr1ej+3btws2gAwdOhQAEBkZiYsXL2LEiBGCeh4kJycDAIKDg1FXV4dBgwbh888/F8xciywOgoKCYDKZ0KdPH0F1B+TAHRAQAADo0aMHKioqBLflJmeNISEhgnodGI1GmM1mSpAYFBSElpYWwZaOSI8DMvEIbYLU1taG8+fPU8wEuU//djr9kdbWSqX9dFQhi7empiaX4kBo5iA2NpZWhNxrEIsDFgwdOhSTJk3CsWPHoNPpcPHiRYSFhQmmP9DpdBg/fjyKi4sxYMAAXLp0CcHBwZgzZ44gAwzJHpw4cQL9+vXD1atXERAQIJj3QWJiIkaMGIEff/wR8fHx1NHUa9euFaT9uLg4PPDAA/j5558RHR0Nk8kkKHsQFRWFAQMGULtTALsw64MPPhCkfVJ30NTURA2ARqNRMPFpaGgoevTogY6ODigUCgQFBcFoNOLLL78UpH3S64A88VGtVguqOyD3n5PnK5C+B+fOnROkfRKO69pCeh2QRaSjINFmswm2M4icRTsuWwiJiooKEARBtatQKKBWq6lzIm4XgoKCYLVaoVAoBGcOnJcVRObAM4jFAQeWLFkChUKB0NBQtLa2IjExEefOnRNMf7Bo0SI0NTUhJSUFFy9eRHp6Or755hvBxHHPPfccLl68iOHDh+PUqVN45JFHBPU+yMvLQ2lpKcaNG4cvvvgCEyZMwNatWwVTnU+cOBHHjh3D448/jr1792LChAmCsgd6vR5ffPEFxo8fj3379uGxxx7D5s2bBZtdpqWl4ZtvvsHDDz+M48ePIz09XVDPg9TUVPz888+4//77ce7cOSQmJgq6tBATE4ObN28iJiaGGgSF0h2QKm/SwZAcwIVeWiCLA5KhEGp2Ss5CHbcyAsIlILKfnTWjLy0thVwuB0EQUKvV6OjouCMz4KCgILS2tiI6OrpTmQOFQiHYsyE9DiIjI+/YfbsdEIsDDpDeBwcPHsSkSZNw8OBBTJgwQTD9QUxMDGbMmIH//Oc/+NOf/oSPP/4YEyZMwKpVq3DmzBmf2yfZg3379uHhhx/GgQMHMHz4cMG8D4YPH47evXvj7NmziI+PR1VVFe677z7k5+cLIq589NFH4efnR/nj+/v7C8oe6PV6tLa2IiEhAXV1dUhNTUVNTY1gngFpaWk4d+4chg4dilOnTiEjI0NQz4OUlBSUlZUhLS0NX3/9NTIzM3HgwAHBihtS4Z+SkoLy8nIMHTpUcN1BS0sLoqOjUVdXh7i4OMGLA7LoIBkKoRIQE3Pg+LmvID0OyJMLhbbnLSsrQ58+fXD16lXExMTcMXo8KCgIzc3Ngu8mcWQOAGF3k5AeB3dCxHk7IRYHbvDHP/4R6enp2L9/Px5++GF89tln0Ov1gukP/va3v1EGKuHh4aipqUFcXByeffZZQdZfn3vuOVy4cAFDhgzB9evXkZycjPr6ekG8D6RSKZ5++mns378fU6ZMwaFDhzB58mQcPXoUhw8f9rl90vNg9+7dmDBhAnbs2IEpU6YIxh4kJSUhLi4Op0+fRmpqKk6cOIGhQ4cKxtyQugM/Pz8oFApYrVZBPQ9SUlKoZ1pXV4fk5GQ0NDQIZkpFDtipqakoKyvDsGHDBNcdOCYGstgRGqSRkJBeB2zMgVAJiPQ4aGtrg1qtpoocoVBWVobU1FTa2vmdoMdJIaeQxQEpFnVM2kLuJiH7Sd4vcVnhVwrS++D69evo2bMnAFCHAwmhP1Cr1Zg/fz52796N3NxcHDt2DL///e9RUVGB9evX+9x/kj3Ytm0bJk+ejH//+9/461//Kpj3QXZ2NtRqNa5cuYL4+HgUFxcjLS0NL7/8siDFzYQJE3D+/Hn89re/xc2bNxEdHS0YeyCRSKDX67F//37k5OSgqKgIEydOxIkTJ/Djjz/63D6pO/jhhx+QlpaGQ4cO4bHHHhPM84C0UVYqlVAoFKirq0NkZKRgSwvkgE0WH0lJSYLqDrRaLZqamhATE0MVB6WlpYI62ZHH6Qo9O+1s5oB02OyMNW2LxYLy8nKkpKTccWEdmbSFfDYGgwEWi4V234TcTUL2k1yqEpmDXzFI74N///vfmDVrFg4ePIjs7GzB9AeTJk1C3759sXfvXjz66KP417/+hb/+9a8oKChASUmJz+2T7EHv3r0hlUpx48YNJCUlCeJ9EBAQgMmTJ2Pbtm145plnqCWYyspKvP/++z73nfQ8OHbsGEaPHo2tW7di6tSpgrEHer0etbW1SEhIgEQioQYqobY1kpS/Xq9HcXExHnnkEcE8D3r27ImgoCBUVlbi/vvvxzfffAO9Xo99+/YJkmBJr4OoqCgAQEdHh6C6AybmoLGxUdDTRAE6dS2U6I10jySXK0hNgJAJqLPo/vPnz8NkMlEeB3dSWEfS/bGxsYJ5HZAFmuN9I98BIUB6HJDLdyJz8CvH//zP/yAuLg6ffvopsrOz8f/+3//Dc889J4j+QC6XY9myZThx4gQeeughmEwm1NXVYcCAAZg1a5bP29NI9uCtt97CrFmzsHXrVsycOVMw74OpU6eira0NRqMR8fHx2LNnDyZMmIB169b5/AdJeh7s3r0bU6ZMQXl5OXQ6nWDsgU6nQ1hYGIqLizF69Gjs2LEDubm52L17tyDKdlJ3oNPpYLVaqbV1ITwPpFIpkpOTUVpaStMdVFdXCyIKJbczWq1WaDQanD59WlDdgWNxUFdXh/j4eADCixLJWSPJUAgBMmmTgkeFQgE/Pz9BE1BnJW3y/vbo0QNGo7HLMAeAMF4HZIHmvKwgZOFG3jPnOPcSxOKAJ0jvg++++w79+/eHWq3G0aNH8fvf/14Q/cHw4cMxatQo/OMf/8ALL7yArVu3Ijc3F5cvX8Yrr7zic/9J9iA4OBg9e/bEf/7zH0yZMkUQ74OoqCg88sgjePvttzFnzhwUFRXh0UcfhcFgQEFBgc99Jz0PmpubkZSUhO3bt2PatGmCsAcymQxjxozBvn37MHHiRJSWluL++++HUqkUpHAidQdVVVUYNGgQ9u/fj4kTJwrmeeAoSqyrq0O3bt2g0Wiwd+9en9t2HLAd4wilOyCXFcg4FosFISEhgjslOiYgobwOmJIpeT2+gvQ46KykXVpaiujoaCq53UnmwLFwA4QRjJLX5SxI7IzCTSaTUcsL9xrE4sADkN4Hr7/+OpYtW4Zjx44hNTVVMP3B0qVLUVNTg46ODgwePBgFBQVYtGgRNm/ejKNHj/rUNske/N///R9efPFFHDlyBL/73e8E8z7Iy8vDhQsXEBQUhPj4eGzZsgUzZ87Epk2bcPHiRZ/aJj0PPvzwQ+Tl5eHAgQMYO3asYOyBXq9HZWUlYmNjERYWhs8++wyTJk3Cli1bfLaEJnUH5NLCkSNH8OijjwrmeZCamorKykokJydDoVDg22+/xcMPPyyI7oD0OiCLA5KhEEp34MgcAPQiREg4UtdCeR0wJVPyenwFOXsmE5DQxUFZWRmlNyDj3MndCmazGVqtVjCvAzbmQOjiwJk9utcgFgceYsmSJZDL5di7dy9yc3Oxbt06LF68WBD9QWJiIiZPnkwVBZWVlWhra0N6ejrmzJnj88tNsgft7e144IEHqCJHCO8DnU6HwYMHY/PmzXjuuedQVFSE3/3udwgNDcWrr77qU9uA3fPg6NGjGDp0KIKDg/Gf//xHMPbgwQcfREBAAA4dOoQ//vGP+OijjzBlyhQ0NDRg165dPvfdUXfQ3t6OqqoqwTwPUlJSYLPZcOnSJdx///0oLi6GXq9HWVmZILMwR7HghQsXEBsbK5jugJxpR0REQC6X03ZGCAln6lqo2alzMtVoNIIwB85JW8gZPUEQKC0tpbbtqtVqBAQEoK2t7Y4xBwCoLa2dyRwI8WxIj4N73QAJEIsDj0F6H3z88cdIT09HTEwMCgoKkJ+fL4j+YN68eSAIAv/9738xY8YMbNiwAfPmzUNbWxsWL17sU9ske7BhwwYsXrwYZ86cQUtLC0aNGiWI90FeXh6++uorJCYmIj4+Hm+88QZefPFF7Nmzx+ftdaTnwaeffoopU6Zg27ZtePLJJwVhD/z8/DBy5EhqaaGurg7nz59HRkYGNm3a5LO4j9QdaDQaxMfHU3GE8DxISkqCTCaj+R2MGDECCoVCEL8Gx+2MBEHg7NmzgukONBoNTCYTLBYLoqOjKebg4sWLgrrZdQZ1zZQYtFqtIP0mPQ4iIiIEn9HX1tairq6OYg5iYmKo5a07xRwAEHTHAnnKJykWBX4pEH39WyY9Du6kN8TtglgceAHS+2DZsmVYs2YNSktLUVdXh/Hjx/usP+jWrRtmz56NLVu24Pe//z3Cw8Px97//HStWrMDOnTt9pqJJ9qCyshLZ2dlYu3YtFi1aJIj3wdixYxEZGYl//etfFHvQp08f9O/fH/n5+T5t3yM9D7Zv346nnnoKRqMRBw4cEIw90Ov1KCkpQWhoKFJTU7F9+3bk5eWhoqICx44d86ltUndA7iY4cOAAxowZI4jngUqlQp8+fWi6g6tXr+Khhx4SZGmBHLATExOhUCiopQUhdAdkcnXesQBAMJdN4Belur+/v2BeB2zMgVDFQVRUFORyueCzU5KVcdzGyETD3y44bgEVqjhgYltIm+b29naf2nZkdTpjyacrQSwOvADpfXDt2jV8/vnnmD17NjZs2IA///nPgugPcnNzERUVhXXr1mHVqlX48ssvIZPJMHbsWMyfP9+nw41I9mD9+vV4/vnn0dbWho8//hjPP/+8z94HCoUC06ZNw0cffYT09HTEx8dj/fr1WLZsGb7//nufWRXS86CmpgaPPfYY3n77beTl5QnCHowePRoymYwSDBYVFSEpKQn9+vXz2RTJUXeQlZWFuro6lJeXC+Z5QOoBdDodFAoFtYRx/PhxNDQ0+NQ2OWDL5XJaESKE7oAcWJubm6nli4SEBCiVSkGXFhxnjULOTpmYAyGoa9LjoKOjA0ajUdAEVFZWBrVaTd0HR9X9ndrKCEBQIySmws2RofAFZP9I5kBcVhDhAtL74I033kBmZib69euHhQsX4v/+7/981h+oVCq89NJLKCoqglKpxLhx45Cfn49FixZBJpPhhRde8IkeI9mD48eP45lnnkFhYSH0er0g3gdPPvkkpFIpPvjgA4o9CAwMhF6vxyuvvOKTwI/0PCBn9ZcuXcLJkycFYQ+0Wi2GDRuGffv24Q9/+AMkEgk++eQTTJ8+HUVFRT7vRiEp/0GDBiE8PJxaWhDC8yAlJQWnT5+GSqWidAcZGRkgCAJFRUU+tU16HZD20mVlZejXr58gugNyAHdMDAqFAn379hV0x4JarYbFYoHBYBDM66CzmQMy+QDCJm1SjEjGudNb8pyZAyG8DpgKNzKOr8Ub6XFAslEicyCCEaT3wUsvvYQNGzbg4sWL+OSTT7By5Uqf9Qfjxo2DTqdDfn4+li1bBpPJhDfeeAPr1q1DUVGRT2I2R/Zg+vTpCA4Oxtq1a7FmzRqfvQ9CQkKQk5ODd955B2PHjkV8fDz+93//F0uWLEFtbS0KCwu9btvR8yAxMRFDhgzBpk2b8Ne//lUQ9iArKwvHjh2DXC7H6NGjsX37dowfPx5hYWE+myKRuoObN28iMzMT+/btg06nE8TzIDU1Fe3t7bh48SJVhISHh0On0/m8tOAo4iOLEJvNJojuwHlZoa6uDu3t7YLvWHBMQEJ4HTDZ8wLCMQedmbRLS0uRkpKCuro6yuOA7POdmAX7+flRyydCeR0wPRuhDsYinw3AXITcSxCLAx/g6H3w3XffYdGiRSgsLERcXJzP+gOJRIL8/HycPn0aX3zxBV588UW8//77CA4OxqRJk7BkyRJcunTJ676T7MH+/fuxcOFCqpARwvsgNzcXtbW1+O9//0uxB83NzZg6dSo2btzo07II6Xmwb98+5OXlobi4GFeuXBGEPcjMzITZbMaRI0coz4PKyko89dRT2L59u08DC6k7OH78OPR6PS5cuICzZ88K4nmQnJwMAJQeoK6uDj///DP0ej0+//xzn0y0nIsDk8mEqqoqQXQHjssKjokhNTUVFRUVgthvA67Uta9eB0ajkdp+5wiNRoOWlhaflokcPQ6ETtptbW04f/48daYCAFoRIvTJj3xAns4p5G4SJi2AkMwB2U+RORDBCdL7YOXKlXjssccwbNgwzJ07F0uWLPFZf6DT6TB+/HisXr0af/jDHzB48GDMnz8fixcvRkhICObMmeP1QOTIHvzhD39AcnIy8vPzsXDhQp+9DxITEzFixAgUFhbiscceo9iDuXPnQi6XY+3atV63TXoebN++HXq9HtHR0XjrrbcEYQ+ioqIwYMAA7N27FyNHjkRYWBg+/PBDTJkyBWazGR988IHXbTvqDtLT0xEYGIh9+/YhOzvbZ8+D0NBQ9OjRA2VlZTTdQVZWFoxGI7788kuv23b2OgAgmO4gMDAQUqmUNmskixCz2Yxz58553bYjSJMaMgH56nVAJlOy6CCh0Whgs9l82vXj6HEgNHNQUVEBgiBcPA6ampoQFBQEmUwmSBxPQW4B7d69uyBeB52tORCZAxG8QXofLF++HOvXr0dTUxPWrFmDTZs2+aw/WLRoERobG/Hmm29izZo1qKysxHvvvYcNGzbgm2++8UksR7IHn3zyCfLz83Hy5El88cUXWL58uc/eB3l5efjpp59QUlJCsQcXL17EvHnzsHXrVp/U6KTnQW1tLaZNm4Zdu3bBYrEIwh7o9XocPnwYBEFQngchISEYP348Nm/e7NOMk6T8lUolZVQUHR0tiOcBqQcICAigdAe9evVCYmKiz0sLJBWv1WoRExMjmO7Acdbo6HXQr18/AMLZKDszB4Bvs1O2Gb3jMom3cE7agHDFQWlpKeRyORITEymPA/L+38kZMLkFVCqVCuJ1wMQcKJVKKJVKn56No8eByWRCR0eHyByI4Iaj90FlZSVWrFiB7du3o7q62mf9QUxMDGbMmIE33ngDwcHBmDFjBv7+97+jR48emD59OlatWoUzZ8541bYjezB06FBkZGRg5cqVGDNmjM/eB8OHD0fv3r2xadMm/P73v6fYg6eeegr33Xcf8vPzvRZVkp4HO3fuxBNPPAGFQkGdNukre6DX69Ha2opjx45RngdHjhzB008/jZqaGp+8A0jdQW1tLfR6PU6dOoUrV64I4nnguE5PFiEEQVBbJ30pahxV5OTOCKlUKpjugLShJb0O1Go14uLiBCsOnDUHgG/FAduM3nGZxFs4exxIpVKq/76irKwMffr0gVKppESPEonkjs+AHYWcQuxYYNtF4KsmxNHj4E5u/7xdEIsDgUB6HyxcuBDjxo3DmDFj8PzzzyMzM9Nn/cHf/vY3qNVqrFq1Cs899xzCw8OxcOFCLFiwAHFxcXj22We9Xp8l2YP//Oc/WLp0Ka5du4a3334br776qk/eB1KpFE8//TT27t2LK1euUOxBeXk5li5diqNHj+Lw4cNete3oeaDRaDBx4kS8++67CAwM9Jk9SEpKQlxcHPbt24d+/fpRngf9+/fH0KFDfWJqHHUHo0aNooyKsrKyfPY8SElJwfXr13Hjxg0X3UFDQ4NPJlSOAzbJUBAEIZjugCkxCClKVKlUUCgUaGpqEsTrwB1z4EsCcvQ4aG5uhlqthlQqzDBdVlaG1NRUKk5XWTt3TNq+FgdsYlHA990kTDoNcVlBhFs4eh9s2LABa9euBUEQWLhwIVavXu2T/kCtVmP+/Pn46KOPcPbsWcr7YO/evSgoKEBFRQXWr1/vVb8d2YP77rsPU6ZMwYYNGxAQEOCz90F2djbUajX+9a9/0diDMWPGIC0tDS+//LLXRQ3peXDy5Enk5ubi5s2b+Pjjj31mDyQSCfR6Pfbv3w+bzUZ5HtTV1SEvLw8nTpzAjz/+6FXbjroDjUaDtLQ07N27F/7+/j57HpB6APLUSlJ3MGDAAERGRvq0tEAO2OR6dV1dHWprawXRHTgmBsedBCRDIcTR047LF47X4y06kzkgPQ4AYde0LRYLysvLXbYxAne+OBDy2RgMBlgslk5hDhw9DkTmQIRHcPQ+qKurw9q1a7F3717s27fPZ/3BpEmT0LdvX+Tn52PUqFEYN24cli1bhp49e2Lu3LkoKChASUmJV207sgfz5s2DVCrFunXrkJeX55P3QUBAACZPnowPPvgABoOBYg9OnTqFZcuWobKyEu+//75XfXb0PIiPj8fo0aOxadMmhISE+Mwe6PV61NbW4vvvv6c8Dz7++GOMGTMGsbGxPm1rJCl/Mk5xcTGampp89jzo2bMngoKCXHQHUqkUer0e+/bt8zrROnodkMmltLRUEN0BF3PQ2Njo84mhbHF8Eb01NTVBLpfD39/fJQb5c29B0v2AsEn7/PnzMJlMSElJAUEQXUpY58wc+OJ1wCXiFII5cPQ4AETmQIQHIL0P5s+fj8zMTOTk5GDx4sXQarU+6Q/kcjmWLVuGEydO4LPPPsPy5cthMpnwyiuv4Nlnn8WAAQMwa9Ysr7atObIHarUac+fOxXvvvYeqqiqfvQ+mTp2KtrY27Nixg8Ye9O/fHxMmTMC6deu8+oN19DwwGAzIy8tDeXk5iouLfWYPdDodwsLCsG/fPoSGhlKeBzKZDLm5udi9e7fXandH3UFmZiasVisOHjyI3/zmNz55HkilUiQnJ1Msj7PuoLq62msRqKOILyYmBhqNBmVlZYLoDpyTNul1QNLfQi0tsDEU3oDtND6lUgk/Pz+fE1BnJG1H22RHjwOg6zEHgPdeB1zbP309GMuZbSHbvFchFgcCw9H74IMPPsCKFSuohPunP/3JJ/3B8OHDMWrUKKxcuRIhISGU90FJSQkKCgpw+fJlvPLKK17125E9mDp1Knr27Inly5dDp9P55H0QFRWFRx55BJs2bYJEIqHYgx9//BELFiyAwWBAQUGBV3129DxIT09HUlISNm3ahNDQUJ/YA5lMhjFjxlBUPOl5UF5ejkmTJkGpVHpdLDnqDiIjIzFo0CDs27cPEonEZ88DZ1EiqTsYNmwYNBoN9u7d61W7jsWBRCJxieOL7sB51gjYE0NkZCRCQkIEc0p0TkC+eB1wJVNfqGtHjwN3cTxFaWkpoqOjERwcTFs7B+48c0AmbdLeGvBeMMqVtH09GMu5cJPJZNQ22XsRYnHQCXD0PjAajVi/fj2++uorvPPOO1izZo1P+oOlS5eipqYGmzdvxp///GfK+6Bnz55YsmQJNm/ejKNHj3rcriN7IJVKsXjxYhw5cgRHjhzBiy++6JP3QV5eHi5cuIBDhw7R2IPIyEjMnDkTmzZtwsWLFz1u19HzQCKRIC8vDwcOHMCFCxd8Zg/0ej0qKytx7tw5mueBRqPBpEmTsGXLFq+soB11B2ScI0eOwGg0+ux5kJqaisrKShgMBpruQKFQUFsnvYGj1wHwix4AgM+6A6ZZI1MR4iucixBfvA64kqkv1LWjxwEZR6jiwNk22THOnWYOtFotzGYzTCaTz14HXFoAIZYVnO+ZM3t0L0EsDjoJpPdBfn4+0tPTkZubi5UrV+LatWs+6Q8SExMxefJkmp9CZWUl3njjDfzlL39Beno65syZ49UfgSN7kJWVhQceeADLly9HQECAT94HOp0OgwcPxqZNmyCTyWjswTPPPIPQ0FC8+uqrHrcL/OJ5cOXKFTz++OMIDg7G5s2bfWYPHnzwQQQEBGDfvn1QKBSU54HZbEZubi4aGhqwa9cur/rsrDtob2/H0aNHffY8SElJgc1mQ0VFBU13QMYpKyvzekbmLBa8cOECWltbfdYdOCZtR68D4JedEUKArQjxBlzJ1BfqmilpCzGjJwgCpaWl1FKNo8eBxWJBW1vbHWcOAHti99XrgEsL4Aur4+hxQPb1XtYbAGJx0Glw9D74/PPPsWjRIsTExODZZ59Fnz59fNIfzJs3DwRB4PXXX0dycjLlfXDp0iWsX78ebW1tWLx4scftOrIHVqsV+fn5OHPmDLZu3Ypx48b55H2Ql5eHr776CqdPn6axBwEBAXjxxRexZ88er7bbOXoe+Pn5YcqUKdi2bRtaWlp8Yg/8/PwwcuRI2tIC6XkQFxeHjIwMbNq0ySuRn6PuoHfv3oiPj6fF8dbzICkpCTKZjNHvYOTIkdTWSW/gvJ2RIAhUVFT4rDvQaDQwmUwwmUw0rwPA/j5evHhRkMOMnDUHgPfFAVdi8IW6dvQ4AISb0dfW1tLEpI4eBy0tLQDu7Nq5s3mULzsWmpqaoFAooFKpXH5GFoje/M06ehyQfb2X9QaAWBx0Khy9DwCgoKAApaWl2LhxI5588kmv9QfdunXD7NmzsWXLFpw7d47mfdCjRw+sXLkSO3fu9IqedmQPBg4ciOzsbKxZswatra0+eR+MHTsWkZGReOutt1zYg+zsbPTv3x/5+fkeb+Vz9DwgCAJ/+ctfYDQasW3bNp/ZA71ej5KSEly/fp3meQDYi52KigocO3bM43YddQfk1skDBw7AarX65HmgUqmoY5UBuu4gKCgIDz30kNdLC44DdmJiIhQKBW1pwVvdAVdiIJOZL26aJByZA1+9DtwxB74UB6THASDc7NRRjEjGcZwBA3e2OHDeAupLcUCyLUx0v1arhdVqRXt7u8ftMuk0xOJAhNdw9D5Yv349Bg0ahNmzZ2P9+vU4deqUT/qD3NxcREVFYcWKFQgICKC8Dz7++GP88Y9/xNixYzF//nyPDzlyZA8sFgsWLlyItrY2bNy4ET179vTa+0ChUGDatGn46KOPUFdXR2MPpFIpli1bhu+//94rJsXR8yAiIgKPPfYY3n77bVitVp/Yg9GjR0Mmk1GzbUfPg7S0NPTr188rUyRn3UFWVhbq6upw8uRJnz0PHPUAjroDwF7sHD9+HA0NDR636+h1oFAoXIoQb3UHzonBcfkiISEBSqVSkKUF51mjr7NTLubAW+ra0eOgo6MDRqNRkARUVlYGtVpNW05xVt3f6a2MAGiakM4q3MjveApHjwOyDXFZQYRPcPQ+qKiowOzZs9GvXz/MmjULcrnca/2BSqXCSy+9hKKiIhw9ehQPP/ww5X3Q1NSE1atXQyaT4YUXXvCYRnNkD6KiovDMM8+gsLAQ1dXVPnkfPPnkk5BKpfj3v//twh6kpaVBr9fjlVde8Vjo5+h5ANhn9ZcuXUJRUZFP7IFWq8WwYcOo2baj54FEIsH06dNRVFTk1c4TR93BoEGDEB4eTlta8NbzgDxW2Wq1uugOMjIyQBAEioqKPG7X0esAoOsBfNEdOHsDOCYGhUKBvn37CrJjQavVwmKxUFt9ffE66EzmwDH5AMIkbVKMKJFIXDwOusKWPCbmwFuvA3diUfI7nsLR44Dsq8gciPAZjt4HMpkMGzduxMWLF/Haa68hOTnZa/3BuHHjoNPpkJ+fD6vVSvM+CAsLw7p161BUVOSxwM2ZPZg5cyaCg4Px6quvQqFQeO19EBISgpycHLzzzjswm8009gCwizhra2tRWFjoUbvOngcDBw7EkCFDqFm9L+xBVlYWjh07hubmZprnAQCMHz8eYWFhXpkiOeoOpFIpMjMzKaMiXzwPUlNT0d7eTu3+cNQddO/eHTqdzqulBWcRH1mEWCwWn3QHTMsKpNcBGUco5sAxjrdeB1z2vIBvzEFnJe3S0lJqScHZ40DoY6G9gb+/P+RyOeOWVk/h7tmQ3/EUjs8GEAWJIgSCs/dBYmIiFi1ahMLCQhw7dsxr/YFEIkF+fj5Onz6NDz/8EBEREZT3wYkTJzBmzBhMmjQJS5YswaVLlzzqsyN7EBgYiIULF+KTTz7ByZMnffI+yM3NRW1tLXbv3u3CHvTq1QtTp07Fxo0bPV4OcfQ8AOzsQXFxMUpLS31iDzIzM2E2m3HkyBEAdM8DlUqFp556Ctu3b/d4wHHUHQB2yv/ChQs4c+aMT54HycnJAEDTA5C6AzLO559/7rFZFlNxYDKZUFVVRcXxRnfANGsEfkkMqampqKio8NpmmwQTde2N14HRaITZbOacnba0tHi8JOTscSBU0m5ra8P58+dpZyoAcClCyBnxnQCTvTXgnWC0M5kDx+JAZA5ECAZH74Pa2lo8/fTTGDZsGObMmYPW1lav9Qc6nQ7jx4/H6tWr0draSvM+MJvNePnllxESEoI5c+Z4NGA5swc5OTlITk6mTlP01vsgMTERI0aMQGFhIQiCcGEP5s6dC7lcjrVr13rUrqPnAWBPgtHR0dSs3lv2ICoqCgMGDKAMhBw9DwBgypQpMJvN+OCDDzxq11l3kJ6ejsDAQKq48dbzIDQ0FD169KBm2866g6ysLBiNRnz55ZcetcvkdQDAZ91BYGAgpFKpy6zRsQgxm804d+6cR+0y9R+gFyHeeB24m9FrNBrYbDaPd/Q4exwIxRxUVFRQZ2IAzMK6oKAgSgR5p+C4BdQXrwORORAOYnFwG+HofSCVSimvgqVLlyIoKMhr/cGiRYvQ2NiIf/7zn5DJZDTvA7VajQ0bNuCbb77xWDznyB7IZDLk5+fj5MmT2LNnDzQajdfeB3l5efjpp5/w7bffurAHwcHBmDdvHrZu3eqxSt3R80Aul2PatGnYtWsXamtrfWIP9Ho9Dh8+jI6ODhfPg+7du2P8+PHYvHmzx7NQR92BUqmkGRX54nngqAdw1h306tULiYmJXi0tOFLxWq0WMTExPusOnGeNzl4H/fr1A+C7jTITcwB4Pjt1N6P3NgExJW3A9+KgtLQUcrkciYmJAOgeB2Q/u8IM2HELqC9eB1y7CFQqFZRKpcfPxtnjwGQyoaOjo0vct86EWBzcRjh7H8TGxmLFihXYvn079u/f77X+ICYmBjNmzMAbb7yBK1eu0LwPLly4gGHDhmH69OlYtWoVzpw5w7tdZ/YgPT0dGRkZWLlyJUwmk9feB8OHD0fv3r2pYsWZPXjqqadw3333USwFXzh6HgDAE088AYVCgX//+98AvGcP9Ho9WltbqW2Ljp4HAPD000+jpqbGYw8BR90BGefUqVO4cuUKFccbzwPndXpH3QEZ58CBAx4XM84qcsedEb7qDshk6Ox1oFarERcX53NxwKQ5ADwvDvgwB47f4wsmjwOpVIrAwECP2nFGWVkZ+vTpA6VSScUhPQ6ArjMDdhZyertjwd0uAm80Ic4eB11h++ftgFgc3GY4eh8YDAZMmDABY8aMwfPPP4+bN296rT/429/+BrVajVWrVgEAzfuAPDo6Li4Ozz77rEfrt47sAWC3b7527RreeustSCQSr7wPpFIpnn76aezduxfV1dUu7IFCocDSpUtx9OhRHD58mHe7zp4HWq0WEydOxLvvvguTyeQ1e5CUlIS4uDhqtu3sedC/f38MHTrUY2bGWXcwatQomlGRt54HKSkpuH79Om7cuAGAWXfQ0NDgsemU84BNMhRk0eGL7oArMQghSvTz84NCoaAGdm+9DvgyB54mIGePg+bmZqjVakilvg3RZWVllN6AjNMV186dk7Y3xYE7sSjg3W4SNp1GVyiqOhNicXCb4ex9IJFIsHbtWhAEgQULFgCAV/oDtVqN+fPn46OPPsIPP/zg4n2gUqlQUFCAiooKrF+/nnd/ndmDhIQETJkyBRs2bMDNmze99j7Izs6GWq3Gv/71LwCu7MGYMWOQlpaGl19+2aNixtHzALALIG/evImPP/4YgHfsAWlUtH//fkq34eh5ANiXSk6cOIEff/yRd7vOugONRoO0tDRK3+Ct5wG5vlxeXg7AVXcwYMAAREZGery04Oh1QMapq6ujmA9vdQfOicF5JwHJUHh75DTgunzheD2eoLOYA0ePA0CYGb3FYkF5eTn1PgBdtzgQ4tkYDAZYLBbBmQNnjwORORDRaXD2PggPD8fatWuxd+9e7Ny502v9waRJk9C3b1+Kjnf0PmhsbMSAAQMwd+5cFBQUoKSkhHe7zuzBvHnzIJVKKbbAG++DgIAATJ48GR988AFaW1td2AOJRIJly5ahsrIS77//Pu++OnsexMfHY/To0ZTVsbfsgV6vR21tLZX4HD0PAHsxExsb6/G2RkfdARmnuLiYGoC88Tzo2bMngoKCWHUHUqkUer2e2jrJF85eB2TSIYtCb3UHfJiDxsZGr04FdRfHU9FbU1MT5HI5/P39WWOQ3/MEjh4HgDBJ+/z58zCZTNRzcvY4IPvZFWbATMyBp14HfESc3jIHzh4HZJ/vZYjFwR2Co/eBzWZDVlYWcnJysHjxYly+fNkr/YFcLseyZctw4sQJfPbZZwBA8z4AgGeffRYDBgzArFmzeG9nc2YPQkJCMHfuXLz33ns4c+aM194HU6dORVtbG3bs2AHAlT3o378/JkyYgHXr1vH+g3b2PADsxUt5eTmVHL1hD3Q6HcLCwqjZtrPngUwmQ25uLnbv3u2RAt5Zd5CZmQmr1YqDBw8CgFeeB1KpFMnJyTQmh0l3UF1d7ZHo01nEFxMTA41GQxUh3uoOmJK2o9cBSYsLIUrkYij4wN1pfEqlEn5+fl4lIKGTtrNtsrPHAdC1mQPAM68DPts/vTkYi4ltIdu6lyEWB3cIzt4HALBixQqo1WrMnTsXNpvNK/3B8OHDMWrUKKxcuRIdHR0u3gdyuRwFBQW4fPkyVTDwgTN7MHXqVPTs2RPLly8HAK+8D6KiovDII49g06ZNsNlsLuwBACxYsAAGgwEFBQW8++rseZCeno6kpCRKE+ANeyCTyTBmzBgaFe/oeQDYmRulUulRgeSsO4iMjMSgQYOoON56HjCJEh11B8OGDYNGo6GWMPjAuThgOlbZG90B06wR+CUxREZGIiQkxGenRKYE5KnXAZ9k6il17exxwDeOO5SWliI6OhrBwcEAXNfOga7DHJBJ29HeGvBMMMonaXtzMBZT4SaTyRAQEOBRO3cbxOLgDsLZ+0Cj0WD9+vX46quv8K9//QsSicQr/cHSpUtRU1ODzZs3A4CL90FCQgKWLFmCzZs34+jRo7zadGYPlEolFi9ejCNHjlCqfW+8D/Ly8nDhwgUcOnQIgCt7EBkZiZkzZ2LTpk2U6587OHseSCQS5OXl4cCBA5Ty3xv2QK/Xo7Kyktpz7+x5oNFoMGnSJGzZsoW3BbSz7oCMc+TIEaoNbzwPUlNTUVlZSbEnzroDhUJB2zrJB85eBwB9xwLgne6AbdbIVYR4A6YixFOvAz7J1FPq2tnjgIzja3FA2iaTYCoOugpzoNVqYTabqTHOG68DPloAb5cVmO4ZG3t0r0AsDu4wHL0PAPssNzc3FytXrsS5c+e80h8kJiZi8uTJWL9+Perr6128DwDgL3/5C9LT0zFnzhzefyzO7EFWVhYeeOABLF++HBaLxSvvA51Oh8GDB1Ozeib24JlnnkFoaCheffVVXm0CdM8DAHj88ccRHBxMFUzesAcPPvggAgICqITq7HkA2AWQDQ0N2LVrF+++MukO2tvbqcLNG8+DlJQU2Gw2VFRUAHDVHZBxysrKPJqdMYkFL1y4QLEa3ugOnJO2s9cBQPdu8BbuihA+4JNMPaWu2ZK2LzN6giBQWlpK26ng7HFgsVjQ1tbWZZgD4JcE743XAR8tgKesjrPHAdnHrnDPOhticXCH4ex9ANhNjWJiYqhth97oD+bNmweCIPD6668DgIv3AWnC1NbWhsWLF/Nq05k9IO2bz5w5g61btwKAV94HeXl5+Oqrr6j1b2f2ICAgAC+++CL27NnDe/uds+eBn58fpkyZgm3btlFn2HvKHvj5+WHkyJEuSwuOngdxcXHIyMigBJB84Kw76N27N+Lj413ieOJ5kJSUBJlMxul3MHLkSNrWST5g2s5IEARVhHijO9BoNDCZTNSs0dnrALC/excvXvT6UCOAWXMAeFYc8EkMnlLXzh4HgO8z+traWtTV1bkwB44eB+TfQVdhDgD4tGOhqakJCoUCKpWK9TvOp3O6g7PHAdnHrnDPOhticdAF4Ox94O/vj4KCApSWlmLjxo0A4LH+oFu3bpg9eza2bNlC0eDO3gdRUVFYuXIldu7cyZuydmYPBg4ciOzsbKxZswYtLS1eeR+MHTsWkZGRlNKfiT3Izs5G//79kZ+fz2tbn7PnAWBnS4xGI7Zt2wbAO/ZAr9ejpKSEoqKdPQ8Ae7FTUVFBmSa5g7PugNw6eeDAAWr3h6eeByqVinasMuCqOwgKCsJDDz3k0dKC84CdmJgIhULhsrTgie6AT2Igk5ynrpmOcGYOvPE64MsceFocOHocAL7PTp3FiGQc5xkw2d87DaYtoJ4WByTbwkX3a7VaWK1WSuzqDmw6ja5wzzobYnHQBeDsfQDYj/GdPXs21q9fT23t81R/kJubi6ioKKxYsQIAXLwPAHthMnbsWMyfP5/XYUfO7AEALFy4EG1tbVQh46n3gUKhwLRp0/DRRx9R2+Sc2QOpVIply5bh+++/582eOHseRERE4LHHHsPbb79NJV1P2YPRo0dDJpPRZtvOngdpaWno168fb1MkJt1BVlYW6urqqL5743ngrAdw1h0A9mLn+PHjaGho4NWms9eBQqFgLEI80R0wJQbn5YuEhAQolUqflhaYZo3ezE75MAeeUNfOHgcdHR0wGo0+JaCysjKo1Wpau2yq+65AkTOZR3lTHPAp3Mjv8oGzxwH5u13hnnU2xOKgi8DZ+wAAZs+ejX79+mHWrFkwGo0e6w9UKhVeeuklFBUVUevXzt4HEokEq1evhkwmwwsvvMCLbnNmD6KiovDMM8+gsLCQ+mPy1PvgySefhFQqpayOmdiDtLQ06PV6vPLKK7wEf86eB2S/Ll26hKKiIgCeswdarRbDhg2jzbadPQ8kEgmmT5+OoqIi3rtMnHUHgwYNQnh4uMvSgieeB+SxyuT9Z9IdZGRkgCAI6n64g7PXAeCqB/BUd8DkDeCcGBQKBfr27evTjgWtVguLxULbwuup10FnMQfOyYfsr7cgxYjkLJrJ46ArbcljYw488TrgKxYlv8sHzh4HZB+7wj3rbIjFQReCs/eBQqHAxo0bcfHiRbz22msA4LH+YNy4cdDpdMjPz6eShLP3QVhYGNatW4eioiJeojcm9mDmzJkIDg6mRIOeeh+EhIQgJycH77zzDiXuc2YPALuAs7a2FoWFhW7bZPI8GDhwIIYMGUKb1XvKHmRlZeHYsWPUQObseQAA48ePR1hYGG9TJGfdgVQqRWZmJs2oyFPPg9TUVLS3t9N2eTjrDrp37w6dTsd7aYFJxEcWIeS74KnugG1ZwdHrgIzjK3PgHMcTrwM+9ryA58xBZyTt0tJS2pICk8eBUMdCCwF/f3/I5XLOLa3uwPfZkN/lA+dnA4iCRBF3AEzeB4mJiVi0aBEKCwupNWxP9AekaPD06dNUUnH2PgDsDn+TJk3CkiVLcOnSJbd9dWYPAgMDsXDhQnzyyScUFe6p90Fubi5qa2uxe/duAMzsQa9evTB16lRs3LiR1zKIs+cBYGcPiouLqVmop+xBZmYmzGYzJUIEXD0PVCoVnnrqKWzfvp3XQOSsOwDslP+FCxeow7I89TxITk4GABc9gKPugIzz+eef8zLFYisOTCYTqqqqaHH46g7YZo0APTGkpqaioqLCIzttR7BR13y9DoxGI8xmM6/ZaUtLC6/lHyaPA1+TdltbG86fP+9ypgLguiMCAG1WfKfAZm8N8BeMdhZz4FwciMyBiDsCZ+8DwH7q37BhwzBnzhxK9OeJ/kCn02H8+PFYvXo1lVScvQ8A4OWXX0ZISAjmzJnjdmBjYg9ycnKQnJxMO03RE++DxMREjBgxAoWFhdTvM7EHc+fOhVwux9q1a9226ex5ANiTYXR0NG1W7wl7EBUVhQEDBtAMhJw9DwBgypQpMJvNVKHHBSbdQXp6OgIDA2mFjSeeB6GhoejRowdtts2kO8jKyoLRaMSXX37ptk02rwMAXusOAgMDIZVKGWeNzkWI2WymBLaegq0I4et1wHdGr9FoYLPZeO3WYfI48JU5qKioAEEQbj0OmpqaEBQURBNC3kk4bwH11OtAZA6EhVgcdEE4ex+Q2w6bmpqwdOlSAPBYf7Bo0SI0Njbin//8JwAweh+o1Wps2LAB33zzDS8xnTN7IJPJkJ+fj5MnT2LPnj0A4LH3QV5eHn766SdqyyITexAcHIx58+Zh69atvNTrzp4Hcrkc06ZNw65du6gCzFP2QK/X4/Dhw+jo6ADA7HnQvXt3jB8/Hps3b+Y1M3XWHSiVShejIk89D5z1AEy6g169eiExMZH30oIzFa/VahETE+O17oBp1sjkddCvXz8A3tsoszEHAL/ZKd8ZvScJiC1pA94XB6WlpZDL5UhMTKQ+c/Y4IPvXlWbAzltAPfU64LOLQKVSQalU8no2TB4HJpMJHR0dXeq+dRbE4qALgsn7IDY2FitWrMD27dsppbwn+oOYmBjMmDEDb7zxBpUknb0PALut7vTp07Fq1SqKzmYDE3uQnp6OjIwMrFy5kmI0PPE+GD58OHr37k0rTpjYg6eeegr33XcfjaVgg7PnAQA88cQTUCgUlAAS8Iw90Ov1aG1tpW1XdPY8AOysT01NDS8vAWfdARnn1KlT1DMj4/D1PGBap3fWHZBxDhw4wKuIYVKRO++M8EZ34Ji0mbwO1Go14uLivC4O2DQHAL/iwBPmwDkOG9g8DqRSKQIDA93+PhPKysrQp08fKJVKWhxHjwOg682AmYScnuxY4LuLgK8mhMnjoCtt/+xsiMVBF4Wz9wFg35o3ZswYPP/887h58yYAz/QHf/vb36BWq7Fq1SrqM2fvA8C+NTEuLo4yYeKCM3sA2O2br127RtH2nngfSKVSPP3009i7dy81KDCxBwqFAkuXLsXRo0dx+PBhzjaZPA+0Wi0mTpyId999lypiPGEPkpKSEBcXR5ttM3ke9O/fH0OHDuXFxDDpDkaNGuViVOSJ50FKSgquX7+OGzduUJ+x6Q4aGhp4mUwxDdgkQ+FYcHiqO+CTGHwRJfr5+UGhUNASgydeB54yB3wSEJPHQXNzM9RqNaRS74bnsrIymt6AjNPV186Zkjbf4oCvWBTgv5uES6fRlYqqzoJYHHRRMHkfSCQSrF27FgRBYMGCBSAIwiP9gVqtxvz58/HRRx/hhx9+AMDsfaBSqVBQUICKigoqNhuY2IOEhARMmTIFGzZsoIoYT7wPsrOzoVar8a9//Yv6jIk9GDNmDNLS0vDyyy+7LWKcPQ8AuwDy5s2b1HUD/NkD0qho//79NH2Gs+cBYF8qOXHiBFXYsIFJd6DRaJCWlkbTN3jieUCuO5NCSYBZdzBgwABERkbyWlpw9jog49TV1dFYD090B0yJgWknAclQeHLUNAmm5QvH63GHzmAOnD0OAN9m9BaLBeXl5TS9AXB3FAe+PBuDwQCLxSIoc8DkcSAyByK6BJi8D8LDw7F27Vrs3buXmjl6oj+YNGkS+vbtS6Pjnb0PAHuymDt3LgoKClBSUsLZJhN7MG/ePEilUhpTwNf7ICAgAJMnT8YHH3xACSiZ2AOJRIJly5ahsrIS77//PmcfmTwP4uPjMXr0aJrVsSfsgV6vR21tLS35OXseAPYiJjY2lte2RmfdARmnuLiYNqDx9Tzo2bMngoKC3OoOpFIp9Ho9beskG5i8Dshk5Fj4eaI78IQ5aGxs5H3yJ984fERvTU1NkMvl8Pf3dxuD/L47OHscAL4l7fPnz8NkMtGKAyaPA7J/XWkGzMYc8PE68ETE6QlzwORxQPb1XodYHHRxOHsfAHZaOScnB4sXL8bly5cB8NcfyOVyLFu2DCdOnMBnn31Gfe7sfQAAzz77LAYMGIBZs2ZxbnNjYg9CQkIwd+5cvPfee5R2wRPvg6lTp6KtrQ07duygPmNiD/r3748JEyZg3bp1nH/wTJ4HgL1gKS8vpyVKvuyBTqdDWFgYbbbN5Hkgk8mQm5uL3bt3u1XFM+kOMjMzYbVacfDgQeozvp4HUqkUycnJLmwNm+6gurrarciTScQXExMDjUZDK0I80R2wJW1nrwOSLvdFlMiHoWAC39P4lEol/Pz8eCcgIZM2k20yk8cBcPcwB4B7rwNPtn/yPRiLjW0h27jXIRYHXRxM3gcAsGLFCqjVasydO5cqGvjqD4YPH45Ro0Zh5cqVlNqeyftALpejoKAAly9fphUNTGBiD6ZOnYqePXti+fLl1Gd8vQ+ioqLwyCOPYNOmTdT1MbEHALBgwQIYDAYUFBRw9pHJ8yA9PR1JSUk0TQBf9kAmk2HMmDEuVLyz5wFgZ2yUSqXboohJdxAZGYlBgwbR4njiecAmSnTWHQwbNgwajYa2hMEEpuKA7VhlvroDtlkjQE8MkZGRCAkJ8dopkS0B8fE68CSZ8qGumTwOPI3jjNLSUkRHRyM4OJj6jGntHOh6zAGZtJ3trQH3glFPkjbfg7HYCjeZTIaAgAC3v3+3QywO7gIweR9oNBqsX78eX331FbU274n+YOnSpaipqaGOMAaYvQ8SEhKwZMkSbN68mbJgZgITe6BUKrF48WIcOXKEpuDn632Ql5eHCxcu4NChQ9RnTOxBZGQkZs6ciU2bNtHcAJ3B5HkgkUiQl5eHAwcO0NT/fNkDvV6PyspK2t57Js8DjUaDSZMmYcuWLZzWz0y6AzLOkSNHaL/L1/MgNTUVlZWVNMaESXegUChctk4ygcnrAHDdsQDw1x1wzRr5FCF8wVaE8PE68CSZ8qGumTwOyDjeFgekbbIj2IqDrsYcaLVamM1m2rjF1+vAEy2AJ8sKbPfMHXt0L0AsDu4SOHsfAPZZb25uLlauXEklJ776g8TEREyePBnr16+nZsdM3geA/TTD9PR0zJkzh/OPiok9yMrKwgMPPIDly5dTRQNf7wOdTofBgwfTZvVs7MEzzzyD0NBQyr6ZDc6eBwDw+OOPIzg4mFYo8WUPHnzwQQQEBNASKpPnAWAXQDY0NGDXrl2cfWTTHbS3t9MKNL6eBykpKbDZbJRuBWDWHZBxysrK3M7U2MSCFy5coDEZfHUHTEmbyesAcPVu8AR8ixAmeJJM+VDXXEnbmxk9QRAoLS112anA5HFgsVjQ1tbW5ZgDgK7V4Ot14IkWgA+rw+RxQPatK92zzoRYHNwlYPI+AOzmRjExMbRth3z1B/PmzQNBEHj99depz5i8D0gTpra2NixevJi1PSb2gLRvPnPmDLZu3Up9l6/3QV5eHr766ivaOjgTexAQEIAXX3wRe/bs4dyOx+R54OfnhylTpmDbtm3UGfcAP/bAz88PI0eOZFxacPY8iIuLQ0ZGBk0AyQQm3UHv3r0RHx/PGMed50FSUhJkMhkvv4ORI0e6bJ1kAtt2RoIgaEUIX92BRqOByWSizRqZvA4A+3t28eJFjw43IsGmOQDcFweeJAY+1DWTxwHg/Yy+trYWdXV1jMyBs8cB+Z53NeYAcN3lwWfHQlNTExQKBVQqlds4TKdzOoPJ44DsW1e6Z50JsTi4i8DkfeDv74+CggKUlpZSRyYD/PQH3bp1w+zZs7FlyxYaLc7kfRAVFYWVK1di586dnDQ2E3swcOBAZGdnY82aNdSgxNf7YOzYsYiMjKQp/dnYg+zsbPTv3x/5+fmsW/yYPA8AOztiNBqxbds26jO+7IFer0dJSQmNlmbyPADsxU5FRQXNPMkZTLoDcuvkgQMHaDs9+HgeqFQql2OVAWbdQVBQEB566CG3SwtMA3ZiYiIUCgXj0oI73YEniYFMfnzcMZ3BxBzw9TrwlDngUxw4exwA3s9OmcSIZBymGTDZz64Cti2gfIoDkm3hQ/drtVpYrVaa0NUZXDqNrnTPOhNicXAXgcn7ALAf7zt79mysX7+ets2Pj/4gNzcXUVFRWLFiBfUZk/cBYC9Oxo4di/nz57MeesTEHgB2Y6W2tjZaAcPH+0ChUGDatGn46KOPaFvnmNgDqVSKZcuW4fvvv+dkTJg8DyIiIvDYY4/h7bffpiVfPuzB6NGjIZPJXGbbTJ4HaWlp6NevH6cpEpvuICsrC3V1dbR+8/U8YNIDMOkOAHuxc/z4cTQ0NLC2x+R1oFAoWIsQd7oDtsTAtHyRkJAApVLp1dIC26yR7+zUE+bAHXXN5HHQ0dEBo9HoVQIqKyuDWq12aZNLdd+VKHI28yi+xYEnhRv5O2xg8jggf6cr3bPOhFgc3GVg8j4AgNmzZ6Nfv36YNWsWJVrjoz9QqVR46aWXUFRURFvPZvI+kEgkWL16NWQyGV544QVWWo6JPYiKisIzzzyDwsJC2h86H++DJ598ElKplGZ1zMYepKWlQa/X45VXXmEV/jF5HpB9uXTpEoqKiqjP+LAHWq0Ww4YNc5ltM3keSCQSTJ8+HUVFRZw7Sph0B4MGDUJ4eDjj0oI7zwPyWGXHe8ymO8jIyABBELT74AwmrwOAWQ/AR3fA5g3AlBgUCgX69u3r1Y4FrVYLi8XisjWXj9dBZzAHTMmH7KenIMWIjrNnNo+Drrglj4s5cOd14KlYlPwdNjB5HJB960r3rDMhFgd3IZi8DxQKBTZu3IiLFy/itddeo77LR38wbtw46HQ65Ofn05IHk/dBWFgY1q1bh6KiIlYhHBt7MHPmTAQHB9NEg3y8D0JCQpCTk4N33nmHJvBjYg8Au3iztrYWhYWFjO2xeR4MHDgQQ4YMcZnV82EPsrKycOzYMdrAxuR5AADjx49HWFgYpykSk+5AKpUiMzPTxaiIj+dBamoq2tvbXXZzMOkOunfvDp1Ox7m0wCbiI4sQx+fOR3fAtazg7HVAxvGWOWCK487rwBN7XoAfcyB00i4tLXVZUmDzOPD1WOjOgL+/P+RyOa8trc7w9NmQv8MGpmcDiIJEEV0cbN4HiYmJWLRoEQoLC2lr2u70B6Ro8PTp07QEw+R9ANgd/yZNmoQlS5bg0qVLjH1kYg8CAwOxcOFCfPLJJzRqnI/3QW5uLmpra7F7927qMzb2oFevXpg6dSo2btzIuvzB5HkA2NmD4uJi2qyUD3uQmZkJs9lMEyACzJ4HKpUKTz31FLZv3846QDHpDgA75X/hwgXaoVh8PA+Sk5MBgFEP4Kw7ION8/vnnrOZXXMWByWRCVVWVSxwu3QHXrBFwTQypqamoqKhwa5vtDC7qmsvrwGg0wmw2ezQ7bWlpYV3qYfM48DZpt7W14fz584xnKgDMOyIAuMyM7yS47K0BbsFoZzAHTMWByByI6PJg8j4A7KcADhs2DHPmzKGJ/9zpD3Q6HcaPH4/Vq1fTEgyT9wEAvPzyywgJCcGcOXMYB0A29iAnJwfJyckupym68z5ITEzEiBEjUFhYSPs9NvZg7ty5kMvlWLt2LWN7TJ4HgD0pRkdHu8zq3bEHUVFRGDBggIuBEJPnAQBMmTIFZrOZVtw5gk13kJ6ejsDAQJeixp3nQWhoKHr06OEy22bTHWRlZcFoNOLLL79kbI/L6wBwdTB0pzsIDAyEVCplnTUyFSFms5kmpOUDriKEy+vA0xm9RqOBzWZj3YnD5nHgLXNQUVEBgiB4exw0NTUhKCjIRQx5p8G0BZSP14HIHAgPsTi4i8HkfUBuO2xqasLSpUupz/noDxYtWoTGxkb885//pD5j8z5Qq9XYsGEDvvnmG1ZxHRN7IJPJkJ+fj5MnT2LPnj3U53y8D/Ly8vDTTz/RtiqysQfBwcGYN28etm7dyqpqZ/I8kMvlmDZtGnbt2kUruviwB3q9HocPH6ZcJwF2z4Pu3btj/Pjx2Lx5M+tslUl3oFQqGY2K+HgeMOkB2HQHvXr1QmJiIufSAhMVr9VqERMT47HugG3WyOZ10K9fPwCe2yhzMQcA++zU0xm9uwTElbQBz4uD0tJSyOVyJCYm0j5n8jgg+9UVZ8BMW0D5eB14sotApVJBqVSyPhs2jwOTyYSOjo4ued86A2JxcBeDzfsgNjYWK1aswPbt22kKenf6g5iYGMyYMQNvvPEGLWEyeR8Adrvd6dOnY9WqVTSamwQbe5Ceno6MjAysXLmSxmK48z4YPnw4evfu7VKMsLEHTz31FO677z4XloIEk+cBADzxxBNQKBQ0ASTgnj3Q6/VobW112abI5HkA2FmempoaVk8BJt0BGefUqVO0Z0TG4fI8YFunZ9IdkHEOHDjAWrywqciZdkbw1R04J202rwO1Wo24uDiPiwMuzQHAXhx4wxwwxSHB5XEglUoRGBjIKw6JsrIy9OnTB0ql0iWOs8cB0HVnwGxCTnc7FjzdRcClCWHzOOiK2z87E2JxcJeDyfsAsG/XGzNmDJ5//nnq2GTAvf7gb3/7G9RqNVatWkX7nMn7ALBvUYyLi6OZMDn/njN7ANjtm69du0aj7915H0ilUjz99NPYu3cvbaBgYw8UCgWWLl2Ko0eP4vDhwy7tsXkeaLVaTJw4Ee+++y6teHHHHiQlJSEuLs5lts3medC/f38MHTqUlXlh0x2MGjWK0ajInedBSkoKrl+/jhs3btA+59IdNDQ0sJpKsQ3YJEPhXGzw0R14khi8ESX6+flBoVC4JAZ3XgfeMgdsCYjN46C5uRlqtRpSqWdDc1lZmYvegIxzN62dsyVtruLAU7EowL2bxJ1OoysWVZ0BsTi4y8HmfSCRSLB27VoQBIEFCxZQA7U7/YFarcb8+fPx0Ucf4YcffqA+Z/M+UKlUKCgoQEVFBS0+CTb2ICEhAVOmTMGGDRtoxYs774Ps7Gyo1WrqPAkSbOzBmDFjkJaWhpdffpmxeGHyPADsAsibN2/SrhXgZg9Io6L9+/e76DCYPA8A+1LJiRMnaEUNCTbdgUajQVpamou+wZ3nAbke7SiOBNh1BwMGDEBkZCTr0gKT1wEZp66uzoXxcKc7YEsMbDsJSIbC3RHTjmBbvnC8HiYIzRwweRwA3s3oLRYLysvLXfQGwN1XHHjzbAwGAywWi2DMAZvHgcgciLjrwOZ9EB4ejrVr12Lv3r202aQ7/cGkSZPQt29fFzqeyfsAsCeRuXPnoqCgACUlJS7tsbEH8+bNg1QqdWEJuLwPAgICMHnyZHzwwQc04SQbeyCRSLBs2TJUVlbi/fffd+kbm+dBfHw8Ro8e7WJ17I490Ov1qK2tdUmATJ4HgL14iY2NZd3WyKQ7IOMUFxe7DHBcngc9e/ZEUFAQb92BVCqFXq932TpJgs3rgExSzsWdO92BN8xBY2Mj5+mensZhE701NTVBLpfD39+fdwzy95jA5HEAeJe0z58/D5PJ5FIcsHkckP3qijNgLuaAzevAGxGnO+aAzeOA7OOvAWJxcI+AyfsAsFPNOTk5WLx4MS5fvkx9zqU/kMvlWLZsGU6cOIHPPvuM9jMm7wMAePbZZzFgwADMmjXLZfsbG3sQEhKCuXPn4r333qNpFtx5H0ydOhVtbW3YsWMH7XM29qB///6YMGEC1q1bxyh2YvI8AOxFSnl5uUvS5GIPdDodwsLCXGbbbJ4HMpkMubm52L17N6NSnk13kJmZCavVioMHD9I+5/I8kEqlSE5OZmRkuHQH1dXVjKJONhFfTEwMNBqNSxHiTnfAlbSZvA5IGt0bUaInDAXg+Wl8SqUSfn5+nAlIqKTNZpvM5nEA3J3MAcDsdeDN9k+ug7G42Bbyd38NEIuDewRs3gcAsGLFCqjVasydO5dWOHDpD4YPH45Ro0Zh5cqVNPU9m/eBXC5HQUEBLl++7FI4AOzswdSpU9GzZ08sX76c9jmX90FUVBQeeeQRbNq0iXY9bOwBACxYsAAGgwEFBQUufWPzPEhPT0dSUpKLJoCLPZDJZBgzZgwjFc/keQDYmRqlUslYCLHpDiIjIzFo0CCXOO48D7hEiUy6g2HDhkGj0bgsYQDsxQHXscpcugOuWSPgmhgiIyMREhLisVMiVwJi8zrwJpmyXQ+bx4G3cUpLSxEdHY3g4GDa52xr50DXZQ7IpM1kbw0wC0a9SdpcB2NxFW4ymQwBAQG849zNEIuDewhs3gcajQbr16/HV199RVurd6c/WLp0KWpqamhHGQPs3gcJCQlYsmQJNm/eTLNiBtjZA6VSicWLF+PIkSMuan4u74O8vDxcuHABhw4don3Oxh5ERkZi5syZ2LRpk4tLIJvngUQiQV5eHg4cOOCyA4CLPdDr9aisrHTZg8/meaDRaDBp0iRs2bLFxfKZTXdAxjly5IjL73B5HqSmpqKystKFJWHTHSgUCsatk2S/mbwOAOYdCwC37sDdrNGTIoQLXEUIm9eBN8mU7XrYPA7IOJ4WB6RtsjO4ioOuyhxotVqYzWaXsYjL68AbLYC7ZQWue8aXPbrbIRYH9xiYvA8A+yw4NzcXK1eupCUtLv1BYmIiJk+ejPXr19NmyGzeB4D9dMP09HTMmTPH5Y+PjT3IysrCAw88gOXLl9MKBy7vA51Oh8GDB7vM6rnYg2eeeQahoaE0+2YSTJ4HAPD4448jODjYpUDiYg8efPBBBAQEuCRUNs8DwC6AbGhowK5du1z6xqU7aG9vdynEuDwPUlJSYLPZaNoUgF13QMYpKytjnLVxiQUvXLjgwl5w6Q7Ykjab1wHA7N3gDp4WIYB3yZSNunaXtD0pQgiCQGlpKeNOBTaPA4vFgra2ti7LHACuWg0urwNvtABs7xqbxwHZp654zzoLYnFwj4HN+wCwmxzFxMS4bDvk0h/MmzcPBEHg9ddfp33O5n1AmjC1tbVh8eLFtN9hYw9I++YzZ85g69attN/h8j7Iy8vDV1995bIezsYeBAQE4MUXX8SePXtctuexeR74+flhypQp2LZtG+U4SYKNPfDz88PIkSNZlxaYPA/i4uKQkZHhIoAE2HUHvXv3Rnx8PGscJs+DpKQkyGQyj/wORo4cybh1EuDezkgQhEsRwqU70Gg0MJlMLrNGNq8DwP5OXbx40e0hR47g0hwAzMWBN4mBjbpm8zgAPC9CamtrUVdXx8ocMHkckO9xV2UOAOZdHmzvWlNTExQKBVQqFe84bKdzsnkckH3qivessyAWB/cg2LwP/P39UVBQgNLSUtrRyQC7/qBbt26YPXs2tmzZ4kKTs3kfREVFYeXKldi5c6cLtc3GHgwcOBDZ2dlYs2YNLQlzeR+MHTsWkZGRLkp/LvYgOzsb/fv3R35+Pk2vwOZ5ANjZEKPRiG3bttE+52IP9Ho9SkpKXChqNs8DwF7sVFRUuJgosekOyK2TBw4ccNnVweZ5oFKpGI9VBth1B0FBQXjooYcYixC2ATsxMREKhYJ1aYFJd+BNYiCTIpsLJhPYmAMurwNvmQO24oDJ4wDwvAhhEyOScdhmwGT/uhq4toCyvQMk2+IJ3a/VamG1Wl1Eru50Gl3xnnUWxOLgHgSb9wFgP/Z39uzZWL9+vcuWPzb9QW5uLqKiorBixQpaW2zeB4C9QBk7dizmz59Pm/GysQeA3VCpra3NpXBh8z5QKBSYNm0aPvroI5ftdGzsgVQqxbJly/D999+7sCRsngcRERF47LHH8Pbbb7skYTb2YPTo0ZDJZIyzbTbPg7S0NPTr189lqYRLd5CVlYW6ujqXPnN5HrDpAdh0B4C92Dl+/DgaGhpon7N5HSgUCs4ihEl3wJUY2JYvEhISoFQqPVpaYJs1Ol6PM7xlDpgYCjaPg46ODhiNRo8SUFlZGdRqNWN77lT3XZEi5zKP4ioOvCncyN91BJvHAfndrnjPOgticXCPgs37AABmz56Nfv36YdasWTQxG5v+QKVS4aWXXkJRUZHL+jab94FEIsHq1ashk8nwwgsv0AZiNvYgKioKzzzzDAoLC10GATbvgyeffBJSqdTF6piLPUhLS4Ner8crr7xCu342zwMy/qVLl1BUVET7nI090Gq1GDZsGONsm83zQCKRYPr06SgqKnLZPcKmOxg0aBDCw8NZlxaYPA/IY5WZPCTYdAcZGRkgCMLl+tm8DgB2PQCb7oDLG4AtMSgUCvTt29ejHQtarRYWi4XxxEk2rwOhmQO25EP2jy9IMaLzrJnL46Arb8lzxxwweR14KxYlf9cRbB4HZJ+64j3rLIjFwT0MNu8DhUKBjRs34uLFi3jttddov8OmPxg3bhx0Oh3y8/Ndkgqb90FYWBjWrVuHoqIiWsLlYg9mzpyJ4OBgF9Egm/dBSEgIcnJy8M4777iI/NjYA8Au3KytrUVhYSH1GZfnwcCBAzFkyBBGq2M29iArKwvHjh1zGejYPA8AYPz48QgLC3NZKmHTHUilUmRmZjIaFbF5HqSmpqK9vd1l1wYZh0l30L17d+h0OpcihEvERxYhzs+YTXfgblmByeuAjOMpc8AWh4mh8MaeF2BnDoRM2qWlpYxLClweB94eC3074O/vD7lc7tGWVm+fDfm7jmB7NoAoSBRxD4HL+yAxMRGLFi1CYWGhyxo3k/6AFA2ePn3aJdmweR8AdgfASZMmYcmSJbh06RL1ORt7EBgYiIULF+KTTz5xocrZvA9yc3NRW1uL3bt3077PxR706tULU6dOxcaNG2kJl83zALCzB8XFxS6zVDb2IDMzE2az2UV8CLB7HqhUKjz11FPYvn07beBi0x0Adsr/woULLodfsXkeJCcnA3B1MATYdQdknM8//5xWOLkrDkwmE6qqqhjjOOsO3M0aAWYTnNTUVFRUVDDaYzPBHXXt7HVgNBphNpu9mp22tLTQCnMujwNPk3ZbWxvOnz/PeqYCeT3OIO8v0+z4TsOdvTXg+q4JzRywFQcicyDingKb9wFgPxVw2LBhmDNnjosIkEl/oNPpMH78eKxevdqF2mPzPgCAl19+GSEhIZgzZw41UHKxBzk5OUhOTmY8TZHJ+yAxMREjRoxAYWGhy/e52IO5c+dCLpdj7dq11GdsngeAPTlGR0czWh0zsQdRUVEYMGAAo4EQm+cBAEyZMgVms5lW0HHpDtLT0xEYGMhY0DB5HoSGhqJHjx6Ms20u3UFWVhaMRiO+/PJL6jN3XgcAs4Mhk+4gMDAQUqmUc9bIVoSYzWYXwSwb3BUhzl4H3tLwGo0GNpuNtsuGy+PA0zgVFRUgCMJjj4OmpiYEBQUxCiK7Ati2gLJ5HYjMQedALA5+BWDzPiC3HTY1NWHp0qW0n7HpDxYtWoTGxkb885//pH2fy/tArVZjw4YN+Oabb2i0PBt7IJPJkJ+fj5MnT2LPnj20n7F5H+Tl5eGnn35y2aLIxR4EBwdj3rx52Lp1K03tzuZ5IJfLMW3aNOzatcul0GJjD/R6PQ4fPkxzmQS4PQ+6d++O8ePHY/PmzbTCiU13oFQqWY2K2DwP2PQAXLqDXr16ITEx0SUOm1hQq9UiJiaGt+6Aa9bI5XXQr18/APxtlN0xBwC9CPGWhmdKQO6SNsC/OCgtLYVcLkdiYqLLz9g8Dsj+dOUZMNsWUDavA292EahUKiiVSlocLo8Dk8mEjo6OLn3fhIZYHPwKwOV9EBsbixUrVmD79u0uynom/UFMTAxmzJiBN954wyV5snkfAHYb3unTp2PVqlUU/c3FHqSnpyMjIwMrV6502fLG5H0wfPhw9O7dm1ETwMUePPXUU7jvvvtoLAWb5wEAPPHEE1AoFC4CSICZPdDr9WhtbXVZugHYPQ8AO6tTU1NDeyZsugMyzqlTp1yeCRnH2fOAa52eTXdAxjlw4ADteXGdmMe2M4JLd8CUtLm8DtRqNeLi4ngXB+40BwC9OPCFOXCO487jQCqVIjAwkFf7ZWVl6NOnD5RKpcvP2DwOgK4/A+ZyL2R617zdReD8rnF5HHTl7Z+dBbE4+JWAzfsAsG/hGzNmDJ5//nna8ckAs/7gb3/7G9RqNVatWuUSh837ALBvVYyLi6OZMLGxB4DdvvnatWsuND6T94FUKsXTTz+NvXv3ugweXOyBQqHA0qVLcfToURw+fBgAt+eBVqvFxIkT8e6777oULUzsQVJSEuLi4hhn9VyeB/3798fQoUNpxQ6X7mDUqFGsRkVMngcpKSm4fv06bty44fJ9d7qDhoYGGkPDVRyQDAVTocGmO/AkMTheD9/iwM/PDwqFgrEIYfI68JU5cIzD5XHQ3NwMtVoNqZTfsFxWVsaoNyDj3K1r51zHKTu/A96KRQHXd42PTqMrF1VCQywOfiXg8j6QSCRYu3YtCILAggULaAM5k/5ArVZj/vz5+Oijj/DDDz/Q2uLyPlCpVCgoKEBFRQXVBy72ICEhAVOmTMGGDRtcihYm74Ps7Gyo1Wra+REkuNiDMWPGIC0tDS+//DJVtLB5HgB2AeTNmzddrg9wZQ9Io6L9+/e7+A0A7J4HgH2p5MSJE1RBw6U70Gg0SEtLY9Q3MHkekOvUzoJIgFt3MGDAAERGRtKKHTavAzJOXV0dI9vBpDvgSgxcpyaSDAVTH5zBtXzheD0khGQO2DwOAM9m9BaLBeXl5Yx6A+DuLg48eTYGgwEWi0UQ5oDL40BkDkTc0+DyPggPD8fatWuxd+9eFzqdSX8wadIk9O3bl1E0yOZ9ANiTy9y5c1FQUICSkhIA3OzBvHnzIJVKXdwRAVfvg4CAAEyePBkffPCBi2CSiz2QSCRYtmwZKisr8f777wPg9jyIj4/H6NGjGa2OmdgDvV6P2tpaxsOG2DwPAHvREhsbS2NO2HQHZJzi4mLG5OrsedCzZ08EBQV5rDuQSqXQ6/W0rZNcXgdk8mJaWmDSHfjCHDQ2Nrqc4MkGd3Ecly+ampogl8vh7+/Pq23HGOTvk2DzOAA8S9rnz5+HyWRiLA64PA7I/nTlGbA75sDR68AXzwYm5oDL44Ds268FYnHwKwOb9wFgp59zcnKwePFiXL58mfYzZ/2BXC7HsmXLcOLECXz22Wcucdi8DwDg2WefxYABAzBr1iwYDAZO9iAkJARz587Fe++957JVj8n7YOrUqWhra8OOHTtc4nKxB/3798eECROwbt06au2XzfMAsBcm5eXljAnUmT3Q6XQICwtjXFrg8jyQyWTIzc3F7t27KfU8l+4gMzMTVqsVBw8edPmZs+eBVCpFcnIyq3mQO91BdXU1JeLk2kkQExMDjUbDWIQw6Q7cJW02rwOSXvdElMiXofD2ND6lUgk/Pz+XBCRE0uayTebyOADufuYA+GXXhy+eDc67ItyxLeTv/FogFge/MnB5HwDAihUroFarMXfuXJfiwVl/MHz4cIwaNQorV650UeNzeR/I5XIUFBTg8uXLVPHAxR5MnToVPXv2xPLly11+5ux9EBUVhUceeQSbNm1y6T8XewAACxYsgMFgQEFBAQBuz4P09HQkJSUxCiCd2QOZTIYxY8YwtgOwex4AdoZGqVRSxQ+X7iAyMhKDBg1ijMPkeeBOlMimOxg2bBg0Gg21hMFVHLg7VtlZd+Bu1ggwex1ERkYiJCSEt1OiuwTk6HXgSzJ1vB4ujwNP45SWliI6OhrBwcEuP+NaOwe6PnNAJm02e2vgl2v0JWk774pwV7jJZDIEBAR4HOduhVgc/ArB5X2g0Wiwfv16fPXVVy5r90z6g6VLl6KmpsblSGOA2/sgISEBS5YswebNm3H06FFO9kCpVGLx4sU4cuQIo7Lf2fsgLy8PFy5cwKFDh1y+y8UeREZGYubMmdi0aRMuXrzI6XkgkUiQl5eHAwcOuOzMAFzZA71ej8rKSsa9+FyeBxqNBpMmTcKWLVtgNBo5dQdknCNHjtBsoUk4ex6kpqaisrKSkRnh0h0oFAra1kkurwOAfccC4Ko74DNr9KYIcYa7IsTR68CXZOp4PVweB2QcvkmOtE1mgrvioKszB1qtFmaz2UXwC7h6HfiiBWBaVnB3zzxlj+5miMXBrxRs3geAfVacm5uLlStXuiQzZ/1BYmIiJk+ejPXr17ucTMjlfQDYTztMT0/HnDlz0NzczMkeZGVl4YEHHsDy5ctdigdn7wOdTofBgwczzurdsQfPPPMMQkNDKftmNs8DAHj88ccRHBzMWBg5swcPPvggAgICGGf1XJ4HgF0A2dDQgF27dgFwrztob293OQMDcPU8SElJgc1mc9GfANy6AzJOWVkZTcTFpQe4cOGCiw4EcNUdcCVtLq8DgN27gQmeFCG+JFNH6ppP0uZThBAEgdLSUtadClweBxaLBW1tbV2eOQCYfSicvQ580QI4vmtcHgdkX7ryPesMiMXBrxRc3geA3ewoJiaGtu2QhLP+YN68eSAIAq+//rpLO1zeB6QJU1tbGxYvXszJHpD2zWfOnMHWrVtd4jh7H+Tl5eGrr75iPMqXiz0ICAjAiy++iD179uDbb7/l9Dzw8/PDlClTsG3bNprDJAlH9sDPzw8jR47kXFpg8zyIi4tDRkYGJYDk0h307t0b8fHxnHFIz4OkpCTIZDKv/A5GjhxJ2zrpbjsjQRCMRYiz7kCj0cBkMjHOGrm8DgB7EXLx4kXWpO8Id5oD4Jdk7kticKSuuTwOAP5FSG1tLerq6jiZAzaPA/I97erMAcDsQwHQ37WmpiYoFAqoVCqP4ziezsnlcUD2pSvfs86AWBz8isHlfeDv74+CggKUlpa6HKEM0PUHLS0tmD17NrZs2cJIm3N5H0RFRWHlypXYuXMn/vvf/3KyBwMHDkR2djbWrFnjkoydvQ/Gjh2LyMhIRqtjd+xBdnY2+vfvj/z8fAQEBLB6HgB29sNoNGLbtm0uP3NmD/R6PUpKSmjWvCS4PA8A+1JJRUUFjh07xqk7ILdOHjhwwOWALIDueaBSqViPVQa4dQdBQUF46KGHqCKEqzhITEyEQqHgXFogdQeeJAZnkMmSqSB0Bhdz4Ox14Ctz4FgcsHkcAPyLEC4xIhmHawZM9qurgsukCqC/AyTb4g3dr9VqYbVa0d7ezkun0ZXvWWdALA5+xeDyPgDsxwHPnj0b69evZ9z+56g/mDx5MqKiorBixQqXdri8DwB7kTJ27FjMnz8f4eHhrOwBYDdSamtrYyxYHL0Pzpw5g2nTpuGjjz5i3GLHxR5IpVIsW7YM33//PT755BNOz4OIiAg89thjePvttxmTsSN7MHr0aMhkMkajIoDb8yAtLQ39+vXDpk2b3OoOsrKyUFdXx9hfZ88DLj0Al+4AsC8tHD9+HA0NDZxeBwqFwm0RQuoO3CUGruWLhIQEKJVKXksLjrNGJjjPTn1hDsiEzOVx0NHRAaPRyCsBlZWVQa1Ws7bFR3XflSlyLntrwLU48KVwI9vg8jggv9OV71lnQCwOfuXg8j4AgNmzZ6Nfv36YNWuWi8jNUX/w6quv4qWXXkJRURHjejeX94FEIsHq1ashk8nwwgsvYO7cuazsQVRUFJ555hkUFhYyJglH74NJkyZBKpUyWh27Yw/S0tKg1+vxyiuvYPDgwayeB2TMS5cuoaioyOVnjuyB1WrFsGHDWCl/Ls8DiUSC6dOno6ioCOfPn+fUHQwaNAjh4eGcSwuk5wF5rDJTYeNOd5CRkQGCIFBUVMTpdQBw6wEcdQdc680AN3OgUCjQt29fXjsWtFotLBYLoxiTjEMuXwjJHHAlH7Jf7kCKEZlmy+48Du6GLXl8mAPS68BXsShgf9e4PA7IvnTle9YZEIsDEZzeBwqFAhs3bsTFixfx2muvufyuo/7AZrNBp9MhPz+fMdlweR+EhYVh3bp1KCoqQmlpKSd7MHPmTAQHB1OiQef+kt4Hu3fvRk5ODt555x1GoR8XewDYRZu1tbV46623OD0PBg4ciCFDhjAKIAE6e5CVlYVjx44xDnxcngcAMH78eISFheGtt97i1B1IpVJkZmbSjIoc4eh5kJqaivb2dly8eJExJpfuoHv37tDpdNi3bx/nTgIAVBHC9DwddQd8lhXYvA7IOHyZA644JEPhiz0vQGcOhErapaWlrEsK7jwOfPEFuF3w9/eHXC7ntaXV12cD/MIcsN0zQBQkiviVwp33QWJiIhYtWoTCwkLGA4RI/cELL7yAvLw8nD59mnFbHpf3AWB3BJw0aRKWLFmCP/3pT6zsQWBgIBYuXIhPPvmEkTp39D4YN24camtrsXv3bpfvuWMPevXqhalTp2Ljxo0YOXIkq+cBYGcPiouLGWetjuzBb3/7W5jNZkbhIcDteaBSqfDUU09h+/btVHJg0h0Adsr/woULLsZRAN3zoGfPngCYHQwBbt0BGefzzz9Ht27dAHAXByaTCVVVVaxxvvvuO0pYxtcExxmpqamoqKhgLAYdwYe6vnLlClpbW2E2m32anba0tKCtrY3T44Bv0m5vb8f58+c5z1Qg+88E8r6yzZC7AvjYWwP2axWSOeAqDkTmQMSvFlzeB4D9lMBhw4Zhzpw5jGJAUn9QUFCAcePGYfXq1Yxb17i8DwDg5ZdfRkhICP75z39Cr9ezsgc5OTlITk5mtG8GfvE+eOeddzBixAgUFhYyfs8dezB37lzI5XJs376d1fMAsCfJ6OhoRgEk8At7sHv3bgwYMIDxDASA2/MAAKZMmQKz2YyDBw9y6g7S09MRGBjIWsyQngfFxcXo0aMH62zbne4gKysLRqMRP/zwg1uvA4DdwZDUHZw9exZSqdTtrJGrCDGbzYzCWEfwoa4tFgsqKytp3/cUGo0GNpsNZ8+epfXfGXyZgwsXLoAgCK89DpqamhAUFMQqiuwqcHYvdISj14HIHHQexOJABAUu7wNy22FTUxOWLl3q8nNH/YFcLkdjYyP++c9/unzPnfeBWq3Ghg0b8M033yA2NpaVPZDJZMjPz8fJkyexZ88el587eh/cf//9+Omnn2gnCTq2w8UeBAcHY968edi6dSvS09NZPQ/kcjmmTZuGXbt2MRZXjuzBgw8+iMOHD7u4SgLuPQ+6d++O8ePHY/PmzRg6dChr0lYqlTSjImc4eh5w6QHc6Q569eqFxMRE7Nu3j1MsqNVqERMT41Z3UFxczDlrdOd10K9fPwDubZT5MAcAqKTuiyDRsR1fdxH8/PPPkMvlSExMZPw5l8cBcPfMgJ3dCx3h6HXgyy4ClUoFpVKJxsZGTo8Dk8mEjo6Ou+K+CQmxOBBBwZ33QWxsLFasWIHt27czKu5J/cGuXbvw4IMP4o033mBMpFzeB4Ddnnf69Ol49913kZaWxsoepKenIyMjAytXrmTcF096H3z44Yfo1asXqybAHXvw1FNP4b777sPXX38NlUrF6HkAAE888QQUCgWjABL4hT2oq6tDa2sr4xINwO15ANhZnJqaGvj5+bHqDgA7m3Hq1CnGZ0DGOX78OCdzAHDrDsg4Bw4coJnTMIFrZ4Sz7oAtabvzOlCr1YiLi3NbHPDRHACglkF8VcRXVVW59TiQSqUIDAzkbK+yshJ9+vSBUqlk/DmXxwFw98yAuQpE4Bdhqq+7CLRaLS5fvszpcXA3bP/sDIjFgQgauLwPAPtRxmPGjMHzzz/vcowy8Iv+gEykq1atYozD5X0A2LcsxsXF4cqVKzh//jwjewAAS5cuxbVr1xjpfEfvg+7du2Pv3r2Mycsde6BQKLB06VIUFxdj4MCBrJ4HWq0WEydOxLvvvstYrJDswZ49exAdHc06q3fnedC/f38MHToU3333HQB23cGoUaNoRkXOID0Pbty4gevXr+PGjRuM3+OjO2hoaIBMJuMsDkiGgq3IIHUHQUFBvBIDG/iIEv38/KBQKFiLENLrgBRq+socXLhwgdPjoLm5GWq1GlIp95B87tw5Vr0BwC16JOPcDUmOq0AE6MWBL9ej0WioQ+bu5u2fnQGxOBBBgzvvA4lEgrVr14IgCCxYsMBloCf1B5GRkZDL5di5cyd++OEHl3bceR+oVCoUFBRQe8PZ2IOEhARMmTIFGzZsYCxWSO+DEydOQKlUupwXQcIdezBmzBikpaXh/PnzqKqqYhRCAnar45s3bzJeE/ALe6DVarF//36X3SEkuDwPALsA8scff0RERATr0oJGo0FaWhqrvoH0PPjuu+9AEASjCBJwrzsYMGAAIiMjcePGDVavA8CetOvq6liZDlJ3YLPZOBMD1/IFGae0tJS1H4B70RtA387oK3PA5XEA8J/RV1VVseoNgHunOODzbC5dugSLxeIzc0Ae8y0yB3SIxYEIF7jzPggPD8fatWuxd+9eRoqd1B+0trZCqVSyiga5vA8Ae9KZO3cuLl26hJ9//pmVPZg3bx6kUinWrVvH+PO8vDz07dsXcrkc77//PqNQ0h17IJFIsGzZMty4cQN+fn6ss/r4+HiMHj2asjp2BskenDlzBteuXaMOHHIGl+cBYC9WYmNjIZVKWZM2YJ/VFxcXsybbiRMn4saNG5DL5V7rDqRSKfR6PX7++WcYDAbWgoZMamxLC6TuoLW11WfmoLGxkZUJIcEnAV27dg1yuRz+/v6cbXHFAICrV6+yJh+AX9K2Wq3o6OhgLQ7ceRwAd8+yAh/moL6+HjabzWfm4MaNG249Dsg+/ZogFgciGMHlfQDYKemcnBwsXryYouUcQeoP2tra8OWXX+Kzzz5jjMPlfQAAzz77LHQ6HaRSKV5//XVG9iAkJARz587Fe++9x7h1j/Q+aGlpwY0bN7Bjxw7GWO7Yg/79+2PChAkwGAzYtWsXq4FOXl4eysvLWZPpX//6V2rLHtvSgjvPA5lMhtzcXFRXV+PMmTOss/HMzExYrVYcPHiQ8eek54FSqeQ0D+KjO6ivr4fFYmFN3DExMdBoNKxFCKk7aGhocJu0ubwOSNqd3GnABncJKCYmBjdu3PDpND6lUgk/Pz/U1tb6nLRJgaq3HgfAvcUc2Gw22Gw2n5K2RqNBfX2923tGfvfXBLE4EMEId94HALBixQqo1WrMnTuXsYB48sknMWHCBFgsFixevJhRne/O+0Aul6OgoAAKhQLl5eWs7MHUqVPRs2dPLF++nPHnOp0Of/nLX2Cz2fCPf/yDsb/u2AMAWLBgAVQqFa5fv86a2NPT05GUlMQqgCTZA5PJxLjTggSX5wEATJo0CUFBQTAYDKy6g8jISAwaNIi1r6TnQX19PU6dOsXaF3e6g2HDhiE4OBgmk4m1OOBzrHJaWhpu3LiBhoYG1u+48zqIjIxESEgIr+2M7hJQY2Mj1Go1ZzvuoFar0dzc7HPStlgs6N69O4KDgxl/7m4bI3D3MAfkVkYue2uCIGC1Wn1K2uSuCHf3TCaTISAgwOs4dyPE4kAEK9x5H2g0Gqxfvx5fffUV41o+qT/o3bs3Tp8+jTfffJMxjjvvg4SEBCxfvhxWq5XxyGbAXswsXrwYR44cYVX5v/jii4iIiEB5eTkOHTrE+B137EFkZCRmzZoFq9XKeFQzed15eXk4cOAA424MwM4eBAQEoLy8nDWJufM80Gg0ePLJJ2G1WvHll18yfgewz+qPHDniYn9NIjs7GxKJBOXl5axsiDvdgUKhQEZGBqxWK2vSBrh3LAD24sBmszEeTkXCndcBWYS4Kw74UNcWiwV+fn6c7biDSqUCQRBuE5C7JGc2m9G7d2/Wn/MpDu4W5kCr1cJsNjMKewH7ll6pVOpzcaDRaNDa2srrnnnLHt2tEIsDEZzg8j4A7LPk3NxcrFy5knEwDgoKwnvvvQeVSoX8/HzU19e7fMed9wFgP/3woYcewpkzZ/Dee+8xficrKwsPPPAAawGh0Wiwdu1a2Gw2xgOiyL64Yw+eeeYZdO/eHYcPH2bdJvj4448jODiYtYAIDQ3FjBkzYDQa8dFHHzF+x53nAWAXQEqlUnz66aeMPwfsxUF7ezvjmReA3fNgyJAhaG9vZ9SYAO51B2Qci8XCyQykpKTgwoULjLoPwK47CAwMZNUtAO69DgD70oK7ZQU+zAFBEJDJZJztuINMJnNbHLjbkkcQBCwWC2dx4M7jwGKxoK2t7a5hDgB2HwqpVIqQkP/P3rvHRVnn/f+v65q5BoZhhpMIcRJBQRgPGZZKqHnCQdNc19NdrqWIlV9TUfOUB1LM8y7hvdUt5aa1qaWrWZsHKtu0PFRaCYomAYImCHKGGeb0+2N+n6s5XNc112i7G3i9Ho/7ce8y18w1DO6835/X5/V+fgJgNpvveVvBYDB0CLflt5bUHEgSlDv2AQCsWLECEREReOGFFziLWGJiIjZu3Ij6+no8++yznK/hjn1A0zR27twJlUqF5cuXcxZ/iqKQlZWFK1euYM+ePZz3GTt2LAYMGIAzZ87wThy4cw98fHzYrMS2bds4r/H29sb06dOxd+9eF6Ik0dy5c6FUKnknKAD3zIPo6Gg8/PDDKCkp4V1td+vWDTExMbxbCwAwc+ZMGI1G3r8x4D53MHToUDAMw/u5AraibbVaeZsQmqYRHx+P1tZW3lWjO9YBYGtCfvnlF95pEEBc5kDo+WJFVpx8jAPA/YqehO9iY2N5r3HHOCD/DtuLcwDwcygA2+9htVrZ/M7diGxNhIeH817TXtyW31pScyDJrdyxD5RKJXJzc1FQUMB5lDJgs9GTk5Nx6NAh3kLnjn0QFhaGNWvWoKqqCitXruR8jT59+mDixIlsANFZFEXhrbfeAkVRmDt3LudriHEPpk2bhvDwcPa0RS4988wz0Ov12Lt3L+fjgYGBGDNmDK5du8ZbLN0xDwAb4tlkMvE2GRRFsaAivvc6btw4eHl5CWYg3OUOfH19ERMTI7hij4uLA8MwglsLDz74IIxGo+C0gZiJBQCcTSSRO+dAqVSCYRjB1xAjs9kMLy8vQWSxu9UpceXcbSu4WwED7aM5cAepAmz/3iiKuie7n+SgyNkgXLoXCmN7ltQcSHIre/bBX/7yF85r+vbti/nz5yMnJ4d3FPDgwYPw9vbGk08+ybkqdMc+AIAFCxagW7duyM3N5bX0ly1bhubmZt5GJTY2Fk888QS++eYbXqvdnXtA0zSWLVuGhoYG3mtCQkIwbtw4vPXWW7xFmZwsuWrVKs7HAZt78Omnn3JuyQDA448/DrVajb///e+8r5GWloaamhreVb1SqUR8fDzOnz/Pu1p2lzsAgEceeQS1tbW875VhGHTv3l1w6+GRRx6B1WrlDVkC7lkHsbGxbgs7aQ6EeAgymYwzSOuJ2traBBuDtrY26PV6wQJUXFwMiqIQGhrKe40YxgHQPkby3OGtAZs7x/e/K7Fqbm4GINww3SuFsb1Kag4kiRJhH7zxxhu4fPky5zXz589HQkIC5s2bxxl+CwoKwoYNG3D79m3MnDmT8zXcsQ8oisLOnTthNBrxP//zP7wOw/PPP48dO3bwFpD//d//BcMwmD17NucXjBj34Nlnn0VAQAC2bdvGG/bLyMjA9evXkZ+fz/l4dHQ0EhIScPToUd6C+oc//AEAeBsmiqIwePBgXL16FSUlJZzX9O3bF8HBwYJbC6NGjUJTUxNOnTrF+biY3MGIESNgtVp5p0oACJ7lANj4FhRFCTYh7pwDhmEQHR0t2Bz4+fnBZDLxhjAB22fLNzIpVi0tLYLkQzFF+9q1a2AYhneVLIZx0J5G8sQ4BwzDwGKx8OZXxKixsRE0TQv+O5G2FSRJciN37AOGYbB9+3aUlZVh48aNvK/Rq1cv7N+/HwcPHuS8xh374NFHH8Xw4cNx+vRp3jHLOXPmwN/fn12ZO6tz586YPHkyrl27hrfeeovzGjHuQUZGBmpqavDXv/6V85o+ffrg4Ycf5h1rBIDZs2dDr9fj1Vdf5XzcHfMAsJ3WaLFYeF+DpmmMGjUKR48e5V0pjxkzhs128Mld7qBXr15gGEZwe0Kr1eLy5cu8X8gBAQFQKBQ4f/4872u4Yx0ANgte6OhmdwXIarXCYrHwZkbEqqmpSTC7IKZokwPN+CSGcSD2WOjfg5RKJeRyuaBzQNM0KIoSzJ64E8F+CzUhUiBRkiQ3IuyD7777jtfCjouLw4oVK7Bjxw7Og4UoikJeXh7kcjmef/55zpWuO/YBAGzbtg0KhQKLFy/G9evXXR5XqVRYtmwZPvzwQ14r/aWXXoKXlxfWrFnDIlTtJdY98Pb2xrZt23hBRBkZGTh9+jTvPvsf//hHKJVK5OXl8boHU6ZMwcWLF3ldm0GDBkGpVGLfvn28X3Q6nQ6lpaWcoCjAVrSVSiWOHTvGuxpzlzuIjIyEl5cXzp49y7si12q1MBgM7KFGztJoNFAoFLh8+TJvKNEd6wCwNQdms5m3QXBnXRM3qKGh4a5zB62trWhubobJZOJtENwV7ebmZty4cQMMw/DeR+wYIwBeEuDvSWLw1mazGTRNCzpI7lRdXQ2ZTCbYhEjOgSRJIkTYB+vXr+cthrNmzcLAgQOxYMECzlVXv3798OSTT6KxsZGFATnLHftAq9ViwoQJaGxsxPz58zm/eCdNmoTExERefHNcXBzS0tLQ3NyMl156ifN3ceceREdHY/DgwWhqasKWLVs4r9HpdAgPD+c8HAqwbYP069cPzc3NvCwId8yDkJAQJCQkoKWlhddNSUlJgUqlEqQyRkVFoaWlBf/85z85r3GXO9BoNAgKCoJer+dlL5CwIN/WgkqlgpeXF9ra2njx0u5YB4Atd0Dsdr73CvA7Bw0NDZDJZG65C0KqqKgATdOgaZrd3+a6j/37cVZRURGsVqugcyAWgOTr6yv4Or8nERASn0iW416cg8rKSsk54JHUHEjyWIR9sGbNGs7HaZpGTk4O6uvrsXr1as5r1qxZAz8/P/zwww+cryOGfbB06VJ4e3vjX//6F6dtL5PJkJWVhe+++47X5p4zZw7kcjk++ugjztMLxbgHf/rTn0DTNN59913Olb1cLsfMmTNx8OBB3oZq3LhxYBgGb731Fqd7IIZ58Nhjj8HX1xc7d+7kBUUNHz5cMHfw0EMPwd/fn3cLQ0zuICYmBhqNhvc+fn5+iIiI4G0OKIpCYGAgvLy8eJsQMayDmJgYAOCFIblzDggZ715Wp+Xl5aAoSrAAuZsiKCgogEwmEyzq7hgHQPtbARN6IZ9IUPBu/zYWiwW//PILFAoF730MBgPa2tra1ef2W0lqDiR5LMI++PDDD3nHEiMjI7Fu3Trs27ePs+gSLoJMJsPbb7+NDz/80OUad+wDrVaLJ554AiqVChs2bOC0y1NSUjBy5EhkZ2dzOhRDhgyBVquFn58fVqxYwWmnu3MPHn/8cQQGBkKpVPK6FE8++SQYhsE777zD+Ro6nQ5yuRytra287sGUKVNQXV3NyyJITk5GW1sbrl+/zntMs06nw48//sg76aHVakHTNM6cOcNLd3SXO4iMjERQUBCOHz/Oa8e7IyX6+/sjPDyctwkRwzpQqVSQyWS8o5VinQOKou6pOWAYBjRNC96HpmmoVCrOxwsLC9GlSxe39xFiHADtbwXsbluhoaEBnTp1uuu/TVVVFYxGoyDvoj2Nf/7WkpoDSXclwj5Yvnw5797y5MmTkZqaisWLF3Mepzx37lyEhoYiODgYixcv5swfuGMfLFy4ECaTCSqVihfCtHr1aty6dYvT1iehwqamJty+fZvzZEd37oGvry8ef/xxeHt74+TJk/j8889drvHz88OUKVOwa9cuziYlPj4eMTExiI2Nxc6dOzndA3fMgwEDBoBhGHTt2pU3ADls2DAwDMPbPGi1Wuj1eiiVSs4TNwFxuQOaplFbW4tvvvmG8xoyscDXYGg0GgQHB+Pbb78VzB24KwxyuZy3OfD29gbDMIKFgaKoeypA5eXl7Pgh330aGhqgVqt5JxoKCwsF+QbkPkJbCuQ+7anICRVtq9WKhoYGhISE3NPfBrAtdoQaN/Je7jdJzYGku5IY9gFFUdiyZQusViuWLl3qUgjUajWWLl2K27dvQ6VSISMjw6UQuGMfaLVajB49GnK5HEVFRcjJyXG5JjY2FtOnT8err77K2aRMnDgRAQEB6N27N958801cvHjR5Rp37sHkyZNRW1uLhIQEvPzyy5xNSnp6Oqqrqzl/DwIqunPnDqxWq6B7kJ+fz9k8hISEIDY2FhERETh37hxnI6PRaJCcnIwjR45wvr5WqwVFUejXrx/ef/99ziyHu9wBOU43NDSUd2tBq9WipqaGd5vFz88Pfn5+MBgMvLkDd6wDwLYdc+3aNc4mxF3ojfw8KirqrgtQRUUFoqKiHF7PWUIrepPJhEuXLt2XzYHQ36a1tRUmkwlhYWH33Bx06tRJcg44JDUHku5aYtgHwcHB2LJlC44cOcK5Ep06dSoSExMRGBiIa9euceYP3LEPFi5ciNu3b2Po0KHIzc3lHIFbtGgRaJrmdAZ8fHwwbdo0/PTTT+jWrRtefPFFF/aBO/cgOTkZERERiIyMRHFxMec0R0xMDEaMGIG8vDzOYkWag1GjRvG6B+6YB8nJybh16xYiIyN5A5A6nQ6nT5/m/EKMioqCr68voqOjUVFRwWnru8sdREZGwmAwYPDgwbyjkySUyLe1oNFoIJPJ4OfnJ9iEiHEOGhsbOadRyH2EirZcLkeXLl3uOvRWXl6O6Oho9vW4JFS0S0pKYDAYBLHJYhgH5P7taQUs5BzYN261tbV3xTooLy9HQEAAAgMDJeeAQ1JzIOme5I59ANjofJMmTcLKlStx48YNh8dIsLGoqAgTJ07E7t27OfMHQuwDrVaLtLQ0XL16Fb169cK8efNctjoCAgKQmZmJd999lzObMGPGDLS0tGDIkCG4ePEi3n77bZdrhNwDmqYxefJknD59GhMmTMDWrVs5v3AyMjJw6dIlzsKalJSEoKAg+Pv787oH7pgHycnJKC4uxqRJk3D48GHOlP2oUaNgNpvx6aefcv4eiYmJaGhoQHR0NO90hFDugBSpnj17ory8nLNxjIiIgEaj4Q0lajQaNDY2YsCAAYJNiDvWAQnx8d3HXQHSaDSimhA+kebA29v7rpwD8r6FmgMxjAOgYzkH5G/WtWtXAMIjrXwiDZXQVER7Akf91pKaA0n3JDHsAwBYt24d1Go1MjMzXZqIIUOGYNiwYTh16hTGjh3LmT9wxz5YuHAhysrKoNPpcOPGDc4mYsaMGYiKisLatWtdHgsLC8OYMWOQn5+PP/3pT9i4caPLatOdezBp0iQ0Njaib9++aG1tRW5urss1KSkpiI+P552uSE1NxZdffomZM2fyugdCzIMBAwYAsBVfhUKBXbt2uVwTGhqKvn37Clr+ly5dwpQpU/Dxxx9zrsqEcgekSAUGBkKj0XBuYZBjld0V7eTkZN7cgRjWAU3T0Gg0gg6F0KqRNAc3b970mHXQ2tqK6upqREZGimpCuFRQUIDw8HDB4iRmjBFof84BKdpcDSj5m5Htlrtp3khzIDQVQSZWfHx8PH799i6pOZB0zxLDPtBoNMjJycGpU6c4DwhavXo1bty4gYSEBHTu3JkzfyDEPiDuwd69e7FixQrs3LnT5dwEhUKBlStX4sSJE5xTFhkZGSgtLcWAAQOgUqk4D3cScg+io6PRv39/HD9+HHPmzEFeXh7KysocrqEoChkZGTh+/DjnNIBOp0NxcTFSU1N53QMh5gHJHXz//feYOnUqdu/ezYl21ul0OHHiBOdjWq0WxcXFGDNmDPR6PSfzQCh3oNFooNFocOvWLcHRSaGJBVK0k5OTeXMHYlgHFEUhNjb2rpwDUkwjIyNhMpk8Zh2QpoWsToUKEF/xLywsZLdg+CS2OWhvzoGfnx+MRiNnY2jvHDAMc8/OgbsG8V4Od2qvkpoDSb+J3LEPANuqOT09HdnZ2S6z53FxcZg2bRreeOMNbNmyhTN/4I59sHDhQpSWlkKtViMlJQULFixw+R99Wloa+vfvj7Vr17qsBJOSkvDQQw/hvffew9q1a3HkyBGXVL8792DKlCk4efIkxo8fj8DAQE5884QJE+Dv78+JKR40aBB8fHxw5swZXvfAHfOAWP7p6emora3lxFTrdDq0tLRwHjyl1WpZbHBKSgrnFoa73AEJC+p0OhQWFnIWcK1Wi9LSUk5nghTthIQE3tyBGNYBYFtdCm1fiHEOAM9Xp/ZF2511zbWit1qtKCgoQM+ePQXvI4ZxYDKZ0Nzc3O6cA4A7q0H+ZgEBAQgPD/f4b2OxWHDjxg23rk57c1t+S0nNgaTfRGLYBwCwYsUKlnHgXNgWLVoEq9WKf/7zn8jOzubMHwixD4h7kJubi61bt6K5udll9U9RFLKysnDlyhXs2bPH5f1lZGTg1KlT6NatG4YNG8bJPhByD8hI4z//+U8sX74cH330kcs4n7e3N6ZPn469e/e6ECS9vb0xdOhQHD16FM899xyveyDEPEhOTsa1a9fg4+ODkSNHcgYgu3XrhpiYGM5VfXx8PGQyGQoLCzFlyhRe5oG73EF5eTmGDh3KOzrZs2dPWK1WzuOqNRoNDAYDjEYjb+5ADOsAsO3Xl5WVcTYBYgpDREQEgLtrDuRyOUJCQgSta74VfVVVFWpqakQ5B+4YB+TfWXtzDgDuKY/6+nowDAMvL6+7yoQQxgHJvvCdztne3JbfUlJzIOk3kxj2gVKpRG5uLgoKClyOVO7UqRPmz5+P3bt3o3///hg/fjxn/kCIfUDcgzNnziA7Oxv79+93scX79OmDiRMnYvPmzS7FefTo0QgNDcVbb72FV155BbW1tS4TDkLuga+vL8aMGYN9+/bhj3/8I3r16oWsrCyXnMUzzzwDvV6PvXv3unxGOp0O58+fh9Fo5HUPhJgHJHdw5swZZGRkoKioyOWcCzI6efz4cZfJDG9vb3a1nZaWBl9fX85JE3e5g/Lycvj6+rJTC86Ki4sDwzCcWwv2hcFd7kCMcwCAM6MhxjlQKpV3xTooLy9HWFgY5HK5220FrtUpcTvENAdi8gZA+2oOhCBVxG2hKOqumgN7V8fPzw9ms5kz2Cq05dPRJTUHkn4ziWEfALbjg+fPn4+cnByX4pqeno6wsDBkZ2dj8+bNnPkDIfYBcQ9ycnLwxBNPYPTo0ViyZIlLFmLZsmVobm52aVAYhsHMmTNx4MABqFQqLF68mJN9IOQeTJ48GSUlJbhw4QLWrFmDCxcuuDggISEhGDduHN566y2X4jxixAjIZDIcO3bMrXvAxTwguYOvv/4aycnJSEhI4AxApqWloaamhvNgKpIHUCqVGDduHCfzQCh3QL6wrVYrdDodzpw5g9raWodrGIZB9+7dOS1/+8IglDsQwzog4Uy++/CtGu2L9t0UoIqKCrZo8zkUbW1t0Ov1nAWosLAQarXabeEXyzgg76O9SAhvbb+iv5fmgDgH5DW57tOePrPfUlJzIOk3lRj2AQDMnz8fCQkJmDdvnkMozsvLCy+99BLy8/Nx4cIF5OXlceYPhNgHxD04ePAgNm3aBJlMhhdffNGhAISFheH555/Hjh07XL5YnnrqKdA0jXfeeQcZGRmIj493YR8IuQfJyckIDw/Hvn37kJycDJ1Oh/Xr17uE/zIyMnD9+nXk5+c7/NzPzw8DBw7E0aNHERgYyOseCDEPiOVPURRmz56N/Px8Fwemb9++CA4O5lzVk2OVzWYzpkyZwsk8EModREZGQq/Xo6amBiNHjoTVanX5PYFfSYnOst9vFsodiCkMDMOgR48evA6FyWTidLqcC5CnoTdi95Pfh6/4kPfhLBJGFNouEMs4aI8jeUJF27lx85R1QBgHvr6+brMN7ekz+y0lNQeSfnOJYR8wDIPt27ejrKwMGzdudHhs7NixSEpKQlZWFuLj43nzB3zsA3v3wM/PD1u3bkV+fr6LBT9nzhz4+/u7hAYDAgIwadIklnWwefNmTvYBn3tAmAeHDx9Ga2srVq1ahaqqKuzYscPhuj59+uDhhx/mXdV/9dVXaGho4HUPhJgHJHdQVVWF8ePHIygoyAWKRNM0Ro0axQkq6tmzJ1paWlBWVoZ+/frxMg/4cgf2Ib7OnTsjKSlJsAlxDofabyvQNM2bOxDDOiD3cedQ2IvgecnjYhwKZ9kXbT7nQKhoFxQUuN1SEMs4cHcs9O9RSqUScrlclHMAeMY6cP7bkNd0lhRIlCTpN5RY9kFcXBxWrFiBHTt2OOyJk9Dg5cuX8f777+Opp57izB8IsQ+Ie/CPf/wDqampmDp1KlatWoXr16+z16hUKixbtgwffvihi7Wenp6OqqoqHD58GElJSZg+fboL+0DIPSDMg6NHj6Jr166YMWMGtm/f7rK9kZGRgdOnT7usakeNGgWj0YgTJ04Iugd8zAP73IGXlxeefvpp7Nu3z+ULUKfTobS01AUMlZiYCMBWoCiK4mUe8OUOnBP+Op0OX3zxhcsKXavVwmAw4Oeff3b4uXPR5ssdiC0MPXv2RFFRkUsIls+61uv17KE85D6esA7sGQfk92lsbHRplvmKdnNzM0pKStxOKngyxgjYMjHtRUJ4a2fnAPAsMGrfHEjOAbek5kDSv0Vi2AcAMGvWLAwcOBALFixwCAcmJSVh/Pjx2LRpE5qbm3nzB3zsA3v3wGQy4eWXX0ZAQAAWLFjg8AU9adIkJCYmupymGBcXh8ceeww7duyA1WrF8uXLOdkHfO4BYR6QVX1mZibkcjm2bNnicJ1Op0N4eLjLqj4sLAy9e/dmAUJ87gEf88A+dwAA06dPh9FoxHvvvedwXUpKClQqlcuqPigoCKGhoexqe+LEiZzMA77cAWEdkKKdlpYGvV6PL7/80uE6sjJ2XtWrVCrQNM1+YfPlDsQWBq1WC6PR6DJCy+ccOK/oPWUd2DMOyOtYLBY0NzcL3oeoqKgIVqv1N2Mc1NfXw9fXV/DY59+j+EZA7Yt2586dPWYdSM6Be0nNgaR/m8SwD2iaRk5ODurr67F69WqHx1asWIG6ujq89tpr8PX15cwfCLEP7N0DtVqNV199FWfPnnWw8WUyGbKysvDdd9/ho48+cnh+RkYGLl68iG+++QYajYaTfSDkHhDmwc2bN+Hv749FixZhz549Dqt8uVyOmTNn4uDBgy5NlE6nw+eff462tjZe90CIeUAsf8D2BTp+/Hjs3LnTYfWrUCh4QUX2eYDw8HBO5oFQ7sDeiu/atSvi4uJc7kNGBZ2bA+dVI1/uQCzrICEhAYBrE8LnHDiv6D1dnToXbb4CxDdFUFBQALlcjri4OMH7iGEckPu2xxUw3wio/RQBTdMesQ7sGQeALeekUChc7mMwGNDW1tYuP7ffQlJzIOnfJrHsg8jISKxbtw779u1zKLwRERF49tln8frrr+PmzZtITEzkzB/wsQ+c3YOBAwdi9uzZ2LBhg4ONnpKSgpEjRyI7O9vBlRgyZAi6devGNhNjx47lZB/wuQeEeUDGAJ9++ml06dLFxaV48sknwTAM3nnnHYfn63Q6NDU1sVsufO4BH/PAPncA2FyaiooKF+aATqfDjz/+iJs3bzr83Hmfno95IJQ7sP/CJqOTztY8HynRfp+eL3cglnWgVqsRHR3t0hyIdQ48ZR3YMw7c3YemaahUKoefFxYWonv37lAoFG7v445xALTfFbBQkNP+9/FkYsGecUDElQlpj+Ofv6Wk5kDSv1Vi2AeAbfwvNTUVixcvdjhWee7cuVCr1diwYQMA8OYP+NgH9u4BYBthjI6OdoEwrV69Grdu3XKw92maxqxZs3DkyBGUl5eDoihO9gGfe2DPPLBarWAYBqtXr8bJkyfx+eefs9f5+flhypQp2LVrl0NzEh8fj+joaHa1zece8DEP7HMHANCrVy8MGDDAJQA5bNgwTlCRVqtFZWUlbt++DQC8zAOh3IFzc1BbW+sChSIOhXNz4VwYhHIHYgoDVyjR29sbDMO4dQ48ZR3YMw7sX8f5Pg0NDVCr1aBpx6/iwsJCt3kDch93WwrkPu2xyHEVbeewKOBZc8C1FcPVhLTH8c/fUlJzIOnfKrHsA4qisGXLFlitVixdupQtFGq1GkuWLMGBAwfw/fffg6IozvwBH/vA2T3w8vJCbm4uioqKkJOTw14XGxuL6dOn49VXX3VoTiZOnAi1Ws2eBxEVFcXJPuBzDwjzgAQeU1NTkZycjJdfftmhOUlPT0d1dbXDeyegomPHjrE5CSH3wJl54Jw7AGxbJefOnXNoYjQaDZKTk10OSCLF6dKlSwDAyzzgyx3Ysw4AoHfv3ggNDXXZWtBqtaipqXHZVnEuDHy5A7GTBMShsG9C+EJvXFkATwqQPePA/nW4thWci4/JZMKlS5fc5g2Ajt8ccP1tWltbYTKZ7to5sGccEEnOgauk5kDSv11i2QfBwcHYsmULjhw54rA6nTp1Knr06MHa8Xz5Az72gbN70Lt3b2RmZiI3Nxfnz59nr1u0aBFomnZwBXx8fDBt2jS899577FYCF/uAzz2wZx4AtmK0Zs0aFBcXO0xyxMTEYMSIES6oY51Oh6qqKrYg8rkHfMwD+9wBYGtOIiMjXQKQOp0Op0+fdviCjIqKgkqlctlacGYe8OUO7FkHgM2J0el0LqOTpAg6by04Fwa+3IEnzkFdXZ3LaZtcBai+vh5yuRxKpdLhPmJDb/aMA3IP8rr24iraJSUlMBgMbpsDsYwDct/2uALmKtp8jZtY1oE944BIcg5cJTUHkv4jEsM+AGzW9aRJk7By5UrcuHEDANhQ47lz5/DJJ58AAG/+gIt94OweAMALL7yA3r17Y968eex2R0BAADIzM/Huu+86ZBJmzJiB5uZmfPDBBwBsIUAu9gGXe+DMPABs9v7kyZOxdetWhy+kjIwMXLp0yaHIJiUlISgoyGG1zeUe8DEPnHMHMpkM6enpOHz4sEPyftSoUTCbzfj0008d3ntiYqJD0eZjHnDlDrhCfDqdDuXl5Q5NIqHUceUB7D8fvtyBWNYBcUK4Qol8Rdt+L98T1oFz0VYoFPD29hblHIjFJotlHAAdyzngGv/0hHXA1VBxTUW0R3DUbympOZD0H5FY9gEArFu3Dmq1GpmZmWwjMWTIEAwbNgzZ2dloa2sDwJ0/4GMfOLsHcrkcubm5uHHjhkMjMWPGDERFRWHt2rXsz8LCwjBmzBjk5eWx74eLfcDnHtgzD4iWLl2K1tZW5Obmsj9LSUlBfHy8yzRFamqqw3P53AMu5oFz7gCwOTEKhQK7du1ifxYaGoq+ffu6WP7OBEM+5gFX7oCrORg4cCA0Go3DFgZFUZx5AK6izZU7EFsYQkNDERAQ4NahALiLqVjWgTPjQOj34bpPQUEBwsPD4e/vL3gfsWOMQPt1DkjRtm86+ZwDQFxglKs54JqKqK+vh0wmg4+Pz12///YsqTmQ9B+TWPaBRqNBTk4OTp06xe71A7bQYEVFBXvUMV/+gIt9wOUexMbGYtWqVdi5cyd7dLFCocDKlStx4sQJhwmLjIwMlJaW4rPPPmN/xsU+4HIPnJkHgK1QzZkzB3l5eSgrK2N/n4yMDBw/ftxhIkCn06G4uNhhRp/LPeBiHnDlDjQaDaZOnYrdu3c7IJ11Oh1OnDjh8DOtVovi4mKHMCkX84Ard+DMOgBsrgvX6CTXxAJX0ebKHYgtDJ40IVzFVCzrwJlxIPT7cB3sQ7DJ7uRJc9BenQM/Pz8YjUaHZpArC+AJ64DPOeBrEN1NgnRUSc2BpP+oxLAPANsqOj09HdnZ2WxRjIuLw7Rp05CTk8OumLnyB3zsA2f3ALCdjpiSkoIFCxawXw5paWno378/1q5dyzYSSUlJeOihhxxW9VzsAz73wJ55QPT8888jMDDQAd88YcIE+Pv7sw0QAAwaNAg+Pj5u3QM+5oFz7gCwBSBra2tx8OBB9mc6nQ4tLS1sowTYirbFYnE4VpmLecCXO+Cy4nU6HQoLCx1+rtVqUVpa6uBGcBVtrtyBWNYBwH2WgyfOAeC+CeEr2nzWtX0TYrVaUVBQIGpSQSzjwGQyobm5ud06B4BjVoMrCyCWdeDMOCAS2yDeT5KaA0n/UYllHwA2CFJERITD2OGiRYtgtVqxbds29jqu/AEX+4DLPSAQpubmZtYBIPjmK1euYM+ePex9MjIycOrUKQfbnot9wOUeODMPAFtBXb58OT766CN2vM/b2xvTp0/H3r17WWKkt7c3hg4d6rLa5nIPuJgHzrkDwOZmjBw50iEA2a1bN8TExDjcJz4+HjKZzKWgcjEP+HIHzl/YQ4cOdRmd7NmzJ6xWq0MTotFoYDAYHFaNXLkDsawDwPZvoKyszKEZEFsYxLIOnBkH9vdx14RUVVWhpqZGtHMghnFA/h21V+cAcJzyqK+vB8Mw8PLycrhWTDCVi3EAcJ/O2V7dlt9KUnMg6T8usewDpVKJ3NxcFBQUsEcrd+rUCfPnz8fu3bsdbHau/AEX+4DLPSBHRO/fv5+1yvv06YOJEydi8+bN7Jfr6NGjERoa6pD052IfcLkHzswDookTJ6JXr17Iyspi8wzPPPMM9Ho99u7dy16n0+lw/vx5B0ubyz3gYh5w5Q4AW7NTVFTEQpbI6OTx48fZKQxvb29069bNpTngYh7w5Q6cv7B9fX0xePBghyYkLi4ODMM4bC3wUQX5cgdiJxYAODR4Yp0DsawDZ8aB0H2cmxCxYURyH7F5A3L/9iauEVDitjg3RWL+DfC5On5+fjCbzQ6hVq4tn/tJUnMg6T8usewDwHas8Pz585GTk8MW2vT0dISFhWHdunUOr+mcP+BiH3C5B4CtYRk9ejSWLFnCrrCXLVuG5uZmtjFhGAYzZ87EgQMH2PE8gJt9wOUeODMPANtKeM2aNbhw4QLreoSEhGDcuHF466232CI9YsQIyGQyF1ARn3tgzzzgyh0AtiKbkJDgsFWSlpaGmpoah/fIlQfgYh5w5Q6cWQdEOp0OZ86cQW1tLfvZdu/e3aEJ4WMDcOUOxE4SxMbGQqFQuNzHedXIZymLKUDOjAMiZ4eira0Ner3eoQAVFhZCrVaLKvqeMA7I/dubuOBRfCt6T5oDLueAvLb9fdrjZ/ZbSWoOJP1XJJZ9AADz589HQkIC5s2bB71eDy8vL7z00kvIz8932B/nyh9wsQ+43AOKorBp0ybIZDK8+OKLsFqtCAsLw/PPP48dO3awXypPPfUUaJp2QR07sw+43ANn5gFRcnIydDod1q9fz4YBMzIycP36deTn5wOwfUkOHDjQZWuByz3gYh5w5Q4oisLs2bORn5/Pui19+/ZFcHCww33IscqkUSFyZh5w5Q6cWQdEI0eOhNVqZX8/wDUPwMcG4ModiHUOGIZBjx49XBwKk8nk4GIJFSB32xfOjAP738e5+JD7E5EworutAk8YB+15JI+raAs1bu5YB1yMA/v7iGlC7hdJzYGk/5rEsg8YhsH27dtRVlaGjRs3ArDt9SclJSErK8uhaHHlD5zZB3zuQVBQELZu3Yr8/Hy2gM+ZMwf+/v5saDAgIACTJk3C22+/7RD642IfOLsHXMwDolWrVqGqqgo7duwAYNvWePjhh11W9V999ZXLStrZPeBiHnDlDgBg/PjxCAoKYrdKaJrGqFGjHEBFPXv2REtLCztVQcTFPHDOHfCF+Dp37oykpCTOJoT8Tfi2FbhyB2JZB+Q+Qg4FF56XSIxDwVe0nZ0DrqJdUFAgakvBE8YB37HQ7UFKpRJyuVy0cwAIj7QK/W3IaxNJgURJkv5L8oR9EBcXhxUrVmDHjh346quv2NDg5cuXXYA8zvkDLvYBl3sA2AiCU6dOxapVq3D9+nWoVCosW7YMH374IWu1p6eno6qqCocPH3Z4rjP7gMs94GIeALZTC2fMmIHt27ezBTwjIwOnT59mV7mjRo2C0Wh0CXJyuQfOzAO+3IGXlxeefvpp7Nu3j/1i1Ol0KC0tZUFQiYmJAFwJhlzMA+fcgVDCX6fT4YsvvmAbJa1WC4PBgJ9//hkA/7YCuY997sATCE7Pnj1RVFTENnfO1rVer4fRaORdnQqxDvgYB+T3aWxsZBth56Ld3NyMkpIS0WcqkPfjTuTzc14ttwdx4a2FnANAODDK1xxIzoGrpOZA0n9VYtkHgO1UwYEDB2LBggVobGxEUlISxo8fj02bNjlYiVz5A2f2AZ97AAAvv/wyAgICsGDBAlgsFkyaNAmJiYksvjkuLg6PPfYYduzY4bKX7sw+cHYPuJgHRJmZmZDL5diyZQsAW/EMDw9nV/VhYWHo3bu3yxkIgKt74Mw84MsdAMD06dNhNBrx3nvvAbCNkapUKraBCQoKQmhoqEsoEXBlHjjnDrhYB0RpaWnQ6/X48ssvAfwawiP3UalUoGnaZVsBcM0deALB0Wq1MBqNbKDVuQkRsuHdsQ74GAfk9SwWC5qbmznvU1RUBKvV+pszDurr6+Hr6+sSkGwvch4B5SvaYlgHknMgXlJzIOm/LrHsAzJ2WF9fj9WrVwOwjTvW1dXhtddec7jWOX/AxT7gcw/UajVeffVVnD17Fnl5eZDJZMjKysJ3332Hjz76CIBtVX/x4kWXEwad2Qdc7gEX8wAA/P39sWjRIuzZsweXL1+GXC7HzJkzcfDgQbZx0ul0+Pzzz1lKJJGze8DFPODKHQC2L9Xx48dj586dMJlMUCgULqAiLj4A4Mo84Mod8FnxXbt2RVxcHHsfPz8/REREsPfhOxQJcM0deMI6SEhIAPBrE+LsHAjZ8O6aEKGi7VyAnKcICgoKIJfLERcX5/Z3EMs4IPdrzytg5xFQvikCd6wDPsYBYHPQFAoFex+DwYC2trZ2/bndq6TmQNJ/XZ6wDyIjI7Fu3Trs27cPx44dQ0REBJ599lm8/vrrLsXWOX/gzD4Qcg8GDhyI2bNnY8OGDbhy5QpSUlIwcuRIZGdnw2AwYMiQIejWrZvL8ceAK/vA2T3gYh4QPf300+jSpQvrUjz55JNgGIYNQOp0OjQ1NbHjh/Zydg+cmQd8uQPA5spUVFSw0xA6nQ4//vgj+5lykQWJnJkHXLkDvi9sMjpJPn/nyQguBgHgmjvwhHWgVqsRHR3N/j6eOAfuWAd8jAO++9A0DZVKBcDWrHTv3h0KhcLt7yCWcQC0/xUwV5CT7/cR+rfGxzggsv+31p7HP38rSc2BpN+FxLIPANtIYGpqKhYvXozq6mrMnTsXarUaGzZscLnWOX/gzD7gcw8A2yhjdHQ0C2FavXo1bt26hTfffBM0TWPWrFk4cuSIy5eRM/vA2T3gYx4AtmDj6tWrcfLkSXz++efw8/PDlClTsGvXLhgMBsTHxyM6OtolswC4ugfOzAO+3AFgOwxqwIABbLMzbNgwB1CRVqtFZWUlbt++7fJcZ+YBV+5AqDmora1lHRjiUJDPhc85IPdxzh2IPRjJvtnx9vYGwzCinAN3rAM+xoH965HXb2hogFqtBk3bvoYLCwtF5Q3IfcRsKZD7tOciZ1+0hcKigPC/AXdbMfb/1trz+OdvJak5kPS7kCfsA4qisGXLFlitVixduhS+vr5YsmQJDhw4gO+//97lWvv8gUwmc2AfCLkHXl5eyM3NRVFREXJychAbG4vp06fj1VdfRXV1NSZOnAi1Wu1w/gORM/vA2T3gYh4QpaamIjk5GS+//DKMRiPS09NRXV2NQ4cOsaCiY8eOcU54cLkHhHkglDsAbFsl586dww8//ACNRoPk5GQ230CK1qVLl1ye58w8cM4d8LEOANvx2aGhoWyzo9VqUVNTw7obfM4B4Jo78OTUROJQWK1Wl+0Ld6N/QgWIj3Fg/3r22wqk+JhMJly6dElU3gC4v5oD+79Na2srTCbTXTkHfIwDIsk5cJTUHEj63cgT9kFwcDC2bNmCI0eOYP/+/Zg6dSp69OjB2vH2cs4fOLMPhNyD3r17IzMzE7m5uTh//jwWLVoEmqaxdetW+Pj4YNq0aXjvvfc4Z6vt2QcAHNwDPuYBYGto1qxZg+LiYvz9739HTEwMRowYwaKOdTodqqqqHCBARM7ugTPzgC93ANiaksjISDYAqdPpcPr0adTX1yMqKgoqlUpwa4EwD5xzB3ysA8C2PaDT6djRSVIcydaCkHPgnDvw1Dmoq6tjT9S0v099fT3kcjmUSiXnc4VYB3yMA3IP8vqAY9EuKSmBwWAQ1Rx4wjgg92vPK2D7oi2mceNjHfAxDogk58BRUnMg6XclsewDwGZnT5o0CStXrkRlZSXWrFmDc+fO4ZNPPnG51jl/YM8+EHIPAOCFF15A7969MW/ePHh7eyMzMxPvvvsurly5ghkzZqC5uRkffPCBy/Oc2Qf27oEQ8wCw2fyTJ0/G1q1b0dDQgIyMDFy6dAmnT59GUlISgoKCOLcWAEf3wJl5IJQ7kMlkSE9Px+HDh1FZWYlRo0bBbDbj008/BU3TSExMdBlnJHJmHtjnDtyF+HQ6HcrLy3H58mVERERAo9E45AH4mgPn3IEnrAPihNiHEp2LNt9+vpBDIVS0FQoFvL29OZ0DT7DJnjAOgI7lHLhjNgiNtLprqOynItozOOq3ktQcSPpdyRP2AQCsW7cOarUamZmZGDRoEIYNG4bs7GyXND/gmD9oaWlxYB8IuQdyuRy5ubm4ceMG1q9fjxkzZiAqKgpr165FWFgYxowZg7y8PM5mxp59UFVV5eAe8DEPiJYuXYrW1lbk5uYiJSUF8fHx7PREamoq7/Oc3QN75oFQ7gAApk6dCoVCgV27diE0NBR9+/Zl78M3sQC4Mg/scwfumoOBAwdCo9HgyJEjLscqC20rAI65A09YB6GhoQgICOB0KNwVUz7WgRDjgIirCQFsTkl4eDj8/f3dvndPxhiB9u8ckKJN8gbkZ1wS+rfmrjmwn4qor6+HTCaDj4/Pvb79diupOZD0u5Mn7AONRoOcnBycOnUKf/vb37B69WpUVFQ4HHlM5Jw/mDx5Mss+iIuLE3QPYmNjsWrVKuzcuRNnz57FypUrceLECZw4cQIZGRkoLS3FZ599xvke7dkH9u6BEPMAsBWwOXPmIC8vD9evX0dGRgaOHz+O0tJS6HQ6FBcXOxw+ZS9798CeeeAud6DRaDB16lTs3r0ber0eOp0OJ06cgF6vh1arRXFxMW9g1J55YJ87EGIdADaHxX500n5iQcg5ABxzB56wDoSaEHfFlI91IMQ4IHJeBZMiR7DJYuRpc9DenQM/Pz8YjUYYDAa3WQAh1oEY58C5QRQzDdJRJTUHkn6XEss+AGzQnvT0dGRnZ4OmaUybNg05OTksLdBe9vmDtWvXOrAPhNwDwHZaYkpKChYsWIBHH30U/fv3x9q1a9GnTx889NBDnGONgCP74NNPP3VwD/iYB0TPP/88AgMD8corr2DChAnw9/fHzp07MWjQIPj4+IhyDxobGx2YB0K5A8BGgKytrcXBgweh0+nQ0tKCkydPQqvVwmKxOByrbC975oFz7sBdWFCn06GwsBDl5eXQarUoLS1FU1OTW+fAPnfgCesAcHRCPHUOANcmREzRdrau/fz8YLVaUVBQIHpSwRPGgclkQnNzc7t3DgBbM+UuC8DHOhBiHBB50iDeD5KaA0m/S3nCPgBsMKSIiAi88MILmDdvHqxWK7Zt28Z5rX3+4KeffmLZByqVStA9IBCm5uZmrFq1CllZWbhy5Qr27NmDjIwMnDp1ijdIac8+GD58OOseCDEPABtUaPny5fjoo49w8eJFTJ8+HXv37oXRaMRjjz3G2xwAju6BPfNAKHcA2CiOI0eORF5eHmJjYxETE4OjR48iPj4eMpmMd2sBcGQeOOcOhIr20KFD2dHJnj17wmq1oqioCBqNBgaDweF4ZnvZ5w48YR0ANoeirKyMLdJiCwMf60CIcUBkb12TJqSqqgo1NTUeOQdiGQfkuPH27hwAts+rvr4eDMPAy8uL93quf2t37twRZBwAjqdztne35beQ1BxI+t3KE/aBUqlEbm4uCgoKsGfPHsyfPx+7d+/mtd3t8wcTJkxg2QeZmZmC7kFYWBiys7Oxf/9+VFRUYOLEidi8eTMGDRqE0NBQNunvLHv2wV/+8hfWPSguLuZlHhBNnDgRvXr1QlZWFqZPnw69Xo+9e/dCp9Ph/PnzvChfe/cgJCSEZR64yx0AtkmLoqIifP311yyoiGEYdOvWTbA5sGceOOcOhJoDX19fDB48GEePHkVcXBwYhkFBQQHv4Uv2cs4deDKxAACXL1/2yDngYx0IMQ6InLcV/Pz8PAojkvt4kjcg922vsh8BJY2cUGPE9W/g1q1b7GN88vPzg9lsRktLCy+F8X6S1BxI+t3KE/YBYDtueP78+cjJycHDDz+MsLAwrFu3jve1Sf5g3rx5ePnll/Hll1/ip59+EnQPAFvTMnr0aCxZsgSzZs1Cc3Mz3njjDcycORMHDhzgHNkDHNkHMTExrHsgxDwAbKvjNWvW4MKFCzhz5gzGjRuHt956C0OHDoVMJmNBRVxydg/y8/PBMIxg7gCwFdyEhATk5eUhLS0NNTU1+O6771wIhs6yZx707duXzR0IsQ6IdDodzpw5g6amJnTv3h2FhYWChy/Zv1eSO/CEdRAbGwuFQsHeh6waxVjKXAVIiHFARByKtrY26PV6djJDrVaLLvieMg7Ifdur7OFRYlb0Qs2BO+cAcGxC7mdJzYGk37U8YR8AwPz585GQkIDFixfjxRdfRH5+Pk6ePMl5rX3+4F//+hfLPpg1a5age0BRFDZt2gSZTIZt27bhueeew44dOzBkyBDQNM2ijrlE2AfLli3D/PnzkZ+fD5VKxcs8IEpOToZOp8P69esxffp0XL9+Hd988w0GDhwouLVg7x489thjAGzMA3e5A4qiMHv2bOTn58Pf3x/BwcE4evQoe6yy/THZziLMgx9++IHNHQixDohGjhwJq9WK/Px8Ng/AdVqes+xzB544BwzDoEePHqxDYTKZ0NraKroAOW9fCDEOiEgTYl+0SRhRzDaBp4yDjjCSZ1+0xTZuzqyDW7duCTIO7O8jtgnp6JKaA0m/e3nCPmAYBtu3b0dZWRkuXryIpKQkZGVl8RYz+/wBWYH+4x//cOseBAUFYevWrcjPz0fnzp3h7++P1157DZMmTcLbb7/NHnbE9f4I+6Curg4xMTHIyckRZB4QrVq1ClVVVThz5gwefvhh5OXlQafT4auvvhJcWRP34P3332eZB+5yBwAwfvx4BAUFYefOnRg1ahTbHLS0tKCsrIz3efbMA9KEuDuTALAlzZOSkhyaEHLugNDvZ5878IR1APyKUfa0MHA5FGKKNnEO7It2QUGB6C2Furo6jxgH7rgA7UFKpRJyudwj5wBwHGm9deuWqL8NIL4J6eiSmgNJv3t5yj6Ii4vDihUrkJeXh/Hjx+Py5cssnIdLJH+QnZ2NWbNm4e9//ztGjhwp6B4ANqIgGbmcNWsWPvzwQ/Tv3x9VVVU4fPgw7/MI+2Dz5s2YMWMG8vPzodVqBZkHgO0UwxkzZmD79u2YNGkSTp8+jS5dusBoNAqGNu3dg7S0NFy8eBGBgYEAhHMHXl5eePrpp7Fv3z4MGjQIpaWl7KFAQlsL9syDBx98EDU1NSx3wt2qXqfT4YsvvkC3bt1gMBhYp0GoOQB+zR2QMKDYUGLPnj1RVFTENiHkcB4xq1N71oFer3fLOABszUBjYyNqa2sB2JrFkpIS0ZMKYvbO7UU+N6EV8+9d9nhrsc4B4PhvTUxzIDkHjpKaA0ntQp6wDwDbKYMDBw7EG2+8gdGjR2PTpk2cSFXAMX9w9OhR9OnTB2+88QZGjRol6B4AwMsvv4yAgAB89tlnSEhIwN/+9jcMGTIEO3bsENxfJ+yDr776CjExMdi3b58g84AoMzMTcrkcFy5cQHh4OD766CP06tWLPQOBT8Q9KCoqQlBQED7//HO3uQMAmD59OoxGI8rKyqBSqXDmzBmEhoYKhhKBX5kHlZWVYBgGP/74oyDrgCgtLQ16vZ4tniUlJaBpWnBbAfg1d1BXVwdAHOsAsDkHRqORvZ89TllIhHVAmhcSChVTgCwWC/tvuKqqygEb7U6eNgf19fXw9fUVDEm2B5ERUDFFm4t1IDkHnktqDiS1G3nCPiBjh6So1NXV4bXXXuO9nuQPiouLER4ejuLiYoSGhrp1D9RqNV599VWcO3cODz30EBvau3jxInvSIJcI++Do0aMYOnQo8vPzMWDAAEHmAQD4+/tj0aJF2LdvH9LS0nDw4EE8+uij+PzzzzmpkETEPdi1axdGjx6NAwcOoH///m6bg86dO2P8+PHYvXs3hg4diqNHjwqSEokI8+DQoUNs7kBMWLBr166Ii4vDyZMnERERgUuXLrkFIQG/5g6uXLniEesgISEBAHDjxg0AvxZfsatTcr3Yok1el1xfVlYGuVyOuLg4Ue+3srJSNOMAaP8AJCIyAipmioCLdVBVVeX2b+Pl5QWFQsE6XR3hc7sXSc2BpHYjT9kHkZGRWLduHT755BMMHToUr7/+umDhJfmDTz75BIMHD8bevXuRkpLi1j0YOHAgZs+ejQ8++ACPPPIIDh8+jJiYGF4oEhFhH3zyySfo0qULfvjhB0HmAdHTTz+NLl26oKCgAHK5HE1NTWhqasJXX30l+DziHrS1taG6uhpqtdpt7gCwuTAVFRXo3LkzfvzxR0RGRrptDoBfmQc9evRgcwdiijYZnUxISGDDgu6cA5I7OHv2rEesA7VajejoaJSWlgIA+1mIyRwAvzoGt27dcss4sH/dqqoq0DSN4uJidO/end2ucadbt26JZhwAHQfmYx/kFPP72AdTLRYLTCaT27AoYGtCyN9Uag4kSWpH8oR9ANiORk5NTcW5c+egVCqxYcMGwetJ/uDs2bPs/nBJSYmgewAAy5YtQ3R0NKqrq/HLL78gJiYGR44cESyG9uyDqKgofPHFF3jkkUcEmQeAbZ969erVOHPmDPr374+jR48iMjJSMK8A/OoefPzxx4iPj8fVq1cBCOcOANshUAMGDMD3338PhmHQ3NyMyspK3L59W/B5hHnQ2NiImpoaqFQq0c1BbW2tw5ifO+cA+DV3EBYWJto5AGxbC1evXgXDMOzv5K4AEdaBvXPgjnFg/7qkObt06ZLovAG5j9gtBaBjOQeeZAHsmwMSRhbzuWk0GlRXV7P3vJ8lNQeS2pU8ZR9QFIUtW7aAoigEBwdj//79+P777wWv37x5M0JCQiCTyfD9998jMTHRrXvg5eWF3NxcXL9+HXFxcTh9+jSUSiX+9re/Cb4/wj746quvEBISgrq6OkHmAVFqaio7cXD79m1ERUXh2LFjbqc5iHsQGBiIU6dOISoqyu3WAmAbwTx//jwSEhLw008/AQAuXbok+BzCPDh37hzkcjlaWlrcsg4A2zHZoaGhuHPnDmpqauDt7e3WOQB+zR0oFAqPm4OCggKo1WoWuS22AJHmoLKyUnTxAWwnK2o0Gly6dEl03sCT+xB1lOZAo9GgtrYWJpPJY+eANAdinQOSI+kIn9u9SGoOJLU7eco+CA4OxpYtW/DTTz8hKCgIWVlZggWK5A/u3LmDkJAQlJeX4+eff3brHvTu3RuZmZkoKiqC0WjEAw88gPfee483CElE2AcA8P333yMgIMBtMJGiKKxZswY3btxATEwMSktLUVlZiQsXLgg+j7gH33//PcxmMwICAkQ1B6mpqWwI78cff4S3t7forYWbN28iKioKlZWVblkHgG2LQKfT4dKlS7BarTCZTKKcA5I7IE2IWGm1WtTV1UGpVKK2thZyuRxKpdLt8yIjIx22FcQUH1JwamtrwTAMDAaDR82Bp85BR9lW8PPz87hxq62tRUtLC8xmMzQajaiJDdKEkHvez5KaA0ntUp6wDwCbxT1p0iQ0NDTg9OnT+OSTTwSvJ/mDW7duobm5GcHBwW7dAwB44YUX8OCDD0Iul+Pq1auoq6vDBx98IPgcwj6oqqqCr68vlEqlW+YBYLP7J0+ejF9++QXl5eVQKpVutxYAm3tAURRCQ0Nx69YtUbkDmUyG9PR0FBUVoa2tDUFBQYLjjESEeWC1WnHt2jUW4uNOOp0OlZWV8Pb2ZsFE7kRyB+SsAjHbTgBYW5+iKNTV1Yk+jS8iIsJj50ChUMDb2xt1dXXsv1uxzYHFYnE4mlqMOpJz4AmzgXxGlZWVMJvNCA0NFX0fMvHSET63e5HUHEhql/KUfQAA69atQ+fOneHt7Y1169YJpvsBW/5gwoQJMJlMuHnzJq5everWPZDL5cjNzYXJZIJcLodarUZeXp7bBoawD5qamlBaWoo7d+6IKvRLly4FRVFQKpWimwPiHvzyyy+4ceMGjEaj29wBAEydOhVKpRIBAQEwmUyinAPCPCgtLUV9fT3MZrOo5mDgwIHQaDRQq9VobGwUta0A2LYWysrKYLVaec+ccFZoaCgCAgJgNBrR2NgouihERkbi9u3bsFgsqK2tFV20SfLeYDAgPDwc/v7+op7nyd45UUdxDuzx1mKdA8DmtHjSHPj5+aGxsREymQw+Pj739J7bu6TmQFK7lafsA41Gg5ycHLS2tuLq1avYuXOn4PUkfxAbGwuKoiCXy/HnP//ZrXsQGxuL1atXo7W1Fbdv38aVK1fw2WefuX1/y5cvZ7MOSqXS7dYCYCtsc+bMQWNjI27evIkrV67wHjZlr+eeew5KpRI0TcPHx0fU1oJGo8HUqVPR0NCAmzdv4tq1a6JW5xMnToTVaoXZbIZMJhM1ScAwDIYPH46mpibU1NSIcg4AW3NgsVhgNBrZVb07URQFrVaL1tZWNDY2ii6mkZGRMJvN7L8HsUWbBF2bmpo82lK4m+agozgHfn5+bDMv5vchrIO7cQ6amppEu0cdWVJzIKldyxP2AQCkpKTg2WefhcViwebNm9l9TD75+vrizTffhJeXFxobG3H58mW37gEAPPPMMxg+fDgAsAcfuRNhHxiNRty5cweff/654Ogl0fPPP8/udxuNRo/cA6PRiObmZpw6dcrtcwAgPT0dZrMZra2t0Ov1KCoqcvuc8PBwDBo0CAzDgKZp0XkAnU6Huro63Llzh90HdqeEhAQEBATAbDaLdg4A29ZCQ0MDWlpaPHIOALCobE+ag5aWFtTW1no0qWCxWKBSqUS/P5PJhObm5g7jHFitVlgsFlG/D2Ed/PLLL7BYLB45Bx3lM7tXSc2BpHYtT9kHALBixQr06NEDlZWV2Lx5s9vrExMT2YOW2trasHHjRrfuAYEwBQQEoKWlBZ9++qmo8OTYsWORlpYGAGhpaXHLPAAAHx8frFixAmazGUajER9//LHb5wA290ClUqG5uRmXL18W5b5ER0cjLS0NFEXBYDCI2loAbMHE5uZmNDY24vr166KeM3ToUHh7e7NFzmAwuH0OyR3QNO1Rc6DVallehNjCQBoyk8kEmUzmlnFARAqQXq/32DkICQkRvaJtbGwE0DH2zv38/GCxWCCTyeDl5SXqOZGRkewWk9i/jUajQWtrK9Rq9b283Q4hqTmQ1O7lKftAqVTi9ddfh0KhwBtvvCHKhn/qqacwdepUWCwWFBYW4sCBA26fExYWhi1btkAmk6GlpUWQ0EhEURQ2bNgAlUqFtrY27Ny50+3oH2Cz7pOSktDW1obTp0+LKoyBgYFsOLGlpUVU7gCwTVeQbYKLFy+Kek5aWhr8/PxgMBhYvoI7+fr6YujQoax178nWgl6vZ6mHYkRORSTHKIuRUqmEv78/zGYzOnfuLBpRrNFooNfrQdO0x82B2BUw8OuhSx2hOSDOgUqlEt0c2Z+c6YlzYDab2bM27mdJzYGkdi9P2QcA0LdvXyxduhStra3IzMwUdY8///nP6N69O0wmE1auXOnWPQBsjcsTTzwBi8WC3bt3ux3jA2zsg1WrVrFnIbhjHgC2FfP69evBMAxaWlrcnrVA9Nxzz8HX1xdGo1FULgKwFd8ePXrAaDS6pTISKZVKTJgwAWazGSUlJaIaHgAYPXo0myHwpDmgKArFxcWirgdsORGGYTzG5oaGhnpctMnn7ePj41F+wNP72B8L3d7l5+cHq9Uq2jUAHEdNPXEOrFarqFHWji6pOZDUIeQp+wAAFi1ahMTERBw/fhyffvqp2+t9fX3x/vvvw9vbG8XFxXjnnXfcPoeiKGzfvh1BQUFobGzEq6++Kuq9Pfvss+jRowfa2tpEPyc5ORkjR46E2Wx2G7YkCgwMxOzZs2G1WkVvR1AUhczMTFitVly8eJH3OGxnTZs2DTRNsyFDMRo5ciTkcjna2tpETywkJCRApVJ55BwwDIPIyEhYLBaPCkNoaCgsFovo4gPYJm2sViu6du0qehVMnJq7aQ46inNgsVg8bg6amppAUZToyQNyH7E4644sqTmQ1GHkKfuAYRjs3bsXMpkMGRkZoopcYmIim1NYtGiRKPcgKCgIeXl5oCgKf/nLX9gAm7v39tZbb4Gmaezfv1/0zP5f/vIXyOVynDlzRvRKe+HChfDy8kJZWZmo3AEATJgwAWq1mh29FKN+/fqhU6dOaGtrE5076Ny5M6Kjo2E2m0WHEmmaRmJiIhobG0U7FIDNPbBarWAYRvRzQkJCPAq8AbbmwGKxiD5sCbAdHObJ3jkAj7gAv3eRhs2Tvw1p9mhafJkjDoUn9+mokpoDSR1Gd8M+iI+PR2ZmJq5fv45169aJes6cOXPw8MMPo7a2FsuWLRP1nHHjxmHQoEFoamrC6tWrRT3nkUcewYgRI6DX67Fp0yZRz+natStGjx4No9GI7du3i3pOYGAgxo0bB7PZjLffflvUc7y8vNjtkkOHDol6DkVRGDduHKxWK/71r3+Jeg4AjBgxAlarVRR0iWjAgAEwmUyimjei7t27i76WKDAwEICNwilWpAn1lIwIiN87B351DsSQAX/voigKMpnMo6On76Y5IM6BTCa7m7fZoSQ1B5I6lDxlHwA2OFKXLl2wefNm/PLLL26vpygKx48fh0KhQE5ODktUc6dDhw6JZiUQ7dmzBzKZDNu2bRN1PQC8+eab7LSEWL366qugKEpUaJJo/fr1ACC6oQCAxYsXA4CocVCi9PR0ABA9jQLYcM8A3IKu7BUbGwsAorc8ALD2s7e3t+jnkIN9CDJbjO6mOaivr4evr69HBfX3LJqmPWIPdO7cGRaLxaPnEOfAk4aio0r6BCR1OHnKPqBpGnv37oXRaMTkyZNFPcfPzw/btm2D2WzGoEGDRD3H398fc+fORVtbG6ZMmSLqOQEBARgzZgyamprcnihJ1KlTJzz44IOorq4WXVBDQkIQGRmJ69evix4BjIiIgL+/P65cuSK62enWrRsUCoXoKQcA6NOnDyiKwo8//ij6OSkpKaAoyqPmoEuXLgAgqkG8F5HPt2vXrh49h6Ioj1yAjgJAuld5srUk6VdJzYGkDqe7YR888sgjmDhxIk6fPo333ntP1HPmzp2LLl26oKCgAG+88Yao52zbtg0qlQqHDh0SXSB37doFmqaRnZ3t9hAnIrKlQMYOxWjOnDmwWq2ipjeIUlJSYDQaRX9mgK2paGhoQElJiejn+Pj44ObNm6KbEIZhoNFoROU7iMi+thjwFBFpPvR6vejnEBfAkxXtrVu3IJPJPHpOR0EnE1ksFo8KfVVVlceUw/r6elAUJSqz1NElNQeSOqQ8ZR8AwP/93/9BrVbjhRdeYK1fd/rggw9A0zQyMzPx888/u72epmm89NJLsFgs+MMf/iCqePn7+2Pw4MFoaWlhbXl3GjhwIAIDA1FSUiKKmAjYqI4ymQyHDh1yS44k+tOf/gQA2Lp1q6jryXuzWq2iGyrAFuo0Go04d+6c6Oc88MADsFgsot0DvV4PiqI8ag7IFsTt27dFP4cULQIpEiPSHHiijuQckGkNTzIk5eXlkMlkHhX6hoYGUBQlegKnI0tqDiR1SN0N+0Cj0WD9+vVoaGjArFmzRK1SHn74YQwbNgwGgwHjx48XRfGbP38+/Pz8UFJSwu7bu1NWVhZomsauXbtEOQ4UReGpp56C1WrFwoULRTUhISEhiIqKgl6vF/2ZPfLII2AYBleuXMEPP/wg6jkDBgwARVH44IMPRH9xR0VFwWq1ioJPEZHpA7GjrY2NjaAoCr/88ovoFWplZSVomhZ9joPJZGKfI3aahNznfm4OSIPvaXNA07RHbkN9fT1omvbIceqokpoDSR1Wd8M+mD17NhITE3H06FG3Ry0T5eTkwMvLC5cuXcLSpUvdXu/j44O5c+eCoihs27YN58+fd/ucQYMGITo6Gm1tbXjuuedErWyeeuopKBQKFBcX49133xX1uzz++OOgaRo7duwQ5R5ERUWxlMC//vWvou7RrVs3yOVy3Lp1C6dPnxb1nPDwcMhkMnzyySeiv+xJ4E9s00IKQ2trq+jcwa1btzxCNZeUlMBkMoGmadHcBqvVelfOQUfaViArejHNN1F5eTl8fX1hsVjQ0tLi0X08yap0VEnNgaQOLU/ZB+TIZZlMhoULF4oC6Wi1WvzhD38ATdN488038eGHH7p9zpw5c+Dr6wu9Xo+MjAy3Wx80TWP27NmQy+W4cOGCqAmBfv364YEHHgBgm8gQs1IdPnw4GIZBQ0ODqMOiaJpG3759IZPJcPDgQVFFMjIyEl5eXrBaraJOngRsWwRyuRw3b94U3eiRZL+Y5guwFQbCIBB7ZgRZ0Yt1Dsjrks9YjGpqamAwGO5r54A0bp5kO8rLy9G5c2cAEN28NTQ0sA3i/S6pOZDUoXU37IMhQ4bg8ccfR11dHebPny+qqXjppZegVCphMpkwd+5ct2G7sLAwTJo0CQqFAleuXBG1vTBlyhT4+PjAarXi5Zdfdru6lclkGD9+PLy9vVFdXY3c3Fy39xgwYABLk3vjjTdEuQf9+vVjz4LYtWuX2+tJc0BRFA4dOiQqZOnv7w8fHx9QFCUaDR0aGgqKolBQUCBqxdnQ0ABvb28wDCOKqdDa2ora2lrIZDLcvn1blOVdUFAAb29veHt7i3YOyCmWknNgOwNErHNUXl7O4qnFNm+kCRHrNHRkSc2BpA6vu2Uf+Pj44NNPP8Xf/vY3t9drtVpMmDAB3t7ebGbBXUF67rnnWBzsG2+8gZMnTwpeHx0djSFDhsDHxwdNTU1YuXKl2/c1evRoyGQyWK1WvP766ygrKxO8PiQkBD169ICPjw8aGxtFuQdarZaFzezatcvt6k6j0SAwMBAKhQKNjY345z//6fYeGo0GDMNAqVSKDlgS58BgMODChQtur6+vr4ePjw98fX1FOQfkUB+5XC76iOjCwkL4+PhAqVSKdg7utjnoaM4BCQqK3VooLy9Hly5dQFGUR86BJ3+bjiypOZB0X8hT9kFcXBzS09Mhl8uxdu1aUSc3Ll68GAzDgKIofP/9927vlZSUhIEDB0Kj0YCmacyfP9/tl9LUqVPZc+0/+ugjHDt2TPD6QYMGwd/fHyqVCmazGa+88orb3yMlJQW+vr5QKBTYuXOnW/dAq9VCoVCwX8IHDx50e4+oqCgEBwcjMDBQ1NYCObK3ra0NBQUFbMEUUlBQEACbhf/111+7vb6hoQEqlQre3t6imgPyHghq1917IpRHhUIBlUol2jmoqKjw6DRCAOwx1x3JOSAQJDGfm8ViwY0bN/DAAw94FBitr6/36G/TkSU1B5LuC90N+2DRokUICAiAxWLBCy+84DbBrNVqMW7cOLbY/+1vf3ObP5g9ezaMRiPMZjNu3brl1g14/PHH4e/vj4CAAPj6+mLFihWCtry3tzeGDx+OgIAAUBSFw4cP45tvvhG8R3JyMlpaWtgglzv3ID4+HgqFAsHBwQgJCUFeXp5b6zcyMpI9nfDMmTNuz2cgp+WRQuyuKQLA4nY7deokKvhIiII0TaOsrMxto0ZG5cQ2B1VVVezoo6+vr0fOgSdnKgBgxyQ7knNAGm8xn1tVVRWMRiNCQkI8yoQ0NDSwf5v7HZ4kNQeS7ht5yj7o1KkTMjMz0dbWhu+//17UWQVkbFCj0UCtVmPx4sWC+YPRo0cjMjISUVFRkMvl+OCDDwRtdl9fXzz++OPw8vJCc3MzKisr3TIGdDod7ty5A5qmERgYiKysLMEcxYABA8AwDMLDw/HAAw+4dQ+8vb3RvXt3hISEoLW1FUVFRW6Pco6MjITVaoXRaISXlxf2798veL2fnx/kcjkYhkHXrl1Fby3IZDL4+Pjg22+/dWtHExuefDbugo8k8EZRFPz9/d02B8SNIP8+PGkOPMEmA78eutRRmoOGhgbWBRHzuZG/RWhoqEfNQX19PTQaDcxm832fO5CaA0n3je6GfZCeno7o6GiEh4cjJyfH7VicVqvF6NGj4e3tjaamJvbER77CxDAMZs6cidu3b4OiKISHh2PJkiWC2YjJkyejvr4eDzzwAMLDw/Hmm28Ksg9GjBgBhUKBhIQEAMCFCxcEHY2QkBDExsYiNDQUt27dgtlsduseaLVaWK1WtLa2Ijw8HHl5eYLXR0ZGoq6uDgqFAvHx8Xj//fcFGxaNRgOKohAVFYWAgACcOXNG1CmNJG8hJndQX18Pf39/6PV6KBQKt1sLFRUVbNEODQ0V1Rz4+vrCZDLB39/fo0Cip80BKaAdaVuB/C5iPjfytyDOgSeZA39/f/Y/38+SmgNJ95U8ZR94eXnhpZdewo0bNxAaGop58+a5DdwtXLgQtbW16NmzJywWC65evSqYPyA8gj59+qCyshIWiwUvvvgir62ZnJyMiIgIdOnSBdevX0d4eDhefPFFXvaBv78/Bg4cCIZh2Pe1fv16wd8jOTkZdXV1kMlk6Nu3r1v3QKvV4ubNm+jcuTO6du2K/Px8QcckMjISbW1tSExMhFKpREVFhaD1T1bAXbp0gV6vh9VqRX5+Pu/1RAQ25Ofn5zZ30NDQgICAAJjNZnTv3t3txIK93R8aGsoGFPlUWFjInvwYEBAgqvhYrdZ7ag46inNQX1/PnoAp1jkICAiAj48P+29AzFQM+TdA7nk/S2oOJN138pR9MHbsWPTr1w8ymQxlZWXYuHGj4PVarRZpaWmoq6sDRVHo1asXdu/ezbtaDwgIwKRJk1BSUoLAwEDExsYiPz+fN6hH0zQmT56My5cvo2vXrggODsbFixcF2Qc6nQ6XLl1C3759QdM0qqqqsGPHDt7rk5OTUVZWhkcffRS1tbWwWq2C7kHPnj3R2tqK/v374/r16wgKCsKbb77Jez0ZMYuLi8NPP/2E6OhovP/++7zXk1VjWFgYfv75Zzz00EOithZkMhkaGhrQr18/webDarWioaGBLUCxsbFunQP7oh0SEuLWOSgoKGAPWwoKChJVfGpqaqDX6z3OHJDX7kjOgb+/P+RyuWjngPwbI1Me7po3wPa5kSCr5BxIknSfyVP2AUVRyMrKQllZGUaMGIEdO3a43VNfuHAhbt68ieHDh+P8+fNITk4WzB+kp6ejpqYGw4YNw/nz5zF06FCsWrUK169f57x+0qRJaGpqwqBBg3D+/HnodDps3LiRl30watQoGI1G9O3bFz/++CPGjBmD7du3825fDBgwAIAtbFhUVITHH39c0D1ITEwEYJtCuH79OtLS0rBv3z7eL1jyxR0aGoo7d+5g6NCh+Pjjj3lXd2QFHBwcDIPBgIceeghffPGF2+wIKQzx8fGCuQO9Xg+j0Yjg4GD29ygqKuINoba2tqK6utqhORA6GKq5uRklJSWIiIgAYMuzNDY2um1O7ffOPRH53D05xfH3LLLlIzarwdUciJlwaWhoQKdOndh73s+SmgNJ96U8ZR8kJSVh/Pjx+Oabb/Dwww9jwYIFggfnEPfgwoULeOihh1BZWYng4GDe/EFcXBwee+wxFBYWIjExEXfu3EFAQAAWLFjAWUCio6PRv39/lJSUICYmBi0tLVCpVLzTDuHh4ejVqxeqqqoQHh4OwDafv2XLFs7rSe6gqakJQUFBLNGQzz0ICgpCaGgorFYrVCoV1Gq14GmNGo0GGo0GSqUSDMOgU6dO0Ov1vGFMlUoFmqbZ/eAHHngAer0eX375Jef1RKQwPPDAA4K5A1JwCFEvLCwMRqORd4SVrELttxXIuQlcKioqgtVqZa/v3LkzLBYLmpubBd//3TYHZPJCLpd79Lzfq0hYVKPReOwc0DQNuVwu2jkgfyPJOZAk6T6Vp+yDFStWoL6+HlqtFvX19Vi9erXg9QsXLkRZWRmGDx+O0tJSPPbYY7h27Rrv/TIyMlBQUIDJkyfjhx9+wMSJE3H27FnecN+UKVPw1Vdf4ZlnnsG//vUvzJgxA0eOHOEd89PpdPjiiy8wffp0fPLJJ8jIyMCePXt4sxfJyck4e/Ys/vjHP+LIkSN4+umnBd2Dnj174sqVKxg+fDi++uorjB8/Hjt37uRdTUdERKCyshIPPvggioqKkJKSwruVQlEUNBoNTCYTIiIiUF1djbi4OLdbCzRNs0cdC+UOSMEhRZhsL/BtLTgXbfL/+VanBQUFkMvlrANCrndXgCoqKqBWqz12ADoSAAn4dYrAz8/P7WdGGAekOaAoCp07d3brHBgMBrS1tSEoKAgKhUJqDv7bb0CSpP+WPGUfRERE4Nlnn8WePXuQmZmJffv2Cc7bE/dg//79bCGeP38+b/5gyJAh6NatG7755huMHDkS+/fvx8yZM7FhwwZcuXLF5frHH3+cnYqIiYnBd999h2HDhvGyD3Q6HZqamhAdHQ2GYWAymdClSxdkZWVxhh+Tk5Nx7do1jBgxAtXV1UhMTBR0D7RaLQoLC6HT6fDjjz9i3LhxqKio4P2MIiMjUV5ejuTkZHz99deYPHmyIPPAz8+Pbc4KCgqg0+lw/PhxQWwxKQw3b97EgAEDeHMHpBCQsyhMJhOio6MFmwO5XM7uT5PVJl8BImHE1tZW0DTNOhRiWAoREREeAZCAjoVOBn6dVhCzrUAYB2QLBxA3TWI//kn+rd3PkpoDSfe1PGUfzJ07F2q1GoWFhUhNTcXixYtRXV3Ne/3ChQtRWlrKBgfPnDmDJ554gjN/QNM0Zs2ahSNHjmDWrFm4desWgoKCEB0dzQlh8vX1xZgxY/DBBx8gMzMTn376KaZNm4ba2lpO9kGPHj3QpUsXnDp1ClOmTMG7776L5cuX4+TJk/j8889drie5gzt37qBnz544cuQIZs6cyeseaLVaVFZWonfv3mAYBtevX8eAAQN4nQ/75qCmpgbdu3eHr68vL/OAFIaePXuisLAQo0aNQm1trVuoEykMycnJvLkDUgg6d+4MhmHYJkSoOQgLC2Nte29vb3Tq1EmwOejZsycaGhqgVqtFJ+Lt7XFP1JGcAxIWFVu0yd/A/nMTExi1H//0hEPRUSU1B5Lua3nKPlCr1ViyZAn+8Y9/YPr06bBarVi6dCnv2CFxD15//XVkZ2fj5MmTGDRoEDp37syZP5g4cSLUajVOnDiB6dOn47XXXsPLL7+MoqIi5OTkuLz+5MmT2aBbTEwM9uzZg8WLF3OyDyiKgk6nw7FjxzBjxgxUV1ejqakJycnJePnll12aD5I7+PrrrzFlyhTk5+djypQpvO5Bz549AYAtxEeOHEFGRgbOnTvHyYcgzcFDDz0EhmFw/vx5jBs3jpd5YO8c1NTUIDQ0FKGhoW63FkhhSE5O5s0dcBUG4lBw/W0rKipcijb5dpmqSwAAxCRJREFUfZxlMplw6dIldjuK3MP+vnySmgNb+NNkMoku2uRvIDkH9yapOZB038tT9sHUqVPRo0cP5ObmYvPmzThy5Igg4Y+4B3V1dRg7diw2btyIbdu2ceYPfHx8MG3aNLz33nt49tlnQdM0jhw5gszMTOTm5rocP5ycnIzw8HDs378fCxcuRH5+Ph555BHEx8dzsg90Oh2qqqpQX1+PESNG4M0338Tq1atRXFzMOblBLP8//OEPAIB//etfvO5BVFQUVCoVu7Vw+vRp9O/fH5GRkZxjjZGRkdDr9WhtbcWDDz6I06dPY8qUKbzMA/uiDQCXLl2CTqfD0aNHBVG3pDAkJCTw5g7q6+shl8uhVCod7lNXV8c5AULsfuffhyv0VlJSAoPBAK1W6xCsI/flE2Ec3E1z0JG2FeyZDWKdA4IXJwoNDUVtba0g60ByDhwlNQeSJMEz9gEJMZ47dw5WqxWTJk3CypUrcePGDc7riXuQk5OD1atXw2Aw4MCBA8jOzubMH8yYMQPNzc349NNPkZmZiXfffRepqano3bs35s2b57D9QZgHhw8fRmpqKmJiYrB9+3Zs3ryZk33Qr18/BAYG4ujRo8jIyMClS5fQ1NSEyZMnY+vWrS5fiCR3YDKZMGLECOzbtw/PPfccp3tA0zQSExNRUFCAUaNGwWw248SJE0hPT8fhw4ddkvyk6NnnDpKSkniZB+QLOyIiAhqNhm1CysvLBZu6kJAQlhfAlzsgRZsEF+vr61knhGtrgatoR0REcK5OyfPtnQOFQsGe4Mkn8p7vd+fAntkg1jlw/sxIAFRoYsG+CRE7FdGRJTUHkiTBc/bBkCFDMGzYMGRnZ2PVqlVQq9XIzMzkbSyIe/DVV19h+fLl+Pvf/47u3btj/PjxLvmDsLAwjBkzBnl5eXj66acRFRWFV155Bbm5ubhx4wbWr1/v8NqTJk1CY2Mj8vPzWfdALpdj+vTpLuwDmUyG1NRUHD16FCkpKYiPj0deXh6WLl2K1tZW5ObmOrw2yR2cOXMGU6ZMwcWLF1FZWcnrHpA8QGhoKPr27YujR49i6tSpUCgU2LVrl8O1zs1BTU0Nrl27hilTpnAyD0jRpiiKzQOQUy2PHDnC+7eyLwx8uQP7YkoKUGhoKAICAlxIiYRxwLWtwMU6KCgoQHh4OPz9/R3u424VzLV3LlYd1TkgRVvIKRJqDoS2Furr69mzOMRMRXR0Sc2BJEn/vzxlH6xevRoVFRXYv38/cnJycOrUKfztb3/jvNbePfif//kfPPTQQ1i6dCnWr1/PmT/IyMhAaWkpTp48iZUrV+LEiRO4fv06Vq1ahZ07d+LkyZPstYR5sG/fPjzxxBOIiYnBn//8ZyxfvpyTfZCWlobi4mIUFxcjIyMDx48fh16vx5w5c5CXl4eysjL2WvvcwdChQxEUFIT333+f1z3QarUoLi5Ga2srdDodTpw4AS8vL0ydOhW7d+92QDaTL/uKigokJSWxRytPnDiRk3lgv2okeQCGYTB8+HDB3IF9YeDLHdgXU64mxF5k9cnVHHCxDgoLC9mtEDKS5/z7cOlemoOO6ByQbQWj0Sh4iBZXcxAYGAiGYdw6B8Q9krYVpOZAkiQHecI+iIuLw7Rp05CTk4PExESkp6cjOzubF5xD3IMPP/wQmzdvRnFxMd555x3k5eW55A+SkpLw0EMPIS8vD2lpaejfvz/Wrl2LadOmISUlBQsWLHD48poyZQpOnjyJyspK1j0oKSnB2rVrXdgHgwYNglKpxNGjRzFhwgT4+/tj586deP755xEYGIhXXnnF4X0Ty59hGPzxj3/EgQMHoFarOd0DrVYLi8WCoqIi6HQ6tLS04OTJk0hPT0dtbS0OHjzo8NrEivfx8WFzB+Hh4ZzMA/uVtlarRWlpKZqamqDT6VBYWMi7KgwKCoJcLhfMHXA5B8CvToi9+Iq2vRNCZLVaUVBQwG5R2B8g5M66JowDT4u8yWRCc3Nzh3MO7IOcfJ+bM+OAiKZphIeHu3UOnBvE+1lScyBJkp08ZR8sWrQIVqsV27Ztw4oVKxAREcE5dgg4ugdxcXF49tln8Ze//AU+Pj6c+YOMjAycOnUKRUVFyMrKwpUrV7Bv3z7k5OSgubnZwREgzIP9+/c7uAdjx451YR94e3tj6NChOHr0KLy9vTF9+nTs3bsXZrMZy5cvx0cffeQwHkhyB1VVVZgyZQqqq6vxxRdfcLoH8fHxkMlkKCwsRLdu3RATE4OjR48iOjoaI0eORF5enoMlbJ/wJ02I1WrFlClTXJgHGo0GBoMBBoMBPXv2hNVqRVFREYYOHQqGYXh5CjKZDOHh4aioqABN05y5A77CoNVqUVZW5tCIEcaB83kHJKBoX4CqqqpQU1PDOgfO2wrunIO7YRwQcmdHcg4YhoGXl5fbY5u5GAdEfNMkRFwNotD2RUeX1BxIkuQkT9gHnTp1YsFGN27cQG5uLgoKCrB9+3bO64l78I9//AMLFy5EcHAwli1bhieffNIlfzB69GiEhobizTffRJ8+fTBx4kRs3rwZarUa2dnZ2L9/P2u9E+bBvn37QNM06x78+OOPeOWVV1zYBzqdDufPn0dlZSWeeeYZ6PV67N27FxMnTkSvXr2QlZXF5ifscwcJCQno2bMn9u3bh8DAQBf3wNvbG926dUNhYSE7Onn8+HGYzWZkZGSgqKjI4VwK5+agpqYGP/30E9LS0lyYB/aFIS4uDgzDoKCgAL6+vhg8eLDg1oLzfZxzB3zOASnq9oFHZ8YBkVKpdGEd2IcRAccmRMy2wt3mDcjrdwQRt4XY/eRnXBLainHXHNhv+fj5+cFsNqOlpeVe3367ldQcSJLkJE/ZB+np6QgLC8O6devQt29fzJ8/Hzk5OZyz/fbugUKhwIYNG/Dll1+yWw32+QOGYTBz5kwcOHAANTU1WLZsGZqbm7F9+3b88Y9/xOjRo7FkyRI2H0GYB999952DexAVFeXCPhgxYgRkMhmOHTuGkJAQjBs3Dm+99RasVivWrFmDCxcusC6Gfe4AAMs8uHPnDqd7QPIAgC3fUF1dzR4+lZCQ4ABFIl/YVqvVIXegVCpdmAf2hYFhGHTv3p0tvjqdDmfOnEFtbS3n38h+koArd8BVtK1WK2JjY6FQKBy2FrgYB86/D1FhYSHUajV7RLVer/cokHi3eQPy+h1Bzm4LwL+twMU4IBLjHNj/GyA/u18lNQeSJHHIE/aBl5cXXnrpJeTn5+PkyZOYP38+EhISMG/ePIcAHpG9ezB8+HCMHTsWa9asgclkcskfPPXUU6BpGu+88w7CwsLw/PPPY8eOHaioqMCmTZsgk8nw4osvwmq1ssyDffv2QSaTse7BDz/8gIyMDAf2gb+/PwYOHMiutjMyMnD9+nXk5+cjOTkZOp0O69evZ98/sfwBsMyDQ4cOcboHWq0Wly9fhtlsRt++fREcHIyjR4+CoijMnj2bzUMAv7IOampqHHIHAFyYB877zfZ5gJEjR8JqtSI/P5/zb2RfGLhyB84FyGQyobW1FQzDoEePHg4TC1yMA/v72IfeSBiRoiiXoi3kHNwL48A+3d8R5Ny4AcLOgTPjgCgyMlKQdeDsHpF736+SmgNJknjkCftg7NixSEpKQlZWFmiaxvbt21FWVoaNGze6XGvvHphMJqxduxYGgwHr169HYmKiQ/4gICAAkyZNwttvvw2j0Yg5c+bA398fr7zyCoKCgrB161bk5+ez2wmEedDa2urgHjAM48I+0Ol0+Oqrr9DQ0IA+ffrg4YcfZlf1q1atQlVVFXbs2AHAMXcQGBjIMg8AuLgHPXv2REtLC8rKykDTNEaNGoUjR47AarVi/PjxCAoKYqFIziE++9xBv379HJgHzvvNpAkxmUzo3LkzkpKSeLcWIiMjUVNTg5aWFpfcgT2eF3AtQM4TC0JF25l1UFBQ4JA3sH99IefgXhgH9lyAjiD7v41SqYRcLhd0DoRcHYCfdeCcOyH3vl8lNQeSJPHIE/YBRVHIysrC5cuX8f777yMuLg4rVqzAjh07HPbYiezdg5CQEJZ9cO7cOTz11FMO+YP09HRUVVXh8OHDUKlUWLZsGT788EN89913SE1NxdSpU7Fq1Spcv36dZR4cPXrUxT1ISkpyYB+MGjUKRqORDV5mZGTg9OnTKCgoQNeuXTFjxgxs374dVVVVDrkDACzz4PLlyy7uQWJiIgCwq22dTofS0lJcvXoVXl5eePrpp7Fv3z40NDRwNgckd0BRlAPzgKtoGwwG/Pzzz+x9vvjiC86ciHNhsM8d6PV6GI1Gl8Jg71AUFRXBaDTyMg7s70NYB83NzSgpKWEnFZyLtkajQWNjI2fjea9jjAA8Psnx9yr7ou1uzFBMc8C3tSA5B46SmgNJkgTkCfsgKSkJ48ePx6ZNm9DU1IRZs2Zh4MCBWLBgAZsgJ3J2D/70pz/hoYcewpIlS2AymRzyB126dMFjjz2GHTt2sETGxMRE9jTFl19+GQEBAViwYAGioqJY5gEAB/cAgAP7IDw8HL169WIBQjqdDuHh4eyqPjMzE3K5HFu2bHHJHdgzDwBH9yAoKAihoaHsajslJQUqlYpd1U+fPh1GoxHvvfeeA+uAfIYkdwDAgXmgUqlA07TDJAHwa+gvLS0Ner0eX375pcvfhqsJIbkD5xU9VxNiNBpx7do1XsaB/X0I66CoqAhWq5XXOdBoNLBYLGhubnZ5nXsFIPn6+roEJturnJkNQiOgQs0BOVRLcg7ESWoOJElyI0/YBytWrEBdXR1ee+010DSNnJwc1NfXY/Xq1S7X2rsHMpmMZR+8/vrr8PX1dcgfZGRk4OLFi/jmm28gk8mQlZWF7777Dh999BHUajVeffVVnD17Fnl5eSzz4ObNmy7ugUajcWAf6HQ6fP7552hra4NcLsfMmTNx8OBBVFVVwd/fH4sWLcKePXtw+fJlh9yBPfPAaDS6uAf2eQCFQuEAKurcuTPGjx+PnTt3wmQyOVjxzrkDe+aB86rRz88PERER7H26du2KuLg4zq2FkJAQlnUAOOYOnFf0zs5BQkICADiwFMSsTgsKCiCXyxEXF+fwes7hOq4CdLeMA/J6HSVvADhOEQD8I6B8jAMiIdaBwWBAW1sbex8vLy8oFAqpOZAkSRK/PGEfRERE4Nlnn8Xrr7+OmzdvIjIyEuvWrcO+fftc5vCd3YPExESWfVBaWuqQP6irq0O3bt3YTEBKSgpGjhyJ7OxsGAwGDBw4ELNnz8aGDRsQFxfHMg8AV/fAnn0waNAgNDU1sVsfTz75JBiGwTvvvAMAePrpp9GlSxdkZWVh4MCBbO4AgAPzAHB0D5z36XU6HX744QfcvHkTADBr1ixUVFTg2LFjLily+9wBuQ9hHjjv09tPRpD7HD9+3AVhbM86AOCQO3DnHKjVakRHR7PNARfjwP7vD9iag8LCQnTv3h0KhYJ9PZqmoVKpOO9jr7tlHAAdC50MOE4RAPxBTiHGARHfxALX+Of9DkKSmgNJkkTIE/bB3LlzoVarsWHDBgC2EcPU1FQsXrwY1dXVDtfauwfkvxP2gdVqZfMHS5YswRNPPIEjR46wX26rV6/GrVu32G2AZcuWITo6GsuWLYNOp8O+fftgtVpd3AOKolj2wUcffYQuXbqwq20/Pz9MmTIFu3btYscpV69ejZMnT7IFl+QO7JkHABzcg6ioKFRWVuL27dsAgGHDhjmAinr16oUBAwYgLy+PszkguQMADswD58JAHArSSOh0OtTW1jpAnIi47vPtt9+y75EUIG9vbzAM49KEkOaAi3FAZM86KCwsZPMGgK3IqdVq0DTtcD+uAnS3kwrkPh3FOXAOiwL8RVvMVgxfc8A1/nm/I5Sl5kCSJBHyhH2gVquxZMkSHDhwAN9//z0oisKWLVtgtVqxdOlSB+qas3vg4+PDsg8OHToEiqLY/MHHH38MlUrFnt8QGxuL6dOn49VXX0V1dTW8vLyQm5vL7nUT5gHg6h4Q9sFbb72Fvn374tixY2wwLj09HdXV1Th06BAAIDU1FcnJycjNzUXXrl0dRgDtmQfAr+4BYQhcunQJgO2LNjk52cHyz8jIwLlz5wCAZR0ArrkDe+aB836zVqtFTU0N62b07t0boaGhnFsLzpMEJHdAeBSkAHGF3ohDIaZoR0ZGoqysDJcuXWLzBoDrit6dcyA1B7ZDrkwmk6iiLcQ4IJKcA/GSmgNJkkTKE/bB1KlT0aNHDzY0GBwcjC1btuDIkSMO1D/A1T2wZx/U1dWx+YOSkhKEhITgvffeY2e1Fy1aBJqmWfph7969kZmZiY8++gj+/v7sqt7ZPQDAsg8uXLiAyspKtqDHxMRgxIgRLOqYoiisWbMGxcXFLnwAe+YB8Kt7cPDgQXh7e7tsLZw+fZr9wk1NTUVkZCS+//57lnUAuOYOgF+ZB3q93qVoA79ORtA0DZ1Oh6NHj7qgb50LA8kd/PDDD5DL5VAqlexjXM1BXV0drl27Jlh8yH2uXr0Kg8Hg0BxwBesAV+fgXhgH5PU6yrYCF7NByDngYxwQ8bEOJOfAVVJzIEmSBxLLPiABxnPnzuGTTz4BYLPHJ02ahJUrV+LGjRvstc7uAQAH9gEANn9w9epVVFdX44MPPgBgy0NkZmbi3XffxZUrVwAAL7zwAnr37o3W1lYcOnSI3QZxdg8I++D69eugadplVX/p0iW2QPfq1QuTJ09GYWEhrl69yq7UnZkHwK/ugbe3t0MeYNSoUTCZTPjss88A2BqW9PR0fPvttzCbzYK5A8I8qKiocPjCjoiIgEajcWlCysvL2RFHInvWAfBr7qCoqIg9jY/IuQCR7YGff/7ZbdGOiIhg7y3kHCgUCnh7e7sUoHthHAAdyzngYjYIOQdiXB3AlXXA1YS4Oxiro0tqDiRJ8kCesA+GDBmCYcOGITs7G21tbQCAdevWQa1WIzMz06G5cHYPnNkHgI2WOGHCBBiNRmzfvp19/owZMxAVFYW1a9cCsDUmubm5MJlMuHXrFlv0udwDwj5oaWnB4cOH2feTkpKC+Ph4B9Tx0qVLQVEUmpub2dwB4Mg8AH51D27duoXvv/+evS40NBR9+/Z1aEKmTp0KpVKJ1tZWwdwBYR6UlZU5nALJdazywIEDodFocOrUKYe/B1dhSE5ORmlpqctq07kAhYaGwt/fHzU1NaIKUGVlJcLCwuDv78/+nKtoc62C72WMEej4zgEp2s7OkCfNgfPWQn19PWQyGXx8fNifuTsYq6NLag4kSfJQnrAPVq9ejYqKCuzcuROA7YstJycHp06dYrMDALd7YM8+MBqNbP6AJOcJn0ChUGDlypU4ceIEO00RGxuLl19+GSaTCf/7v//L3sfZPQBs7IPAwEBcvHiRPW6aoihkZGTg+PHj7MmIoaGh7ImT5N6AK/MAsLkH5EwC+wAnGZ0khx5pNBo8+eSTMBgMLFIZcM0dADbmgdlsdln1OU8sMAyD4cOHu8CnuApDcnIy+9nay7loUxSF6OhomEwmUQXIYDCga9euDj93Hskjv79zAbrX5qAjOgfO2wpGo9Hh4CxAXHPAxzogn5n9vwNpW0GSJEkeSyz7IC4uDtOmTUNOTg674k1JSUF6ejqys7PZYgy4ugfO7APARr3bs2cPZDIZFi1axD43LS0N/fv3x9q1a9nm4plnnkGfPn1w8uRJdsuByz3QaDTYtGkT2traHMKWEyZMgL+/P9vYAMDzzz8PPz8/NmMAuDIPAJt7MGnSJDQ3N+Ps2bPstTqdDi0tLTh58iT7s/T0dFAUhc8//5z9GVfuIDw8HPHx8S4TH1qtFqWlpQ77yDqdDsXFxTCbzezPnFkHgC13wDCMywQKV2Ho3LmzqOYgIiICJpMJoaGhDj93Hskj93F2Du6FcUDIjB3NOeAKctp/bu4YB0R8rAMut0UKJEqSJMljecI+WLRoEaxWK7Zt28b+bMWKFYiIiGBX4gC3e+DMPrD/2U8//cS6AgTffOXKFezZswcA2AObAGD27Nnsvbncgz/+8Y+Ijo7Gu+++yxZZb29vTJ8+HXv37mUJjz4+Ppg+fTqqqqocuA3OzAPA5kgAwGuvvcb+rFu3boiJiXHYWoiOjkZERATOnj3rYBU75w4A21aNXq9nmx3AlgewWq0oKipifzZ06FDI5XKH1aUz64B8Rv7+/i6NAFdh8PX1hdlsdgguckmhUMBisUCtVjv8nG9bgcs5uFvGAfk7dSTngGEYeHl5sT/jgkeJYRwQcU0scP1t7E/nvB8lNQeSJN2lxLIPOnXqhPnz52P37t2sU6BUKpGbm4uCggJs376dvdbZPSA/s2cfAMCmTZsQGBiIVatWsXZ8nz59MHHiRGzevJktEt27d8eIESNw+vRpfPzxxwC43QOKorBo0SI0NzcjKyuLvfczzzwDvV6PvXv3OrwfuVyOl156ic09ODMPACAsLAxRUVH49NNPWdeEoigWVGS/qh80aBBqa2sdtgKccweArTmgKIptgACbO8MwjMPWgq+vL5KSklysZ67C4Ovri5qaGodruZwDmUwGmUzm8H649PPPP4OmachkMoefc61O+bYV7iVvQF63I4i4Lc52P3mMyJOtGK5/A1xbPn5+fjCbzWyA9X6T1BxIknSX8oR9kJ6ejrCwMKxbt479Wd++fTF//nzk5OSwRZrLPXBmHwC21emyZcvQ2tqKZ555hi1sy5YtQ3Nzs0PDsXz5csjlcsybN4/NSHC5B//zP/8DtVqNnTt34uLFiwBsVvy4cePw1ltvscX8gQceQI8ePXDlyhV8+OGH7POdmQeADX5kMBjYExsB2xZIdXU1zp8/z/5s4MCBoGnaIQDJlTsIDg6Gt7c3Dh48yDYmDMOge/fuDqFEAHj00UfR1tbmMt3gXBjkcrkDmwHgXjW2tLSAYRiX+zirsLAQXl5eDudptLW1Qa/Xiw4k3kvegLxuRxCf2wI4biuIYRwQ8TkHXI0beex+lNQcSJJ0DxLLPvDy8sJLL72E/Px8h/32+fPnIyEhAfPmzYNerwfA7R44sw8AYObMmejUqRMuXrzIZh/CwsLw/PPPY8eOHewX4KOPPor4+Hg0NjbixRdf5KQmAoC/vz+GDx8OhUKBF198kW0GMjIycP36deTn57PvR6fTQaVSYf369ez7dmYeALYC7+3tzZ65ANiaouDgYIethaioKHh7e+PYsWOsE8KVO9BoNPD29sbNmzcdfm5/lgMROUnS/jquwmA0GqFUKh2aED8/P5hMJgdH6ObNmwgODnZwKLhUWFiI4OBgh3FVvqLt7BzcK+OAK93fnsXntgCuzoE7xgERF+uAb1uBvIf7UVJzIEnSPUos+2Ds2LFISkpCVlYWW3gZhsH27dtRVlaGjRs3AuB2DwBX9kFAQACeeuopqNVq7N69m13Fz5kzB/7+/njllVcA2PbVn3zySXh5eeH48eO8JzYCwOjRo0FRFH788Ue8/fbbAGzbFQ8//LDDqj45ORkWiwW3bt3Cjh07AHAzD3r27AmGYdDW1sa6BzRNY9SoUThy5Ai7Mo+MjIS3tzfUajWLgyb3sc8d+Pn5gWEYhISEOExHaLVaXL582eHzCgoKAsMwDlsVzqwDq9WKxsZGdO/e3aUJAVwLEJkUEVJBQQG6dOni0ITwFW1n5+BeGQdcXID2LK6irVQqIZfLXZwDsZ8Z10grXyCRvIf7UVJzIEnSPUos+4CEBi9fvuxQ2OLi4rBixQrs2LGDLWRc7gEX+yA9PR1tbW3o3bs3Fi9ejJKSEqhUKixbtgwffvghi0+eNGkSLBYLHn74YaxatQrXr1/ndA9GjRoFiqKQnJyMjRs34pdffgFgcw9Onz7NrpoHDBgAuVyOlJQUbN++3eEwJnvmQWJiImiaxuDBgx3cA51Oh9LSUly9ehWA7Quboij2BEbyheycOyDjZgMHDsTHH3/Mrv60Wi0MBoML+MjLywvffPMN6wA4Fwa9Xg+j0YhevXrh22+/ZbdnnK3r1tZWVFdXIzExEUVFRWyI1FnNzc0oKSlBYmIibt68yTYrfEVbo9GgsbGRbSp/izFGAKJW0O1BXEWbC299N82Bc/MmOQeOkpoDSZJ+A4llHyQlJWH8+PHYtGmTg605a9YsDBw4EAsWLEBjYyOve+DMPoiLi8PQoUNhNBrRuXNnZGRkwGAwYNKkSUhMTGTxzdHR0ejfvz8YhkFAQAAWLFgAi8Xi4h6Eh4ejV69e0Gg0UKlUWLlyJQBbMQ8PD2dX9SEhIYiNjUVoaCjkcjm2bNkCwJV5EBQUhNDQUERHR7MnNgK2cU6VSsVuLWg0Gmg0GvTo0QNGoxHvvfce+3nZ5w5UKhVomkbPnj2h1+vxz3/+E8CvJELnVb2Xlxfa2trw5ZdfAnAtDKTAkPAiyR04OwekmUhKSoLRaHQYQbUXOdciKSkJJpMJlZWVDq/DVYAsFguam5sd3te9OAe+vr68B0O1N/ExG5xHQD1pDrhYB5Jz4CqpOZAk6TeSWPbBihUrUFdX5zDiR9M0cnJyUF9fj9WrVwPgdg+42AcZGRm4fPkyXnjhBVy7dg1r1qyBTCZDVlYWvvvuO3z00UcAfj36eOXKlTh79izy8vI43QOdTodTp05h1apVOHLkCI4dOwa5XM6emUCan+TkZJw/fx6LFi3Cnj17cPnyZU7mQc+ePVFSUsKe2Hjnzh0oFAoMHz7cIXcQERGBuro6jB8/Hjt37mQPorLPHZBVI3EtyBaGn58fIiIiXJoDuVzucOqkM+uAFJhevXo5nBvh7ByQ61NSUgC4NiFEBQUFkMvlbN7B+T584Tr7JuRuGQfkdTpK3gDgniIAHEdAxTIOiJxZBwaDAW1tbS738fLygkKhkJoDSZIk3ZvEsg8iIiLw7LPP4vXXX8fNmzfZn0dGRmLdunXYt28fjh07xuseOLMPhgwZgm7duuGzzz5DdnY2mz9ISUnByJEjkZ2dDYPBgMcffxze3t4oLS3F7NmzsWHDBly5csXFPdDpdGhqakJAQACGDRuGFStWoKmpCU8++SQYhmHZCcnJybh27RrS0tLQpUsX1qVwZh4QvDE5c4G4BzqdDj/88AP7GZCw4KxZs1BRUcFyFLhyB/X19WyzQ/gPzqREokcffRTHjx+HyWRyYR2QL35/f38MGDCAbUKcnYPy8nLI5XLExsYK5g4KCwvRvXt3xMTEsM8jr0PTNFQqlcP1XPe5W8YB0LHQyQD3FAHgGOT0hHFAZB9MFRr/vJ9BSFJzIEnSbyix7IO5c+dCrVZjw4YNDj+fPHkyUlNTsXjxYlRXV3O6B4Aj+4CiKMyaNQtHjhzB4MGDMX78eDZ/sHr1aty6dQtvvvkmfH19MWbMGOzbtw9Lly5FdHQ0XnjhBVgsFgf3oEePHujSpQuOHTuGV155BbW1tdi6dSv8/PwwZcoU7Nq1CwaDgV0df/fdd1i9ejVOnjyJzz//3IV5oNVqUVlZCbPZ7OAeDBs2DAzDsE0A+cLu1asXBgwYwAYguXIHDQ0NSEtLg6+vL3vKJZlYcIbWPProo6itrcU333zjcB/AMQuQnJzM5g68vb3BMIyDcxAWFga5XO5yloO9CgsL0bNnTyiVSnTq1MmhOVCr1aBpx69cLofibrcUyH06inNgtVp5fx/7on03WzH2/waExj/vZ4Sy1BxIkvQbSiz7QK1WY8mSJThw4IDD4UQURWHLli2wWq1YunQpEhMTOd0DZ/bBxIkToVar8fbbb2Pz5s1s/iAiIgLTp0/Hq6++iurqakyePBklJSUoKChAbm4uioqKkJOT4+AeEFDRsWPHEBERgcWLF+PNN9/ExYsXkZ6ejurqahw6dIjNHXz99ddITU1FcnIyXn75ZRiNRgfmATnR8NKlSw7ugUajQXJyMmv5ky9sq9WKjIwMnDt3Dj/88INL7oAUBqVSiXHjxuH999+HxWKBVqtFTU2NS+YjLi4OoaGh7H3sWQf2WYDk5GQ2d+AcequoqGCLD3EonJsQk8mES5cusfkH5yaEr/jYvw+pOfhVra2tMJlMbou2J4wDIsk5cC+pOZAk6TeWWPbB1KlT0aNHD9aOJwoODsaWLVtw5MgR7N+/n9c9sGcftLW1Ydq0aWyQLy8vj80fLFq0CDRNY+vWrUhOTkZ4eDj27duH3r17IzMzE7m5ufjhhx8c3AOdToeqqipcuHABGRkZiI+Px4svvoguXbpgxIgRyMvLg9VqZS1/iqKwZs0aFBcX4+9//7sD8yAqKgoqlQqFhYXsiY3EPdDpdDh9+jTq6+sRGRkJvV6PmpoapKamIjIyEm+++aZL7sC+MEyZMgUVFRU4ffo0W5SdtxZomoZOp8PRo0dhtVpdCoNcLodSqURCQoJD7sC5AJHio9VqUVdXx05yEJWUlMBgMDg0B/bbF3zBOvI+7pVxQF6no2wrCDEbnJ0DsYwDInvWgeQccEtqDiRJ+jdIDPuAhBfPnTuHTz75xOGxtLQ0TJo0CStXroS/vz+newA4sg9mzJiB5uZmfPDBB0hMTGTzB19++SUyMzPx7rvv4qeffsLkyZNx+PBhtLa24oUXXkDv3r0xb948pKamsu5Bv379EBgYiKNHj4JhGGzevBkXL17E22+/jYyMDFy6dAmnT59mcwdVVVXo1asXJk+ejK1bt0Iul7PMA5qmkZiYyBZte/dg1KhRMJlM+OyzzxwmCWQyGdLT03H48GFUVlY65A7sv7D79euH6OhovP/++4iIiIBGo+G0/HU6HcrLy3H58mUH1oH9aXw0TTvkDpwLEHl/xAlxvg/576Q5sHco+Iq2QqGAt7c3Ghoa7plxAHQs50CI2eDcuHn6mdmPtAo1IVwHY90vkpoDSZL+DRLLPhgyZAiGDRuG7OxstLW1OTy2bt06qNVqZGZmYsGCBZzugT37oKKiAmPGjEFeXh4sFgueeuopNn/w2GOPISoqCmvXrsWkSZPQ2NiIo0ePQi6XIzc3Fzdu3MDGjRtZ96CgoACpqamsFZ+UlITp06dj48aNiI2NRXx8PPLy8tjcwZkzZwAAS5cuRWtrK3Jzcx2YB/YEQ3v3QKFQoG/fvjh69KjLmOHUqVOhUCiwa9cuh9yBfdGmKApTpkzBxx9/jObmZt48wMCBA6HRaHDkyBGXwmBfFOxzB6QAEcYBeV5oaCgCAgJcHIqCggKEh4fD398fgK0AEdaBUNEmv8+9jjEC949zQIr23bot9v/W6uvrIZPJ4OPj43Id18FY94uk5kCSpH+TxLIPVq9ejYqKCoejkQHbF2BOTg5OnTqFc+fO8boH9uyDGTNmoLS0FJ999hkoimLzB//v//0/LF26FCdOnEBJSQn69+/PBgZjY2OxatUq7Ny5E4GBgax7kJaWhuLiYnamf/ny5VCpVFi1ahUyMjJw/PhxtLa2srkDwFY458yZg7y8PMTExLDMA61Wi+LiYjakae8e6HQ6fP755/Dy8oJGo2GteI1Gg6lTp2L37t3QarVs7sDZ6p04cSLLPOCbWGAYhh2ddC4M9sXUPndAijZ5P+R5FEVxNiGFhYWsa0CuJ6wDvpE88ns2NDT8Js1BR3QO+LYVjEYjDAbDXTUH9qwDe/fIWdK2giRJkv4tEsM+iIuLw7Rp05CTk+NwaBFgm6tPT09HdnY2Jk6cyOke2LMPzp49i4ceeohN+vv6+rL5g6+//hr9+/fH2rVrMXHiRJw8eZIdI3zmmWeQkpKCRYsW4bnnnkN+fj78/PygVCodQEVr167FkSNHoFar4e/vj507d7KWP9Hzzz+PwMBAbNmyhWUexMXFwWKxsMcq27sHAwYMQEtLC06ePOlyMFJ6ejpqa2tx7NgxNnfgHBILDw9nmQdarRalpaUsVMheOp0OhYWFaGtrY1kHzsXUPncgVLSdz3KwWq0oKChgtxzsryf34VvRk1XwvTIOTCYTmpubO5xzIBTkrK2t9YhxQGTPOhByW6RAoiRJkv4tEss+WLRoEaxWK7Zt2+by2IoVKxAREYHc3FyMGjWK0z2wZx+MGzcOp06dckAYZ2dn45133sGQIUNw5coVtLS0wNvbmx0DJBCm5uZmnD17FjExMfjrX/+KoUOHOoCKxo4di2HDhiErKwtTpkzB3r170bdvXzZ3ANgmKZYvX46PPvoIiYmJqK6uRmVlJWQymUNBJe5Bfn4+YmJi2FW9fXMQHR2NkSNHIi8vDwMHDsTXX38NtVoNg8HgcMQyYR4EBATAarWyTYi9hg4dCoZh8Omnn7KsA+fCYJ87sLf75XI5QkJC2Ou0Wi3KyspYyuWdO3dQU1Pj4ByQACNXE2IvYl3fK+OAnALZkZwDhmHg5eXl8hj5m5WUlHjMOCAi/9aE/jZcp3PeL5KaA0mS/s0Swz7o1KkT5s+fj927d7ugeZVKJXJzc1FQUIDg4GBO9wD4lX3w6aefIiQkxOEAI5I/+Otf/4qRI0ciNzcXI0eOxL59+9gvvrCwMGRnZ+PAgQMYMmQI8vPz0aNHD5w/f57FAFMUxbIPGhoaoNfr2dMHSe4AsFn9vXr1wq5du6DVanHw4EF069bNoTkg7sHf/vY3DB48GMePH3cg1xFlZGSgqKgIarUaNTU1bEG2t3sJ8+DChQtgGIZza8HX1xeDBw92aEK4CgPJHfj4+LBFmzAOiEgTQM5yIH8z++bAnnUgtDq1dyjuNW9AXq8jiLgtfHY/8OvnfjefG/k3ILTl4+fnB7PZzB7UdT9Jag4kSfo3Syz7ID09HWFhYVi3bp3LY3379sX8+fOxd+9ePPLII5zuAWEfnDp1Cv369cOBAwdQU1PDvgeSP/j555/R1NQEi8WCkpIS9nAmwNbIjB49GocOHUJERAS+++47yGQyFlQE2I5XXrx4Mfbu3YtHH30UH3zwAWJiYhy2Fmiaxpo1a3DhwgXExcUhPz8fsbGxLkWbuAcNDQ2orq5mA2b2K7Xk5GQkJCTg66+/BsMwbEG2bw4I8+DAgQMuTYi9dDodzpw5I1i0Se6ANEBcRTs2NhYKhQLFxcUAgOLiYqjVapfrIiMjUVpaCr1eLyqQeK95A/J6HUHu3BYA7PHe9+ocCDVu5L3cb5KaA0mS/gMSwz7w8vLCSy+9hPz8fJw8edLl8fnz5yMhIQE3btxASUkJp3tA2Adk7I+gjoFf8wfk6OHjx48jODjY4YhliqKwadMmyGQyqFQqfPHFF0hISHDYWgDAsg+uX7+OsrIyPPDAAw7NAWArsjqdDl999RWsVisMBgMuX77MHlcN/OoeHDt2DAEBASgvL2dZB/bvafbs2Thx4gS6d++OK1euAHA9LY8wD4KCgnibg5EjR8JqtaK5uZnXOSC5g4qKCphMJpSVlbkUH4Zh0KNHD3bleu3aNWi1WpdVLmkOAP6i/Vs5B0Lp/vYod24LAFy/ft1jxgERYR3cuXNHcFuBvJf7TVJzIEnSf0hi2Adjx45FUlISsrKyHIooYCtI27dvx+3btxEaGsrpHgA29oHJZEJISAjefvtth+OFSf6gqKgIFEXBx8eHZR4QBQUFYevWrbhy5Qo0Gg2am5vx1VdfOayeCPugtLQUISEhqKiocMgdEK1atQp37txBWFgYm3UoKytzuIa4B0FBQfjxxx9Z98Be48ePR1BQECwWCy5evMi6DfYizIOamhpcunSJ87Pp3LkzkpKSUF5ejpqaGtTV1bkUBpI7IA5FWVkZZ9EmExjAr82Bs+wDlkKr4Dt37twz40CIC9AeJeQcKJVKyOVy3Lx5864/M/K827dvCwYSyXu53yQ1B5Ik/Yckhn1AURSysrJw+fJl9thje8XFxWHFihW4ceMGrl69yukeEPZBaWkpKioqcPjwYYfHn3rqKfzhD3+AXq/HTz/9hDt37rg4A6mpqZg6dSoaGhpw9epVtLS0uAQqCfugqqoK165dg9FodMgdAEDXrl0xY8YMlJeXo7S0FEaj0WVrgbgHP//8M3755ReYzWaX5sDLywtPP/00rl69ijt37sBsNrt8YRPmQVFREVpbW9kshLN0Oh2uXLkCi8UCg8HAWRgI3MlisaCmpoazAJHTJsmpgPaTCkSRkZG4desWrFar22kFQm+8W5HP425W0b9HCTkHBG9dWVl5z81BbW2t5BxwSGoOJEn6D0oM+yApKQnjx4/Hpk2b2PCdvWbNmoVBgwaBoihs27aNc4X8pz/9CY888ghkMhneeOMNhz18kj/o2rUrLBYLaJrG3r17XV7j5ZdfRkREBCwWC+RyOY4cOeJyzfLlyxEcHAzA1vw4by0AQGZmJtRqNaxWK+RyOafl/9xzz8HLywsmkwkURbFsAXtNnz4dNE3DaDTCaDRyfmFPnDiR3cIgq3pnpaWlwWw2w2AwwGw2cxaG5ORkGI1GtLW1wWKx8DoHJpMJBoMBVquV0zmIjIyE0WiExWIRLEBGo/Gem4P6+nr4+vo6BCfbs9wxGzQajQOcylMR1oFQ5kByDiRJkvQfkxj2wYoVK1BXV4fXXnvN5TEydkjOK+ByDwj7wGq14ty5c+yJhES+vr5488034eXlhfr6enz66acOx0cDtsOhcnNzAQB1dXU4cuSIC8VRo9Fg3bp1MBqNqKurY49ptpe/vz8WL14Mg8GA5uZmXLx40eWawMBApKenw2QywWg0ujgHgO3L/A9/+AOsVivntgJgYx4MGjQIAFymPoi6du2K+Ph4GI1GmM1mzsKQkJAAf39/tvBzFaCEhAQAQFtbG2QyGeLi4lyuiYyMhMVi4W1CAFsBslgs8PHxuae8QEcCIAEQnCIAbP/26urq7ro5oGkaYWFhLA2TS15eXlAoFFJzIEmSpH+/xLAPIiIi8Oyzz+L11193KdqArehs2rQJFosFWVlZnO5BYmIiXnjhBRgMBvz5z3/mfHzLli2gaRoNDQ2c7sHAgQMxd+5cWCwWVFZW4quvvnK5ZuzYsRg1ahTa2tpQWFjI6Yg8/fTT6NatG1pbW3H27FnO3/m5556Dj48PGhsb2dChs2bNmgWz2YzW1lbU1dVxXjNlyhQYDAb8+OOPnI8DNvfAZDLBZDJxFgaaptG/f38YjUZQFOXAOCBSq9UICwuD0WhEly5doFAoXK6JiIhgmxmVSsX5XjQaDcxmMzp37nzXjAOgY6GTAQiu6AFb4TabzXc1qUDUuXNnwcYNuH9BSFJzIEnSf0Fi2Adz586FWq3Ghg0bOB+fPHkyUlNT8dNPP+Htt9/mvGbRokUICwvD4cOHcf36dZfHSf7AbDbjL3/5CyfsZcWKFejWrRva2to470OOmfbx8UFzczPnpAXDMOzvUVFRgdu3b7tcExgYiIyMDFgsFt7C3qtXLzz44IPsFAGX0tLSWFeFD16j0+lgtVp5jwQGgEGDBrHNA59VHxsbC7PZjG7dunE+rlQq4ePjA7lcDprm/rols/RBQUGcj4tVR3IOiDMk9PvQNM275SNWwcHBsFgsgk3I/YpQlpoDSZL+CxLDPlCr1ViyZAkOHDiA77//nvM18vLy4OvrixUrVjhMJRD5+Phg+/btMBqNWLp0Kedr/N///R86deqEiooKzlyBl5cX3n33XdA0jQ8++IBz0iIqKoqlPP7v//4v5++TmpqKHj16oK2tDadOneK8ZsGCBWAYBtevX+ct7JmZmbBarbhw4QLn40qlEoMHD0Z9fb3LxAdR79694e3tzescAMCjjz4KwLZFwyeS24iNjeW9Rq1W8zYGwK/Owb2u+jtSc9Da2irYuAGAxWKB1Wq9J+fA399fcg54JDUHkiT9lySGfTB16lT06NEDWVlZnMUyODgYGzZsQE1NDZYsWcL5GmPGjMGDDz6If/zjH5xBP19fXxw6dAiAzbbnUt++faHT6dDa2oqNGzdyXkMOZjp16hTnNgdFUfjrX/8KANi8eTPnawQGBqJfv34wGo28xX/cuHFgGAY//fQT5+MAMGPGDFgsFuj1es7HCVvfYrHA29ub85qEhARQFMXZdBGR4iW06lcqlbyjq4CteTCbzVCr1bzXiFFH2lYQw2wwGo2gafqepjPUajUbuOWT5BxIkiTpPy537AMSXDx37hw++eQTztd47rnn0KNHD7zxxhu8Vvubb74Ji8WCjIwMzseTk5PRr18//PLLL8jJyeG85v333wdN03jllVc4t0IYhsHTTz8Nk8mERYsWcb7G4MGD4evri2+//Zb3C5c4HCtXruR8XCaTISoqCg0NDbh16xbnNaNHjwbDMA7nLzgrOjpa0IGgaRo0TXMe4kREGjYh9r5CoeBslojImQhKpZL3GjHqSM6BGGaDXq8XdHXEiORAhIo/GTW93yQ1B5Ik/Rclhn0wZMgQDBs2DNnZ2S7TAkQ7d+6E2WzG1KlTOZuMPn36ICUlBZ999pkLi4CIbB0sX76cxdLay8fHB0OGDEFzczPmzZvH+RqrVq0CTdPIy8vDL7/8wnnN8OHDYTKZsGrVKt7fVyaT4V//+pfLKZVE/fv35z2oCrAV9qioKBiNRl4ufnh4OADggw8+4HycNEBNTU28TQY5c4IrNEokk8lgMBh4G4Ty8nJQFAWGYXhfQ4zuN+eAjPney6FIJERaXV3New05GOt+k9QcSJL0X5YY9sHq1atRUVGBnTt3cj7ev39/jBw5Et99953DgUv22rx5M2iaxrPPPstplcfHxyMpKQkGgwETJ07kLIhLliyBTCbDu+++yxk8DA0NRdeuXWEwGLBgwQLO9zFhwgTQNI23336b0+nQaDQICAiAXq9ntyGc1atXL9A0jT179vBuHZAG4ssvv+R8nIQE8/PzOR+vqKiAXC6HxWLhdRd+/vlnyGQy3rFJ4NfiRRoJZ5WXl4Om6XteBXdE50Do96mvrwdFUYLukBjJZDJeYBZ5D1JzIEmSpP+K3LEP4uLiMG3aNOTk5PCupjdv3gwvLy+sXLmSs1g9/PDD6N+/P3766Se8/vrrnK+RmZkJhmFQWFjIubJ/7LHHEBQUBJPJhGeffZbzS/OJJ56AXC7HJ5984nBgE1GfPn2gVCqh1+uRnZ3N+T66d+8OuVyON954g/P3DQ4OBsMwqK2txcGDBzlfo3fv3gCAf/7zn5yPm0wmyOVy/Pzzz5xcBVK05XI5J9zJarXi2rVrkMvlvMAlADCbzaAoivMegK0JYRiGt8kRI5PJhObm5g7nHPD9PhaLBXV1daBp+p4s/8bGRnh5efH+bch7kLYVJEmS9F+RGPYBmQbgs9K1Wi0mTJgAvV6PuXPncroDCxcuZAFJ5EAge40dOxbBwcHsJMSHH37o8Li3tzfGjBkDlUqFGzducOYCBg8ezNq1y5Ytc6E8xsfHsyS/f/zjHy6AJsDWDKnVarS0tOD//u//XB7XaDRQKBRQKBTIy8vjtJa7desGiqLw448/cv6ujY2N0Gg0sFqtnE1MeXk55HI5VCoVTp8+7fJ4VVUV6urqwDAMfvnlF97VpcFgAE3TvAWovLwcvr6+bPbgbkSe25GcA4Zh4OXlxfl4VVUVzGYzZDLZPa3qGxoa4OvrK9gcEOfgXrYv2qOk5kCSpN+J3LEPOnXqhPnz52P37t28NvaSJUvg5eWFb7/9Ftu3b3d5fPTo0exs/rJly1y+8Hx9fTFhwgT4+fmBpmksXLjQJX8wevRoUBQFiqKwd+9el5X5gAED4OPjA4ZhUFFRga1btzo87u3tjYSEBAQHB0OpVCIrK8slJxEVFQVfX194eXlh586dLu6Bn58fFAoFKIpCQUEBJ5ypS5cuoCgKNE1j//79Lo83NDQgMDAQwcHBLmdLALaiHRAQALlcjm+//dbFviYYaNII8U2cNDY2Qq1WCzYH/v7+91TkxNjw7UkEgMQHhbLfirnXz02j0bh1DsxmM292paNKag4kSfqdSAz7ID09HWFhYVi3bh3n41qtFuPGjYOvry9ycnLwww8/ODzOMAxmzZoFi8WCL774gh1htNfkyZNhtVrZlH1GRoZDYRwxYgRUKhWCg4Ph5+eHJUuWOGQlQkJCEBcXh65du7KYZmdkslarhZ+fH0wmE7777jsXh4KcSQDYUunO7oFGowHDMPD29kanTp2Ql5fn8nswDAO5XI7Q0FC8//77Lg1IfX09goKC4OPjgzNnzqC2ttbh8YqKCgQHB7NnNTjnDgoLC6FSqaBQKNitGGe1tbVBr9ejc+fOgs1BUFDQPVnX7mz49iZ3+QkS4pTJZPf8uQUGBrp1Dsi195Ok5kCSpN+R3LEPvLy88NJLLyE/P58zEAjYtg4MBgMCAgIwb948l73sp556CiqVCjExMVizZo0Lhjg5ORlRUVGIi4uD0WjElStXHLIQ/v7+SE5ORmhoKBobG2E0GvHiiy86uBDJycmwWq3Q6/Xo1KkTXnzxRQcgkVarRUNDAxQKBbp164b169c7vE9yJkGnTp0QHx/v4h5oNBpQFIW4uDiEhYUhPz+fc8JCLpezDobz1kBDQwNCQkLQ1tYGq9XqEkwsLy9HaGgoez/n3EFhYSFiY2NBURSio6NdTpsk9wCABx54gJMxQY6n7ty58z3b4+R9dgS5m7woLy9HYGAgKIq6588tODgYtbW1nIecAffvyYxScyBJ0u9M7tgHY8eORVJSErKysjgJgFqtFqNHjwZN0ygrK3OBFgUEBGDSpEmor6+HXq/H+vXrHR6naRqTJ0/GzZs30alTJ8TFxWH37t0Oq3udToeysjJ07doVXbp0QX5+Pvbt28c+npycjFu3bqFPnz4IDAzExYsXHdDLPXv2hMFgQP/+/UFRFKqqqrBjxw728cjISFAUhaSkJPY4Y3v3gBSO+Ph4/PLLLwgKCuKc0mAYBpWVlejSpYvDEdgEzxsWFob6+no8+OCDLlsL5eXlCA8PB0VRePDBB12ai4KCAhab3K1bN07ngBSuiIgIztVpTU0N9Ho9+z7uVmK4AO1JYpyDqKgoyOXye/7cHnjgAQDgbN6A+/dkRqk5kCTpdyZ37AOKopCVlYXLly87FDx7LVy4EJWVlUhNTcWOHTtc9uTT09NRW1uLUaNG4e9//zvOnTvn8PikSZPQ3NyMkSNH4tKlS3j00UexePFidnU+atQomEwmDBkyBIWFhRg+fDhWrVrFnt8wYMAAALYJiaKiIowePRobN25k2QeJiYkAbI1McXExHn/8cWzfvp3dniC8/O7du+PGjRsYO3asg3tACkd0dDRqa2sxevRo7Nu3z+ULXC6Xw2QyYfjw4fj444/Z1aFer4fRaGTv069fP3zxxRds1qO1tRXV1dWIjo5m36d97qC5uRklJSUOzUFRUZFLCJQUrujoaNy8edOFdUAahoiICDQ2NgqSFIVEfu97oQX+niTGOYiKirrnMcOGhgaWd8G3tSA5B5IkSfrdyB37ICkpCePHj8emTZs47VCtVou0tDRcvHgRAwYMwIIFCxzS8HFxcXjsscdw5coVPPTQQ1iyZIlDYYuOjkb//v1RXl4OrVaLpqYmdO7cmc0fhIeHo1evXrhz5w5iYmJgNpsREBCABQsWwGKxICQkBLGxsey1JPVPphuCgoIQGhoKuVyOoKAg9nCjLVu2ALB9IZP/I/kGe/dApVKBpml2pDE8PBxGoxHvvfeew+dAsLhdu3aFXq9nw5OkoJDi3717d+j1epaJQFaRMTEx7OP2uYOioiJYrVb2TIXY2FgYjUaXoCi5T2xsLEwmkwvrgBSk6OhoWCwWQRqjkOrr69kJkI4gMc5BZGTkPdML6+vrER4ezm49cUlyDiRJkvS7kjv2wYoVK1BXV4fXXnuN8/GFCxeirKwMI0aM+P/aO/P4qKrz/7/vbJkkM5ONJWSBkECAJKxRgYCirEERKMrSilpZRKtVEbUWFVEQrSvV/vRboKi4ICgtIkoggggICAJiEtYAgYRAQvZt9rm/P+JcM8kkJBDaEM779eqrciczT+6dm3ue8znP8zmUlpYyb948j9dnzpxJeno6d999NydOnKjjfTB58mR++OEHHn74YQ4ePMjvf/97MjMzld8nOTmZrVu38sgjj7B161YefvhhfvzxR6U4MCkpid27dzNt2jS++eYb5syZw4YNG5S2wYSEBI4cOcKECRP45ptveOyxx1i5cqVSaxEREcG5c+cYNmwY27dvZ9q0aYp6IEkSJpMJq9VKnz59yMjIYPz48Sxfvtxjdq5SqWjfvj3nzp1j8ODBytJHzRm9W12IjY1Vlhbcg3ZsbCxQvedDQECAUneQnp6ORqNRkgt3ElF7acEdp2vXrh6f6yYnJwej0ahI25c6ALUmAyT4rYvAGy6Xi7NnzxIZGXlZ7oVWqxWbzUZgYCDh4eH1Kgc+Pj7odDqRHAgEgpbBxbwPIiIimDVrFu+9955X+163evDxxx8zf/58Vq1a5dHPP2TIELp06cK3337LrFmzeOuttzz8AMaMGYNer+fMmTOMGDGCFStW8Pzzzyv1B8nJyVRUVBAcHEx0dDSbN2/m/vvv5+WXX+bo0aMkJSWRmZnJiBEjlLX/YcOGMXfuXCoqKoiPjycjI4PJkydTUFBAx44d6dSpk7LJVGRkJNnZ2SQnJ3Pw4EHGjRvnoR64zWmSkpLYuXMn06dPJycnp45nQUxMjBJn9+7dZGVlKQ/6oKAgwsPDycnJITk5mU2bNuFwOBSPA7cyUFFRwYABA5S6g4yMDLp27apYHvv7+xMVFVUnOSgrK0OlUilJRu0BKDs7m4iIiMuenbYm62T4rZXRG/n5+djtdiIiIi5rWaFm+6f7XquPa9EISSQHAkEL5mLeBw8//DBGo5GXX37Z6/sff/xxsrKyUKvVjBw5kieeeELxkVepVMyYMYMNGzYwadIk2rVr5+F9YDAYuO2221i1ahXPPfcc58+fp7KykvHjx/PEE0/g4+OjFCM+/vjjpKamcuuttxIVFcWf//xnEhMTATh06BCTJ09Wkovi4mJef/114uPjycvLo23btsTHx7NmzRrmzZvH9u3b2bJli/LAHjp0KFqtlj179nioB+6BISkpicLCQvR6PQMGDKjT1tilSxfS09NJTk7GYDDwxRdfeBTw1UxCiouL2bt3L9nZ2YSFhWEwGNBqtUoS4q47yMjIICEhwSOOO9mpSVlZGUajEX9/f9q0aeM1OXDPgOHS17Vbk3LgLhat73zc19B93S7nmoHnPVAf16KFskgOBIIWzMW8D4xGI0899RRr1qzh559/rvO6Wz34+9//zssvv4wsy/zlL39REoA777wTo9HIZ599xssvv8y2bds8vA8mTZrEqVOnKCkp4Z577uHtt9/mqaeeol27dtx///0MHz6cjRs3cvvttxMdHc0//vEP3n77bY4cOcLKlSuJiYlRZvUFBQXs27ePJ554gmXLlinr4+7kITU1leuuu46kpCReeOEFOnToQHZ2NkajkaSkJFJSUnjggQcU9cA9MCQmJqLVatm5cyczZ85kz549Hv4OMTExFBYWUl5eztixY1m9erXSvmkymZROgl69ehEaGkpKSgo5OTlKx0TNJMRqtbJ3714OHTpEfHx8nWudnp7u0dJZc0bvbQCquXYOYlkBqotBHQ5HvcpBzSJOoRxcOURyIBC0cC7mfTBlyhS6d++uyPG1casH27dv57XXXmPDhg2KY6Cfnx9Tp07l008/5YYbbmDs2LEe3gdJSUmEh4ezatUq5syZg0ql4v/+7/9YunQpmZmZnD59mvz8fH755RdFPZBlmdmzZ/P2228THR3Nzp07iY6OZvjw4SxdupQZM2bQrVs33nrrLfz8/MjIyOB3v/sdsizz5Zdf8vzzz3PixAkyMzOxWCwUFhaSnJzMrl27UKvVinrg4+NDWVkZfn5+SqvhyJEjiYyM9GhrdHcUuJcWcnJy2L9/PxqNBl9fX2VgUKlUJCcnk5KSwpkzZ4iIiAB+mzX26NGDgIAAvv76a6xWq9fkoKSkxGM3ypqDdmRkpEfRm9vjoGZycKkDUGtaVriYZ4PbudJgMDSrcnAxrwOhHAgEghZHQ94H7qLFPXv28M0339R5r1s9WLx4MSNGjGDixIk8++yzyk509913H5WVlXz++ee88MILWK1WxfvA7Xmwbt069Ho9s2fP5uOPP0atVrNw4UK+/fZbNBoNKSkpjBs3jujoaN58803+/Oc/06tXL/bu3cvx48fJz89n5syZHDp0iJ9++olXX32V9PR0DAYD6enphISEMHz4cFatWkXPnj2VmC6Xi+zsbKV1cvPmzYp6cOrUKeWB7a47UKlUTJ8+nXXr1lFYWAhUOzaaTCYyMjK47rrriIqKYseOHYqRUmRkJIWFhVRVVZGcnEx2djaZmZlKm6N7AFKpVAwYMIDvv/9eua41cS8z1FxaqDlo1/Y6cHscREZGotPp0Ov1Qjng4p4N7oQKLm/QrpmEuD+vvo6Fy+2KuBoRyYFAcBVwMe+DIUOGMHToUBYuXIjNZqvzuls9+Pe//82CBQswGo3Mnj0bl8tFWFgYt912G0uXLqVt27bMnTvXw/tg4sSJlJeXk5KSwn333UfHjh158cUXueuuuxg/fjzl5eWsXbsWtVqtqAcZGRm8/fbbVFRUUFFRwe7duxk8eDDdunVj6dKlJCYmcu+993LmzBn2798PVHdHpKWlcfjwYf7yl78oOw26nQr79u1LSkoKwcHBTJs2jcOHDyv1E+66g+PHjzNlyhR0Op1i2iRJklIPIEmSEsff3x/AY2AYOHAgRqOR8+fPex2AkpKSOHz4MB06dCAwMNDjGoeGhhIUFOThlFhbOajpdVBz7RwuT7q+1pSDmt+N2ySrqZSWlqJWq/Hz81M+r76lhcvpirhaEcmBQHCVcDHvg3nz5pGTk8Py5cvrvFZTPfDz82Px4sXs2LGD999/H6hua8zKymLz5s3cfffdHt4Hbs+DVatWodPpePbZZ/nuu+/YunUrr776KmFhYfzyyy9kZGR4qAcxMTHMnz8fm83GqlWrkCSJmTNnsmnTJrKysnj66acxGo2kpaVhNpsZOnQoISEhrF69mtDQUB5++GEsFotSP5CcnMyWLVuwWq088MADSJKkdFfUrDswmUxMmTKFr776Shk03PUAUF1nYbfbFUOjmgODVqvluuuuw2q1eh20k5KSsFgsiq1yTWomIW5qtuRFRkZ6eB3UTg4udxbc2pSDxiQHAQEBHt9lU3BfM0mSaNeuXYNeB2JZQSAQtGga8j6IjY1l6tSpLF68uM4uhuCpHgwePJjp06ezcOFCMjMzSUxMpF+/fixduhSVSsVrr73m4X0wefJktm/fTm5uLqNHj6Z///68+OKL6PV6Pv74Y1wuF4899piHenDw4EH++Mc/0rlzZ9atW0dZWRkTJkwgMDCQ5cuXYzKZmDNnDhaLheXLl6PVapkwYQJr1qzBbrfz4IMPotfr+fe//w1UJwdVVVVs376d4OBghgwZQkFBAUVFRR51B1DtAFleXq7s1xAfH8+pU6eorKwkPDycdu3aKapD+/bt0Wg0ymDdo0cPHA4HarUa8BwYunfvjizLqFTeH50JCQkeyUHNlrzas1O3x4F7ELxU6dqtsLQ25cDb+dT0OIDLcy+sqbaoVKoGvQ5EQaJAIGjRXMz7YM6cOciyzBtvvFHntZrqgcPhYO7cuURERPDnP/8Zu93OzJkz2bFjB4cPH6ZHjx4e3gduz4MvvvhCsW8+evQoK1eupG/fvgwaNIjt27fz5ZdfeqgHKpWKv/zlL5jNZh5//HH0ej333HMPn332GeXl5cycORO9Xs/rr79ORUWF4nmwdetW/Pz8SExM5OjRo+zdu5cuXboQHR2tGBWNGTMGWZb5f//v/wG/1R3IskxUVBQDBgygqqoKWZZJSEhAlmWOHDkCVG+EVFxcrLR5ur0OANq2bYskScpyR82BoaCgAJVKVWezqprX+PTp08oAV3NG7y5wdA9Abo8D97bElypdu50vW5NyoNVq8fHxqfNaTY8DuDz3wtpqS0MdC+4E8VKWL65WRHIgEFxlNOR90KZNGx599FFWrFhRx8oXPNUDX19f3n77bdLT03nnnXe49dZbCQ0NVSr9H3/8ccX7wN/fX/E8kGWZ3r17c+edd/Lqq69SXl7OQw89hFqtZvbs2Zw5c8ZDPbj11lsxGo38+9//5uuvv+aPf/wjFouFzz77DF9fX3r16qV4H8TFxREfH684Gd54443o9XqlE8NtVOR0OomIiMDPz4/333+foqIij7oD93VyOBwcOHCA2NhYtFqtsrTg7++Pj4+P0rVRc2C4cOECgYGByi6NNZWDjIwMdDodWVlZXqVsd5Giu6uk5uzU19fXw+ugpjxeO05TuJgMf7XhVlvcSVNNvC3FuN/TVGq7MDaUHAQEBOB0OqmqqmpynKsVkRwIBFcZF/M+mD59OmFhYSxYsKDOa7XVg759+/Loo4+yePFiDh06xLRp01izZg2FhYX4+fl5eB+4PQ/27dsHwNNPP01lZSXvvPMOI0aMIDAwELVazcyZM0lOTlbUg/bt2xMfH09kZCRPPfUUkiQxduxY/vWvf+F0OklMTFTaD9PS0hTPg6KiIjp27Iher+fAgQN8+eWXjB49moKCAvbv34/JZMLPzw+n08k///lPj7oDgD59+qDRaFizZg1arZauXbsqkn9FRQU9evRg9erVuFwuj06CnJwcYmJi2L17N8XFxR6zxoyMDAIDA3E6nco+CzWJiYlBp9ORkZGBzWbDYrHUOwDVTg4uVbpuSIa/GmmMAVJt5eBSr1vNa3Yx5cD9nmsFkRwIBFchDXkf+Pj48Mwzz5Camsr27dvrvLemegDw6KOP0qNHDx555BHuuOMOVCoVH330EQBDhw5VvA/i4uIUzwOAsLAwHnzwQZYsWUJ5eTmDBg0iNjaWzMxMXnzxRQ/1YNCgQfj5+aFWq3nyySeZMWMGZ86cITU1lfj4eKqqqoiNjeXJJ59k7NixyLLM2rVrlcHz5ptv5qWXXqJHjx60bduWlJQUTCYTKpVK2bHRYrF41B1IkoSfnx+7d+/m1KlTHvUAZWVlDBgwgJycHHbt2lVn0O7Tpw+yLJOamkpAQAAOhwOz2UxGRgZ9+/b12GehJlqtlu7du5Oenu510HZ7HdT0OHBzqcrBxar7rzYa6ryo6XEAlzdoe1tWqM/r4FrcmVEkBwLBVUpD3ge33347iYmJzJ8/H6fT6fFabfVAq9XyzjvvcPr0af75z38yceJEPvjgA2WXRrf3wcsvv6z4D7iXM/70pz8RGBjIokWLSE5OJj09nWeeeYYVK1YgSZKiHiQlJXH69GmeffZZUlNTOXLkCNdffz1Lly4lISEBs9nMo48+SlpaGl999ZXieeAePP/whz+Qn5/PsmXLGDVqFBs2bFAe2CNHjlRcE2vWHQDo9XoCAgJYtmwZ8fHxHDp0CLvdTllZGfHx8URFRbF69WoPr4Ps7Gy6detGYmKikoRA9WCSnp5OQkKCxz4LtXF3LHgbtN0KRU2PAzeXqhxczBfgauNiykHNa+br64tGo7nsgkTwbGmtzbW4M6NIDgSCq5SGvA/cRYOHDx9m9erVdd5bWz2IjY1l7ty5LFmyhD59+pCfn8+6deuA6mp+t/dB165dFc8DqF67f/rpp/nyyy/p0KEDdrudtm3bMn78eJ566inuuusuUlNTMRqNQPVgPWXKFJ577jnGjRvHrl27lLVlSZK49957eeWVVxg+fDhpaWnKGq/L5eK+++7jnXfeoX///mRlZXlsf+x2TUxISPCoO3AvYaxatYqoqCisVitHjhzBbrcTGBjI5MmTWb9+PSEhIQBkZmZSUFBAZGSksuukuzDu3LlzigLh3mfBm6eEe7dJdzdE7QEoNzeXU6dOKf92YzKZKC8vr5PoXQz3gOWeTV/tXEw5qHnNatpbNxVvyoE7Rm2EciAQCK4qGvI+SExMZPz48fztb3+rI5XWVg8AZsyYwcCBA3nzzTcZNGgQS5YsUWbgbu+DxYsXc/311ytLC1BtkhQXF8e7775LQkICKSkpvPrqq7Rr144vvviCqKgoPvzwQ2WfhRdeeIGgoCC++uorwsLC+OKLLwgNDSUjI0MpfkxNTSUkJIRvvvkGk8lETk4Os2fPRqPR8MMPP+Dv78+2bdtQqVSUlpYqrok//fSTR90BVKsodrtdKUZ010yYTCbuvPNOLBaL0sXgriOIjIxk9OjRWCwWjh49CkBaWhqyLBMfH6/ss+DNzjo+Ph673a58Zu0ByOFwKL9L7eTA5XJRWVnZuC//V0pLSzEYDMpeFVc7TVEO4NJbQGsnIQ15HQjlQCAQXHU05H0wd+5cSkpKePfdd+u8Vls9UKlULF68WHGcS0tLY+/evcprbu+DoKAgxfMAQK1WM3/+fPbt20dkZCRbtmxBp9OxdOlSTpw4Qfv27UlNTaVLly7s3LkTo9HI3//+d/bs2UNsbCz/+c9/lG2VTSYTCxYsYOPGjfTq1Ys1a9YQFhZGdnY2gYGBzJkzh9WrV9OvXz82btyozBrdrokff/wxcXFxHpJ/SEgI48ePZ+XKlYSHhysbVAUEBBAeHs7gwYPZtGkTGo1GqUmIjIykc+fOxMbGKk6R6enpaDQaYmNjlX0Wam7w5KZHjx7AbzbK3manhw4d8vA4cP8+0PQBqDUZIEHdLgI3tT0O3FxKC6jVasVms3nEacjrwMfHB51OJ5IDgUBw9dCQ90FERASzZs3ivffeUwZzN97Ug8jISBYsWMDOnTsJCQnx2P7Y7X2wdetW1Gq10gYIMHjwYEaMGMHevXspLy/nhx9+IC4ujoULF/Ljjz8SEBDA6dOnyczMJD8/n4EDB3L//fezY8cOZFmmqqpKGUzHjBnDsGHD+Pnnn8nPz0er1SoP7HvvvZdOnTpx9uxZfv75Z3x9fZVZo1s9kGXZo+4AqlWRnJwcAgIClNm+e2CYPHkyP/74IyEhIZw4cQKNRkP79u2BauOl7du3I8syx44do2vXruh0OmWfBW/JgdFoJCoqiuPHj6NSqRSbZvf3AdXLFzU9Dmr+Pk0dgFqTdTLU7SJwU9vjwM2lLCvU1/55sXZGsawgEAiuKhryPnj44YcxGo28/PLLdd5XWz2A6m2aR44cSUlJCevXr/d4WD7++OO0b98evV7PZ5995jEAz5s3j5KSEvR6vVKT4N5/oaSkhLS0NOx2O7t37waqWyGjo6OVGfv58+e5cOECkiSxaNEizGYzfn5+5OfnK7+DVqtl3rx5nDhxApfLhdVqVQYGt3qQnp7OhQsXOH36tPK79ezZkwEDBnD+/HmOHTuGLMvKADR69GgMBgMul4szZ84QFhamSPTJycmUlJQgyzInT55UNleCatOljIwMr8Y48fHxZGVlYTQaPdwU3V4HZ86c8ToDhqava7cm5UCW5XrPp7bHgZtLGbTra/9sjBHStYJIDgSCVkBD3gdGo5GnnnqKNWvWKJK6G2/qgSRJvPbaaxiNRsxms8deDW7vg6KiIo4cOaKs30N1j/8999xDWVkZX3/9NS6XC0mSePXVV+ncuTN2ux1JkpR6AB8fH95++20sFgsFBQVYLBYOHToEVD+kn3jiCYqLizl58iRZWVnKIDxy5EgGDRqELMuUlJR4DAwPPPAAPj4+HnsyuJk5cybnzp2jsLAQl8ulDEC+vr6MHTuWvLw8jw2XAHr16kVoaKgiadfciTEpKQm73a50ddS+rjk5OV4HucjISPLy8ryuncO1vaxgNptxOBxelYPaHgduhHJwZRDJgUDQSmjI+2DKlCl0795dcRqsiTf1oG3btrzxxhu4XC6WLFniUdA4dOhQ7rjjDiwWCx9++KHHZ82ZMwej0UhWVpZS3GcwGFi2bBk6nY6SkhI2bdqk/HyvXr148sknkWUZs9nssaPhzJkz6dmzJ2azmZKSEmULZkmSeP7557Hb7Vy4cEHpCoBq9WD69Ok4HA6lXsLNyJEj6dixI1arFVmW8fX1VV6bPHkyZrOZwsJCj8FHpVKRnJxMZWUlVqvVIzno0aMHBoPBa8dCfHw8ZrPZqwVwREQExcXF9SYHTR2AWtOyQkOeDbU9Dtw0t3LQkNeBUA4EAsFVSX3eB+6CxT179vDNN994vMebegDVcvukSZPIz89nyZIlHu958cUX8ff355NPPvFYxggKCuIvf/kLVqtVMVICiIuL4/XXX1dcBmt2Vvz5z3+mV69e2Gw2j8RBq9Xy1ltvoVarla2b3fTs2ZOJEydit9vr2EQ/8MAD6PV6pZ7BjVqt5oEHHvBQSNxcd911hIaGYrFYlHoDN8nJydjtdlwul0dyoFKp6NWrl1flICEhod6WxODgYOx2e53kQKfTodfrr2nloCHPBm+dCnBpg3Z9SUhDXgeX2hVxtSKSA4GgFdGQ98GQIUMYOnQoCxcurDPb9aYeALz55puKyVHNxKF9+/Y8/fTTlJaW8s4773i8Z/r06bRt25ZPP/3U4/jdd9/N4MGDsdls/OMf/1COazQaPvroI1QqFZs3b/Z4T2JiIrfeeitOp5MNGzZ4vPbiiy+i0WjqJAfBwcFMmDCB0tLSOgP373//ezQaTZ26DEmSFDOl2jsuDhw4EEmSkCSJwMBAj9d69+6N3W6vcz1DQ0PRarVe91/w9fXF6XTSoUOHOq9dyiz4WlIO6ksO3B02jaW0tBS1Wo2fn5/H8Ya8Di51Y6yrFZEcCAStjIa8D+bNm0dOTo5HHQHUrx6YTCZeeeUViouLeeqppzzeM3v2bNq2bcvrr7/uMQjrdDoeeughCgsL+fjjj5XjkiSxdu1a1Go1b775psfA2aVLF2666SYqKys93gOwZMkSJElSto92ExoaSrdu3aioqODYsWN1zhOoIw+bTCbatm1LVVWVsp2zm6FDhwLUWZLRarXo9XqvSoDbZrn2e9zWzd48C9zJh7clh0udBbc25aApyUFAQAB2u91rIlYf7mtWe3OnhrwOxLKCQCC46qnP+yA2NpapU6eyePFiioqKPF6rTz2YPn060dHR/POf//SYpatUKp588kkKCwt55ZVX6nyWXq/nxRdf9Eg2AgICGDJkCJWVlTz44IMe71m0aBGSJDF79myPh3BISAjt2rUjNzeXr7/+2uM9d955pxKvJhEREXTs2BGbzVZnJt6pUydcLhcrV670OO5ey65ZZAko7ZF2u73OjDI6OhpJkry2NOp0Oq8qgMPhQJIkr9s+N1W6djgcVFZWtjrloPb51OdxAJdWq1Gf2tKQ14EoSBQIBFc9DXkfzJkzB1mWeeONNzyO16ceALz00kvY7Xbuu+8+D5Vg1qxZBAQEsHjxYrKyspTjvr6+jBw5kjNnztQZhN3bO69cuZIvv/xSOd6nTx/8/f29qhQDBgxAkiQee+wxDzUgLi4OtVrN1q1b6xQgjho1ClmW+fzzzz2Om0wm1Go17777rocUnZubi0ajISsry+Nc8vPzlc6LjRs3enyWSqVCp9N5TQ4kSaKsrKzObLOiogK1Wl2vE19TZqfl5eXKObUGSktL0Wq1dVSV+jwO4NLMoxpSW+rrWKi5O+e1gEgOBIJWSn3eB23atOHRRx9lxYoVddbr61MPfve73xEdHc3PP//sUWNgMBiYPHkyNpuNp59+2uPBedddd6FWq1m0aJEyiAEMGjQIg8GALMv8+c9/VvYZ0Ov19OrVC51Ox2effeahEvTq1Qt/f3/y8vJ4/fXXleOBgYHo9XoAnn/+eQ/pv3///kiSxOeff+6hksiyjE6nIzMzkx9++EE5np2drfgS1DR4ysjIQK1W4+vrq/g31MS9RXNtWdvdull7yeH8+fP4+/s3OAA1loZk+KsRtwFSbbm/Po8DuLQW0PpcGN0x6lMOnE6nst9Ha0ckBwJBK6Uh74Pp06cTFhbGggULPI7Xpx5otVoefvhhNBoNb775psdM+a677kKn07F582bWrl2rHB8+fDgBAQEUFhZ6JBTt27cnISGB4OBgLBYLM2fOVAbWvn370rZtW3Q6HU899ZRSMxEZGYlOp0Oj0bBkyRLS0tKA6oHB19cXnU7H3r17PZSIuLg4JEnCarXyz3/+UzleXl5OaGgoJpPJwwEyJyeHNm3aEBwczOrVq5VEIyMjA19fX7RaLbt376a4uNjjmmm1Wux2u9K6CWCz2XA6nUriUJPs7GxCQkKaRbquT4a/WrmYAVJDykFTr1t916wh5cD93msBkRwIBK2Y+rwPfHx8eOaZZ0hNTWX79u0e76lPPbjrrrsIDAzEYDDwyCOPKAV9SUlJREdHEx4ezvPPP6+spQcGBjJ48GDCw8NZsmSJxwN30KBBBAYGIssyhw4dUmoj4uPjcblcqFQqqqqqFA+EyMhIZfYeEBDAk08+idPpxGQyodFoaNOmDZGRkbz00kvK7+Ue0Dt06MDy5csV9aCsrIzIyEiCg4NJTU1VlIvs7Gw6dOiAJEnk5OQo+zNkZGQQFRWFRqPB5XKRmprqcV00Gg0Gg8Fjs6eysjIkSaJjx44e3g2yLJOdnU1YWFizFL01VN1/NVJfLUB9HgdwaYP2xZYVvHkdXGs7M4rkQCBo5dTnfXD77beTmJjI/PnzcTqdyvH61IOgoCAmTZqEJEmcPn1aKUJUqVRMmjSJ8vJyLBYLL730kvKe5ORkCgoKMJlMLFq0SDmelJREcXEx0dHRxMTEsGLFCr788ksSEhJwOp307NmT8PBwUlNTWbVqFZGRkahUKq677joCAwNJS0vjgw8+UCTofv36AdTxZNDpdFRVVSHLMv/85z8Ve97OnTtTXFxMcHAwy5YtA6oHoKioKKqqqujYsaOy1XV6ejpdunRBrVbTs2fPOksLkiTRq1cvj82e3ANVbGysh3JQWFiIxWKhU6dOzaIcNOQLcDXSkHLgbUkBqpNAjUbTLAWJUL/XwbW2M6NIDgSCVk593geSJDF//nwOHz6sDIRuGupcKC0tJTk5mSVLlihr9hMnTsRsNpOcnMwnn3yi7GQ4atQonE4nI0eO5Msvv1Q6AdwFhkOHDiUzM5PBgwfzxBNPKJsUDRgwgJMnTzJ8+HCee+45JX7fvn05ffo0t912G6+88oqy/puQkMD58+e5/fbbeeedd5TlCJ1OR0VFBWPHjmX58uXk5uZit9uJjY3FZrMxZswYVq1aRV5eHgUFBXTr1g1Jkhg2bBjr168nLy+PU6dOERcXp/xeW7dureOT0Lt3b3766SdlecQ9UMXHx3PkyBGliNOdEHTr1o3c3Nw6hZ8mk4ny8vJ6DZRq4x6ovM2or0YaUg7qSw4kSbokxaUh5cAdsyZCORAIBK2O+rwPEhMTGT9+PH/72988ZNT61IPY2FhuvvlmTp48ycCBA3nssccoLy8nKiqK/v37k5eXR79+/Xjqqaew2+2Eh4fTs2dPysrKiIuLU+yb27dvT0xMDE6nk5iYGDQaDe3ateOpp56iXbt2+Pj4EB4ejsFgICgoiOeeew6j0UhISIjyP39/fxYtWqS0n/n7+xMREYFGo+G1114DqusBNBoN0dHRyLKsbF3tdjrs3r07drtdqUno2bMnUF0AabFYWL58ObIs06tXL6A6ObFYLGzbts3j+vbp0wer1arUHbgHKrdJkrvw0z3g9OzZE4fDQV5ensfnmEwmXC6XV38Eb5SWlmIwGJSNoq52LkU5gKa3gDakHNTndSCUA4FA0Cqpz/tg7ty5lJSUKAOnm/rUg5kzZ5Kens4f//hHSktLFcOhyZMns2PHDp588klOnDihmBYlJyezdetWnnnmGfbt28dXX30FVC8t7N69m8cff5ytW7cyZ84cMjMzcTgcHDlyhGnTpvH111/z/PPP8+OPPyJJErm5uUyYMEE5npKSotQnDBs2jG3btjFnzhxWrlzJyZMnkSSJbt26kZaWxrRp0/jkk09wuVyEhYURERFBTk4O48eP59NPP0WWZXr37q04KA4ePJg1a9ag0Wjo3bs3UD1Dj42NrbO0EB0dTUBAgFJ34B6o3Msd7qWFnJwcjEYj3bt3B+rOTps6ALUmAyTw3kXQkMeBm6a0gFqtVmw2W73XrT6vAx8fH3Q6nUgOBAJB66I+74OIiAhmzZrFe++9R25urnK8PvVgyJAhdOnShXXr1rFgwQJWrVrFxo0bGTNmDHq9noMHDzJr1izeeustsrKySE5OVlSJESNGsHDhQqxWK0lJSWRmZjJw4ECio6P58ssvWbhwIWfOnGHnzp384Q9/QKvVcuTIEe6//35ycnLIyMhg8uTJFBQU4O/vz7BhwygqKiI/P5/k5GQOHjzIiBEj6NSpE++99x6yLNOnTx927tzJrFmzlFY0k8lEfHw8GRkZzJgxg7y8PBwOB2FhYYSHh5OTk8PkyZM5cuQIERERtGnTBqgejJOTk9m0aZPHNVGpVAwYMECpOygrK0OlUhEaGkpUVJSSHGRnZxMREXFR6bqxA1Brsk4G710EDXkcuGnKskJj2j8bamcUywoCgaDVUZ/3wcMPP4zRaOTll1/2+Hlv6oFKpWLGjBls2LCBgQMHMnLkSJ544gksFgu33XYbq1atYvbs2bRr146nn36abt260alTJ1JSUpg3bx7nz59n2bJlDBgwAIC9e/fy+OOPk5qaSkJCAoMHD+bMmTMcP36cyZMn8+GHHzJ79mzatGnD9u3b6dq1K/Hx8axevZpFixbhcrnYvHkzQ4cORavVsmXLFubNm8f+/fux2Wz07t2bwsJCCgsLGTlyJFVVVbhcLhISEkhPTychIYEOHTrgdDrRaDTKwDB69GhkWUatVqPX69FqtUq9RXFxcR3TpaSkJKXuoKysTPFMcCch8Js87uvrS5s2bepVDho7ALUm5cBdLFr7fBryOHDTlEG7Me2fFzNCuhYQyYFAcA1Rn/eB0WjkqaeeYs2aNfz888/K8frUgzvvvBOj0cgHH3zAa6+9hizL/OUvf2HixImcOnWKw4cP8/LLL7Nt2za+/PJLkpOT2bhxI507d+aee+7h73//O2q1mpiYGHbu3Mm4ceOIjo7mrbfe4rXXXkOlUjFr1iymTp1KQUEBGzZs4N5776W8vJy33nqLyZMnk5qair+/P927d+fnn3/m9OnTJCUlkZKSwsiRI+nduzcVFRXExsai1WrZuXMnQ4YMAWD16tXEx8dTWFhIfn4+UVFRmM1mDh48SEREBNnZ2Uq9Qk5ODrIsKwNDr169CA0NrbO0kJSUpNQd1JzRx8fHk56errQxugc5bwNQU5WD1pQcmM1mHA5HnUG7IY8DN0I5aH5EciAQXGPU530wZcoUunfvrhQNuvGmHvj5+TF16lQ+/fRTfH19ee2119iwYQO5ubmEh4ezatUqhg4dytixY3n++ecZNGgQ+fn5HDhwgDlz5qBSqXj99ddJSkpi586dqNVqRT2w2Wx06NCBrKwsPvzwQ4YPH87SpUsZMGAAfn5+/P3vf1cKDNeuXUufPn0wGAw8+eSTjBw5kl27dlFWVqZsz7xlyxb69OnDrl27cLlcGAwGPv74Y8LDw4Hf6gECAgJYtmyZMjCcOnUKrVZLeXk5u3btUgYglUpFcnIyKSkpHtepR48eSt1BzUE7Pj6ekpIScnNz6yQHtYvemloR35qWFerzbGjI48DNlVAO6vM6EMqBQCBotXjzPnAXK+7Zs4dvvvlG+dn61IP77ruPyspKPv/8c0aPHs3EiROZN28eo0aNYt26dZjNZl544QWsVisbNmwgODiYlJQUgoKCmD17Nh9//DGdOnUiMzOT/Px8RT1YvHgxffr0oW/fvqxYsYLu3btz6NAhCgsL8ff3Jzo6mnnz5nHzzTezatUqAgMD6dq1K2lpaRQXF+NwONi8eTOxsbH4+vrywQcf0K9fP3bu3ElpaSmhoaHIssxXX32FyWQiIyODnJwcbrzxRtatW4fRaKSwsJD9+/ej1WqJjo5m9erVHgNQcnIy2dnZnDx5UrkeNesOag7aCQkJAOzatQuLxaIkB26FoiY6nQ69Xn9NKgf1eTZcrFMBmjZoN8Y4qj6vg6Z2RVzNiORAILgGqc/7YMiQIQwdOpSFCxdis9mU497Ug7CwMG677TaWLl2Ky+ViwYIFGI1GDhw4QFlZGSkpKbRv3565c+eycuVKevXqpUjx9913Hx07dmTz5s0A7N6920M9aNu2LTabjfHjx/P+++/TsWNHUlJSkCSJqVOncvbsWex2O2lpadhsNiRJ4t577+W9996jR48eShx/f3+sVivZ2dkUFhZy6tQpgoODmTZtGu+//z5du3bl4MGDFBQUMGbMGHQ6nbKssmvXLiIiIrjrrrtYv349vr6+ysAycOBATCYTO3bs8Liu7rqD4uJiZfAJDQ0lKChIKVasqRx48zpoyiz4WlEOGpMclJaWNmpTpNLSUtRqNX5+fvX+TH0Fo03dGOtqRiQHAsE1Sn3eB/PmzSMnJ4fly5crx+pTD2bOnElWVhabN2/GZDKxePFiDhw4QGhoKKtWrQLg7rvvpl+/fmRkZJCZmUlmZiY6nY5nn32WXbt2ERISorQAutWDY8eOcfLkSV544QXatWtHRUUFW7ZswdfXF6fTyXPPPcf333+PXq8nMzOTsrIynn76afz9/amqqmLLli3YbDbUajWTJ09m06ZNSJLE0aNHCQgI4IEHHkCWZSorKxVvgm7dujFlyhS+/fZbZFnm4MGDxMfHc+edd2KxWCgtLVUGba1Wy7Bhwzw2boLf6g6ys7OVQU6SJOLj4/nll18Az+SgPq+Da1k5uJTkICAgALvdXmfzK2+4r1ntzZ1qUp/XgVhWEAgE1wTevA9iY2OZOnUqixcv9tjN0Jt6kJiYSL9+/ZQNjAYPHsz06dM5e/Ys3333Hbm5uahUKl577TUKCwux2+3KrH706NH079+f0tJSZZB1qwdHjhzBarWSk5PD0qVLKS8vx2az4XK5yM7O5o9//CODBw/GYrGQlpZGSUkJJpOJBQsWcPLkSYqLi9m/fz8AkyZNIiQkBK1WS1ZWFiaTSVEPDh8+zKlTp3C5XERGRjJ9+nQl1vHjx0lISCA8PFzpoKg5MCQnJ3PixAkP62l33cG5c+c8ZvQJCQmcOHECo9GoDH4NtTM2RjlwOBxUVla2OuWg5vk0xuMAmlar0Ri1pT6vA1GQKBAIrgnq8z6YM2cOsizzxhtvKMcaUg927NihFDfOnTuXLl26UF5erqgHPXr04IEHHsBqtSrJhdu+uaKigrS0NEW9GDduHF26dKGqqoqMjAzi4uJ46aWXsNls5OXlcfLkSVQqFYsXL0av11NYWEh5eTlWq5UxY8YwcuRIrFarcj6+vr789a9/paioyGNG/8ADD6DVapWWzvbt2xMVFcWIESOw2+2UlJQoToqTJ0/m/PnzHrP8W265BY1G4zFbddcdFBYWesyA4+PjuXDhAqGhocqM1V19f6nStXsb7NakHGi1Wnx8fJRjjfE4gKaZRzVWbamvm6SsrKxRyxdXOyI5EAiucbx5H7Rp04ZHH32UFStWKNa/4F09uPXWWwkNDVU2MPL19eX//b//h1qt5u2331YepI8//jihoaHs2rWL8+fPA9X2whMmTKCyspItW7YA1erBE088oXQaQPWOkBMmTMBqtSr7NoSFhfHqq6/idDqpqKhQdkJctGgROp2OjRs3KrHvvPNOunfvrrTLAQQHBzNz5kxsNht6vV6xIHZvIe1wOJTkYPTo0ej1eg+TKIPBQGJiYh0pOykpicrKSo817fj4eJxOp0fFfX1eB42VrhvTknc14TZAqin3N8bjAJrWAurNhdEb3pKDgIAAxUirtSOSA4HgGqc+74Pp06cTFhbGggULlGPe1AOtVsu0adNYs2YNhYWFQPUeBPfccw9nzpxh5cqVQHX74xtvvIHNZvPYofHFF19ErVYrdstQrR6EhIQo2yNLksQ//vEPDAYDp0+fVvYeuOOOO4iPj8dmsymFhJGRkdx///2UlJQoyY5KpeKVV17B5XJ5tG8+9NBDSJLksZdBUlISfn5+OBwOZVDy9fWlX79+FBcXeywjDBo0CJvN5jEoXX/99bhcLuVaAMTExChbUdekvgGoMdJ1Y1ryriYaMkBqrHLQ2OvWmGvWHD4UVzMiORAIBF69D3x8fHjmmWdITU1l+/btys96Uw/uuusuVCoVH330kXLszTffxGAw8Je//AWLxQLA2LFjiYqKYsWKFZSUlADVCsCAAQP48ccflYexWq1mzJgxnDt3TqkdMBgMPPLII8iyzB/+8Afgt8QG4IknnlCUghdeeAEfHx8qKiqUwXzo0KFoNBrS09OV3yc4OBij0UhJSYlSXyFJEm3btsXlcpGVlaWcz9ChQ3E4HGzdulU55nZ5rLldc1hYGJIkcebMGeWYRqNBpVLV2c2xPq+Dxsrj7p9vDXirBWiMxwE0bdBuyrJCba+Da2lnRpEcCAQCwLv3we23305iYiLz589XBllv6kFQUBATJ07kgw8+ULYn9vHxYdasWZw/f95DfXj44YeprKxUNmwCePDBB5UuBDd/+MMfUKlULFy4UDk2ZcoUNBoNKSkpfPnll0D1Doo6nY7Dhw8rNQ4+Pj4MGzYMp9PJ2rVrgWp7Xl9fXywWi7ILI1SrAi6Xy0O5gOokoeaxfv36oVarFSUEUAoda3YtVFRUoNPpOH78uHKssLAQlUpFcXGxRwxvXgeNVQ7q8wW4WqlPObjYkgJUf4cajabZChLBu9fBtbQzo0gOBAIB4N37wF00ePjwYVavXq38rDf1YPr06eTn57Nu3Trl2J/+9Cf8/f157733lAF00qRJ+Pv78/HHHyv1AzfffDMGg4F169axb98+oHpbY39/f7Zu3crBgweB6ge2wWBAkiQeeeQRTp06hclkwmAwoFKp+Mtf/qLM2MeNGwfAkiVLOHfuHBaLBZ1Oh1ar5a233iI/Px+z2YzNZkOn07F06VKKioqorKykuLgYHx8fVq1apQwEgYGB+Pr6smnTJo/ZpI+PD3v37lVUgdLSUnQ6HceOHVPqEbKzs9FoNJw7d05JntznU9vrwGQyUV5eriRo9eH+vS42q75aqE85aExyIElSkxSXxioH7t/BjVAOBALBNYk374PExETGjx/P3/72N2VQ9KYexMbGcvPNN7NkyRJF3o+KiuLmm2/G39+fxx57jPLycsLDw7nhhhuU/Rzsdjvt27cnPj4ek8mk2DeHhIQQFRWFyWTizTffBKofzu3ataNt27bY7XZmzpyJRqNBr9cTEhKCw+Hgsccew+Vy0a9fP1QqFU6nk2effZaysjK0Wi0GgwGbzcZrr71GTk4OGo0GPz8/rFYr//znPzly5AgqlQo/Pz8sFguffvqpEluv12OxWPj666+Va+bj44PNZmPbtm0AShyHw6F4KLiTA1mWPQo8vXkdmEwmXC6XRx2EN0pLSzEYDEoh5dXO5SgH0PgW0MYqB968DoRyIBAIrlm8eR/MnTuXkpIS3n33XeWYN/Vg5syZpKWleexYOGXKFOx2O4WFhcpSwujRo5EkiRMnTijS/aBBgwgICGDfvn189dVXQLV60LFjR1JTUz3Ug7i4OACOHTvG/PnzCQgIoHfv3uj1en788UeWLl2KVqtVkoYNGzawfv16JEkiLi6Orl27snLlSnbs2IFKpSIyMpKEhASWL1/O7t270el0+Pn50atXL5YvX65sCKRWq4mLi1OWL6C6nsC96yRUDz4ajUbZZwGqpemgoCAkSVL2cnCfC3jOThs7ALUmAySo20XQWI8DN41pAbVardhstkZdN29eBz4+Puh0OpEcCASCaw9v3gcRERHMmjWL9957T2nn86YeDBkyhC5duiimSABjxozB39+fm266iVWrVrFx40aSk5Ox2WyMGDGCt956i6ysLJKSkrhw4QI33ngjCxcuxGq1Eh8fT1lZGdHR0Yp6EBkZSUBAAH5+fgwePJgVK1bgdDqJjY3FbDYzbNgwXn75ZU6dOoWPjw8XLlxg4MCBvP7667hcLq6//noKCwvp1KkT//d//4daraZ3794YjUZkWWbVqlXExsYSHh5Ot27dyMnJYePGjcqAcsMNN7B7926PYsVBgwaxadMmHA4HZWVlqNVqBg4cqBQqZmdn07FjR6KiojySA29eB40trmtN1slQt4ugsR4HbhqzrNDU9s/L6Sa52hHJgUAgqIM374OHH34Yo9HIyy+/rPxcbfVApVIxY8YMNmzYoDxUDQYDt912G8eOHWPkyJE88cQTtGnThk6dOhEYGEi7du14+umn6d+/P1DdFXD+/HmWLVtGfHw8+fn5TJ8+XVEPIiMjycvLY/LkyaSlpXH77beTk5ODxWIhPj4etVpNVFQUr7zyClqtFq1WS1JSEiUlJVRWVjJ48GCKiooUh0SDwUCvXr04fvw49913H/v27aNLly5ERkZit9sZMGAAS5cuRa/Xo9VqiYmJwWAw8MUXXyjXYdCgQRQXF7N3717KysowGo0MGjSIn376SbFTjoyMJD4+3iM58OZ10Ni2vNakHMiyXOd8Gutx4KYxg3ZT2z8bMkJq7YjkQCAQ1MGb94G7RmDNmjWKp4A39eDOO+/EaDTy/vvvK583adIksrKyuOuuu5BlmaeffppRo0axZcsWXnrpJbZt28auXbuIiYnh1KlT3HPPPfz9738nLCwMgE6dOinqgfuBPW3aNAoLC0lKSsLX15f169czYcIEtmzZwoIFCzh16hRms5nevXuzZ88ebr/9dqqqqggODkar1aJSqWjTpg0FBQV069aNwsJCxo0bh81mIz8/X+kkmDlzJnv27OGXX37BZDJhsVgYO3Ysq1evVooGY2NjCQ0NJSUlRZnRu/dZOHDggEdykJ6e7uGwV3sAaqxy0JqSA7c5Vc1Bu7EeB26EctC8iORAIBB4xZv3wZQpU+jevbtSNAh11QM/Pz+mTp3Kp59+qhQwJiUlER4ezqZNm3jttdfYsGEDOp2O/Px8goKCGDt2LM8//7yytfKcOXNQqVSsWrUKf39/jhw5ouzYaLfbsVgsBAQEMHz4cD766CNuuukmSkpKOHLkCLIsc/z4ce6++24qKyvp3Lkzu3btomfPnmi1WhYtWkTv3r3ZvXs34eHhmM1mjh07BsD+/fvx9fXlp59+Ijg4mOzsbEaOHElkZCTLli1TBqDJkyeTk5Oj1EGoVCqSk5OV5MBkMin7LPzwww8eyUFJSQnnzp1TrnNtr4PGVsS3pmUFb54NjfU4cHOllANvXgdCORAIBNc0tb0P3IWKe/bs4ZtvvgG8qwf33XcflZWVfP7550D14Dlp0iTWrVvHzTffzMSJE/nwww8xGo2kpKTwwgsvYLVaOXPmDJmZmdjtdmbPns0nn3xCx44dSU9PV3Zs3LhxI4Ayqz906BA6nY6uXbvy+eef07VrV1atWsXvf/97tFot27dvx2638/PPPxMeHk5aWho6nY6dO3dSUlJCYmIiy5cvx9/fn+3bt+Pn54dWq+Xw4cMUFhZitVqZPn0669atQ6/XU1paynXXXUdUVJTyu0D1RkzZ2dlkZWUREBCg7LPw/fffY7FYlKJHoE7dQc3ZqU6nQ6/XX1PKgTfPhqZ0KkDjBu2mGkd58zpobFfE1Y5IDgQCQb148z4YMmQIQ4cOZeHChdhsNqCuehAWFsZtt93G0qVLFel94sSJlJeXk5KSwoIFC5QCwA0bNtC+fXvmzp3Lrl27sNls7N69m/vuu4+OHTuSl5dHRkaGsmPjnj17sNvtZGdnM3jwYLp168bRo0cxGAyMHz+eI0eOcODAAc6cOYPJZKKoqAh/f39++eUX2rdvz7333svu3bvJy8sjLy+PqVOnYjab0el0Sk3DjBkz2LZtGy6Xi5ycHKZMmYJOp6OgoEDZw2Hy5MnKzwAMHDgQk8nE8ePHlcEnKSmJffv2IcsykZGRhIaGEhQURHp6unKNvXkdNGYWfC0oB01NDkpLSxvcFKm0tBS1Wu2x70VD1NdNIpQDgUBwzePN+2DevHnk5OSwfPlywLt6MHPmTLKysti8eTNQ7XnQv39/Vq1ahclkYvHixRQWFpKenk5mZiZ333031113HXa7ne3bt6PT6Xj22Wc5e/Yshw4dwmw2M27cOGJiYrDZbOTk5CBJEjNnzuTkyZMUFhby6quv0qlTJ6qqqvjmm2/QaDTMmjWLCxcucOTIEYxGI08//TTBwcFUVlZis9no2bMnf/rTnzh79iyZmZnEx8fzwAMPoNFoqKqqUnZynDJlCtnZ2YrN8p133onNZlOMjrRaLcOGDVOSEqhODsxmM3a7ncjISCRJqlOUWJ/XwbWoHFxOchAQEIDdbq+zEVZN3Nes5uZODeHN60AsKwgEAsGv1PY+iI2NZerUqSxevFgZLGurB4mJifTr18+jrXHy5Mls376d3NxcBg8ezP33309lZSUfffQRKpWK1157DVmWlc8YPXo0ffv2paysjPT0dEU9sFgs/PTTTwBMmDABg8FAbm4uBoOBZcuWodFo+Pzzz5FlmXHjxjFo0CAqKyuprKzEZDLx0ksvKbULkZGRPPjggwQGBlJSUkJsbCzBwcFMnz4ds9ms1FtMnz4du92u2CKHh4fTt29fj/0SkpOTPQaOHj16oNPpUKlUysCXkJBwUa+Di0nXDoeDysrKVqccuM+nqR4H0LhajaaqLd68DkRBokAgEPyKN++DOXPmIMsyb7zxBlC/erBjxw5lgB0zZgx6vV5pA5w3bx4hISG899572O12evTowe23387p06f56aeflK4Jh8PBv/71L6DaFjkwMFDZAEmv13PLLbdQUVFBQUEBcXFx/PWvf6W0tJSKigpUKhVLly5FpVJx5MgR5ffo0KEDVqsVPz8//Pz8+OMf/4gsy8puin/6059Qq9XKHg5RUVF07dqVrKwsRboeNWoUdruds2fPAnDLLbcgy7Lyb5VKRbt27QCU2Wp8fDynT59WBkRvXgcXk67Ly8uB1rXpklarxcfHB2i6xwE0zjzqUtQWb90kZWVlDS5ftAZEciAQCBpFbe+DNm3a8Oijj7JixQrFEri2enDrrbcSGhrKsmXLgN88D1atWqVshDRnzhwKCwuVbZwXLlyISqVi9uzZyLLMDTfcQIcOHfj3v/9NeXk5arWam266ibNnzyrdAmPHjkWWZVasWAHAU089Rdu2bamsrCQnJ4fw8HDatm1LcXEx69atQ5IkBg4cCKC4Nrp3WNywYQMul4vg4GC6du3Knj17FHXkpptuoqqqStknYvDgwUiSpGwtbTAY0Ol0nDx5Urlufn5+mM1mRe6Oj48HUBImb14HF5Oum9qS19JxGyC5E6imehxA41pAa7swNobayUFAQABOp5Oqqqomfc7VhkgOBAJBo/DmfTB9+nTCwsKUXRdrqwdarZZp06axZs0aZUY+adIkTp06pWywNHPmTIxGI2+//TYHDx6kc+fOdOvWjZ9//lnZUXHEiBFUVlbyzjvvADB8+HAkSVJcEzt16oRer1fcEiVJYtq0aciyzHPPPYfVaqVt27ao1Woee+wx8vPz8ff3R6vV8sknn5CWlsbx48fx8fHhzJkzilpw44034nA4lF0ce/fujVqtVpZK9Ho9er2eTZs24XK5sNlsaLVaTp06pezA6FZR3PssxMTEoNPp6iwtNEW6bmpLXkunPgOkS1EOLnbdmnrNLtWH4mpHJAcCgaDR1PY+8PHx4ZlnniE1NZXt27cDddWDu+66C5VKxUcffQT85nng3p8gMDCQ4cOHo9PpeOSRR7BYLNx6660YDAaef/55SkpKuOGGG9Dr9SxZsoTs7Gw6deqEr68vGzdu5ODBg5hMJvz8/Dh79qwyi6+5f8Pzzz+Py+UiJCSEqqoqnnzySc6dO0dERAS+vr48+eSTpKWlERERQVBQEC+99BIWi4WuXbtiMBhYvnw5RUVFHjsznjp1CqhOEPLy8ti1axdlZWXodDpFTXAvUxgMBmWfBa1WS/fu3et0LDSl6K2pLXktndq1AE31OIDGDdqXuqxQ0+vgWtmZUSQHAoGgSdT2Prj99ttJTExk/vz5OJ3OOupBUFAQEydO5IMPPsBut3t4HriL+W699VYkSSIrK4tXXnmFpKQkXC4XVVVVvPTSSyQkJKDVavHz82PRokVERkai1+sJDQ3lzTffJCAgAK1WS2xsrDKrDwwMRK/X07ZtW1asWEFeXh59+vQhODiY1NRU0tPTiYuLw9fXl7S0NL777ju6deuGLMvk5+ezZMkSpcPA5XLxz3/+U9mZMTAwUFkq0Wq1hIWFsXr1amVfhR49epCSkqL4JCQkJCj7LAB1OhZqex1cTDnw5gtwNeNNOWjKkgJUL89oNJpmLUiEul4H18rOjCI5EAgETaK294EkScyfP5/Dhw+zevVqoK56MH36dPLz81m3bh3g6XkA1YV9ALfddhtLlixBpVKhVqsZM2YMn3zyCRaLBZVKxa233sqXX35JQUEBkiQxevRoUlNTOX36NFC9L8OuXbuUWbmvry/FxcUMHjyY4uJiunXrRklJCcOGDSM3N5fY2FiqqqpITk7m1KlTxMXF4XK5GDt2LO+88w7+/v6oVCrGjRuntG1KksTtt9/OqlWrqKioQJIkRo0axfr16xXnw1tuuYWtW7cqnQ0191mA6o6FI0eOYLfbgbpeByaTifLycsVDoTbugakpM+uWjDfloKnJgSRJjVJcLkU5cP9OIJQDgUAgqJfa3geJiYmMHz+ev/3tb1RUVNRRD2JjY7n55ptZsmQJsix7eB5AdVtgz549cTqdDBw4kBdffJFOnTrh4+NDv379eOmll2jfvj1BQUHExcXx+uuvYzQaCQsLIzo6mv/7v/9DpVIRExNDeHi4MqvX6XQEBgbSoUMHVCoV33//PX5+foSGhqJSqfjpp5/QaDS0a9cOSZKUboaBAwei0WiUZObGG29ElmXFFXLYsGHY7Xbl3yNGjMBisbBp0yageknDYrEoDorJycnKPgtQrRzY7XalkLO214HJZMLlclFZWen1+peWlmIwGNBoNM37xf6PaA7lAC7eAnopykFtrwOhHAgEAkED1PY+mDt3LiUlJbz77rtAXfVg5syZpKWlsXfvXsDT8wCqB9DvvvuOV199ldLSUux2O7t27eK1117jxIkTaDQaDh8+zPz589m3bx96vZ6zZ88qey7odDoqKyuZNm0a//nPfygsLESSJIYNG0ZKSgoBAQHk5eVhNBr5/vvvMZlMHDt2jKCgIHbv3k1gYCD79u3DaDRy6tQp5syZw1dffYUsy5SWliqf63K5UKvVjB8/nrVr1yLLMu3bt2fw4MFKcpCQkEBsbCzbtm3DaDRy/fXXExAQoNQd9OjRA/jNRrn27PRiA1BrMkACzy6CS/E4cNNQC6jVasVmszX5utX2OvDx8UGn04nkQCAQCLxR2/sgIiKCWbNm8d5775Gbm1tHPRgyZAhdunRRagJqex4kJydTUVHBmTNnWLBgASdPniQjI4OQkBBmzZrFiRMn2L9/P4MHD2bEiBHk5uaSlZWl7LlQXl5OaWkpf/jDH9Bqtaxfv1753KKiIlwuF7Nnz+b06dMcOnQIHx8fZs2axZkzZ/j5559JSEhg2LBhFBYW8vPPP3PvvffSqVMnbDYb2dnZPPDAA0iSRFVVFWVlZcyYMYO8vDxlqWDy5MkcOXIEl8uFv78/ycnJpKWlERYWhlqtZsCAAUrdgdFoJCoqSkkOansdXKy4rjVZJ4NnF8GleBy4aWhZ4XLaP5vaTdIaEMmBQCC4ZGp7Hzz88MMYjUZefvllwFM9UKlUzJgxgw0bNpCdnV3H86B79+506tSJlJQUJk2axIgRIygrK2PTpk08/vjjtG3bllOnTpGfn8+8efOw2Wz89NNPimtieXk5mZmZBAQEMHnyZNatW4csy8TExNCxY0fMZjNTp05lwoQJmM1m1Go1c+fOJSoqitLSUsLDw1m0aBGyLLNt2zY0Gg3z5s2jqqqKH3/8keDgYKZNm4bZbObs2bP07NmTXr16Kf3uo0ePRqfT4XK5lF0aKysr8fX1Baq7NGrWHdQsSqztdXCxtrzWpBzIsuxxPpficeCmoUH7cto/6zNCas2I5EAgEFwytb0PjEYjTz31FGvWrOHnn3+uox7ceeedGI1G3n//fcDT80CSJJKTk9m4cSOyLPOPf/xDKX709fXl+eefx2azsWTJEmJiYhg8eDCnT5/mwoULjBs3DoPBoJgTTZ8+nZKSEiwWCwD9+/fHZrPhdDpZvHixsl00wP/7f/8PWZY5cuQIkZGR/P73v6ewsJDvv/+ekSNHEhERwc6dO7Hb7Tz44IOoVCqllmDChAnY7XaOHj2Kr6+vUuDocrno1asXarXaY9vq2nUH6enpitNezQHoYspBa0oOzGYzDodDGbQvxePAjVAOmg+RHAgEgsuitvfBlClT6N69O/Pnz0eWZQ/1wM/Pj6lTp/Lpp59SUVFRx/MgOTmZ/Px8Dhw4QNu2bbn11ls5evQoX3zxBVOmTMFgMPDee+9RUlKi2B0vWLAAtVpNnz59yM7O5uDBg0RHR9O/f3+qqqqQZZm4uDgANm7ciMFgoGPHjthsNp5++mnFHCkjI4P9+/fz+OOPo9FolFbN8ePHU15ezieffEJwcDChoaHs2rWLoqIikpKSUKvVSl1FTEyMUishSRJqtZrs7GxkWaZHjx4edQfx8fGUlJQoHQ41vQ4uVhHfmpYVans2XIrHgZsrqRzU9joQyoFAIBBchJreByqViueff549e/bwzTff1FEP7rvvPiorK/n888/reB5cd911BAcHKy2OU6dORaPR8Ne//pVz584xYMAAKisreemll4iLi8Pf359Vq1Zx9OhREhIS0Ov1imviHXfcgcPh4ODBg7hcLoxGo9JqqVKp8PHx4cMPP2T58uX4+vqiVqt55JFHCA0NpUOHDhw7dowPPviA/v374+Pjw6uvvkpZWRldu3ZVfA/c2/9u3bqVvLw8fH19MRgMrF69msLCQtRqNWVlZRw+fBiVSuVRd5CQkADgUXfgnp3qdDr0ev01oRzU9my41E4FaHjQvhzjqNpeBxfrimgNiORAIBBcNrW9D4YMGcLQoUNZuHAhNpvNQz0ICwvjtttuY+nSpbhcLg/PA7VazciRI5XkYMCAARiNRgBmz55NYmIi7du355NPPiE/Px8/Pz+CgoJ48cUXCQoKIjQ0lNTUVA4ePEi/fv3QaDSsWbOGsrIyOnToQFpaGgcOHKC0tJTu3bsTGhrKkiVLaNu2LX5+fmRlZbFo0SISExPp3Lkzr7zyCr6+vvj7+1NRUcHbb79NmzZt6NKlC8uXL6e0tBS9Xo9Wq+XDDz+kvLycrl27sn79eo4ePYpOp8NkMrFhwwbAs+4gNDSUoKAgxZOhttdBQ7Pg1q4cXE5yUFpa6nVTpNLSUiWZayreukmEciAQCASNoLb3wbx588jJyWH58uV11IOZM2eSlZXF5s2b63gejB49mhMnTpCZmUn79u3p2rUrAwYMYMeOHRQUFFBRUUHv3r154YUXMJlMDB06lO+++468vDy0Wi3R0dG8+eabSJKEn58fu3bt4syZM0RGRhISEqLUOwwdOhSLxYIkSZjNZvR6PSNHjmT58uUYjUZ8fHzw9/fn448/Rq1Wc+uttyq7O4aHhyPLsqJ+JCcns2LFCoqKiujZsycWi4W1a9ciSRLDhw9Xkp2adQeSJHkUJXrzOriWlIPmSA4CAgKw2+1K0WdN3NfMvblTU6jtdSCWFQQCgaAJ1PQ+iI2NZerUqSxevJiioiIP9SAxMZF+/fopbY01PQ9uvPFGfH19PQbUM2fOMH36dL7++mvsdjszZszgxIkTQHVbYP/+/dmyZQulpaWK78HRo0fR6/UYjUb27dtHYGAgEyZMYP369ciyzPjx47FYLPj4+GC1WvHx8UGj0TB48GC2bdvG6dOneeaZZ/j++++x2+307duX4OBgMjIysFqtTJs2jbVr1+Jyufjd735HcXExp06dIjw8nMGDB5OamorRaOT2228nIyOD7OzsOnUHCQkJ9Xod1CddOxwOKisrW51yEBAQcFkeB9BwrcblqC21vQ5EQaJAIBA0gdreB3PmzEGWZd544w2v6sGOHTs4fPiwh+eBXq/nlltu8UgOMjMzmTFjBlFRUZSVlVFeXs6sWbPIzc3lyJEjzJ8/n/z8fEpKSkhOTiY6OpoVK1YoVsfHjh3D19eXyZMnU1xcjNPpZMCAAURGRlJaWsr06dPJy8tj48aNyo6TZWVldO7cmWHDhmE2m8nJyeGvf/0rp06d4uzZszzwwAPIskxVVRXh4eGMGDGCnJwcjEYjkydP5sSJE4SEhDB06FC0Wi0bN26sU3cQHx/P6dOnKSsrq+N1UJ90XV5eDrSuTZe0Wi0+Pj6X5XEADZtHXa7aUrubpKyszOvyRWtBJAcCgaBZqel94O/vz6OPPsqKFSvIzMz0UA9uvfVWQkNDWbZsWR3Pg+TkZPbv309eXh4DBgwA4ODBg/zjH/8A4KOPPuLxxx/HZDKxc+dOevXqxU033URlZSV5eXk8/vjj7N69G7vdzrhx43A4HOTm5hIXF0dISAhQvWFSfHw8VquVBx98kGHDhnH27FmOHDnCokWLsFqtfPLJJyxatAiAb775hjvvvJPw8HBOnTpFYGAg48ePp6qqitLSUmbOnInZbObChQvKjpA2mw2DwcBNN93kkey46w7i4+MBOHz4cB2vg/qk68tpyWuJuA2QJEm6LI8DaLgFtKYL46VQMzkICAjA6XQqHhetEZEcCASCZqW298H06dMJCwtjwYIFHuqBJElMmzaNNWvWUFhY6OF5MHz4cNRqNRs3bqR9+/bExMSwc+dO+vbtS2JiIjt37uT48eNMmTKF4uJi/vOf/zBjxgzFH2HcuHFERERQWVlJSEgIgYGBHD58GKfTSXh4OJWVlRQVFRESEoIsyxQUFCjdB4888gjjx4+nffv2fPTRR/j4+NC/f38yMjLIyMhgwoQJVFVVsXbtWiZNmgTA559/znXXXYdarWbXrl34+voSEBDAuXPncLlcJCcns3v3boqLiz3qDmJiYtDpdB5LCxeTri+nJa8l4s0A6XKVg/qu2+Vcs6b4ULQGRHIgEAianZreBydPnuSZZ54hNTWV7du3e6gHd911FyqVio8++sjD8yAwMJCBAwd6zLbd6/S///3vkSSJP//5zwwZMgQfHx+effZZpeNg5cqV5Obmcvfdd2O1Wjl69Cj+/v6UlZUpezCo1WrWrl1LWVkZ/v7+bNy4kXbt2jFo0CDOnDnD/PnzGTNmDDabjSeffJLk5GQ0Gg1PPvkkffv2xcfHh4ULF6LX6/Hz82Pt2rWcOXMGPz8/0tPTOXnypLJx0q5duxgxYgSyLJOamupRd6DVaunevbtHx8LFit4upyWvJVKzFuByPA6g4UG7OZYV3F4H18LOjCI5EAgEV4Sa3ge33XYbiYmJzJ8/n+7duyvqgdFoZOLEiXzwwQc4nU4Pz4Pk5GR++OEHysrKlLqD/Px8evfujcFg4OTJk6SkpGAwGKiqquKDDz7Az88PPz8/Fi1axC233IJarWbFihXY7Xaio6NZunQpeXl5dO/enVWrVpGRkUF8fDwbNmxAlmVGjRpFYGAgK1asQKPR4OfnR2pqKrm5ufj6+vLLL7+we/duDAYDeXl5fPHFF/j5+SHLMkuWLEGv1xMYGMg777yDy+UiLCyM1atX065dOxITE0lJSfFad+DN66A+5aC2L8DVTm3l4FKXFKDahlqj0TR7QSJ4eh1cCzsziuRAIBBcEWp6H3z66afMnz+fw4cPs3r1ag/1YPr06eTn57Nu3ToPz4NRo0Zht9v57rvvlLqD3bt3ExcXh0ajYdy4cfznP//B6XQqOyQ6HA7Gjx/Pl19+qSgGu3btoqqqitGjR7Nz507OnTvHiBEj+OWXXzh27BjDhg0jKyuLY8eOkZSUhMPh4Oabb2bdunW4XC5GjRrFF198gUqlYuzYsaxevRpJkhg/fjwrV65UOh/c9RITJkzgiy++QJZlxo4dy/r166moqCA5OZmtW7diNps96g4SEhI4cuQIdrvdw+vAZDJRXl6Oy+XyuK7uAelSZ9ctjdrKweUkB5IkNai4XK5y4P4dhXIgEAgEl0FN74PIyEjGjx/P3/72Nzp16qSoB9HR0dx8880sWbKETp06KZ4H4eHh9OzZkw0bNnjUHYSEhBAaGkpYWBhJSUlUVlYSHh5OYmIi5eXl9OjRg7i4ON599118fHwIDQ2lsrKSIUOG0KZNGyVR8Pf3x2w2M2HCBPz9/UlJSSExMRGdTsdNN91EeHg4paWl3HLLLbRp04bS0lKSk5Px9/envLycO+64A7VaTWVlJZMmTVIK1KZOnYrVasVsNnPvvfdisVj4+uuvGT16NBaLhW3btnnUHcTHx2O328nMzPTwOjCZTMrSRE1KS0sxGAxoNJr/0bfavDSncgD1t4BernJQ0+tAKAcCgUBwmdT0Ppg7dy4lJSW8++67HurBzJkzSUtLY+/evR6eB8nJyWzZsgWbzeZRd5CQkMDhw4eVwsbVq1fz2muv4XK5SElJUVQKm83GmDFjsFqtFBQUMGzYMKxWK0ajkYSEBKxWK7GxsQwbNoyUlBT8/Pzo06cPBw4cYPny5QAsW7aMd955B4fDwX/+8x/mzp2L1Wrlxx9/5J577sFsNlNYWMjQoUOpqqoiMDBQ6YLo0qULgwcPZtWqVXTu3JnY2FhSUlI86g569OgBVNso15yd1jcAtSYDJPiti+ByPQ7ceGsBtdls2Gy2y7puNb0OfHx80Ol0IjkQCASCS6Wm98Hx48eZNWsW7733HkFBQYp6MGjQILp06cLSpUs9PA+Sk5OpqKjghx9+8Kg7cK/TR0ZGcsMNN5CRkcGZM2cIDQ1l8+bNREREMGDAACoqKujRowdqtZrPP/+cbt26IUkSmzZtIjg4GEmS2LlzJ8nJyRw8eJDc3FwlCenRowf9+/dn7969FBYW0qFDB9atW0fPnj3x8fFh2bJljBgxArVazXvvvUdSUhIAn3zyCdHR0ciyzKZNm5g8eTK7d+8mKyuL5ORkNm3ahMvlUuoOjEYjUVFRZGRkeHgd1Fdcd7lV9y0N9/lcrseBG2/LCjU3TLocGtNN0loQyYFAILji1PQ+mD59OkajkZdffllRD9auXcuMGTPYsGEDxcXFiudBt27d6NSpEykpKR51B/Hx8eTl5XHhwgVuvPFGjEYjTzzxBJ07d0av1/P0008za9YsnE4nGzduxN/fn927d5Oenk67du346KOPyM3NpX379qxatcrDqCgpKYnCwkKOHz/O2LFj8fPz44knniA+Ph5fX1+eeuopAgMDKS8v5+OPP8ZoNLJ//34OHz5MUFAQ77//PmVlZYSGhrJ06VJGjx6NwWBQkp3i4mL27t1bx+8gIyPDw+ugvra81qQcyLKsnM/lehy48aYcuJdmLjep8maE1FoRyYFAILji1PQ+WLZsGU899RRr1qzBbrcr6sH48eMxGo28//77iufB/v37SU5OZuPGjbRt21apO3DvaHjo0CE6duyIj48PsiyTnZ1NYmIi27Zt4/jx40q3gU6nIzo6mm+//ZZevXpRUFDA/v37ufnmm0lNTcXhcJCUlKTUHWi1WiWOVqslKCiIQ4cOERUVxZEjR3C5XAwZMoR///vfSJJE7969+eqrr4iMjESWZX766SeSkpLYs2cPx44dUwoZExISCA0NJSUlpU7dQXp6OrIsKwNQfcrB5Zr5tCQsFgsOh4OAgIDL9jhw423Qbi5XSaEcCAQCQTNT0/ugd+/edO/enfnz5zN79myysrJISUlh6tSpfPrpp/Tq1UvxPEhOTiY/P58DBw4okn/Hjh3x9/dXlhYcDgfPPvusYqE8duxY3n33XXx9fZFlGbPZzJw5czh9+jQhISHccMMNlJaWMnnyZGRZZu3atSQnJ7Nr1y7sdjt9+vRh165dxMfHo1KpeOCBB6ioqOD48ePMnj2b4uJigoODiYqKoqKigvvvv5+CggJsNhv33XcfOTk5XHfddURGRrJs2TImT55MTk4OP/74I8nJyaSkpNC9e3el7iA+Pp6SkhLOnTuneB3UVxHfmpYV3DN6t3JwOR4HbrwN2s2pHNT0OhDKgUAgEDQDbu+DuXPn8txzz7Fnzx5Onz6tqAd33303lZWVrFmzRvE8iI+PJzg4WJltZ2ZmUlBQQFxcHOnp6YoMHRsbS2xsLAcOHOCBBx7AZrNRVVVFYmIiZrNZqT04evQoN9xwAw6HA41Gw/Dhw1m1ahWjRo3C4XCwefNmJQkJDw/HZDJRWVnJ1KlTKSoqIjQ0lICAAL7++mseeugh7HY7hw4dIjo6muzsbG699VZkWSYtLY3p06ezbt06IiMjiYqKYvXq1SQnJ5Odnc3Ro0eVugO3EuKuO8jOzkan06HX61t1QaJ7Ru9WDi53SQGufM0BoCRvQjkQCASCZqCm90FOTg5Dhw5l4cKF/PnPfyYrK4vdu3dz2223sXTpUu644w7Ky8tJTU1l5MiRdeoO3Dsa1nxgJycnI0kSixYtYvr06ZjNZgwGA3q9nhdffBGdTseJEyfIycnB39+fzz77jMmTJ5OWlkZxcTF9+/ZVkpDCwkIyMzOVeoA//OEP6PV6/vrXvxIfH09ZWRk7duzA19eX5cuXExERgSzLLFu2DD8/P7777jtGjhyJTqdjxYoVTJ48mfXr19OzZ09MJhMbNmxQ6g6CgoIICgpSkh2314G3WfDltuS1JGorB82VHNS+ZhUVFajVavz8/C7rs2t3kwjlQCAQCJqJmt4HDz30EDk5OezevVtRD+677z6ysrI4ceKE4nkwevRoTpw4QXl5uVJ3EB8fz4kTJ9Bqtcrg0q5dO9q3b8+OHTtwOBxotVp27NhB165d+e6775AkicjISDZs2ECfPn3YtGkT0dHRhISEKLP6LVu2KLUG7jjp6el07NgRo9GIwWDg+PHjxMbGsnbtWnQ6Hb6+vqSlpdGnTx8+//xzxaJ55cqVTJkyhRUrVjBmzBgsFgubNm1SWifddQc///yzRwdGTa+D1qwc1JzRN1dyEBAQgM1mw2q1KscqKysxmUxIknRZn13T60AsKwgEAkEz4/Y+WLFiBVOnTmXx4sVMnz6drKwsTp8+Tb9+/Vi6dKnieRATE4Ovr68yoLoHbZfLxZEjRxQp3r1b3vTp05UZfFlZGS6Xi65du1JZWcmDDz5ITk4Offr0ITAwkI8++ogJEyawZs0ahg0bRlVVFfv27fOoOzh16hQGgwGdTsfvf/97ysvLKSoqom/fvpSXlytbPoeFheHj44PD4WD69OksX76cO+64g+LiYvbs2aN4HiQnJ5ORkYHBYFDqDmorIe6ixJqzYIfDQUVFRatRDtzJgdFobBaPA8BrrUZ5eXmzXLOaXgeiIFEgEAiamZreB/3790eWZcVFcPHixUybNo0dO3bQpUsX9Ho969ev55ZbbvGoOwgKCkKtVisDqnswtVqtzJkzh/bt21NVVUV4eDgnTpxQ6gzMZjOSJHHo0CHuuecePvvsM8aMGUNBQQE5OTlER0fXSUJkWeb48eOEh4cjyzIjRowgJyeHwYMHI8syBw4cwN/fnx9++IHevXtjNpuV89qwYQMjRoxg6dKlTJo0id27dxMdHY1WqyU1NVWpO4iPj+f06dMeboG1pWv3FsGtSTnQarWUlpY2i8cB4NU8yq0cNAc177WysjJkWW6Wz21piORAIBD8T3B7H7zyyis8+OCDrFixgjvvvJOsrCwsFguhoaGsXLlS8TwYNWoU+/fvJyYmBoCff/6ZLl26eCQH7oHBbrfz9NNPY7fbsdvtGAwGUlNTadu2Le+88w5+fn6kpaVx/fXXY7FYFFnfvbSwadMm+vfvT2FhIZIkodVqlXqA7OxsxVth2bJl+Pv78+2336JWq7FYLJw+fZo2bdrw1ltvcd9997F8+XImT57MkSNHCAwMxGAwsGHDBm666SYlCfnpp5/o2rUrAFlZWYrXQW3purkK61oKbhXEvRPllVQOmjs5cKtU7oSttSGSA4FA8D+hpvdBWVkZYWFhfPbZZ4wePZp//OMf3HvvvaxZs4ZRo0Zx6tQp2rRpg1qtVhKEmvUA7ge20WgEqmeNPXr0wN/fn9zcXG644QZOnjxJREQEZWVlqNVqunbtyocffsjYsWP517/+xcSJE0lNTSUpKYmCggLUajVarZa9e/fStWtXj06CgIAA/Pz8CA4Oxmw2M2DAAEpKShg5ciTHjh3juuuu48CBA4rvwYEDB+jRowcrVqxQPA9GjhypGDpZrVbKysrQ6XR1kp2ag5w7OWgtywruGX1zeRxA/cpBc12zi/lQtBZEciAQCP5nuL0Pli1bxj333ENqaipDhgwhKysLo9GISqXi6NGjhIeH88033zBw4MA6kv/hw4cJCwvDarXidDqB32aN/v7+aLVaMjIyCA4O5vTp03Tu3BmLxaLEu+mmmzhz5gyBgYHIsszJkydp27YtW7duVeoOatYD1Jw1Pv3007hcLnQ6HQDnz59HpVKRmZnJqFGjePvtt7nnnnt4//33+cMf/kBqaiqDBw8mJyeHoKAgZFnmzJkzBAQEsGfPHrp3764kO96K3lqbcuCuBWgujwPA66Dt9iVoDtxeB+6Nr1pr3YFIDgQCwf8Ut/fBhg0b6NevHx9++CHJycksW7aMO+64gxUrVnDHHXewbt06hg4dyg8//ECfPn3IzMwkPDycqqoq1Go18NvgWXNg8Pf3p6SkBIvFgiRJ5OTkYDQa2bdvH9HR0Xz99ddcf/31rFq1iuHDh/P5558zatQoNmzYwMCBA9m5cydxcXEcOnSIsLAwCgsLlWSgffv2GAwGvvvuO/R6PT///DMajYa8vDy6detGfn4+Wq0WWZbJzc0lJCSEPXv2EBUVRWpqKomJiWzatMmj7qC2QlFz8GkuM5+WQk3loDmWFAB8fX3RaDR1FJfmVA7gt/oPoRwIBALBFcDtfbB//35uuOEGDh8+TI8ePcjKyiI8PJz8/HwCAgIoLy9Ho9Fgt9ux2WzAbw/mkpISj/+v/cAeP348RUVFDBgwgPz8fIYMGcJXX33FuHHjSE1NZfjw4ezatYv+/fuTlpamxI+MjKSwsFApdHQnIRaLBaie+fr6+ipGS3369MFsNjNixAj+9a9/ceedd7J8+XImTZrEihUrmDhxIqtXr2bcuHFKkeXWrVu57rrr+Omnn+jWrRtHjhyhQ4cO5ObmKttDu1wu4Lfkpzlm2C0B96DdnMmBJEl1FJfmLkiE3xQDoRwIBALBFcLtffDpp58yatQoPvnkE4YPH87q1asZMmQIa9eupX///nz77bf07NmTXbt2ERMTQ3p6OqGhoZw6dQqTycSFCxdQqVTKA9s9qCYlJaHT6fjll1/QaDScOHGCHj168P333xMdHc2ePXsIDw8nPT2dkJAQTp48qdQraLVaioqKgN+SDvcgXVlZiSRJ/O53v0OlUpGTk4NKpaK4uBh/f3/y8/PRaDRKVbvVasVutyPLMhaLBY1Go/y/O/mw2+2oVCocDgculwuXy4XZbFbiGgwGRdK+2nHL/c2ZHEBdI6TmamWE37wO6ktEWwsiORAIBC0Ct/eBw+GgpKSENm3akJWVRdeuXUlLSyMxMZHt27czcOBAtmzZQv/+/T38ASIiIuqs07vbzCwWCyaTiaqqKkX2T0hIYP/+/dx4441s3ryZkSNHsm7dOkaNGsWXX37JLbfcwpYtW+jTpw8HDx5UPl+j0SgDg9v+1263ExAQwIULF9Dr9aSlpTFo0CC2bNnCqFGjWLt2LWPGjFG6If79738zaNAgvvvuO2JjYzl8+DABAQHk5eUBvyUfNZMC9/+3lnoD+C3ZaS6PAzc1W0BlWcZutzfbdXN7HZw/fx6dTieSA4FAILiSuL0PNm/ezIgRI/jPf/7DkCFDSE1NJSYmhszMTPR6PTabjYqKCgIDA8nMzKRTp071Vvi7k4OysjJ8fHwUr4OhQ4eybt06Bg4cyLfffktUVBQnT55Eq9UiSRIFBQWEhYVx8OBBEhISPIofw8PDFSXBXQNQWVmJj48PgwYNwmq1ctNNN7F+/Xquv/56tm3bRkREBFlZWciyjF6vJycnh65du7J792769+9PamoqN9xwAwcOHCAqKqpOkuCO05oMkOA3W+Pm8jhwU1M5cKtHzZlU1ddN0poQyYFAIGgxuL0Pfv75ZwwGA5Ikcfr0aXr16sW3337LTTfdxNatW+nUqRPnz59X3peXl0dwcHAdbwD3wFBcXExYWBgul4uYmBh++ukngoODsVqt5OXlER8fz/fff8/NN9/Mxo0b6dGjh5IsuFwuCgsLad++vdJJcO7cObRaraIcVFRUYDQaMZlMdO7cmb1799KhQweKi4spKSmhS5cu7NmzhyFDhvDNN9/Qr18/fvnlFwwGAzabjeLiYjp06MBPP/1E9+7dOXbsGG3atFEGHnec5lw7/18jyzKVlZVK/ciVVA7cx5qL2kZIrRGRHAgEghaD2/vgwoUL9OjRg61bt3LDDTfw008/Ka2NWVlZ9OrVix07dhATE0NBQQFQLffWpxwUFhYSHh7O4cOHmT59OpIk0a5dO/bv30///v3ZunUrkZGRFBUVUVBQQJcuXfj++++57rrrOHbsGFqtFrvdTmFhIcHBwcryRe0ZfU5ODuPGjaN9+/bIssypU6fo3bs33333HfHx8Rw6dAhZlmnTpg379u1j4MCB7Nixg9DQUEpLS7FarZhMJiUJKSwsBH5TDprTzKcl4HQ6leLO5lYOaicHQjloGiI5EAgELQq398GuXbvo2LEjZWVlZGdn07t3b3bs2EGHDh2orKwkPz+f6Oho0tPT8ff3p6qqCqvV6rEO7HK5UKvVnDt3DqPRiNVqZcCAAbz22mscPHhQGbAlSSIsLIzdu3eTmJjIkSNHkGWZwMBA9u7dS3x8vKJUuJMQk8nkIfsbjUays7OJiYlh6dKl5OXlERsby969e5WWyzNnztCnTx/lPMxmM2fPniUhIYF9+/YREBCA2WympKSE4OBgLly4AHguL7SWZYWaHRjN5XHgpuag7Y7T3MpBcXGxsndHa0QkBwKBoMXx0EMP0blzZ1QqFUeOHCEhIYHMzEyqqqqIiYlhz549BAUF4XQ6OXHiBDExMcosG/CYNfr7+5Odna3syBcfH8/o0aOZOHEiJ0+exGKxEBUVxZ49e+jQoQN2u53jx4/Tq1cvTpw4gcPhICQkhIMHD2IymbBYLBQWFmIwGJRB293SaLFYiIyMJC4ujoULF3Lo0CFCQ0Ox2WycOnWKuLg40tPTcblcdOzYkd27dyuJQ05ODt27d+fs2bMAqNVqzp49i16vb5UFiTXrQZpzSQH+O8oB4NEZ09oQyYFAIGhxuL0PsrKy6Ny5M3l5eeTm5tK9e3cyMzOpqKggJiaG48ePAyizdqieKdacNfr5+VFQUIDZbCY8PJzAwEAAFixYQFBQECEhIaSlpRESEoK/vz8HDx4kPDwcm83GsWPH6Nq1KyUlJRQVFdGpUyeKi4sB0Gg0HgWJKlX149Q9cNx111387ne/o6CggMLCQjp37kxmZiYWi4WYmBh++eUXtFotHTp0YP/+/UqLYnp6OoGBgdhsNnJzcz0UitZUkOie0RcWFl6R5KDmPaBSqfDz82u2z3f/vrIsC+VAIBAI/pu4vQ/OnTtHQUGBkiScP3+ezp07K8sN4eHhWK1WTp8+rSwd1Jw1arVaAIqKioiPj1c+32QysXjxYrKzs2nXrp2y82KbNm3Q6/Wkp6djMpnw9/cnIyMDjUajdBpAdX2Eu1CwplGRe+CQJIlXX32V8PBwjEYjJ06cQKPR0K5dOw4fPozT6aRTp04cPXoUi8VC586dycnJwWaz0aFDB0pKSnA4HB7KQWsrSAS4cOFCsycHAQEB2Gw2bDYbsiwrxa3NhdvrwG63i+RAIBAI/ts899xz+Pn50b59e3Jzc8nPz6dDhw44nU6OHTuGTqcjMDCQnJwcXC4XgYGBmM1mj4JElUql7GGQkJDg8fmDBw9mxowZFBQUcOHCBdq2bYssy2RmZuLr60u7du04ceIEFouFiIgIKisrOXv2LGq1GqfT6aEcOJ1OpWPBjcFgYOnSpVRWVhIYGIjL5eLMmTPo9XratWvHyZMnKSsro1OnTpSVlZGVlaXsB5GbmwtUKxQVFRXIskxVVVWrUg5kWSYvL++KKAdQnbS5k4PmxO11YLVaxbKCQCAQ/Ldxex/k5ubicDgIDQ2lsrKSrKwsNBqN0i547tw5JEnCx8eH8vJyrFYrNptNmc2rVCrKyso8lAM3c+fOJTo6GpPJRGFhIfn5+RiNRgIDAzl9+jSlpaUEBwej0Wg4ffq08nvZ7XaPFkN3AlF7hhoXF8dLL71EcXExFotFSRJOnz6N0+kkLCyMiooKTp06hUqlol27dpSWlpKXl4csy0iSpCQH0Ho2XXInbg6Ho1k7FeC34sPKykpcLhf+/v7N+vlQrRBVVlYq7petDZEcCASCFs0dd9zBTTfdhEaj4dy5cxQVFeHr60tISAhFRUVkZ2cjyzLBwcE4nU7FvdA9oDocDmVA9ZYc+Pr68vbbb1NZWYlGoyEwMBCLxUJ2djY2m43g4GB8fHw4e/YsFRUVSJKEXq/HbDZ7tBhWVlbWOwO+6667uOOOO3C5XBQUFCjdDX5+fuTl5SkbNIWGhmKxWDhz5gySJOHv74/L5VIGOWhdyYGPjw/QvB4H8Ns1ct8DV2IvisjISMrKynA6nYqTZWtCJAcCgaBF4/Y+cG+N7J4Vnjt3TikODAgIQKfTUV5e7uEN4HK5sNvt6PV6jEZjvYNQ3759mT17NmazmcLCQqxWK35+fgQEBGCxWMjNzVXW/d0z//LycmXwsdlsDVbdu+sPOnfujI+PD5IkUVJSQmFhIQ6HA4PBgMlkoqSkhJycHJxOJ7Is4+fnh81mU+Rx97m2Blwul7JHxJVSDioqKnC5XFcsOajtlNmaEMmBQCBo8URHR/PYY48pbYSlpaW4XC70ej2BgYGo1WpKS0spKCjAbrcrg7csy5jNZpxOJ/Hx8Q0WpT366KP07dtXGbwrKirIz8+nrKwMh8Oh1DeoVCqqqqooLS1VNkeSZZni4uIGZ8AGg4Fly5ahUqlwOp1otVr0ej1qtZrKykrOnz+vzETVarUywFksFiorK1vlsoIkSc3ucQD/PeXA/b24E8fWhEgOBALBVcFDDz1E9+7dlUHVvX1zSUkJFy5coLi4WKlOdzqdysBQWVlJeXm51yWFmmi1Wt555x3F699dw+Dr64u/vz8ajYaqqirFRdH9+e5ZvsPhuKg8HhcXx8svv6wsFZSXl1NVVYXD4UCj0eDj44PJZMLPz0/ZjbGiosKjG6I1KQcul6vZlxSgeqmoZiHnlUoOJElS7rXWhkgOBALBVYFOp+O1117D5XJRUVFBRUWF4opot9txOp0e/yspKcHlcimz/NqdCt6IjY3lueeeU2x93QVnJSUlFBcXU1paSlVVlbLtssvlUuJJktSoge6uu+5i8uTJii+C+3McDofSaVFcXExRURFFRUWUlZVRVVWlKAdXYqD7X9DYhOpSkCRJsbe+kgWJrTk5uOo3BXfKMoUWJ/lmBxfMTiodLpyyjFqS8NeoaOurpp2vhhC9GvVl9LmKOCJOazqXqzXOgAEDuPvuu3n//feB6i4EtVqNWq1GpdYQFNGZoE4xhHTqSmX0dUx+6f9AdmEtKyGgRyL5ZsdF48yYMYOUlBQ2b96sxHAP5JJKTXDHaNp0jqVt524Ygtug1upw2G3YykswB4ZfNIa7/mD//v3KXgsul0tZ8pBlGbVGS0inGNrFdKdt524YQ9oiqbVoVLA9z0pbX0eL+26aEuesM4AJ899BhUxUdCfSiyzNHqf/3X9G3TmGOxd0JjCuB9+drWzW88EYTM+Rv8PQIZKSiF6MevIVDjoDKGjGOP9LJPkq7cEosznJKLLyS5GFSruMS5ZRSRKuGqfj/rdKkvDXSvQK1hMf7INJpxZxRJxGx2lN59Ia4hQXFzNgwADFETGgfRg9R02gz60T8Q9ug0qtweVyotXqcDgcIEngcuLnb2h0nOzsbG688Uby8/MBMLXrQO/kO+itxFDjcrpQqdXIgATIsgs/P/9Gxzh06BDDhg2jpKQESZKQJImA9mH0Tr6DnqPvwD+oDZJKjez6LY5KkvDz9W2x301j4zhcTixmC5IkodNqUGu0zR7HYjajUquVehGdVtvs51NlNuN0ONDpfXDYHfjofdCo1JcdpyVw1SUHVqeLH85V8UuRtTp7k0GjklCB12IjWZZxAQ6XDBKoJYlewT4M6uCHj7r+VRURR8RpTefS2uJ88cUXPPDwIyTd/Sf63jYZtVaHjIzDZsXlcFTXC+h8MFvMSJKEVqslJDikSXFWrVrFnx55jEF3P0SfMZPR1I6BhMxvj0+dVktwE2N8/PHHPPDAA6i0Ptw8YzZ9bvOMIzscNSJUGyK1bdO2RX83jYljd9i5cOECkiQRHBSMTqdr9jglJcXIMlisFgICAvD382/28ykrKcZqteHn50eVuYqQkBC0Gu0lx2lJXFXJwZlyO5tyKii1OVEhoZG839D1IcsyDhlcyATq1IyIMNDRqBVxRJw6cVrTubTGOKfLbfxr52E0hkCcTgf2X5MA5F/n8VJ1jYLVakWSpOq2RFNAk+KcLrfx/q4jqPwDfotBjXOpdVp6vZ6gwKAmxZBlmcdeeAVVwo0EdYjE6XTgsJh/+/CaMWTQ6bSEhLS5pGvWku6BmslB2zZt0Gh++5zmilNSWm0/bbPZCAoMxNfXc2+F5ohTWlZdg+Ln64vZYlGSg0uJ09K4apKDXwotbD5biUuW0UoSqstYx3HJMvZfZZ9h4f70CtGLOCKOEqc1nUtrjuNwuigrLsTpcNR5v4SEVqvBZrcjIWEKMOHvV7co7WL3gNPloqyoCIfD7iUG1UsWsgxStWGRyVi3zfCi55JTQUWVGUtlOfKvHQm1zwWpepDR++gJDg6+5GvWUu4Bm91GQUEBkiTRvn17VFLd2fTlxiktK8Vms2G32wkODkbvo6/zM5cbp6KyupNEr9djtVq9JgeNidMSuSoKEqv/gKq/IJ1KuuwNNFSShA6wuWQ251SbV/QK0Ys4Ig5AqzmX1h5Hr1bh9PPzuvGNjPzb+rlEvQ/si90DPioVJpOR4uLiOha5MvyqVIAky6jV3teUL34u4K/XYanwPk+TkXGvLUiq+q9rS/puLhbHfS0lSfKaGDRHHJVKpbR/NvS7XE4ctVoNMnXujabEaam0+OTgTLldydya48Z2I0kSOtWvX9TZSqxOmR3nq0ScazhOas6v7UgyV/25XCtx/P39FZ+A2siu3x7YGm39j7qL3QN6Hz2+vr5UVVXV+xky1JscNO5ctAQEBCjWzw19zsVebynfTUO4B1O1quH198uJI0mSRxJyJeKo1WqQftt++mLUjhOoU7fYJYYWvaxgdbr46FgppTYnOqn5buyayLKM1SX/WgmMiHONxnG5XFT9+vftp6be2czl0NquWUuJ45aoa+MeHNQqNe3bt79onIbuAZfs4sKFCzidTq/vlZBo07ZNvQpF485FprikpEGffn9/f4/aiUuL03xcahyz2UxxSTE+Pj6EBIdckThV5mp/C1mWadu27UW/m0uJ43Q5yc/PR61W43K5GlxWqB3HJlfXIEyNDWiRRYot7zeqwQ/nqii1OdFeoRsbfs0oZXDK7qVDEedajGOXvf93c9LarllLiaPT6vDz9a37RvfsVNO4FrKG7gGVpCIwMLCBX7Jh5UD5sQbPRSIgIOCiCkRjaCnfTX245Oos7GLKweXEuZRzbmocxcjK1bSHhiRJaCWJEpuTH87Vr0j9L2mxyUGZzckvRVZUXF7xzMVwyTJuQdJdUSriXFtxqguFfvu33XXl4rSWa9bS4pgCAuo8yN0/5d7c52IxLnYP+Oh88PPzoz4a85y62LmoJFW9BYfw22B0uXGai0uN4xasVY1IqC41TmOv1eXEkZBQqVTIcuOWFTx+P0lChcQvRVbKbN4Vqf8lLTY5yPi1n1Rz5fICoPoG8Ph3079jEecqj1Mzhvt2u9JxrlSMazWOSlLVu+eAVntxmbex90BAQIDXQaf62MUfVo05F61GS0A9mys1djbckr4bb7icvyoHjUwOLiXOpSgHlxJHpVJdcuqlkardFjOKrJf4CVeOFpkcOGWZX4oscAXlMKjOXu2/ykHuKHaX7GFsIuK07jjeYvy34lyt16ylxvH7dbOd2mguMgA15R6QkLzO7BujGjTlXPz9/dHpdHWON+Z52BK/m9o4XdUz5cYkB5caR6VS0ZRTvtQ4arW6Ud0K3nAvY/xSZKk2V2pBtMjkoNDipNIuo2mgbcdN5r5dpH+/kb3rVyvHVr4w2+Pf9eGi7r0j/3q8uWKIOC07jrcY3uJcDedyrcWp+9kSqf94ifTNX3n8/MWk64vdA7Xj6LQ6Nv1joUecxkjYTT2XTf9YSEatc2lMctC0OE37Pporjru6v/mv229xqq+V3Ag95/LiqFWXZ4usUUlU2qv3hGhJtMjkIN/sqPamvsjPFeVm42cMIKxrHNs++5dyPLxbAoW5Zy4ap3YNieTl+OXGEHFadhxvdUS141wt53ItxSk46/2zI3v0oqIgv1GfXV+MxsSJ7plIaV6u8m9VIwaIpp5LRLee2MpKPN/TqLqGpsVpyvfRXHEa4z9wuXFUUtPk/kuN09iC1/pQUa1aXDDXbcf9X9Iik4MLZieqRnQoFJ3LISw2jvRtm4jpN1A5nnDTSELCOl40jtskpXaUmpuPXG4MEadlx6kvRs3XrpZzuZbiFJ3LrvezI7rENuqzLxbjYnHCo3+L05A50cXiNBSjXcfO+Pj4KMca02J7KXEa+300VxxvTpDNHee34aOxHRSXFkdZGrmMpQVJksg3C+XgolQ6XB4Pmfroklj9RaVt3UDCkFEer7m/xPTvNypyUOa+XR4/U1+EmqEbE8NcUca2z/7lkVVeiTju81j75vw659LccXKPHWLv+tVe5cbmiuMm/fuNV/R8Vr4wm9xjh8g9doiUJa83KkbNOI09l22f/Uu5367kuZgr6joCNncc93lc6fPZu3416d9vZNtn/yL32KFGx+nct/7P7tIvqXpfhcoK9n31GT+sft/j9drPhIbugYbidO9/EwDWygr2/OfjOn//tZ8Ll3IuMf0GEhIcrJzLzi8+qHMutZ8JlxrH2+9cM07tZ8LlxHHYLOz/alWd76ZmvMs/HwmXzer1HvD2TLjUOFqtFqfVwk/r6saBhp8LblyyTNWVqhq9RFpkctCUwgxzRRm5xw8pDyKA3OOHCA6LpCg3m8x9u0gYMorrx0xi22fLPN7b2CgNxQA4sW8XVWXF9b6/OeK4H5zXj5nEqPsfZ+ULj12ROOaKMr5fuZSw2DgSbk5m7Vvzr0icmj/z/cqlWLwMeM0Vp+hcNv964j5Slr7BkD/cf0ViLH9yOtePmUjCkFF8v3LpFTmXotxs0rdt5PU/jGDB2P48MyyuzkO8ue6BonM5JAwZRcKQUU1K3JoSJ/fYIeXv86Yp00lZ+kaT4jT02W1C2lCecwLZZvFQIL09Ey52Lg3Fad++PQUnDuO01jUuqv1cuNRzAcnrudT3TLj0ON6fZfU9Ey4nTkHmIVw2s1d1uPYz4XLiFJ064jWOt2fCpcbRqDUUZx31Gudiz4WaOFpYQWKLtE9WN6FDoTg3h+AOkV5fO7F/F3qDQfm3r8FE5r5dyhfc2CgNxQBIGDIKc3kp5opyr683R5yq8lLloeZrMOFnCiT32CHCYuOaNY6vwcRD//eF8nO1Z/nNFcdN+tYUet482utrzRVnyO9n1sn4mzNG7rFD+BpMyn+7r19zxyk6l8OzX+5WYu1dv5rrx0xq9ji+BhN716+mS7+BhMXGefwNNWeczP27COoQ7nGsKff0xb73XjePxlpR7vF36e2ZcGr/Ljr2rXufNyaOWqXm+lHj2Lt+dZ2//9rPheY+l/qeCcEx3S85jrdnWX3PhOY+Hze1nwlXIo63Z0Jzx2nMc6EmmivYmXcptMjkwF+jarTxkd5g9Ph3+vcblS+9MPcMfqYg5TVfY4DHDLW+CLVDNxSjMTRHnC6JAz2y1qqyEo+HaHPFceOWXH///Ft1P6+Z4uQeO0RMv4Gkb9vk/fOaKU7O0TQAzOWlAB4DakN3Wc04DcU4eyydonPZFOfmALD2zfmMf3x+s59Lze9/7/rVJNycXPfzmiEOwKiZj/P/HryTsK5xTHt9+RWJE9whgrNH05XXis/lKOu7jYlzKX+X3p4J1nqS+suJ4/WzmjlGfc8Eq9O7PH2551L7mdDc5wPenwlXIo63Z0Jzx2nMc8GNSpLw07QsIb9FJgdtfdW4ZLlR9pXBYZHE3zSCvetX4/trRWlDuG8G+LU3Wa7uYq0ZpXZi0tQYtWnuOGvfnM/v5rx4ReNcP2YSQR0i2bjkzTo3dHPFKTqX3eAfWHPFSb7/CeW/35g6ioSbk5WMvr4YteM0FMNcUV597NdB7eyx9Doz4Ob8bopys6tjGuoa5TRXnJyjaTz03hekLH2D5U9MqzPraY44CUNGkbY1BXNFGWePZgCgr3VODcW53L9LN5aK6mdCffdAc8W5kudS85lwpeLUfiZciTjenglXIo63Z4LGz9iscRrzXIDqTgVZlmnne3ldD81Ni0wO2vlqUEkSLqAxl6vmF12TkLCOHjKPubyUoBrSUO0CY7me4w3FaAzNGSf9+410SRzodVBtrjjmijJ8DSa6JA5k5QuPkTBklMcMpTnibPvsXwR3iCD9+42cPZpOUW42wR0iaw2olx8n/fuN5BxNU17XG4wU5+bg+2scb59VX5z6YgR3iPCQHH2NAXVmwM15D+xZv4ouiYO8vtZc16xL4iDCYuOY9tq/lGK35r4HAH7//FvkHjtEeLd49AYj4d3im3Q+Tf279PZMCAmrKxdfbhxvNPe5uKn9TLgScbw9Ezr3G9Cscep7JrTv2qNZ49T3TGjuOI15LkC1j4IkSbT1bVnDccvSMX4lRK/GXyvhaOJmFrWJ6TfQQ7YsOpft+YCj7kxBovkvSnPFydy3C73BRMKQUeQeO0RRbnazx9m7fjXff7pE+befKRA/Y0Czx7lpynSl4C2oQzhdEgfW+aNpjjjBHSI9BlJLRbnnoO0lRlPjxCQOpOjcb99F8bkcYhI917Cb817L2JZKcIcIr681RxxzeanHd94lceAVuQfMFWWsfGE2YbFxmMtKCY9NqKOGNPffqLdnQtd+Ay/7HmgMV+J54+2Z0Nxx6nsmNHec+p4JzR2nvmdCs99rjXguADhcMv5aiRC9UA4uilqS6BWsZ2deFbIsX7KFcnBYJD1vTib9+42Yy0sZ8vuZHq9LkoT217213WmIViUhNbrcqprMfbvI3LcLc0UZwR0i6ha6NEOcotxsjw4FS2U5L232bP1qjjgJNydz4tfzydz3A9ePmVS3tqGZrhtUX7sT+3dTfO4sYV3jPDoZmiNOWGyc0kaUczSN+1717FipHcP9yU2J42swccOYSUpR2qiZj9cZ5JrzmukNRnzr2ba3OeJUV/H/i7PHqgfRmtJoc8Zxz0TTv99I0bkcr+uxlxPH29+lt2fC5d4D9f39ezvenOfS0DOhOeM09Exozjg1X6v9TGjOOPU9E5r7XmvMc0GWZZCgV7C+SYX4/w0k+VJNoa8wZTYny4+UIMvVX9CVwiXLVDl/uwR+muqdskScaydO7Rj/rThX8zVrbXHEPSDi/DfjuLG7ZCQJpnUPxKRrWcpBi1xWADDp1PQK9sGF3ChDpEtFJUmKfKKRuGI3gojTcuOoJAltjY/Vqq5cnNZyzVpbHHEPiDj/zThQnYi4kOkV7NPiEgNowckBwKAOfgTq1Nh/rea8ErhlHbVU3bIi4lybcTwGhiv0PGht16y1xRH3gIjz34xjl2UCdWoGdfC7IjEulxadHPioVYyIMKCSpOp1oGb+omRZxuaSUaskbg7zF3Gu4Th2uXq2qFWB3dX8D4XWeM1aWxxxD4g4/804KkliRIQBH3XLHIZb5m9Vg45GLcPCm/+LqvkFDQv35/p2viLONR5nRIThiiSjrfmatbY44h4Qcf6bcToatc3yuVeCFtmtUJteIXoANp+txCbLaKlrttIUXL9KOipV9Rfk/nwRR8Rx01rORcS5tDit6VxEnJYdp6XSYrsVvHGm3E5qTgUlNicqJDTSxR0UayLLMg4ZXFSv9YyIMHjN3EQcEac1nYuIc2lxWtO5iDgtP05L46pKDgCsThc/nKvilyJr9e6NMmhUUrWBhZcvTJZlXFQbTVQXmkj0CvZhUAe/Btd6RBwRpzWdi4gj7gERp+XHaUlcdcmBmzKbk4wiK78UWai0V68JSZLk0faokiTluL+22lgpvoltIyKOiNOazkXEEfeAiNPy47QErtrkwI1Tlim0OLlgdpBvdlLlcOGQZTRS9S5X7XzVtPXVEKJXX5YDlYgj4rSmcxFxxD0g4rT8OP9LrvrkQCAQCAQCQfNydSx+CAQCgUAg+K8hkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBByI5EAgEAoFA4IFIDgQCgUAgEHggkgOBQCAQCAQeiORAIBAIBAKBB/8fq4Q5o9p830cAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = PreProcessor(data, transform_config, dataset.data_dir)\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The hypergraph has 8 hyperedges.\n", - "Hyperedge 0 contains the nodes [0 1]\n", - "Hyperedge 1 contains the nodes [0 1]\n", - "Hyperedge 2 contains the nodes [1 2]\n", - "Hyperedge 3 contains the nodes [2 3]\n", - "Hyperedge 4 contains the nodes [3 4]\n", - "Hyperedge 5 contains the nodes [4 5]\n", - "Hyperedge 6 contains the nodes [5 6]\n", - "Hyperedge 7 contains the nodes [6 7]\n" + " - Hypergraph with 17 vertices and 17 hyperedges.\n", + " - Features dimensions: [7, 7]\n", + "\n" ] } ], "source": [ - "incidence = data.incidence_hyperedges.coalesce()\n", - "indices = incidence.indices()\n", - "\n", - "print(f\"The hypergraph has {data.incidence_hyperedges.shape[1]} hyperedges.\")\n", - "for he_idx in torch.unique(indices[1]):\n", - " corresponding_idxs = indices[0] == he_idx\n", - " nodes = indices[1, corresponding_idxs]\n", - " print(f\"Hyperedge {he_idx} contains the nodes {nodes.numpy()}\")\n", - " if he_idx >= 10:\n", - " print(\"...\")\n", - " break" + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" ] }, { @@ -302,13 +285,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Model configuration for hypergraph UNIGCN:\n", + "\n", "{'in_channels': None,\n", " 'hidden_channels': 32,\n", " 'out_channels': None,\n", @@ -328,11 +314,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ - "y_hat = model(data)" + "y_hat = model(lifted_dataset.get(0))" ] }, { diff --git a/tutorials/graph2simplicial/clique_lifting.ipynb b/tutorials/graph2simplicial/clique_lifting.ipynb index ba468613..414a085b 100644 --- a/tutorials/graph2simplicial/clique_lifting.ipynb +++ b/tutorials/graph2simplicial/clique_lifting.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# SimplicialCliqueLifting Tutorial" + "# Graph-to-Simplicial Clique Lifting Tutorial" ] }, { @@ -45,21 +45,29 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 147, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "# With this cell any imported module is reloaded before each cell execution\n", "%load_ext autoreload\n", "%autoreload 2\n", - "import torch\n", - "from modules.io.load.loaders import GraphLoader\n", - "from modules.io.preprocess.preprocessor import PreProcessor\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", "from modules.utils.utils import (\n", " load_dataset_config,\n", " load_model_config,\n", " load_transform_config,\n", - " plot_manual_graph,\n", + " describe_data,\n", ")" ] }, @@ -79,13 +87,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 148, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Dataset configuration for manual_dataset:\n", + "\n", "{'data_domain': 'graph',\n", " 'data_type': 'toy_dataset',\n", " 'data_name': 'manual',\n", @@ -102,7 +113,7 @@ "source": [ "dataset_name = \"manual_dataset\"\n", "dataset_config = load_dataset_config(dataset_name)\n", - "dataset = GraphLoader(dataset_config)" + "loader = GraphLoader(dataset_config)" ] }, { @@ -114,53 +125,41 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 149, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset only contains 1 sample:\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = dataset.load()\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The graph is undirected and has 8 nodes and 13 edges.\n", - "The nodes have features have dimension 1.\n", - "There are 0 isolated nodes.\n" + " - Graph with 8 vertices and 13 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n" ] } ], "source": [ - "print(\n", - " f\"The graph is undirected and has {data.x.shape[0]} nodes and {data.edge_index.shape[1]} edges.\"\n", - ")\n", - "print(f\"The nodes have features have dimension {data.x.shape[1]}.\")\n", - "\n", - "connected_nodes = torch.unique(data.edge_index)\n", - "isolated_nodes = []\n", - "for i in range(data.x.shape[0]):\n", - " if i not in connected_nodes:\n", - " isolated_nodes.append(i)\n", - "print(f\"There are {len(isolated_nodes)} isolated nodes.\")" + "dataset = loader.load()\n", + "describe_data(dataset)" ] }, { @@ -187,13 +186,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 150, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Transform configuration for graph2simplicial/clique_lifting:\n", + "\n", "{'transform_type': 'lifting',\n", " 'transform_name': 'SimplicialCliqueLifting',\n", " 'complex_dim': 3,\n", @@ -225,93 +227,41 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 151, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /Users/leone/Desktop/PhD-S/projects/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2744620725\n" + "Transform parameters are the same, using existing data_dir: /Users/gbg141/Documents/TopoProjectX/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2744620725\n", + "\n", + "Dataset only contains 1 sample:\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "data = PreProcessor(data, transform_config, dataset.data_dir)\n", - "if dataset_name == \"manual_dataset\":\n", - " plot_manual_graph(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "The simplicial complex has 6 triangles.\n", - "Triangle 0 is composed from nodes [0 1 2]\n", - "Triangle 1 is composed from nodes [0 1 4]\n", - "Triangle 2 is composed from nodes [0 2 4]\n", - "Triangle 3 is composed from nodes [0 2 7]\n", - "Triangle 4 is composed from nodes [1 2 4]\n", - "Triangle 5 is composed from nodes [2 5 7]\n", - "\n", - "The simplicial complex has 1 tetrahedrons.\n", - "Tetrahedron 0 is composed from nodes [0 1 2 4]\n" + " - 4-Complex with dimensions [8, 13, 6, 1].\n", + " - Complex features dimensions: [1, 1, 1, 1]\n", + "\n" ] } ], "source": [ - "edges2nodes = [[] for _ in range(data.incidence_1.shape[1])]\n", - "indices = data.incidence_1.coalesce().indices()\n", - "for i in range(data.incidence_1.shape[1]):\n", - " edges2nodes[i] = indices[0, indices[1, :] == i]\n", - "edges2nodes = torch.stack(edges2nodes)\n", - "\n", - "triangles2edges = [[] for _ in range(data.incidence_2.shape[1])]\n", - "indices = data.incidence_2.coalesce().indices()\n", - "for i in range(data.incidence_2.shape[1]):\n", - " triangles2edges[i] = indices[0, indices[1, :] == i]\n", - "triangles2edges = torch.stack(triangles2edges)\n", - "\n", - "incidence_2 = data.incidence_2.coalesce()\n", - "indices = incidence_2.indices()\n", - "\n", - "print(f\"The simplicial complex has {incidence_2.shape[1]} triangles.\")\n", - "for triangles_idx in torch.unique(indices[1]):\n", - " corresponding_idxs = indices[1] == triangles_idx\n", - " edges = indices[0, corresponding_idxs]\n", - " nodes = torch.unique(edges2nodes[edges]).numpy()\n", - " print(f\"Triangle {triangles_idx} is composed from nodes {nodes}\")\n", - " if triangles_idx >= 10:\n", - " print(\"...\")\n", - " break\n", - "\n", - "incidence_3 = data.incidence_3.coalesce()\n", - "indices = incidence_3.indices()\n", - "\n", - "print(f\"\\nThe simplicial complex has {incidence_3.shape[1]} tetrahedrons.\")\n", - "for tetrahedrons_idx in torch.unique(indices[1]):\n", - " corresponding_idxs = indices[1] == tetrahedrons_idx\n", - " triangles = indices[0, corresponding_idxs]\n", - " nodes = torch.unique(edges2nodes[triangles2edges[triangles]]).numpy()\n", - " print(f\"Tetrahedron {tetrahedrons_idx} is composed from nodes {nodes}\")\n", - " if tetrahedrons_idx > 10:\n", - " print(\"...\")\n", - " break" + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" ] }, { @@ -330,13 +280,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 154, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Model configuration for simplicial SAN:\n", + "\n", "{'in_channels': None,\n", " 'hidden_channels': 32,\n", " 'out_channels': None,\n", @@ -359,11 +312,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 153, "metadata": {}, "outputs": [], "source": [ - "y_hat = model(data)" + "y_hat = model(lifted_dataset.get(0))" ] }, { @@ -372,21 +325,6 @@ "source": [ "If everything is correct the cell above should execute without errors. " ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": {