From 205cadc1afaf75c247237cec8072f21d94ce899b Mon Sep 17 00:00:00 2001 From: David Leko Date: Mon, 3 Nov 2025 23:28:48 +0100 Subject: [PATCH 01/11] =?UTF-8?q?Category:=20B1;=C2=A0=20Team=20name:=20DL?= =?UTF-8?q?LB;=C2=A0=20Dataset:=20FakeDataset?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: luka-benic Co-authored-by: dleko11 --- .gitignore | 2 + configs/dataset/graph/fake.yaml | 50 + configs/dataset/graph/fake_inmem.yaml | 48 + test/_utils/simplified_pipeline.py | 9 +- test/data/load/test_datasetloaders.py | 33 +- test/memory_usage_tracking/memory_plotting.py | 242 +++ test/pipeline/memory_checks_template.py | 43 + test/pipeline/test_pipeline.py | 28 +- topobench/data/datasets/__init__.py | 11 +- .../data/datasets/fake_on_disk_dataset.py | 245 +++ .../data/loaders/graph/fake_dataset_loader.py | 60 + .../graph/fake_ondisk_dataset_loader.py | 62 + topobench/data/preprocessor/__init__.py | 2 + .../data/preprocessor/on_disk_preprocessor.py | 309 +++ topobench/data/utils/__init__.py | 4 +- topobench/data/utils/split_utils.py | 238 ++- .../tutorial_on_disk_inductive_pipeline.ipynb | 1654 +++++++++++++++++ 17 files changed, 2956 insertions(+), 84 deletions(-) create mode 100755 configs/dataset/graph/fake.yaml create mode 100755 configs/dataset/graph/fake_inmem.yaml create mode 100644 test/memory_usage_tracking/memory_plotting.py create mode 100644 test/pipeline/memory_checks_template.py create mode 100644 topobench/data/datasets/fake_on_disk_dataset.py create mode 100644 topobench/data/loaders/graph/fake_dataset_loader.py create mode 100644 topobench/data/loaders/graph/fake_ondisk_dataset_loader.py create mode 100644 topobench/data/preprocessor/on_disk_preprocessor.py create mode 100644 tutorials/tutorial_on_disk_inductive_pipeline.ipynb diff --git a/.gitignore b/.gitignore index e618d5221..fdcde230e 100755 --- a/.gitignore +++ b/.gitignore @@ -185,6 +185,8 @@ notebooks/tmp /tutorials/datasets/ /tutorials/lightning_logs/ /tutorials/datasets/ +# Memory usage tracking outputs +test/memory_usage_tracking/outputs/ # wandb wandb/ diff --git a/configs/dataset/graph/fake.yaml b/configs/dataset/graph/fake.yaml new file mode 100755 index 000000000..c29c7091f --- /dev/null +++ b/configs/dataset/graph/fake.yaml @@ -0,0 +1,50 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.graph.FakeOnDiskDatasetLoader + parameters: + # Framework-specific data organization + data_domain: graph + data_type: FakeOnDiskDataset + data_name: FakeOnDiskDataset + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + memory_type: on_disk + + # FakeOnDiskDataset specific generation parameters + num_graphs: 500 # Total number of graphs to generate + avg_num_nodes: 100 # Average nodes per graph + avg_degree: 8.0 # Average connections per node + edge_dim: 0 # Dimension of edge features (0 for none) + is_undirected: True # Whether to make graphs undirected + backend: 'sqlite' # 'sqlite' backend + + # Parameters linked from the main 'parameters' section below + num_channels: ${dataset.parameters.num_features} # Use num_features for node feature dim + num_classes: ${dataset.parameters.num_classes} # Use num_classes for generation + task: ${dataset.parameters.task_level} # Use task_level ('graph' or 'node') + +# Dataset parameters +parameters: + num_features: 64 # Node feature dimension for the generated data + num_classes: 5 # Number of classes for the generated labels + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: graph # This will be passed to the loader's task parameter + +# Splits +split_params: + learning_setting: inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.8 + valid_prop: 0.1 + test_prop: 0.1 + + +# Dataloader parameters +dataloader_params: + batch_size: 32 # Adjusted for potentially larger graph data + num_workers: 0 + pin_memory: False diff --git a/configs/dataset/graph/fake_inmem.yaml b/configs/dataset/graph/fake_inmem.yaml new file mode 100755 index 000000000..90785b36e --- /dev/null +++ b/configs/dataset/graph/fake_inmem.yaml @@ -0,0 +1,48 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.graph.FakeDatasetLoader + parameters: + # Framework-specific data organization --- + data_domain: graph + data_type: FakeDataset + data_name: FakeDataset + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # FakeOnDiskDataset specific generation parameters + num_graphs: 500 # Total number of graphs to generate + avg_num_nodes: 100 # Average nodes per graph + avg_degree: 8.0 # Average connections per node + edge_dim: 0 # Dimension of edge features (0 for none) + is_undirected: True # Whether to make graphs undirected + + # Parameters linked from the main 'parameters' section below + num_channels: ${dataset.parameters.num_features} # Use num_features for node feature dim + num_classes: ${dataset.parameters.num_classes} # Use num_classes for generation + task: ${dataset.parameters.task_level} # Use task_level ('graph' or 'node') + +# Dataset parameters +parameters: + num_features: 64 # Node feature dimension for the generated data + num_classes: 5 # Number of classes for the generated labels + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: graph + +# Splits +split_params: + learning_setting: inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.8 + valid_prop: 0.1 + test_prop: 0.1 + + +# Dataloader parameters +dataloader_params: + batch_size: 32 # Adjusted for potentially larger graph data + num_workers: 0 + pin_memory: False diff --git a/test/_utils/simplified_pipeline.py b/test/_utils/simplified_pipeline.py index 39c949210..05da39cac 100644 --- a/test/_utils/simplified_pipeline.py +++ b/test/_utils/simplified_pipeline.py @@ -1,12 +1,9 @@ """Test pipeline for a particular dataset and model.""" -from omegaconf import OmegaConf import hydra -from lightning import Callback, Trainer -from lightning.pytorch.loggers import Logger from omegaconf import DictConfig, OmegaConf -from topobench.data.preprocessor import PreProcessor +from topobench.data.preprocessor import OnDiskPreProcessor, PreProcessor from topobench.dataloader import TBDataloader from topobench.utils import instantiate_callbacks from topobench.utils.config_resolvers import ( @@ -61,7 +58,9 @@ def run(cfg: DictConfig) -> DictConfig: dataset, dataset_dir = dataset_loader.load() # Preprocess dataset and load the splits transform_config = cfg.get("transforms", None) - preprocessor = PreProcessor(dataset, dataset_dir, transform_config) + memory_type = cfg.dataset.loader.parameters.get("memory_type", "in_memory") + preprocessor_cls = OnDiskPreProcessor if memory_type == "on_disk" else PreProcessor + preprocessor = preprocessor_cls(dataset, dataset_dir, transform_config) dataset_train, dataset_val, dataset_test = ( preprocessor.load_dataset_splits(cfg.dataset.split_params) ) diff --git a/test/data/load/test_datasetloaders.py b/test/data/load/test_datasetloaders.py index cb21fd421..de0dcb27c 100644 --- a/test/data/load/test_datasetloaders.py +++ b/test/data/load/test_datasetloaders.py @@ -1,12 +1,11 @@ """Comprehensive test suite for all dataset loaders.""" -import os -import pytest -import torch -import hydra from pathlib import Path -from typing import List, Tuple, Dict, Any -from omegaconf import DictConfig -from topobench.data.preprocessor.preprocessor import PreProcessor +from typing import Any + +import hydra +import pytest + + class TestLoaders: """Comprehensive test suite for all dataset loaders.""" @@ -18,10 +17,10 @@ def setup(self): base_dir = Path(__file__).resolve().parents[3] self.config_files = self._gather_config_files(base_dir) self.relative_config_dir = "../../../configs" - self.test_splits = ['train', 'val', 'test'] + self.test_splits = ["train", "val", "test"] # Existing helper methods remain the same - def _gather_config_files(self, base_dir: Path) -> List[str]: + def _gather_config_files(self, base_dir: Path) -> list[str]: """Gather all relevant config files. Parameters @@ -44,12 +43,12 @@ def _gather_config_files(self, base_dir: Path) -> List[str]: "ogbg-molpcba.yaml", "manual_dataset.yaml" # "ogbg-molhiv.yaml" } - # Below the datasets that takes quite some time to load and process + # Below the datasets that takes quite some time to load and process self.long_running_datasets = {"mantra_name.yaml", "mantra_orientation.yaml", "mantra_genus.yaml", "mantra_betti_numbers.yaml"} for dir_path in config_base_dir.iterdir(): - curr_dir = str(dir_path).split('/')[-1] + curr_dir = str(dir_path).split("/")[-1] if dir_path.is_dir(): config_files.extend([ (curr_dir, f.name) for f in dir_path.glob("*.yaml") @@ -57,7 +56,7 @@ def _gather_config_files(self, base_dir: Path) -> List[str]: ]) return config_files - def _load_dataset(self, data_domain: str, config_file: str) -> Tuple[Any, Dict]: + def _load_dataset(self, data_domain: str, config_file: str) -> tuple[Any, dict]: """Load dataset with given config file. Parameters @@ -77,11 +76,11 @@ def _load_dataset(self, data_domain: str, config_file: str) -> Tuple[Any, Dict]: config_path=self.relative_config_dir, job_name="run" ): - print('Current config file: ', config_file) + print("Current config file: ", config_file) parameters = hydra.compose( config_name="run.yaml", - overrides=[f"dataset={data_domain}/{config_file}", f"model=graph/gat"], - return_hydra_config=True, + overrides=[f"dataset={data_domain}/{config_file}", "model=graph/gat"], + return_hydra_config=True, ) dataset_loader = hydra.utils.instantiate(parameters.dataset.loader) print(repr(dataset_loader)) @@ -104,12 +103,12 @@ def test_dataset_loading_states(self): assert dataset.data.y.size(0) > 0, "Empty labels" # Below brakes with manual dataset - # else: + # else: # assert dataset[0].x.size(0) > 0, "Empty node features" # assert dataset[0].y.size(0) > 0, "Empty labels" # Test node feature dimensions - if hasattr(dataset, 'num_node_features'): + if hasattr(dataset, "data") and hasattr(dataset, "num_node_features"): assert dataset.data.x.size(1) == dataset.num_node_features # Below brakes with manual dataset diff --git a/test/memory_usage_tracking/memory_plotting.py b/test/memory_usage_tracking/memory_plotting.py new file mode 100644 index 000000000..b25804693 --- /dev/null +++ b/test/memory_usage_tracking/memory_plotting.py @@ -0,0 +1,242 @@ +# test/memory_usage_tracking/memory_plotting.py + +import argparse +import ast +import csv +import os +import subprocess +import sys +import tempfile +import time + +import matplotlib.pyplot as plt +import pandas as pd +import psutil + +# Constants & paths +SCRIPT_FILE_PATH = "test/pipeline/memory_checks_template.py" +OUTPUT_ROOT = "test/memory_usage_tracking/outputs" + +# Helpers +def dataset_short(name: str) -> str: + """Return the part after the first '/' in the dataset path.""" + parts = name.split("/", 1) + return parts[1] if len(parts) > 1 else parts[0] + +def model_fs(name: str) -> str: + """When used in file/folder names, replace '/' with '__'.""" + return name.replace("/", "__") + +# AST modification +def apply_ast_replacements(original_content: str, dataset_to_inject: str, model_to_inject: str) -> str: + tree = ast.parse(original_content) + + class ModuleLevelReplacer(ast.NodeTransformer): + def visit_Module(self, node): + for n in node.body: + if isinstance(n, ast.Assign) and len(n.targets) == 1 and isinstance(n.targets[0], ast.Name): + name = n.targets[0].id + if name == "DATASET": + n.value = ast.Constant(value=dataset_to_inject) + elif name == "MODELS": + n.value = ast.List(elts=[ast.Constant(value=model_to_inject)], ctx=ast.Load()) + return node + + modified_tree = ModuleLevelReplacer().visit(tree) + ast.fix_missing_locations(modified_tree) + return ast.unparse(modified_tree) + +# Core monitoring +def monitor_script(script_path: str, + dataset_to_inject: str, + model_to_inject: str, + output_csv: str, + interval: float = 0.05) -> tuple[list[tuple[float, float]], int]: + print(f"Running for model '{model_to_inject}' on dataset '{dataset_to_inject}'") + + project_root = os.getcwd() + script_abspath = os.path.abspath(script_path) + + env = os.environ.copy() + env["PYTHONPATH"] = project_root + os.pathsep + env.get("PYTHONPATH", "") + + try: + with open(script_abspath, encoding="utf-8") as f: + original_content = f.read() + except FileNotFoundError: + print(f"ERROR: Template not found at {script_abspath}", file=sys.stderr) + return [], -1 + + try: + modified_code = apply_ast_replacements(original_content, dataset_to_inject, model_to_inject) + except Exception as e: + print(f"ERROR: Failed to AST-modify the template: {e}", file=sys.stderr) + return [], -1 + + temp_script_path: str | None = None + try: + original_script_dir = os.path.dirname(script_abspath) + with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, dir=original_script_dir, encoding="utf-8") as temp_f: + temp_f.write(modified_code) + temp_script_path = temp_f.name + + process = subprocess.Popen(["pytest", temp_script_path], cwd=project_root, env=env) + + ps_proc = psutil.Process(process.pid) + memory_data: list[tuple[float, float]] = [] + start_time = time.time() + + try: + while process.poll() is None: + try: + mem_info = ps_proc.memory_info() + rss_mb = mem_info.rss / (1024 ** 2) + timestamp = time.time() - start_time + memory_data.append((timestamp, rss_mb)) + time.sleep(interval) + except (psutil.NoSuchProcess, psutil.AccessDenied): + break + except KeyboardInterrupt: + print("Interrupted by user. Terminating child process.") + process.terminate() + + process.wait() + return_code = process.returncode + total_runtime = time.time() - start_time + + print(f"Script finished in {total_runtime:.2f}s with return code {return_code}") + + with open(output_csv, "w", newline="", encoding="utf-8") as f: + writer = csv.writer(f) + writer.writerow(["time_s", "memory_MB"]) + writer.writerows(memory_data) + print(f"Memory usage saved to {output_csv}") + + return memory_data, return_code + finally: + if temp_script_path and os.path.exists(temp_script_path): + try: + os.remove(temp_script_path) + print(f"Temporary script {temp_script_path} removed.") + except OSError as e: + print(f"Warning: failed to remove temp file {temp_script_path}: {e}", file=sys.stderr) + +# Plotting (normalized time) +def plot_normalized_memory(model_label: str, + csv_files: list[str], + labels: list[str], + plot_path: str, + colors: tuple[str, str] = ("blue", "red")) -> None: + plt.figure(figsize=(10, 6)) + for i, (csv_file, label) in enumerate(zip(csv_files, labels, strict=False)): + if not os.path.exists(csv_file): + print(f"Warning: CSV file not found, skipping plot line: {csv_file}") + continue + df = pd.read_csv(csv_file) + if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: + print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") + continue + total_duration = df["time_s"].iloc[-1] - df["time_s"].iloc[0] + if total_duration > 0: + df["norm_time"] = (df["time_s"] - df["time_s"].iloc[0]) / total_duration + else: + n = max(1, len(df) - 1) + df["norm_time"] = (df.index - df.index[0]) / n + print(f"Warning: zero duration in {csv_file}; using sample index for normalization.") + plt.plot(df["norm_time"], df["memory_MB"], label=label, color=colors[i % len(colors)]) + plt.xlabel("Normalized time") + plt.ylabel("Memory usage [MB]") + plt.title(f"Memory usage comparison for model: {model_label}") + plt.xlim(0, 1) + plt.ylim(0, None) + plt.legend(loc="best") + plt.tight_layout() + plt.savefig(plot_path) + plt.close() + +# Plotting (raw time) +def plot_raw_time_memory(model_label: str, + csv_files: list[str], + labels: list[str], + plot_path: str, + colors: tuple[str, str] = ("blue", "red")) -> None: + """ + Plot memory vs raw time (seconds since start, shifted to t=0). + """ + plt.figure(figsize=(10, 6)) + for i, (csv_file, label) in enumerate(zip(csv_files, labels, strict=False)): + if not os.path.exists(csv_file): + print(f"Warning: CSV file not found, skipping plot line: {csv_file}") + continue + df = pd.read_csv(csv_file) + if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: + print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") + continue + t0 = df["time_s"].iloc[0] if len(df) else 0.0 + df["time_shifted"] = df["time_s"] - t0 + plt.plot(df["time_shifted"], df["memory_MB"], label=label, color=colors[i % len(colors)]) + plt.xlabel("Time [s]") + plt.ylabel("Memory usage [MB]") + plt.title(f"Memory usage (raw time) for model: {model_label}") + plt.xlim(0, None) + plt.ylim(0, None) + plt.legend(loc="best") + plt.tight_layout() + plt.savefig(plot_path) + plt.close() + +# CLI entry +def main(): + parser = argparse.ArgumentParser(description="Monitor and plot memory usage of a test pipeline.") + parser.add_argument("--datasets", type=str, nargs=2, required=True, + help="Two datasets to compare (e.g., graph/ds1 hypergraph/ds1). Order is used for plotting and file naming.") + parser.add_argument("--models", type=str, nargs="+", required=True, + help="One or more models to run (e.g., graph/gcn).") + parser.add_argument("--interval", type=float, default=0.05, + help="Sampling interval in seconds (default: 0.05).") + args = parser.parse_args() + + dataset1_disp = dataset_short(args.datasets[0]) + dataset2_disp = dataset_short(args.datasets[1]) + + # Filesystem parts (datasets shown without prefix) + dataset1_fs = dataset1_disp + dataset2_fs = dataset2_disp + + for model in args.models: + model_label = model + model_part = model_fs(model_label) # only for file/folder names + + # One folder per (dataset1,dataset2,model) + cfg_folder = f"{dataset1_fs}__{dataset2_fs}__{model_part}" + config_dir = os.path.join(OUTPUT_ROOT, cfg_folder) + os.makedirs(config_dir, exist_ok=True) + + csv_outputs_for_model: list[str] = [] + return_codes: list[int] = [] + + for dataset_disp in (dataset1_disp, dataset2_disp): + # Inject the ORIGINAL dataset string into the template + original_dataset_arg = args.datasets[0] if dataset_disp == dataset1_disp else args.datasets[1] + output_csv = os.path.join(config_dir, f"{model_part}__{dataset_disp}.csv") + _, rc = monitor_script(SCRIPT_FILE_PATH, original_dataset_arg, model_label, output_csv, interval=args.interval) + csv_outputs_for_model.append(output_csv) + return_codes.append(rc) + + for i, rc in enumerate(return_codes): + if rc != 0: + print( + f"WARNING: Run for model '{model_label}' on dataset '{[dataset1_disp, dataset2_disp][i]}' " + f"exited with non-zero code {rc}.", + file=sys.stderr + ) + + labels = [dataset1_disp, dataset2_disp] + norm_plot_path = os.path.join(config_dir, "memory_plot_normalized.png") + raw_plot_path = os.path.join(config_dir, "memory_plot_raw.png") + + plot_normalized_memory(model_label, csv_outputs_for_model, labels=labels, plot_path=norm_plot_path, colors=("blue", "red")) + plot_raw_time_memory(model_label, csv_outputs_for_model, labels=labels, plot_path=raw_plot_path, colors=("blue", "red")) + +if __name__ == "__main__": + main() diff --git a/test/pipeline/memory_checks_template.py b/test/pipeline/memory_checks_template.py new file mode 100644 index 000000000..e88b5dd11 --- /dev/null +++ b/test/pipeline/memory_checks_template.py @@ -0,0 +1,43 @@ +"""Test pipeline for a particular dataset and model.""" + +import hydra + +from test._utils.simplified_pipeline import run + +# Use your contributed dataset + a lightweight, well-supported model +DATASET = "placeholder/dataset" +MODELS = ["placeholder/model"] + +class TestPipeline: + """Test pipeline for a particular dataset and model.""" + + def setup_method(pythself): + """Setup method.""" + hydra.core.global_hydra.GlobalHydra.instance().clear() + + def test_pipeline(self): + """Test pipeline.""" + # The config path is relative to this file: ../../configs + with hydra.initialize(config_path="../../configs", job_name="job"): + for MODEL in MODELS: + cfg = hydra.compose( + config_name="run.yaml", + overrides=[ + f"model={MODEL}", + f"dataset={DATASET}", + # keep CI fast & deterministic + "trainer.max_epochs=2", + "trainer.min_epochs=1", + "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + # write under a tmp test path + "paths=test", + # reuse the same callback config used elsewhere in tests + "callbacks=model_checkpoint" + ], + return_hydra_config=True, + ) + # print(cfg) + run(cfg) diff --git a/test/pipeline/test_pipeline.py b/test/pipeline/test_pipeline.py index 785987159..ea9959ba1 100644 --- a/test/pipeline/test_pipeline.py +++ b/test/pipeline/test_pipeline.py @@ -1,35 +1,43 @@ """Test pipeline for a particular dataset and model.""" import hydra -from test._utils.simplified_pipeline import run - -DATASET = "graph/MUTAG" # ADD YOUR DATASET HERE -MODELS = ["graph/gcn", "cell/topotune", "simplicial/topotune"] # ADD ONE OR SEVERAL MODELS OF YOUR CHOICE HERE +from test._utils.simplified_pipeline import run +# Use your contributed dataset + a lightweight, well-supported model +DATASET = "graph/fake" +MODELS = ["graph/gcn", "cell/topotune", "simplicial/topotune"] +# MODELS = ["graph/gcn"] class TestPipeline: """Test pipeline for a particular dataset and model.""" - def setup_method(self): + def setup_method(pythself): """Setup method.""" hydra.core.global_hydra.GlobalHydra.instance().clear() - + def test_pipeline(self): """Test pipeline.""" + # The config path is relative to this file: ../../configs with hydra.initialize(config_path="../../configs", job_name="job"): for MODEL in MODELS: cfg = hydra.compose( config_name="run.yaml", overrides=[ f"model={MODEL}", - f"dataset={DATASET}", # IF YOU IMPLEMENT A LARGE DATASET WITH AN OPTION TO USE A SLICE OF IT, ADD BELOW THE CORRESPONDING OPTION + f"dataset={DATASET}", + # keep CI fast & deterministic "trainer.max_epochs=2", "trainer.min_epochs=1", "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + # write under a tmp test path "paths=test", - "callbacks=model_checkpoint", + # reuse the same callback config used elsewhere in tests + "callbacks=model_checkpoint" ], - return_hydra_config=True + return_hydra_config=True, ) - run(cfg) \ No newline at end of file + run(cfg) diff --git a/topobench/data/datasets/__init__.py b/topobench/data/datasets/__init__.py index 68a4d6345..fe28f451a 100644 --- a/topobench/data/datasets/__init__.py +++ b/topobench/data/datasets/__init__.py @@ -5,7 +5,7 @@ from pathlib import Path from typing import ClassVar -from torch_geometric.data import InMemoryDataset +from torch_geometric.data import InMemoryDataset, OnDiskDataset class DatasetManager: @@ -43,7 +43,7 @@ class DatasetManager: @classmethod def discover_datasets( cls, package_path: str - ) -> dict[str, type[InMemoryDataset]]: + ): """Dynamically discover all dataset classes in the package. Parameters @@ -53,7 +53,7 @@ def discover_datasets( Returns ------- - Dict[str, Type[InMemoryDataset]] + Dict[str, Type[]] Dictionary mapping class names to their corresponding class objects. """ datasets = {} @@ -81,8 +81,11 @@ def discover_datasets( inspect.isclass(obj) and obj.__module__ == module.__name__ and not name.startswith("_") - and issubclass(obj, InMemoryDataset) + # and issubclass(obj, InMemoryDataset) + and (issubclass(obj, InMemoryDataset) or issubclass(obj, OnDiskDataset)) and obj != InMemoryDataset + and obj != OnDiskDataset + ) } datasets.update(new_datasets) diff --git a/topobench/data/datasets/fake_on_disk_dataset.py b/topobench/data/datasets/fake_on_disk_dataset.py new file mode 100644 index 000000000..376a590a3 --- /dev/null +++ b/topobench/data/datasets/fake_on_disk_dataset.py @@ -0,0 +1,245 @@ +import os.path as osp +import random +from collections.abc import Callable + +import torch +from torch import Tensor +from torch_geometric.data import Data, OnDiskDataset +from torch_geometric.utils import coalesce, remove_self_loops, to_undirected + + +# Helpers taken from their torch_gometric.FakeDataset, unchanged +def get_num_nodes(avg_num_nodes: int, avg_degree: float) -> int: + min_num_nodes = max(3 * avg_num_nodes // 4, int(avg_degree)) + max_num_nodes = 5 * avg_num_nodes // 4 + return random.randint(min_num_nodes, max_num_nodes) + + +def get_num_channels(num_channels: int) -> int: + min_num_channels = 3 * num_channels // 4 + max_num_channels = 5 * num_channels // 4 + return random.randint(min_num_channels, max_num_channels) + + +def get_edge_index( + num_src_nodes: int, + num_dst_nodes: int, + avg_degree: float, + is_undirected: bool = False, + remove_loops: bool = False, +) -> Tensor: + num_edges = int(num_src_nodes * avg_degree) + row = torch.randint(num_src_nodes, (num_edges,), dtype=torch.int64) + col = torch.randint(num_dst_nodes, (num_edges,), dtype=torch.int64) + edge_index = torch.stack([row, col], dim=0) + + if remove_loops: + edge_index, _ = remove_self_loops(edge_index) + + num_nodes = max(num_src_nodes, num_dst_nodes) + if is_undirected: + edge_index = to_undirected(edge_index, num_nodes=num_nodes) + else: + edge_index = coalesce(edge_index, num_nodes=num_nodes) + + return edge_index + + +# FakeOnDiskDataset: API & generation logic taken from torch_geometric FakeDataset, +# but persisted via OnDiskDataset. +class FakeOnDiskDataset(OnDiskDataset): + r"""A fake dataset that returns randomly generated Data objects, + persisted to disk via :class:`~torch_geometric.data.OnDiskDataset`. + + Args: + root (str): Root directory where the processed DB will live. + num_graphs (int, optional): Number of graphs. (default: 1) + avg_num_nodes (int, optional): Average nodes per graph. (default: 1000) + avg_degree (float, optional): Average degree per node. (default: 10.0) + num_channels (int, optional): Node feature dimension. (default: 64) + edge_dim (int, optional): Edge feature dimension. (default: 0) + num_classes (int, optional): Number of classes. (default: 10) + task (str, optional): 'node', 'graph', or 'auto'. (default: 'auto') + is_undirected (bool, optional): Make edges undirected. (default: True) + transform (callable, optional): Applied on read. (default: None) + pre_transform (callable, optional): (unused, kept for parity) + backend (str, optional): 'sqlite' or 'rocksdb'. (default: 'sqlite') + force_reload (bool, optional): Rebuild DB even if present. (default: False) + **kwargs (optional): Extra attributes & shapes, e.g. global_features=5. + """ + + def __init__( + self, + root: str, + name: str, + num_graphs: int = 1, + avg_num_nodes: int = 1000, + avg_degree: float = 10.0, + num_channels: int = 64, + edge_dim: int = 0, + num_classes: int = 10, + task: str = "auto", + is_undirected: bool = True, + transform: Callable | None = None, + pre_transform: Callable | None = None, + backend: str = "sqlite", + **kwargs, + ): + if task == "auto": + task = "graph" if num_graphs > 1 else "node" + assert task in ["node", "graph"] + self.name = name + self.num_graphs = max(int(num_graphs), 1) + self.avg_num_nodes = max(int(avg_num_nodes), int(avg_degree)) + self.avg_degree = max(float(avg_degree), 1.0) + self.num_channels = int(num_channels) + self.edge_dim = int(edge_dim) + self._num_classes = int(num_classes) + self.task = task + self.is_undirected = bool(is_undirected) + self.root = root + self.kwargs = kwargs + + # Static schema consistent with configuration: + # Always store num_nodes (typed) to avoid KeyErrors. + schema: dict[str, object] = { + "edge_index": dict(dtype=torch.int64, size=(2, -1)), + "num_nodes": dict(dtype=torch.int64, size=(1,)), + "x": (dict(dtype=torch.float32, size=(-1, self.num_channels)) + if self.num_channels > 0 else object), + "edge_attr": (dict(dtype=torch.float32, size=(-1, self.edge_dim)) + if self.edge_dim > 1 else object), + "edge_weight": (dict(dtype=torch.float32, size=(-1,)) + if self.edge_dim == 1 else object), + "y": ( + dict(dtype=torch.int64, size=(-1,)) if (self._num_classes > 0 and self.task == "node") + else dict(dtype=torch.int64, size=(1,)) if (self._num_classes > 0 and self.task == "graph") + else object + ), + } + + super().__init__(self.root, transform, backend=backend, schema=schema) + + @property + def raw_file_names(self) -> list[str]: + return [] + + @property + def raw_dir(self) -> str: + """Return the path to the raw directory of the dataset. + + Returns + ------- + str + Path to the raw directory. + """ + return osp.join(self.root, self.name, "raw") + + @property + def processed_dir(self) -> str: + """Return the path to the processed directory of the dataset. + + Returns + ------- + str + Path to the processed directory. + """ + return osp.join(self.root, self.name, "processed") + + + def download(self) -> None: + pass + + def process(self) -> None: + """Generate synthetic graphs and write them to disk in batches. + + This mirrors the batch-writing logic from pcqm4m: we never keep + all graphs in memory at once, only up to `batch_size` at a time. + """ + batch_size = 1000 # same idea as pcqm4m + + data_list: list[Data] = [] + + for i in range(self.num_graphs): + data = self.generate_data() + data_list.append(data) + + # flush either every `batch_size` items, or at the very end + if (i + 1) == self.num_graphs or ((i + 1) % batch_size == 0): + # this writes the batch to disk / processed dir + self.extend(data_list) + # free the batch from RAM + data_list = [] + + print("Finished.") + + # Mirrors torch_geometric.FakeDataset.generate_data(): + def generate_data(self) -> Data: + num_nodes = get_num_nodes(self.avg_num_nodes, self.avg_degree) + + data = Data() + data.num_nodes = num_nodes # always store for schema consistency + + if self._num_classes > 0 and self.task == "node": + data.y = torch.randint(self._num_classes, (num_nodes,)) + elif self._num_classes > 0 and self.task == "graph": + data.y = torch.tensor([random.randint(0, self._num_classes - 1)]) + + data.edge_index = get_edge_index( + num_nodes, num_nodes, self.avg_degree, self.is_undirected, remove_loops=True + ) + + if self.num_channels > 0: + x = torch.randn(num_nodes, self.num_channels) + if self._num_classes > 0 and self.task == "node": + x = x + data.y.unsqueeze(1) # weak correlation like theirs + elif self._num_classes > 0 and self.task == "graph": + x = x + data.y + data.x = x + + if self.edge_dim > 1: + data.edge_attr = torch.rand(data.num_edges, self.edge_dim) + elif self.edge_dim == 1: + data.edge_weight = torch.rand(data.num_edges) + + for feature_name, feature_shape in self.kwargs.items(): + setattr(data, feature_name, torch.randn(feature_shape)) + return data + + # Map Data -> dict following the schema (always include num_nodes). + def serialize(self, data: Data) -> dict[str, object]: + row: dict[str, object] = { + "edge_index": data.edge_index, + "num_nodes": torch.tensor([data.num_nodes], dtype=torch.int64), + "x": getattr(data, "x", None) if self.num_channels > 0 else None, + "edge_attr": getattr(data, "edge_attr", None) if self.edge_dim > 1 else None, + "edge_weight": getattr(data, "edge_weight", None) if self.edge_dim == 1 else None, + "y": getattr(data, "y", None) if self._num_classes > 0 else None, + } + return row + + # Map dict -> Data; only set optional fields if present/non-None. + def deserialize(self, row: dict[str, object]) -> Data: + d = Data() + d.edge_index = row["edge_index"] # type: ignore[assignment] + # num_nodes is guaranteed present & typed + n = row["num_nodes"] + d.num_nodes = int(n[0]) if isinstance(n, torch.Tensor) else int(n[0]) # type: ignore[index] + + x = row.get("x") + if x is not None: + d.x = x # type: ignore[assignment] + + ea = row.get("edge_attr") + if ea is not None: + d.edge_attr = ea # type: ignore[assignment] + + ew = row.get("edge_weight") + if ew is not None: + d.edge_weight = ew # type: ignore[assignment] + + y = row.get("y") + if y is not None: + d.y = y # type: ignore[assignment] + + return d diff --git a/topobench/data/loaders/graph/fake_dataset_loader.py b/topobench/data/loaders/graph/fake_dataset_loader.py new file mode 100644 index 000000000..ca749df64 --- /dev/null +++ b/topobench/data/loaders/graph/fake_dataset_loader.py @@ -0,0 +1,60 @@ +"""Loaders for Citation Hypergraph dataset.""" + +from omegaconf import DictConfig +from torch_geometric.data import Dataset +from torch_geometric.datasets import FakeDataset + +from topobench.data.loaders.base import AbstractLoader + + +class FakeDatasetLoader(AbstractLoader): + """Load FakeOnDisk datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters containing: + - data_dir: Root directory for data + - num_graphs: Number of graphs to generate + - avg_num_nodes: Average number of nodes per graph + - avg_degree: Average degree per node + - num_channels: Node feature dimension + - edge_dim: Edge feature dimension + - num_classes: Number of classes + - task: 'node' or 'graph' + - is_undirected: Whether the graph is undirected + - backend: 'sqlite' or 'rocksdb' + """ + + def __init__(self, parameters: DictConfig) -> None: + super().__init__(parameters) + + def load_dataset(self) -> Dataset: + """Load FakeOnDiskDataset. + + Returns + ------- + Dataset + The loaded FakeOnDiskDataset. + + Raises + ------ + RuntimeError + If dataset loading fails. + """ + try: + dataset = FakeDataset( + # root=str(self.root_data_dir), + num_graphs=self.parameters.get("num_graphs", 1), + avg_num_nodes=self.parameters.get("avg_num_nodes", 1000), + avg_degree=self.parameters.get("avg_degree", 10.0), + num_channels=self.parameters.get("num_channels", 64), + edge_dim=self.parameters.get("edge_dim", 0), + num_classes=self.parameters.get("num_classes", 10), + task=self.parameters.get("task", "auto"), + is_undirected=self.parameters.get("is_undirected", True), + ) + except Exception as e: + raise RuntimeError("Failed to load FakeOnDiskDataset") from e + + return dataset diff --git a/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py b/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py new file mode 100644 index 000000000..11a129bb7 --- /dev/null +++ b/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py @@ -0,0 +1,62 @@ +"""Loaders for Citation Hypergraph dataset.""" + +from omegaconf import DictConfig +from torch_geometric.data import Dataset + +from topobench.data.datasets import FakeOnDiskDataset +from topobench.data.loaders.base import AbstractLoader + + +class FakeOnDiskDatasetLoader(AbstractLoader): + """Load FakeOnDisk datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters containing: + - data_dir: Root directory for data + - num_graphs: Number of graphs to generate + - avg_num_nodes: Average number of nodes per graph + - avg_degree: Average degree per node + - num_channels: Node feature dimension + - edge_dim: Edge feature dimension + - num_classes: Number of classes + - task: 'node' or 'graph' + - is_undirected: Whether the graph is undirected + - backend: 'sqlite' or 'rocksdb' + """ + + def __init__(self, parameters: DictConfig) -> None: + super().__init__(parameters) + + def load_dataset(self) -> Dataset: + """Load FakeOnDiskDataset. + + Returns + ------- + Dataset + The loaded FakeOnDiskDataset. + + Raises + ------ + RuntimeError + If dataset loading fails. + """ + try: + dataset = FakeOnDiskDataset( + root=str(self.root_data_dir), + name=self.parameters.get("data_name", "FakeOnDiskDataset"), + num_graphs=self.parameters.get("num_graphs", 1), + avg_num_nodes=self.parameters.get("avg_num_nodes", 1000), + avg_degree=self.parameters.get("avg_degree", 10.0), + num_channels=self.parameters.get("num_channels", 64), + edge_dim=self.parameters.get("edge_dim", 0), + num_classes=self.parameters.get("num_classes", 10), + task=self.parameters.get("task", "auto"), + is_undirected=self.parameters.get("is_undirected", True), + backend=self.parameters.get("backend", "sqlite"), + ) + except Exception as e: + raise RuntimeError("Failed to load FakeOnDiskDataset") from e + + return dataset diff --git a/topobench/data/preprocessor/__init__.py b/topobench/data/preprocessor/__init__.py index 740b4fb5f..169745cb1 100644 --- a/topobench/data/preprocessor/__init__.py +++ b/topobench/data/preprocessor/__init__.py @@ -1,7 +1,9 @@ """Init file for Preprocessor module.""" +from .on_disk_preprocessor import OnDiskPreProcessor from .preprocessor import PreProcessor __all__ = [ "PreProcessor", + "OnDiskPreProcessor" ] diff --git a/topobench/data/preprocessor/on_disk_preprocessor.py b/topobench/data/preprocessor/on_disk_preprocessor.py new file mode 100644 index 000000000..760a6e9f1 --- /dev/null +++ b/topobench/data/preprocessor/on_disk_preprocessor.py @@ -0,0 +1,309 @@ +"""Preprocessor for datasets, backed by PyG OnDiskDataset.""" + +import json +import os +from collections.abc import Callable, Sequence +from typing import Any + +import torch_geometric +from torch_geometric.data.data import BaseData + +from topobench.data.utils import ( + ensure_serializable, + load_inductive_splits_on_disk, + # load_transductive_splits, + make_hash, +) +from topobench.dataloader import DataloadDataset +from topobench.transforms.data_transform import DataTransform + + +class _LazyDataList(Sequence): + """ + Lazy list-like wrapper around an OnDiskDataset to preserve compatibility + with TopoBench split utilities that expect `dataset.data_list`. + Does NOT load the whole dataset into memory. + """ + def __init__(self, dataset): + self._ds = dataset + + def __len__(self): + return len(self._ds) + + def __getitem__(self, idx): + if isinstance(idx, slice): + start, stop, step = idx.indices(len(self)) + return [self._ds[i] for i in range(start, stop, step)] + return self._ds[idx] # fetches on demand from disk + + def __iter__(self): + for i in range(len(self)): + yield self._ds[i] + + +class OnDiskPreProcessor(torch_geometric.data.OnDiskDataset): + def __init__( + self, + dataset, + data_dir: str, + transforms_config: dict[str, Any] | None = None, + **kwargs, + ) -> None: + # Keep a handle on the upstream dataset + self.dataset = dataset + self.transforms_applied = transforms_config is not None + + # Defaults: + self.heavy_transforms_config: dict[str, Any] = {} + self.easy_transforms_config: dict[str, Any] = {} + self.heavy_transforms: Callable | None = None + self.transforms_parameters: dict[str, Any] = {} + + if self.transforms_applied: + ( + self.heavy_transforms_config, + self.easy_transforms_config, + ) = self._split_transforms(transforms_config) + + heavy_transform_dict, _ = self._build_transform_dict( + self.heavy_transforms_config + ) + self.heavy_transforms = self._compose_from_dict(heavy_transform_dict) + + self.transforms_parameters = ensure_serializable( + { + name: transform.parameters + for name, transform in heavy_transform_dict.items() + } + ) + params_hash = make_hash(self.transforms_parameters) + repo_name = "_".join(list(self.heavy_transforms_config.keys())) + + if repo_name: + root_for_this_version = os.path.join( + data_dir, repo_name, f"{params_hash}" + ) + else: + root_for_this_version = os.path.join(data_dir, f"{params_hash}") + super().__init__( + root=root_for_this_version, + transform=None, # Online transforms are set manually later + pre_filter=None, + **kwargs, + ) + else: + root_for_this_version = data_dir + super().__init__( + root=root_for_this_version, + transform=None, # Online transforms are set manually later + pre_filter=None, + **kwargs, + ) + # Attach dataset to OnDiskPreProcessor class + if len(self) == 0: + for sample in self.dataset: + self.append(sample) + + # Prepare online transforms and save metadata. + # The `self.transform` attribute is used by PyG during data loading. + self.transform = self._prepare_online_transforms() + if self.transforms_applied: + self.save_transform_parameters() + + # Preserve split_idx if the original dataset had fixed splits. + if hasattr(dataset, "split_idx"): + self.split_idx = dataset.split_idx + + @property + def processed_dir(self) -> str: + """Return the path to the processed directory. + + Returns + ------- + str + Path to the processed directory. + """ + if self.transforms_applied: + return self.root + else: + return os.path.join(self.root, "processed") + + @property + def data_list(self): + """ + Compatibility with original PreProcessor. + Returns a sequence-like object, but keeps data on disk. + """ + if not hasattr(self, "_lazy_data_list"): + self._lazy_data_list = _LazyDataList(self) + return self._lazy_data_list + + def process(self) -> None: + """ + Called (once per cache dir) by Dataset._process() if the DB does not + already exist. We iterate over `self.dataset`, apply heavy transforms, + optionally apply `pre_filter`, and append each sample to the on-disk DB. + """ + for sample in self.dataset: + if not isinstance(sample, BaseData): + raise TypeError( + f"Source dataset must yield PyG BaseData objects, " + f"but got {type(sample)}" + ) + + if self.heavy_transforms is not None: + sample = self.heavy_transforms(sample) + + # Respect PyG-style pre_filter semantics if provided: + if getattr(self, "pre_filter", None) is not None and not self.pre_filter(sample): + continue + + # Insert into the underlying DB (self.db): + self.append(sample) + + def save_transform_parameters(self) -> None: + """ + Save (or verify) the parameters of the heavy/offline transforms. + Raises if an existing cache directory corresponds to a different set + of transform parameters. + """ + # self.processed_dir now correctly points to the hashed directory + os.makedirs(self.processed_dir, exist_ok=True) + + path_transform_parameters = os.path.join( + self.processed_dir, "path_transform_parameters_dict.json" + ) + + if not os.path.exists(path_transform_parameters): + with open(path_transform_parameters, "w") as f: + json.dump(self.transforms_parameters, f, indent=4) + else: + with open(path_transform_parameters) as f: + saved_transform_parameters = json.load(f) + + if saved_transform_parameters != self.transforms_parameters: + raise ValueError( + "Different transform parameters for the same data_dir" + ) + + print( + "Transform parameters are the same, " + f"using existing data_dir: {self.processed_dir}" + ) + + def _prepare_online_transforms(self) -> Callable | None: + """ + Compose lightweight/easy transforms (feature tweaks, etc.) with the + dataset's intrinsic transform, and return a callable. + This becomes `self.transform`, which PyG applies at access time. + """ + transforms_list: Sequence[Callable] = [] + + # 1. Dataset's intrinsic transform, if present: + if hasattr(self.dataset, "transform") and self.dataset.transform is not None: + transforms_list.append(self.dataset.transform) + + # 2. Easy transforms from config: + easy_transform_dict, _ = self._build_transform_dict( + self.easy_transforms_config + ) + easy_compose = self._compose_from_dict(easy_transform_dict) + if easy_compose is not None: + transforms_list.append(easy_compose) + + # Return None / single transform / composed pipeline: + if not transforms_list: + return None + if len(transforms_list) == 1: + return transforms_list[0] + return torch_geometric.transforms.Compose(list(transforms_list)) + + # Transform config utilities + def _split_transforms( + self, transforms_config: dict[str, Any] + ) -> tuple[dict[str, Any], dict[str, Any]]: + """ + Split a Hydra-style transforms config into: + heavy_config = {name: cfg} for lifting / feature_lifting + easy_config = {name: cfg} for the rest + + We support: + - dict-of-dicts + - or a single dict with keys like "transform_name", "transform_type". + """ + heavy_config: dict[str, Any] = {} + easy_config: dict[str, Any] = {} + heavy_types = {"lifting", "feature_lifting"} + + # Normalize to {name: cfg} form: + if "transform_name" in transforms_config: + cfg_items = {"single": transforms_config} + else: + cfg_items = transforms_config + + for name, cfg in cfg_items.items(): + ttype = cfg.get("transform_type") + if ttype in heavy_types: + heavy_config[name] = cfg + else: + easy_config[name] = cfg + + return heavy_config, easy_config + + def _build_transform_dict( + self, subset_cfg: dict[str, Any] + ) -> tuple[dict[str, DataTransform], dict[str, Any]]: + """ + Instantiate DataTransform objects from a subset config. + Returns both: + transform_dict: {name: DataTransform(...)} + params_dict: {name: parameters} # for hashing/metadata + """ + transform_dict: dict[str, DataTransform] = {} + params_dict: dict[str, Any] = {} + + for name, cfg in subset_cfg.items(): + transform = DataTransform(**cfg) + transform_dict[name] = transform + params_dict[name] = transform.parameters + + return transform_dict, params_dict + + @staticmethod + def _compose_from_dict( + transform_dict: dict[str, Callable] + ) -> Callable | None: + """ + Turn {name: transform} into: + None (if empty), + that single transform (if only one), + or a torch_geometric.transforms.Compose([...]) (if multiple). + """ + if len(transform_dict) == 0: + return None + if len(transform_dict) == 1: + return list(transform_dict.values())[0] + return torch_geometric.transforms.Compose( + list(transform_dict.values()) + ) + + # Split loading + def load_dataset_splits( + self, split_params: dict[str, Any] + ) -> tuple[ + DataloadDataset, DataloadDataset | None, DataloadDataset | None + ]: + """ + Load or generate train/val/test splits using project utilities. + """ + if not split_params.get("learning_setting", False): + raise ValueError("No learning setting specified in split_params") + if split_params.learning_setting == "inductive": + return load_inductive_splits_on_disk(self, split_params) + # elif split_params.learning_setting == "transductive": + # return load_transductive_splits(self, split_params) + else: + raise ValueError( + f"Invalid '{split_params.learning_setting}' learning setting. " + "Please define either 'inductive' or 'transductive'." + ) diff --git a/topobench/data/utils/__init__.py b/topobench/data/utils/__init__.py index 8793f773e..a06d5aae9 100644 --- a/topobench/data/utils/__init__.py +++ b/topobench/data/utils/__init__.py @@ -33,14 +33,16 @@ from .split_utils import ( # noqa: E402 load_coauthorship_hypergraph_splits, # noqa: F401 load_inductive_splits, # noqa: F401 - load_transductive_splits, # noqa: F401 + load_inductive_splits_on_disk, # noqa: F401 # import function here, add noqa: F401 for PR + load_transductive_splits, # noqa: F401 ) split_helper_functions = [ "load_coauthorship_hypergraph_splits", "load_inductive_splits", "load_transductive_splits", + "load_inductive_splits_on_disk", # add function name here ] diff --git a/topobench/data/utils/split_utils.py b/topobench/data/utils/split_utils.py index 5d66d7e14..cc2d755b8 100644 --- a/topobench/data/utils/split_utils.py +++ b/topobench/data/utils/split_utils.py @@ -1,6 +1,7 @@ """Split utilities.""" import os +from collections.abc import Sequence import numpy as np import torch @@ -10,7 +11,7 @@ # Generate splits in different fasions -def k_fold_split(labels, parameters, root=None): +def k_fold_split(labels, parameters): """Return train and valid indices as in K-Fold Cross-Validation. If the split already exists it loads it automatically, otherwise it creates the @@ -22,8 +23,6 @@ def k_fold_split(labels, parameters, root=None): Label tensor. parameters : DictConfig Configuration parameters. - root : str, optional - Root directory for data splits. Overwrite the default directory. Returns ------- @@ -31,11 +30,7 @@ def k_fold_split(labels, parameters, root=None): Dictionary containing the train, validation and test indices, with keys "train", "valid", and "test". """ - data_dir = ( - parameters["data_split_dir"] - if root is None - else os.path.join(root, "data_splits") - ) + data_dir = parameters.data_split_dir k = parameters.k fold = parameters.data_seed assert fold < k, "data_seed needs to be less than k" @@ -50,7 +45,7 @@ def k_fold_split(labels, parameters, root=None): split_path = os.path.join(split_dir, f"{fold}.npz") if not os.path.isfile(split_path): - n = len(labels) + n = labels.shape[0] x_idx = np.arange(n) x_idx = np.random.permutation(x_idx) labels = labels[x_idx] @@ -84,18 +79,21 @@ def k_fold_split(labels, parameters, root=None): 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] == len(labels), "Not all nodes within splits" + 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 random_splitting(labels, parameters, root=None, global_data_seed=42): +def random_splitting(labels, parameters, global_data_seed=42): r"""Randomly splits label into train/valid/test splits. Adapted from https://github.com/CUAI/Non-Homophily-Benchmarks. @@ -106,8 +104,6 @@ def random_splitting(labels, parameters, root=None, global_data_seed=42): Label tensor. parameters : DictConfig Configuration parameter. - root : str, optional - Root directory for data splits. Overwrite the default directory. global_data_seed : int Seed for the random number generator. @@ -117,11 +113,7 @@ def random_splitting(labels, parameters, root=None, global_data_seed=42): Dictionary containing the train, validation and test indices with keys "train", "valid", and "test". """ fold = parameters["data_seed"] - data_dir = ( - parameters["data_split_dir"] - if root is None - else os.path.join(root, "data_splits") - ) + data_dir = parameters["data_split_dir"] train_prop = parameters["train_prop"] valid_prop = (1 - train_prop) / 2 @@ -140,7 +132,7 @@ def random_splitting(labels, parameters, root=None, global_data_seed=42): torch.manual_seed(global_data_seed) np.random.seed(global_data_seed) # Generate a split - n = len(labels) + n = labels.shape[0] train_num = int(n * train_prop) valid_num = int(n * valid_prop) @@ -167,13 +159,16 @@ def random_splitting(labels, parameters, root=None, global_data_seed=42): 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] == len(labels), "Not all nodes within splits" + 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 @@ -245,23 +240,19 @@ def load_transductive_splits(dataset, parameters): "Dataset should have only one graph in a transductive setting." ) + print(dataset.data_list[0].y) + data = dataset.data_list[0] labels = data.y.numpy() # Ensure labels are one dimensional array assert len(labels.shape) == 1, "Labels should be one dimensional array" - root = ( - dataset.dataset.get_data_dir() - if hasattr(dataset.dataset, "get_data_dir") - else None - ) - if parameters.split_type == "random": - splits = random_splitting(labels, parameters, root=root) + splits = random_splitting(labels, parameters) elif parameters.split_type == "k-fold": - splits = k_fold_split(labels, parameters, root=root) + splits = k_fold_split(labels, parameters) else: raise NotImplementedError( @@ -304,19 +295,21 @@ def load_inductive_splits(dataset, parameters): assert len(dataset) > 1, ( "Datasets should have more than one graph in an inductive setting." ) - labels = np.array([data.y.squeeze(0).numpy() for data in dataset]) - root = ( - dataset.dataset.get_data_dir() - if hasattr(dataset.dataset, "get_data_dir") - else None + print(len(dataset.data_list)) + print(dataset.data_list[0].y) + + labels = np.array( + [data.y.squeeze(0).numpy() for data in dataset.data_list] ) + print(labels, labels.shape) + if parameters.split_type == "random": - split_idx = random_splitting(labels, parameters, root=root) + split_idx = random_splitting(labels, parameters) elif parameters.split_type == "k-fold": - split_idx = k_fold_split(labels, parameters, root=root) + split_idx = k_fold_split(labels, parameters) elif parameters.split_type == "fixed" and hasattr(dataset, "split_idx"): split_idx = dataset.split_idx @@ -371,3 +364,154 @@ def load_coauthorship_hypergraph_splits(data, parameters, train_prop=0.5): == data.num_nodes ), "Not all nodes within splits" return DataloadDataset([data]), None, None + +# List-like view over a subset of an on-disk dataset +class _LazySplitList(Sequence): + """ + A lightweight, list-like view over a subset of an on-disk dataset. + + - Holds only the indices for this split (train/valid/test). + - On access (self[i]), loads that ONE graph from disk. + - Injects the appropriate split masks into the returned Data object. + - Supports __len__ so DataloadDataset.len() works. + - Supports integer indexing so DataloadDataset.get() works. + """ + + def __init__(self, base_dataset, indices, split_name: str): + self.base_dataset = base_dataset + self._idx = [int(i) for i in indices] # e.g. split_idx["train"], etc. + + assert split_name in ("train", "valid", "test") + self._split_name = split_name + + # Prebuild the masks once, reuse them for every item + if split_name == "train": + self._train_mask = torch.tensor([1], dtype=torch.long) + self._val_mask = torch.tensor([0], dtype=torch.long) + self._test_mask = torch.tensor([0], dtype=torch.long) + elif split_name == "valid": + self._train_mask = torch.tensor([0], dtype=torch.long) + self._val_mask = torch.tensor([1], dtype=torch.long) + self._test_mask = torch.tensor([0], dtype=torch.long) + else: # "test" + self._train_mask = torch.tensor([0], dtype=torch.long) + self._val_mask = torch.tensor([0], dtype=torch.long) + self._test_mask = torch.tensor([1], dtype=torch.long) + + def __len__(self): + # Allows DataloadDataset.len() to work + return len(self._idx) + + def _load_one(self, real_idx: int): + """ + Load a single graph from disk, attach masks, return it as a Data object. + """ + data = self.base_dataset[real_idx] # OnDiskDataset __getitem__ -> loads from disk + + # tag membership so downstream has train/val/test info + data.train_mask = self._train_mask + data.val_mask = self._val_mask + data.test_mask = self._test_mask + + return data + + def __getitem__(self, pos): + """ + DataloadDataset.get(idx) will call self.data_lst[idx] with idx an int. + So we MUST support integer indexing and return a single Data object. + + We'll also add best-effort slice support for debugging, but that isn't + hit in the training loop. + """ + if isinstance(pos, slice): + start, stop, step = pos.indices(len(self._idx)) + # returning a plain list of Data objects here is fine for debugging, + # and does not break training (training only ever uses int indexing) + return [ + self._load_one(self._idx[i]) + for i in range(start, stop, step) + ] + + # integer index path (the only one real training uses) + real_idx = self._idx[pos] + return self._load_one(real_idx) + +def assign_train_val_test_mask_to_graphs_on_disk(dataset, split_idx): + """ + Build train/val/test datasets WITHOUT materializing the entire split in RAM. + + It gives DataloadDataset a lazy, list-like object (_LazySplitList) + that loads each graph from disk on demand. + """ + + train_list = _LazySplitList( + base_dataset=dataset, + indices=split_idx["train"], + split_name="train", + ) + + val_list = _LazySplitList( + base_dataset=dataset, + indices=split_idx["valid"], + split_name="valid", + ) + + test_list = _LazySplitList( + base_dataset=dataset, + indices=split_idx["test"], + split_name="test", + ) + + train_dataset = DataloadDataset(train_list) + val_dataset = DataloadDataset(val_list) + test_dataset = DataloadDataset(test_list) + + return train_dataset, val_dataset, test_dataset + +def load_inductive_splits_on_disk(dataset, parameters): + r"""Load multiple-graph datasets with the specified split. + + Parameters + ---------- + dataset : torch_geometric.data.Dataset + Graph dataset. + parameters : DictConfig + Configuration parameters. + + Returns + ------- + list: + List containing the train, validation, and test splits. + """ + # Extract labels from dataset object + assert len(dataset) > 1, ( + "Datasets should have more than one graph in an inductive setting." + ) + + print(len(dataset.data_list)) + print(dataset.data_list[0].y) + + labels = np.array( + [data.y.squeeze(0).numpy() for data in dataset.data_list] + ) + + if parameters.split_type == "random": + split_idx = random_splitting(labels, parameters) + + elif parameters.split_type == "k-fold": + split_idx = k_fold_split(labels, parameters) + + elif parameters.split_type == "fixed" and hasattr(dataset, "split_idx"): + split_idx = dataset.split_idx + + else: + raise NotImplementedError( + f"split_type {parameters.split_type} not valid. Choose either 'random', 'k-fold' or 'fixed'.\ + If 'fixed' is chosen, the dataset should have the attribute split_idx" + ) + + train_dataset, val_dataset, test_dataset = ( + assign_train_val_test_mask_to_graphs_on_disk(dataset, split_idx) + ) + + return train_dataset, val_dataset, test_dataset diff --git a/tutorials/tutorial_on_disk_inductive_pipeline.ipynb b/tutorials/tutorial_on_disk_inductive_pipeline.ipynb new file mode 100644 index 000000000..ffb0cc7bd --- /dev/null +++ b/tutorials/tutorial_on_disk_inductive_pipeline.ipynb @@ -0,0 +1,1654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "779c9d47-4d89-4e80-a532-a5c48bd03f51", + "metadata": {}, + "source": [ + "# Inductive `OnDiskDataset` Pipeline\n", + "\n", + "## Tutorial Overview\n", + "\n", + "In this tutorial, we demonstrate how to **implement, configure, run, and test** an inductive on-disk dataset using the `OnDiskDataset` interface from `torch_geometric`.\n", + "\n", + "The tutorial is divided into three main steps:\n", + "\n", + "1. **Implementing an On-Disk Dataset** \n", + " - Implement data loading and preprocessing logic \n", + " - Define the key dataset parameters and structure \n", + "\n", + "2. **Building the Inductive `OnDiskDataset` Pipeline** \n", + " - Integrate the new dataset into the existing TopoBench pipeline \n", + " - Ensure smooth interaction with the rest of the framework \n", + "\n", + "3. **Testing and Memory Tracking** \n", + " - Compare the performance of `OnDiskDataset` and `InMemoryDataset` pipelines \n", + " - Measure and visualize memory usage using the `memory_plotting` script" + ] + }, + { + "cell_type": "markdown", + "id": "6a1c1781-3e1e-4350-afc4-615b1b522aaf", + "metadata": {}, + "source": [ + "## Implementing an On-Disk Dataset\n", + "\n", + "When working with large datasets, storing all graphs in memory can become inefficient. To address this, PyTorch Geometric provides the `OnDiskDataset` class, which lets us store graphs directly on disk and load them as needed.\n", + "\n", + "Here we show how to implement the core functionality using our own example, `FakeOnDiskDataset`. This dataset generates synthetic graphs (like PyG’s `FakeDataset`) but saves them to disk instead of keeping everything in memory.\n", + "\n", + "To implement your dataset, you **must** override at least two methods from `torch_geometric.data.OnDiskDataset`:\n", + "\n", + "- `download()`: Prepares or fetches the raw data \n", + "- `process()`: Generates and writes processed data to disk in batches \n", + "\n", + "In addition, override these if your data differs from the defaults or needs special handling (custom fields, optional attributes, non-standard types):\n", + "\n", + "- `serialize()`: How each graph is stored on disk \n", + "- `deserialize()`: How stored graphs are reconstructed when loaded\n", + "\n", + "---\n", + "\n", + "### `download()`\n", + "\n", + "The `download()` method is responsible for fetching or preparing raw data. In our case, since the dataset is generated locally, this method simply ensures that the necessary directories exist.\n", + "\n", + "For real datasets, this is where you would download files, unzip archives, or copy raw data into the `raw/` folder.\n", + "\n", + "---\n", + "\n", + "### `process()`\n", + "\n", + "The `process()` method defines how the dataset is **generated or preprocessed** and then **saved to disk**. Unlike `InMemoryDataset`, which collates all data into memory, `OnDiskDataset` writes data incrementally using the `extend()` method. \n", + "\n", + "In our example, the method generates random graphs and writes them to disk in small batches:\n", + "\n", + "```python\n", + "def process(self) -> None:\n", + " \"\"\"Generate synthetic graphs and write them to disk in small batches.\"\"\"\n", + " os.makedirs(self.processed_dir, exist_ok=True)\n", + "\n", + " batch_size = 1000\n", + " buffer = []\n", + "\n", + " for i in range(self.num_graphs):\n", + " data = self.generate_data() # create one graph\n", + " buffer.append(data)\n", + "\n", + " # Flush to disk every batch or at the very end\n", + " if (i + 1) % batch_size == 0 or (i + 1) == self.num_graphs:\n", + " self.extend(buffer) # append this batch to the on-disk store\n", + " buffer = []\n", + "\n", + " print(\"Processing complete.\")" + ] + }, + { + "cell_type": "markdown", + "id": "f8d03a93-21d5-485d-9d26-10211b0c2eba", + "metadata": {}, + "source": [ + "---\n", + "\n", + "### `serialize()` and `deserialize()`\n", + "\n", + "The `serialize()` and `deserialize()` methods define how individual `Data` objects are written to and read from disk. They convert between PyTorch Geometric’s in-memory `Data` format and the dictionary format used for on-disk storage.\n", + "\n", + "You need to override these methods if your dataset includes custom fields or non-standard data types. For simple datasets (`x`, `edge_index`, `y`), the default implementations are already sufficient.\n", + "\n", + "Below is a minimal example from our `FakeOnDiskDataset`:\n", + "\n", + "```python\n", + "def serialize(self, data: Data) -> dict[str, object]:\n", + " \"\"\"Convert a Data object into a dictionary for storage.\"\"\"\n", + " return {\n", + " \"edge_index\": data.edge_index,\n", + " \"num_nodes\": torch.tensor([data.num_nodes]),\n", + " \"x\": getattr(data, \"x\", None),\n", + " \"edge_attr\": getattr(data, \"edge_attr\", None),\n", + " \"edge_weight\": getattr(data, \"edge_weight\", None),\n", + " \"y\": getattr(data, \"y\", None),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "2f9b2c9f-c403-475b-9603-6ed52fa2e0b3", + "metadata": {}, + "source": [ + "When loading data back, `deserialize()` reverses this process: it reconstructs each graph from the stored dictionary:\n", + "\n", + "```python\n", + "def deserialize(self, row: dict[str, object]) -> Data:\n", + " \"\"\"Recreate a Data object from stored tensors.\"\"\"\n", + " data = Data()\n", + " data.edge_index = row[\"edge_index\"]\n", + " data.num_nodes = int(row[\"num_nodes\"][0])\n", + "\n", + " # Restore optional attributes\n", + " for key in (\"x\", \"edge_attr\", \"edge_weight\", \"y\"):\n", + " value = row.get(key)\n", + " if value is not None:\n", + " setattr(data, key, value)\n", + "\n", + " return data" + ] + }, + { + "cell_type": "markdown", + "id": "cd338572-973d-486f-800c-563862197007", + "metadata": {}, + "source": [ + "---\n", + "\n", + "### Configuration Setup\n", + "\n", + "Now that we’ve implemented our on-disk dataset class, we need to define its configuration parameters. The configuration structure is almost identical to the one used for `InMemoryDataset`, but includes a few **on-disk–specific fields** related to how data is stored and accessed.\n", + "\n", + "Below is an example configuration for our `FakeOnDiskDataset`:\n", + "\n", + "```yaml\n", + "# Dataset loader configuration\n", + "loader:\n", + " _target_: topobench.data.loaders.graph.FakeOnDiskDatasetLoader\n", + " parameters:\n", + " # Framework-specific data organization\n", + " data_domain: graph\n", + " data_type: FakeOnDiskDataset\n", + " data_name: FakeOnDiskDataset\n", + " data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type}\n", + " memory_type: on_disk # Key parameter: specifies on-disk data handling\n", + " backend: sqlite # Storage backend: 'sqlite'\n", + " ...\n", + " \n", + "# Dataset parameters\n", + "parameters:\n", + " num_features: 64 # Node feature dimension\n", + " num_classes: 5 # Number of label classes\n", + " task: classification\n", + " loss_type: cross_entropy\n", + " monitor_metric: accuracy\n", + " task_level: graph\n", + " ..." + ] + }, + { + "cell_type": "markdown", + "id": "038e5283-e49c-476b-8350-7700caf184a5", + "metadata": {}, + "source": [ + "The `memory_type` and backend `backend` fields are specific to the on-disk implementation and determine how data is stored and accessed." + ] + }, + { + "cell_type": "markdown", + "id": "4769f308-97f0-48bc-89d5-81f099777f61", + "metadata": {}, + "source": [ + "## Building the Inductive `OnDiskDataset` Pipeline\n", + "\n", + "With the dataset and configuration in place, the next step is to integrate it into the existing TopoBench pipeline. To keep the framework consistent, we introduce minimal changes that allow seamless switching between **in-memory** and **on-disk** datasets.\n", + "\n", + "In the original pipeline, the preprocessing step is handled by a class called `PreProcessor`. For on-disk datasets, we add a new class`OnDiskPreProcessor` that manages data stored on disk instead of memory.\n", + "\n", + "Inside the main `run` function, the correct preprocessor is chosen dynamically based on the dataset configuration:\n", + "\n", + "```python\n", + "def run(cfg: DictConfig) -> DictConfig:\n", + " \"\"\"Run pipeline with given configuration.\n", + " \n", + " Parameters\n", + " ----------\n", + " cfg : DictConfig\n", + " Configuration.\n", + " \"\"\"\n", + " # Instantiate and load dataset\n", + " dataset_loader = hydra.utils.instantiate(cfg.dataset.loader)\n", + " dataset, dataset_dir = dataset_loader.load()\n", + " # Preprocess dataset and load the splits\n", + " transform_config = cfg.get(\"transforms\", None)\n", + " memory_type = cfg.dataset.loader.parameters.get(\"memory_type\", \"in_memory\")\n", + " preprocessor_cls = OnDiskPreProcessor if memory_type == \"on_disk\" else PreProcessor\n", + " preprocessor = preprocessor_cls(dataset, dataset_dir, transform_config)" + ] + }, + { + "cell_type": "markdown", + "id": "4691e613-54c7-419d-953f-3569d4de7d8f", + "metadata": {}, + "source": [ + "The new `OnDiskPreProcessor` reuses the same structure and logic as the standard `PreProcessor`, but adapts data loading and transformation for on-disk storage. It handles datasets that use lazy loading, meaning graphs are loaded from disk only when accessed." + ] + }, + { + "cell_type": "markdown", + "id": "ddd6bf2b-ff84-4965-bf76-723f160dd1a1", + "metadata": {}, + "source": [ + "## Testing and Memory Tracking\n", + "\n", + "In this section, we demonstrate how to track and visualize memory usage for the inductive on-disk dataset pipeline using the `memory_plotting` script.\n", + "\n", + "Here’s what happens:\n", + "1. The script updates a test template with the selected dataset and model. \n", + "2. It runs the test while tracking memory consumption in real time. \n", + "3. The recorded data is saved to CSV files and converted into a normalized time plot (memory vs. relative progress).\n", + "\n", + "We showcase this on a practical example comparing `graph/fake` and `graph/fake_inmem` across three models:\n", + "- `graph/gcn` \n", + "- `cell/topotune` \n", + "- `simplicial/topotune`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bf50b3a1-42f8-436e-b521-c47fc39f306b", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "# Imports and Utils are handled here.\n", + "\n", + "from pathlib import Path\n", + "from contextlib import contextmanager\n", + "from IPython.display import Image\n", + "import os, sys\n", + "\n", + "sys.path.insert(0, str(Path.cwd().parents[0] / 'test' / 'memory_usage_tracking'))\n", + "import memory_plotting as mp\n", + "\n", + "@contextmanager\n", + "def pushd(path: Path):\n", + " prev = Path.cwd()\n", + " os.chdir(path)\n", + " try:\n", + " yield\n", + " finally:\n", + " os.chdir(prev)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "30cfaba6-0e38-4411-98f5-f3648e3c8da3", + "metadata": {}, + "outputs": [], + "source": [ + "def run_memory_tracking_demo(\n", + " models=(\"graph/gcn\",),\n", + " datasets=(\"graph/fake_inmem\", \"graph/fake\"),\n", + " interval=0.05\n", + "):\n", + " \"\"\"\n", + " Runs the memory tracking and returns a plot.\n", + " \"\"\"\n", + " project_root = Path.cwd().parents[0]\n", + " script_path = project_root / \"test\" / \"pipeline\" / \"memory_checks_template.py\"\n", + " output_root = project_root / \"test\" / \"memory_usage_tracking\" / \"outputs\"\n", + " output_root.mkdir(parents=True, exist_ok=True)\n", + "\n", + " ds1, ds2 = datasets\n", + " ds1_disp = mp.dataset_short(ds1)\n", + " ds2_disp = mp.dataset_short(ds2)\n", + "\n", + " with pushd(project_root):\n", + " for model in models:\n", + " model_label = model\n", + " model_part = mp.model_fs(model_label)\n", + "\n", + " cfg_folder = f\"{ds1_disp}__{ds2_disp}__{model_part}\"\n", + " config_dir = output_root / cfg_folder\n", + " config_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " csv_outputs_for_model = []\n", + " return_codes = []\n", + "\n", + " for dataset_disp in (ds1_disp, ds2_disp):\n", + " original_dataset_arg = ds1 if dataset_disp == ds1_disp else ds2\n", + " output_csv = config_dir / f\"{model_part}__{dataset_disp}.csv\"\n", + "\n", + " _, rc = mp.monitor_script(\n", + " script_path=str(script_path),\n", + " dataset_to_inject=original_dataset_arg,\n", + " model_to_inject=model_label,\n", + " output_csv=str(output_csv),\n", + " interval=interval\n", + " )\n", + " csv_outputs_for_model.append(str(output_csv))\n", + " return_codes.append(rc)\n", + " \n", + " labels = [\"InMemoryDataset\", \"OnDiskDataset\"]\n", + " norm_plot_path = str(config_dir / \"memory_plot_normalized.png\")\n", + " \n", + " mp.plot_normalized_memory(\n", + " model_label,\n", + " csv_outputs_for_model,\n", + " labels=labels,\n", + " plot_path=norm_plot_path,\n", + " colors=(\"blue\", \"red\")\n", + " )\n", + " \n", + " return Image(filename=norm_plot_path)" + ] + }, + { + "cell_type": "markdown", + "id": "3f878c3a-8b69-4a62-b316-51c878370d32", + "metadata": {}, + "source": [ + "### `graph/gcn` model\n", + "\n", + "For the `graph/gcn` model, we run tests on two synthetic datasets `graph/fake` and `graph/fake_inmem`. Both datasets contain **20,000 graphs** with an average of **100 nodes per graph**, but differ in how they are stored and accessed: \n", + "one uses the on-disk format, while the other is kept entirely in memory. \n", + "\n", + "The plot below shows the memory usage comparison between these two pipelines during execution." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "78d639dc-dde6-450f-8a01-a534eaebe8f7", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running for model 'graph/gcn' on dataset 'graph/fake_inmem'\n", + "\u001b[1m============================= test session starts ==============================\u001b[0m\n", + "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", + "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", + "configfile: pyproject.toml\n", + "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", + "collected 1 item\n", + "\n", + "test/pipeline/tmpwshvgyjw.py " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | Mode \n", + "------------------------------------------------------------------\n", + "0 | feature_encoder | AllCellFeatureEncoder | 8.5 K | train\n", + "1 | backbone | GNNWrapper | 8.4 K | train\n", + "2 | readout | NoReadOut | 325 | train\n", + "3 | val_acc_best | MeanMetric | 0 | train\n", + "------------------------------------------------------------------\n", + "17.3 K Trainable params\n", + "0 Non-trainable params\n", + "17.3 K Total params\n", + "0.069 Total estimated model params size (MB)\n", + "26 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20000\n", + "tensor([3])\n", + "[3 0 3 ... 4 4 4] (20000,)\n", + "Epoch 0: 100%|██████████| 500/500 [00:12<00:00, 38.62it/s]\n", + "Validation: | | 0/? [00:00" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot" + ] + }, + { + "cell_type": "markdown", + "id": "c84b76e5-59d4-4d38-aa2f-1a6cf4b4dfd2", + "metadata": {}, + "source": [ + "### `cell/topotune` model\n", + "\n", + "For the `cell/topotune` model, we test the pipeline using datasets that contain **5,000 graphs** with an average of **100 nodes per graph**. In this case, the `OnDiskPreProcessor` performs computationally intensive topology liftings as an initial step.\n", + "\n", + "This setup demonstrates how the on-disk pipeline handles heavier preprocessing workloads." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "20541a95-ef95-4f39-9e11-13f2e54a88b7", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running for model 'cell/topotune' on dataset 'graph/fake_inmem'\n", + "\u001b[1m============================= test session starts ==============================\u001b[0m\n", + "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", + "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", + "configfile: pyproject.toml\n", + "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", + "collected 1 item\n", + "\n", + "test/pipeline/tmp5o2iftqu.py " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | Mode \n", + "------------------------------------------------------------------\n", + "0 | feature_encoder | AllCellFeatureEncoder | 9.7 K | train\n", + "1 | backbone | TuneWrapper | 17.6 K | train\n", + "2 | readout | PropagateSignalDown | 6.5 K | train\n", + "3 | val_acc_best | MeanMetric | 0 | train\n", + "------------------------------------------------------------------\n", + "33.8 K Trainable params\n", + "0 Non-trainable params\n", + "33.8 K Total params\n", + "0.135 Total estimated model params size (MB)\n", + "156 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000\n", + "tensor([3])\n", + "[3 4 4 ... 3 3 0] (5000,)\n", + "Epoch 0: 100%|██████████| 125/125 [00:53<00:00, 2.35it/s]\n", + "Validation: | | 0/? [00:00" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot" + ] + }, + { + "cell_type": "markdown", + "id": "39e44a31-5285-44f2-90fb-b658e62aae83", + "metadata": {}, + "source": [ + "### `simplicial/topotune` model\n", + "\n", + "For the `simplicial/topotune` model, we use the same dataset configuration: **5,000 graphs** with an average of **100 nodes per graph**." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "69a5cd38-17fd-4807-b26e-9333b457fa54", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running for model 'simplicial/topotune' on dataset 'graph/fake_inmem'\n", + "\u001b[1m============================= test session starts ==============================\u001b[0m\n", + "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", + "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", + "configfile: pyproject.toml\n", + "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", + "collected 1 item\n", + "\n", + "test/pipeline/tmp7sd2ronn.py " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | Mode \n", + "------------------------------------------------------------------\n", + "0 | feature_encoder | AllCellFeatureEncoder | 9.7 K | train\n", + "1 | backbone | TuneWrapper | 35.5 K | train\n", + "2 | readout | PropagateSignalDown | 6.5 K | train\n", + "3 | val_acc_best | MeanMetric | 0 | train\n", + "------------------------------------------------------------------\n", + "51.7 K Trainable params\n", + "0 Non-trainable params\n", + "51.7 K Total params\n", + "0.207 Total estimated model params size (MB)\n", + "252 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000\n", + "tensor([3])\n", + "[3 4 1 ... 3 3 3] (5000,)\n", + "Epoch 0: 100%|██████████| 125/125 [00:26<00:00, 4.69it/s]\n", + "Validation: | | 0/? [00:00" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot" + ] + }, + { + "cell_type": "markdown", + "id": "e9e1ff0a-b6ba-45f1-875d-7e39ed03e371", + "metadata": {}, + "source": [ + "## Cleanup and Further Use\n", + "\n", + "Before running new experiments or regenerating datasets, we recommend removing previously created folders to ensure a clean setup. This prevents conflicts with cached data, outdated splits, or previously processed files.\n", + "\n", + "You can safely remove the old datasets and data split directories using:\n", + "\n", + "```bash\n", + "rm -rf datasets/graph/dataset_name\n", + "rm -rf datasets/data_splits/dataset_name" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 736948e6e64a2300c33732b38606b858ffe3f556 Mon Sep 17 00:00:00 2001 From: luka-benic Date: Mon, 3 Nov 2025 23:40:17 +0100 Subject: [PATCH 02/11] Removed some prints. --- topobench/data/datasets/fake_on_disk_dataset.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/topobench/data/datasets/fake_on_disk_dataset.py b/topobench/data/datasets/fake_on_disk_dataset.py index 376a590a3..cff7c7f70 100644 --- a/topobench/data/datasets/fake_on_disk_dataset.py +++ b/topobench/data/datasets/fake_on_disk_dataset.py @@ -171,8 +171,6 @@ def process(self) -> None: # free the batch from RAM data_list = [] - print("Finished.") - # Mirrors torch_geometric.FakeDataset.generate_data(): def generate_data(self) -> Data: num_nodes = get_num_nodes(self.avg_num_nodes, self.avg_degree) From c9cf909f605e3e67b296405fbaa17a4870c99916 Mon Sep 17 00:00:00 2001 From: David Leko Date: Tue, 4 Nov 2025 15:58:06 +0100 Subject: [PATCH 03/11] Resolved conflicts in split_utils --- topobench/data/utils/split_utils.py | 130 +++++++++++++++++----------- 1 file changed, 81 insertions(+), 49 deletions(-) diff --git a/topobench/data/utils/split_utils.py b/topobench/data/utils/split_utils.py index cc2d755b8..919f42031 100644 --- a/topobench/data/utils/split_utils.py +++ b/topobench/data/utils/split_utils.py @@ -11,7 +11,7 @@ # Generate splits in different fasions -def k_fold_split(labels, parameters): +def k_fold_split(labels, parameters, root=None): """Return train and valid indices as in K-Fold Cross-Validation. If the split already exists it loads it automatically, otherwise it creates the @@ -23,6 +23,8 @@ def k_fold_split(labels, parameters): Label tensor. parameters : DictConfig Configuration parameters. + root : str, optional + Root directory for data splits. Overwrite the default directory. Returns ------- @@ -30,7 +32,11 @@ def k_fold_split(labels, parameters): Dictionary containing the train, validation and test indices, with keys "train", "valid", and "test". """ - data_dir = parameters.data_split_dir + data_dir = ( + parameters["data_split_dir"] + if root is None + else os.path.join(root, "data_splits") + ) k = parameters.k fold = parameters.data_seed assert fold < k, "data_seed needs to be less than k" @@ -45,7 +51,7 @@ def k_fold_split(labels, parameters): split_path = os.path.join(split_dir, f"{fold}.npz") if not os.path.isfile(split_path): - n = labels.shape[0] + n = len(labels) x_idx = np.arange(n) x_idx = np.random.permutation(x_idx) labels = labels[x_idx] @@ -79,21 +85,18 @@ def k_fold_split(labels, parameters): 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" + assert np.unique( + np.array( + split_idx["train"].tolist() + + split_idx["valid"].tolist() + + split_idx["test"].tolist() + ) + ).shape[0] == len(labels), "Not all nodes within splits" return split_idx -def random_splitting(labels, parameters, global_data_seed=42): +def random_splitting(labels, parameters, root=None, global_data_seed=42): r"""Randomly splits label into train/valid/test splits. Adapted from https://github.com/CUAI/Non-Homophily-Benchmarks. @@ -104,6 +107,8 @@ def random_splitting(labels, parameters, global_data_seed=42): Label tensor. parameters : DictConfig Configuration parameter. + root : str, optional + Root directory for data splits. Overwrite the default directory. global_data_seed : int Seed for the random number generator. @@ -112,8 +117,14 @@ def random_splitting(labels, parameters, global_data_seed=42): dict: Dictionary containing the train, validation and test indices with keys "train", "valid", and "test". """ - fold = parameters["data_seed"] - data_dir = parameters["data_split_dir"] + fold = ( + parameters["data_seed"] % 10 + ) # Ensure fold is between 0 and 9, TODO: Modify hardcoded 10 split number + data_dir = ( + parameters["data_split_dir"] + if root is None + else os.path.join(root, "data_splits") + ) train_prop = parameters["train_prop"] valid_prop = (1 - train_prop) / 2 @@ -132,7 +143,7 @@ def random_splitting(labels, parameters, global_data_seed=42): torch.manual_seed(global_data_seed) np.random.seed(global_data_seed) # Generate a split - n = labels.shape[0] + n = len(labels) train_num = int(n * train_prop) valid_num = int(n * valid_prop) @@ -159,16 +170,13 @@ def random_splitting(labels, parameters, global_data_seed=42): 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" + assert np.unique( + np.array( + split_idx["train"].tolist() + + split_idx["valid"].tolist() + + split_idx["test"].tolist() + ) + ).shape[0] == len(labels), "Not all nodes within splits" return split_idx @@ -240,19 +248,23 @@ def load_transductive_splits(dataset, parameters): "Dataset should have only one graph in a transductive setting." ) - print(dataset.data_list[0].y) - data = dataset.data_list[0] labels = data.y.numpy() # Ensure labels are one dimensional array assert len(labels.shape) == 1, "Labels should be one dimensional array" + root = ( + dataset.dataset.get_data_dir() + if hasattr(dataset.dataset, "get_data_dir") + else None + ) + if parameters.split_type == "random": - splits = random_splitting(labels, parameters) + splits = random_splitting(labels, parameters, root=root) elif parameters.split_type == "k-fold": - splits = k_fold_split(labels, parameters) + splits = k_fold_split(labels, parameters, root=root) else: raise NotImplementedError( @@ -295,21 +307,30 @@ def load_inductive_splits(dataset, parameters): assert len(dataset) > 1, ( "Datasets should have more than one graph in an inductive setting." ) - - print(len(dataset.data_list)) - print(dataset.data_list[0].y) - - labels = np.array( - [data.y.squeeze(0).numpy() for data in dataset.data_list] + # Check if labels are ragged (different sizes across graphs) + label_list = [data.y.squeeze(0).numpy() for data in dataset] + label_shapes = [label.shape for label in label_list] + # Use dtype=object only if labels have different shapes (ragged) + labels = ( + np.array(label_list, dtype=object) + if len(set(label_shapes)) > 1 + else np.array(label_list) ) - print(labels, labels.shape) + root = ( + dataset.dataset.get_data_dir() + if hasattr(dataset.dataset, "get_data_dir") + else None + ) if parameters.split_type == "random": - split_idx = random_splitting(labels, parameters) + split_idx = random_splitting(labels, parameters, root=root) elif parameters.split_type == "k-fold": - split_idx = k_fold_split(labels, parameters) + assert type(labels) is not object, ( + "K-Fold splitting not supported for ragged labels." + ) + split_idx = k_fold_split(labels, parameters, root=root) elif parameters.split_type == "fixed" and hasattr(dataset, "split_idx"): split_idx = dataset.split_idx @@ -364,7 +385,7 @@ def load_coauthorship_hypergraph_splits(data, parameters, train_prop=0.5): == data.num_nodes ), "Not all nodes within splits" return DataloadDataset([data]), None, None - + # List-like view over a subset of an on-disk dataset class _LazySplitList(Sequence): """ @@ -467,7 +488,7 @@ def assign_train_val_test_mask_to_graphs_on_disk(dataset, split_idx): test_dataset = DataloadDataset(test_list) return train_dataset, val_dataset, test_dataset - + def load_inductive_splits_on_disk(dataset, parameters): r"""Load multiple-graph datasets with the specified split. @@ -487,19 +508,30 @@ def load_inductive_splits_on_disk(dataset, parameters): assert len(dataset) > 1, ( "Datasets should have more than one graph in an inductive setting." ) + # Check if labels are ragged (different sizes across graphs) + label_list = [data.y.squeeze(0).numpy() for data in dataset] + label_shapes = [label.shape for label in label_list] + # Use dtype=object only if labels have different shapes (ragged) + labels = ( + np.array(label_list, dtype=object) + if len(set(label_shapes)) > 1 + else np.array(label_list) + ) - print(len(dataset.data_list)) - print(dataset.data_list[0].y) - - labels = np.array( - [data.y.squeeze(0).numpy() for data in dataset.data_list] + root = ( + dataset.dataset.get_data_dir() + if hasattr(dataset.dataset, "get_data_dir") + else None ) if parameters.split_type == "random": - split_idx = random_splitting(labels, parameters) + split_idx = random_splitting(labels, parameters, root=root) elif parameters.split_type == "k-fold": - split_idx = k_fold_split(labels, parameters) + assert type(labels) is not object, ( + "K-Fold splitting not supported for ragged labels." + ) + split_idx = k_fold_split(labels, parameters, root=root) elif parameters.split_type == "fixed" and hasattr(dataset, "split_idx"): split_idx = dataset.split_idx From b98ada9ce953816401feba06a474ef38ac661618 Mon Sep 17 00:00:00 2001 From: David Leko Date: Wed, 19 Nov 2025 19:48:01 +0100 Subject: [PATCH 04/11] Added unit tests; fixed docstrings. --- .gitignore | 5 +- test/data/load/test_on_disk_datasetloaders.py | 166 +++++++ .../preprocess/test_on_disk_preprocessor.py | 320 +++++++++++++ test/memory_usage_tracking/memory_plotting.py | 242 ---------- .../graph__gcn__graph__fake.csv | 101 ++++ .../graph__gcn__graph__fake_inmem.csv | 102 ++++ .../memory_plot_normalized.png | Bin 0 -> 38581 bytes .../memory_plot_raw.png | Bin 0 -> 36419 bytes .../graph__gcn__graph__fake.csv | 107 +++++ .../graph__gcn__graph__fake_on_disk.csv | 49 ++ .../memory_plot_normalized.png | Bin 0 -> 39984 bytes .../memory_plot_raw.png | Bin 0 -> 35271 bytes .../test_memory_plotting.py | 211 +++++++++ tools/__init__.py | 0 tools/memory_usage_tracking/__init__.py | 0 .../memory_usage_tracking/memory_plotting.py | 446 ++++++++++++++++++ .../data/datasets/fake_on_disk_dataset.py | 179 ++++++- .../data/loaders/graph/fake_dataset_loader.py | 13 +- .../graph/fake_ondisk_dataset_loader.py | 12 +- .../data/preprocessor/on_disk_preprocessor.py | 219 +++++---- topobench/data/utils/split_utils.py | 84 +++- .../tutorial_on_disk_inductive_pipeline.ipynb | 8 +- 22 files changed, 1856 insertions(+), 408 deletions(-) create mode 100644 test/data/load/test_on_disk_datasetloaders.py create mode 100644 test/data/preprocess/test_on_disk_preprocessor.py delete mode 100644 test/memory_usage_tracking/memory_plotting.py create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png create mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png create mode 100644 test/tools/memory_usage_tracking/test_memory_plotting.py create mode 100644 tools/__init__.py create mode 100644 tools/memory_usage_tracking/__init__.py create mode 100644 tools/memory_usage_tracking/memory_plotting.py diff --git a/.gitignore b/.gitignore index fdcde230e..0b561641f 100755 --- a/.gitignore +++ b/.gitignore @@ -185,8 +185,9 @@ notebooks/tmp /tutorials/datasets/ /tutorials/lightning_logs/ /tutorials/datasets/ -# Memory usage tracking outputs -test/memory_usage_tracking/outputs/ + +# Sweep outputs +/tools/memory_usage_tracking/outputs # wandb wandb/ diff --git a/test/data/load/test_on_disk_datasetloaders.py b/test/data/load/test_on_disk_datasetloaders.py new file mode 100644 index 000000000..1c9c0e319 --- /dev/null +++ b/test/data/load/test_on_disk_datasetloaders.py @@ -0,0 +1,166 @@ +"""Comprehensive test suite for on-disk dataset loaders.""" + +from pathlib import Path +from typing import Any + +import hydra +import pytest +import torch_geometric +from torch_geometric.data import OnDiskDataset + + +class TestOnDiskLoaders: + """ + Test suite for dataset loaders using on-disk storage. + """ + + @pytest.fixture(autouse=True) + def setup(self): + """ + Set up Hydra and loader configuration before each test. + """ + hydra.core.global_hydra.GlobalHydra.instance().clear() + base_dir = Path(__file__).resolve().parents[3] + self.config_files = self._gather_config_files(base_dir) + self.relative_config_dir = "../../../configs" + self.test_splits = ["train", "val", "test"] + + def _gather_config_files(self, base_dir: Path) -> list[tuple[str, str]]: + """ + Gather all dataset config files. + + Parameters + ---------- + base_dir : Path + Project base directory. + + Returns + ------- + list of tuple of str + List of (data_domain, config_file) pairs. + """ + config_files: list[tuple[str, str]] = [] + config_base_dir = base_dir / "configs/dataset" + + exclude_datasets = { + "karate_club.yaml", + "REDDIT-BINARY.yaml", + "IMDB-MULTI.yaml", + "IMDB-BINARY.yaml", + "ogbg-molpcba.yaml", + "manual_dataset.yaml", + } + + self.long_running_datasets = { + "mantra_name.yaml", + "mantra_orientation.yaml", + "mantra_genus.yaml", + "mantra_betti_numbers.yaml", + } + + for dir_path in config_base_dir.iterdir(): + curr_dir = dir_path.name + if dir_path.is_dir(): + for f in dir_path.glob("*.yaml"): + if f.name in exclude_datasets: + continue + config_files.append((curr_dir, f.name)) + + return config_files + + def _load_dataset( + self, data_domain: str, config_file: str + ) -> tuple[OnDiskDataset | None, dict, Any]: + """ + Load dataset and configuration for the given YAML file. + + Parameters + ---------- + data_domain : str + Dataset domain name. + config_file : str + Dataset config filename. + + Returns + ------- + OnDiskDataset or None + Loaded on-disk dataset or None if memory_type is not on_disk. + dict + Dataset directory metadata as returned by the loader. + Any + Full Hydra-composed configuration. + """ + with hydra.initialize( + version_base="1.3", + config_path=self.relative_config_dir, + job_name="run", + ): + parameters = hydra.compose( + config_name="run.yaml", + overrides=[ + f"dataset={data_domain}/{config_file}", + "model=graph/gat", + ], + return_hydra_config=True, + ) + + memory_type = parameters.dataset.loader.parameters.get( + "memory_type", "in_memory" + ) + + if memory_type != "on_disk": + return None, {}, parameters + + print(f"{config_file}") + dataset_loader = hydra.utils.instantiate(parameters.dataset.loader) + + if config_file in self.long_running_datasets: + dataset, data_dir = dataset_loader.load(slice=100) + else: + dataset, data_dir = dataset_loader.load() + + return dataset, data_dir, parameters + + def test_on_disk_dataset_loading_states(self): + """ + Test loading and basic properties for on-disk datasets. + + For configs with memory_type == 'on_disk', this verifies that + the loader returns a valid OnDiskDataset and that features and + labels are non-empty. + """ + for data_domain, config_file in self.config_files: + dataset, _, parameters = self._load_dataset( + data_domain, config_file + ) + + # Skip in-memory datasets. + if dataset is None: + continue + + # Check that the returned dataset is backed by OnDiskDataset. + assert isinstance(dataset, OnDiskDataset) or isinstance( + dataset, torch_geometric.data.OnDiskDataset + ) + + # Dataset must contain at least one graph. + assert len(dataset) > 0 + + # Single-graph style (dataset.data) or multi-graph style (dataset[0]). + if hasattr(dataset, "data"): + data = dataset.data + else: + data = dataset[0] + + # Basic feature and label checks. + assert hasattr(data, "x"), "Missing node features" + assert hasattr(data, "y"), "Missing labels" + assert data.x is not None and data.x.numel() > 0, "Empty node features" + assert data.y is not None and data.y.numel() > 0, "Empty labels" + + # Node feature dimension consistency when available. + if hasattr(dataset, "num_node_features"): + assert data.x.size(1) == dataset.num_node_features + + # Basic repr should not crash. + repr(dataset) \ No newline at end of file diff --git a/test/data/preprocess/test_on_disk_preprocessor.py b/test/data/preprocess/test_on_disk_preprocessor.py new file mode 100644 index 000000000..4e55930b2 --- /dev/null +++ b/test/data/preprocess/test_on_disk_preprocessor.py @@ -0,0 +1,320 @@ +"""Tests for the OnDiskPreProcessor class.""" + +import json +import os +from unittest.mock import MagicMock, ANY, patch + +import pytest +import torch_geometric +from torch_geometric.data import Data +from omegaconf import DictConfig + +from topobench.data.preprocessor.on_disk_preprocessor import ( + OnDiskPreProcessor, + _LazyDataList, +) + + +@pytest.mark.usefixtures("mocker_fixture") +class TestOnDiskPreProcessor: + """ + Test suite for OnDiskPreProcessor. + """ + + @pytest.fixture(autouse=True) + def setup_method(self, mocker_fixture): + """ + Set up a fresh OnDiskPreProcessor for each test. + + Parameters + ---------- + mocker_fixture : pytest_mock.MockerFixture + Mocker fixture used to patch internals. + """ + mocker = mocker_fixture + + # Upstream dataset mocked as a regular PyG dataset. + self.dataset = MagicMock(spec=torch_geometric.data.Dataset) + self.data_dir = "fake/path" + + # Iteration over the upstream dataset should yield Data objects. + self.dataset.__iter__.return_value = iter([Data(), Data(), Data()]) + self.dataset.transform = None + + # Patch the underlying OnDiskDataset.__init__ to avoid real I/O / DB. + self.mock_ondisk_init = mocker.patch( + "torch_geometric.data.OnDiskDataset.__init__", + return_value=None, + ) + + # OnDiskPreProcessor.__init__ checks `len(self)` to decide whether + # to append from the upstream dataset. + self.mock_len = mocker.patch.object( + OnDiskPreProcessor, "__len__", return_value=0 + ) + + # Append should not touch the real on-disk DB. + self.mock_append = mocker.patch.object(OnDiskPreProcessor, "append") + + # Instantiate without transforms. + self.preprocessor = OnDiskPreProcessor( + self.dataset, self.data_dir, None + ) + + def teardown_method(self): + """ + Tear down state after each test. + """ + del self.preprocessor + + def test_init_without_transforms(self): + """ + Test initialization without transform configuration. + + Checks that OnDiskDataset.__init__ is called correctly, that + transforms_applied is False and that samples are appended. + """ + # super().__init__ should be called with the raw data_dir + self.mock_ondisk_init.assert_called_once_with( + root=self.data_dir, transform=None, pre_filter=None + ) + + # No transforms_config -> transforms_applied should be False + assert self.preprocessor.transforms_applied is False + + # Since len(self) == 0 (mocked), we should have appended all + # items from the upstream dataset. + self.mock_len.assert_called_once() + # Three samples in the iterator => 3 appends + assert self.mock_append.call_count == 3 + + def test_data_list_is_lazy_view(self): + """ + Test that data_list is lazy and delegates to the dataset. + + Ensures that data_list returns a _LazyDataList and that + _LazyDataList calls the underlying dataset __getitem__. + """ + # 1) Ensure OnDiskPreProcessor.data_list returns a _LazyDataList + dl = self.preprocessor.data_list + assert isinstance(dl, _LazyDataList) + + # 2) Separately test that _LazyDataList delegates to the underlying + # dataset without involving PyG Dataset internals. + class DummyDataset: + """ + Minimal dataset used to validate delegation logic. + """ + + def __init__(self): + """Initialize the dummy dataset.""" + self.calls = [] + + def __len__(self): + """ + Return dataset length. + + Returns + ------- + int + Fixed length value. + """ + return 3 + + def __getitem__(self, idx): + """ + Return a synthetic item. + + Parameters + ---------- + idx : int + Index of the requested element. + + Returns + ------- + str + Encoded index string. + """ + self.calls.append(idx) + return f"graph-{idx}" + + dummy = DummyDataset() + lazy = _LazyDataList(dummy) + + out = lazy[0] + assert out == "graph-0" + assert dummy.calls == [0] + + def test_init_with_transforms(self, mocker_fixture): + """ + Test initialization when transforms_config is provided. + + Verifies heavy and easy transforms are built and composed, and that + transform parameters are saved. + """ + mocker = mocker_fixture + + # Repatch OnDiskDataset.__init__ just to be explicit for this test + mock_ondisk_init = mocker.patch( + "torch_geometric.data.OnDiskDataset.__init__", + return_value=None, + ) + + # Upstream dataset with an intrinsic transform + dataset = MagicMock(spec=torch_geometric.data.Dataset) + dataset.__iter__.return_value = iter([Data(), Data()]) + dataset.transform = "intrinsic_transform" + + # Heavy & easy transforms (we only care that they flow through) + heavy_transform = MagicMock() + heavy_transform.parameters = {"alpha": 1} + easy_transform = MagicMock() + easy_transform.parameters = {"beta": 2} + + heavy_dict = {"heavy": heavy_transform} + easy_dict = {"easy": easy_transform} + + # _build_transform_dict is called twice: + # 1) for heavy transforms in __init__ + # 2) for easy transforms in _prepare_online_transforms + build_dict_mock = mocker.patch.object( + OnDiskPreProcessor, + "_build_transform_dict", + side_effect=[(heavy_dict, {}), (easy_dict, {})], + ) + + # _compose_from_dict is called twice: + # 1) once for the heavy/offline pipeline + # 2) once for the easy/online part + heavy_pipeline = MagicMock(name="heavy_pipeline") + easy_pipeline = MagicMock(name="easy_pipeline") + compose_mock = mocker.patch.object( + OnDiskPreProcessor, + "_compose_from_dict", + side_effect=[heavy_pipeline, easy_pipeline], + ) + + save_params_mock = mocker.patch.object( + OnDiskPreProcessor, "save_transform_parameters" + ) + + # Config with one heavy and one easy transform type + transforms_config = { + "lift": {"transform_type": "lifting", "foo": "bar"}, + "small": {"transform_type": "something_else", "baz": "qux"}, + } + + preproc = OnDiskPreProcessor(dataset, self.data_dir, transforms_config) + + # The dataset is created for a hashed subdirectory under data_dir. + mock_ondisk_init.assert_called_once() + _, kwargs = mock_ondisk_init.call_args + assert "root" in kwargs + assert kwargs["root"].startswith(self.data_dir) + + # Heavy transforms should be applied + assert preproc.transforms_applied is True + assert preproc.heavy_transforms is heavy_pipeline + + # _build_transform_dict called once for heavy, once for easy + assert build_dict_mock.call_count == 2 + + # We set heavy_pipeline and easy_pipeline as side effects: + assert compose_mock.call_count == 2 + + # Online transform should be a Compose(...) of + # [dataset.transform, easy_pipeline] + from torch_geometric.transforms import Compose + + assert isinstance(preproc.transform, Compose) + + # Heavy transform parameters must have been persisted/validated + save_params_mock.assert_called_once() + + def test_process_applies_heavy_and_respects_pre_filter(self): + """ + Test the process method with heavy transforms and pre_filter. + + Uses a bare instance created with __new__ and a small in-memory + dataset. + """ + # Build a "bare" instance without running __init__ + proc = OnDiskPreProcessor.__new__(OnDiskPreProcessor) + + # Small in-memory source dataset + data1 = Data() + data2 = Data() + proc.dataset = [data1, data2] + + # Heavy transforms pipeline (offline) + heavy_transform = MagicMock(side_effect=lambda d: d) + proc.heavy_transforms = heavy_transform + + # pre_filter that keeps every sample + proc.pre_filter = lambda d: True + + # append should just be a mock (no real DB) + proc.append = MagicMock() + + # Run process + OnDiskPreProcessor.process(proc) + + # Both samples passed through heavy_transforms and appended + assert heavy_transform.call_count == 2 + assert proc.append.call_count == 2 + + def test_process_raises_on_non_basedata(self): + """ + Test that process raises on non-BaseData samples. + + Ensures that TypeError is raised when dataset elements are not + PyG BaseData instances. + + Raises + ------ + TypeError + If a non-BaseData object is processed. + """ + proc = OnDiskPreProcessor.__new__(OnDiskPreProcessor) + + proc.dataset = [object()] # not a BaseData + proc.heavy_transforms = None + proc.pre_filter = None + proc.append = MagicMock() + + with pytest.raises(TypeError): + OnDiskPreProcessor.process(proc) + + @patch( + "topobench.data.preprocessor.on_disk_preprocessor." + "load_inductive_splits_on_disk" + ) + def test_load_dataset_splits_inductive( + self, mock_load_inductive_splits_on_disk + ): + """ + Test loading dataset splits for inductive learning. + + Parameters + ---------- + mock_load_inductive_splits_on_disk : unittest.mock.MagicMock + Mock for load_inductive_splits_on_disk. + """ + split_params = DictConfig({"learning_setting": "inductive"}) + self.preprocessor.load_dataset_splits(split_params) + mock_load_inductive_splits_on_disk.assert_called_once_with( + self.preprocessor, split_params + ) + + def test_invalid_learning_setting_raises(self): + """ + Test that invalid learning settings raise ValueError. + + Raises + ------ + ValueError + If learning_setting is not supported. + """ + split_params = DictConfig({"learning_setting": "transductive"}) + with pytest.raises(ValueError): + self.preprocessor.load_dataset_splits(split_params) \ No newline at end of file diff --git a/test/memory_usage_tracking/memory_plotting.py b/test/memory_usage_tracking/memory_plotting.py deleted file mode 100644 index b25804693..000000000 --- a/test/memory_usage_tracking/memory_plotting.py +++ /dev/null @@ -1,242 +0,0 @@ -# test/memory_usage_tracking/memory_plotting.py - -import argparse -import ast -import csv -import os -import subprocess -import sys -import tempfile -import time - -import matplotlib.pyplot as plt -import pandas as pd -import psutil - -# Constants & paths -SCRIPT_FILE_PATH = "test/pipeline/memory_checks_template.py" -OUTPUT_ROOT = "test/memory_usage_tracking/outputs" - -# Helpers -def dataset_short(name: str) -> str: - """Return the part after the first '/' in the dataset path.""" - parts = name.split("/", 1) - return parts[1] if len(parts) > 1 else parts[0] - -def model_fs(name: str) -> str: - """When used in file/folder names, replace '/' with '__'.""" - return name.replace("/", "__") - -# AST modification -def apply_ast_replacements(original_content: str, dataset_to_inject: str, model_to_inject: str) -> str: - tree = ast.parse(original_content) - - class ModuleLevelReplacer(ast.NodeTransformer): - def visit_Module(self, node): - for n in node.body: - if isinstance(n, ast.Assign) and len(n.targets) == 1 and isinstance(n.targets[0], ast.Name): - name = n.targets[0].id - if name == "DATASET": - n.value = ast.Constant(value=dataset_to_inject) - elif name == "MODELS": - n.value = ast.List(elts=[ast.Constant(value=model_to_inject)], ctx=ast.Load()) - return node - - modified_tree = ModuleLevelReplacer().visit(tree) - ast.fix_missing_locations(modified_tree) - return ast.unparse(modified_tree) - -# Core monitoring -def monitor_script(script_path: str, - dataset_to_inject: str, - model_to_inject: str, - output_csv: str, - interval: float = 0.05) -> tuple[list[tuple[float, float]], int]: - print(f"Running for model '{model_to_inject}' on dataset '{dataset_to_inject}'") - - project_root = os.getcwd() - script_abspath = os.path.abspath(script_path) - - env = os.environ.copy() - env["PYTHONPATH"] = project_root + os.pathsep + env.get("PYTHONPATH", "") - - try: - with open(script_abspath, encoding="utf-8") as f: - original_content = f.read() - except FileNotFoundError: - print(f"ERROR: Template not found at {script_abspath}", file=sys.stderr) - return [], -1 - - try: - modified_code = apply_ast_replacements(original_content, dataset_to_inject, model_to_inject) - except Exception as e: - print(f"ERROR: Failed to AST-modify the template: {e}", file=sys.stderr) - return [], -1 - - temp_script_path: str | None = None - try: - original_script_dir = os.path.dirname(script_abspath) - with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, dir=original_script_dir, encoding="utf-8") as temp_f: - temp_f.write(modified_code) - temp_script_path = temp_f.name - - process = subprocess.Popen(["pytest", temp_script_path], cwd=project_root, env=env) - - ps_proc = psutil.Process(process.pid) - memory_data: list[tuple[float, float]] = [] - start_time = time.time() - - try: - while process.poll() is None: - try: - mem_info = ps_proc.memory_info() - rss_mb = mem_info.rss / (1024 ** 2) - timestamp = time.time() - start_time - memory_data.append((timestamp, rss_mb)) - time.sleep(interval) - except (psutil.NoSuchProcess, psutil.AccessDenied): - break - except KeyboardInterrupt: - print("Interrupted by user. Terminating child process.") - process.terminate() - - process.wait() - return_code = process.returncode - total_runtime = time.time() - start_time - - print(f"Script finished in {total_runtime:.2f}s with return code {return_code}") - - with open(output_csv, "w", newline="", encoding="utf-8") as f: - writer = csv.writer(f) - writer.writerow(["time_s", "memory_MB"]) - writer.writerows(memory_data) - print(f"Memory usage saved to {output_csv}") - - return memory_data, return_code - finally: - if temp_script_path and os.path.exists(temp_script_path): - try: - os.remove(temp_script_path) - print(f"Temporary script {temp_script_path} removed.") - except OSError as e: - print(f"Warning: failed to remove temp file {temp_script_path}: {e}", file=sys.stderr) - -# Plotting (normalized time) -def plot_normalized_memory(model_label: str, - csv_files: list[str], - labels: list[str], - plot_path: str, - colors: tuple[str, str] = ("blue", "red")) -> None: - plt.figure(figsize=(10, 6)) - for i, (csv_file, label) in enumerate(zip(csv_files, labels, strict=False)): - if not os.path.exists(csv_file): - print(f"Warning: CSV file not found, skipping plot line: {csv_file}") - continue - df = pd.read_csv(csv_file) - if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: - print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") - continue - total_duration = df["time_s"].iloc[-1] - df["time_s"].iloc[0] - if total_duration > 0: - df["norm_time"] = (df["time_s"] - df["time_s"].iloc[0]) / total_duration - else: - n = max(1, len(df) - 1) - df["norm_time"] = (df.index - df.index[0]) / n - print(f"Warning: zero duration in {csv_file}; using sample index for normalization.") - plt.plot(df["norm_time"], df["memory_MB"], label=label, color=colors[i % len(colors)]) - plt.xlabel("Normalized time") - plt.ylabel("Memory usage [MB]") - plt.title(f"Memory usage comparison for model: {model_label}") - plt.xlim(0, 1) - plt.ylim(0, None) - plt.legend(loc="best") - plt.tight_layout() - plt.savefig(plot_path) - plt.close() - -# Plotting (raw time) -def plot_raw_time_memory(model_label: str, - csv_files: list[str], - labels: list[str], - plot_path: str, - colors: tuple[str, str] = ("blue", "red")) -> None: - """ - Plot memory vs raw time (seconds since start, shifted to t=0). - """ - plt.figure(figsize=(10, 6)) - for i, (csv_file, label) in enumerate(zip(csv_files, labels, strict=False)): - if not os.path.exists(csv_file): - print(f"Warning: CSV file not found, skipping plot line: {csv_file}") - continue - df = pd.read_csv(csv_file) - if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: - print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") - continue - t0 = df["time_s"].iloc[0] if len(df) else 0.0 - df["time_shifted"] = df["time_s"] - t0 - plt.plot(df["time_shifted"], df["memory_MB"], label=label, color=colors[i % len(colors)]) - plt.xlabel("Time [s]") - plt.ylabel("Memory usage [MB]") - plt.title(f"Memory usage (raw time) for model: {model_label}") - plt.xlim(0, None) - plt.ylim(0, None) - plt.legend(loc="best") - plt.tight_layout() - plt.savefig(plot_path) - plt.close() - -# CLI entry -def main(): - parser = argparse.ArgumentParser(description="Monitor and plot memory usage of a test pipeline.") - parser.add_argument("--datasets", type=str, nargs=2, required=True, - help="Two datasets to compare (e.g., graph/ds1 hypergraph/ds1). Order is used for plotting and file naming.") - parser.add_argument("--models", type=str, nargs="+", required=True, - help="One or more models to run (e.g., graph/gcn).") - parser.add_argument("--interval", type=float, default=0.05, - help="Sampling interval in seconds (default: 0.05).") - args = parser.parse_args() - - dataset1_disp = dataset_short(args.datasets[0]) - dataset2_disp = dataset_short(args.datasets[1]) - - # Filesystem parts (datasets shown without prefix) - dataset1_fs = dataset1_disp - dataset2_fs = dataset2_disp - - for model in args.models: - model_label = model - model_part = model_fs(model_label) # only for file/folder names - - # One folder per (dataset1,dataset2,model) - cfg_folder = f"{dataset1_fs}__{dataset2_fs}__{model_part}" - config_dir = os.path.join(OUTPUT_ROOT, cfg_folder) - os.makedirs(config_dir, exist_ok=True) - - csv_outputs_for_model: list[str] = [] - return_codes: list[int] = [] - - for dataset_disp in (dataset1_disp, dataset2_disp): - # Inject the ORIGINAL dataset string into the template - original_dataset_arg = args.datasets[0] if dataset_disp == dataset1_disp else args.datasets[1] - output_csv = os.path.join(config_dir, f"{model_part}__{dataset_disp}.csv") - _, rc = monitor_script(SCRIPT_FILE_PATH, original_dataset_arg, model_label, output_csv, interval=args.interval) - csv_outputs_for_model.append(output_csv) - return_codes.append(rc) - - for i, rc in enumerate(return_codes): - if rc != 0: - print( - f"WARNING: Run for model '{model_label}' on dataset '{[dataset1_disp, dataset2_disp][i]}' " - f"exited with non-zero code {rc}.", - file=sys.stderr - ) - - labels = [dataset1_disp, dataset2_disp] - norm_plot_path = os.path.join(config_dir, "memory_plot_normalized.png") - raw_plot_path = os.path.join(config_dir, "memory_plot_raw.png") - - plot_normalized_memory(model_label, csv_outputs_for_model, labels=labels, plot_path=norm_plot_path, colors=("blue", "red")) - plot_raw_time_memory(model_label, csv_outputs_for_model, labels=labels, plot_path=raw_plot_path, colors=("blue", "red")) - -if __name__ == "__main__": - main() diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv new file mode 100644 index 000000000..841249d72 --- /dev/null +++ b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv @@ -0,0 +1,101 @@ +time_s,memory_MB +1.6927719116210938e-05,0.140625 +0.05505681037902832,26.9375 +0.11008405685424805,40.171875 +0.16512393951416016,74.109375 +0.22957587242126465,120.515625 +0.28199291229248047,139.796875 +0.3370029926300049,154.0 +0.3920760154724121,163.15625 +0.44712281227111816,169.53125 +0.5021579265594482,176.671875 +0.5571870803833008,188.59375 +0.6122150421142578,200.140625 +0.6672439575195312,207.171875 +0.7222766876220703,217.328125 +0.7773089408874512,236.71875 +0.8323378562927246,249.171875 +0.8873658180236816,256.53125 +0.942396879196167,262.34375 +0.9974479675292969,273.46875 +1.0524818897247314,283.046875 +1.107517957687378,293.953125 +1.1625499725341797,309.671875 +1.2175769805908203,315.140625 +1.2726068496704102,328.84375 +1.3276360034942627,335.296875 +1.3826639652252197,344.5 +1.4376850128173828,356.171875 +1.4927117824554443,372.28125 +1.547738790512085,393.25 +1.6027848720550537,403.234375 +1.657824993133545,411.375 +1.7128548622131348,424.375 +1.7678849697113037,435.390625 +1.822916030883789,441.234375 +1.8779399394989014,451.453125 +1.9329628944396973,457.375 +1.9879889488220215,465.859375 +2.043017864227295,469.46875 +2.098038911819458,470.921875 +2.152184009552002,473.96875 +2.2045140266418457,483.171875 +2.259547710418701,494.359375 +2.3145759105682373,499.96875 +2.3653957843780518,505.125 +2.4204318523406982,553.59375 +2.4754600524902344,553.671875 +2.530489683151245,566.828125 +2.585533857345581,566.828125 +2.640575885772705,579.6875 +2.6956098079681396,580.734375 +2.750638008117676,581.625 +2.8056697845458984,585.25 +2.860700845718384,586.03125 +2.9157328605651855,586.84375 +2.970773935317993,586.84375 +3.0258097648620605,611.984375 +3.0808377265930176,611.984375 +3.135877847671509,612.03125 +3.1909077167510986,612.03125 +3.2459356784820557,612.0625 +3.3009610176086426,612.0625 +3.3559937477111816,612.0625 +3.4110209941864014,612.84375 +3.4660511016845703,613.625 +3.5210838317871094,613.671875 +3.57613205909729,613.671875 +3.631154775619507,626.453125 +3.6861817836761475,633.84375 +3.741210699081421,633.84375 +3.7962398529052734,634.625 +3.851271867752075,634.625 +3.9063048362731934,661.171875 +3.9613330364227295,661.171875 +4.016355037689209,661.171875 +4.071379899978638,661.171875 +4.126403093338013,662.734375 +4.18143367767334,662.734375 +4.236473083496094,662.734375 +4.291501045227051,662.734375 +4.346532821655273,662.734375 +4.401551723480225,662.734375 +4.456584930419922,662.734375 +4.511609792709351,662.734375 +4.566629886627197,662.734375 +4.621665000915527,662.734375 +4.676706075668335,662.734375 +4.731735944747925,662.734375 +4.786756753921509,662.734375 +4.841794013977051,662.734375 +4.896823883056641,675.328125 +4.95185399055481,675.40625 +5.006899833679199,675.6875 +5.061941862106323,675.6875 +5.116989850997925,675.6875 +5.172023057937622,675.6875 +5.227057933807373,676.0 +5.2820868492126465,676.0 +5.337118864059448,676.015625 +5.3921449184417725,676.125 +5.447188854217529,692.03125 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv new file mode 100644 index 000000000..6fffcfdd1 --- /dev/null +++ b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv @@ -0,0 +1,102 @@ +time_s,memory_MB +1.7881393432617188e-05,0.53125 +0.05505776405334473,25.28125 +0.11008381843566895,39.921875 +0.16510987281799316,72.75 +0.22012972831726074,115.28125 +0.2751758098602295,137.859375 +0.3314208984375,150.984375 +0.38599276542663574,163.0 +0.44470977783203125,167.828125 +0.49636387825012207,176.84375 +0.551386833190918,187.453125 +0.6064157485961914,197.71875 +0.6614446640014648,206.140625 +0.7164757251739502,215.546875 +0.7715058326721191,234.84375 +0.8265378475189209,247.296875 +0.8815667629241943,256.75 +0.9365897178649902,261.875 +0.9916186332702637,273.578125 +1.046651840209961,281.046875 +1.1016829013824463,291.109375 +1.1567139625549316,305.984375 +1.2117397785186768,313.875 +1.2667639255523682,327.125 +1.3217897415161133,334.390625 +1.3768136501312256,344.1875 +1.4318428039550781,355.9375 +1.4868748188018799,370.578125 +1.5419089794158936,392.734375 +1.5969526767730713,403.921875 +1.651977777481079,412.734375 +1.7070088386535645,424.859375 +1.762035846710205,437.890625 +1.817063808441162,441.9375 +1.872093915939331,450.53125 +1.9271166324615479,458.453125 +1.9821429252624512,467.9375 +2.037170886993408,470.609375 +2.0921988487243652,472.0 +2.145357608795166,474.96875 +2.2003777027130127,484.3125 +2.2522459030151367,496.59375 +2.3072707653045654,510.859375 +2.362304925918579,587.75 +2.417332887649536,625.703125 +2.4723587036132812,668.21875 +2.527395725250244,670.96875 +2.582418918609619,671.171875 +2.6374526023864746,699.34375 +2.69248366355896,699.359375 +2.747513771057129,732.71875 +2.8025548458099365,732.71875 +2.85758376121521,736.359375 +2.9126198291778564,743.234375 +2.9676506519317627,743.265625 +3.0226778984069824,743.390625 +3.0777106285095215,743.390625 +3.1327459812164307,744.234375 +3.187772750854492,744.28125 +3.242811679840088,744.28125 +3.2978458404541016,751.28125 +3.3528738021850586,751.28125 +3.407902956008911,776.140625 +3.4629247188568115,776.140625 +3.5179507732391357,776.15625 +3.572990894317627,776.15625 +3.6280157566070557,776.984375 +3.683041572570801,789.109375 +3.738067865371704,789.6875 +3.793095827102661,821.71875 +3.8481197357177734,821.71875 +3.9031527042388916,821.71875 +3.9581775665283203,821.71875 +4.013209819793701,821.71875 +4.068231821060181,821.75 +4.123273849487305,821.75 +4.17830491065979,821.75 +4.233339786529541,821.75 +4.288366794586182,821.75 +4.343406677246094,821.75 +4.3984386920928955,821.75 +4.453459978103638,821.75 +4.508484840393066,821.75 +4.56351375579834,821.75 +4.618542671203613,821.75 +4.6735680103302,824.21875 +4.728593826293945,824.21875 +4.783620834350586,824.21875 +4.8386476039886475,824.21875 +4.893677711486816,824.21875 +4.948705673217773,836.203125 +5.00373387336731,836.34375 +5.0587708950042725,836.34375 +5.113834857940674,813.03125 +5.1688759326934814,813.03125 +5.223917722702026,813.03125 +5.2789528369903564,813.046875 +5.333986759185791,813.046875 +5.389018774032593,813.0625 +5.444069862365723,813.15625 +5.499108791351318,831.234375 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png new file mode 100644 index 0000000000000000000000000000000000000000..f310a8c405ab0962d108aca71f128dd2e0df1978 GIT binary patch literal 38581 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�Ad?K{c!1#Nt*@k&> z>oKu@5*Qfv0n{lF8BRJzQ83^~JGUjtPI(B1 zPJTZ6P46}=;H7ZmMTIlap?wz2J66DWGl*^SR~`kd}scA)`5x?`{V#^w=4_z5Fw1`U;7*q1g5v}5a_96`) zkU=690c0~da)qTlF$~#s03bN@5JXxkFlTrHZ+&Y+~Y zD4?X&0{ZDGMnxdUk!8SV#w zTCi@`|L>>u{`~=j!p{XAc98br`dD?aDxx+94*6qbGVO~7=NG#d*7smXYOSQ#O@{^f zH_7t)X(j-nV7{h9d#A#uOF)|@AetdgI$zE5H87H^6qN(mfqKakdh3RvEh};p2a^oE9p!=!a7F^;>1 zj~*3H5xcwBrdBgQ`1<)BIZ02SeDYX+etuF(2`N1*i>xnp|NblYQeVYJOEj8KQ&V%T zRNqZlSUB2)6}qbk0NC%QX<(43tfZ6>&BM)|j=`{P3i0qEW^tSMIIimnyPDR>fBmR&&U|F*D6!j(rRBC z8cKAJE-x?V_awHrC+G=DoPv?5)sh=|KjZ7;o&@n6DOW8E-wD= z6BQO#2YK)k-lfh}FVJ;)d6{T&#?iar<{eY;l~q|B z!cNc5&(GJe%&-(qPfcZh@b}*eAyY#0r-VZIulOfJZ5^FVaZ*oyUf$<7Z}xGZS+@B( zQ)ehCDVgZ*t#eA5g*{dE?qE27-q;1#vz$9MJ7elN)OAAQ+=fKLCs%Fluh%#@2u7o1GEeWtvCTPEdw5tZ92~M~ ztuUA)V3p1yff-ZunjBl@=E_bL1l2F0w%gghoZ{c+WQF>-C!I&OBIJ+i-$wTT-&Z!= aw<(3FC6E0q4%tB%rNkdU$h`OT<^Khu0zQiX literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png new file mode 100644 index 0000000000000000000000000000000000000000..31ba870bdf9206bbf9071e146dff3c5afaab64e3 GIT binary patch literal 36419 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 F{6F_|ut@*_ literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv new file mode 100644 index 000000000..4db6bc6b2 --- /dev/null +++ b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv @@ -0,0 +1,107 @@ +time_s,memory_MB +1.430511474609375e-05,0.109375 +0.0550532341003418,27.1875 +0.11008524894714355,39.75 +0.16513514518737793,67.375 +0.220170259475708,97.953125 +0.27762627601623535,129.359375 +0.3335573673248291,151.28125 +0.3857383728027344,162.234375 +0.44231510162353516,167.421875 +0.49688029289245605,174.234375 +0.5482051372528076,182.53125 +0.6032323837280273,192.90625 +0.6582651138305664,202.40625 +0.7132983207702637,208.546875 +0.7683303356170654,217.609375 +0.8233752250671387,237.328125 +0.8784072399139404,250.265625 +0.9334421157836914,256.234375 +0.9884722232818604,263.890625 +1.0434973239898682,273.953125 +1.0985190868377686,284.84375 +1.153550148010254,297.78125 +1.2085802555084229,309.828125 +1.263606071472168,318.5 +1.3186311721801758,333.59375 +1.3736591339111328,338.1875 +1.4286892414093018,346.265625 +1.4837172031402588,358.609375 +1.538736343383789,376.5 +1.593766212463379,393.09375 +1.6488213539123535,403.875 +1.703857183456421,414.703125 +1.758885145187378,428.15625 +1.8139193058013916,436.953125 +1.8689494132995605,446.203125 +1.923976182937622,454.765625 +1.9790053367614746,460.34375 +2.0340280532836914,465.703125 +2.0890543460845947,470.5625 +2.144127368927002,472.03125 +2.199007272720337,475.578125 +2.2505431175231934,484.75 +2.3055691719055176,495.90625 +2.3605942726135254,501.484375 +2.415626287460327,501.796875 +2.4706413745880127,501.953125 +2.5256550312042236,502.015625 +2.58066725730896,502.0625 +2.6356892585754395,503.265625 +2.6907193660736084,508.484375 +2.745751142501831,553.09375 +2.80078125,554.03125 +2.8558123111724854,590.703125 +2.910842180252075,593.484375 +2.965888023376465,596.6875 +3.020925283432007,608.578125 +3.075955390930176,608.59375 +3.1309890747070312,610.078125 +3.18605899810791,610.859375 +3.2410943508148193,610.890625 +3.2961223125457764,610.890625 +3.351144313812256,640.921875 +3.406165361404419,641.03125 +3.4612081050872803,641.03125 +3.516230344772339,667.765625 +3.571263313293457,667.78125 +3.626293420791626,667.8125 +3.681319236755371,667.8125 +3.736347198486328,669.390625 +3.7913851737976074,669.390625 +3.8464083671569824,669.40625 +3.901430130004883,669.40625 +3.9564521312713623,689.15625 +4.011484384536743,689.21875 +4.0665123462677,689.21875 +4.121539115905762,689.328125 +4.176562309265137,689.328125 +4.231597185134888,689.328125 +4.286616086959839,689.328125 +4.341645240783691,689.328125 +4.396670341491699,689.328125 +4.451701402664185,689.328125 +4.506721019744873,689.328125 +4.56174635887146,689.328125 +4.616775274276733,689.359375 +4.671799182891846,689.359375 +4.726828098297119,689.40625 +4.781855344772339,689.40625 +4.836894273757935,689.40625 +4.891922235488892,689.40625 +4.946948289871216,689.40625 +5.001979351043701,689.40625 +5.057012319564819,689.40625 +5.109022378921509,689.40625 +5.164051294326782,689.40625 +5.219078302383423,695.859375 +5.274112224578857,695.890625 +5.329160213470459,696.1875 +5.384206295013428,696.1875 +5.43925142288208,696.1875 +5.49428915977478,696.1875 +5.549321413040161,696.5 +5.6043572425842285,696.5 +5.6593921184539795,696.515625 +5.714420318603516,696.59375 +5.769449234008789,713.609375 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv new file mode 100644 index 000000000..6b684bb29 --- /dev/null +++ b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv @@ -0,0 +1,49 @@ +time_s,memory_MB +1.71661376953125e-05,0.546875 +0.05505013465881348,25.34375 +0.11007404327392578,40.09375 +0.1650989055633545,73.34375 +0.2201220989227295,115.8125 +0.27518415451049805,134.515625 +0.33127427101135254,151.421875 +0.38585901260375977,162.6875 +0.4391789436340332,168.421875 +0.4942340850830078,176.40625 +0.547835111618042,188.28125 +0.6028590202331543,198.171875 +0.6578850746154785,206.046875 +0.7129120826721191,215.75 +0.7679412364959717,235.15625 +0.8229711055755615,248.65625 +0.8779990673065186,257.15625 +0.9330201148986816,262.53125 +0.988051176071167,274.203125 +1.043081283569336,282.140625 +1.09810209274292,292.46875 +1.153135061264038,306.4375 +1.2081630229949951,314.84375 +1.2631900310516357,327.125 +1.3182141780853271,335.0625 +1.3732399940490723,344.921875 +1.4282679557800293,356.09375 +1.483290195465088,370.9375 +1.5383169651031494,391.21875 +1.5933659076690674,404.640625 +1.6483943462371826,412.328125 +1.7034211158752441,426.734375 +1.758451223373413,438.015625 +1.8134791851043701,444.890625 +1.8685071468353271,450.390625 +1.9235281944274902,459.796875 +1.9785640239715576,465.171875 +2.0335941314697266,471.140625 +2.088621139526367,472.203125 +2.1436421871185303,477.09375 +2.1986911296844482,477.140625 +2.2537381649017334,477.140625 +2.308777332305908,477.140625 +2.363819122314453,477.1875 +2.4188551902770996,477.1875 +2.4738852977752686,477.203125 +2.528918981552124,477.203125 +2.5839731693267822,478.078125 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png new file mode 100644 index 0000000000000000000000000000000000000000..7f437374e04875ace60e195b5e321c00c1b2f135 GIT binary patch literal 39984 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 literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png new file mode 100644 index 0000000000000000000000000000000000000000..10cc4a63881b48b0007fadfb40b988e8bce8d2eb GIT binary patch literal 35271 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 1 + assert all(len(t) == 2 for t in memory_data) + + # Assertions on CSV content. + assert output_csv.exists() + df = pd.read_csv(output_csv) + assert list(df.columns) == ["time_s", "memory_MB"] + assert not df.empty + + def test_plot_normalized_memory_creates_file(self, tmp_path: Path): + """ + Test normalized memory plotting from CSV. + + Writes a simple CSV and verifies that the plot file is created. + """ + csv_path = tmp_path / "mem.csv" + df = pd.DataFrame( + { + "time_s": [0.0, 0.5, 1.0], + "memory_MB": [100.0, 120.0, 110.0], + } + ) + df.to_csv(csv_path, index=False) + + plot_path = tmp_path / "plot_norm.png" + plot_normalized_memory( + model_label="graph/gcn", + csv_files=[str(csv_path)], + labels=["cora"], + plot_path=str(plot_path), + colors=("blue",), + ) + + assert plot_path.exists() + assert plot_path.stat().st_size > 0 + + def test_plot_raw_time_memory_creates_file(self, tmp_path: Path): + """ + Test raw time memory plotting from CSV. + + Writes a simple CSV and verifies that the plot file is created. + """ + csv_path = tmp_path / "mem.csv" + df = pd.DataFrame( + { + "time_s": [10.0, 10.5, 11.0], + "memory_MB": [200.0, 210.0, 205.0], + } + ) + df.to_csv(csv_path, index=False) + + plot_path = tmp_path / "plot_raw.png" + plot_raw_time_memory( + model_label="graph/gcn", + csv_files=[str(csv_path)], + labels=["cora"], + plot_path=str(plot_path), + colors=("red",), + ) + + assert plot_path.exists() + assert plot_path.stat().st_size > 0 \ No newline at end of file diff --git a/tools/__init__.py b/tools/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tools/memory_usage_tracking/__init__.py b/tools/memory_usage_tracking/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tools/memory_usage_tracking/memory_plotting.py b/tools/memory_usage_tracking/memory_plotting.py new file mode 100644 index 000000000..9db40aa0c --- /dev/null +++ b/tools/memory_usage_tracking/memory_plotting.py @@ -0,0 +1,446 @@ +"""Monitor and plot memory usage of test pipelines.""" + +import argparse +import ast +import csv +import itertools +import os +import subprocess +import sys +import tempfile +import time + +import matplotlib.pyplot as plt +import pandas as pd +import psutil + +# Constants & paths +SCRIPT_FILE_PATH = "test/pipeline/memory_checks_template.py" +OUTPUT_ROOT = "test/memory_usage_tracking/outputs" + + +def dataset_short(name: str) -> str: + """ + Return the substring after the first slash. + + Parameters + ---------- + name : str + Dataset name or path-like string. + + Returns + ------- + str + Shortened dataset name. + """ + parts = name.split("/", 1) + return parts[1] if len(parts) > 1 else parts[0] + + +def model_fs(name: str) -> str: + """ + Make a filesystem-safe name. + + Parameters + ---------- + name : str + Original model or dataset name. + + Returns + ------- + str + Name with slashes replaced by double underscores. + """ + return name.replace("/", "__") + + +def apply_ast_replacements( + original_content: str, + dataset_to_inject: str, + model_to_inject: str, +) -> str: + """ + Replace module-level DATASET and MODELS assignments. + + Parameters + ---------- + original_content : str + Original Python source. + dataset_to_inject : str + New value for the DATASET variable. + model_to_inject : str + New single model name for the MODELS list. + + Returns + ------- + str + Modified Python source code. + + Raises + ------ + SyntaxError + If the original source cannot be parsed. + """ + tree = ast.parse(original_content) + + class ModuleLevelReplacer(ast.NodeTransformer): + """AST transformer for module-level assignments.""" + + def visit_Module(self, node): + """ + Modify DATASET and MODELS assignments in the module. + + Parameters + ---------- + node : ast.Module + Root module node. + + Returns + ------- + ast.Module + Modified module node. + """ + for n in node.body: + if ( + isinstance(n, ast.Assign) + and len(n.targets) == 1 + and isinstance(n.targets[0], ast.Name) + ): + name = n.targets[0].id + if name == "DATASET": + n.value = ast.Constant(value=dataset_to_inject) + elif name == "MODELS": + n.value = ast.List( + elts=[ast.Constant(value=model_to_inject)], + ctx=ast.Load(), + ) + return node + + modified_tree = ModuleLevelReplacer().visit(tree) + ast.fix_missing_locations(modified_tree) + return ast.unparse(modified_tree) + + +def monitor_script( + script_path: str, + dataset_to_inject: str, + model_to_inject: str, + output_csv: str, + interval: float = 0.05, +) -> tuple[list[tuple[float, float]], int]: + """ + Run a pytest script and track its memory usage. + + Parameters + ---------- + script_path : str + Path to the template Python test script. + dataset_to_inject : str + Dataset string to inject into the template. + model_to_inject : str + Model string to inject into the template. + output_csv : str + Path where memory usage CSV will be written. + interval : float, optional + Sampling interval in seconds, by default 0.05. + + Returns + ------- + list of tuple of float + Recorded (time_s, memory_MB) pairs. + int + Exit code of the pytest process. + """ + print(f"Running for model '{model_to_inject}' on dataset '{dataset_to_inject}'") + + project_root = os.getcwd() + script_abspath = os.path.abspath(script_path) + + env = os.environ.copy() + env["PYTHONPATH"] = project_root + os.pathsep + env.get("PYTHONPATH", "") + + try: + with open(script_abspath, encoding="utf-8") as f: + original_content = f.read() + except FileNotFoundError: + print(f"ERROR: Template not found at {script_abspath}", file=sys.stderr) + return [], -1 + + try: + modified_code = apply_ast_replacements( + original_content, dataset_to_inject, model_to_inject + ) + except Exception as e: # noqa: BLE001 + print(f"ERROR: Failed to AST-modify the template: {e}", file=sys.stderr) + return [], -1 + + temp_script_path: str | None = None + try: + original_script_dir = os.path.dirname(script_abspath) + with tempfile.NamedTemporaryFile( + mode="w", + suffix=".py", + delete=False, + dir=original_script_dir, + encoding="utf-8", + ) as temp_f: + temp_f.write(modified_code) + temp_script_path = temp_f.name + + process = subprocess.Popen( + ["pytest", temp_script_path], cwd=project_root, env=env + ) + + ps_proc = psutil.Process(process.pid) + memory_data: list[tuple[float, float]] = [] + start_time = time.time() + + try: + while process.poll() is None: + try: + mem_info = ps_proc.memory_info() + rss_mb = mem_info.rss / (1024**2) + timestamp = time.time() - start_time + memory_data.append((timestamp, rss_mb)) + time.sleep(interval) + except (psutil.NoSuchProcess, psutil.AccessDenied): + break + except KeyboardInterrupt: + print("Interrupted by user. Terminating child process.") + process.terminate() + + process.wait() + return_code = process.returncode + total_runtime = time.time() - start_time + + print(f"Script finished in {total_runtime:.2f}s with return code {return_code}") + + with open(output_csv, "w", newline="", encoding="utf-8") as f: + writer = csv.writer(f) + writer.writerow(["time_s", "memory_MB"]) + writer.writerows(memory_data) + print(f"Memory usage saved to {output_csv}") + + return memory_data, return_code + finally: + if temp_script_path and os.path.exists(temp_script_path): + try: + os.remove(temp_script_path) + print(f"Temporary script {temp_script_path} removed.") + except OSError as e: + print( + f"Warning: failed to remove temp file {temp_script_path}: {e}", + file=sys.stderr, + ) + + +def plot_normalized_memory( + model_label: str, + csv_files: list[str], + labels: list[str], + plot_path: str, + colors: tuple[str, ...] = ("blue", "red", "green"), +) -> None: + """ + Plot memory usage vs normalized time. + + Parameters + ---------- + model_label : str + Label for the model shown in the plot title. + csv_files : list of str + Paths to CSV files with time and memory columns. + labels : list of str + Legend labels corresponding to each CSV file. + plot_path : str + Output path for the saved plot image. + colors : tuple of str, optional + Sequence of colors for the lines, by default ("blue", "red", "green"). + """ + plt.figure(figsize=(10, 6)) + color_cycle = itertools.cycle(colors) + for i, csv_file in enumerate(csv_files): + label = labels[i] if i < len(labels) else f"run_{i}" + if not os.path.exists(csv_file): + print(f"Warning: CSV file not found, skipping plot line: {csv_file}") + continue + df = pd.read_csv(csv_file) + if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: + print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") + continue + total_duration = df["time_s"].iloc[-1] - df["time_s"].iloc[0] + if total_duration > 0: + df["norm_time"] = (df["time_s"] - df["time_s"].iloc[0]) / total_duration + else: + n = max(1, len(df) - 1) + df["norm_time"] = (df.index - df.index[0]) / n + print( + f"Warning: zero duration in {csv_file}; using sample index for normalization." + ) + plt.plot( + df["norm_time"], + df["memory_MB"], + label=label, + color=next(color_cycle), + ) + plt.xlabel("Normalized time") + plt.ylabel("Memory usage [MB]") + plt.title(f"Memory usage comparison for model: {model_label}") + plt.xlim(0, 1) + plt.ylim(0, None) + plt.legend(loc="best") + plt.tight_layout() + plt.savefig(plot_path) + plt.close() + + +def plot_raw_time_memory( + model_label: str, + csv_files: list[str], + labels: list[str], + plot_path: str, + colors: tuple[str, ...] = ("blue", "red", "green"), +) -> None: + """ + Plot memory usage vs raw time. + + Parameters + ---------- + model_label : str + Label for the model shown in the plot title. + csv_files : list of str + Paths to CSV files with time and memory columns. + labels : list of str + Legend labels corresponding to each CSV file. + plot_path : str + Output path for the saved plot image. + colors : tuple of str, optional + Sequence of colors for the lines, by default ("blue", "red", "green"). + """ + plt.figure(figsize=(10, 6)) + color_cycle = itertools.cycle(colors) + for i, csv_file in enumerate(csv_files): + label = labels[i] if i < len(labels) else f"run_{i}" + if not os.path.exists(csv_file): + print(f"Warning: CSV file not found, skipping plot line: {csv_file}") + continue + df = pd.read_csv(csv_file) + if df.empty or "time_s" not in df.columns or "memory_MB" not in df.columns: + print(f"Warning: CSV invalid/empty, skipping plot line: {csv_file}") + continue + t0 = df["time_s"].iloc[0] if len(df) else 0.0 + df["time_shifted"] = df["time_s"] - t0 + plt.plot( + df["time_shifted"], + df["memory_MB"], + label=label, + color=next(color_cycle), + ) + plt.xlabel("Time [s]") + plt.ylabel("Memory usage [MB]") + plt.title(f"Memory usage (raw time) for model: {model_label}") + plt.xlim(0, None) + plt.ylim(0, None) + plt.legend(loc="best") + plt.tight_layout() + plt.savefig(plot_path) + plt.close() + + +def main() -> None: + """ + Run memory monitoring and plotting from the command line. + + Parses arguments, runs the monitoring pipeline for all requested + datasets and models and writes CSVs and plots under OUTPUT_ROOT. + """ + parser = argparse.ArgumentParser( + description="Monitor and plot memory usage of a test pipeline." + ) + parser.add_argument( + "--datasets", + type=str, + nargs="+", + required=True, + help=( + "Datasets to compare (e.g., graph/ds1 hypergraph/ds1). " + "Order is used for plotting and file naming." + ), + ) + parser.add_argument( + "--models", + type=str, + nargs="+", + required=True, + help="Models to run (e.g., graph/gcn).", + ) + parser.add_argument( + "--interval", + type=float, + default=0.05, + help="Sampling interval in seconds.", + ) + args = parser.parse_args() + + # Display-friendly dataset names and filesystem-safe names + dataset_disps = [dataset_short(d) for d in args.datasets] + dataset_fs = [model_fs(d) for d in args.datasets] + + os.makedirs(OUTPUT_ROOT, exist_ok=True) + + for model in args.models: + model_label = model + model_part = model_fs(model_label) + + cfg_folder = "__".join(dataset_fs + [model_part]) + config_dir = os.path.join(OUTPUT_ROOT, cfg_folder) + os.makedirs(config_dir, exist_ok=True) + + csv_outputs_for_model: list[str] = [] + return_codes: list[int] = [] + + for idx, _dataset_disp in enumerate(dataset_disps): + original_dataset_arg = args.datasets[idx] + output_csv = os.path.join( + config_dir, f"{model_part}__{dataset_fs[idx]}.csv" + ) + _, rc = monitor_script( + SCRIPT_FILE_PATH, + original_dataset_arg, + model_label, + output_csv, + interval=args.interval, + ) + csv_outputs_for_model.append(output_csv) + return_codes.append(rc) + + for i, rc in enumerate(return_codes): + if rc != 0: + print( + f"WARNING: Run for model '{model_label}' on dataset " + f"'{dataset_disps[i]}' exited with non-zero code {rc}.", + file=sys.stderr, + ) + + labels = dataset_disps[:] + norm_plot_path = os.path.join(config_dir, "memory_plot_normalized.png") + raw_plot_path = os.path.join(config_dir, "memory_plot_raw.png") + + plot_normalized_memory( + model_label, + csv_outputs_for_model, + labels=labels, + plot_path=norm_plot_path, + colors=("blue", "red", "green"), + ) + plot_raw_time_memory( + model_label, + csv_outputs_for_model, + labels=labels, + plot_path=raw_plot_path, + colors=("blue", "red", "green"), + ) + + +if __name__ == "__main__": + main() diff --git a/topobench/data/datasets/fake_on_disk_dataset.py b/topobench/data/datasets/fake_on_disk_dataset.py index cff7c7f70..5c0ec8f1d 100644 --- a/topobench/data/datasets/fake_on_disk_dataset.py +++ b/topobench/data/datasets/fake_on_disk_dataset.py @@ -10,12 +10,38 @@ # Helpers taken from their torch_gometric.FakeDataset, unchanged def get_num_nodes(avg_num_nodes: int, avg_degree: float) -> int: + """Generate a random number of nodes. + + Parameters + ---------- + avg_num_nodes : int + Target average number of nodes. + avg_degree : float + Target average node degree. + + Returns + ------- + int + Sampled number of nodes. + """ min_num_nodes = max(3 * avg_num_nodes // 4, int(avg_degree)) max_num_nodes = 5 * avg_num_nodes // 4 return random.randint(min_num_nodes, max_num_nodes) def get_num_channels(num_channels: int) -> int: + """Generate a random number of feature channels. + + Parameters + ---------- + num_channels : int + Target average number of channels. + + Returns + ------- + int + Sampled number of channels. + """ min_num_channels = 3 * num_channels // 4 max_num_channels = 5 * num_channels // 4 return random.randint(min_num_channels, max_num_channels) @@ -28,6 +54,26 @@ def get_edge_index( is_undirected: bool = False, remove_loops: bool = False, ) -> Tensor: + """Generate a random edge index tensor. + + Parameters + ---------- + num_src_nodes : int + Number of source nodes. + num_dst_nodes : int + Number of destination nodes. + avg_degree : float + Target average node degree. + is_undirected : bool, optional + If True, return an undirected graph. Default is False. + remove_loops : bool, optional + If True, remove self-loops. Default is False. + + Returns + ------- + torch.Tensor + Edge index tensor of shape (2, num_edges). + """ num_edges = int(num_src_nodes * avg_degree) row = torch.randint(num_src_nodes, (num_edges,), dtype=torch.int64) col = torch.randint(num_dst_nodes, (num_edges,), dtype=torch.int64) @@ -48,24 +94,61 @@ def get_edge_index( # FakeOnDiskDataset: API & generation logic taken from torch_geometric FakeDataset, # but persisted via OnDiskDataset. class FakeOnDiskDataset(OnDiskDataset): - r"""A fake dataset that returns randomly generated Data objects, + r"""A fake on-disk dataset of random graphs. + + Randomly generated :class:`~torch_geometric.data.Data` objects are persisted to disk via :class:`~torch_geometric.data.OnDiskDataset`. - Args: - root (str): Root directory where the processed DB will live. - num_graphs (int, optional): Number of graphs. (default: 1) - avg_num_nodes (int, optional): Average nodes per graph. (default: 1000) - avg_degree (float, optional): Average degree per node. (default: 10.0) - num_channels (int, optional): Node feature dimension. (default: 64) - edge_dim (int, optional): Edge feature dimension. (default: 0) - num_classes (int, optional): Number of classes. (default: 10) - task (str, optional): 'node', 'graph', or 'auto'. (default: 'auto') - is_undirected (bool, optional): Make edges undirected. (default: True) - transform (callable, optional): Applied on read. (default: None) - pre_transform (callable, optional): (unused, kept for parity) - backend (str, optional): 'sqlite' or 'rocksdb'. (default: 'sqlite') - force_reload (bool, optional): Rebuild DB even if present. (default: False) - **kwargs (optional): Extra attributes & shapes, e.g. global_features=5. + Parameters + ---------- + root : str + Root directory where the processed DB will live. + name : str + Dataset name used as a subdirectory. + num_graphs : int, optional + Number of graphs to generate. Default is 1. + avg_num_nodes : int, optional + Average number of nodes per graph. Default is 1000. + avg_degree : float, optional + Average degree per node. Default is 10.0. + num_channels : int, optional + Node feature dimension. Default is 64. + edge_dim : int, optional + Edge feature dimension. Default is 0. + num_classes : int, optional + Number of target classes. Default is 10. + task : {"node", "graph", "auto"}, optional + Prediction task type. If "auto", inferred from ``num_graphs``. + Default is "auto". + is_undirected : bool, optional + If True, edges are made undirected. Default is True. + transform : callable, optional + Transform applied on each graph at read time. Default is None. + pre_transform : callable, optional + Unused, kept for API parity. Default is None. + backend : {"sqlite", "rocksdb"}, optional + On-disk backend for storage. Default is "sqlite". + **kwargs + Extra attributes and shapes, e.g. ``global_features=5``. + + Attributes + ---------- + name : str + Dataset name. + num_graphs : int + Number of graphs. + avg_num_nodes : int + Average nodes per graph. + avg_degree : float + Average node degree. + num_channels : int + Node feature dimension. + edge_dim : int + Edge feature dimension. + task : {"node", "graph"} + Prediction task type. + is_undirected : bool + Whether edges are undirected. """ def __init__( @@ -122,11 +205,18 @@ def __init__( @property def raw_file_names(self) -> list[str]: + """Names of raw files in the dataset. + + Returns + ------- + list of str + List of raw file names (empty for this dataset). + """ return [] - + @property def raw_dir(self) -> str: - """Return the path to the raw directory of the dataset. + """Path to the raw directory. Returns ------- @@ -137,7 +227,7 @@ def raw_dir(self) -> str: @property def processed_dir(self) -> str: - """Return the path to the processed directory of the dataset. + """Path to the processed directory. Returns ------- @@ -146,15 +236,23 @@ def processed_dir(self) -> str: """ return osp.join(self.root, self.name, "processed") - def download(self) -> None: - pass + """Download raw data. + + Notes + ----- + This dataset is fully synthetic, so nothing is downloaded. + """ def process(self) -> None: - """Generate synthetic graphs and write them to disk in batches. + """Generate synthetic graphs and write them to disk. - This mirrors the batch-writing logic from pcqm4m: we never keep - all graphs in memory at once, only up to `batch_size` at a time. + Graphs are generated and written in batches to avoid storing + all graphs in memory at once. + + Returns + ------- + None """ batch_size = 1000 # same idea as pcqm4m @@ -171,8 +269,17 @@ def process(self) -> None: # free the batch from RAM data_list = [] + print("Finished.") + # Mirrors torch_geometric.FakeDataset.generate_data(): def generate_data(self) -> Data: + """Generate a single random graph. + + Returns + ------- + torch_geometric.data.Data + Generated graph with features and labels. + """ num_nodes = get_num_nodes(self.avg_num_nodes, self.avg_degree) data = Data() @@ -206,6 +313,18 @@ def generate_data(self) -> Data: # Map Data -> dict following the schema (always include num_nodes). def serialize(self, data: Data) -> dict[str, object]: + """Serialize a graph to a row dictionary. + + Parameters + ---------- + data : torch_geometric.data.Data + Graph data object to serialize. + + Returns + ------- + dict + Dictionary matching the on-disk schema. + """ row: dict[str, object] = { "edge_index": data.edge_index, "num_nodes": torch.tensor([data.num_nodes], dtype=torch.int64), @@ -218,6 +337,18 @@ def serialize(self, data: Data) -> dict[str, object]: # Map dict -> Data; only set optional fields if present/non-None. def deserialize(self, row: dict[str, object]) -> Data: + """Deserialize a row dictionary to a graph. + + Parameters + ---------- + row : dict + Dictionary produced by :meth:`serialize`. + + Returns + ------- + torch_geometric.data.Data + Reconstructed graph data object. + """ d = Data() d.edge_index = row["edge_index"] # type: ignore[assignment] # num_nodes is guaranteed present & typed diff --git a/topobench/data/loaders/graph/fake_dataset_loader.py b/topobench/data/loaders/graph/fake_dataset_loader.py index ca749df64..68ab6659a 100644 --- a/topobench/data/loaders/graph/fake_dataset_loader.py +++ b/topobench/data/loaders/graph/fake_dataset_loader.py @@ -13,19 +13,8 @@ class FakeDatasetLoader(AbstractLoader): Parameters ---------- parameters : DictConfig - Configuration parameters containing: - - data_dir: Root directory for data - - num_graphs: Number of graphs to generate - - avg_num_nodes: Average number of nodes per graph - - avg_degree: Average degree per node - - num_channels: Node feature dimension - - edge_dim: Edge feature dimension - - num_classes: Number of classes - - task: 'node' or 'graph' - - is_undirected: Whether the graph is undirected - - backend: 'sqlite' or 'rocksdb' + Configuration. """ - def __init__(self, parameters: DictConfig) -> None: super().__init__(parameters) diff --git a/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py b/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py index 11a129bb7..eb1f611d1 100644 --- a/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py +++ b/topobench/data/loaders/graph/fake_ondisk_dataset_loader.py @@ -13,17 +13,7 @@ class FakeOnDiskDatasetLoader(AbstractLoader): Parameters ---------- parameters : DictConfig - Configuration parameters containing: - - data_dir: Root directory for data - - num_graphs: Number of graphs to generate - - avg_num_nodes: Average number of nodes per graph - - avg_degree: Average degree per node - - num_channels: Node feature dimension - - edge_dim: Edge feature dimension - - num_classes: Number of classes - - task: 'node' or 'graph' - - is_undirected: Whether the graph is undirected - - backend: 'sqlite' or 'rocksdb' + Configuration. """ def __init__(self, parameters: DictConfig) -> None: diff --git a/topobench/data/preprocessor/on_disk_preprocessor.py b/topobench/data/preprocessor/on_disk_preprocessor.py index 760a6e9f1..8e506d583 100644 --- a/topobench/data/preprocessor/on_disk_preprocessor.py +++ b/topobench/data/preprocessor/on_disk_preprocessor.py @@ -1,4 +1,4 @@ -"""Preprocessor for datasets, backed by PyG OnDiskDataset.""" +"""Preprocessor for datasets using PyG OnDiskDataset.""" import json import os @@ -11,7 +11,6 @@ from topobench.data.utils import ( ensure_serializable, load_inductive_splits_on_disk, - # load_transductive_splits, make_hash, ) from topobench.dataloader import DataloadDataset @@ -19,11 +18,17 @@ class _LazyDataList(Sequence): + """Lazy sequence wrapper around an OnDiskDataset. + + Provides a list-like interface over data stored on disk, avoiding + loading the whole dataset into memory. + + Parameters + ---------- + dataset : OnDiskDataset + Underlying on-disk dataset accessed on demand. """ - Lazy list-like wrapper around an OnDiskDataset to preserve compatibility - with TopoBench split utilities that expect `dataset.data_list`. - Does NOT load the whole dataset into memory. - """ + def __init__(self, dataset): self._ds = dataset @@ -34,7 +39,7 @@ def __getitem__(self, idx): if isinstance(idx, slice): start, stop, step = idx.indices(len(self)) return [self._ds[i] for i in range(start, stop, step)] - return self._ds[idx] # fetches on demand from disk + return self._ds[idx] def __iter__(self): for i in range(len(self)): @@ -42,6 +47,24 @@ def __iter__(self): class OnDiskPreProcessor(torch_geometric.data.OnDiskDataset): + """Preprocess datasets and persist results using OnDiskDataset. + + Applies heavy (offline) transforms once and stores processed samples + on disk. Lightweight (online) transforms are composed and applied at + access time through ``self.transform``. + + Parameters + ---------- + dataset : Dataset + Source dataset yielding PyG ``BaseData`` objects. + data_dir : str + Directory where processed data versions are stored. + transforms_config : dict, optional + Hydra-style configuration for heavy and easy transforms. + **kwargs + Additional arguments forwarded to ``OnDiskDataset``. + """ + def __init__( self, dataset, @@ -71,33 +94,29 @@ def __init__( self.heavy_transforms = self._compose_from_dict(heavy_transform_dict) self.transforms_parameters = ensure_serializable( - { - name: transform.parameters - for name, transform in heavy_transform_dict.items() - } + {name: transform.parameters for name, transform in heavy_transform_dict.items()} ) params_hash = make_hash(self.transforms_parameters) repo_name = "_".join(list(self.heavy_transforms_config.keys())) if repo_name: - root_for_this_version = os.path.join( - data_dir, repo_name, f"{params_hash}" - ) + root_for_this_version = os.path.join(data_dir, repo_name, f"{params_hash}") else: root_for_this_version = os.path.join(data_dir, f"{params_hash}") + super().__init__( - root=root_for_this_version, - transform=None, # Online transforms are set manually later - pre_filter=None, - **kwargs, + root=root_for_this_version, + transform=None, + pre_filter=None, + **kwargs, ) else: root_for_this_version = data_dir super().__init__( - root=root_for_this_version, - transform=None, # Online transforms are set manually later - pre_filter=None, - **kwargs, + root=root_for_this_version, + transform=None, + pre_filter=None, + **kwargs, ) # Attach dataset to OnDiskPreProcessor class if len(self) == 0: @@ -105,23 +124,21 @@ def __init__( self.append(sample) # Prepare online transforms and save metadata. - # The `self.transform` attribute is used by PyG during data loading. self.transform = self._prepare_online_transforms() if self.transforms_applied: self.save_transform_parameters() - # Preserve split_idx if the original dataset had fixed splits. if hasattr(dataset, "split_idx"): self.split_idx = dataset.split_idx @property def processed_dir(self) -> str: - """Return the path to the processed directory. + """Return directory containing processed samples. Returns ------- str - Path to the processed directory. + Path to processed directory. """ if self.transforms_applied: return self.root @@ -130,44 +147,54 @@ def processed_dir(self) -> str: @property def data_list(self): - """ - Compatibility with original PreProcessor. - Returns a sequence-like object, but keeps data on disk. + """Return a lazy list-like interface to on-disk samples. + + Returns + ------- + _LazyDataList + Sequence-like wrapper over stored data. """ if not hasattr(self, "_lazy_data_list"): self._lazy_data_list = _LazyDataList(self) return self._lazy_data_list def process(self) -> None: - """ - Called (once per cache dir) by Dataset._process() if the DB does not - already exist. We iterate over `self.dataset`, apply heavy transforms, - optionally apply `pre_filter`, and append each sample to the on-disk DB. + """Apply heavy transforms and store processed samples. + + Iterates over the source dataset, applies heavy transforms if + defined, applies optional ``pre_filter``, and appends results to + the on-disk database. + + Raises + ------ + TypeError + If a sample is not a ``BaseData`` instance. """ for sample in self.dataset: if not isinstance(sample, BaseData): raise TypeError( - f"Source dataset must yield PyG BaseData objects, " - f"but got {type(sample)}" + f"Source dataset must yield PyG BaseData objects, but got {type(sample)}" ) if self.heavy_transforms is not None: sample = self.heavy_transforms(sample) - # Respect PyG-style pre_filter semantics if provided: if getattr(self, "pre_filter", None) is not None and not self.pre_filter(sample): continue - # Insert into the underlying DB (self.db): self.append(sample) def save_transform_parameters(self) -> None: + """Save or validate heavy transform parameters on disk. + + Ensures reproducibility by writing parameters to a JSON file. + If an existing file contains mismatched parameters, an error is raised. + + Raises + ------ + ValueError + If stored parameters differ from current parameters. """ - Save (or verify) the parameters of the heavy/offline transforms. - Raises if an existing cache directory corresponds to a different set - of transform parameters. - """ - # self.processed_dir now correctly points to the hashed directory os.makedirs(self.processed_dir, exist_ok=True) path_transform_parameters = os.path.join( @@ -182,60 +209,57 @@ def save_transform_parameters(self) -> None: saved_transform_parameters = json.load(f) if saved_transform_parameters != self.transforms_parameters: - raise ValueError( - "Different transform parameters for the same data_dir" - ) + raise ValueError("Different transform parameters for the same data_dir") print( - "Transform parameters are the same, " - f"using existing data_dir: {self.processed_dir}" + "Transform parameters are the same, using existing data_dir: " + f"{self.processed_dir}" ) def _prepare_online_transforms(self) -> Callable | None: - """ - Compose lightweight/easy transforms (feature tweaks, etc.) with the - dataset's intrinsic transform, and return a callable. - This becomes `self.transform`, which PyG applies at access time. + """Compose online (easy) transforms with dataset-level transforms. + + Returns + ------- + callable or None + One transform, composed transforms, or None if no online + transforms exist. """ transforms_list: Sequence[Callable] = [] - # 1. Dataset's intrinsic transform, if present: if hasattr(self.dataset, "transform") and self.dataset.transform is not None: transforms_list.append(self.dataset.transform) - # 2. Easy transforms from config: - easy_transform_dict, _ = self._build_transform_dict( - self.easy_transforms_config - ) + easy_transform_dict, _ = self._build_transform_dict(self.easy_transforms_config) easy_compose = self._compose_from_dict(easy_transform_dict) if easy_compose is not None: transforms_list.append(easy_compose) - # Return None / single transform / composed pipeline: if not transforms_list: return None if len(transforms_list) == 1: return transforms_list[0] return torch_geometric.transforms.Compose(list(transforms_list)) - # Transform config utilities def _split_transforms( self, transforms_config: dict[str, Any] ) -> tuple[dict[str, Any], dict[str, Any]]: - """ - Split a Hydra-style transforms config into: - heavy_config = {name: cfg} for lifting / feature_lifting - easy_config = {name: cfg} for the rest + """Split transform config into heavy and easy components. + + Parameters + ---------- + transforms_config : dict + Raw transform configuration. - We support: - - dict-of-dicts - - or a single dict with keys like "transform_name", "transform_type". + Returns + ------- + tuple of dict + ``(heavy_config, easy_config)``. """ heavy_config: dict[str, Any] = {} easy_config: dict[str, Any] = {} heavy_types = {"lifting", "feature_lifting"} - # Normalize to {name: cfg} form: if "transform_name" in transforms_config: cfg_items = {"single": transforms_config} else: @@ -253,11 +277,17 @@ def _split_transforms( def _build_transform_dict( self, subset_cfg: dict[str, Any] ) -> tuple[dict[str, DataTransform], dict[str, Any]]: - """ - Instantiate DataTransform objects from a subset config. - Returns both: - transform_dict: {name: DataTransform(...)} - params_dict: {name: parameters} # for hashing/metadata + """Build transform instances from config. + + Parameters + ---------- + subset_cfg : dict + Mapping from transform names to configs. + + Returns + ------- + tuple of dict + ``(transform_dict, params_dict)``. """ transform_dict: dict[str, DataTransform] = {} params_dict: dict[str, Any] = {} @@ -273,35 +303,50 @@ def _build_transform_dict( def _compose_from_dict( transform_dict: dict[str, Callable] ) -> Callable | None: - """ - Turn {name: transform} into: - None (if empty), - that single transform (if only one), - or a torch_geometric.transforms.Compose([...]) (if multiple). + """Compose transforms stored in a mapping. + + Parameters + ---------- + transform_dict : dict + Mapping from names to transform callables. + + Returns + ------- + callable or None + Composed transform or single transform. """ if len(transform_dict) == 0: return None if len(transform_dict) == 1: return list(transform_dict.values())[0] - return torch_geometric.transforms.Compose( - list(transform_dict.values()) - ) + return torch_geometric.transforms.Compose(list(transform_dict.values())) - # Split loading def load_dataset_splits( self, split_params: dict[str, Any] - ) -> tuple[ - DataloadDataset, DataloadDataset | None, DataloadDataset | None - ]: - """ - Load or generate train/val/test splits using project utilities. + ) -> tuple[DataloadDataset, DataloadDataset | None, DataloadDataset | None]: + """Load or generate dataset splits. + + Supports inductive learning settings backed by on-disk splits. + + Parameters + ---------- + split_params : dict + Dictionary containing at least ``learning_setting``. + + Returns + ------- + tuple + ``(train, val, test)`` datasets. + + Raises + ------ + ValueError + If learning setting is missing or invalid. """ if not split_params.get("learning_setting", False): raise ValueError("No learning setting specified in split_params") if split_params.learning_setting == "inductive": return load_inductive_splits_on_disk(self, split_params) - # elif split_params.learning_setting == "transductive": - # return load_transductive_splits(self, split_params) else: raise ValueError( f"Invalid '{split_params.learning_setting}' learning setting. " diff --git a/topobench/data/utils/split_utils.py b/topobench/data/utils/split_utils.py index 919f42031..fa413bb3a 100644 --- a/topobench/data/utils/split_utils.py +++ b/topobench/data/utils/split_utils.py @@ -388,14 +388,19 @@ def load_coauthorship_hypergraph_splits(data, parameters, train_prop=0.5): # List-like view over a subset of an on-disk dataset class _LazySplitList(Sequence): - """ - A lightweight, list-like view over a subset of an on-disk dataset. + """Lazy list-like view over a split of an on-disk dataset. + + Provides indexed and sliced access to a subset of graphs, loading + each graph from disk on demand and attaching split masks. - - Holds only the indices for this split (train/valid/test). - - On access (self[i]), loads that ONE graph from disk. - - Injects the appropriate split masks into the returned Data object. - - Supports __len__ so DataloadDataset.len() works. - - Supports integer indexing so DataloadDataset.get() works. + Parameters + ---------- + base_dataset : + Underlying on-disk dataset. + indices : sequence of int + Indices belonging to this split. + split_name : {"train", "valid", "test"} + Name of the split. """ def __init__(self, base_dataset, indices, split_name: str): @@ -424,8 +429,17 @@ def __len__(self): return len(self._idx) def _load_one(self, real_idx: int): - """ - Load a single graph from disk, attach masks, return it as a Data object. + """Load a single graph from disk and attach split masks. + + Parameters + ---------- + real_idx : int + Index into the underlying base dataset. + + Returns + ------- + Data + Graph with ``train_mask``, ``val_mask`` and ``test_mask`` set. """ data = self.base_dataset[real_idx] # OnDiskDataset __getitem__ -> loads from disk @@ -437,12 +451,20 @@ def _load_one(self, real_idx: int): return data def __getitem__(self, pos): - """ - DataloadDataset.get(idx) will call self.data_lst[idx] with idx an int. - So we MUST support integer indexing and return a single Data object. + """Return one or more graphs for the given position. + + Supports integer indexing (training use case) and slicing + (for debugging). + + Parameters + ---------- + pos : int or slice + Position within the split. - We'll also add best-effort slice support for debugging, but that isn't - hit in the training loop. + Returns + ------- + Data or list of Data + Single graph for integer index, or list of graphs for a slice. """ if isinstance(pos, slice): start, stop, step = pos.indices(len(self._idx)) @@ -458,13 +480,23 @@ def __getitem__(self, pos): return self._load_one(real_idx) def assign_train_val_test_mask_to_graphs_on_disk(dataset, split_idx): - """ - Build train/val/test datasets WITHOUT materializing the entire split in RAM. + """Create lazy train/val/test datasets without loading all graphs. - It gives DataloadDataset a lazy, list-like object (_LazySplitList) - that loads each graph from disk on demand. - """ + Builds :class:`DataloadDataset` objects backed by :class:`_LazySplitList`, + which load graphs and attach split masks on demand. + Parameters + ---------- + dataset : + On-disk dataset providing graph objects. + split_idx : dict + Mapping with keys ``"train"``, ``"valid"``, ``"test"`` to index lists. + + Returns + ------- + tuple of DataloadDataset + ``(train_dataset, val_dataset, test_dataset)``. + """ train_list = _LazySplitList( base_dataset=dataset, indices=split_idx["train"], @@ -490,19 +522,23 @@ def assign_train_val_test_mask_to_graphs_on_disk(dataset, split_idx): return train_dataset, val_dataset, test_dataset def load_inductive_splits_on_disk(dataset, parameters): - r"""Load multiple-graph datasets with the specified split. + """Load inductive train/val/test splits for multi-graph datasets. + + Splits graphs into train, validation and test sets according to the + requested split type (random, k-fold or fixed), handling ragged labels + if needed. Parameters ---------- dataset : torch_geometric.data.Dataset - Graph dataset. + Graph dataset in an inductive setting. parameters : DictConfig - Configuration parameters. + Split configuration, including ``split_type`` and related options. Returns ------- - list: - List containing the train, validation, and test splits. + tuple of DataloadDataset + ``(train_dataset, val_dataset, test_dataset)``. """ # Extract labels from dataset object assert len(dataset) > 1, ( diff --git a/tutorials/tutorial_on_disk_inductive_pipeline.ipynb b/tutorials/tutorial_on_disk_inductive_pipeline.ipynb index ffb0cc7bd..27d2380b1 100644 --- a/tutorials/tutorial_on_disk_inductive_pipeline.ipynb +++ b/tutorials/tutorial_on_disk_inductive_pipeline.ipynb @@ -244,11 +244,7 @@ "cell_type": "code", "execution_count": 1, "id": "bf50b3a1-42f8-436e-b521-c47fc39f306b", - "metadata": { - "jupyter": { - "source_hidden": true - } - }, + "metadata": {}, "outputs": [], "source": [ "# Imports and Utils are handled here.\n", @@ -258,7 +254,7 @@ "from IPython.display import Image\n", "import os, sys\n", "\n", - "sys.path.insert(0, str(Path.cwd().parents[0] / 'test' / 'memory_usage_tracking'))\n", + "sys.path.insert(0, str(Path.cwd().parents[0] / 'tools' / 'memory_usage_tracking'))\n", "import memory_plotting as mp\n", "\n", "@contextmanager\n", From 43997c331fdae50d2f1ef06aae79595b3537fb0b Mon Sep 17 00:00:00 2001 From: David Leko Date: Wed, 19 Nov 2025 19:54:10 +0100 Subject: [PATCH 05/11] Fixed memory_plotting output path. --- .../graph__gcn__graph__fake.csv | 101 ----------------- .../graph__gcn__graph__fake_inmem.csv | 102 ----------------- .../memory_plot_normalized.png | Bin 38581 -> 0 bytes .../memory_plot_raw.png | Bin 36419 -> 0 bytes .../graph__gcn__graph__fake.csv | 107 ------------------ .../graph__gcn__graph__fake_on_disk.csv | 49 -------- .../memory_plot_normalized.png | Bin 39984 -> 0 bytes .../memory_plot_raw.png | Bin 35271 -> 0 bytes .../memory_usage_tracking/memory_plotting.py | 2 +- 9 files changed, 1 insertion(+), 360 deletions(-) delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png delete mode 100644 test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv deleted file mode 100644 index 841249d72..000000000 --- a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake.csv +++ /dev/null @@ -1,101 +0,0 @@ -time_s,memory_MB -1.6927719116210938e-05,0.140625 -0.05505681037902832,26.9375 -0.11008405685424805,40.171875 -0.16512393951416016,74.109375 -0.22957587242126465,120.515625 -0.28199291229248047,139.796875 -0.3370029926300049,154.0 -0.3920760154724121,163.15625 -0.44712281227111816,169.53125 -0.5021579265594482,176.671875 -0.5571870803833008,188.59375 -0.6122150421142578,200.140625 -0.6672439575195312,207.171875 -0.7222766876220703,217.328125 -0.7773089408874512,236.71875 -0.8323378562927246,249.171875 -0.8873658180236816,256.53125 -0.942396879196167,262.34375 -0.9974479675292969,273.46875 -1.0524818897247314,283.046875 -1.107517957687378,293.953125 -1.1625499725341797,309.671875 -1.2175769805908203,315.140625 -1.2726068496704102,328.84375 -1.3276360034942627,335.296875 -1.3826639652252197,344.5 -1.4376850128173828,356.171875 -1.4927117824554443,372.28125 -1.547738790512085,393.25 -1.6027848720550537,403.234375 -1.657824993133545,411.375 -1.7128548622131348,424.375 -1.7678849697113037,435.390625 -1.822916030883789,441.234375 -1.8779399394989014,451.453125 -1.9329628944396973,457.375 -1.9879889488220215,465.859375 -2.043017864227295,469.46875 -2.098038911819458,470.921875 -2.152184009552002,473.96875 -2.2045140266418457,483.171875 -2.259547710418701,494.359375 -2.3145759105682373,499.96875 -2.3653957843780518,505.125 -2.4204318523406982,553.59375 -2.4754600524902344,553.671875 -2.530489683151245,566.828125 -2.585533857345581,566.828125 -2.640575885772705,579.6875 -2.6956098079681396,580.734375 -2.750638008117676,581.625 -2.8056697845458984,585.25 -2.860700845718384,586.03125 -2.9157328605651855,586.84375 -2.970773935317993,586.84375 -3.0258097648620605,611.984375 -3.0808377265930176,611.984375 -3.135877847671509,612.03125 -3.1909077167510986,612.03125 -3.2459356784820557,612.0625 -3.3009610176086426,612.0625 -3.3559937477111816,612.0625 -3.4110209941864014,612.84375 -3.4660511016845703,613.625 -3.5210838317871094,613.671875 -3.57613205909729,613.671875 -3.631154775619507,626.453125 -3.6861817836761475,633.84375 -3.741210699081421,633.84375 -3.7962398529052734,634.625 -3.851271867752075,634.625 -3.9063048362731934,661.171875 -3.9613330364227295,661.171875 -4.016355037689209,661.171875 -4.071379899978638,661.171875 -4.126403093338013,662.734375 -4.18143367767334,662.734375 -4.236473083496094,662.734375 -4.291501045227051,662.734375 -4.346532821655273,662.734375 -4.401551723480225,662.734375 -4.456584930419922,662.734375 -4.511609792709351,662.734375 -4.566629886627197,662.734375 -4.621665000915527,662.734375 -4.676706075668335,662.734375 -4.731735944747925,662.734375 -4.786756753921509,662.734375 -4.841794013977051,662.734375 -4.896823883056641,675.328125 -4.95185399055481,675.40625 -5.006899833679199,675.6875 -5.061941862106323,675.6875 -5.116989850997925,675.6875 -5.172023057937622,675.6875 -5.227057933807373,676.0 -5.2820868492126465,676.0 -5.337118864059448,676.015625 -5.3921449184417725,676.125 -5.447188854217529,692.03125 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv deleted file mode 100644 index 6fffcfdd1..000000000 --- a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/graph__gcn__graph__fake_inmem.csv +++ /dev/null @@ -1,102 +0,0 @@ -time_s,memory_MB -1.7881393432617188e-05,0.53125 -0.05505776405334473,25.28125 -0.11008381843566895,39.921875 -0.16510987281799316,72.75 -0.22012972831726074,115.28125 -0.2751758098602295,137.859375 -0.3314208984375,150.984375 -0.38599276542663574,163.0 -0.44470977783203125,167.828125 -0.49636387825012207,176.84375 -0.551386833190918,187.453125 -0.6064157485961914,197.71875 -0.6614446640014648,206.140625 -0.7164757251739502,215.546875 -0.7715058326721191,234.84375 -0.8265378475189209,247.296875 -0.8815667629241943,256.75 -0.9365897178649902,261.875 -0.9916186332702637,273.578125 -1.046651840209961,281.046875 -1.1016829013824463,291.109375 -1.1567139625549316,305.984375 -1.2117397785186768,313.875 -1.2667639255523682,327.125 -1.3217897415161133,334.390625 -1.3768136501312256,344.1875 -1.4318428039550781,355.9375 -1.4868748188018799,370.578125 -1.5419089794158936,392.734375 -1.5969526767730713,403.921875 -1.651977777481079,412.734375 -1.7070088386535645,424.859375 -1.762035846710205,437.890625 -1.817063808441162,441.9375 -1.872093915939331,450.53125 -1.9271166324615479,458.453125 -1.9821429252624512,467.9375 -2.037170886993408,470.609375 -2.0921988487243652,472.0 -2.145357608795166,474.96875 -2.2003777027130127,484.3125 -2.2522459030151367,496.59375 -2.3072707653045654,510.859375 -2.362304925918579,587.75 -2.417332887649536,625.703125 -2.4723587036132812,668.21875 -2.527395725250244,670.96875 -2.582418918609619,671.171875 -2.6374526023864746,699.34375 -2.69248366355896,699.359375 -2.747513771057129,732.71875 -2.8025548458099365,732.71875 -2.85758376121521,736.359375 -2.9126198291778564,743.234375 -2.9676506519317627,743.265625 -3.0226778984069824,743.390625 -3.0777106285095215,743.390625 -3.1327459812164307,744.234375 -3.187772750854492,744.28125 -3.242811679840088,744.28125 -3.2978458404541016,751.28125 -3.3528738021850586,751.28125 -3.407902956008911,776.140625 -3.4629247188568115,776.140625 -3.5179507732391357,776.15625 -3.572990894317627,776.15625 -3.6280157566070557,776.984375 -3.683041572570801,789.109375 -3.738067865371704,789.6875 -3.793095827102661,821.71875 -3.8481197357177734,821.71875 -3.9031527042388916,821.71875 -3.9581775665283203,821.71875 -4.013209819793701,821.71875 -4.068231821060181,821.75 -4.123273849487305,821.75 -4.17830491065979,821.75 -4.233339786529541,821.75 -4.288366794586182,821.75 -4.343406677246094,821.75 -4.3984386920928955,821.75 -4.453459978103638,821.75 -4.508484840393066,821.75 -4.56351375579834,821.75 -4.618542671203613,821.75 -4.6735680103302,824.21875 -4.728593826293945,824.21875 -4.783620834350586,824.21875 -4.8386476039886475,824.21875 -4.893677711486816,824.21875 -4.948705673217773,836.203125 -5.00373387336731,836.34375 -5.0587708950042725,836.34375 -5.113834857940674,813.03125 -5.1688759326934814,813.03125 -5.223917722702026,813.03125 -5.2789528369903564,813.046875 -5.333986759185791,813.046875 -5.389018774032593,813.0625 -5.444069862365723,813.15625 -5.499108791351318,831.234375 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_normalized.png deleted file mode 100644 index f310a8c405ab0962d108aca71f128dd2e0df1978..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 38581 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�Ad?K{c!1#Nt*@k&> z>oKu@5*Qfv0n{lF8BRJzQ83^~JGUjtPI(B1 zPJTZ6P46}=;H7ZmMTIlap?wz2J66DWGl*^SR~`kd}scA)`5x?`{V#^w=4_z5Fw1`U;7*q1g5v}5a_96`) zkU=690c0~da)qTlF$~#s03bN@5JXxkFlTrHZ+&Y+~Y zD4?X&0{ZDGMnxdUk!8SV#w zTCi@`|L>>u{`~=j!p{XAc98br`dD?aDxx+94*6qbGVO~7=NG#d*7smXYOSQ#O@{^f zH_7t)X(j-nV7{h9d#A#uOF)|@AetdgI$zE5H87H^6qN(mfqKakdh3RvEh};p2a^oE9p!=!a7F^;>1 zj~*3H5xcwBrdBgQ`1<)BIZ02SeDYX+etuF(2`N1*i>xnp|NblYQeVYJOEj8KQ&V%T zRNqZlSUB2)6}qbk0NC%QX<(43tfZ6>&BM)|j=`{P3i0qEW^tSMIIimnyPDR>fBmR&&U|F*D6!j(rRBC z8cKAJE-x?V_awHrC+G=DoPv?5)sh=|KjZ7;o&@n6DOW8E-wD= z6BQO#2YK)k-lfh}FVJ;)d6{T&#?iar<{eY;l~q|B z!cNc5&(GJe%&-(qPfcZh@b}*eAyY#0r-VZIulOfJZ5^FVaZ*oyUf$<7Z}xGZS+@B( zQ)ehCDVgZ*t#eA5g*{dE?qE27-q;1#vz$9MJ7elN)OAAQ+=fKLCs%Fluh%#@2u7o1GEeWtvCTPEdw5tZ92~M~ ztuUA)V3p1yff-ZunjBl@=E_bL1l2F0w%gghoZ{c+WQF>-C!I&OBIJ+i-$wTT-&Z!= aw<(3FC6E0q4%tB%rNkdU$h`OT<^Khu0zQiX diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_inmem__graph__gcn/memory_plot_raw.png deleted file mode 100644 index 31ba870bdf9206bbf9071e146dff3c5afaab64e3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 36419 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 F{6F_|ut@*_ diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv deleted file mode 100644 index 4db6bc6b2..000000000 --- a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake.csv +++ /dev/null @@ -1,107 +0,0 @@ -time_s,memory_MB -1.430511474609375e-05,0.109375 -0.0550532341003418,27.1875 -0.11008524894714355,39.75 -0.16513514518737793,67.375 -0.220170259475708,97.953125 -0.27762627601623535,129.359375 -0.3335573673248291,151.28125 -0.3857383728027344,162.234375 -0.44231510162353516,167.421875 -0.49688029289245605,174.234375 -0.5482051372528076,182.53125 -0.6032323837280273,192.90625 -0.6582651138305664,202.40625 -0.7132983207702637,208.546875 -0.7683303356170654,217.609375 -0.8233752250671387,237.328125 -0.8784072399139404,250.265625 -0.9334421157836914,256.234375 -0.9884722232818604,263.890625 -1.0434973239898682,273.953125 -1.0985190868377686,284.84375 -1.153550148010254,297.78125 -1.2085802555084229,309.828125 -1.263606071472168,318.5 -1.3186311721801758,333.59375 -1.3736591339111328,338.1875 -1.4286892414093018,346.265625 -1.4837172031402588,358.609375 -1.538736343383789,376.5 -1.593766212463379,393.09375 -1.6488213539123535,403.875 -1.703857183456421,414.703125 -1.758885145187378,428.15625 -1.8139193058013916,436.953125 -1.8689494132995605,446.203125 -1.923976182937622,454.765625 -1.9790053367614746,460.34375 -2.0340280532836914,465.703125 -2.0890543460845947,470.5625 -2.144127368927002,472.03125 -2.199007272720337,475.578125 -2.2505431175231934,484.75 -2.3055691719055176,495.90625 -2.3605942726135254,501.484375 -2.415626287460327,501.796875 -2.4706413745880127,501.953125 -2.5256550312042236,502.015625 -2.58066725730896,502.0625 -2.6356892585754395,503.265625 -2.6907193660736084,508.484375 -2.745751142501831,553.09375 -2.80078125,554.03125 -2.8558123111724854,590.703125 -2.910842180252075,593.484375 -2.965888023376465,596.6875 -3.020925283432007,608.578125 -3.075955390930176,608.59375 -3.1309890747070312,610.078125 -3.18605899810791,610.859375 -3.2410943508148193,610.890625 -3.2961223125457764,610.890625 -3.351144313812256,640.921875 -3.406165361404419,641.03125 -3.4612081050872803,641.03125 -3.516230344772339,667.765625 -3.571263313293457,667.78125 -3.626293420791626,667.8125 -3.681319236755371,667.8125 -3.736347198486328,669.390625 -3.7913851737976074,669.390625 -3.8464083671569824,669.40625 -3.901430130004883,669.40625 -3.9564521312713623,689.15625 -4.011484384536743,689.21875 -4.0665123462677,689.21875 -4.121539115905762,689.328125 -4.176562309265137,689.328125 -4.231597185134888,689.328125 -4.286616086959839,689.328125 -4.341645240783691,689.328125 -4.396670341491699,689.328125 -4.451701402664185,689.328125 -4.506721019744873,689.328125 -4.56174635887146,689.328125 -4.616775274276733,689.359375 -4.671799182891846,689.359375 -4.726828098297119,689.40625 -4.781855344772339,689.40625 -4.836894273757935,689.40625 -4.891922235488892,689.40625 -4.946948289871216,689.40625 -5.001979351043701,689.40625 -5.057012319564819,689.40625 -5.109022378921509,689.40625 -5.164051294326782,689.40625 -5.219078302383423,695.859375 -5.274112224578857,695.890625 -5.329160213470459,696.1875 -5.384206295013428,696.1875 -5.43925142288208,696.1875 -5.49428915977478,696.1875 -5.549321413040161,696.5 -5.6043572425842285,696.5 -5.6593921184539795,696.515625 -5.714420318603516,696.59375 -5.769449234008789,713.609375 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv deleted file mode 100644 index 6b684bb29..000000000 --- a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/graph__gcn__graph__fake_on_disk.csv +++ /dev/null @@ -1,49 +0,0 @@ -time_s,memory_MB -1.71661376953125e-05,0.546875 -0.05505013465881348,25.34375 -0.11007404327392578,40.09375 -0.1650989055633545,73.34375 -0.2201220989227295,115.8125 -0.27518415451049805,134.515625 -0.33127427101135254,151.421875 -0.38585901260375977,162.6875 -0.4391789436340332,168.421875 -0.4942340850830078,176.40625 -0.547835111618042,188.28125 -0.6028590202331543,198.171875 -0.6578850746154785,206.046875 -0.7129120826721191,215.75 -0.7679412364959717,235.15625 -0.8229711055755615,248.65625 -0.8779990673065186,257.15625 -0.9330201148986816,262.53125 -0.988051176071167,274.203125 -1.043081283569336,282.140625 -1.09810209274292,292.46875 -1.153135061264038,306.4375 -1.2081630229949951,314.84375 -1.2631900310516357,327.125 -1.3182141780853271,335.0625 -1.3732399940490723,344.921875 -1.4282679557800293,356.09375 -1.483290195465088,370.9375 -1.5383169651031494,391.21875 -1.5933659076690674,404.640625 -1.6483943462371826,412.328125 -1.7034211158752441,426.734375 -1.758451223373413,438.015625 -1.8134791851043701,444.890625 -1.8685071468353271,450.390625 -1.9235281944274902,459.796875 -1.9785640239715576,465.171875 -2.0335941314697266,471.140625 -2.088621139526367,472.203125 -2.1436421871185303,477.09375 -2.1986911296844482,477.140625 -2.2537381649017334,477.140625 -2.308777332305908,477.140625 -2.363819122314453,477.1875 -2.4188551902770996,477.1875 -2.4738852977752686,477.203125 -2.528918981552124,477.203125 -2.5839731693267822,478.078125 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_normalized.png deleted file mode 100644 index 7f437374e04875ace60e195b5e321c00c1b2f135..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 39984 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 diff --git a/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png b/test/memory_usage_tracking/outputs/graph__fake__graph__fake_on_disk__graph__gcn/memory_plot_raw.png deleted file mode 100644 index 10cc4a63881b48b0007fadfb40b988e8bce8d2eb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35271 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 str: From 6d50b4df6c0d459364dab8ad40f58f51af120c30 Mon Sep 17 00:00:00 2001 From: David Leko Date: Wed, 19 Nov 2025 21:53:14 +0100 Subject: [PATCH 06/11] Improved plotting utilities. --- .../cell__topotune__fake.csv | 302 +++++++ .../cell__topotune__fake_inmem.csv | 784 ++++++++++++++++++ .../memory_plot_normalized.png | Bin 0 -> 39804 bytes .../graph__gcn__fake.csv | 72 ++ .../graph__gcn__fake_inmem.csv | 75 ++ .../memory_plot_normalized.png | Bin 0 -> 42639 bytes .../memory_plot_normalized.png | Bin 0 -> 47281 bytes .../simplicial__topotune__fake.csv | 192 +++++ .../simplicial__topotune__fake_inmem.csv | 672 +++++++++++++++ .../memory_usage_tracking/memory_plotting.py | 7 +- 10 files changed, 2102 insertions(+), 2 deletions(-) create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv create mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv new file mode 100644 index 000000000..5d4809c8a --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv @@ -0,0 +1,302 @@ +time_s,memory_MB +2.3126602172851562e-05,0.515625 +0.05225086212158203,19.828125 +0.11227607727050781,29.921875 +0.1723017692565918,39.1875 +0.23233699798583984,64.28125 +0.2923750877380371,101.609375 +0.352916955947876,133.890625 +0.4147357940673828,150.546875 +0.47348690032958984,159.703125 +0.5335917472839355,166.84375 +0.5936238765716553,175.75 +0.6441988945007324,184.875 +0.704226016998291,194.203125 +0.7642650604248047,200.21875 +0.8243017196655273,210.890625 +0.8843300342559814,217.8125 +0.9443600177764893,233.921875 +1.0043840408325195,241.59375 +1.0644118785858154,249.546875 +1.124445915222168,253.4375 +1.1748559474945068,258.203125 +1.2348768711090088,268.09375 +1.2948999404907227,273.25 +1.354928970336914,279.125 +1.4068570137023926,283.34375 +1.4668827056884766,291.140625 +1.5269129276275635,301.875 +1.5775220394134521,309.6875 +1.6375470161437988,318.03125 +1.6975948810577393,328.21875 +1.7576169967651367,334.953125 +1.8176357746124268,340.953125 +1.8776569366455078,347.9375 +1.9376778602600098,355.1875 +1.9977028369903564,364.203125 +2.057724952697754,384.625 +2.117748975753784,393.703125 +2.177772045135498,400.21875 +2.23779296875,410.859375 +2.2978179454803467,419.515625 +2.3578379154205322,427.921875 +2.417860746383667,435.015625 +2.477886915206909,442.53125 +2.5379059314727783,451.953125 +2.5979268550872803,459.703125 +2.657946825027466,461.5625 +2.717967987060547,466.265625 +2.7779898643493652,467.59375 +2.8380119800567627,468.59375 +2.8969359397888184,478.765625 +2.9481749534606934,490.421875 +2.998363971710205,500.203125 +3.0583889484405518,508.421875 +3.118412971496582,509.6875 +3.178435802459717,509.8125 +3.2384679317474365,513.421875 +3.2985050678253174,518.234375 +3.350855827331543,710.375 +3.410885810852051,907.890625 +3.4709110260009766,1023.046875 +3.530937910079956,1087.03125 +3.590970993041992,1099.859375 +3.650998115539551,1099.859375 +3.7110259532928467,1106.09375 +3.7710509300231934,1106.09375 +3.8310790061950684,1031.046875 +3.8911149501800537,1090.203125 +3.951140880584717,1132.3125 +4.011164903640747,1132.40625 +4.071190118789673,1154.203125 +4.131218910217285,1154.21875 +4.191245079040527,1154.21875 +4.25127387046814,1154.234375 +4.311298131942749,1154.25 +4.371322870254517,1154.421875 +4.431348085403442,1154.46875 +4.491372108459473,1154.46875 +4.551404714584351,1157.40625 +4.611433029174805,1168.03125 +4.6714560985565186,1168.03125 +4.731485843658447,1168.046875 +4.791504859924316,1168.046875 +4.85152792930603,1232.34375 +4.91155481338501,1349.3125 +4.971576929092407,1388.8125 +5.03160285949707,1428.875 +5.091630935668945,1435.390625 +5.151658058166504,1435.390625 +5.2116858959198,1456.234375 +5.271715879440308,1456.265625 +5.331739902496338,1472.859375 +5.391770839691162,1504.0625 +5.451796054840088,1550.203125 +5.511820077896118,1553.078125 +5.571855783462524,1555.953125 +5.631887912750244,1559.203125 +5.691917896270752,1559.203125 +5.751940965652466,1559.203125 +5.811962842941284,1559.234375 +5.871991872787476,1561.265625 +5.932015895843506,1561.265625 +5.992043972015381,1561.265625 +6.052073955535889,1561.265625 +6.11210298538208,1561.265625 +6.172134876251221,1561.265625 +6.232161998748779,1561.265625 +6.292186975479126,1561.265625 +6.352216720581055,1562.03125 +6.4122397899627686,1562.03125 +6.472275972366333,1562.03125 +6.532299995422363,1562.03125 +6.59232497215271,1562.046875 +6.65234899520874,1562.046875 +6.712374925613403,1562.046875 +6.772397756576538,1562.046875 +6.832427978515625,1563.078125 +6.89245080947876,1563.078125 +6.952473878860474,1563.078125 +7.01251482963562,1568.515625 +7.062839031219482,1603.296875 +7.122880935668945,1603.28125 +7.1829140186309814,1603.28125 +7.242944955825806,1603.28125 +7.302970886230469,1603.28125 +7.3630101680755615,1605.015625 +7.4148218631744385,1624.09375 +7.474854946136475,1645.25 +7.534885883331299,1645.28125 +7.591914892196655,1645.296875 +7.651956081390381,1645.296875 +7.711984872817993,1645.296875 +7.772015810012817,1645.296875 +7.832047939300537,1645.296875 +7.8920738697052,1645.296875 +7.9521098136901855,1645.296875 +8.012146949768066,1645.296875 +8.07217788696289,1645.296875 +8.132208824157715,1645.296875 +8.192240953445435,1645.296875 +8.252271890640259,1645.296875 +8.312294960021973,1645.296875 +8.372326850891113,1645.46875 +8.432363033294678,1645.46875 +8.49239993095398,1645.46875 +8.542808771133423,1645.46875 +8.602844953536987,1645.46875 +8.654810905456543,1645.46875 +8.714863777160645,1645.46875 +8.76680612564087,1645.46875 +8.826834917068481,1645.46875 +8.881897926330566,1646.578125 +8.932140111923218,1646.578125 +8.992172002792358,1646.578125 +9.052199840545654,1646.609375 +9.112236022949219,1646.609375 +9.17226505279541,1646.609375 +9.232310056686401,1646.609375 +9.284130096435547,1646.609375 +9.344161033630371,1667.765625 +9.404188871383667,1667.765625 +9.464224100112915,1667.765625 +9.524255990982056,1667.765625 +9.58428692817688,1668.3125 +9.644324779510498,1668.3125 +9.694793939590454,1668.3125 +9.75482177734375,1668.3125 +9.81485390663147,1668.3125 +9.865458965301514,1668.3125 +9.925485849380493,1668.3125 +9.98551607131958,1668.40625 +10.036128044128418,1668.421875 +10.09615683555603,1668.421875 +10.156182050704956,1668.421875 +10.216223955154419,1668.421875 +10.276257991790771,1668.421875 +10.33628797531128,1668.421875 +10.396339893341064,1668.421875 +10.44677996635437,1668.421875 +10.50681185722351,1668.4375 +10.56684398651123,1668.4375 +10.621983051300049,1671.265625 +10.682011842727661,1671.265625 +10.742042779922485,1671.265625 +10.802068948745728,1671.265625 +10.86210298538208,1671.265625 +10.922132968902588,1671.265625 +10.982157707214355,1671.265625 +11.042181968688965,1671.265625 +11.102230072021484,1671.265625 +11.153439998626709,1671.265625 +11.213469982147217,1671.265625 +11.273496866226196,1671.265625 +11.333526134490967,1671.265625 +11.393555879592896,1671.265625 +11.453577995300293,1671.265625 +11.513603925704956,1671.265625 +11.573632955551147,1680.546875 +11.63199496269226,1680.546875 +11.692019939422607,1680.578125 +11.752048969268799,1680.578125 +11.812076091766357,1680.578125 +11.87210488319397,1680.578125 +11.932154893875122,1680.578125 +11.992187976837158,1680.578125 +12.052213907241821,1680.578125 +12.112249851226807,1680.578125 +12.17229175567627,1680.578125 +12.222768783569336,1680.578125 +12.282793998718262,1680.578125 +12.342820882797241,1680.578125 +12.402860879898071,1680.578125 +12.462891101837158,1680.578125 +12.522912979125977,1680.578125 +12.582948923110962,1680.578125 +12.633434772491455,1680.578125 +12.693459033966064,1680.578125 +12.753483057022095,1680.578125 +12.813534021377563,1680.578125 +12.873579978942871,1680.578125 +12.933616876602173,1680.578125 +12.993647813796997,1680.578125 +13.053678750991821,1680.578125 +13.113707065582275,1680.578125 +13.173748970031738,1680.578125 +13.225436925888062,1680.578125 +13.285470008850098,1680.578125 +13.345503091812134,1680.578125 +13.405542850494385,1680.578125 +13.465581893920898,1680.578125 +13.525603771209717,1680.578125 +13.58563780784607,1680.578125 +13.645666122436523,1680.578125 +13.705704927444458,1680.578125 +13.765744924545288,1680.59375 +13.825776815414429,1680.59375 +13.885828971862793,1680.59375 +13.940098762512207,1680.59375 +14.000130891799927,1680.59375 +14.060159921646118,1680.59375 +14.120206832885742,1680.59375 +14.172096967697144,1680.59375 +14.232141017913818,1680.59375 +14.292166948318481,1680.59375 +14.352200031280518,1680.59375 +14.412230968475342,1680.59375 +14.472261905670166,1680.59375 +14.532293796539307,1680.59375 +14.592315912246704,1680.59375 +14.652336835861206,1680.59375 +14.712364912033081,1680.59375 +14.772407054901123,1680.59375 +14.822762966156006,1680.59375 +14.882802963256836,1680.59375 +14.942831754684448,1680.59375 +15.002862930297852,1680.59375 +15.062898874282837,1680.59375 +15.122928857803345,1680.703125 +15.18295669555664,1680.703125 +15.242981910705566,1680.703125 +15.303009986877441,1680.703125 +15.363039016723633,1680.703125 +15.42309308052063,1680.703125 +15.473413944244385,1680.703125 +15.533447027206421,1680.703125 +15.593487977981567,1680.703125 +15.653522968292236,1680.703125 +15.713547945022583,1680.703125 +15.773576974868774,1680.703125 +15.833606958389282,1680.703125 +15.893642902374268,1680.703125 +15.95366883277893,1680.703125 +16.0136981010437,1680.703125 +16.07373070716858,1680.703125 +16.13376212120056,1680.703125 +16.193793058395386,1680.703125 +16.25384783744812,1680.703125 +16.30541706085205,1680.703125 +16.365453720092773,1680.703125 +16.417412757873535,1680.703125 +16.47745370864868,1680.703125 +16.52940082550049,1680.703125 +16.589431047439575,1680.703125 +16.64946484565735,1680.703125 +16.709491968154907,1680.703125 +16.76951503753662,1680.75 +16.829543828964233,1680.75 +16.889580726623535,1680.75 +16.940059900283813,1680.75 +17.00008773803711,1680.75 +17.06015396118164,1680.75 +17.120194911956787,1680.75 +17.17207098007202,1680.75 +17.232115030288696,1680.84375 +17.28407597541809,1680.84375 +17.34411096572876,1680.84375 +17.404151916503906,1680.84375 +17.454729080200195,1680.859375 +17.514763116836548,1680.859375 +17.574790000915527,1680.875 +17.63481879234314,1680.875 +17.694851875305176,1680.84375 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv new file mode 100644 index 000000000..3a173aa25 --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv @@ -0,0 +1,784 @@ +time_s,memory_MB +3.910064697265625e-05,0.125 +0.05097508430480957,25.3125 +0.10600090026855469,38.5 +0.1610279083251953,66.1875 +0.21605801582336426,100.34375 +0.27111101150512695,133.625 +0.3217949867248535,149.859375 +0.38090085983276367,161.84375 +0.4356811046600342,166.25 +0.4914579391479492,173.390625 +0.5435621738433838,183.96875 +0.5985889434814453,195.578125 +0.6536400318145752,202.515625 +0.7086770534515381,210.4375 +0.7637059688568115,220.296875 +0.8187589645385742,235.765625 +0.8697922229766846,247.90625 +0.9248340129852295,255.65625 +0.9798710346221924,260.0 +1.0346851348876953,269.140625 +1.0856821537017822,274.59375 +1.140714168548584,283.875 +1.195749044418335,294.890625 +1.2482860088348389,307.734375 +1.3033161163330078,313.15625 +1.3583450317382812,325.515625 +1.4133720397949219,331.390625 +1.4683940410614014,341.3125 +1.5234220027923584,350.890625 +1.578449010848999,364.28125 +1.6334779262542725,387.546875 +1.6885020732879639,394.6875 +1.7435338497161865,402.234375 +1.7985711097717285,415.015625 +1.8509469032287598,425.71875 +1.905975103378296,436.59375 +1.9610021114349365,443.15625 +2.0160348415374756,449.046875 +2.066944122314453,453.640625 +2.1219711303710938,462.203125 +2.177002191543579,467.765625 +2.229614019393921,468.546875 +2.2846450805664062,470.09375 +2.338937997817993,477.5 +2.393963098526001,490.5625 +2.4489948749542236,497.703125 +2.504031181335449,514.234375 +2.554939031600952,552.921875 +2.60998797416687,575.859375 +2.6616101264953613,575.984375 +2.7166459560394287,600.953125 +2.7682740688323975,603.875 +2.823305130004883,608.875 +2.8783349990844727,615.265625 +2.933357000350952,616.296875 +2.9883759021759033,616.40625 +3.0434021949768066,616.59375 +3.0962929725646973,622.0625 +3.151327133178711,625.9375 +3.2063560485839844,629.265625 +3.2613840103149414,633.765625 +3.3164188861846924,641.0 +3.3682639598846436,641.421875 +3.4232988357543945,647.046875 +3.474925994873047,647.578125 +3.5299649238586426,649.265625 +3.5816400051116943,649.296875 +3.6362650394439697,649.34375 +3.6912999153137207,649.8125 +3.741595983505249,649.8125 +3.7966179847717285,649.8125 +3.851641893386841,650.0 +3.906665086746216,650.15625 +3.9616920948028564,650.1875 +4.016715049743652,650.25 +4.071742057800293,650.421875 +4.126766920089722,650.4375 +4.181803226470947,650.59375 +4.236831188201904,650.609375 +4.291856050491333,650.765625 +4.34688401222229,653.953125 +4.397594928741455,659.953125 +4.452630043029785,659.953125 +4.5042500495910645,660.15625 +4.559286117553711,660.375 +4.61431884765625,664.734375 +4.666918039321899,666.34375 +4.7219460010528564,666.453125 +4.776987075805664,666.453125 +4.832006931304932,666.515625 +4.887030124664307,666.609375 +4.942061901092529,666.75 +4.992249965667725,666.796875 +5.047277927398682,666.796875 +5.1016340255737305,666.921875 +5.156666040420532,666.9375 +5.211694955825806,667.046875 +5.266723871231079,667.109375 +5.321758985519409,668.265625 +5.373578071594238,668.421875 +5.4286110401153564,670.5625 +5.480262041091919,670.609375 +5.535290002822876,670.625 +5.590325117111206,670.765625 +5.645350933074951,670.875 +5.700374126434326,671.015625 +5.755401134490967,671.015625 +5.810420036315918,671.09375 +5.865447044372559,677.921875 +5.92048192024231,680.734375 +5.975503921508789,682.375 +6.0305280685424805,682.375 +6.085558176040649,682.375 +6.1405839920043945,687.828125 +6.195605039596558,687.890625 +6.250635147094727,688.015625 +6.305660963058472,688.1875 +6.360681056976318,688.328125 +6.415709018707275,688.359375 +6.470736980438232,688.359375 +6.52577018737793,688.359375 +6.580798149108887,688.359375 +6.635823965072632,688.375 +6.690852880477905,688.390625 +6.745882987976074,688.390625 +6.800910949707031,697.546875 +6.855937957763672,708.3125 +6.910967111587524,708.3125 +6.965996980667114,708.578125 +7.021038055419922,708.59375 +7.076061964035034,708.71875 +7.131091117858887,708.71875 +7.186129093170166,708.96875 +7.2411558628082275,711.75 +7.296190023422241,711.75 +7.351217985153198,711.75 +7.4062511920928955,711.75 +7.461282014846802,711.75 +7.516309022903442,711.75 +7.571333885192871,711.75 +7.62636923789978,711.75 +7.6813929080963135,711.75 +7.736418962478638,711.75 +7.791445016860962,713.046875 +7.846468925476074,713.046875 +7.901492118835449,713.046875 +7.956524133682251,714.421875 +8.011548042297363,714.4375 +8.066578149795532,714.4375 +8.121603965759277,714.828125 +8.176630020141602,714.84375 +8.23166012763977,717.796875 +8.286690950393677,727.5625 +8.341716051101685,727.578125 +8.39674711227417,727.578125 +8.451777935028076,727.578125 +8.506814002990723,727.578125 +8.561841011047363,727.578125 +8.61686897277832,727.59375 +8.671897888183594,727.59375 +8.726931095123291,727.59375 +8.781959056854248,727.703125 +8.836986064910889,727.734375 +8.892012119293213,727.796875 +8.947041988372803,727.9375 +9.002064943313599,728.03125 +9.05709195137024,730.71875 +9.112117052078247,730.75 +9.167143106460571,730.75 +9.22216796875,730.78125 +9.27719521522522,730.78125 +9.332228899002075,730.78125 +9.38725996017456,730.78125 +9.442296981811523,730.78125 +9.49732494354248,731.078125 +9.5523521900177,731.09375 +9.60738492012024,733.90625 +9.662410020828247,735.3125 +9.717437028884888,735.3125 +9.772461891174316,735.3125 +9.827486991882324,737.875 +9.882513046264648,737.9375 +9.937540054321289,737.9375 +9.99256420135498,738.0 +10.04759407043457,738.0 +10.102618932723999,738.03125 +10.157649040222168,738.171875 +10.212676048278809,738.203125 +10.267705917358398,738.265625 +10.322729110717773,738.28125 +10.377765893936157,738.28125 +10.432793855667114,738.28125 +10.487820148468018,738.296875 +10.542850971221924,738.359375 +10.597880840301514,746.984375 +10.652907133102417,747.15625 +10.707942008972168,747.28125 +10.762969970703125,747.3125 +10.818001985549927,750.8125 +10.87303113937378,751.015625 +10.928060054779053,751.0625 +10.983085870742798,751.09375 +11.038113117218018,751.578125 +11.093139171600342,754.609375 +11.148162841796875,762.25 +11.203185081481934,762.34375 +11.258218050003052,762.375 +11.313256025314331,762.375 +11.368293046951294,762.40625 +11.42332410812378,762.53125 +11.478349924087524,762.5625 +11.53338098526001,762.578125 +11.588409900665283,762.6875 +11.643436193466187,762.765625 +11.698462009429932,762.875 +11.7534921169281,762.875 +11.808524131774902,762.984375 +11.863550186157227,763.046875 +11.918581008911133,763.1875 +11.973618030548096,769.234375 +12.024193048477173,772.203125 +12.079219102859497,772.390625 +12.133136987686157,772.40625 +12.184195041656494,772.46875 +12.239227056503296,772.578125 +12.294262170791626,772.9375 +12.34929609298706,773.0625 +12.404325008392334,779.109375 +12.456187963485718,779.171875 +12.511219024658203,779.296875 +12.566246032714844,779.375 +12.621278047561646,783.265625 +12.67630910873413,783.328125 +12.731348991394043,783.328125 +12.786372900009155,783.453125 +12.841402053833008,783.640625 +12.896427154541016,783.6875 +12.951451063156128,783.6875 +13.00647783279419,783.75 +13.06150507926941,783.875 +13.116527080535889,784.0 +13.171557903289795,784.1875 +13.22658896446228,784.203125 +13.281636953353882,784.375 +13.336663007736206,784.421875 +13.391692161560059,785.6875 +13.4467191696167,788.125 +13.501741886138916,788.171875 +13.556769847869873,788.484375 +13.611804962158203,788.484375 +13.666839838027954,788.625 +13.721874952316284,788.640625 +13.77689790725708,788.828125 +13.831926107406616,788.859375 +13.88695216178894,789.0625 +13.941980123519897,789.203125 +13.99700403213501,789.5625 +14.052041053771973,800.328125 +14.107071161270142,800.390625 +14.162096977233887,800.671875 +14.217135906219482,800.90625 +14.27216386795044,801.0 +14.327189207077026,801.140625 +14.382220983505249,801.265625 +14.437250852584839,801.359375 +14.492280960083008,801.40625 +14.547307014465332,801.5 +14.602330923080444,801.625 +14.657353162765503,801.71875 +14.712385177612305,801.765625 +14.767409086227417,813.78125 +14.822433948516846,814.046875 +14.877459049224854,814.328125 +14.932487964630127,814.453125 +14.987514019012451,814.453125 +15.047543048858643,814.515625 +15.107572078704834,820.03125 +15.167598962783813,820.03125 +15.227628946304321,820.078125 +15.28766393661499,820.125 +15.338827133178711,820.125 +15.398850917816162,820.140625 +15.458876132965088,820.203125 +15.518900156021118,821.46875 +15.578924894332886,821.609375 +15.63895297050476,825.96875 +15.69897723197937,826.0625 +15.75900411605835,826.21875 +15.819033861160278,827.5 +15.879059076309204,831.90625 +15.939090013504028,832.015625 +15.999113082885742,832.03125 +16.059139013290405,832.078125 +16.119169235229492,832.140625 +16.17919611930847,832.28125 +16.239220142364502,832.28125 +16.299248933792114,832.296875 +16.35927414894104,832.34375 +16.419301986694336,835.546875 +16.47932720184326,840.25 +16.539350986480713,840.25 +16.5993812084198,843.40625 +16.659405946731567,846.71875 +16.719434022903442,846.75 +16.779468059539795,846.859375 +16.839494943618774,846.859375 +16.899523973464966,846.859375 +16.95954704284668,847.03125 +17.019581079483032,847.046875 +17.0796160697937,847.046875 +17.13964295387268,847.046875 +17.199671268463135,847.1875 +17.259696006774902,848.59375 +17.319722175598145,849.8125 +17.37974524497986,849.8125 +17.439770936965942,849.90625 +17.499794006347656,849.921875 +17.559819221496582,849.921875 +17.619847059249878,850.0625 +17.679873943328857,850.0625 +17.739901065826416,850.1875 +17.799927234649658,853.09375 +17.85995602607727,853.15625 +17.919984102249146,853.234375 +17.980008125305176,853.734375 +18.04004216194153,853.734375 +18.100067853927612,858.234375 +18.16009211540222,858.3125 +18.220124006271362,858.3125 +18.280150175094604,858.3125 +18.340178966522217,859.453125 +18.400205850601196,864.328125 +18.46022891998291,864.359375 +18.520257234573364,864.4375 +18.58027982711792,864.46875 +18.640305995941162,864.640625 +18.700335025787354,864.640625 +18.7603600025177,864.765625 +18.82038402557373,864.78125 +18.88040781021118,864.78125 +18.94043207168579,866.078125 +19.000455141067505,866.203125 +19.060487031936646,866.265625 +19.120513200759888,866.28125 +19.179604053497314,867.546875 +19.23213815689087,868.921875 +19.292165994644165,875.28125 +19.352192163467407,883.375 +19.41221785545349,883.375 +19.472244024276733,883.390625 +19.53226900100708,883.453125 +19.59229612350464,883.5 +19.65232014656067,883.53125 +19.71235203742981,883.5625 +19.772380113601685,883.5625 +19.83240509033203,883.65625 +19.89244508743286,883.6875 +19.952471017837524,883.6875 +20.01249599456787,883.78125 +20.0725200176239,883.8125 +20.132549047470093,885.15625 +20.189604997634888,885.15625 +20.240122079849243,885.234375 +20.30014705657959,885.421875 +20.360174894332886,885.484375 +20.4201979637146,885.484375 +20.480223178863525,886.6875 +20.540246963500977,886.703125 +20.600274085998535,886.734375 +20.660300254821777,888.09375 +20.720329999923706,893.578125 +20.780354022979736,893.78125 +20.840378999710083,896.625 +20.89079785346985,896.78125 +20.950822114944458,896.921875 +21.010849237442017,896.921875 +21.070876121520996,896.921875 +21.13090491294861,896.9375 +21.19093108177185,896.9375 +21.250958919525146,897.046875 +21.310982942581177,897.109375 +21.371011972427368,898.453125 +21.431035041809082,898.578125 +21.49106216430664,898.578125 +21.551090002059937,898.65625 +21.611115217208862,898.6875 +21.671139001846313,898.6875 +21.731159925460815,898.8125 +21.791199207305908,898.84375 +21.85122585296631,903.671875 +21.911254167556763,904.96875 +21.97127890586853,908.78125 +22.03130292892456,908.90625 +22.09132981300354,909.09375 +22.141438007354736,909.203125 +22.2014639377594,912.625 +22.253443956375122,917.1875 +22.31346893310547,917.359375 +22.373498916625977,920.265625 +22.424106121063232,921.78125 +22.484133005142212,921.859375 +22.544164896011353,921.9375 +22.59477210044861,922.078125 +22.654796838760376,922.3125 +22.7148220539093,922.328125 +22.774852991104126,922.421875 +22.834877014160156,922.515625 +22.894906044006348,922.640625 +22.954933166503906,923.59375 +23.01495885848999,925.59375 +23.074981927871704,925.65625 +23.135009050369263,925.78125 +23.195035934448242,926.984375 +23.25507116317749,927.140625 +23.306768894195557,928.53125 +23.36679697036743,931.390625 +23.42682409286499,931.390625 +23.486862897872925,931.578125 +23.546889066696167,931.609375 +23.60692000389099,934.328125 +23.666945219039917,934.484375 +23.726975202560425,934.5 +23.787004947662354,942.328125 +23.83743119239807,945.328125 +23.897457122802734,945.484375 +23.957479000091553,945.703125 +24.017505884170532,945.78125 +24.077531099319458,946.0 +24.137558937072754,946.09375 +24.197585105895996,946.125 +24.25760793685913,947.6875 +24.31763792037964,952.5625 +24.368086099624634,952.875 +24.428112030029297,954.4375 +24.488136053085327,958.03125 +24.548166036605835,958.09375 +24.60819101333618,958.125 +24.66822099685669,958.15625 +24.72008514404297,958.203125 +24.78011393547058,959.75 +24.840139150619507,960.03125 +24.900169134140015,960.171875 +24.96019220352173,960.390625 +25.020219087600708,960.421875 +25.08024311065674,960.59375 +25.140269994735718,960.640625 +25.20029616355896,960.828125 +25.260321140289307,960.921875 +25.320348024368286,960.953125 +25.380378007888794,961.140625 +25.433382034301758,961.234375 +25.48542809486389,961.265625 +25.545454025268555,961.328125 +25.605481147766113,961.640625 +25.665505170822144,961.796875 +25.725532054901123,961.859375 +25.785556077957153,961.984375 +25.845580101013184,967.4375 +25.905603885650635,971.625 +25.965636014938354,975.03125 +26.025656938552856,975.03125 +26.08568787574768,975.171875 +26.136080026626587,975.375 +26.196105003356934,975.40625 +26.256131887435913,975.703125 +26.316155910491943,978.234375 +26.37617802619934,978.40625 +26.43620491027832,978.40625 +26.496232986450195,978.546875 +26.556257247924805,978.859375 +26.616291046142578,981.265625 +26.666733980178833,981.328125 +26.72676110267639,992.4375 +26.786782026290894,992.578125 +26.846802949905396,992.765625 +26.90682888031006,993.140625 +26.96685290336609,993.140625 +27.026875972747803,997.75 +27.08690118789673,997.78125 +27.14692497253418,997.9375 +27.206944227218628,998.0 +27.266968965530396,998.21875 +27.32699203491211,1001.28125 +27.387013912200928,1001.484375 +27.44704294204712,1001.9375 +27.507070064544678,1001.9375 +27.56709599494934,1001.953125 +27.627119064331055,1002.078125 +27.687146186828613,1002.109375 +27.747173070907593,1002.3125 +27.80719804763794,1002.484375 +27.86722207069397,1002.671875 +27.92724585533142,1002.703125 +27.987274169921875,1002.84375 +28.047301054000854,1003.0 +28.107325077056885,1005.4375 +28.167351961135864,1007.9375 +28.227375984191895,1007.984375 +28.287402153015137,1008.046875 +28.347422122955322,1008.25 +28.40744686126709,1008.296875 +28.467466115951538,1008.328125 +28.52748990058899,1008.453125 +28.587514877319336,1008.640625 +28.647542238235474,1008.703125 +28.70757007598877,1009.96875 +28.767595052719116,1010.203125 +28.8276150226593,1010.265625 +28.887644052505493,1012.796875 +28.947670936584473,1012.984375 +29.007697105407715,1020.03125 +29.067721128463745,1020.21875 +29.127745151519775,1020.390625 +29.18777108192444,1020.421875 +29.24779510498047,1021.9375 +29.30782699584961,1022.109375 +29.367856979370117,1022.109375 +29.42788600921631,1022.1875 +29.487910985946655,1022.234375 +29.547945022583008,1022.359375 +29.60005211830139,1022.53125 +29.66008710861206,1022.671875 +29.720113039016724,1023.96875 +29.780141830444336,1024.265625 +29.8320369720459,1024.34375 +29.892061948776245,1024.484375 +29.952084064483643,1024.484375 +30.01211190223694,1024.625 +30.072136163711548,1024.796875 +30.132161855697632,1027.15625 +30.192183256149292,1027.390625 +30.25221300125122,1027.5625 +30.312247037887573,1027.75 +30.372272968292236,1031.078125 +30.43229603767395,1033.421875 +30.492319107055664,1036.03125 +30.55234384536743,1038.296875 +30.612367868423462,1038.59375 +30.672390937805176,1038.734375 +30.732412099838257,1038.890625 +30.79243516921997,1038.96875 +30.852460861206055,1039.125 +30.912480115890503,1039.140625 +30.972503900527954,1043.15625 +31.03253412246704,1322.34375 +31.092567920684814,1443.859375 +31.152594089508057,1474.28125 +31.21261501312256,1624.6875 +31.272648096084595,1836.453125 +31.332672119140625,1446.65625 +31.392701148986816,1573.125 +31.452728033065796,1603.5 +31.51275086402893,1603.84375 +31.572787046432495,1607.140625 +31.632813930511475,1608.09375 +31.692848920822144,1770.375 +31.75288200378418,1846.328125 +31.8129141330719,1887.296875 +31.87297010421753,1887.296875 +31.92537784576416,1912.203125 +31.98540997505188,1912.203125 +32.04487204551697,1912.25 +32.09604597091675,1912.25 +32.150030851364136,1912.640625 +32.20536804199219,1912.75 +32.26539921760559,1912.78125 +32.3254292011261,1912.84375 +32.38546586036682,1912.84375 +32.44549894332886,1912.84375 +32.50555205345154,1912.84375 +32.565590143203735,1912.84375 +32.62561917304993,1912.84375 +32.68564796447754,1912.84375 +32.74569511413574,1953.6875 +32.79736304283142,1965.125 +32.85739302635193,1979.109375 +32.913684129714966,1985.015625 +32.96536302566528,1985.015625 +33.02539801597595,1990.53125 +33.085434913635254,1990.53125 +33.145468950271606,1990.875 +33.20048189163208,1990.875 +33.25603795051575,1990.875 +33.31607508659363,1990.875 +33.376112937927246,1996.1875 +33.43615126609802,1996.1875 +33.496185064315796,1996.1875 +33.549899101257324,1996.1875 +33.60992908477783,1996.1875 +33.66995692253113,1996.1875 +33.729995012283325,1996.1875 +33.78402590751648,1996.21875 +33.84408211708069,1996.21875 +33.90412187576294,1996.21875 +33.96417808532715,1996.21875 +34.0242121219635,1996.21875 +34.0842490196228,1996.21875 +34.144274950027466,2037.25 +34.20430302619934,2037.25 +34.26432704925537,2037.25 +34.32435584068298,2037.25 +34.3843879699707,2037.25 +34.44441890716553,2037.25 +34.50447392463684,2037.25 +34.5546760559082,2037.25 +34.614710092544556,2037.25 +34.674736976623535,2037.25 +34.73476600646973,2048.890625 +34.794800996780396,2048.890625 +34.85484719276428,2048.890625 +34.90668702125549,2048.890625 +34.96673011779785,2048.890625 +35.02676796913147,2048.890625 +35.086796045303345,2048.890625 +35.14683294296265,2048.890625 +35.197340965270996,2048.890625 +35.25739097595215,2048.890625 +35.31743001937866,2048.890625 +35.368009090423584,2048.890625 +35.42805218696594,2048.890625 +35.488080978393555,2048.890625 +35.5481071472168,2048.890625 +35.608131885528564,2048.890625 +35.66815805435181,2048.890625 +35.728187084198,2048.890625 +35.78821587562561,2048.890625 +35.84824800491333,2048.890625 +35.90826892852783,2048.890625 +35.9682981967926,2048.96875 +36.0283260345459,2048.96875 +36.08836221694946,2048.96875 +36.138664960861206,2048.96875 +36.19869923591614,2048.96875 +36.25873899459839,2048.96875 +36.30932426452637,2048.96875 +36.36935615539551,2048.96875 +36.429386138916016,2048.96875 +36.48941707611084,2048.96875 +36.5494430065155,2048.96875 +36.609468936920166,2048.96875 +36.669495820999146,2048.96875 +36.72952604293823,2048.96875 +36.78957915306091,2048.96875 +36.84961295127869,2048.96875 +36.90963912010193,2048.96875 +36.96966600418091,2048.96875 +37.02969312667847,2048.96875 +37.08973407745361,2048.96875 +37.14132809638977,2048.96875 +37.2013578414917,2048.96875 +37.261388063430786,2048.96875 +37.321414947509766,2048.96875 +37.381447076797485,2069.703125 +37.44147324562073,2069.703125 +37.50149703025818,2069.703125 +37.56152296066284,2070.203125 +37.62154817581177,2070.203125 +37.68157696723938,2070.203125 +37.741617918014526,2070.203125 +37.79197812080383,2094.296875 +37.85200500488281,2094.296875 +37.91205096244812,2094.40625 +37.97209310531616,2094.40625 +38.023980140686035,2094.40625 +38.08402490615845,2094.453125 +38.13600015640259,2094.453125 +38.196033239364624,2094.46875 +38.256062030792236,2094.46875 +38.316092014312744,2094.46875 +38.37612295150757,2094.953125 +38.43615126609802,2094.953125 +38.49617600440979,2094.953125 +38.55478525161743,2094.953125 +38.61482000350952,2094.953125 +38.67484998703003,2094.953125 +38.73487901687622,2094.953125 +38.794902086257935,2094.953125 +38.854931116104126,2094.953125 +38.91495609283447,2094.953125 +38.974982023239136,2094.96875 +39.03500699996948,2094.96875 +39.095041036605835,2094.96875 +39.155067920684814,2094.96875 +39.21509599685669,2094.96875 +39.27513003349304,2094.96875 +39.325308084487915,2094.96875 +39.385343074798584,2094.96875 +39.445372104644775,2094.96875 +39.5054030418396,2094.96875 +39.56542611122131,2094.984375 +39.62545299530029,2094.984375 +39.685484170913696,2094.984375 +39.74551200866699,2094.984375 +39.80553889274597,2094.984375 +39.86557197570801,2094.984375 +39.925601959228516,2094.984375 +39.985636949539185,2094.984375 +40.04566693305969,2094.984375 +40.10569787025452,2094.984375 +40.1657280921936,2094.984375 +40.22575402259827,2095.609375 +40.28578281402588,2095.609375 +40.34580588340759,2095.609375 +40.405832052230835,2095.609375 +40.46586298942566,2095.609375 +40.5258891582489,2095.609375 +40.585936069488525,2095.609375 +40.637288093566895,2095.609375 +40.69731903076172,2095.609375 +40.757346868515015,2095.609375 +40.81737399101257,2095.609375 +40.87740612030029,2095.609375 +40.93743395805359,2095.609375 +40.99746012687683,2095.609375 +41.05749201774597,2095.609375 +41.117516040802,2095.609375 +41.17754411697388,2095.609375 +41.237574100494385,2095.609375 +41.29761290550232,2095.609375 +41.34929895401001,2095.609375 +41.409339904785156,2095.609375 +41.46937417984009,2095.609375 +41.5294029712677,2095.609375 +41.58944606781006,2095.609375 +41.64948105812073,2096.203125 +41.709511041641235,2096.203125 +41.76956105232239,2096.203125 +41.82958912849426,2096.203125 +41.88963794708252,2096.203125 +41.94128394126892,2096.203125 +42.00131320953369,2096.203125 +42.0613489151001,2096.203125 +42.11194610595703,2096.203125 +42.17198300361633,2096.203125 +42.22395610809326,2096.203125 +42.28399395942688,2096.203125 +42.33594512939453,2096.203125 +42.395987033843994,2096.203125 +42.44795513153076,2096.203125 +42.50799298286438,2096.203125 +42.56803488731384,2096.203125 +42.628074169158936,2096.203125 +42.6799418926239,2096.203125 +42.73997092247009,2096.203125 +42.80000019073486,2096.203125 +42.860032081604004,2096.203125 +42.92006993293762,2096.203125 +42.97060489654541,2096.203125 +43.03064513206482,2096.203125 +43.0906720161438,2096.203125 +43.15070390701294,2096.203125 +43.21073603630066,2096.203125 +43.27077794075012,2096.203125 +43.33084297180176,2096.203125 +43.381277084350586,2096.203125 +43.44131803512573,2096.203125 +43.493273973464966,2096.203125 +43.55331325531006,2096.203125 +43.605266094207764,2096.203125 +43.66529607772827,2096.203125 +43.72533321380615,2096.34375 +43.78537106513977,2096.34375 +43.84539985656738,2096.34375 +43.90544295310974,2096.34375 +43.95725917816162,2096.34375 +44.01730012893677,2096.34375 +44.07732892036438,2096.359375 +44.12794613838196,2096.359375 +44.18797492980957,2096.359375 +44.24800705909729,2096.359375 +44.308034896850586,2096.359375 +44.36806297302246,2123.40625 +44.42809510231018,2123.40625 +44.48812913894653,2082.25 +44.54816293716431,1710.203125 +44.60819602012634,1710.203125 +44.66823101043701,1710.203125 +44.724956035614014,1710.203125 +44.784985065460205,1710.21875 +44.84501910209656,1710.21875 +44.90506410598755,1710.25 +44.957255125045776,1710.25 +45.017290115356445,1710.296875 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png new file mode 100644 index 0000000000000000000000000000000000000000..2261edd88ce850d58f6e7e0ed4c5e145ebe6deba GIT binary patch literal 39804 zcmb5Wc{tQ>_%=MGR0`jU7Fk*(g;KJQrM{&ICHq=rHp5=QqpIo%QXGprTv7G zkN>9gy}o+$)IQtO{S4dnfyQ{4PtIs_$%ya+j<7Q&6ZP}?P<#)-TT*~Xi)1$n`{WqUgt z^5Q8Q2Mi4St4FbWZN9KZ{r^48_lJA-?2);`!oDRxT0;S-#%H8nt@VF zfr6+1yp{Q~5<~Woc_DPX({9Adi* zJNMmKn)&6;Ao+^w-Cj8#?inf-Y2(av&~_uPQVVDLt@ zQpRrW?Tm#sRmyzx8KXk$ZvzyEf`v+2O-{)thR4|V*I~3T(v62dz$dH*gP52RS)UQR z_7wGO)6(qbj8DCFNxk_Nl}A@CiO!e;B1~2H`^#L6)i;u6JxgazLk`Y$Xb2lXv>8<0 z_wYSTOb)b+D(=m(Z%aC)8dSy1HDzY%B*u*#Sd=uwm65fuLO6@2NKtRH-{dr0gI1BQ z(mUJ6;?bCsH!m7l1um&4AK57HTh)>(ueZSW(&w@?VcSxp zaBx7o$}G#JzbKvgldyoEOz@P!(q}_)W+e`KIr z4f9OP8--g{H`YeirEqS8`6bJP8|#_3bkV=iZp=A{p4@i=cD!M@vBpJHf0%T6Ch>quK-nq7+$lPSmbvsZ zlY#xUE<0B?%I#ZyZ~R9XwPU=rxZTVcO6hZ7^&H z9gQr!qYd-T{pt(Ohe(`+b=}=pXd^kZqa{&EuDi@*^hV=L!M!vrlZwC8Uu4S#>%=Pc z8Qif&jAIF@rN-DE}bxHEfGAXv3g7v_SUif)FH8VL# zvBYm-;s&|O?-HKmLsV}Y#G#q9#XKvAAfWrvPsY|pSAy35G~UQJFTW_39B|J8LU`^% zIg3ub)Dm|=YhVJ_g-^kyWR<{+Z7R%MtO}hl_Ve9&8MrC9mlZju?vroOSo)2&B=jX+ z^pgHm)j}&5++mww7a9M1lt8g-8;6wOLnKJ=-LvPSTlJFRlzWBO^avfsuetr{KgTXc zsH}d(vXWq_A1`=-@mv{?t?Vtim8mmF7mYQKylbVwv?O}Wk2UR8Twfj~*>@y0KiY3O z_0oGVkRhtjQ`jgZP%)hmKOh^Sx_*DE`8*W& z$CZz;GE(Qqo1Y*d$XF-Z|4<3tE2gt6TFQb@ok>4f$mk}kGKo7k4ig4zs~Mr&cHg6U zKqQbn-=eWTBR)As1wOP#rOkB4_hS)dj7kWpIluolv}@Pqo98?O)>kGg>3z&Q1)h+- z_11_ylLboMo^%r>7c(Yz3B7NyAdr7nNpcUSknxp_cc%-Qe7tdlv2vj+L!0YYfz@Cj zeucI&))Ykwgb?*jzQatKB31fMg^4A(C-W%1tQJ;rev+31iPt$E?rY)OGd|CPmADJe zolDiLur{ASN}r@VCVSUfnBiTul?|7DU!Pfll@*t8equQ{gZTY6m0c$4C)v5d!%<)ZHq zvfprx1i00#OsK2Yx-kT*2DIwI^b$cA&;N; zFvI3ys<$$xS(c@H`J0FbgK`%+riKSS8Y~w^zC9NsufrXYcBFm@HQeF}`$;N?u;;wF*YxU0siNtC`l*Win{N?SVn7H5-Q* z(_LasEJ(5Ol_ezuSF3u5B}CCxf)Yg1U>qA%w7m0gerQlHxU8A1;cTPXrXbnLv@|v?3gqtmvF;<8*k_+L zOOH!%|GFcLW~50=OrJGVEK8p!mbllPv;9#<9nyVmb#uci==t>56^! z=hBDIi({O<)n=Dfm_cO_@ul7rL%B7PglZnhQ(9G+g3{8ijkUu~45#C1i}>4v2J7~9 zk3aWe?+n@x7ZjrzqmYrGTH2#bZn+pnu!U?d7H)#|ntyti{U|$C10U|J6Sg&opSS-2 z>5Vb(UMc0X=lKT&;=f9!FRjb_2t-VC?rbt?zdh=VNyraR-NmCBSuC6g3+{&Ns5Mn% z=)WC%2i|H4XdT)C$n+Pa^At*crH(JjJ65UHHr8UovhKI=x~%IWY!IHKHjLT+DC>@9)_i$^2mnrW(*h9)iOBqMk8vV=CwPGuz$-}ChQN=i8W|S~7NXG2BgncxV!`|!?ko_6HgvSw@PMl715c6H5 zAD&roVDq2P+R2h;4Z8$*&QB&7P6wXpT&)U}6;fWI*wea($(6Mm>%>6&G`g=-u$%1T zJ|~p1KwW5{)qEqt_r-J^iaKE!dL2+PmdUw!98VBkCltmtO{*}4CKCrLn z_uX>pn(5~s%noFWIR7p<6f;yA0_&K5z~$v3+gtby)XUpOxUC#ddc17k0^FGhV|;mCG(V5 zmO;AJd_r1znKFK7ebe-?f|1QH7^}@^YP&D*w;0>$*UxkmJ3rf4$!A!+_qyZC^|X5b zxm+VR*zV`h*s<3di@)o5DwEJm?A3zqBu~5Q{f>d;j%6iniaj&h$nu&8f7s958sTZ2 zgjLNzVhWbtZ_lUi$g;fNHu>Gso>;&)s^w_b{2PV36v8dyY7THQe@~@>C2r{41w(a0 zXL!7fW8|EO2s(FXp-Iu*CUr(Xk9kf?VvnT|Wk+ceg+a!)u}~#Z+a0fMlv)aDxoJ!J z6+{;bNl_H=<9`~3eGNuv<DOU!&88r0*+#$3x^gNIJ&O5-On5rvjbzb(Be(ma!l zSyOi>rtTT6a321r-uNxbWjwBr$DTr($IkwQos>iwsnvLG-B{G^Slc@Q8~mBMPF+r1 zcK{_3hcgrPOx`-B(flw_>kj@~5s!}I^zq$7%6(g>hLan|sZBcc8QV{WBHSxOLXBo_`?K?fVAvS{uX32{VtajS7~_Sgd|)NLMubaY!L;JYcQpDYChYW+SgYEc|ZlJ>;Ui7N=)O4L)srhSQIIp9iu{|+R)QSYg96#wpM zJ9-*ZDC5QT+a(uc>R&Uf@gaSI$a6P2e7MB2$DM!d#N@^hnco-^~Ek-vHn)}Z2~sVUG^sNk;UDkmkR$ddSW<*?hmCf*JM`<3bnKL zx9X@Zj}{!GW@RR6c5+u@#E#6?KiN<;9pWXM*-z7Cla{ac*USd$tgjMyQ5&pcQ#PDy z_s5&pI%lZ=MQH0r|5I?e%%N((;~km?BvT94qu+P7`;2@(cSwSFsp~UUp>M}$1<#4& zD+wps8VYOKurCtFb_(y@v;Ow#^#D4zF&Ycnc%AXCtw+6j6<RJO~)93AFHez-L<| zyyml~&j0>buE>6#0A`_+dgRg#6Iu?-xYVOMNcUZf7N&X^NXA6TwWs1;0XsHUwi^uAsce zj)_(J6P-S1d-bf+-p5jXP&>>CMz zb`s6sbYuy?w{h)}JY7fjRZ_4S^ni(Xr?YG^MYYVa+_?u^hYdM?zqzI3k*uzClTeNI zWtb9vzlGAQye-alwC{$Xl1Wt6%g1Ojtgvgsbeg%oP;Bw?zr{OnzTb$}}{c$qBr!nJJ(R7WArCGe?w0lJ9=!xXcAITMs8T1_tNNP`j zqZ)Z>-QwBEK3;#fPyj@&1x) zvcYBAlXk@ZbZr_P();muxM|?H?iGZ!@L+Da_V2S0*B-ZPtDCUK_5RAZSG4k@c74^^ z_j-J+VuCit_SUg}^Ix(?MJ=~53r}kQGzdHibd_C-uO?q`>UO8%Rw6Mvi!fTEuEq9k zLUO`|EzTGwzPyOJM2WrYga^E}-fc|}h?8>@0@^J({$Z;nW$f1N@Pp?Yw2#>rd?+QU zG>dC{M0Xb6isSx~QCqxHi^=!Hw&V%=pwktakv)v8q=ajcCZ%3_a=gp*k!tLio|BEH z9(JvxX8)5oyOs$TT`4pzOWUFk_!_yT*lJ%{ZJXsc*qTRN`zuEKmH*I9O8vU1tm}@7 zXW~z^&>e%f-~xYT8;}OS;s=8S3jNw!VAFiNoJ24m>QRY5t-J@bBiXKHos3DMl{)td zb#IHe8d#seXvz^amVF;$f?F>1mMMIp(z zhx<9y46XaO%34_6e-@l(Tu>Z7h$DOW$FbeDO)J}?#xLzUATQU`r)OZ3n4a)>|4^}y z+0N{AqG_CD$WUS7pkt!tZq%!D0715w0a4d&;D~b?kj?KXushuBzce%c&`aQ$)96*q z>?)La7OB}Uauaw&M*HNQ;L47uafXBxv%B&Sn8FoZo2e`?n*fA24Ia)=3!G3&z^P-Dt&#RPOggwA)gq!%`tVbo~KnSMj|U< zW&WQUjA%zd_yO-51=4)PPG7w_qYH z0x1aKe9F%tZrMkN;2a@+S3+KXFsupi3l~(9ZK~)mwy(^Zn4fGbFh;mD88241S&^15;pSqC};#x6%Le856^pLrL%b`!3MJ){oKrc8>B^6U^Wa*dQlW&1-53;&H zywxDz+{ABw%tIZg9g27E%|Fg8+Vv1h{S#!IrJGWI3s2D39bzBh4^lS=+SU+b*_>Y z`SX@572kWzcW&U687>!V70|N|6sH9gYMx^M=04ddZd37O^p6AEIqJ`3T@QIfz64{1 z>d**Dx_0r1BM~e#rrx9dKu`H$>(` ztr1H1{l;fhR*q9$`+W%(fv#AhS7a+NCM+1WFrx7dXNK8lr8{3aAO~Lo*76>@&*$h6 zFo8YQ3^Ijqcau=@Bt9XzQO$5J?+7?d{8(Qtiylu7SkSIs>M@gQ86a3c*Z|%pzAU_y z3elolNFAO%{va{rQzJp;CvZvKnYzM(K*g?(Md<>8E^C3n`#=Z`g}HgCJ$=ygJ>12% z&HM;=4`g_Bv$8xeh~8he?k`(vASeecyQ3Kco~yv&E&(&1qm!r@hMDd!&a`WZ8-ILI z!n~{w1(AchDlF#Le@QE9Hv{9F^8%QGpB6#xA!5wEp%=f9JEW_V4FI7dsotHly+ zaL@w(`42$PdtWk_mLC^~&~Zf9E;!Q%MD;MpG4w|F3`?L&MSeZJP1zxfu%BG=ROuK+ zSBaETp~Z(=xw7E`6e+pIC3lJr7`Ga1Os;|!wb zCmTu2Dr4Asbd>X#^35Wu+KRS+4HrTamcA03woxA8XHmrU0nauA7)}eO4p6)JJd!;X zuSGGD;}0P=?KazJzr<5+>8Hwt1d`h9drrY8yW8tb;_zGhnoM}`=>fs8D5TD6XK@nr z`Y{4rHzfH;RuZ4Mb+_Wbdh#bcVYHj2xPI|lR;(3NWi3W={bUUd^wIgp2!S=QqE75+ z)yBJ$WH1C7gk=xg`YZQ_rRf9*zT0!u%^BT8C6wNZK4oAYQHtiV`Ld8|e5$6jPAA0p zEGD9~w<$OwQ5l%~C&U7boZtLiDyg!UWG{9im$Mf3fNPewxaR7tZXwrQ7$LNHJ@QO) zZX! z@BfC~t2}9Gq9xwB0HR)%+Wn)p{PeT_J* z(1|7&aUHtg^k!LJ>Cf$h95IL7rkS!QHePE8d8n6FXBb+LA9MBD%5!xip~k_<=6|A4 zr{{pAgOGHOv#U5omQKt#rq$XIZ)WSuHNhf}U;XqIW0=y)U%Q{w`6EvxaVbssC0|~# z2chS=tK--(`cGCNnF)H(FTOX$Nr7CSB%k7jsvNsA!o*p_ppA@6v7{+A1-0v@ZORKT z1bkg*{njAvui={Fh|n{bs+N(RKXYre74ansJUlavKTHvJeSR!^<2>aqZ&w7=8z{Rs7O9vkQwQvt13T zFvMK>d1B~veIKR5+p+wMX6mxRE(}EekoCFv)xQ(7R%W}y*nbr=bM#$RSsfBPMnE`d zwy?26a~{W|g$W*yHZnJpb0g;}&6U+*CW}k3T%Ryi)zvsz9r7HW?4y){roqCVMpz&= zCMbB+hH)rP1pIG{UCPZQ^_bv7sK-hf+u>f+7SC=I{KuBf=DzzoWl7S`YTzAzYO`$F zRt=0S(pA@&>%zrV^`KNB`!#ND!ntwvVXANjk-A)5k$Iov)Bhtjg^o!$;8KVg(#3ms z8ETU{J15(cX*~i^?w^{8adLH}0_W`GI5jNcIfM}H5%_)gbClh3HCc~$3z$ECuzT+( z@otH?Jh~hBC{FD-84q=QdPOa85MfzMhPztXy-s)9Z(W>KF!oSBeZoFBlDS)MVCbBH z%dVQl!$_ozbd-5SvUb(3`@1#d7)SBWpSCz+A>mN`xpg8I=ka~mXKrA6XY$Gd<`}(S z-_3A|#6ETZ+ay1H)1-fn6#2-t(#H?q7=d>oe0a_}8otlB{sN^O_ud=VC+`j)LYZ{E zzs&j2bMNygp?^}2<@dkEaCKrVy|s7{DD~<>Aj6`Q*c^L$f*1bCT4&NaToI5Ia{X*@ zjju^XNr_$fH}+==`@%M*`+9AjRohs<*u_m)p|)?0h3ETLD(=No+vj6AjBR}RLDluR z<~e?;@0|7#hz>*!WXwJ_Cnq|fSI{F=Hy z-UFw`M(cDH&ig=mf+ja;1MIlI`|fi-t#WD>I$0#wjXc0Ste<^c(qtt3lGvsZA>{h) z>DIwunnkjbQMQ#TLGq%+NArHJcFf^b6MJ#H8^;kusup7_{!>8CzdA!KftT7NVyK@x zWwHL}iS4}Da`f>E#_h4?|(7$(&!mx3?X5F138dZ#PXXy%O zdD>5B=TxN!2fM}lFTE#e)<+)R*i9$nb)_FkPsx8rlQVUHFQh{o^R(Gi#g(a19&-nOt8rB82iF)Mvi!x6%h4dq5UJqFToTL4cGx z3rs|1(DE>6_+bS-kmb9uwCYUHRt2&5jc{#hi{_r;`_qJfIA+=!I`eY$7h_|gz>!Gh z6yz*SvZGu`mc_&&Vzt4?8|t8qd$G~1f?4UHXNwiuuONjen%bjo*L>;pUnbgJMAs7UyMQ6dRy-?CG|hPLfjcZkIR0eBkwD&j752aOyXqJ zH}(oC&l~gf(w|AyEL-;mDM`1NIvY`$H2r?Cgpd$4toML@tJe?l%ra_#eUe`WKo6d! zIg(PL2HE(8ItW7g`Q{3Uwhl^#huHbA{R<^aJ|kZU_vXqco#M4Wt|S8hR2NHde+Xpg z2iPvA4#vOuqw1qqkAT6sw>?O3r772z3nviuoqC?Dczu+)H}+sWJvNP!|J+CGpXcZ) ztc`?PCMWuQvxe)SP@>IbbL>R9AR>AoD%v6C`@hxE1pZmm+i1tmwEElgkR-c6aPk62 zL}kcggMgctdLT>%kKbXg`&L0Kw%W-m7JzWa)fq$&3Hd<4$kCux#?F9n(z@@~pEf0$ za-t8x@z8m@7ev_$An5ur&5dB*8~?&9*yx|AK?hj-vaI{kfaSyS?QiT+>^!OM}nqAFd#%z#RN!KUFw z-L|P7o7sp`ohAS%=9<;DiQyKytq&c5MMvSJM}lZRrV-9;pSBL-mS^wQfx5Z`(7Zw@ zNNXIQGUz`~<#^QQ-wN>r#)E4ArF&wsmRM?OJt~k!uCACZY93e)w5gu1S!XdTqXc|v z2W@KZ|FK3Os+5{4R3(vjkt8o-n;bM_(a@=H@-(pDM&?^0N>F?r>(7%30&!Tcq#Ew_ zJs3tuambrB=6p7V9GtRhKeC7BTiSoW&Kfv2Dtj7d#_8uR2Y|_ikoT}3a zPZ&Rlg>V7;ocx)y|(sTYdG2@Teoj82+(?F=#eEsPCj&56Ch3;d>+dqh3 zx~oCybMzYUXe=LE0-wS?bXQZqKi4^y5P8gTlHSK+GKA^!xa8l3Js<+Pe8F#RHGJFZ zpCG1_@V4)SmInTFAc%(fnI!*`uA^`d`v*E_g##CFG6p2`2H73C%6P^RICXh)b}VG; za7Tm4Q^fMHu6wciKg!DFxB# z#=@MU*jGa9ZLWF)qtQ!!8PYAvaT4i-&IZhj^6+RyA2wq!a3r?h<(o8Y1j7R`|f*cdE*!Tnz=vW zOiKd7BvL2(fUlr{R7;SEW&tn0wkL#!4XUZkhN1cH>9FJg9o+$TBxEwM0H zjQElTRkIUV&YZe3TGXpse7=5u$bhnvxOIAXv^1}?La;Z(gbDm1=^ESV8oTQGAl=e% z4F00K;el56878cRlwGJCl?_P#Q`tHB_s|Sc%{T55#qaO;Tyj0Q6|}-KsGQ>uq?qZh zfD>gzj|j}hv@5YJFxX{d3y*RNOjUn+32~nnonRd8FEHrFR)ucRd3ili(E#xpqVU9jU$9$D?!<#lKM{@8gCD{xgzOr6GOKvP^Eoo4-7)FtBI`a-;UH z&cGmARr(t{k>K;AtiAJCZGHZr@TKw}WC zno%L-t`v5Mi9bc7ueuOQn$QhJTO>Z>qu6n(N;Q0sil=8@gcsl&O|q*JUwqo%h-dpw8OF4Z2-Hzs9zD=VPBxja+a^iuNP4hl45_YzqapOfC7!gKK4znKa5 zo&ljYwbQo0jEt~~Z=Ml9Xz&<$RH;2+&%ggR+<@DD!5HuK>qq!PDXUN3D&Af(A$+>j zqup@1xj{5SKu+pb(lIz2uQ=eqX$>C#Ly#*brIvvQ!^La(gR3Zi4;@PVJ@`ULJQ+(v zSFf*9T$unn%8y#B#K--3=oueH$abk+?9`H4##x)G2sk?vjfX#N<>D_JF*huufV1t# z;^Zzk$6;}}cFJN(W58>9_@@77NnSU^aP~I%r*z}gFC#1OF86nk3Hr6I0QpNGI~jsy zyoVp{ulQW8pQYy-fAhnY@|`4{YP=00pXg;K%Zh2s=qM8Z;^LH3mwNSZ(V@*Dj%eYA z!l?v{kDakBv@S8@;HWcmyC(bG)AZSCz2j0ZR58)2rM+OAG%u)7eH4>*^TXp)`X7hb zy=-D-ZKH(~1md}yEsf*bh=V5rK*C;Ei7cKjo&7W1JbXM^SKz5_fF&Dhdy+v;)zEYFM{u^dlEANH&T}7V!$=qBFJ+`jx4l9MOa_x7 z=p?{Z8J z;U!<4v8oApMl^k8X6Zgtxnr*1foYZmmj@^f*|&KI|( z<(WkU4B96hY>Htwv3j|2^bY%?%na}{24^naA;#bL7*WAuZNk`l2SNyZa1}s9M;3 z<`x?&xewhfjnW&OOYlq^uFESH8)x2Px)J=@BUDw+VYZH3=GGhNN^&LU7@g5hQtsCd zwL^CdBiJxO!E+``SH+_%=V1KfmJ9>u?vJl4F|nbXJUtcO6!QlPHhja9%lTl+8<7TqNQ1t_BOa_CzUwkTabvdF}~YN&M|*w=sMJ;o8l15AK6S@q$a= zS$qT_=w2$3wzYQnvA`mrqv=*9T6bx$We#xg`UN2R=FB1(^52Ua>rmFk^Yyv*<_S;@ z*&vqCQ_^xRrcUBGo5q(00GIbVCTj4Vjm1*%{S2%Dx%K-O*#mm^R44=+Hy z)S9T|Jk_2m72a#l=uemd@yN$<5x}I?h%~p@c`YjBE|IrcRNH2Mn>I0>Hw0X`&vVqW z%Y1%Ac={=Wv~(@L^MzJFw@#_6BZlvgONA*_7D`PsJI`1JiKO$ZEw&_{PV~=~+wxU7 z_^`j(ggR1pvb+8~K%0+q-roAaIO^DyTLU`~M|j9~Cd+qvG=c|g;nrI81Co0*Ha+D3 z_VpEVX6WSTixcwLc;EQ7|Ier6&wi<#C0rm#vc1})H-H>K{*!a;BGHY!RNVH`#~GFO z-@Z+*oIBU}NWb#6mHBI;T30GBp!6>CAZ~SDP8ZD!Ha2a0_q-<^LW$qmwfUw7oB#Na z4%Zza-LFQFk*>cPVwtX4V#Yq?j-HY|Y`YQkZP%t0ei$Cm(W-9p2vl;PzGk_zs5^|0ZWUieZ+Y=k#Q9IvSfss;m~R zMm~~OMibqvRjs@1ldl!q36fM=Rjp3xpVX6N=XC_}1`f^k>GlI(zv=YO4-uLQo|@(N z{8Xp%dZCI+)6(=zB+^mVM!1c2AI#I8XvAc%_F{D%ODpoQ$;GnXqxQRj}eB>o+-2IFkXi-Vm7wf^`W?GKhu?!(7!3N#|PDteq(s{(ncGd(?0 z^aJTA>Q7Io&gL{-jXOX2c}YF=eg7WRyMrlRo6=7G+wtb=X0fDK`IS;Id#^gcK?av& zt*lmHu7J$k!T)({}K{~Pf&tSRTW@bkW=u$5rgmjt>>SjoqO)bj{n%aORm3%J3*+m zn(5K@pDVxQ#-P=bZU2nC>y$uAi*Ww^`-I;{;Pj*YX#%eDYckFm4jtDW`9lr>7XGWh ztS#sga0}S>=X}lW6R4+0`mb%?**RU)TSmy3Mg6Z2rj0*g%#k{A7_v9)WkGi{IgzdU zX&#Cs9Gvt@gik7ASeu>q*uD160lS-2vi6(aMSQ;Rb ze2)2dWX@SG^U%73{@a_f<&QY$-|%pur@(>hV`u*|J=Qs#B;ioxYgYd=g5Q;g(KavC zIeB0Hz5l(BHh$afQVelVE6e<{-zp##$kQAkJ2bCeZ3ht}aV*FzwsRhAu*Y3*W$C4d z&Iv1eIYhF6pud3>GD*sQ`k)y>{Vvh92`0`p=38*)XVQ-aEZEVC+=qWU?hWZf3XeJ> z$PCa9k%<_izcGypEEDhg0ZDCv+GNFv&?0fR$p=a^%_=uAemIe<$`P^!z+CxI5Y$MA z(EeVJRaId$?k15cdCYaG8p|&Q$+qOGcU>n?g-0}YWt467ruB6c*=pg_GQb;r&9!!+ zRS6;U^??yMP64vzemkz_&uF7FOr%s<8}K=xT%`kCnF8o+1aBT&ybdSe{ZD8yQK`CF z+3#GYHp=>v&xCqJF0l18z(W{83jw%K^$3t)^Y`j1cPzc4?Pgv{y5JlGJO0E&Pb-jX z5b*%>yZJs81|m}akX0TmzX=su{0sIob8roU?h|-m*JF*1ZUq#Y9I7=-rJ>GQ_s)mRuV|pKA)A>jQFcvZebKMgj7^s$S|uS^snmng!&M8+b-gVx zPXG7`!AL!|e1^S`(hY%#J1qTnM5qrH`17r_Q+vvToaG>SLzEQ2no}l4X_X}4tK<@i z04?|6->C#vWJ3diwSQ${5(C6NQ4?g)XZQK4R+AueK=dNV@?=|uShP^XJU0OtU0GxO z?b-3sT40uz_F>!dPy=9JUxW#92C5_98VhB-H+1ocZ5xE%7GFo2p}8xl0*GRE<>ldb z$1fmPYohv%bcWYnwVOqjLH*f`n8tzLcJK&LGPD;~)WN`#cmdRO-@uXju$_-CI>B5& zLz8@JTbx}llX4FvfbHvx@9@`07eE*RLa%P=Yb-Q-fN5CuRxa#Y^(H)ud;<@bqmOO7 zHDCk80c_M3zXMP5U(MvdZni`RO%>{DL*>?nLS!O?ua zx0~%+Areq(qOw2{oG$4~D|N0W?$|+&Tw7gdb#|uz*tglP^}Ps0dyxy{Kl)`zin%TE zm=kAhcRs6!+Yo7f|4b=F1jK(x)-jjC?DW50-$hRhS5F|>gR-gkhkQ4wHuYZ_|Nc{J ztj*KwKRWI8Hq$~eKV}yCX6Hy6QRc1a?nr%x*foY-KzyI>KKi$yb8c29-l~;#dLHMD zFP_}jEh>h$O%DctAnidtecKY5d&S(YK4^1? zsMot(?6;71`MF+e<4aqsfFs&(hb#(=be#w?_n7oaMa@hqF@1l-;WD7fc4S*9P0OCQ z*YvE7p6QKkb%-gXhQ+h~y=OHmwg4Bz%_6ORKlWo6GAJTGv;D`=i?2$ozop`fIn=Zi zN@Sd#f1UMsLXh3g=)XNB9DLo>N742lcH@+P2*f8FqM5mjazn}K zveBdQ>xUX6#g3hAITT{NiL&0e>DA_yy}hh8nRFV>l2Jc(E}b*5k(+kTVFwqg=)@*& z>#*;-7dRi*8?NBA?~B5@<3Ljis^xxw{Ve2-gypP3nhtq9M(=e&_s-ySZ(_=<=SGkt z%iob|ics`AruLo|H3O9;eVZQ2 zx8YCgX%R3B{AIu~srLCMoU$EhRvZ#g(2E1$WvYKj`Y50m_cySC^2#7H{xm z>&dQTIf|@9lJs~WW06H+C$?rY03d4;>K&fGNKv|gqb3JyHpg76_V=TJc#wTdtS)Z5 zh^&9RoXab_wwSpJ%I82hsx=#+Ns;9f*Iz06#?WUK<^$hIp5A?cx5<$0=@+5J$>iAl zTFae}xN}u05?RKD*WH9rhyOdQf>P`GSQB*oi{JX19+l838he#iEygGD_Mf~hyyGa+ zm4apTRFs(T_Es$YO;7G?6_&o{)u)z9Y@am%K8y58XtUzos;qiz*N#R@yu&s2)3@&Y zopbnUD2lY+Er*%+Zx3GnV#fGoq!)GKCI&ergeb2|kD%QlxtNzq2pr@MWvdWvG!Cf= zs`k}s>(1u;mBFU=41qHo@dj3Mu@?N)7}V2YA+H4%gKWDpulM?Bhx2|^8o(YDuQ{dX znpM!W1;{$?PlddSouYjm)5TCC{767Oq)_qcEN1$)-D#T92)vgjhtAo^UPcu@+x)Iu z^|(bRmRn>udP)V-XZRnq>Dcy#$p}qP)X*mgNfCaNS5BVTwm8w2glUVxGHF8IGeNpDb0#O9QV=`y z3m5_vM=mGYs^;&>;j-Vi_=g9teB)|hg#>gQbqn+#|9-?EZ)WMF(MJ*6HlcppiR1Ub zcnp6fpRrW3OyfIsobSw>q~Cm6Rd~zm`ZF#ljROcO7cqnZQj;-xcE2mb@d4Cv;X)J=NW#-8hf(Y>PMfPhO{OK8wsn$U{|VkXF0UkD@wHJ_bx>fIc{!{iRMFiK*C_R|pMJN| zqit;Uh%N1D3}cWXb*4-N%7_pNft1OXc$xG>*uM&2AY*lhW?8^VI=g-tbxuaD?H@z_ zcW^@z&&yFP@bujPzm);l$3%}GpQ7Rib?ya2y*#k`dmJ=$-J%u%Fge_Uim<6%Jf)ZR zw8DpqC?O~M?O+dgB9vqy;tsgYocliAc{jg?`uq-UM);(D%J8~V-&y2l%BKJ3EjU{s zz*hvcBn7Qb>*EVU0zjJyYlc3E$N{%6E6@oj6S(RHy>H*PvVgePtqT4>G3+!D;vFGu zTV(tfr*;LpqTFvR`6zw4s&EJOR32(xj+;MQLdghnJ*)|M%>bNc`)EucL}k2Z^r8RJ z2uRr?GX{8V5E-W(c(ob-iN*-w0yq~1QS_jNP#;uAN#jpyKnvWDR1-p-Q&zKIQ$XF_ z{`dGxDVg8wlLIqA_sIt5LYC1J_o5GDC*<|e3pH(LqIjlu)}nT0Vl(h08dA1wfB$(YMa(E&lP?-@8{&9E;4Sn~ z$KH(xdqBmHx%D#dO7lt|OeAKFm<0^F2hEUAC4eo&3;XA?BhyEz?qs6Jl@hZpC=){` zG~nnhPi-IYv~NHWDYvcq`nz*;KF};x;xT%~D3Qc~`Evs2qto)B{uNxffzM#Ez3zyt z;U7{%3A9Pe>}+FKGyjw-uZ#9hVJIItLXc$t3*6NAd9qcs7`gKO!bmsAp7HH9$~7LI zs~ml)1YN!^h`R53cok+n7v5>*^E;2|lmeOLJTo~^-829pmx87`tv8zYu+nj`rusCm z{lW*LmrK+M?auG7k42?@+M-sk{q87hy;6?h_k_E{bvNp+BZBJw1!_4MOkIk9>i3eY z!B0T}Y+GAo-4)VBm8<-%5yeb>idA8*!$U&BxT(g7#YanA&^ z*LWxr%7+Gpf{7S>IqUqlLm|7C>i3e<1AF_2HZ=FM5$Uw2A#a*Z_Z`D<`0OO+ro*OkHrG{VhLE2?b zB0I|-IyDN~stCmz6~8YQK>0BVh7Lv@580MVAloia9i8!Fe`*WB!Cl7SsmrSme(QdY zJrY^B)u-RtZ*OH2d6v8QB+Go|vtqo3Z!>=uY=0NHVEcoy=%mnU)Bib^mYEzQi_!ES zY){o&neT8qh*CrNjr7FxOZ^VVP@7Qam7!rYtA+{OY&w<5Qv;!%F5vp~N;3)teACK; z2JlUpKQ9b5Jm@0IGf~n_u$>0wMcC}X+!dQ!&>s2?- zkhcKjMO?QmLTmTO;Ei=BQbp-D9-&;wp;;D{K1d_B0hk?sp~@hGOMc&UJ!Vm;GHfT0Op`;@q6b80U$xbMP85_h4pi=3xoIXjC@fTCuJ4$&`)<>!V zE^ar&`^Q4ek4SwZ1%Q(xY$4U`7ajU}{souVhstVjK7VjKg8H{^b*Xc4n(U3-&spSt zdZ8n5r5&7htH<$sPiAw7JS7L25h{(c&3bc&xKZ0VU|u`~QqH$2gh(WlTL&glyeE0tw4$D8-R! zgcNt)Kj+ zdIs^Vf;p6Aya*eI6);=R>*v@+7H0c~wc*(a>YO2;w@ty)Lvlvb<&lY>?>@luSe$@u z$=1(`%rBofgmhAJOaSa}Q{`DJI&CTg-~yG_HAf=bB2QES{CO`Vh~Su6-c1Kd+GO`3 z8Fvai^d%=0S2^|m`OAs3DBi?H`bNfU4iv`|D|YbpBV%_?K}`-ih~QBmp?cNHevl8& zsfj@_vDc094ZptUMS>5v{D`_p*Z-F9J9L} z+Ey*7J2v>0U+}0bt10Cwo~KFym>!J%&5*V z2-bEeYf%Ad_$_KF0Lr&lyya@IT^`{o1?3qUFAOeTd`J#rQtO$yPDoFh0R+@|Tk;^L zE9;gR*vC&bslam?#)JfFp!-RtNfzuT`tT@&Xfa)(=rdN9U`UJjijg1@YWIj2PO9SoeC&%={DA?12?T;4BOLjC+;i^Z?|!P5}ZBZ2X9ZiaxI z4GOIAL@x~&e6d{F$xdLgW8S?Npbfs)}PP^-{PYzlvTAQZgj;Y}l>zqV~x zyNzfTCcu0FmA5_nDI>+6?&XBEjf>A-ezxyg5&8e1e3xnqMUiK8z>nvb@&f3v$d?O( zk$6W4LP;ZX)pi*uM>#D1WnTn0jWa~vDWm*^o%>Fvz<`%8#XM87`+r({?|7>J@PGKw zP^oCpP@JS>Hz^Tql7@`zB8hU4eay5pj0lz0K#`G=V^fJDqhrOfA}g!RGVkY0pYQMf zJ?_VSKkoaF+drSrBgZ-K^M1cx*Xz2j=eWMCHd(oM%{gNx>+R*>3yTi(J? zw&11ofH=ntb7*?(ID^KrIyQ*V#Gob1Riq9tSMlaDq+IyA(g7br^~1WG{Uk{6PZ6`E zn>Fv9qo8bvCnUBt?-mv6JGBR*pGgO4ETEwl%zdKJh=pt)a{c-8qu-3_NZ0lKTqAES zUel`9JN0o<3EQUwqXWUyla*Oz%`%j^%V!^}lE*akv03bw5%^ERpJ_#{ZW05iz4jWO z&>6JQX~*e~15U@*N?++xYjB^La&TZ3MknfLNq?4}?yD+{AM2?tkE)y~Ii|qFt61}E zteM&0sCK{;0w9u7?`FqN^pq528z=NZ^39wW-AbhK0C)F{{<4mr}sY95@!j5&}N0( z_Usz#6lPS7iJXa!yllwp5@A=PeTOmiv~JYWCNK|Foql^rY69fS7QL@ax9RClW4BI= z_uiAJmyyg_@!`59-@$$Vy3Yp@{7ylN(qMD$?k=j2gkG1vW+FctEfgPa#OB!>Ns0t; zm`~2(SgJlf`B(pqGgDbOgXnS$GDl7Jr}4O{ls@ax_>_zf2`?kxGPm0oi^#J^rILvN#%zIgnofNLZ& zps}YTuu}5LD%XP%7tP=*#Veyf$Z04W#1({2(k$r`T>f;GnC2JNn4r-3lnJ7QQGavp zozl9c6v57y5s`hYO%rZLOCh$~`ESk5eTqj~?!7HyoAD7?M-d4T{8%bpoqo|^5#rf* ze@B@Yxe0@9<$OE+l1*nbhojd>%swon$gpk)8wTtF`6xovjDHO&%D$ON8-Ntw8gs!3 z5VYPx@e=P)z{zrb_HW{D96_1afCQj-|4YSnl)3ykzvk)}T-HNd;S56HiR1)yLmuo~ zOj(x`wm0e~XU^=GYng3)9{$mD8Pvo~z-A-$mlMsf5IGw2kiIIdn@?f(mn&E#95pKm zs$%>dGfd2ix}c1D>&un(6zUuV&)Iv^3=(pJVgt!Gp|$#n3b+QFxxHgQfenS0vQf;& z>P$&z&V42`BpCK>4KjKY@fafN*vR z`N%L>9jNmhDihf}hI$g2RWSy?)-7`C>17)F43E~t8zjl-rdbTt7`na<(${f=sWuUA&7lcI|nHXWI3OMh{wkl{$SCnp!rMu z>7zmx>nW{^XK(x=c3YLpAjl5b6|OPuLL#n)j#Xo57gF1=kV)~AH^^k0liiYid`po zfX~#hdloCPb+{>(nGFShWi>tPE`um%l0ZmI4 z0hjQu@wbnkd#B4Qit+g_)w(I@e>#=)>d+tuh zH#@DKg4xQ9(+0_!gZ`C`@`>{Ae#>{E`Ej)}=5crB%Pf?B3br3xulNk38*sRFE5$RP zUM!V;3i(7gowLSQURo!fol?N|Uubs4Nh)fXo1L}Kq`4V1Yz zM}l;%4BkAg%FTHw5u*Ogv+A{0s_uNsr&a}~9{^w|hRnl?5g|#?Z65(I;8fPP*FyVK99D!>t$(p6mXp^bzw$+e+03yXSgP(SRGD zauBgJh&g^(nuh7jqW8TEACFjQ#IWIY&*HOR{aX28U%2 zXc4@sxh{`uk5DK$(l4;#kI+kNKiJe9bLJ(spyCl$#u+$*%n7tNa8{)cDt8a$1<->1 zsJkw24wMKP{9}V+hjNFEikd&<_xVlLnn-}7ZT zJMyM#vdGy$J@)A062#LVJw3=jRj=+{xhO-VCY=6LWS1FJX!&i5-?EFP{s4PoHAmE{ zY}#cfjVCFMv6%z)o7&4HN*{0RYaZ~{kkXR;5VC}#ce>*;AR7Xx(=IvKWPO8yu_IM>N0)-$8k| zq~heBO?|#eA~kWV(ACbi?!tcZSba|6=)nyGU>JEkEw0!Gc<9m8-6TP)j;b@2W8Z!q zupYhlNv(a!K^+R^bicd|*@Eb%cxeG=nwjp2N}FJF(5a5Gp(+|?e-m47`mx=-w#+Y@ zono~cFHOenq&8KudTLKj{26*EnlaJcw}ekkdKHCx1)J>5dbR~XQm6*&&FERbor|>+ zgP^<0D*IzYQCx`%;?p9~n;ZxBEBK?|TW4V|J@ox{(9ptqa=h6$mL?AfLmv~ z1Hd@yW97^g+V>5z5B(Y{gFj|g6ue5=G9^&Bg>hCnkNiYqFH@Q9d&0*feBx!j;1-7Vk|>u6sqZLu~fnvIeyDW;3=y12Y+=Lx9=3|5T_?L~C% z^tj^qc!WFso`_c2cIhZuW90jrFQ&vP)WSKoDi(~VF7IzFB)xxGyPxRv-F}TG8ffp2 zhR^t2Yxo^mMDiy*-v>RUf>~!WtyldyV@)>l<50|hMb}&-zk@bi zj-#_09BYEe6s@zl&zc6SQ!ciaeZgFJ*@EK0$6I(QejPKiO-@JY{d=T#GiLT(nPiNZ zuM*#~%d9nQXbD$(U+ynf(R$(P1lMzu>5b*?2Pxd&DWubt337Ec+Bpa3cbP#!CQW=C zHQe(cO<9`h4uFad`xa~lsSJa^$S6-r=%iM_;*AvH3{_-BdRCTgEf#v&JTH5ia-3WL zjG=sfjb4o`BrH%MZUl7r+-~9`$ z3eZJ%j<%O@ec54<90`VvS~v5nn>595Ge~ zrhdFR)}eW!R4R3}Mi&o7SvPIny8AC*{?d7IWRxXtHlCq+hS#mpO|UwyyPEP=-M(iR zV_Pf51Bp`2UW+U1=zruoYuYRr7NK;ZvsSdYBDv7U(Sei_|Is|9N9*=neFfJ9%W9=#B_g}!qNuGkX-@L z;&Nt#e6U*)HOH;w%>U@%%Jhno0KxlI0@*(LRVu^umN^Ey-$$z&26n+E>yoZcMs-TO zVRKJ)8dWYzg%e~8>vc~f;BipAIBJIPSE_xV4slMk&S^}roY9?Plp@{qm!pArm5`h@ z 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 literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv new file mode 100644 index 000000000..7a4147171 --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv @@ -0,0 +1,72 @@ +time_s,memory_MB +2.5987625122070312e-05,0.515625 +0.05507612228393555,25.984375 +0.11010503768920898,38.75 +0.16513991355895996,65.90625 +0.22017502784729004,99.765625 +0.2772369384765625,127.859375 +0.33347606658935547,150.5625 +0.3901660442352295,162.34375 +0.446382999420166,168.921875 +0.4980320930480957,176.15625 +0.5519368648529053,187.515625 +0.6069607734680176,197.171875 +0.6619818210601807,203.59375 +0.7170050144195557,214.125 +0.7720298767089844,228.75 +0.8270549774169922,241.484375 +0.8820829391479492,252.40625 +0.9371178150177002,259.359375 +0.9887259006500244,267.5625 +1.0437560081481934,273.140625 +1.0987858772277832,282.5625 +1.1538138389587402,291.71875 +1.2088418006896973,304.8125 +1.2638640403747559,314.4375 +1.318889856338501,323.3125 +1.3739230632781982,330.1875 +1.428952932357788,340.1875 +1.4839799404144287,349.40625 +1.5390000343322754,362.234375 +1.5940289497375488,386.84375 +1.6490559577941895,393.34375 +1.7040929794311523,401.875 +1.7591280937194824,413.421875 +1.8100578784942627,424.671875 +1.8650898933410645,433.421875 +1.9201221466064453,442.453125 +1.9727180004119873,448.71875 +2.0277469158172607,456.65625 +2.07938289642334,463.78125 +2.134410858154297,466.6875 +2.1894419193267822,468.46875 +2.244468927383423,469.9375 +2.298341751098633,476.984375 +2.352308988571167,483.46875 +2.404711961746216,493.546875 +2.458678960800171,498.5625 +2.51370906829834,504.109375 +2.5687568187713623,554.234375 +2.6207189559936523,568.5 +2.675801992416382,570.5625 +2.730849027633667,571.71875 +2.7858810424804688,606.953125 +2.840913772583008,607.0 +2.8959500789642334,619.75 +2.950983762741089,626.984375 +3.006021738052368,626.984375 +3.061053991317749,679.265625 +3.1160879135131836,679.265625 +3.1711227893829346,679.265625 +3.2261528968811035,679.265625 +3.281181812286377,685.21875 +3.33621883392334,685.28125 +3.3894739151000977,685.59375 +3.444511890411377,685.59375 +3.4995598793029785,685.59375 +3.5546109676361084,685.59375 +3.609644889831543,685.609375 +3.664702892303467,685.875 +3.719740867614746,685.90625 +3.774772882461548,685.90625 +3.829810857772827,685.96875 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv new file mode 100644 index 000000000..611db629b --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv @@ -0,0 +1,75 @@ +time_s,memory_MB +3.1948089599609375e-05,0.171875 +0.051419734954833984,22.703125 +0.10647702217102051,32.453125 +0.16150593757629395,41.09375 +0.21654391288757324,79.78125 +0.2781028747558594,120.546875 +0.3287777900695801,139.03125 +0.38186001777648926,154.046875 +0.4347388744354248,162.125 +0.48984694480895996,167.1875 +0.5448818206787109,176.09375 +0.5953888893127441,186.6875 +0.6504178047180176,197.15625 +0.7054398059844971,204.28125 +0.7604677677154541,215.234375 +0.8155057430267334,227.578125 +0.8673849105834961,241.171875 +0.9224140644073486,252.90625 +0.977435827255249,257.328125 +1.0324609279632568,264.34375 +1.0875067710876465,273.40625 +1.1425299644470215,283.34375 +1.1975510120391846,293.515625 +1.2525818347930908,305.09375 +1.3076090812683105,313.84375 +1.3626370429992676,326.78125 +1.4176619052886963,330.953125 +1.4726898670196533,341.328125 +1.5277187824249268,350.453125 +1.5827507972717285,361.953125 +1.635375738143921,381.90625 +1.6904067993164062,392.828125 +1.7454447746276855,402.625 +1.800475835800171,415.46875 +1.8554987907409668,425.6875 +1.9105257987976074,437.03125 +1.9655518531799316,443.609375 +2.020576000213623,448.34375 +2.0756008625030518,458.09375 +2.1306278705596924,465.578125 +2.185661792755127,467.84375 +2.2406938076019287,470.078125 +2.2957160472869873,471.546875 +2.350738763809204,476.28125 +2.405771017074585,486.203125 +2.4599969387054443,495.15625 +2.515030860900879,510.640625 +2.570060968399048,542.390625 +2.6250879764556885,616.515625 +2.677243709564209,629.4375 +2.732282876968384,633.96875 +2.7873167991638184,651.3125 +2.8423609733581543,686.90625 +2.894052743911743,712.484375 +2.949090003967285,713.421875 +3.0041210651397705,715.03125 +3.0591609477996826,715.046875 +3.114189863204956,740.78125 +3.169217824935913,740.78125 +3.22426700592041,740.78125 +3.279294967651367,740.78125 +3.3343358039855957,740.78125 +3.3847107887268066,740.78125 +3.439743995666504,766.46875 +3.494767665863037,773.109375 +3.5498127937316895,773.109375 +3.6048519611358643,773.109375 +3.65989089012146,773.109375 +3.7149298191070557,773.109375 +3.7699670791625977,773.125 +3.824997663497925,773.125 +3.880037784576416,773.140625 +3.935072898864746,773.140625 +3.990103006362915,773.234375 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png new file mode 100644 index 0000000000000000000000000000000000000000..577049471783d6afe7c1b7e3e49e90526ad1ee03 GIT binary patch literal 42639 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 literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png new file mode 100644 index 0000000000000000000000000000000000000000..3c978bea6e50f36995670527750f78e3a6f52634 GIT binary patch literal 47281 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�u1qv!pzE90YdOEL}PZ}BJuq)O0EfX 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 literal 0 HcmV?d00001 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv new file mode 100644 index 000000000..2f05c0a2d --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv @@ -0,0 +1,192 @@ +time_s,memory_MB +2.7894973754882812e-05,0.515625 +0.05098390579223633,20.484375 +0.11100602149963379,31.390625 +0.17103314399719238,40.125 +0.23106098175048828,72.015625 +0.2910888195037842,114.75 +0.3513500690460205,135.796875 +0.4114079475402832,151.453125 +0.468533992767334,160.34375 +0.5202350616455078,166.328125 +0.5802559852600098,174.640625 +0.64028000831604,186.78125 +0.7003037929534912,195.484375 +0.7603390216827393,202.03125 +0.8203690052032471,213.75 +0.8804049491882324,221.234375 +0.9404540061950684,235.40625 +1.0004830360412598,245.28125 +1.0605151653289795,251.859375 +1.120548963546753,258.078125 +1.1805791854858398,262.453125 +1.2406079769134521,271.96875 +1.3006348609924316,276.53125 +1.3606610298156738,282.6875 +1.420685052871704,290.078125 +1.4807169437408447,299.40625 +1.5407490730285645,309.59375 +1.600773811340332,316.75 +1.6608059406280518,328.71875 +1.7208359241485596,333.0625 +1.7808630466461182,341.203125 +1.8408870697021484,347.8125 +1.9009130001068115,355.25 +1.9609458446502686,363.34375 +2.0136098861694336,373.5625 +2.073683023452759,389.4375 +2.1337289810180664,401.3125 +2.1937599182128906,408.046875 +2.25378680229187,417.609375 +2.313817024230957,427.125 +2.3738460540771484,434.265625 +2.4338738918304443,440.453125 +2.4939000606536865,451.1875 +2.553926944732666,457.359375 +2.6139578819274902,460.984375 +2.673983097076416,466.0625 +2.7340140342712402,468.109375 +2.7940380573272705,469.640625 +2.854059934616089,476.625 +2.914083957672119,488.671875 +2.9655659198760986,493.671875 +3.021054983139038,506.203125 +3.0722758769989014,509.875 +3.132309913635254,510.03125 +3.184264898300171,510.265625 +3.244292974472046,515.546875 +3.304331064224243,676.09375 +3.354951858520508,877.5 +3.4149909019470215,987.90625 +3.4750280380249023,1011.1875 +3.5350589752197266,892.140625 +3.5869460105895996,989.046875 +3.6469919681549072,1044.3125 +3.707026958465576,1055.265625 +3.767058849334717,1055.265625 +3.8270998001098633,964.859375 +3.887136936187744,1040.5625 +3.9471828937530518,1066.015625 +4.007214784622192,1066.015625 +4.067253112792969,1070.953125 +4.127281904220581,1089.890625 +4.187314033508301,1105.953125 +4.247349977493286,1123.15625 +4.307376861572266,1020.734375 +4.36740779876709,1134.109375 +4.42743706703186,1154.453125 +4.487468957901001,1157.84375 +4.5475099086761475,1157.859375 +4.607547998428345,1052.8125 +4.667582988739014,1052.84375 +4.727622985839844,1142.109375 +4.778936147689819,1142.125 +4.8389739990234375,1142.125 +4.8990159034729,1142.140625 +4.959053039550781,1172.796875 +5.010929822921753,1187.453125 +5.070976972579956,1231.5625 +5.122921943664551,1231.59375 +5.18294882774353,1103.796875 +5.242978096008301,1170.84375 +5.303008079528809,1178.6875 +5.363039970397949,1178.703125 +5.423080921173096,1207.53125 +5.4831249713897705,1091.515625 +5.543152809143066,1170.046875 +5.6031858921051025,1197.296875 +5.654855966567993,1213.328125 +5.7069079875946045,1085.59375 +5.764301061630249,1158.03125 +5.8243348598480225,1173.078125 +5.884387731552124,1208.015625 +5.936255931854248,1208.015625 +5.996281862258911,1086.609375 +6.056315898895264,1170.0 +6.116353988647461,1214.359375 +6.176386117935181,1214.359375 +6.236418962478638,1086.375 +6.296444892883301,1137.5 +6.356472015380859,1209.28125 +6.4165198802948,1209.3125 +6.476553916931152,1209.3125 +6.536579847335815,1082.4375 +6.596611738204956,1135.40625 +6.65663480758667,1136.0625 +6.7166619300842285,1136.0625 +6.776684999465942,1136.140625 +6.83671498298645,1136.140625 +6.896742820739746,1136.28125 +6.956768989562988,1172.5 +7.01680588722229,1206.984375 +7.0768351554870605,1206.984375 +7.136858940124512,1079.140625 +7.1906208992004395,1119.53125 +7.24291205406189,1185.625 +7.3029608726501465,1231.359375 +7.362997055053711,1231.359375 +7.423030138015747,1103.5625 +7.483073949813843,1171.609375 +7.543118953704834,1214.578125 +7.603178024291992,1215.40625 +7.653575897216797,1215.421875 +7.713608026504517,1180.046875 +7.7736358642578125,1205.125 +7.833667755126953,1221.984375 +7.893693923950195,1221.984375 +7.953717947006226,1102.765625 +8.01374888420105,1201.5 +8.07378101348877,1201.53125 +8.133811950683594,1201.53125 +8.193838834762573,1201.53125 +8.253865003585815,1201.53125 +8.313893795013428,1201.53125 +8.373925924301147,1211.59375 +8.43395209312439,1211.59375 +8.493993997573853,1114.140625 +8.544235944747925,1205.90625 +8.604276895523071,1205.90625 +8.66107177734375,1205.90625 +8.721114873886108,1205.984375 +8.773550748825073,1206.0 +8.825335025787354,1206.015625 +8.885371923446655,1259.34375 +8.94540810585022,1259.390625 +9.005429983139038,1131.765625 +9.06546401977539,1205.1875 +9.125511884689331,1210.109375 +9.17622995376587,1210.109375 +9.236270904541016,1210.125 +9.28821611404419,1210.1875 +9.348242998123169,1210.28125 +9.408273935317993,1210.28125 +9.468300104141235,1210.28125 +9.528320074081421,1210.28125 +9.583738803863525,1210.28125 +9.643770933151245,1229.984375 +9.703819036483765,1235.625 +9.75487995147705,1235.625 +9.814916849136353,1156.1875 +9.874944925308228,1209.203125 +9.934991836547852,1249.203125 +9.986894130706787,1249.296875 +10.046926736831665,1123.3125 +10.098874807357788,1176.1875 +10.158918857574463,1183.796875 +10.21894884109497,1183.796875 +10.278982877731323,1183.796875 +10.330873966217041,1183.796875 +10.390896797180176,1183.90625 +10.450926065444946,1184.84375 +10.510953903198242,1184.84375 +10.570990085601807,1184.84375 +10.631033897399902,1184.84375 +10.691067934036255,1184.84375 +10.751112937927246,1184.84375 +10.811145067214966,1184.84375 +10.86421513557434,1184.859375 +10.92424988746643,1184.921875 +10.984280109405518,1184.96875 +11.044331073760986,1184.96875 +11.096199035644531,1185.046875 +11.156227827072144,1202.78125 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv new file mode 100644 index 000000000..4e01b1438 --- /dev/null +++ b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv @@ -0,0 +1,672 @@ +time_s,memory_MB +4.100799560546875e-05,0.125 +0.060099124908447266,26.453125 +0.11203312873840332,39.15625 +0.17206788063049316,71.765625 +0.2240431308746338,104.28125 +0.28447604179382324,133.15625 +0.3431241512298584,151.5 +0.4075779914855957,162.015625 +0.46924614906311035,169.75 +0.5234909057617188,175.671875 +0.5760300159454346,188.109375 +0.6360540390014648,199.671875 +0.6960771083831787,206.234375 +0.7560992240905762,214.625 +0.8161249160766602,235.78125 +0.8761579990386963,248.109375 +0.928023099899292,255.015625 +0.9880521297454834,260.125 +1.048086166381836,272.046875 +1.1081140041351318,280.4375 +1.168138027191162,290.421875 +1.228165864944458,304.09375 +1.2882120609283447,313.828125 +1.3386940956115723,323.859375 +1.3987281322479248,330.890625 +1.4587531089782715,342.109375 +1.5187809467315674,353.578125 +1.578813076019287,368.265625 +1.6293561458587646,389.203125 +1.6893880367279053,402.171875 +1.7494218349456787,407.53125 +1.8000259399414062,417.921875 +1.8600609302520752,430.28125 +1.9120211601257324,439.28125 +1.972053050994873,444.515625 +2.0240190029144287,451.359375 +2.0840489864349365,462.828125 +2.1440751552581787,468.75 +2.204102039337158,469.1875 +2.264129161834717,470.796875 +2.3241560459136963,477.859375 +2.3817832469940186,490.203125 +2.440110921859741,498.953125 +2.490684986114502,514.4375 +2.5507171154022217,553.328125 +2.6026699542999268,558.25 +2.6627140045166016,558.34375 +2.722743034362793,560.03125 +2.7827699184417725,560.828125 +2.8346681594848633,562.59375 +2.894688129425049,564.484375 +2.954700231552124,564.90625 +3.014719009399414,568.015625 +3.0747339725494385,569.015625 +3.1347548961639404,569.71875 +3.1866610050201416,570.328125 +3.2466819286346436,571.40625 +3.29866099357605,571.8125 +3.358680248260498,573.265625 +3.418701171875,574.078125 +3.4787259101867676,577.015625 +3.538743019104004,578.890625 +3.5987548828125,580.28125 +3.6587700843811035,581.5625 +3.718787908554077,582.546875 +3.7788031101226807,585.046875 +3.838818073272705,586.609375 +3.898839235305786,587.734375 +3.949341058731079,588.71875 +4.009371995925903,588.515625 +4.0613250732421875,589.53125 +4.121340990066528,590.8125 +4.1813578605651855,591.453125 +4.241374969482422,591.765625 +4.301399230957031,592.484375 +4.361423015594482,592.5 +4.421440124511719,593.171875 +4.481463193893433,593.453125 +4.541481971740723,593.921875 +4.60149621963501,593.921875 +4.661512136459351,594.765625 +4.721528053283691,594.921875 +4.781545162200928,595.640625 +4.8415608406066895,596.265625 +4.901579141616821,597.03125 +4.961592197418213,597.1875 +5.021605014801025,597.65625 +5.081624269485474,599.0 +5.141639947891235,599.34375 +5.201669931411743,599.46875 +5.261696100234985,599.875 +5.321712017059326,600.21875 +5.3817291259765625,600.234375 +5.44175386428833,601.28125 +5.50177001953125,601.296875 +5.561785936355591,601.296875 +5.621803045272827,602.15625 +5.681822061538696,602.296875 +5.741851091384888,603.3125 +5.791975021362305,604.171875 +5.851997137069702,604.546875 +5.903970956802368,604.578125 +5.963990211486816,604.578125 +6.024017095565796,606.828125 +6.084028959274292,607.71875 +6.144045114517212,607.953125 +6.204057931900024,607.953125 +6.264074087142944,608.421875 +6.32409405708313,608.84375 +6.38411808013916,609.5 +6.444155931472778,609.625 +6.504181146621704,610.046875 +6.56420111656189,610.046875 +6.624215126037598,610.046875 +6.684231996536255,610.59375 +6.74425196647644,611.0625 +6.80426812171936,611.546875 +6.864284038543701,612.03125 +6.924301862716675,612.234375 +6.984320163726807,612.234375 +7.044347047805786,613.25 +7.1043641567230225,613.296875 +7.164381980895996,613.3125 +7.224400043487549,613.890625 +7.284415006637573,614.25 +7.344436168670654,614.953125 +7.4044508934021,615.171875 +7.46447491645813,615.34375 +7.514623165130615,616.6875 +7.57464599609375,616.734375 +7.634675025939941,616.765625 +7.694701194763184,617.328125 +7.754725933074951,617.328125 +7.805289030075073,617.921875 +7.865311145782471,617.921875 +7.925325155258179,617.921875 +7.9853410720825195,618.109375 +8.045356035232544,619.828125 +8.105375051498413,619.828125 +8.157292127609253,620.59375 +8.217311143875122,621.515625 +8.27732801437378,621.9375 +8.337346076965332,621.984375 +8.397361040115356,623.78125 +8.457381010055542,624.171875 +8.51739501953125,625.203125 +8.577407121658325,625.21875 +8.637421131134033,625.671875 +8.69286298751831,626.28125 +8.743943929672241,626.28125 +8.803966045379639,626.375 +8.863983869552612,626.53125 +8.924020051956177,626.53125 +8.984040975570679,626.796875 +9.044060945510864,627.03125 +9.095943927764893,628.21875 +9.155963897705078,628.75 +9.215978145599365,628.75 +9.275995969772339,629.359375 +9.336011171340942,629.375 +9.396032094955444,630.96875 +9.456048011779785,631.125 +9.516064167022705,631.34375 +9.576082944869995,631.9375 +9.63610291481018,633.296875 +9.696125984191895,633.59375 +9.756145000457764,634.15625 +9.816160202026367,635.53125 +9.876180171966553,636.28125 +9.936195135116577,636.609375 +9.996208906173706,636.8125 +10.056230068206787,636.8125 +10.11626410484314,637.59375 +10.176299095153809,637.5 +10.236323833465576,637.640625 +10.296342134475708,638.359375 +10.356359004974365,639.265625 +10.416381120681763,640.875 +10.466602087020874,640.921875 +10.52662992477417,641.71875 +10.578598022460938,642.484375 +10.638617038726807,643.28125 +10.698632001876831,643.53125 +10.758648872375488,644.09375 +10.818665027618408,645.34375 +10.878683090209961,645.765625 +10.938702821731567,645.984375 +10.989261865615845,647.140625 +11.049276113510132,647.3125 +11.109291076660156,647.484375 +11.169309139251709,648.109375 +11.229324102401733,648.78125 +11.289345026016235,648.890625 +11.349376201629639,648.890625 +11.409401893615723,648.890625 +11.46942400932312,649.96875 +11.519921064376831,650.515625 +11.579939842224121,650.625 +11.639958143234253,651.0625 +11.699980020523071,651.71875 +11.751923084259033,653.359375 +11.811944961547852,653.515625 +11.863922119140625,654.34375 +11.923939943313599,655.21875 +11.983957052230835,655.40625 +12.043972969055176,656.671875 +12.103992223739624,656.875 +12.164008140563965,657.625 +12.224030017852783,658.578125 +12.27458119392395,658.71875 +12.334602117538452,659.125 +12.394626140594482,659.421875 +12.454648971557617,660.0 +12.514663934707642,660.703125 +12.574680805206299,661.09375 +12.634721040725708,662.34375 +12.6947500705719,662.34375 +12.754767894744873,662.484375 +12.814790964126587,663.9375 +12.874817132949829,664.390625 +12.925249099731445,664.671875 +12.985272884368896,665.109375 +13.037245035171509,665.15625 +13.097269058227539,665.59375 +13.157285928726196,665.828125 +13.217300176620483,665.890625 +13.277315855026245,666.171875 +13.33733320236206,668.28125 +13.397346258163452,668.46875 +13.457368850708008,668.703125 +13.517383098602295,670.15625 +13.577404975891113,670.3125 +13.637420177459717,670.796875 +13.697441101074219,670.953125 +13.757454872131348,671.078125 +13.817476987838745,671.140625 +13.87749195098877,672.59375 +13.937527179718018,673.390625 +13.997551918029785,673.421875 +14.057574033737183,673.671875 +14.117595911026001,675.296875 +14.177613258361816,675.59375 +14.237634181976318,676.875 +14.297652006149292,677.09375 +14.357671022415161,677.171875 +14.417694091796875,678.046875 +14.469232082366943,678.1875 +14.529253005981445,680.59375 +14.589269161224365,681.265625 +14.64928913116455,682.203125 +14.709306955337524,683.140625 +14.769320011138916,683.21875 +14.829342126846313,683.609375 +14.889362096786499,684.578125 +14.949390888214111,685.890625 +15.009416103363037,686.28125 +15.061228036880493,686.484375 +15.121248006820679,686.640625 +15.181279182434082,686.671875 +15.241302013397217,687.421875 +15.301321029663086,687.8125 +15.361341953277588,689.171875 +15.42136001586914,689.609375 +15.481383085250854,689.90625 +15.541406154632568,691.015625 +15.5918869972229,691.359375 +15.651904106140137,691.515625 +15.711920976638794,691.703125 +15.771936178207397,691.9375 +15.831953048706055,692.125 +15.891976118087769,694.265625 +15.951997995376587,694.984375 +16.012014865875244,695.375 +16.072037935256958,695.59375 +16.132056951522827,695.6875 +16.192080974578857,696.28125 +16.247886896133423,697.0625 +16.30790615081787,697.90625 +16.367926120758057,698.78125 +16.42795205116272,698.78125 +16.48797082901001,699.4375 +16.547992944717407,699.75 +16.608012199401855,700.203125 +16.668027877807617,700.328125 +16.728044033050537,700.9375 +16.788058042526245,702.0625 +16.84807300567627,702.171875 +16.90809202194214,702.296875 +16.968106031417847,704.171875 +17.025609016418457,704.34375 +17.085636854171753,704.4375 +17.135874032974243,704.734375 +17.195889949798584,707.0625 +17.255905151367188,707.296875 +17.31591510772705,708.65625 +17.37593102455139,708.84375 +17.43594980239868,709.765625 +17.49596405029297,710.765625 +17.55598020553589,710.828125 +17.616007089614868,710.84375 +17.676030158996582,711.234375 +17.736045122146606,711.5 +17.79606008529663,712.140625 +17.85607624053955,712.609375 +17.916097164154053,714.078125 +17.969887018203735,714.5 +18.02657914161682,715.765625 +18.08659601211548,715.8125 +18.1466121673584,716.15625 +18.206637144088745,716.984375 +18.266649961471558,717.734375 +18.32666802406311,717.75 +18.38669204711914,718.328125 +18.446710109710693,718.640625 +18.50673222541809,720.015625 +18.566749095916748,720.15625 +18.62676692008972,720.59375 +18.686782121658325,721.46875 +18.746806144714355,721.859375 +18.806822061538696,722.71875 +18.866843938827515,723.703125 +18.92687702178955,723.921875 +18.98690104484558,724.78125 +19.046916961669922,726.1875 +19.106935024261475,726.5 +19.166950941085815,726.90625 +19.226969003677368,727.984375 +19.286983966827393,729.3125 +19.347000122070312,729.453125 +19.407021045684814,729.90625 +19.467041015625,731.3125 +19.527063131332397,731.640625 +19.58708906173706,731.8125 +19.637192010879517,731.9375 +19.697205066680908,732.234375 +19.757222890853882,734.3125 +19.8172390460968,734.578125 +19.877272844314575,734.765625 +19.93729019165039,735.1875 +19.989903926849365,735.5 +20.04992699623108,736.515625 +20.10118317604065,736.71875 +20.16119885444641,738.15625 +20.22123098373413,738.171875 +20.281261920928955,738.359375 +20.33318305015564,738.46875 +20.393197059631348,739.234375 +20.453213930130005,739.53125 +20.513235092163086,740.15625 +20.565176248550415,741.0625 +20.625197172164917,741.734375 +20.685218811035156,743.578125 +20.745244026184082,743.84375 +20.79717516899109,744.515625 +20.8571879863739,744.671875 +20.917206048965454,745.0 +20.97722601890564,745.140625 +21.031247854232788,745.90625 +21.091267108917236,747.015625 +21.151286125183105,747.453125 +21.211302995681763,748.828125 +21.271319150924683,749.875 +21.331333875656128,750.734375 +21.391348123550415,750.9375 +21.451378107070923,751.078125 +21.51140785217285,752.28125 +21.562505960464478,752.3125 +21.62252712249756,753.578125 +21.682552099227905,754.34375 +21.742581129074097,755.328125 +21.79450297355652,755.4375 +21.854525089263916,755.75 +21.90650510787964,756.921875 +21.966521978378296,756.984375 +22.02654194831848,757.5 +22.086560010910034,758.15625 +22.146581172943115,758.859375 +22.206605911254883,759.546875 +22.25849986076355,759.96875 +22.318521976470947,760.578125 +22.370498180389404,761.34375 +22.43051505088806,761.46875 +22.49053716659546,762.8125 +22.55055022239685,763.609375 +22.610594034194946,763.765625 +22.661167860031128,763.765625 +22.72118616104126,763.890625 +22.781203031539917,764.484375 +22.841229915618896,764.796875 +22.89315700531006,765.15625 +22.95317506790161,767.203125 +23.01318883895874,768.15625 +23.073204040527344,768.234375 +23.133220911026,768.84375 +23.193239212036133,769.671875 +23.253253936767578,769.734375 +23.313267946243286,770.703125 +23.373289108276367,771.265625 +23.43330407142639,772.4375 +23.493327856063843,772.703125 +23.55334782600403,772.8125 +23.613365173339844,774.40625 +23.673380851745605,774.796875 +23.733393907546997,774.90625 +23.793421030044556,775.03125 +23.84517216682434,775.109375 +23.905194997787476,776.265625 +23.965214014053345,776.453125 +24.020509958267212,776.796875 +24.080533027648926,777.03125 +24.13314700126648,778.34375 +24.1931631565094,778.625 +24.253177881240845,780.15625 +24.313199996948242,780.34375 +24.373216152191162,782.421875 +24.43323302268982,782.703125 +24.493247985839844,782.984375 +24.553267002105713,783.0625 +24.61328911781311,783.234375 +24.663811206817627,783.515625 +24.72383213043213,785.4375 +24.77581024169922,785.75 +24.835832118988037,786.625 +24.8878071308136,786.890625 +24.94782590866089,788.25 +25.007848978042603,788.8125 +25.06786799430847,788.828125 +25.119812965393066,789.25 +25.17985486984253,790.203125 +25.23181390762329,790.71875 +25.291833877563477,791.140625 +25.351850032806396,791.25 +25.41186499595642,791.578125 +25.471885204315186,791.59375 +25.52246904373169,793.875 +25.58248519897461,794.171875 +25.64250087738037,794.6875 +25.702522039413452,795.140625 +25.762547969818115,796.0625 +25.82257318496704,797.234375 +25.87447214126587,797.828125 +25.93449306488037,798.75 +25.986464023590088,798.984375 +26.041547060012817,799.0625 +26.09313201904297,799.8125 +26.153154134750366,799.921875 +26.21316909790039,800.03125 +26.27318501472473,800.53125 +26.333199977874756,800.859375 +26.393213033676147,802.5625 +26.453235149383545,802.640625 +26.513253927230835,803.515625 +26.5732901096344,804.671875 +26.633321046829224,805.8125 +26.693344116210938,806.015625 +26.753363132476807,807.703125 +26.813387155532837,807.953125 +26.863797187805176,808.59375 +26.92381191253662,809.046875 +26.983827114105225,809.234375 +27.043605089187622,809.921875 +27.095789194107056,810.0625 +27.15580701828003,810.375 +27.215819120407104,811.0 +27.27583909034729,811.71875 +27.335856914520264,812.515625 +27.395878076553345,813.765625 +27.447789192199707,814.296875 +27.507806062698364,814.875 +27.567821264266968,815.421875 +27.62783908843994,815.9375 +27.687853813171387,816.1875 +27.74786901473999,818.265625 +27.80788516998291,818.578125 +27.862235069274902,818.578125 +27.922266006469727,818.640625 +27.982293128967285,818.96875 +28.042315006256104,819.34375 +28.102336168289185,819.5 +28.162360191345215,820.875 +28.222381114959717,821.90625 +28.27444887161255,822.109375 +28.33446502685547,823.59375 +28.39447784423828,823.90625 +28.454496145248413,824.84375 +28.514509916305542,825.015625 +28.57452702522278,827.03125 +28.634541988372803,827.453125 +28.694556951522827,827.65625 +28.754578113555908,827.875 +28.805108070373535,828.015625 +28.865127086639404,829.890625 +28.92514204978943,831.46875 +28.985177993774414,831.546875 +29.04520297050476,831.5625 +29.10522699356079,832.5 +29.165245056152344,832.875 +29.225265979766846,833.921875 +29.28528594970703,834.296875 +29.345298051834106,834.84375 +29.405312061309814,835.03125 +29.46532893180847,835.875 +29.52535104751587,837.546875 +29.58537721633911,837.71875 +29.6453959941864,837.828125 +29.705415964126587,838.1875 +29.765435934066772,838.421875 +29.825448989868164,839.25 +29.885467052459717,839.671875 +29.945483207702637,840.640625 +30.005497932434082,841.375 +30.065516233444214,842.765625 +30.12553310394287,843.03125 +30.18554925918579,844.625 +30.245573043823242,844.921875 +30.295765161514282,845.296875 +30.35579204559326,845.5 +30.415821075439453,846.078125 +30.466432094573975,846.28125 +30.526448011398315,846.53125 +30.586466789245605,847.46875 +30.646486043930054,847.953125 +30.706501007080078,848.640625 +30.766517162322998,849.84375 +30.826531887054443,849.921875 +30.87658405303955,850.28125 +30.936607122421265,851.8125 +30.996623992919922,852.40625 +31.056641101837158,852.484375 +31.1166570186615,852.625 +31.176680088043213,853.0625 +31.236701011657715,854.53125 +31.293102979660034,1044.171875 +31.35314702987671,1245.765625 +31.413175106048584,1245.765625 +31.473201990127563,1361.609375 +31.53324007987976,1534.6875 +31.593273878097534,1302.359375 +31.65330219268799,1339.046875 +31.7133309841156,1339.15625 +31.77336883544922,1342.109375 +31.833409070968628,1363.984375 +31.887085914611816,1528.8125 +31.94713807106018,1682.234375 +32.00719690322876,1683.296875 +32.06630611419678,1683.359375 +32.11868715286255,1684.296875 +32.17872595787048,1739.953125 +32.23838019371033,1749.671875 +32.290436029434204,1749.671875 +32.35047101974487,1749.671875 +32.40323996543884,1754.75 +32.455771923065186,1766.34375 +32.515820026397705,1778.640625 +32.57293391227722,1778.65625 +32.632899045944214,1866.921875 +32.69295287132263,1943.53125 +32.752992153167725,1943.53125 +32.805535078048706,1943.53125 +32.855754137039185,1943.53125 +32.915791034698486,1943.625 +32.97584295272827,1943.640625 +33.035887002944946,1943.640625 +33.093411922454834,1943.65625 +33.14376091957092,1943.65625 +33.20324683189392,1983.234375 +33.262633085250854,1988.34375 +33.31443691253662,1988.34375 +33.37447905540466,2019.15625 +33.43349099159241,2056.0625 +33.49353504180908,2056.65625 +33.5437650680542,2056.65625 +33.6038019657135,2056.65625 +33.663838148117065,2056.65625 +33.717092990875244,2056.734375 +33.77713322639465,2056.734375 +33.83301901817322,2056.734375 +33.89305806159973,2056.734375 +33.95309019088745,2056.734375 +34.01312494277954,2056.734375 +34.073172092437744,2056.734375 +34.13319802284241,2056.734375 +34.19322919845581,2056.734375 +34.253260135650635,2056.734375 +34.31329607963562,2056.734375 +34.37331700325012,2056.734375 +34.43334412574768,2087.578125 +34.493388175964355,2087.578125 +34.543757915496826,2087.578125 +34.60379910469055,2087.578125 +34.66383218765259,2087.578125 +34.71927094459534,2087.578125 +34.779306173324585,2087.578125 +34.839341163635254,2087.578125 +34.89936399459839,2087.578125 +34.95939898490906,2087.578125 +35.01941990852356,2088.0625 +35.079469203948975,2088.140625 +35.13840103149414,2088.140625 +35.198429107666016,2088.140625 +35.25846314430237,2088.140625 +35.31849408149719,2088.5625 +35.37854290008545,2088.5625 +35.42907404899597,2088.5625 +35.48910903930664,2088.5625 +35.549155950546265,2088.5625 +35.60919713973999,2088.5625 +35.6692419052124,2088.5625 +35.72506403923035,2088.5625 +35.78510022163391,2088.5625 +35.845134019851685,2088.5625 +35.89573907852173,2088.5625 +35.955782890319824,2088.5625 +36.00773096084595,2088.5625 +36.06778001785278,2088.5625 +36.11973524093628,2088.5625 +36.17976713180542,2088.5625 +36.23980093002319,2088.5625 +36.29039812088013,2088.5625 +36.35042905807495,2088.5625 +36.41047501564026,2088.5625 +36.470508098602295,2088.5625 +36.53054189682007,2088.5625 +36.59058499336243,2088.5625 +36.642395973205566,2088.5625 +36.70243000984192,2088.5625 +36.76245903968811,2088.5625 +36.82249188423157,2088.5625 +36.8825261592865,2090.9375 +36.942553997039795,2090.9375 +37.00258708000183,2090.9375 +37.06259202957153,2090.9375 +37.12263202667236,2090.9375 +37.1826651096344,2090.9375 +37.24269127845764,2090.9375 +37.302730083465576,2090.9375 +37.354384899139404,2090.953125 +37.414422035217285,2090.953125 +37.474454164505005,2090.953125 +37.53449201583862,2090.953125 +37.59453010559082,2090.953125 +37.645055055618286,2091.046875 +37.70508289337158,2091.046875 +37.7651150226593,2091.046875 +37.825154066085815,2091.046875 +37.885180950164795,2091.046875 +37.94521403312683,2091.046875 +38.00524401664734,2091.078125 +38.06527805328369,2091.078125 +38.12530994415283,2091.078125 +38.18535089492798,2091.078125 +38.24538207054138,2091.078125 +38.29571604728699,2091.078125 +38.355754137039185,2091.078125 +38.4157829284668,2091.078125 +38.47581100463867,2091.078125 +38.53584003448486,2091.078125 +38.59586215019226,2091.09375 +38.65590310096741,2091.09375 +38.70639109611511,2091.09375 +38.7664258480072,2091.09375 +38.82645606994629,2091.109375 +38.88649606704712,2075.109375 +38.93838119506836,1870.5 +38.998425006866455,1870.5 +39.05847406387329,1870.5 +39.10905313491821,1870.515625 +39.169090032577515,1870.515625 +39.22911810874939,1869.953125 +39.28914499282837,1869.953125 +39.349180936813354,1868.96875 diff --git a/tools/memory_usage_tracking/memory_plotting.py b/tools/memory_usage_tracking/memory_plotting.py index ec0ead4ed..f841a624f 100644 --- a/tools/memory_usage_tracking/memory_plotting.py +++ b/tools/memory_usage_tracking/memory_plotting.py @@ -10,7 +10,9 @@ import tempfile import time +import matplotlib.cm as cm import matplotlib.pyplot as plt +import numpy as np import pandas as pd import psutil @@ -385,6 +387,7 @@ def main() -> None: # Display-friendly dataset names and filesystem-safe names dataset_disps = [dataset_short(d) for d in args.datasets] dataset_fs = [model_fs(d) for d in args.datasets] + colors = cm.jet(np.linspace(0, 1, len(dataset_fs))) os.makedirs(OUTPUT_ROOT, exist_ok=True) @@ -431,14 +434,14 @@ def main() -> None: csv_outputs_for_model, labels=labels, plot_path=norm_plot_path, - colors=("blue", "red", "green"), + colors=colors, ) plot_raw_time_memory( model_label, csv_outputs_for_model, labels=labels, plot_path=raw_plot_path, - colors=("blue", "red", "green"), + colors=colors, ) From 1a12c671faa76b2821432dc16841fd984d31a308 Mon Sep 17 00:00:00 2001 From: David Leko Date: Wed, 19 Nov 2025 21:58:53 +0100 Subject: [PATCH 07/11] Improved plotting. --- .../cell__topotune__fake.csv | 302 ------- .../cell__topotune__fake_inmem.csv | 784 ------------------ .../memory_plot_normalized.png | Bin 39804 -> 0 bytes .../graph__gcn__fake.csv | 72 -- .../graph__gcn__fake_inmem.csv | 75 -- .../memory_plot_normalized.png | Bin 42639 -> 0 bytes .../memory_plot_normalized.png | Bin 47281 -> 0 bytes .../simplicial__topotune__fake.csv | 192 ----- .../simplicial__topotune__fake_inmem.csv | 672 --------------- 9 files changed, 2097 deletions(-) delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv delete mode 100644 test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv deleted file mode 100644 index 5d4809c8a..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake.csv +++ /dev/null @@ -1,302 +0,0 @@ -time_s,memory_MB -2.3126602172851562e-05,0.515625 -0.05225086212158203,19.828125 -0.11227607727050781,29.921875 -0.1723017692565918,39.1875 -0.23233699798583984,64.28125 -0.2923750877380371,101.609375 -0.352916955947876,133.890625 -0.4147357940673828,150.546875 -0.47348690032958984,159.703125 -0.5335917472839355,166.84375 -0.5936238765716553,175.75 -0.6441988945007324,184.875 -0.704226016998291,194.203125 -0.7642650604248047,200.21875 -0.8243017196655273,210.890625 -0.8843300342559814,217.8125 -0.9443600177764893,233.921875 -1.0043840408325195,241.59375 -1.0644118785858154,249.546875 -1.124445915222168,253.4375 -1.1748559474945068,258.203125 -1.2348768711090088,268.09375 -1.2948999404907227,273.25 -1.354928970336914,279.125 -1.4068570137023926,283.34375 -1.4668827056884766,291.140625 -1.5269129276275635,301.875 -1.5775220394134521,309.6875 -1.6375470161437988,318.03125 -1.6975948810577393,328.21875 -1.7576169967651367,334.953125 -1.8176357746124268,340.953125 -1.8776569366455078,347.9375 -1.9376778602600098,355.1875 -1.9977028369903564,364.203125 -2.057724952697754,384.625 -2.117748975753784,393.703125 -2.177772045135498,400.21875 -2.23779296875,410.859375 -2.2978179454803467,419.515625 -2.3578379154205322,427.921875 -2.417860746383667,435.015625 -2.477886915206909,442.53125 -2.5379059314727783,451.953125 -2.5979268550872803,459.703125 -2.657946825027466,461.5625 -2.717967987060547,466.265625 -2.7779898643493652,467.59375 -2.8380119800567627,468.59375 -2.8969359397888184,478.765625 -2.9481749534606934,490.421875 -2.998363971710205,500.203125 -3.0583889484405518,508.421875 -3.118412971496582,509.6875 -3.178435802459717,509.8125 -3.2384679317474365,513.421875 -3.2985050678253174,518.234375 -3.350855827331543,710.375 -3.410885810852051,907.890625 -3.4709110260009766,1023.046875 -3.530937910079956,1087.03125 -3.590970993041992,1099.859375 -3.650998115539551,1099.859375 -3.7110259532928467,1106.09375 -3.7710509300231934,1106.09375 -3.8310790061950684,1031.046875 -3.8911149501800537,1090.203125 -3.951140880584717,1132.3125 -4.011164903640747,1132.40625 -4.071190118789673,1154.203125 -4.131218910217285,1154.21875 -4.191245079040527,1154.21875 -4.25127387046814,1154.234375 -4.311298131942749,1154.25 -4.371322870254517,1154.421875 -4.431348085403442,1154.46875 -4.491372108459473,1154.46875 -4.551404714584351,1157.40625 -4.611433029174805,1168.03125 -4.6714560985565186,1168.03125 -4.731485843658447,1168.046875 -4.791504859924316,1168.046875 -4.85152792930603,1232.34375 -4.91155481338501,1349.3125 -4.971576929092407,1388.8125 -5.03160285949707,1428.875 -5.091630935668945,1435.390625 -5.151658058166504,1435.390625 -5.2116858959198,1456.234375 -5.271715879440308,1456.265625 -5.331739902496338,1472.859375 -5.391770839691162,1504.0625 -5.451796054840088,1550.203125 -5.511820077896118,1553.078125 -5.571855783462524,1555.953125 -5.631887912750244,1559.203125 -5.691917896270752,1559.203125 -5.751940965652466,1559.203125 -5.811962842941284,1559.234375 -5.871991872787476,1561.265625 -5.932015895843506,1561.265625 -5.992043972015381,1561.265625 -6.052073955535889,1561.265625 -6.11210298538208,1561.265625 -6.172134876251221,1561.265625 -6.232161998748779,1561.265625 -6.292186975479126,1561.265625 -6.352216720581055,1562.03125 -6.4122397899627686,1562.03125 -6.472275972366333,1562.03125 -6.532299995422363,1562.03125 -6.59232497215271,1562.046875 -6.65234899520874,1562.046875 -6.712374925613403,1562.046875 -6.772397756576538,1562.046875 -6.832427978515625,1563.078125 -6.89245080947876,1563.078125 -6.952473878860474,1563.078125 -7.01251482963562,1568.515625 -7.062839031219482,1603.296875 -7.122880935668945,1603.28125 -7.1829140186309814,1603.28125 -7.242944955825806,1603.28125 -7.302970886230469,1603.28125 -7.3630101680755615,1605.015625 -7.4148218631744385,1624.09375 -7.474854946136475,1645.25 -7.534885883331299,1645.28125 -7.591914892196655,1645.296875 -7.651956081390381,1645.296875 -7.711984872817993,1645.296875 -7.772015810012817,1645.296875 -7.832047939300537,1645.296875 -7.8920738697052,1645.296875 -7.9521098136901855,1645.296875 -8.012146949768066,1645.296875 -8.07217788696289,1645.296875 -8.132208824157715,1645.296875 -8.192240953445435,1645.296875 -8.252271890640259,1645.296875 -8.312294960021973,1645.296875 -8.372326850891113,1645.46875 -8.432363033294678,1645.46875 -8.49239993095398,1645.46875 -8.542808771133423,1645.46875 -8.602844953536987,1645.46875 -8.654810905456543,1645.46875 -8.714863777160645,1645.46875 -8.76680612564087,1645.46875 -8.826834917068481,1645.46875 -8.881897926330566,1646.578125 -8.932140111923218,1646.578125 -8.992172002792358,1646.578125 -9.052199840545654,1646.609375 -9.112236022949219,1646.609375 -9.17226505279541,1646.609375 -9.232310056686401,1646.609375 -9.284130096435547,1646.609375 -9.344161033630371,1667.765625 -9.404188871383667,1667.765625 -9.464224100112915,1667.765625 -9.524255990982056,1667.765625 -9.58428692817688,1668.3125 -9.644324779510498,1668.3125 -9.694793939590454,1668.3125 -9.75482177734375,1668.3125 -9.81485390663147,1668.3125 -9.865458965301514,1668.3125 -9.925485849380493,1668.3125 -9.98551607131958,1668.40625 -10.036128044128418,1668.421875 -10.09615683555603,1668.421875 -10.156182050704956,1668.421875 -10.216223955154419,1668.421875 -10.276257991790771,1668.421875 -10.33628797531128,1668.421875 -10.396339893341064,1668.421875 -10.44677996635437,1668.421875 -10.50681185722351,1668.4375 -10.56684398651123,1668.4375 -10.621983051300049,1671.265625 -10.682011842727661,1671.265625 -10.742042779922485,1671.265625 -10.802068948745728,1671.265625 -10.86210298538208,1671.265625 -10.922132968902588,1671.265625 -10.982157707214355,1671.265625 -11.042181968688965,1671.265625 -11.102230072021484,1671.265625 -11.153439998626709,1671.265625 -11.213469982147217,1671.265625 -11.273496866226196,1671.265625 -11.333526134490967,1671.265625 -11.393555879592896,1671.265625 -11.453577995300293,1671.265625 -11.513603925704956,1671.265625 -11.573632955551147,1680.546875 -11.63199496269226,1680.546875 -11.692019939422607,1680.578125 -11.752048969268799,1680.578125 -11.812076091766357,1680.578125 -11.87210488319397,1680.578125 -11.932154893875122,1680.578125 -11.992187976837158,1680.578125 -12.052213907241821,1680.578125 -12.112249851226807,1680.578125 -12.17229175567627,1680.578125 -12.222768783569336,1680.578125 -12.282793998718262,1680.578125 -12.342820882797241,1680.578125 -12.402860879898071,1680.578125 -12.462891101837158,1680.578125 -12.522912979125977,1680.578125 -12.582948923110962,1680.578125 -12.633434772491455,1680.578125 -12.693459033966064,1680.578125 -12.753483057022095,1680.578125 -12.813534021377563,1680.578125 -12.873579978942871,1680.578125 -12.933616876602173,1680.578125 -12.993647813796997,1680.578125 -13.053678750991821,1680.578125 -13.113707065582275,1680.578125 -13.173748970031738,1680.578125 -13.225436925888062,1680.578125 -13.285470008850098,1680.578125 -13.345503091812134,1680.578125 -13.405542850494385,1680.578125 -13.465581893920898,1680.578125 -13.525603771209717,1680.578125 -13.58563780784607,1680.578125 -13.645666122436523,1680.578125 -13.705704927444458,1680.578125 -13.765744924545288,1680.59375 -13.825776815414429,1680.59375 -13.885828971862793,1680.59375 -13.940098762512207,1680.59375 -14.000130891799927,1680.59375 -14.060159921646118,1680.59375 -14.120206832885742,1680.59375 -14.172096967697144,1680.59375 -14.232141017913818,1680.59375 -14.292166948318481,1680.59375 -14.352200031280518,1680.59375 -14.412230968475342,1680.59375 -14.472261905670166,1680.59375 -14.532293796539307,1680.59375 -14.592315912246704,1680.59375 -14.652336835861206,1680.59375 -14.712364912033081,1680.59375 -14.772407054901123,1680.59375 -14.822762966156006,1680.59375 -14.882802963256836,1680.59375 -14.942831754684448,1680.59375 -15.002862930297852,1680.59375 -15.062898874282837,1680.59375 -15.122928857803345,1680.703125 -15.18295669555664,1680.703125 -15.242981910705566,1680.703125 -15.303009986877441,1680.703125 -15.363039016723633,1680.703125 -15.42309308052063,1680.703125 -15.473413944244385,1680.703125 -15.533447027206421,1680.703125 -15.593487977981567,1680.703125 -15.653522968292236,1680.703125 -15.713547945022583,1680.703125 -15.773576974868774,1680.703125 -15.833606958389282,1680.703125 -15.893642902374268,1680.703125 -15.95366883277893,1680.703125 -16.0136981010437,1680.703125 -16.07373070716858,1680.703125 -16.13376212120056,1680.703125 -16.193793058395386,1680.703125 -16.25384783744812,1680.703125 -16.30541706085205,1680.703125 -16.365453720092773,1680.703125 -16.417412757873535,1680.703125 -16.47745370864868,1680.703125 -16.52940082550049,1680.703125 -16.589431047439575,1680.703125 -16.64946484565735,1680.703125 -16.709491968154907,1680.703125 -16.76951503753662,1680.75 -16.829543828964233,1680.75 -16.889580726623535,1680.75 -16.940059900283813,1680.75 -17.00008773803711,1680.75 -17.06015396118164,1680.75 -17.120194911956787,1680.75 -17.17207098007202,1680.75 -17.232115030288696,1680.84375 -17.28407597541809,1680.84375 -17.34411096572876,1680.84375 -17.404151916503906,1680.84375 -17.454729080200195,1680.859375 -17.514763116836548,1680.859375 -17.574790000915527,1680.875 -17.63481879234314,1680.875 -17.694851875305176,1680.84375 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv deleted file mode 100644 index 3a173aa25..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/cell__topotune__fake_inmem.csv +++ /dev/null @@ -1,784 +0,0 @@ -time_s,memory_MB -3.910064697265625e-05,0.125 -0.05097508430480957,25.3125 -0.10600090026855469,38.5 -0.1610279083251953,66.1875 -0.21605801582336426,100.34375 -0.27111101150512695,133.625 -0.3217949867248535,149.859375 -0.38090085983276367,161.84375 -0.4356811046600342,166.25 -0.4914579391479492,173.390625 -0.5435621738433838,183.96875 -0.5985889434814453,195.578125 -0.6536400318145752,202.515625 -0.7086770534515381,210.4375 -0.7637059688568115,220.296875 -0.8187589645385742,235.765625 -0.8697922229766846,247.90625 -0.9248340129852295,255.65625 -0.9798710346221924,260.0 -1.0346851348876953,269.140625 -1.0856821537017822,274.59375 -1.140714168548584,283.875 -1.195749044418335,294.890625 -1.2482860088348389,307.734375 -1.3033161163330078,313.15625 -1.3583450317382812,325.515625 -1.4133720397949219,331.390625 -1.4683940410614014,341.3125 -1.5234220027923584,350.890625 -1.578449010848999,364.28125 -1.6334779262542725,387.546875 -1.6885020732879639,394.6875 -1.7435338497161865,402.234375 -1.7985711097717285,415.015625 -1.8509469032287598,425.71875 -1.905975103378296,436.59375 -1.9610021114349365,443.15625 -2.0160348415374756,449.046875 -2.066944122314453,453.640625 -2.1219711303710938,462.203125 -2.177002191543579,467.765625 -2.229614019393921,468.546875 -2.2846450805664062,470.09375 -2.338937997817993,477.5 -2.393963098526001,490.5625 -2.4489948749542236,497.703125 -2.504031181335449,514.234375 -2.554939031600952,552.921875 -2.60998797416687,575.859375 -2.6616101264953613,575.984375 -2.7166459560394287,600.953125 -2.7682740688323975,603.875 -2.823305130004883,608.875 -2.8783349990844727,615.265625 -2.933357000350952,616.296875 -2.9883759021759033,616.40625 -3.0434021949768066,616.59375 -3.0962929725646973,622.0625 -3.151327133178711,625.9375 -3.2063560485839844,629.265625 -3.2613840103149414,633.765625 -3.3164188861846924,641.0 -3.3682639598846436,641.421875 -3.4232988357543945,647.046875 -3.474925994873047,647.578125 -3.5299649238586426,649.265625 -3.5816400051116943,649.296875 -3.6362650394439697,649.34375 -3.6912999153137207,649.8125 -3.741595983505249,649.8125 -3.7966179847717285,649.8125 -3.851641893386841,650.0 -3.906665086746216,650.15625 -3.9616920948028564,650.1875 -4.016715049743652,650.25 -4.071742057800293,650.421875 -4.126766920089722,650.4375 -4.181803226470947,650.59375 -4.236831188201904,650.609375 -4.291856050491333,650.765625 -4.34688401222229,653.953125 -4.397594928741455,659.953125 -4.452630043029785,659.953125 -4.5042500495910645,660.15625 -4.559286117553711,660.375 -4.61431884765625,664.734375 -4.666918039321899,666.34375 -4.7219460010528564,666.453125 -4.776987075805664,666.453125 -4.832006931304932,666.515625 -4.887030124664307,666.609375 -4.942061901092529,666.75 -4.992249965667725,666.796875 -5.047277927398682,666.796875 -5.1016340255737305,666.921875 -5.156666040420532,666.9375 -5.211694955825806,667.046875 -5.266723871231079,667.109375 -5.321758985519409,668.265625 -5.373578071594238,668.421875 -5.4286110401153564,670.5625 -5.480262041091919,670.609375 -5.535290002822876,670.625 -5.590325117111206,670.765625 -5.645350933074951,670.875 -5.700374126434326,671.015625 -5.755401134490967,671.015625 -5.810420036315918,671.09375 -5.865447044372559,677.921875 -5.92048192024231,680.734375 -5.975503921508789,682.375 -6.0305280685424805,682.375 -6.085558176040649,682.375 -6.1405839920043945,687.828125 -6.195605039596558,687.890625 -6.250635147094727,688.015625 -6.305660963058472,688.1875 -6.360681056976318,688.328125 -6.415709018707275,688.359375 -6.470736980438232,688.359375 -6.52577018737793,688.359375 -6.580798149108887,688.359375 -6.635823965072632,688.375 -6.690852880477905,688.390625 -6.745882987976074,688.390625 -6.800910949707031,697.546875 -6.855937957763672,708.3125 -6.910967111587524,708.3125 -6.965996980667114,708.578125 -7.021038055419922,708.59375 -7.076061964035034,708.71875 -7.131091117858887,708.71875 -7.186129093170166,708.96875 -7.2411558628082275,711.75 -7.296190023422241,711.75 -7.351217985153198,711.75 -7.4062511920928955,711.75 -7.461282014846802,711.75 -7.516309022903442,711.75 -7.571333885192871,711.75 -7.62636923789978,711.75 -7.6813929080963135,711.75 -7.736418962478638,711.75 -7.791445016860962,713.046875 -7.846468925476074,713.046875 -7.901492118835449,713.046875 -7.956524133682251,714.421875 -8.011548042297363,714.4375 -8.066578149795532,714.4375 -8.121603965759277,714.828125 -8.176630020141602,714.84375 -8.23166012763977,717.796875 -8.286690950393677,727.5625 -8.341716051101685,727.578125 -8.39674711227417,727.578125 -8.451777935028076,727.578125 -8.506814002990723,727.578125 -8.561841011047363,727.578125 -8.61686897277832,727.59375 -8.671897888183594,727.59375 -8.726931095123291,727.59375 -8.781959056854248,727.703125 -8.836986064910889,727.734375 -8.892012119293213,727.796875 -8.947041988372803,727.9375 -9.002064943313599,728.03125 -9.05709195137024,730.71875 -9.112117052078247,730.75 -9.167143106460571,730.75 -9.22216796875,730.78125 -9.27719521522522,730.78125 -9.332228899002075,730.78125 -9.38725996017456,730.78125 -9.442296981811523,730.78125 -9.49732494354248,731.078125 -9.5523521900177,731.09375 -9.60738492012024,733.90625 -9.662410020828247,735.3125 -9.717437028884888,735.3125 -9.772461891174316,735.3125 -9.827486991882324,737.875 -9.882513046264648,737.9375 -9.937540054321289,737.9375 -9.99256420135498,738.0 -10.04759407043457,738.0 -10.102618932723999,738.03125 -10.157649040222168,738.171875 -10.212676048278809,738.203125 -10.267705917358398,738.265625 -10.322729110717773,738.28125 -10.377765893936157,738.28125 -10.432793855667114,738.28125 -10.487820148468018,738.296875 -10.542850971221924,738.359375 -10.597880840301514,746.984375 -10.652907133102417,747.15625 -10.707942008972168,747.28125 -10.762969970703125,747.3125 -10.818001985549927,750.8125 -10.87303113937378,751.015625 -10.928060054779053,751.0625 -10.983085870742798,751.09375 -11.038113117218018,751.578125 -11.093139171600342,754.609375 -11.148162841796875,762.25 -11.203185081481934,762.34375 -11.258218050003052,762.375 -11.313256025314331,762.375 -11.368293046951294,762.40625 -11.42332410812378,762.53125 -11.478349924087524,762.5625 -11.53338098526001,762.578125 -11.588409900665283,762.6875 -11.643436193466187,762.765625 -11.698462009429932,762.875 -11.7534921169281,762.875 -11.808524131774902,762.984375 -11.863550186157227,763.046875 -11.918581008911133,763.1875 -11.973618030548096,769.234375 -12.024193048477173,772.203125 -12.079219102859497,772.390625 -12.133136987686157,772.40625 -12.184195041656494,772.46875 -12.239227056503296,772.578125 -12.294262170791626,772.9375 -12.34929609298706,773.0625 -12.404325008392334,779.109375 -12.456187963485718,779.171875 -12.511219024658203,779.296875 -12.566246032714844,779.375 -12.621278047561646,783.265625 -12.67630910873413,783.328125 -12.731348991394043,783.328125 -12.786372900009155,783.453125 -12.841402053833008,783.640625 -12.896427154541016,783.6875 -12.951451063156128,783.6875 -13.00647783279419,783.75 -13.06150507926941,783.875 -13.116527080535889,784.0 -13.171557903289795,784.1875 -13.22658896446228,784.203125 -13.281636953353882,784.375 -13.336663007736206,784.421875 -13.391692161560059,785.6875 -13.4467191696167,788.125 -13.501741886138916,788.171875 -13.556769847869873,788.484375 -13.611804962158203,788.484375 -13.666839838027954,788.625 -13.721874952316284,788.640625 -13.77689790725708,788.828125 -13.831926107406616,788.859375 -13.88695216178894,789.0625 -13.941980123519897,789.203125 -13.99700403213501,789.5625 -14.052041053771973,800.328125 -14.107071161270142,800.390625 -14.162096977233887,800.671875 -14.217135906219482,800.90625 -14.27216386795044,801.0 -14.327189207077026,801.140625 -14.382220983505249,801.265625 -14.437250852584839,801.359375 -14.492280960083008,801.40625 -14.547307014465332,801.5 -14.602330923080444,801.625 -14.657353162765503,801.71875 -14.712385177612305,801.765625 -14.767409086227417,813.78125 -14.822433948516846,814.046875 -14.877459049224854,814.328125 -14.932487964630127,814.453125 -14.987514019012451,814.453125 -15.047543048858643,814.515625 -15.107572078704834,820.03125 -15.167598962783813,820.03125 -15.227628946304321,820.078125 -15.28766393661499,820.125 -15.338827133178711,820.125 -15.398850917816162,820.140625 -15.458876132965088,820.203125 -15.518900156021118,821.46875 -15.578924894332886,821.609375 -15.63895297050476,825.96875 -15.69897723197937,826.0625 -15.75900411605835,826.21875 -15.819033861160278,827.5 -15.879059076309204,831.90625 -15.939090013504028,832.015625 -15.999113082885742,832.03125 -16.059139013290405,832.078125 -16.119169235229492,832.140625 -16.17919611930847,832.28125 -16.239220142364502,832.28125 -16.299248933792114,832.296875 -16.35927414894104,832.34375 -16.419301986694336,835.546875 -16.47932720184326,840.25 -16.539350986480713,840.25 -16.5993812084198,843.40625 -16.659405946731567,846.71875 -16.719434022903442,846.75 -16.779468059539795,846.859375 -16.839494943618774,846.859375 -16.899523973464966,846.859375 -16.95954704284668,847.03125 -17.019581079483032,847.046875 -17.0796160697937,847.046875 -17.13964295387268,847.046875 -17.199671268463135,847.1875 -17.259696006774902,848.59375 -17.319722175598145,849.8125 -17.37974524497986,849.8125 -17.439770936965942,849.90625 -17.499794006347656,849.921875 -17.559819221496582,849.921875 -17.619847059249878,850.0625 -17.679873943328857,850.0625 -17.739901065826416,850.1875 -17.799927234649658,853.09375 -17.85995602607727,853.15625 -17.919984102249146,853.234375 -17.980008125305176,853.734375 -18.04004216194153,853.734375 -18.100067853927612,858.234375 -18.16009211540222,858.3125 -18.220124006271362,858.3125 -18.280150175094604,858.3125 -18.340178966522217,859.453125 -18.400205850601196,864.328125 -18.46022891998291,864.359375 -18.520257234573364,864.4375 -18.58027982711792,864.46875 -18.640305995941162,864.640625 -18.700335025787354,864.640625 -18.7603600025177,864.765625 -18.82038402557373,864.78125 -18.88040781021118,864.78125 -18.94043207168579,866.078125 -19.000455141067505,866.203125 -19.060487031936646,866.265625 -19.120513200759888,866.28125 -19.179604053497314,867.546875 -19.23213815689087,868.921875 -19.292165994644165,875.28125 -19.352192163467407,883.375 -19.41221785545349,883.375 -19.472244024276733,883.390625 -19.53226900100708,883.453125 -19.59229612350464,883.5 -19.65232014656067,883.53125 -19.71235203742981,883.5625 -19.772380113601685,883.5625 -19.83240509033203,883.65625 -19.89244508743286,883.6875 -19.952471017837524,883.6875 -20.01249599456787,883.78125 -20.0725200176239,883.8125 -20.132549047470093,885.15625 -20.189604997634888,885.15625 -20.240122079849243,885.234375 -20.30014705657959,885.421875 -20.360174894332886,885.484375 -20.4201979637146,885.484375 -20.480223178863525,886.6875 -20.540246963500977,886.703125 -20.600274085998535,886.734375 -20.660300254821777,888.09375 -20.720329999923706,893.578125 -20.780354022979736,893.78125 -20.840378999710083,896.625 -20.89079785346985,896.78125 -20.950822114944458,896.921875 -21.010849237442017,896.921875 -21.070876121520996,896.921875 -21.13090491294861,896.9375 -21.19093108177185,896.9375 -21.250958919525146,897.046875 -21.310982942581177,897.109375 -21.371011972427368,898.453125 -21.431035041809082,898.578125 -21.49106216430664,898.578125 -21.551090002059937,898.65625 -21.611115217208862,898.6875 -21.671139001846313,898.6875 -21.731159925460815,898.8125 -21.791199207305908,898.84375 -21.85122585296631,903.671875 -21.911254167556763,904.96875 -21.97127890586853,908.78125 -22.03130292892456,908.90625 -22.09132981300354,909.09375 -22.141438007354736,909.203125 -22.2014639377594,912.625 -22.253443956375122,917.1875 -22.31346893310547,917.359375 -22.373498916625977,920.265625 -22.424106121063232,921.78125 -22.484133005142212,921.859375 -22.544164896011353,921.9375 -22.59477210044861,922.078125 -22.654796838760376,922.3125 -22.7148220539093,922.328125 -22.774852991104126,922.421875 -22.834877014160156,922.515625 -22.894906044006348,922.640625 -22.954933166503906,923.59375 -23.01495885848999,925.59375 -23.074981927871704,925.65625 -23.135009050369263,925.78125 -23.195035934448242,926.984375 -23.25507116317749,927.140625 -23.306768894195557,928.53125 -23.36679697036743,931.390625 -23.42682409286499,931.390625 -23.486862897872925,931.578125 -23.546889066696167,931.609375 -23.60692000389099,934.328125 -23.666945219039917,934.484375 -23.726975202560425,934.5 -23.787004947662354,942.328125 -23.83743119239807,945.328125 -23.897457122802734,945.484375 -23.957479000091553,945.703125 -24.017505884170532,945.78125 -24.077531099319458,946.0 -24.137558937072754,946.09375 -24.197585105895996,946.125 -24.25760793685913,947.6875 -24.31763792037964,952.5625 -24.368086099624634,952.875 -24.428112030029297,954.4375 -24.488136053085327,958.03125 -24.548166036605835,958.09375 -24.60819101333618,958.125 -24.66822099685669,958.15625 -24.72008514404297,958.203125 -24.78011393547058,959.75 -24.840139150619507,960.03125 -24.900169134140015,960.171875 -24.96019220352173,960.390625 -25.020219087600708,960.421875 -25.08024311065674,960.59375 -25.140269994735718,960.640625 -25.20029616355896,960.828125 -25.260321140289307,960.921875 -25.320348024368286,960.953125 -25.380378007888794,961.140625 -25.433382034301758,961.234375 -25.48542809486389,961.265625 -25.545454025268555,961.328125 -25.605481147766113,961.640625 -25.665505170822144,961.796875 -25.725532054901123,961.859375 -25.785556077957153,961.984375 -25.845580101013184,967.4375 -25.905603885650635,971.625 -25.965636014938354,975.03125 -26.025656938552856,975.03125 -26.08568787574768,975.171875 -26.136080026626587,975.375 -26.196105003356934,975.40625 -26.256131887435913,975.703125 -26.316155910491943,978.234375 -26.37617802619934,978.40625 -26.43620491027832,978.40625 -26.496232986450195,978.546875 -26.556257247924805,978.859375 -26.616291046142578,981.265625 -26.666733980178833,981.328125 -26.72676110267639,992.4375 -26.786782026290894,992.578125 -26.846802949905396,992.765625 -26.90682888031006,993.140625 -26.96685290336609,993.140625 -27.026875972747803,997.75 -27.08690118789673,997.78125 -27.14692497253418,997.9375 -27.206944227218628,998.0 -27.266968965530396,998.21875 -27.32699203491211,1001.28125 -27.387013912200928,1001.484375 -27.44704294204712,1001.9375 -27.507070064544678,1001.9375 -27.56709599494934,1001.953125 -27.627119064331055,1002.078125 -27.687146186828613,1002.109375 -27.747173070907593,1002.3125 -27.80719804763794,1002.484375 -27.86722207069397,1002.671875 -27.92724585533142,1002.703125 -27.987274169921875,1002.84375 -28.047301054000854,1003.0 -28.107325077056885,1005.4375 -28.167351961135864,1007.9375 -28.227375984191895,1007.984375 -28.287402153015137,1008.046875 -28.347422122955322,1008.25 -28.40744686126709,1008.296875 -28.467466115951538,1008.328125 -28.52748990058899,1008.453125 -28.587514877319336,1008.640625 -28.647542238235474,1008.703125 -28.70757007598877,1009.96875 -28.767595052719116,1010.203125 -28.8276150226593,1010.265625 -28.887644052505493,1012.796875 -28.947670936584473,1012.984375 -29.007697105407715,1020.03125 -29.067721128463745,1020.21875 -29.127745151519775,1020.390625 -29.18777108192444,1020.421875 -29.24779510498047,1021.9375 -29.30782699584961,1022.109375 -29.367856979370117,1022.109375 -29.42788600921631,1022.1875 -29.487910985946655,1022.234375 -29.547945022583008,1022.359375 -29.60005211830139,1022.53125 -29.66008710861206,1022.671875 -29.720113039016724,1023.96875 -29.780141830444336,1024.265625 -29.8320369720459,1024.34375 -29.892061948776245,1024.484375 -29.952084064483643,1024.484375 -30.01211190223694,1024.625 -30.072136163711548,1024.796875 -30.132161855697632,1027.15625 -30.192183256149292,1027.390625 -30.25221300125122,1027.5625 -30.312247037887573,1027.75 -30.372272968292236,1031.078125 -30.43229603767395,1033.421875 -30.492319107055664,1036.03125 -30.55234384536743,1038.296875 -30.612367868423462,1038.59375 -30.672390937805176,1038.734375 -30.732412099838257,1038.890625 -30.79243516921997,1038.96875 -30.852460861206055,1039.125 -30.912480115890503,1039.140625 -30.972503900527954,1043.15625 -31.03253412246704,1322.34375 -31.092567920684814,1443.859375 -31.152594089508057,1474.28125 -31.21261501312256,1624.6875 -31.272648096084595,1836.453125 -31.332672119140625,1446.65625 -31.392701148986816,1573.125 -31.452728033065796,1603.5 -31.51275086402893,1603.84375 -31.572787046432495,1607.140625 -31.632813930511475,1608.09375 -31.692848920822144,1770.375 -31.75288200378418,1846.328125 -31.8129141330719,1887.296875 -31.87297010421753,1887.296875 -31.92537784576416,1912.203125 -31.98540997505188,1912.203125 -32.04487204551697,1912.25 -32.09604597091675,1912.25 -32.150030851364136,1912.640625 -32.20536804199219,1912.75 -32.26539921760559,1912.78125 -32.3254292011261,1912.84375 -32.38546586036682,1912.84375 -32.44549894332886,1912.84375 -32.50555205345154,1912.84375 -32.565590143203735,1912.84375 -32.62561917304993,1912.84375 -32.68564796447754,1912.84375 -32.74569511413574,1953.6875 -32.79736304283142,1965.125 -32.85739302635193,1979.109375 -32.913684129714966,1985.015625 -32.96536302566528,1985.015625 -33.02539801597595,1990.53125 -33.085434913635254,1990.53125 -33.145468950271606,1990.875 -33.20048189163208,1990.875 -33.25603795051575,1990.875 -33.31607508659363,1990.875 -33.376112937927246,1996.1875 -33.43615126609802,1996.1875 -33.496185064315796,1996.1875 -33.549899101257324,1996.1875 -33.60992908477783,1996.1875 -33.66995692253113,1996.1875 -33.729995012283325,1996.1875 -33.78402590751648,1996.21875 -33.84408211708069,1996.21875 -33.90412187576294,1996.21875 -33.96417808532715,1996.21875 -34.0242121219635,1996.21875 -34.0842490196228,1996.21875 -34.144274950027466,2037.25 -34.20430302619934,2037.25 -34.26432704925537,2037.25 -34.32435584068298,2037.25 -34.3843879699707,2037.25 -34.44441890716553,2037.25 -34.50447392463684,2037.25 -34.5546760559082,2037.25 -34.614710092544556,2037.25 -34.674736976623535,2037.25 -34.73476600646973,2048.890625 -34.794800996780396,2048.890625 -34.85484719276428,2048.890625 -34.90668702125549,2048.890625 -34.96673011779785,2048.890625 -35.02676796913147,2048.890625 -35.086796045303345,2048.890625 -35.14683294296265,2048.890625 -35.197340965270996,2048.890625 -35.25739097595215,2048.890625 -35.31743001937866,2048.890625 -35.368009090423584,2048.890625 -35.42805218696594,2048.890625 -35.488080978393555,2048.890625 -35.5481071472168,2048.890625 -35.608131885528564,2048.890625 -35.66815805435181,2048.890625 -35.728187084198,2048.890625 -35.78821587562561,2048.890625 -35.84824800491333,2048.890625 -35.90826892852783,2048.890625 -35.9682981967926,2048.96875 -36.0283260345459,2048.96875 -36.08836221694946,2048.96875 -36.138664960861206,2048.96875 -36.19869923591614,2048.96875 -36.25873899459839,2048.96875 -36.30932426452637,2048.96875 -36.36935615539551,2048.96875 -36.429386138916016,2048.96875 -36.48941707611084,2048.96875 -36.5494430065155,2048.96875 -36.609468936920166,2048.96875 -36.669495820999146,2048.96875 -36.72952604293823,2048.96875 -36.78957915306091,2048.96875 -36.84961295127869,2048.96875 -36.90963912010193,2048.96875 -36.96966600418091,2048.96875 -37.02969312667847,2048.96875 -37.08973407745361,2048.96875 -37.14132809638977,2048.96875 -37.2013578414917,2048.96875 -37.261388063430786,2048.96875 -37.321414947509766,2048.96875 -37.381447076797485,2069.703125 -37.44147324562073,2069.703125 -37.50149703025818,2069.703125 -37.56152296066284,2070.203125 -37.62154817581177,2070.203125 -37.68157696723938,2070.203125 -37.741617918014526,2070.203125 -37.79197812080383,2094.296875 -37.85200500488281,2094.296875 -37.91205096244812,2094.40625 -37.97209310531616,2094.40625 -38.023980140686035,2094.40625 -38.08402490615845,2094.453125 -38.13600015640259,2094.453125 -38.196033239364624,2094.46875 -38.256062030792236,2094.46875 -38.316092014312744,2094.46875 -38.37612295150757,2094.953125 -38.43615126609802,2094.953125 -38.49617600440979,2094.953125 -38.55478525161743,2094.953125 -38.61482000350952,2094.953125 -38.67484998703003,2094.953125 -38.73487901687622,2094.953125 -38.794902086257935,2094.953125 -38.854931116104126,2094.953125 -38.91495609283447,2094.953125 -38.974982023239136,2094.96875 -39.03500699996948,2094.96875 -39.095041036605835,2094.96875 -39.155067920684814,2094.96875 -39.21509599685669,2094.96875 -39.27513003349304,2094.96875 -39.325308084487915,2094.96875 -39.385343074798584,2094.96875 -39.445372104644775,2094.96875 -39.5054030418396,2094.96875 -39.56542611122131,2094.984375 -39.62545299530029,2094.984375 -39.685484170913696,2094.984375 -39.74551200866699,2094.984375 -39.80553889274597,2094.984375 -39.86557197570801,2094.984375 -39.925601959228516,2094.984375 -39.985636949539185,2094.984375 -40.04566693305969,2094.984375 -40.10569787025452,2094.984375 -40.1657280921936,2094.984375 -40.22575402259827,2095.609375 -40.28578281402588,2095.609375 -40.34580588340759,2095.609375 -40.405832052230835,2095.609375 -40.46586298942566,2095.609375 -40.5258891582489,2095.609375 -40.585936069488525,2095.609375 -40.637288093566895,2095.609375 -40.69731903076172,2095.609375 -40.757346868515015,2095.609375 -40.81737399101257,2095.609375 -40.87740612030029,2095.609375 -40.93743395805359,2095.609375 -40.99746012687683,2095.609375 -41.05749201774597,2095.609375 -41.117516040802,2095.609375 -41.17754411697388,2095.609375 -41.237574100494385,2095.609375 -41.29761290550232,2095.609375 -41.34929895401001,2095.609375 -41.409339904785156,2095.609375 -41.46937417984009,2095.609375 -41.5294029712677,2095.609375 -41.58944606781006,2095.609375 -41.64948105812073,2096.203125 -41.709511041641235,2096.203125 -41.76956105232239,2096.203125 -41.82958912849426,2096.203125 -41.88963794708252,2096.203125 -41.94128394126892,2096.203125 -42.00131320953369,2096.203125 -42.0613489151001,2096.203125 -42.11194610595703,2096.203125 -42.17198300361633,2096.203125 -42.22395610809326,2096.203125 -42.28399395942688,2096.203125 -42.33594512939453,2096.203125 -42.395987033843994,2096.203125 -42.44795513153076,2096.203125 -42.50799298286438,2096.203125 -42.56803488731384,2096.203125 -42.628074169158936,2096.203125 -42.6799418926239,2096.203125 -42.73997092247009,2096.203125 -42.80000019073486,2096.203125 -42.860032081604004,2096.203125 -42.92006993293762,2096.203125 -42.97060489654541,2096.203125 -43.03064513206482,2096.203125 -43.0906720161438,2096.203125 -43.15070390701294,2096.203125 -43.21073603630066,2096.203125 -43.27077794075012,2096.203125 -43.33084297180176,2096.203125 -43.381277084350586,2096.203125 -43.44131803512573,2096.203125 -43.493273973464966,2096.203125 -43.55331325531006,2096.203125 -43.605266094207764,2096.203125 -43.66529607772827,2096.203125 -43.72533321380615,2096.34375 -43.78537106513977,2096.34375 -43.84539985656738,2096.34375 -43.90544295310974,2096.34375 -43.95725917816162,2096.34375 -44.01730012893677,2096.34375 -44.07732892036438,2096.359375 -44.12794613838196,2096.359375 -44.18797492980957,2096.359375 -44.24800705909729,2096.359375 -44.308034896850586,2096.359375 -44.36806297302246,2123.40625 -44.42809510231018,2123.40625 -44.48812913894653,2082.25 -44.54816293716431,1710.203125 -44.60819602012634,1710.203125 -44.66823101043701,1710.203125 -44.724956035614014,1710.203125 -44.784985065460205,1710.21875 -44.84501910209656,1710.21875 -44.90506410598755,1710.25 -44.957255125045776,1710.25 -45.017290115356445,1710.296875 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__cell__topotune/memory_plot_normalized.png deleted file mode 100644 index 2261edd88ce850d58f6e7e0ed4c5e145ebe6deba..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 39804 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 z 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 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv deleted file mode 100644 index 7a4147171..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake.csv +++ /dev/null @@ -1,72 +0,0 @@ -time_s,memory_MB -2.5987625122070312e-05,0.515625 -0.05507612228393555,25.984375 -0.11010503768920898,38.75 -0.16513991355895996,65.90625 -0.22017502784729004,99.765625 -0.2772369384765625,127.859375 -0.33347606658935547,150.5625 -0.3901660442352295,162.34375 -0.446382999420166,168.921875 -0.4980320930480957,176.15625 -0.5519368648529053,187.515625 -0.6069607734680176,197.171875 -0.6619818210601807,203.59375 -0.7170050144195557,214.125 -0.7720298767089844,228.75 -0.8270549774169922,241.484375 -0.8820829391479492,252.40625 -0.9371178150177002,259.359375 -0.9887259006500244,267.5625 -1.0437560081481934,273.140625 -1.0987858772277832,282.5625 -1.1538138389587402,291.71875 -1.2088418006896973,304.8125 -1.2638640403747559,314.4375 -1.318889856338501,323.3125 -1.3739230632781982,330.1875 -1.428952932357788,340.1875 -1.4839799404144287,349.40625 -1.5390000343322754,362.234375 -1.5940289497375488,386.84375 -1.6490559577941895,393.34375 -1.7040929794311523,401.875 -1.7591280937194824,413.421875 -1.8100578784942627,424.671875 -1.8650898933410645,433.421875 -1.9201221466064453,442.453125 -1.9727180004119873,448.71875 -2.0277469158172607,456.65625 -2.07938289642334,463.78125 -2.134410858154297,466.6875 -2.1894419193267822,468.46875 -2.244468927383423,469.9375 -2.298341751098633,476.984375 -2.352308988571167,483.46875 -2.404711961746216,493.546875 -2.458678960800171,498.5625 -2.51370906829834,504.109375 -2.5687568187713623,554.234375 -2.6207189559936523,568.5 -2.675801992416382,570.5625 -2.730849027633667,571.71875 -2.7858810424804688,606.953125 -2.840913772583008,607.0 -2.8959500789642334,619.75 -2.950983762741089,626.984375 -3.006021738052368,626.984375 -3.061053991317749,679.265625 -3.1160879135131836,679.265625 -3.1711227893829346,679.265625 -3.2261528968811035,679.265625 -3.281181812286377,685.21875 -3.33621883392334,685.28125 -3.3894739151000977,685.59375 -3.444511890411377,685.59375 -3.4995598793029785,685.59375 -3.5546109676361084,685.59375 -3.609644889831543,685.609375 -3.664702892303467,685.875 -3.719740867614746,685.90625 -3.774772882461548,685.90625 -3.829810857772827,685.96875 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv deleted file mode 100644 index 611db629b..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/graph__gcn__fake_inmem.csv +++ /dev/null @@ -1,75 +0,0 @@ -time_s,memory_MB -3.1948089599609375e-05,0.171875 -0.051419734954833984,22.703125 -0.10647702217102051,32.453125 -0.16150593757629395,41.09375 -0.21654391288757324,79.78125 -0.2781028747558594,120.546875 -0.3287777900695801,139.03125 -0.38186001777648926,154.046875 -0.4347388744354248,162.125 -0.48984694480895996,167.1875 -0.5448818206787109,176.09375 -0.5953888893127441,186.6875 -0.6504178047180176,197.15625 -0.7054398059844971,204.28125 -0.7604677677154541,215.234375 -0.8155057430267334,227.578125 -0.8673849105834961,241.171875 -0.9224140644073486,252.90625 -0.977435827255249,257.328125 -1.0324609279632568,264.34375 -1.0875067710876465,273.40625 -1.1425299644470215,283.34375 -1.1975510120391846,293.515625 -1.2525818347930908,305.09375 -1.3076090812683105,313.84375 -1.3626370429992676,326.78125 -1.4176619052886963,330.953125 -1.4726898670196533,341.328125 -1.5277187824249268,350.453125 -1.5827507972717285,361.953125 -1.635375738143921,381.90625 -1.6904067993164062,392.828125 -1.7454447746276855,402.625 -1.800475835800171,415.46875 -1.8554987907409668,425.6875 -1.9105257987976074,437.03125 -1.9655518531799316,443.609375 -2.020576000213623,448.34375 -2.0756008625030518,458.09375 -2.1306278705596924,465.578125 -2.185661792755127,467.84375 -2.2406938076019287,470.078125 -2.2957160472869873,471.546875 -2.350738763809204,476.28125 -2.405771017074585,486.203125 -2.4599969387054443,495.15625 -2.515030860900879,510.640625 -2.570060968399048,542.390625 -2.6250879764556885,616.515625 -2.677243709564209,629.4375 -2.732282876968384,633.96875 -2.7873167991638184,651.3125 -2.8423609733581543,686.90625 -2.894052743911743,712.484375 -2.949090003967285,713.421875 -3.0041210651397705,715.03125 -3.0591609477996826,715.046875 -3.114189863204956,740.78125 -3.169217824935913,740.78125 -3.22426700592041,740.78125 -3.279294967651367,740.78125 -3.3343358039855957,740.78125 -3.3847107887268066,740.78125 -3.439743995666504,766.46875 -3.494767665863037,773.109375 -3.5498127937316895,773.109375 -3.6048519611358643,773.109375 -3.65989089012146,773.109375 -3.7149298191070557,773.109375 -3.7699670791625977,773.125 -3.824997663497925,773.125 -3.880037784576416,773.140625 -3.935072898864746,773.140625 -3.990103006362915,773.234375 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__graph__gcn/memory_plot_normalized.png deleted file mode 100644 index 577049471783d6afe7c1b7e3e49e90526ad1ee03..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 42639 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 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/memory_plot_normalized.png deleted file mode 100644 index 3c978bea6e50f36995670527750f78e3a6f52634..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 47281 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�u1qv!pzE90YdOEL}PZ}BJuq)O0EfX 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 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv deleted file mode 100644 index 2f05c0a2d..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake.csv +++ /dev/null @@ -1,192 +0,0 @@ -time_s,memory_MB -2.7894973754882812e-05,0.515625 -0.05098390579223633,20.484375 -0.11100602149963379,31.390625 -0.17103314399719238,40.125 -0.23106098175048828,72.015625 -0.2910888195037842,114.75 -0.3513500690460205,135.796875 -0.4114079475402832,151.453125 -0.468533992767334,160.34375 -0.5202350616455078,166.328125 -0.5802559852600098,174.640625 -0.64028000831604,186.78125 -0.7003037929534912,195.484375 -0.7603390216827393,202.03125 -0.8203690052032471,213.75 -0.8804049491882324,221.234375 -0.9404540061950684,235.40625 -1.0004830360412598,245.28125 -1.0605151653289795,251.859375 -1.120548963546753,258.078125 -1.1805791854858398,262.453125 -1.2406079769134521,271.96875 -1.3006348609924316,276.53125 -1.3606610298156738,282.6875 -1.420685052871704,290.078125 -1.4807169437408447,299.40625 -1.5407490730285645,309.59375 -1.600773811340332,316.75 -1.6608059406280518,328.71875 -1.7208359241485596,333.0625 -1.7808630466461182,341.203125 -1.8408870697021484,347.8125 -1.9009130001068115,355.25 -1.9609458446502686,363.34375 -2.0136098861694336,373.5625 -2.073683023452759,389.4375 -2.1337289810180664,401.3125 -2.1937599182128906,408.046875 -2.25378680229187,417.609375 -2.313817024230957,427.125 -2.3738460540771484,434.265625 -2.4338738918304443,440.453125 -2.4939000606536865,451.1875 -2.553926944732666,457.359375 -2.6139578819274902,460.984375 -2.673983097076416,466.0625 -2.7340140342712402,468.109375 -2.7940380573272705,469.640625 -2.854059934616089,476.625 -2.914083957672119,488.671875 -2.9655659198760986,493.671875 -3.021054983139038,506.203125 -3.0722758769989014,509.875 -3.132309913635254,510.03125 -3.184264898300171,510.265625 -3.244292974472046,515.546875 -3.304331064224243,676.09375 -3.354951858520508,877.5 -3.4149909019470215,987.90625 -3.4750280380249023,1011.1875 -3.5350589752197266,892.140625 -3.5869460105895996,989.046875 -3.6469919681549072,1044.3125 -3.707026958465576,1055.265625 -3.767058849334717,1055.265625 -3.8270998001098633,964.859375 -3.887136936187744,1040.5625 -3.9471828937530518,1066.015625 -4.007214784622192,1066.015625 -4.067253112792969,1070.953125 -4.127281904220581,1089.890625 -4.187314033508301,1105.953125 -4.247349977493286,1123.15625 -4.307376861572266,1020.734375 -4.36740779876709,1134.109375 -4.42743706703186,1154.453125 -4.487468957901001,1157.84375 -4.5475099086761475,1157.859375 -4.607547998428345,1052.8125 -4.667582988739014,1052.84375 -4.727622985839844,1142.109375 -4.778936147689819,1142.125 -4.8389739990234375,1142.125 -4.8990159034729,1142.140625 -4.959053039550781,1172.796875 -5.010929822921753,1187.453125 -5.070976972579956,1231.5625 -5.122921943664551,1231.59375 -5.18294882774353,1103.796875 -5.242978096008301,1170.84375 -5.303008079528809,1178.6875 -5.363039970397949,1178.703125 -5.423080921173096,1207.53125 -5.4831249713897705,1091.515625 -5.543152809143066,1170.046875 -5.6031858921051025,1197.296875 -5.654855966567993,1213.328125 -5.7069079875946045,1085.59375 -5.764301061630249,1158.03125 -5.8243348598480225,1173.078125 -5.884387731552124,1208.015625 -5.936255931854248,1208.015625 -5.996281862258911,1086.609375 -6.056315898895264,1170.0 -6.116353988647461,1214.359375 -6.176386117935181,1214.359375 -6.236418962478638,1086.375 -6.296444892883301,1137.5 -6.356472015380859,1209.28125 -6.4165198802948,1209.3125 -6.476553916931152,1209.3125 -6.536579847335815,1082.4375 -6.596611738204956,1135.40625 -6.65663480758667,1136.0625 -6.7166619300842285,1136.0625 -6.776684999465942,1136.140625 -6.83671498298645,1136.140625 -6.896742820739746,1136.28125 -6.956768989562988,1172.5 -7.01680588722229,1206.984375 -7.0768351554870605,1206.984375 -7.136858940124512,1079.140625 -7.1906208992004395,1119.53125 -7.24291205406189,1185.625 -7.3029608726501465,1231.359375 -7.362997055053711,1231.359375 -7.423030138015747,1103.5625 -7.483073949813843,1171.609375 -7.543118953704834,1214.578125 -7.603178024291992,1215.40625 -7.653575897216797,1215.421875 -7.713608026504517,1180.046875 -7.7736358642578125,1205.125 -7.833667755126953,1221.984375 -7.893693923950195,1221.984375 -7.953717947006226,1102.765625 -8.01374888420105,1201.5 -8.07378101348877,1201.53125 -8.133811950683594,1201.53125 -8.193838834762573,1201.53125 -8.253865003585815,1201.53125 -8.313893795013428,1201.53125 -8.373925924301147,1211.59375 -8.43395209312439,1211.59375 -8.493993997573853,1114.140625 -8.544235944747925,1205.90625 -8.604276895523071,1205.90625 -8.66107177734375,1205.90625 -8.721114873886108,1205.984375 -8.773550748825073,1206.0 -8.825335025787354,1206.015625 -8.885371923446655,1259.34375 -8.94540810585022,1259.390625 -9.005429983139038,1131.765625 -9.06546401977539,1205.1875 -9.125511884689331,1210.109375 -9.17622995376587,1210.109375 -9.236270904541016,1210.125 -9.28821611404419,1210.1875 -9.348242998123169,1210.28125 -9.408273935317993,1210.28125 -9.468300104141235,1210.28125 -9.528320074081421,1210.28125 -9.583738803863525,1210.28125 -9.643770933151245,1229.984375 -9.703819036483765,1235.625 -9.75487995147705,1235.625 -9.814916849136353,1156.1875 -9.874944925308228,1209.203125 -9.934991836547852,1249.203125 -9.986894130706787,1249.296875 -10.046926736831665,1123.3125 -10.098874807357788,1176.1875 -10.158918857574463,1183.796875 -10.21894884109497,1183.796875 -10.278982877731323,1183.796875 -10.330873966217041,1183.796875 -10.390896797180176,1183.90625 -10.450926065444946,1184.84375 -10.510953903198242,1184.84375 -10.570990085601807,1184.84375 -10.631033897399902,1184.84375 -10.691067934036255,1184.84375 -10.751112937927246,1184.84375 -10.811145067214966,1184.84375 -10.86421513557434,1184.859375 -10.92424988746643,1184.921875 -10.984280109405518,1184.96875 -11.044331073760986,1184.96875 -11.096199035644531,1185.046875 -11.156227827072144,1202.78125 diff --git a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv b/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv deleted file mode 100644 index 4e01b1438..000000000 --- a/test/memory_usage_tracking/outputs/fake_inmem__fake__simplicial__topotune/simplicial__topotune__fake_inmem.csv +++ /dev/null @@ -1,672 +0,0 @@ -time_s,memory_MB -4.100799560546875e-05,0.125 -0.060099124908447266,26.453125 -0.11203312873840332,39.15625 -0.17206788063049316,71.765625 -0.2240431308746338,104.28125 -0.28447604179382324,133.15625 -0.3431241512298584,151.5 -0.4075779914855957,162.015625 -0.46924614906311035,169.75 -0.5234909057617188,175.671875 -0.5760300159454346,188.109375 -0.6360540390014648,199.671875 -0.6960771083831787,206.234375 -0.7560992240905762,214.625 -0.8161249160766602,235.78125 -0.8761579990386963,248.109375 -0.928023099899292,255.015625 -0.9880521297454834,260.125 -1.048086166381836,272.046875 -1.1081140041351318,280.4375 -1.168138027191162,290.421875 -1.228165864944458,304.09375 -1.2882120609283447,313.828125 -1.3386940956115723,323.859375 -1.3987281322479248,330.890625 -1.4587531089782715,342.109375 -1.5187809467315674,353.578125 -1.578813076019287,368.265625 -1.6293561458587646,389.203125 -1.6893880367279053,402.171875 -1.7494218349456787,407.53125 -1.8000259399414062,417.921875 -1.8600609302520752,430.28125 -1.9120211601257324,439.28125 -1.972053050994873,444.515625 -2.0240190029144287,451.359375 -2.0840489864349365,462.828125 -2.1440751552581787,468.75 -2.204102039337158,469.1875 -2.264129161834717,470.796875 -2.3241560459136963,477.859375 -2.3817832469940186,490.203125 -2.440110921859741,498.953125 -2.490684986114502,514.4375 -2.5507171154022217,553.328125 -2.6026699542999268,558.25 -2.6627140045166016,558.34375 -2.722743034362793,560.03125 -2.7827699184417725,560.828125 -2.8346681594848633,562.59375 -2.894688129425049,564.484375 -2.954700231552124,564.90625 -3.014719009399414,568.015625 -3.0747339725494385,569.015625 -3.1347548961639404,569.71875 -3.1866610050201416,570.328125 -3.2466819286346436,571.40625 -3.29866099357605,571.8125 -3.358680248260498,573.265625 -3.418701171875,574.078125 -3.4787259101867676,577.015625 -3.538743019104004,578.890625 -3.5987548828125,580.28125 -3.6587700843811035,581.5625 -3.718787908554077,582.546875 -3.7788031101226807,585.046875 -3.838818073272705,586.609375 -3.898839235305786,587.734375 -3.949341058731079,588.71875 -4.009371995925903,588.515625 -4.0613250732421875,589.53125 -4.121340990066528,590.8125 -4.1813578605651855,591.453125 -4.241374969482422,591.765625 -4.301399230957031,592.484375 -4.361423015594482,592.5 -4.421440124511719,593.171875 -4.481463193893433,593.453125 -4.541481971740723,593.921875 -4.60149621963501,593.921875 -4.661512136459351,594.765625 -4.721528053283691,594.921875 -4.781545162200928,595.640625 -4.8415608406066895,596.265625 -4.901579141616821,597.03125 -4.961592197418213,597.1875 -5.021605014801025,597.65625 -5.081624269485474,599.0 -5.141639947891235,599.34375 -5.201669931411743,599.46875 -5.261696100234985,599.875 -5.321712017059326,600.21875 -5.3817291259765625,600.234375 -5.44175386428833,601.28125 -5.50177001953125,601.296875 -5.561785936355591,601.296875 -5.621803045272827,602.15625 -5.681822061538696,602.296875 -5.741851091384888,603.3125 -5.791975021362305,604.171875 -5.851997137069702,604.546875 -5.903970956802368,604.578125 -5.963990211486816,604.578125 -6.024017095565796,606.828125 -6.084028959274292,607.71875 -6.144045114517212,607.953125 -6.204057931900024,607.953125 -6.264074087142944,608.421875 -6.32409405708313,608.84375 -6.38411808013916,609.5 -6.444155931472778,609.625 -6.504181146621704,610.046875 -6.56420111656189,610.046875 -6.624215126037598,610.046875 -6.684231996536255,610.59375 -6.74425196647644,611.0625 -6.80426812171936,611.546875 -6.864284038543701,612.03125 -6.924301862716675,612.234375 -6.984320163726807,612.234375 -7.044347047805786,613.25 -7.1043641567230225,613.296875 -7.164381980895996,613.3125 -7.224400043487549,613.890625 -7.284415006637573,614.25 -7.344436168670654,614.953125 -7.4044508934021,615.171875 -7.46447491645813,615.34375 -7.514623165130615,616.6875 -7.57464599609375,616.734375 -7.634675025939941,616.765625 -7.694701194763184,617.328125 -7.754725933074951,617.328125 -7.805289030075073,617.921875 -7.865311145782471,617.921875 -7.925325155258179,617.921875 -7.9853410720825195,618.109375 -8.045356035232544,619.828125 -8.105375051498413,619.828125 -8.157292127609253,620.59375 -8.217311143875122,621.515625 -8.27732801437378,621.9375 -8.337346076965332,621.984375 -8.397361040115356,623.78125 -8.457381010055542,624.171875 -8.51739501953125,625.203125 -8.577407121658325,625.21875 -8.637421131134033,625.671875 -8.69286298751831,626.28125 -8.743943929672241,626.28125 -8.803966045379639,626.375 -8.863983869552612,626.53125 -8.924020051956177,626.53125 -8.984040975570679,626.796875 -9.044060945510864,627.03125 -9.095943927764893,628.21875 -9.155963897705078,628.75 -9.215978145599365,628.75 -9.275995969772339,629.359375 -9.336011171340942,629.375 -9.396032094955444,630.96875 -9.456048011779785,631.125 -9.516064167022705,631.34375 -9.576082944869995,631.9375 -9.63610291481018,633.296875 -9.696125984191895,633.59375 -9.756145000457764,634.15625 -9.816160202026367,635.53125 -9.876180171966553,636.28125 -9.936195135116577,636.609375 -9.996208906173706,636.8125 -10.056230068206787,636.8125 -10.11626410484314,637.59375 -10.176299095153809,637.5 -10.236323833465576,637.640625 -10.296342134475708,638.359375 -10.356359004974365,639.265625 -10.416381120681763,640.875 -10.466602087020874,640.921875 -10.52662992477417,641.71875 -10.578598022460938,642.484375 -10.638617038726807,643.28125 -10.698632001876831,643.53125 -10.758648872375488,644.09375 -10.818665027618408,645.34375 -10.878683090209961,645.765625 -10.938702821731567,645.984375 -10.989261865615845,647.140625 -11.049276113510132,647.3125 -11.109291076660156,647.484375 -11.169309139251709,648.109375 -11.229324102401733,648.78125 -11.289345026016235,648.890625 -11.349376201629639,648.890625 -11.409401893615723,648.890625 -11.46942400932312,649.96875 -11.519921064376831,650.515625 -11.579939842224121,650.625 -11.639958143234253,651.0625 -11.699980020523071,651.71875 -11.751923084259033,653.359375 -11.811944961547852,653.515625 -11.863922119140625,654.34375 -11.923939943313599,655.21875 -11.983957052230835,655.40625 -12.043972969055176,656.671875 -12.103992223739624,656.875 -12.164008140563965,657.625 -12.224030017852783,658.578125 -12.27458119392395,658.71875 -12.334602117538452,659.125 -12.394626140594482,659.421875 -12.454648971557617,660.0 -12.514663934707642,660.703125 -12.574680805206299,661.09375 -12.634721040725708,662.34375 -12.6947500705719,662.34375 -12.754767894744873,662.484375 -12.814790964126587,663.9375 -12.874817132949829,664.390625 -12.925249099731445,664.671875 -12.985272884368896,665.109375 -13.037245035171509,665.15625 -13.097269058227539,665.59375 -13.157285928726196,665.828125 -13.217300176620483,665.890625 -13.277315855026245,666.171875 -13.33733320236206,668.28125 -13.397346258163452,668.46875 -13.457368850708008,668.703125 -13.517383098602295,670.15625 -13.577404975891113,670.3125 -13.637420177459717,670.796875 -13.697441101074219,670.953125 -13.757454872131348,671.078125 -13.817476987838745,671.140625 -13.87749195098877,672.59375 -13.937527179718018,673.390625 -13.997551918029785,673.421875 -14.057574033737183,673.671875 -14.117595911026001,675.296875 -14.177613258361816,675.59375 -14.237634181976318,676.875 -14.297652006149292,677.09375 -14.357671022415161,677.171875 -14.417694091796875,678.046875 -14.469232082366943,678.1875 -14.529253005981445,680.59375 -14.589269161224365,681.265625 -14.64928913116455,682.203125 -14.709306955337524,683.140625 -14.769320011138916,683.21875 -14.829342126846313,683.609375 -14.889362096786499,684.578125 -14.949390888214111,685.890625 -15.009416103363037,686.28125 -15.061228036880493,686.484375 -15.121248006820679,686.640625 -15.181279182434082,686.671875 -15.241302013397217,687.421875 -15.301321029663086,687.8125 -15.361341953277588,689.171875 -15.42136001586914,689.609375 -15.481383085250854,689.90625 -15.541406154632568,691.015625 -15.5918869972229,691.359375 -15.651904106140137,691.515625 -15.711920976638794,691.703125 -15.771936178207397,691.9375 -15.831953048706055,692.125 -15.891976118087769,694.265625 -15.951997995376587,694.984375 -16.012014865875244,695.375 -16.072037935256958,695.59375 -16.132056951522827,695.6875 -16.192080974578857,696.28125 -16.247886896133423,697.0625 -16.30790615081787,697.90625 -16.367926120758057,698.78125 -16.42795205116272,698.78125 -16.48797082901001,699.4375 -16.547992944717407,699.75 -16.608012199401855,700.203125 -16.668027877807617,700.328125 -16.728044033050537,700.9375 -16.788058042526245,702.0625 -16.84807300567627,702.171875 -16.90809202194214,702.296875 -16.968106031417847,704.171875 -17.025609016418457,704.34375 -17.085636854171753,704.4375 -17.135874032974243,704.734375 -17.195889949798584,707.0625 -17.255905151367188,707.296875 -17.31591510772705,708.65625 -17.37593102455139,708.84375 -17.43594980239868,709.765625 -17.49596405029297,710.765625 -17.55598020553589,710.828125 -17.616007089614868,710.84375 -17.676030158996582,711.234375 -17.736045122146606,711.5 -17.79606008529663,712.140625 -17.85607624053955,712.609375 -17.916097164154053,714.078125 -17.969887018203735,714.5 -18.02657914161682,715.765625 -18.08659601211548,715.8125 -18.1466121673584,716.15625 -18.206637144088745,716.984375 -18.266649961471558,717.734375 -18.32666802406311,717.75 -18.38669204711914,718.328125 -18.446710109710693,718.640625 -18.50673222541809,720.015625 -18.566749095916748,720.15625 -18.62676692008972,720.59375 -18.686782121658325,721.46875 -18.746806144714355,721.859375 -18.806822061538696,722.71875 -18.866843938827515,723.703125 -18.92687702178955,723.921875 -18.98690104484558,724.78125 -19.046916961669922,726.1875 -19.106935024261475,726.5 -19.166950941085815,726.90625 -19.226969003677368,727.984375 -19.286983966827393,729.3125 -19.347000122070312,729.453125 -19.407021045684814,729.90625 -19.467041015625,731.3125 -19.527063131332397,731.640625 -19.58708906173706,731.8125 -19.637192010879517,731.9375 -19.697205066680908,732.234375 -19.757222890853882,734.3125 -19.8172390460968,734.578125 -19.877272844314575,734.765625 -19.93729019165039,735.1875 -19.989903926849365,735.5 -20.04992699623108,736.515625 -20.10118317604065,736.71875 -20.16119885444641,738.15625 -20.22123098373413,738.171875 -20.281261920928955,738.359375 -20.33318305015564,738.46875 -20.393197059631348,739.234375 -20.453213930130005,739.53125 -20.513235092163086,740.15625 -20.565176248550415,741.0625 -20.625197172164917,741.734375 -20.685218811035156,743.578125 -20.745244026184082,743.84375 -20.79717516899109,744.515625 -20.8571879863739,744.671875 -20.917206048965454,745.0 -20.97722601890564,745.140625 -21.031247854232788,745.90625 -21.091267108917236,747.015625 -21.151286125183105,747.453125 -21.211302995681763,748.828125 -21.271319150924683,749.875 -21.331333875656128,750.734375 -21.391348123550415,750.9375 -21.451378107070923,751.078125 -21.51140785217285,752.28125 -21.562505960464478,752.3125 -21.62252712249756,753.578125 -21.682552099227905,754.34375 -21.742581129074097,755.328125 -21.79450297355652,755.4375 -21.854525089263916,755.75 -21.90650510787964,756.921875 -21.966521978378296,756.984375 -22.02654194831848,757.5 -22.086560010910034,758.15625 -22.146581172943115,758.859375 -22.206605911254883,759.546875 -22.25849986076355,759.96875 -22.318521976470947,760.578125 -22.370498180389404,761.34375 -22.43051505088806,761.46875 -22.49053716659546,762.8125 -22.55055022239685,763.609375 -22.610594034194946,763.765625 -22.661167860031128,763.765625 -22.72118616104126,763.890625 -22.781203031539917,764.484375 -22.841229915618896,764.796875 -22.89315700531006,765.15625 -22.95317506790161,767.203125 -23.01318883895874,768.15625 -23.073204040527344,768.234375 -23.133220911026,768.84375 -23.193239212036133,769.671875 -23.253253936767578,769.734375 -23.313267946243286,770.703125 -23.373289108276367,771.265625 -23.43330407142639,772.4375 -23.493327856063843,772.703125 -23.55334782600403,772.8125 -23.613365173339844,774.40625 -23.673380851745605,774.796875 -23.733393907546997,774.90625 -23.793421030044556,775.03125 -23.84517216682434,775.109375 -23.905194997787476,776.265625 -23.965214014053345,776.453125 -24.020509958267212,776.796875 -24.080533027648926,777.03125 -24.13314700126648,778.34375 -24.1931631565094,778.625 -24.253177881240845,780.15625 -24.313199996948242,780.34375 -24.373216152191162,782.421875 -24.43323302268982,782.703125 -24.493247985839844,782.984375 -24.553267002105713,783.0625 -24.61328911781311,783.234375 -24.663811206817627,783.515625 -24.72383213043213,785.4375 -24.77581024169922,785.75 -24.835832118988037,786.625 -24.8878071308136,786.890625 -24.94782590866089,788.25 -25.007848978042603,788.8125 -25.06786799430847,788.828125 -25.119812965393066,789.25 -25.17985486984253,790.203125 -25.23181390762329,790.71875 -25.291833877563477,791.140625 -25.351850032806396,791.25 -25.41186499595642,791.578125 -25.471885204315186,791.59375 -25.52246904373169,793.875 -25.58248519897461,794.171875 -25.64250087738037,794.6875 -25.702522039413452,795.140625 -25.762547969818115,796.0625 -25.82257318496704,797.234375 -25.87447214126587,797.828125 -25.93449306488037,798.75 -25.986464023590088,798.984375 -26.041547060012817,799.0625 -26.09313201904297,799.8125 -26.153154134750366,799.921875 -26.21316909790039,800.03125 -26.27318501472473,800.53125 -26.333199977874756,800.859375 -26.393213033676147,802.5625 -26.453235149383545,802.640625 -26.513253927230835,803.515625 -26.5732901096344,804.671875 -26.633321046829224,805.8125 -26.693344116210938,806.015625 -26.753363132476807,807.703125 -26.813387155532837,807.953125 -26.863797187805176,808.59375 -26.92381191253662,809.046875 -26.983827114105225,809.234375 -27.043605089187622,809.921875 -27.095789194107056,810.0625 -27.15580701828003,810.375 -27.215819120407104,811.0 -27.27583909034729,811.71875 -27.335856914520264,812.515625 -27.395878076553345,813.765625 -27.447789192199707,814.296875 -27.507806062698364,814.875 -27.567821264266968,815.421875 -27.62783908843994,815.9375 -27.687853813171387,816.1875 -27.74786901473999,818.265625 -27.80788516998291,818.578125 -27.862235069274902,818.578125 -27.922266006469727,818.640625 -27.982293128967285,818.96875 -28.042315006256104,819.34375 -28.102336168289185,819.5 -28.162360191345215,820.875 -28.222381114959717,821.90625 -28.27444887161255,822.109375 -28.33446502685547,823.59375 -28.39447784423828,823.90625 -28.454496145248413,824.84375 -28.514509916305542,825.015625 -28.57452702522278,827.03125 -28.634541988372803,827.453125 -28.694556951522827,827.65625 -28.754578113555908,827.875 -28.805108070373535,828.015625 -28.865127086639404,829.890625 -28.92514204978943,831.46875 -28.985177993774414,831.546875 -29.04520297050476,831.5625 -29.10522699356079,832.5 -29.165245056152344,832.875 -29.225265979766846,833.921875 -29.28528594970703,834.296875 -29.345298051834106,834.84375 -29.405312061309814,835.03125 -29.46532893180847,835.875 -29.52535104751587,837.546875 -29.58537721633911,837.71875 -29.6453959941864,837.828125 -29.705415964126587,838.1875 -29.765435934066772,838.421875 -29.825448989868164,839.25 -29.885467052459717,839.671875 -29.945483207702637,840.640625 -30.005497932434082,841.375 -30.065516233444214,842.765625 -30.12553310394287,843.03125 -30.18554925918579,844.625 -30.245573043823242,844.921875 -30.295765161514282,845.296875 -30.35579204559326,845.5 -30.415821075439453,846.078125 -30.466432094573975,846.28125 -30.526448011398315,846.53125 -30.586466789245605,847.46875 -30.646486043930054,847.953125 -30.706501007080078,848.640625 -30.766517162322998,849.84375 -30.826531887054443,849.921875 -30.87658405303955,850.28125 -30.936607122421265,851.8125 -30.996623992919922,852.40625 -31.056641101837158,852.484375 -31.1166570186615,852.625 -31.176680088043213,853.0625 -31.236701011657715,854.53125 -31.293102979660034,1044.171875 -31.35314702987671,1245.765625 -31.413175106048584,1245.765625 -31.473201990127563,1361.609375 -31.53324007987976,1534.6875 -31.593273878097534,1302.359375 -31.65330219268799,1339.046875 -31.7133309841156,1339.15625 -31.77336883544922,1342.109375 -31.833409070968628,1363.984375 -31.887085914611816,1528.8125 -31.94713807106018,1682.234375 -32.00719690322876,1683.296875 -32.06630611419678,1683.359375 -32.11868715286255,1684.296875 -32.17872595787048,1739.953125 -32.23838019371033,1749.671875 -32.290436029434204,1749.671875 -32.35047101974487,1749.671875 -32.40323996543884,1754.75 -32.455771923065186,1766.34375 -32.515820026397705,1778.640625 -32.57293391227722,1778.65625 -32.632899045944214,1866.921875 -32.69295287132263,1943.53125 -32.752992153167725,1943.53125 -32.805535078048706,1943.53125 -32.855754137039185,1943.53125 -32.915791034698486,1943.625 -32.97584295272827,1943.640625 -33.035887002944946,1943.640625 -33.093411922454834,1943.65625 -33.14376091957092,1943.65625 -33.20324683189392,1983.234375 -33.262633085250854,1988.34375 -33.31443691253662,1988.34375 -33.37447905540466,2019.15625 -33.43349099159241,2056.0625 -33.49353504180908,2056.65625 -33.5437650680542,2056.65625 -33.6038019657135,2056.65625 -33.663838148117065,2056.65625 -33.717092990875244,2056.734375 -33.77713322639465,2056.734375 -33.83301901817322,2056.734375 -33.89305806159973,2056.734375 -33.95309019088745,2056.734375 -34.01312494277954,2056.734375 -34.073172092437744,2056.734375 -34.13319802284241,2056.734375 -34.19322919845581,2056.734375 -34.253260135650635,2056.734375 -34.31329607963562,2056.734375 -34.37331700325012,2056.734375 -34.43334412574768,2087.578125 -34.493388175964355,2087.578125 -34.543757915496826,2087.578125 -34.60379910469055,2087.578125 -34.66383218765259,2087.578125 -34.71927094459534,2087.578125 -34.779306173324585,2087.578125 -34.839341163635254,2087.578125 -34.89936399459839,2087.578125 -34.95939898490906,2087.578125 -35.01941990852356,2088.0625 -35.079469203948975,2088.140625 -35.13840103149414,2088.140625 -35.198429107666016,2088.140625 -35.25846314430237,2088.140625 -35.31849408149719,2088.5625 -35.37854290008545,2088.5625 -35.42907404899597,2088.5625 -35.48910903930664,2088.5625 -35.549155950546265,2088.5625 -35.60919713973999,2088.5625 -35.6692419052124,2088.5625 -35.72506403923035,2088.5625 -35.78510022163391,2088.5625 -35.845134019851685,2088.5625 -35.89573907852173,2088.5625 -35.955782890319824,2088.5625 -36.00773096084595,2088.5625 -36.06778001785278,2088.5625 -36.11973524093628,2088.5625 -36.17976713180542,2088.5625 -36.23980093002319,2088.5625 -36.29039812088013,2088.5625 -36.35042905807495,2088.5625 -36.41047501564026,2088.5625 -36.470508098602295,2088.5625 -36.53054189682007,2088.5625 -36.59058499336243,2088.5625 -36.642395973205566,2088.5625 -36.70243000984192,2088.5625 -36.76245903968811,2088.5625 -36.82249188423157,2088.5625 -36.8825261592865,2090.9375 -36.942553997039795,2090.9375 -37.00258708000183,2090.9375 -37.06259202957153,2090.9375 -37.12263202667236,2090.9375 -37.1826651096344,2090.9375 -37.24269127845764,2090.9375 -37.302730083465576,2090.9375 -37.354384899139404,2090.953125 -37.414422035217285,2090.953125 -37.474454164505005,2090.953125 -37.53449201583862,2090.953125 -37.59453010559082,2090.953125 -37.645055055618286,2091.046875 -37.70508289337158,2091.046875 -37.7651150226593,2091.046875 -37.825154066085815,2091.046875 -37.885180950164795,2091.046875 -37.94521403312683,2091.046875 -38.00524401664734,2091.078125 -38.06527805328369,2091.078125 -38.12530994415283,2091.078125 -38.18535089492798,2091.078125 -38.24538207054138,2091.078125 -38.29571604728699,2091.078125 -38.355754137039185,2091.078125 -38.4157829284668,2091.078125 -38.47581100463867,2091.078125 -38.53584003448486,2091.078125 -38.59586215019226,2091.09375 -38.65590310096741,2091.09375 -38.70639109611511,2091.09375 -38.7664258480072,2091.09375 -38.82645606994629,2091.109375 -38.88649606704712,2075.109375 -38.93838119506836,1870.5 -38.998425006866455,1870.5 -39.05847406387329,1870.5 -39.10905313491821,1870.515625 -39.169090032577515,1870.515625 -39.22911810874939,1869.953125 -39.28914499282837,1869.953125 -39.349180936813354,1868.96875 From 4ed754c3aa9729f3ef905fc80fa9f9f97084590b Mon Sep 17 00:00:00 2001 From: David Leko Date: Wed, 19 Nov 2025 22:59:34 +0100 Subject: [PATCH 08/11] B1 Bonus. --- .gitignore | 1 + .../cocitation_citeseer_for_partitioning.yaml | 55 + .../graph/cocitation_citeseer_on_disk.yaml | 55 + .../cocitation_cora_for_partitioning.yaml | 55 + .../graph/cocitation_cora_on_disk.yaml | 55 + .../cocitation_pubmed_for_partitioning.yaml | 55 + .../graph/cocitation_pubmed_on_disk.yaml | 55 + configs/dataset/graph/reddit.yaml | 36 + .../graph/reddit_for_partitioning.yaml | 55 + test/_utils/simplified_pipeline.py | 82 +- test/data/__init__.py | 2 +- test/data/dataload/test_Dataloaders.py | 14 +- test/data/dataload/test_dataload_cluster.py | 274 +++++ test/data/load/test_datasetloaders.py | 3 +- test/data/load/test_on_disk_datasetloaders.py | 11 +- test/data/preprocess/__init__.py | 2 +- .../preprocess/test_on_disk_preprocessor.py | 8 +- test/data/preprocess/test_preprocessor.py | 920 ++++++----------- test/data/utils/test_cluster_utils.py | 376 +++++++ test/data/utils/test_data_utils.py | 35 +- test/pipeline/test_pipeline.py | 2 +- .../test_memory_plotting.py | 7 +- test/tools/sweep_tools/test_sweep_cells.py | 387 +++++++ .../sweep_tools/test_sweep_hypergraphs.py | 243 +++++ .../test_sweep_over_epochs_cells.py | 432 ++++++++ .../test_sweep_over_epochs_hypergraphs.py | 287 +++++ tools/sweep_tools/__init__.py | 0 tools/sweep_tools/sweep_cells.py | 942 +++++++++++++++++ tools/sweep_tools/sweep_hypergraphs.py | 640 ++++++++++++ tools/sweep_tools/sweep_over_epochs_cells.py | 976 ++++++++++++++++++ .../sweep_over_epochs_hypergraphs.py | 708 +++++++++++++ .../base_transductive_on_disk_dataset.py | 276 +++++ .../graph/base_transductive_on_disk_loader.py | 79 ++ .../loaders/graph/reddit_dataset_loader.py | 32 + topobench/data/preprocessor/preprocessor.py | 273 ++++- topobench/data/utils/__init__.py | 18 +- topobench/data/utils/cluster_utils.py | 557 ++++++++++ topobench/dataloader/__init__.py | 3 +- topobench/dataloader/dataload_cluster.py | 436 ++++++++ topobench/dataloader/utils.py | 29 + ...torial_on_disk_transductive_pipeline.ipynb | 755 ++++++++++++++ 41 files changed, 8532 insertions(+), 699 deletions(-) create mode 100644 configs/dataset/graph/cocitation_citeseer_for_partitioning.yaml create mode 100644 configs/dataset/graph/cocitation_citeseer_on_disk.yaml create mode 100644 configs/dataset/graph/cocitation_cora_for_partitioning.yaml create mode 100644 configs/dataset/graph/cocitation_cora_on_disk.yaml create mode 100644 configs/dataset/graph/cocitation_pubmed_for_partitioning.yaml create mode 100644 configs/dataset/graph/cocitation_pubmed_on_disk.yaml create mode 100755 configs/dataset/graph/reddit.yaml create mode 100644 configs/dataset/graph/reddit_for_partitioning.yaml create mode 100644 test/data/dataload/test_dataload_cluster.py create mode 100644 test/data/utils/test_cluster_utils.py create mode 100644 test/tools/sweep_tools/test_sweep_cells.py create mode 100644 test/tools/sweep_tools/test_sweep_hypergraphs.py create mode 100644 test/tools/sweep_tools/test_sweep_over_epochs_cells.py create mode 100644 test/tools/sweep_tools/test_sweep_over_epochs_hypergraphs.py create mode 100644 tools/sweep_tools/__init__.py create mode 100644 tools/sweep_tools/sweep_cells.py create mode 100644 tools/sweep_tools/sweep_hypergraphs.py create mode 100644 tools/sweep_tools/sweep_over_epochs_cells.py create mode 100644 tools/sweep_tools/sweep_over_epochs_hypergraphs.py create mode 100644 topobench/data/datasets/base_transductive_on_disk_dataset.py create mode 100644 topobench/data/loaders/graph/base_transductive_on_disk_loader.py create mode 100644 topobench/data/loaders/graph/reddit_dataset_loader.py create mode 100644 topobench/data/utils/cluster_utils.py create mode 100644 topobench/dataloader/dataload_cluster.py create mode 100644 tutorials/tutorial_on_disk_transductive_pipeline.ipynb diff --git a/.gitignore b/.gitignore index 0b561641f..2c25bed61 100755 --- a/.gitignore +++ b/.gitignore @@ -187,6 +187,7 @@ notebooks/tmp /tutorials/datasets/ # Sweep outputs +/tools/sweep_tools/outputs /tools/memory_usage_tracking/outputs # wandb diff --git a/configs/dataset/graph/cocitation_citeseer_for_partitioning.yaml b/configs/dataset/graph/cocitation_citeseer_for_partitioning.yaml new file mode 100644 index 000000000..58f612d5b --- /dev/null +++ b/configs/dataset/graph/cocitation_citeseer_for_partitioning.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.PlanetoidDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: citeseer + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk_cluster # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition settings + cluster: + num_parts: 32 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 3703 + num_classes: 6 + num_nodes: 3327 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/cocitation_citeseer_on_disk.yaml b/configs/dataset/graph/cocitation_citeseer_on_disk.yaml new file mode 100644 index 000000000..349ed716b --- /dev/null +++ b/configs/dataset/graph/cocitation_citeseer_on_disk.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.OnDiskDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: citeseer_on_disk + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition setting + cluster: + num_parts: 32 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 3703 + num_classes: 6 + num_nodes: 3327 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/cocitation_cora_for_partitioning.yaml b/configs/dataset/graph/cocitation_cora_for_partitioning.yaml new file mode 100644 index 000000000..b2d01441f --- /dev/null +++ b/configs/dataset/graph/cocitation_cora_for_partitioning.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.PlanetoidDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: Cora + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk_cluster # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition settings + cluster: + num_parts: 32 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 1433 + num_classes: 7 + num_nodes: 2708 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/cocitation_cora_on_disk.yaml b/configs/dataset/graph/cocitation_cora_on_disk.yaml new file mode 100644 index 000000000..48f8e989f --- /dev/null +++ b/configs/dataset/graph/cocitation_cora_on_disk.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.OnDiskDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: Cora_on_disk + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition setting + cluster: + num_parts: 32 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 1433 + num_classes: 7 + num_nodes: 2708 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/cocitation_pubmed_for_partitioning.yaml b/configs/dataset/graph/cocitation_pubmed_for_partitioning.yaml new file mode 100644 index 000000000..539ee9db4 --- /dev/null +++ b/configs/dataset/graph/cocitation_pubmed_for_partitioning.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.PlanetoidDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: PubMed + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk_cluster # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition settings + cluster: + num_parts: 64 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 500 + num_classes: 3 + num_nodes: 19717 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/cocitation_pubmed_on_disk.yaml b/configs/dataset/graph/cocitation_pubmed_on_disk.yaml new file mode 100644 index 000000000..5a1dd8108 --- /dev/null +++ b/configs/dataset/graph/cocitation_pubmed_on_disk.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.OnDiskDatasetLoader + parameters: + data_domain: graph + data_type: cocitation_on_disk + data_name: PubMed_on_disk + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # Choose memory mode + memory_type: on_disk # "in_memory", "on_disk", or "on_disk_cluster" + + # Global partition setting + cluster: + num_parts: 64 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # Streaming / loader settings for block-wise training + stream: + q: 4 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # How to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters (unchanged) +parameters: + num_features: 500 + num_classes: 3 + num_nodes: 19717 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +# Splits (unchanged; used by pack_global_partition) +split_params: + learning_setting: transductive # transductive # inductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random + k: 10 + train_prop: 0.5 + +# Dataloader parameters for legacy paths (kept; ignored in on_disk_cluster mode) +dataloader_params: + batch_size: 1 + drop_last: True + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/configs/dataset/graph/reddit.yaml b/configs/dataset/graph/reddit.yaml new file mode 100755 index 000000000..7e43d26ea --- /dev/null +++ b/configs/dataset/graph/reddit.yaml @@ -0,0 +1,36 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.RedditDatasetLoader + parameters: + data_domain: graph + data_type: graph + data_name: reddit + subsample_nodes: 2000 + subsample_seed: 42 + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + +# Dataset parameters +parameters: + num_features: 602 + num_classes: 41 + num_nodes: 232965 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +#splits +split_params: + learning_setting: transductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random #'k-fold' # either "k-fold" or "random" strategies + k: 10 # for "k-fold" Cross-Validation + train_prop: 0.5 # for "random" strategy splitting + standardize: False + +# Dataloader parameters +dataloader_params: + batch_size: 1 # Fixed + num_workers: 0 + pin_memory: False diff --git a/configs/dataset/graph/reddit_for_partitioning.yaml b/configs/dataset/graph/reddit_for_partitioning.yaml new file mode 100644 index 000000000..0567844f8 --- /dev/null +++ b/configs/dataset/graph/reddit_for_partitioning.yaml @@ -0,0 +1,55 @@ +# Dataset loader config +loader: + _target_: topobench.data.loaders.RedditDatasetLoader + parameters: + data_domain: graph + data_type: Reddit_on_disk + data_name: Reddit + data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type} + + # NEW: choose memory mode + memory_type: on_disk_cluster # "in_memory", "on_disk", or "on_disk_cluster" + + # NEW: global partition settings (Option B) + cluster: + num_parts: 2048 # number of clusters for single global partition + recursive: false # forwarded to PyG ClusterData + keep_inter_cluster_edges: false # standard Cluster-GCN style + sparse_format: csr # required by our block-stream loader + + # NEW: streaming / loader settings for block-wise training + stream: + q: 8 # clusters per batch (Cluster-GCN "bsize") + num_workers: 0 # increase if needed + pin_memory: false # true if you want faster H2D + with_edge_attr: false # WebKB has no edge_attr + precompute_split_parts: true # write parts_with_{train,val,test}.npy + + # NEW: how to store features on disk + dtype_policy: float32 # current ClusterOnDisk uses float32 + +# Dataset parameters +parameters: + num_features: 602 + num_classes: 41 + num_nodes: 232965 + task: classification + loss_type: cross_entropy + monitor_metric: accuracy + task_level: node + +#splits +split_params: + learning_setting: transductive + data_split_dir: ${paths.data_dir}/data_splits/${dataset.loader.parameters.data_name} + data_seed: 0 + split_type: random #'k-fold' # either "k-fold" or "random" strategies + k: 10 # for "k-fold" Cross-Validation + train_prop: 0.5 # for "random" strategy splitting + standardize: False + +# Dataloader parameters +dataloader_params: + batch_size: 1 # Fixed + num_workers: 0 + pin_memory: False \ No newline at end of file diff --git a/test/_utils/simplified_pipeline.py b/test/_utils/simplified_pipeline.py index 05da39cac..a3aac7115 100644 --- a/test/_utils/simplified_pipeline.py +++ b/test/_utils/simplified_pipeline.py @@ -4,7 +4,8 @@ from omegaconf import DictConfig, OmegaConf from topobench.data.preprocessor import OnDiskPreProcessor, PreProcessor -from topobench.dataloader import TBDataloader +from topobench.data.utils import build_cluster_transform +from topobench.dataloader import ClusterGCNDataModule, TBDataloader from topobench.utils import instantiate_callbacks from topobench.utils.config_resolvers import ( get_default_metrics, @@ -56,24 +57,77 @@ def run(cfg: DictConfig) -> DictConfig: # Instantiate and load dataset dataset_loader = hydra.utils.instantiate(cfg.dataset.loader) dataset, dataset_dir = dataset_loader.load() + # Preprocess dataset and load the splits transform_config = cfg.get("transforms", None) + print(transform_config) + + # memory_type and learning_setting memory_type = cfg.dataset.loader.parameters.get("memory_type", "in_memory") - preprocessor_cls = OnDiskPreProcessor if memory_type == "on_disk" else PreProcessor - preprocessor = preprocessor_cls(dataset, dataset_dir, transform_config) - dataset_train, dataset_val, dataset_test = ( - preprocessor.load_dataset_splits(cfg.dataset.split_params) - ) - # Prepare datamodule - if cfg.dataset.parameters.task_level in ["node", "graph"]: - datamodule = TBDataloader( - dataset_train=dataset_train, - dataset_val=dataset_val, - dataset_test=dataset_test, - **cfg.dataset.get("dataloader_params", {}), + learning_setting = cfg.dataset.get("split_params", {}).get("learning_setting", "inductive") + + # Branches for three cases: + if memory_type == "on_disk_cluster": + # Loads a graph in memory, performs partitioning + preprocessor = PreProcessor(dataset, dataset_dir, None) + post_batch_transform = build_cluster_transform(transform_config) + + handle = preprocessor.pack_global_partition( + split_params=cfg.dataset.get("split_params", {}), + cluster_params=cfg.dataset.loader.parameters.get("cluster", {}), + stream_params=cfg.dataset.loader.parameters.get("stream", {}), + dtype_policy=cfg.dataset.loader.parameters.get("dtype_policy", "preserve"), + pack_db=True, # for future use + pack_memmaps=True + ) + + # Build streaming loaders that return batches with: + # edge_index, x, (edge_attr), y, supervised_mask, global_nid, num_nodes + datamodule = ClusterGCNDataModule( + data_handle=handle, + q=cfg.dataset.loader.parameters.get("stream", {}).get("q", 1), + num_workers=cfg.dataset.loader.parameters.get("stream", {}).get("num_workers", 0), + pin_memory=cfg.dataset.loader.parameters.get("stream", {}).get("pin_memory", False), + with_edge_attr=cfg.dataset.loader.parameters.get("stream", {}).get("with_edge_attr", False), + eval_cover_strategy=cfg.get("eval", {}).get("cover_strategy", "all_parts"), + seed=cfg.get("seed", 42), + post_batch_transform=post_batch_transform, + ) + elif memory_type == "on_disk" and learning_setting == "transductive": + # Transductive on-disk pipeline (pre-partitioned transductive dataset) + handle = dataset.handle + post_batch_transform = build_cluster_transform(transform_config) + + # Build streaming loaders that return batches with: + # edge_index, x, (edge_attr), y, supervised_mask, global_nid, num_nodes + datamodule = ClusterGCNDataModule( + data_handle=handle, + q=cfg.dataset.loader.parameters.get("stream", {}).get("q", 10), + num_workers=cfg.dataset.loader.parameters.get("stream", {}).get("num_workers", 0), + pin_memory=cfg.dataset.loader.parameters.get("stream", {}).get("pin_memory", False), + with_edge_attr=cfg.dataset.loader.parameters.get("stream", {}).get("with_edge_attr", False), + eval_cover_strategy=cfg.get("eval", {}).get("cover_strategy", "all_parts"), + seed=cfg.get("seed", 42), + post_batch_transform=post_batch_transform, ) else: - raise ValueError("Invalid task_level") + # TB standard in-memory pipeline and on-disk inductive pipeline + preprocessor_cls = OnDiskPreProcessor if memory_type == "on_disk" else PreProcessor + preprocessor = preprocessor_cls(dataset, dataset_dir, transform_config) + + dataset_train, dataset_val, dataset_test = ( + preprocessor.load_dataset_splits(cfg.dataset.split_params) + ) + # Prepare datamodule + if cfg.dataset.parameters.task_level in ["node", "graph"]: + datamodule = TBDataloader( + dataset_train=dataset_train, + dataset_val=dataset_val, + dataset_test=dataset_test, + **cfg.dataset.get("dataloader_params", {}), + ) + else: + raise ValueError("Invalid task_level") # Model for us is Network + logic: inputs backbone, readout, losses model = hydra.utils.instantiate( diff --git a/test/data/__init__.py b/test/data/__init__.py index d6f9f795a..6a953e457 100644 --- a/test/data/__init__.py +++ b/test/data/__init__.py @@ -1 +1 @@ -"""Init file for data.""" \ No newline at end of file +"""Init file for data.""" diff --git a/test/data/dataload/test_Dataloaders.py b/test/data/dataload/test_Dataloaders.py index bc16470db..886e27647 100644 --- a/test/data/dataload/test_Dataloaders.py +++ b/test/data/dataload/test_Dataloaders.py @@ -1,17 +1,13 @@ """Test the Dataloader class.""" + import hydra -import rootutils import torch from topobench.data.preprocessor import PreProcessor from topobench.dataloader import TBDataloader from topobench.dataloader.utils import to_data_list -from omegaconf import OmegaConf -import os -from topobench.run import initialize_hydra - # rootutils.setup_root("./", indicator=".project-root", pythonpath=True) @@ -47,7 +43,7 @@ def setup_method(self): def test_lift_features(self): """Test the collate funciton. - To test the collate function we use the TBDataloader class to create a dataloader that uses the collate function. + To test the collate function we use the TBDataloader class to create a dataloader that uses the collate function. We then first check that the batched data has the expected shape. We then convert the batched data back to a list and check that the data in the list is the same as the original data. """ @@ -124,11 +120,11 @@ def check_values(matrix, m1, m2): elems = [self.val_dataset.data_lst[i] for i in range(self.batch_size)] # Check shape - for key, val in batch: + for key, _val in batch: check_shape(batch, elems, key) # Check that the batched data is separated correctly and the values are correct - for key, val in batch: + for key, _val in batch: if "incidence_" in key: i = int(key.split("_")[1]) if i == 0: @@ -168,4 +164,4 @@ def check_values(matrix, m1, m2): if __name__ == "__main__": t = TestCollateFunction() t.setup_method() - t.test_lift_features() \ No newline at end of file + t.test_lift_features() diff --git a/test/data/dataload/test_dataload_cluster.py b/test/data/dataload/test_dataload_cluster.py new file mode 100644 index 000000000..d996721cc --- /dev/null +++ b/test/data/dataload/test_dataload_cluster.py @@ -0,0 +1,274 @@ +"""Unit tests for Cluster-GCN dataloader and collator.""" + +from pathlib import Path +from typing import Any + +import numpy as np +import pytest +import torch +from torch.utils.data import DataLoader + +from topobench.dataloader.dataload_cluster import ( + BlockCSRBatchCollator, + ClusterGCNDataModule, +) + + +class FakeAdapter: + """Minimal adapter to mimic _HandleAdapter. + + Parameters + ---------- + handle : dict + Handle dictionary passed from the data module. + """ + + def __init__(self, handle: dict[str, Any]) -> None: + paths = handle.get("paths", {}) + self.processed_dir: str = str(paths["processed_dir"]) + self.sparse_format: str = handle.get("sparse_format", "csr") + self.num_parts: int = int(handle.get("num_parts", 2)) + + +@pytest.fixture +def memmap_dir(tmp_path: Path) -> Path: + """Create a synthetic perm_memmap directory. + + Returns + ------- + Path + Directory that plays the role of processed_dir. + """ + processed_dir = tmp_path / "processed" + mm_dir = processed_dir / "perm_memmap" + mm_dir.mkdir(parents=True, exist_ok=True) + + # Part pointer: two parts, [0,2) and [2,4) + partptr = np.array([0, 2, 4], dtype=np.int64) + + # CSR for a simple chain 0-1-2-3 (undirected via adjacency) + # Row 0: [1] + # Row 1: [0, 2] + # Row 2: [1, 3] + # Row 3: [2] + indptr = np.array([0, 1, 3, 5, 6], dtype=np.int64) + indices = np.array([1, 0, 2, 1, 3, 2], dtype=np.int64) + + X = np.array( + [ + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 0.0], + ], + dtype=np.float32, + ) + y = np.array([0, 1, 0, 1], dtype=np.int64) + edge_attr = np.arange(indices.shape[0], dtype=np.float32) + + train_mask = np.array([True, True, False, False], dtype=bool) + val_mask = np.array([False, False, True, False], dtype=bool) + test_mask = np.array([False, False, False, True], dtype=bool) + + np.save(mm_dir / "partptr.npy", partptr) + np.save(mm_dir / "indptr.npy", indptr) + np.save(mm_dir / "indices.npy", indices) + np.save(mm_dir / "X_perm.npy", X) + np.save(mm_dir / "y_perm.npy", y) + np.save(mm_dir / "edge_attr_perm.npy", edge_attr) + np.save(mm_dir / "train_mask_perm.npy", train_mask) + np.save(mm_dir / "val_mask_perm.npy", val_mask) + np.save(mm_dir / "test_mask_perm.npy", test_mask) + + return processed_dir + + +@pytest.fixture +def fake_adapter(memmap_dir: Path) -> FakeAdapter: + """Return a FakeAdapter pointing to the synthetic memmap directory.""" + handle = { + "paths": {"processed_dir": str(memmap_dir)}, + "sparse_format": "csr", + "num_parts": 2, + } + return FakeAdapter(handle) + + +def test_block_csr_collator_active_mask_array(fake_adapter: FakeAdapter): + """Test that _active_mask_array returns correct split masks.""" + coll_train = BlockCSRBatchCollator(fake_adapter, active_split="train") + coll_val = BlockCSRBatchCollator(fake_adapter, active_split="val") + coll_test = BlockCSRBatchCollator(fake_adapter, active_split="test") + + train_mask = coll_train._active_mask_array() + val_mask = coll_val._active_mask_array() + test_mask = coll_test._active_mask_array() + + assert train_mask.tolist() == [True, True, False, False] + assert val_mask.tolist() == [False, False, True, False] + assert test_mask.tolist() == [False, False, False, True] + + +def test_block_csr_collator_call_single_part(fake_adapter: FakeAdapter): + """Test batching for a single cluster ID.""" + coll = BlockCSRBatchCollator(fake_adapter, active_split="train", with_edge_attr=True) + data = coll([0]) # part 0: nodes 0,1 + + assert data.num_nodes == 2 + assert data.x.shape == (2, 2) + assert data.y.shape == (2,) + assert data.edge_index.shape[0] == 2 + assert data.supervised_mask.tolist() == [True, True] + assert data.global_nid.tolist() == [0, 1] + assert torch.allclose(data.x_0, data.x) + assert data.batch_0.shape == (data.num_nodes,) + + +def test_block_csr_collator_call_two_parts(fake_adapter: FakeAdapter): + """Test batching for two cluster IDs in one mini-batch.""" + coll = BlockCSRBatchCollator(fake_adapter, active_split="val", with_edge_attr=True) + data = coll([0, 1]) + + assert data.num_nodes == 4 + assert data.x.shape == (4, 2) + assert data.y.shape == (4,) + assert data.edge_attr.shape[0] == data.edge_index.shape[1] + assert data.supervised_mask.tolist() == [False, False, True, False] + assert data.global_nid.tolist() == [0, 1, 2, 3] + + +@pytest.fixture +def handle_with_parts(memmap_dir: Path, tmp_path: Path) -> dict[str, Any]: + """Create a handle dict with paths and precomputed part lists.""" + parts_dir = tmp_path / "parts_lists" + parts_dir.mkdir(parents=True, exist_ok=True) + + train_parts = np.array([0], dtype=np.int64) + val_parts = np.array([1], dtype=np.int64) + test_parts = np.array([0, 1], dtype=np.int64) + + train_path = parts_dir / "parts_with_train.npy" + val_path = parts_dir / "parts_with_val.npy" + test_path = parts_dir / "parts_with_test.npy" + + np.save(train_path, train_parts) + np.save(val_path, val_parts) + np.save(test_path, test_parts) + + return { + "paths": { + "processed_dir": str(memmap_dir), + "parts_with_train": str(train_path), + "parts_with_val": str(val_path), + "parts_with_test": str(test_path), + }, + "sparse_format": "csr", + "num_parts": 2, + } + + +@pytest.fixture +def datamodule_with_patch( + monkeypatch: pytest.MonkeyPatch, handle_with_parts: dict[str, Any] +) -> ClusterGCNDataModule: + """Return ClusterGCNDataModule with _HandleAdapter patched to FakeAdapter.""" + def fake_handle_adapter(handle: dict[str, Any]) -> FakeAdapter: + return FakeAdapter(handle) + + monkeypatch.setattr( + "topobench.dataloader.dataload_cluster._HandleAdapter", + fake_handle_adapter, + ) + + dm = ClusterGCNDataModule( + data_handle=handle_with_parts, + q=1, + num_workers=0, + pin_memory=False, + with_edge_attr=True, + device=None, + ) + return dm + + +def test_part_ids_for_split_uses_precomputed(datamodule_with_patch: ClusterGCNDataModule): + """Test that _part_ids_for_split prefers precomputed parts_with_* arrays.""" + train_ids = datamodule_with_patch._part_ids_for_split("train") + val_ids = datamodule_with_patch._part_ids_for_split("val") + test_ids = datamodule_with_patch._part_ids_for_split("test") + + assert np.array_equal(train_ids, np.array([0], dtype=np.int64)) + assert np.array_equal(val_ids, np.array([1], dtype=np.int64)) + assert np.array_equal(test_ids, np.array([0, 1], dtype=np.int64)) + + +def test_part_ids_for_split_fallback_all_parts( + monkeypatch: pytest.MonkeyPatch, memmap_dir: Path +): + """Test that _part_ids_for_split falls back to all parts if lists missing.""" + def fake_handle_adapter(handle: dict[str, Any]) -> FakeAdapter: + return FakeAdapter(handle) + + monkeypatch.setattr( + "topobench.dataloader.dataload_cluster._HandleAdapter", + fake_handle_adapter, + ) + + handle = { + "paths": {"processed_dir": str(memmap_dir)}, + "sparse_format": "csr", + "num_parts": 2, + } + + dm = ClusterGCNDataModule(data_handle=handle, q=1) + expected = np.arange(2, dtype=np.int64) + + assert np.array_equal(dm._part_ids_for_split("train"), expected) + assert np.array_equal(dm._part_ids_for_split("val"), expected) + assert np.array_equal(dm._part_ids_for_split("test"), expected) + + +def test_build_loader_and_single_batch(datamodule_with_patch: ClusterGCNDataModule): + """Test that _build_loader constructs a working DataLoader and batch.""" + loader = datamodule_with_patch._build_loader(split="train", shuffle=False) + assert isinstance(loader, DataLoader) + + batch = next(iter(loader)) + assert batch.num_nodes == 2 + assert batch.supervised_mask.tolist() == [True, True] + + +def test_train_val_test_dataloaders(datamodule_with_patch: ClusterGCNDataModule): + """Test that train/val/test_dataloader methods return working loaders.""" + train_loader = datamodule_with_patch.train_dataloader() + val_loader = datamodule_with_patch.val_dataloader() + test_loader = datamodule_with_patch.test_dataloader() + + assert isinstance(train_loader, DataLoader) + assert isinstance(val_loader, DataLoader) + assert isinstance(test_loader, DataLoader) + + train_batch = next(iter(train_loader)) + val_batch = next(iter(val_loader)) + test_batches = list(iter(test_loader)) + + # Train: only part 0 -> nodes 0,1 (both supervised in train split) + assert train_batch.num_nodes == 2 + assert train_batch.supervised_mask.tolist() == [True, True] + + # Val: only part 1 -> nodes 2,3 (only node 2 supervised in val split) + assert val_batch.num_nodes == 2 + assert val_batch.supervised_mask.tolist() == [True, False] + + # Test: parts 0 and 1, but q=1 -> two batches + assert len(test_batches) == 2 + + tb0, tb1 = test_batches + + # First test batch: part 0 -> nodes 0,1 (no supervised nodes in test split) + assert tb0.num_nodes == 2 + assert tb0.supervised_mask.tolist() == [False, False] + + # Second test batch: part 1 -> nodes 2,3 (only node 3 supervised in test split) + assert tb1.num_nodes == 2 + assert tb1.supervised_mask.tolist() == [False, True] diff --git a/test/data/load/test_datasetloaders.py b/test/data/load/test_datasetloaders.py index de0dcb27c..644dc13ec 100644 --- a/test/data/load/test_datasetloaders.py +++ b/test/data/load/test_datasetloaders.py @@ -40,7 +40,8 @@ def _gather_config_files(self, base_dir: Path) -> list[str]: # Below the datasets that have some default transforms with we manually overriten with no_transform, # due to lack of default transform for domain2domain "REDDIT-BINARY.yaml", "IMDB-MULTI.yaml", "IMDB-BINARY.yaml", #"ZINC.yaml" - "ogbg-molpcba.yaml", "manual_dataset.yaml" # "ogbg-molhiv.yaml" + "ogbg-molpcba.yaml", "manual_dataset.yaml", # "ogbg-molhiv.yaml" + "reddit.yaml", "reddit_for_partitioning.yaml", } # Below the datasets that takes quite some time to load and process diff --git a/test/data/load/test_on_disk_datasetloaders.py b/test/data/load/test_on_disk_datasetloaders.py index 1c9c0e319..e53133d6b 100644 --- a/test/data/load/test_on_disk_datasetloaders.py +++ b/test/data/load/test_on_disk_datasetloaders.py @@ -139,18 +139,13 @@ def test_on_disk_dataset_loading_states(self): continue # Check that the returned dataset is backed by OnDiskDataset. - assert isinstance(dataset, OnDiskDataset) or isinstance( - dataset, torch_geometric.data.OnDiskDataset - ) + assert isinstance(dataset, (OnDiskDataset, torch_geometric.data.OnDiskDataset)) # Dataset must contain at least one graph. assert len(dataset) > 0 # Single-graph style (dataset.data) or multi-graph style (dataset[0]). - if hasattr(dataset, "data"): - data = dataset.data - else: - data = dataset[0] + data = dataset.data if hasattr(dataset, "data") else dataset[0] # Basic feature and label checks. assert hasattr(data, "x"), "Missing node features" @@ -163,4 +158,4 @@ def test_on_disk_dataset_loading_states(self): assert data.x.size(1) == dataset.num_node_features # Basic repr should not crash. - repr(dataset) \ No newline at end of file + repr(dataset) diff --git a/test/data/preprocess/__init__.py b/test/data/preprocess/__init__.py index 5966a5cb8..5efe5665c 100644 --- a/test/data/preprocess/__init__.py +++ b/test/data/preprocess/__init__.py @@ -1 +1 @@ -"""Init file for preprocess.""" \ No newline at end of file +"""Init file for preprocess.""" diff --git a/test/data/preprocess/test_on_disk_preprocessor.py b/test/data/preprocess/test_on_disk_preprocessor.py index 4e55930b2..f5e304267 100644 --- a/test/data/preprocess/test_on_disk_preprocessor.py +++ b/test/data/preprocess/test_on_disk_preprocessor.py @@ -1,13 +1,11 @@ """Tests for the OnDiskPreProcessor class.""" -import json -import os -from unittest.mock import MagicMock, ANY, patch +from unittest.mock import MagicMock, patch import pytest import torch_geometric -from torch_geometric.data import Data from omegaconf import DictConfig +from torch_geometric.data import Data from topobench.data.preprocessor.on_disk_preprocessor import ( OnDiskPreProcessor, @@ -317,4 +315,4 @@ def test_invalid_learning_setting_raises(self): """ split_params = DictConfig({"learning_setting": "transductive"}) with pytest.raises(ValueError): - self.preprocessor.load_dataset_splits(split_params) \ No newline at end of file + self.preprocessor.load_dataset_splits(split_params) diff --git a/test/data/preprocess/test_preprocessor.py b/test/data/preprocess/test_preprocessor.py index 89a60c321..7e1d0fefb 100644 --- a/test/data/preprocess/test_preprocessor.py +++ b/test/data/preprocess/test_preprocessor.py @@ -1,20 +1,20 @@ -"""Comprehensive unit tests for the PreProcessor class. +""" Test the PreProcessor class.""" -This test file provides extensive coverage of the PreProcessor class functionality, -including initialization, data transformations, split loading, and edge cases. -""" - -import json import os -import tempfile +import os.path as osp +from unittest.mock import ANY, MagicMock, PropertyMock, patch + +import numpy as np import pytest -from unittest.mock import MagicMock, patch, mock_open import torch import torch_geometric.data from omegaconf import DictConfig +import topobench.data.preprocessor.preprocessor as preproc_mod from topobench.data.preprocessor.preprocessor import PreProcessor +from ..._utils.flow_mocker import FlowMocker + class MockTorchDataset(torch.utils.data.Dataset): """A mock of the torch.utils.data.Dataset class. @@ -52,60 +52,114 @@ def __getitem__(self, idx): """ return self.data[idx] +@pytest.mark.usefixtures("mocker_fixture") +class TestPreProcessor: + """Test the PreProcessor class.""" -class TestPreProcessorBasic: - """Test basic PreProcessor functionality.""" + @pytest.fixture(autouse=True) + def setup_method(self, mocker_fixture): + """Test setup. + + Parameters + ---------- + mocker_fixture : MockerFixture + A fixture that provides a mocker object. + """ + mocker = mocker_fixture + + # Setup test parameters + self.dataset = MagicMock(spec=torch_geometric.data.Dataset) + self.data_dir = "fake/path" + self.transforms_config = DictConfig( + {"transform": {"transform_name": "CellCycleLifting"}} + ) + + params = [ + { + "mock_inmemory_init": "torch_geometric.data.InMemoryDataset.__init__" + }, + { + "mock_save_transform": ( + PreProcessor, + "save_transform_parameters", + ) + }, + {"mock_load": (PreProcessor, "load")}, + { + "mock_len": (PreProcessor, "__len__"), + "init_args": {"return_value": 3}, + }, + { + "mock_getitem": (PreProcessor, "get"), + "init_args": {"return_value": "0"}, + }, + ] + self.flow_mocker = FlowMocker(mocker, params) - def test_init_without_transforms(self): - """Test PreProcessor initialization without transforms.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([ - torch_geometric.data.Data(x=torch.randn(3, 4)), - torch_geometric.data.Data(x=torch.randn(5, 4)), - ])) + # Initialize PreProcessor + self.preprocessor = PreProcessor(self.dataset, self.data_dir, None) - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - assert preprocessor.transforms_applied == False - assert hasattr(preprocessor, 'data_list') - - def test_init_preserves_split_idx(self): - """Test that split_idx is preserved from dataset.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.split_idx = {"train": [0, 1], "val": [2], "test": [3]} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) + def teardown_method(self): + """Test teardown.""" + del self.preprocessor + del self.flow_mocker + + def test_init(self): + """Test the initialization of the PreProcessor class.""" + self.flow_mocker.get("mock_inmemory_init").assert_called_once_with( + self.data_dir, None, None + ) + self.flow_mocker.get("mock_load").assert_called_once_with( + self.data_dir + "/processed/data.pt" + ) + assert not self.preprocessor.transforms_applied + assert self.preprocessor.data_list == ["0", "0", "0"] + + def test_init_with_transform(self, mocker_fixture): + """Test the initialization of the PreProcessor class with transforms. - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - assert hasattr(preprocessor, "split_idx") - assert preprocessor.split_idx == mock_dataset.split_idx - - def test_processed_file_names(self): - """Test the processed_file_names property.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) + Parameters + ---------- + mocker_fixture : MockerFixture + A fixture that provides a mocker object. + """ + mocker = mocker_fixture + val_processed_paths = ["/some/path"] + params = [ + {"assert_args": ("created_property", "processed_data_dir")}, + {"assert_args": ("created_property", "processed_data_dir")}, + { + "mock_inmemory_init": "torch_geometric.data.InMemoryDataset.__init__", + "assert_args": ("called_once_with", ANY, None, ANY), + }, + { + "mock_processed_paths": (PreProcessor, "processed_paths"), + "init_args": {"property_val": val_processed_paths}, + }, + { + "mock_save_transform": ( + PreProcessor, + "save_transform_parameters", + ), + "assert_args": ("created_property", "processed_paths"), + }, + { + "mock_load": (PreProcessor, "load"), + "assert_args": ("called_once_with", val_processed_paths[0]), + }, + {"mock_len": (PreProcessor, "__len__")}, + {"mock_getitem": (PreProcessor, "get")}, + ] + self.flow_mocker = FlowMocker(mocker, params) + self.preprocessor_with_tranform = PreProcessor( + self.dataset, self.data_dir, self.transforms_config + ) + self.flow_mocker.assert_all(self.preprocessor_with_tranform) - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - assert preprocessor.processed_file_names == "data.pt" + transforms_config_liftings = DictConfig( + {"liftings": {"transform": {"transform_name": "CellCycleLifting"}}} + ) + _ = self.preprocessor.instantiate_pre_transform(self.data_dir, transforms_config_liftings) @patch("topobench.data.preprocessor.preprocessor.load_inductive_splits") def test_load_dataset_splits_inductive(self, mock_load_inductive_splits): @@ -114,562 +168,220 @@ def test_load_dataset_splits_inductive(self, mock_load_inductive_splits): Parameters ---------- mock_load_inductive_splits : MagicMock - Mock of the load_inductive_splits function. + A mock of the load_inductive_splits function. """ - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - split_params = DictConfig({"learning_setting": "inductive"}) - preprocessor.load_dataset_splits(split_params) - - mock_load_inductive_splits.assert_called_once_with( - preprocessor, split_params - ) - - @patch("topobench.data.preprocessor.preprocessor.load_transductive_splits") - def test_load_dataset_splits_transductive(self, mock_load_transductive_splits): + split_params = DictConfig({"learning_setting": "inductive"}) + self.preprocessor.load_dataset_splits(split_params) + mock_load_inductive_splits.assert_called_once_with( + self.preprocessor, split_params + ) + + @patch( + "topobench.data.preprocessor.preprocessor.load_transductive_splits" + ) + def test_load_dataset_splits_transductive( + self, mock_load_transductive_splits + ): """Test loading dataset splits for transductive learning. Parameters ---------- mock_load_transductive_splits : MagicMock - Mock of the load_transductive_splits function. + A mock of the load_transductive_splits function. """ - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - split_params = DictConfig({"learning_setting": "transductive"}) - preprocessor.load_dataset_splits(split_params) - - mock_load_transductive_splits.assert_called_once_with( - preprocessor, split_params - ) + split_params = DictConfig({"learning_setting": "transductive"}) + self.preprocessor.load_dataset_splits(split_params) + mock_load_transductive_splits.assert_called_once_with( + self.preprocessor, split_params + ) def test_invalid_learning_setting(self): - """Test error with invalid learning setting.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - split_params = DictConfig({"learning_setting": "invalid"}) - with pytest.raises(ValueError, match="Invalid.*learning setting"): - preprocessor.load_dataset_splits(split_params) - - def test_no_learning_setting_error(self): - """Test error when no learning setting is specified.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - mock_dataset.__iter__ = MagicMock(return_value=iter([])) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch("torch_geometric.data.InMemoryDataset.__init__"): - with patch.object(PreProcessor, "load"): - preprocessor = PreProcessor(mock_dataset, tmpdir, None) - - # Test with no learning_setting key - split_params = DictConfig({}) - with pytest.raises(ValueError, match="No learning setting specified"): - preprocessor.load_dataset_splits(split_params) - - # Test with learning_setting = False - split_params = DictConfig({"learning_setting": False}) - with pytest.raises(ValueError, match="No learning setting specified"): - preprocessor.load_dataset_splits(split_params) - - -class TestPreProcessorProcessing: - """Test PreProcessor data processing methods.""" - - def test_process_with_torch_utils_dataset(self): - """Test process method with torch.utils.data.Dataset.""" - mock_data = [ - torch_geometric.data.Data(x=torch.randn(3, 4)), - torch_geometric.data.Data(x=torch.randn(5, 4)), - ] - mock_dataset = MockTorchDataset(mock_data) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.dataset = mock_dataset - preprocessor.pre_transform = None - preprocessor.collate = MagicMock( - return_value=(torch_geometric.data.Data(), {}) - ) - preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): - preprocessor.process() - - assert len(preprocessor.data_list) == len(mock_data) - preprocessor.collate.assert_called_once() - preprocessor.save.assert_called_once() - - def test_process_with_torch_geometric_data(self): - """Test process method with torch_geometric.data.Data.""" - mock_data = torch_geometric.data.Data(x=torch.randn(3, 4)) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.dataset = mock_data - preprocessor.pre_transform = None - preprocessor.collate = MagicMock( - return_value=(torch_geometric.data.Data(), {}) - ) - preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): - preprocessor.process() - - assert preprocessor.data_list == [mock_data] - preprocessor.collate.assert_called_once_with([mock_data]) - - def test_process_with_pre_transform(self): - """Test process method with a pre_transform applied.""" - mock_data = [ - torch_geometric.data.Data(x=torch.randn(3, 4)), - torch_geometric.data.Data(x=torch.randn(5, 4)) - ] + """Test an invalid learning setting.""" + split_params = DictConfig({"learning_setting": "invalid"}) + with pytest.raises(ValueError): + self.preprocessor.load_dataset_splits(split_params) + + def test_process_torch_utils_dataset(self): + """Test the process method with torch.utils.data.Dataset.""" + mock_data = [1, 2, 3] mock_dataset = MockTorchDataset(mock_data) - mock_pre_transform = MagicMock(side_effect=lambda x: x) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.dataset = mock_dataset - preprocessor.pre_transform = mock_pre_transform - preprocessor.collate = MagicMock( - return_value=(torch_geometric.data.Data(), {}) - ) - preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): - preprocessor.process() - - # Verify pre_transform was called for each data item - assert mock_pre_transform.call_count == len(mock_data) - - -class TestPreProcessorLoad: - """Test PreProcessor load method.""" - - @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") - def test_load_backward_compatibility_2_elements(self, mock_torch_load): - """Test load method with 2 elements (backward compatibility). - - Parameters - ---------- - mock_torch_load : MagicMock - Mock of the torch_load function. - """ + self.preprocessor.dataset = mock_dataset + self.preprocessor.pre_transform = None + self.preprocessor.collate = MagicMock(return_value=(torch_geometric.data.Data(), MagicMock())) # Corrected line + self.preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(PreProcessor, "processed_paths", new_callable=PropertyMock) as mock_processed_paths: + mock_processed_paths.return_value = ["/fake/path"] + self.preprocessor.process() + + assert self.preprocessor.data_list == mock_data + self.preprocessor.collate.assert_called_once_with(mock_data) + self.preprocessor.save.assert_called_once() + + def test_process_torch_geometric_data_data(self): + """Test the process method with torch_geometric.data.Data.""" mock_data = torch_geometric.data.Data() - mock_slices = {"x": torch.tensor([0, 3])} - mock_torch_load.return_value = (mock_data, mock_slices) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.load("/fake/path") - - # Use _data as that's what the actual code uses - assert preprocessor._data == mock_data - assert preprocessor.slices == mock_slices - - @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") - def test_load_backward_compatibility_3_elements(self, mock_torch_load): - """Test load method with 3 elements (backward compatibility). + self.preprocessor.dataset = mock_data + self.preprocessor.pre_transform = None + self.preprocessor.collate = MagicMock(return_value=(torch_geometric.data.Data(), MagicMock())) # Corrected line + self.preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(PreProcessor, "processed_paths", new_callable=PropertyMock) as mock_processed_paths: + mock_processed_paths.return_value = ["/fake/path"] + self.preprocessor.process() + + assert self.preprocessor.data_list == [mock_data] + self.preprocessor.collate.assert_called_once_with([mock_data]) + self.preprocessor.save.assert_called_once() - Parameters - ---------- - mock_torch_load : MagicMock - Mock of the torch_load function. - """ - mock_data = torch_geometric.data.Data() - mock_slices = {"x": torch.tensor([0, 3])} - mock_data_cls = torch_geometric.data.Data - mock_torch_load.return_value = (mock_data, mock_slices, mock_data_cls) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.load("/fake/path") - - assert preprocessor._data == mock_data - assert preprocessor.slices == mock_slices - - @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") - def test_load_with_4_elements(self, mock_torch_load): - """Test load method with 4 elements (TU Datasets format). - - Parameters - ---------- - mock_torch_load : MagicMock - Mock of the torch_load function. - """ - mock_data = torch_geometric.data.Data() - mock_slices = {"x": torch.tensor([0, 3])} - mock_sizes = {"x": 3} - mock_data_cls = torch_geometric.data.Data - mock_torch_load.return_value = (mock_data, mock_slices, mock_sizes, mock_data_cls) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.load("/fake/path") - - assert preprocessor._data == mock_data - assert preprocessor.slices == mock_slices - - @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") - def test_load_with_dict_data(self, mock_torch_load): - """Test load method when data is a dictionary. - - Parameters - ---------- - mock_torch_load : MagicMock - Mock of the torch_load function. - """ - mock_data_dict = { - "x": torch.randn(3, 4), - "edge_index": torch.tensor([[0, 1], [1, 2]]) - } - mock_slices = {"x": torch.tensor([0, 3])} - mock_data_cls = MagicMock() - mock_reconstructed_data = torch_geometric.data.Data() - mock_data_cls.from_dict.return_value = mock_reconstructed_data - mock_torch_load.return_value = (mock_data_dict, mock_slices, mock_data_cls) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.load("/fake/path") - - mock_data_cls.from_dict.assert_called_once_with(mock_data_dict) - assert preprocessor._data == mock_reconstructed_data - assert preprocessor.slices == mock_slices - - -class TestPreProcessorTransforms: - """Test PreProcessor with transforms.""" - - def test_save_transform_parameters_new_file(self): - """Test saving transform parameters when file doesn't exist.""" - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.processed_data_dir = tmpdir - preprocessor.transforms_parameters = { - "transform1": {"param": "value"} - } - - preprocessor.save_transform_parameters() - - # Check if file was created - param_file = os.path.join( - tmpdir, "path_transform_parameters_dict.json" - ) - assert os.path.exists(param_file) - - # Check file contents - with open(param_file, 'r') as f: - saved_params = json.load(f) - assert saved_params == preprocessor.transforms_parameters - - def test_save_transform_parameters_existing_same(self, capsys): - """Test saving transform parameters when file exists with same params. - - Parameters - ---------- - capsys : pytest.CaptureFixture - Pytest fixture to capture stdout/stderr output. - """ - with tempfile.TemporaryDirectory() as tmpdir: - # Create existing params file - params = {"transform1": {"param": "value"}} - param_file = os.path.join( - tmpdir, "path_transform_parameters_dict.json" - ) - with open(param_file, 'w') as f: - json.dump(params, f) - - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.processed_data_dir = tmpdir - preprocessor.transforms_parameters = params - - preprocessor.save_transform_parameters() - - # Check that message was printed - captured = capsys.readouterr() - assert "Transform parameters are the same" in captured.out - - def test_save_transform_parameters_existing_different(self): - """Test error when saving different transform parameters to same path.""" - with tempfile.TemporaryDirectory() as tmpdir: - # Create existing params file with different params - existing_params = {"transform1": {"param": "old_value"}} - param_file = os.path.join( - tmpdir, "path_transform_parameters_dict.json" - ) - with open(param_file, 'w') as f: - json.dump(existing_params, f) - - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.processed_data_dir = tmpdir - preprocessor.transforms_parameters = { - "transform1": {"param": "new_value"} - } - - with pytest.raises(ValueError, match="Different transform parameters"): - preprocessor.save_transform_parameters() - - def test_instantiate_pre_transform_with_liftings(self): - """Test instantiate_pre_transform with liftings config.""" - mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) - mock_dataset.transform = None - mock_dataset._data = torch_geometric.data.Data() - mock_dataset.slices = {} - - transforms_config = DictConfig({ - "liftings": { - "transform1": {"transform_name": "DummyTransform", "param1": "value1"} - } - }) - - with tempfile.TemporaryDirectory() as tmpdir: - # Create preprocessor instance - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - - # Mock DataTransform to avoid needing real transforms - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - mock_dt.return_value = MagicMock() - preprocessor.set_processed_data_dir = MagicMock() - - pre_transform = preprocessor.instantiate_pre_transform( - tmpdir, transforms_config - ) - - # Check that a Compose object was created - assert hasattr(pre_transform, '__call__') - - def test_instantiate_pre_transform_multiple_transforms(self): - """Test instantiate_pre_transform with multiple transforms (else branch).""" - transforms_config = DictConfig({ - "transform1": {"transform_name": "Transform1", "param1": "value1"}, - "transform2": {"transform_name": "Transform2", "param2": "value2"} - }) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - - # Mock DataTransform - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - mock_dt.return_value = MagicMock() - - # Mock set_processed_data_dir - preprocessor.set_processed_data_dir = MagicMock() - - pre_transform = preprocessor.instantiate_pre_transform( - tmpdir, transforms_config - ) - - # DataTransform should be called for each transform - assert mock_dt.call_count == 2 - assert hasattr(pre_transform, '__call__') - - def test_instantiate_pre_transform_single_transform(self): - """Test instantiate_pre_transform with single transform (if branch).""" - transforms_config = DictConfig({ - "transform_name": "SingleTransform", - "param1": "value1", - "param2": 42 - }) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - - # Mock DataTransform - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - # Mock DataTransform to return a mock object - mock_transform = MagicMock() - mock_dt.return_value = mock_transform - - # Mock set_processed_data_dir - preprocessor.set_processed_data_dir = MagicMock() - - pre_transform = preprocessor.instantiate_pre_transform( - tmpdir, transforms_config - ) - - # DataTransform should be called once with the entire config - assert mock_dt.call_count == 1 - # Should be called with all the config parameters - mock_dt.assert_called_once_with(**transforms_config) - - # Verify the pre_transform is a Compose object - assert isinstance( - pre_transform, - torch_geometric.transforms.Compose - ) - - def test_instantiate_pre_transform_calls_set_processed_data_dir(self): - """Test that instantiate_pre_transform calls set_processed_data_dir.""" - transforms_config = DictConfig({ - "transform1": {"transform_name": "Transform1", "param1": "value1"} - }) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - mock_dt.return_value = MagicMock() - # Mock set_processed_data_dir - preprocessor.set_processed_data_dir = MagicMock() - - pre_transform = preprocessor.instantiate_pre_transform( - tmpdir, transforms_config - ) - - # Verify set_processed_data_dir was called - preprocessor.set_processed_data_dir.assert_called_once() - call_args = preprocessor.set_processed_data_dir.call_args - assert call_args[0][1] == tmpdir - assert call_args[0][2] == transforms_config - - def test_instantiate_pre_transform_returns_compose(self): - """Test that instantiate_pre_transform returns a Compose object.""" - transforms_config = DictConfig({ - "transform1": {"transform_name": "Transform1", "param1": "value1"} - }) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - mock_dt.return_value = MagicMock() - preprocessor.set_processed_data_dir = MagicMock() - - pre_transform = preprocessor.instantiate_pre_transform( - tmpdir, transforms_config - ) - - # Check it's a Compose instance - assert isinstance( - pre_transform, - torch_geometric.transforms.Compose - ) - - def test_instantiate_pre_transform_single_vs_multiple(self): - """Test that the method correctly distinguishes between single and multiple transforms.""" - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.set_processed_data_dir = MagicMock() - - with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: - mock_dt.return_value = MagicMock() - - # Test single transform (has transform_name key) - single_config = DictConfig({ - "transform_name": "SingleTransform", - "param1": "value1" - }) - - preprocessor.instantiate_pre_transform(tmpdir, single_config) - - # Should be called once with all parameters - assert mock_dt.call_count == 1 - mock_dt.assert_called_with(**single_config) - - # Reset mock - mock_dt.reset_mock() - - # Test multiple transforms (no transform_name key at top level) - multiple_config = DictConfig({ - "transform1": {"transform_name": "Transform1", "param1": "value1"}, - "transform2": {"transform_name": "Transform2", "param2": "value2"} - }) - - preprocessor.instantiate_pre_transform(tmpdir, multiple_config) - - # Should be called twice, once for each transform - assert mock_dt.call_count == 2 - - -class TestPreProcessorEdgeCases: - """Test edge cases and error handling.""" - - def test_process_with_empty_dataset(self): - """Test process method with an empty dataset.""" - mock_dataset = MockTorchDataset([]) - - with tempfile.TemporaryDirectory() as tmpdir: - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.dataset = mock_dataset - preprocessor.pre_transform = None - # For empty list, collate should return a single empty Data object - preprocessor.collate = MagicMock( - return_value=(torch_geometric.data.Data(), {}) - ) - preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): - preprocessor.process() - - assert preprocessor.data_list == [] - - def test_processed_dir_property(self): - """Test the processed_dir property returns correct paths.""" - with tempfile.TemporaryDirectory() as tmpdir: - # Without transforms - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.root = tmpdir - preprocessor.transforms_applied = False - - assert preprocessor.processed_dir == tmpdir - - # With transforms - with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): - preprocessor = PreProcessor(None, tmpdir, None) - preprocessor.root = tmpdir - preprocessor.transforms_applied = True - - assert preprocessor.processed_dir == tmpdir + "/processed" +def test_pack_global_partition(tmp_path, monkeypatch): + """ + Test pack_global_partition builds a valid handle and memmaps. + + Parameters + ---------- + tmp_path : pathlib.Path + Temporary directory for data_dir. + monkeypatch : pytest.MonkeyPatch + Fixture to patch ClusterOnDisk. + """ + # Fake ClusterOnDisk with minimal behavior + class FakePartition: + def __init__(self): + # Two parts, four nodes: [0,2), [2,4) + self.partptr = torch.tensor([0, 2, 4], dtype=torch.long) + self.indptr = torch.tensor([0, 1, 2, 3, 4], dtype=torch.long) + self.index = torch.tensor([0, 1, 2, 3], dtype=torch.long) + self.node_perm = torch.arange(4, dtype=torch.long) + self.edge_perm = torch.arange(4, dtype=torch.long) + + class FakeClusterOnDisk: + def __init__( + self, + root, + *, + graph_getter, + num_parts, + recursive, + keep_inter_cluster_edges, + sparse_format, + backend, + transform, + pre_filter, + ): + self.root = root + self.processed_dir = osp.join(root, "processed") + os.makedirs(self.processed_dir, exist_ok=True) + + self.num_parts = int(num_parts) + self.recursive = bool(recursive) + self.keep_inter_cluster_edges = bool(keep_inter_cluster_edges) + self.sparse_format = str(sparse_format) + + mm_dir = osp.join(self.processed_dir, "perm_memmap") + os.makedirs(mm_dir, exist_ok=True) + + partptr = np.array([0, 2, 4], dtype=np.int64) + indptr = np.array([0, 1, 2, 3, 4], dtype=np.int64) + indices = np.array([0, 1, 2, 3], dtype=np.int64) + np.save(osp.join(mm_dir, "partptr.npy"), partptr) + np.save(osp.join(mm_dir, "indptr.npy"), indptr) + np.save(osp.join(mm_dir, "indices.npy"), indices) + + self._partition = FakePartition() + self.schema = {"edge_index": dict(dtype=torch.long, size=(2, -1))} + + @property + def partition(self): + """Return fake partition.""" + return self._partition + + def __len__(self): + """Return number of cluster parts.""" + return self.num_parts + + # Patch ClusterOnDisk used inside preprocessor module + monkeypatch.setattr(preproc_mod, "ClusterOnDisk", FakeClusterOnDisk) + + # Build a tiny full graph with masks + edge_index = torch.tensor( + [[0, 1, 2, 3], + [1, 2, 3, 0]], + dtype=torch.long, + ) + x = torch.randn(4, 3) + y = torch.tensor([0, 1, 0, 1], dtype=torch.long) + train_mask = torch.tensor([True, True, False, False]) + val_mask = torch.tensor([False, False, True, False]) + test_mask = torch.tensor([False, False, False, True]) + + full = torch_geometric.data.Data( + edge_index=edge_index, + x=x, + y=y, + train_mask=train_mask, + val_mask=val_mask, + test_mask=test_mask, + ) + + class DatasetWrapper: + def __init__(self, data): + self.data = data + + dataset = DatasetWrapper(full) + + # Create a minimal PreProcessor-like instance without running __init__ + pre = object.__new__(PreProcessor) + pre.dataset = dataset + pre.data_dir = str(tmp_path) + pre.load_dataset_splits = MagicMock(return_value=(None, None, None)) + + split_params = DictConfig({"learning_setting": "transductive"}) + cluster_params = { + "num_parts": 2, + "recursive": False, + "keep_inter_cluster_edges": False, + "sparse_format": "csr", + } + stream_params = {"precompute_split_parts": True} + + handle = pre.pack_global_partition( + split_params=split_params, + cluster_params=cluster_params, + stream_params=stream_params, + dtype_policy="preserve", + ) + + # Basic handle structure checks + assert isinstance(handle, dict) + assert handle["root"] == pre.data_dir + assert handle["num_parts"] == 2 + assert handle["sparse_format"] == "csr" + assert handle["has_x"] is True + assert handle["has_y"] is True + + memmap_dir = handle["memmap_dir"] + assert osp.isdir(memmap_dir) + + # Mask memmaps must exist and have correct length + for key in ("train_mask_perm", "val_mask_perm", "test_mask_perm"): + path = handle["paths"][key] + assert osp.exists(path) + arr = np.load(path) + assert arr.shape == (4,) + + # Cached handle should be reused on second call + call_count_before = pre.load_dataset_splits.call_count + handle2 = pre.pack_global_partition( + split_params=split_params, + cluster_params=cluster_params, + stream_params=stream_params, + dtype_policy="preserve", + ) + call_count_after = pre.load_dataset_splits.call_count + + assert handle2["config_hash"] == handle["config_hash"] + # No extra split loading on cached path + assert call_count_after == call_count_before diff --git a/test/data/utils/test_cluster_utils.py b/test/data/utils/test_cluster_utils.py new file mode 100644 index 000000000..7ee06f4dc --- /dev/null +++ b/test/data/utils/test_cluster_utils.py @@ -0,0 +1,376 @@ +"""Unit tests for cluster-related utilities and ClusterOnDisk.""" + +from pathlib import Path +from typing import Any + +import hydra +import numpy as np +import pytest +import torch +from torch_geometric.data import Data + +from topobench.data.utils import ( + ClusterOnDisk, + _tensor_schema_entry, + build_cluster_transform, + to_bool_mask, +) + + +@pytest.fixture +def tiny_data() -> Data: + """ + Create a tiny test graph. + + Returns + ------- + Data + Simple 3-node graph with features, labels and edge attributes. + """ + edge_index = torch.tensor( + [[0, 1, 1, 2], + [1, 0, 2, 1]], + dtype=torch.long, + ) + x = torch.tensor( + [ + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ], + dtype=torch.float32, + ) + y = torch.tensor([0, 1, 0], dtype=torch.long) + edge_attr = torch.arange(edge_index.size(1), dtype=torch.float32).view(-1, 1) + return Data(edge_index=edge_index, x=x, y=y, edge_attr=edge_attr) + + +@pytest.fixture +def graph_getter(tiny_data: Data): + """ + Build a graph_getter callable for ClusterOnDisk. + + Parameters + ---------- + tiny_data : Data + Tiny test graph. + + Returns + ------- + callable + Function returning a cloned copy of the graph. + """ + def _getter() -> Data: + return tiny_data.clone() + + return _getter + + +def test_build_cluster_transform_none_returns_none(): + """ + Test that empty configs return no transform. + + Notes + ----- + Both empty dict and ``None`` should yield ``None``. + """ + assert build_cluster_transform({}) is None + assert build_cluster_transform(None) is None + + +def test_build_cluster_transform_single_transform(monkeypatch: pytest.MonkeyPatch): + """ + Test building a single transform from config. + + Parameters + ---------- + monkeypatch : pytest.MonkeyPatch + Fixture used to patch hydra and DataTransform. + """ + calls: dict[str, Any] = {} + + def fake_instantiate(cfg): + calls["cfg"] = cfg + return object() + + class DummyTransform: + def __init__(self, **kwargs): + self.kwargs = kwargs + + def __call__(self, data: Data) -> Data: + data.marked = True + return data + + monkeypatch.setattr( + hydra.utils, + "instantiate", + fake_instantiate, + ) + monkeypatch.setattr( + "topobench.transforms.data_transform.DataTransform", + DummyTransform, + raising=True, + ) + + cfg = { + "t1": {"_target_": "dummy.target", "foo": 1}, + } + transform = build_cluster_transform(cfg) + + assert isinstance(transform, DummyTransform) + assert "t1" in calls["cfg"] + + d = Data() + d2 = transform(d) + assert d2.marked is True + + +def test_build_cluster_transform_multiple_transforms( + monkeypatch: pytest.MonkeyPatch, +): + """ + Test building a composed transform from multiple configs. + + Parameters + ---------- + monkeypatch : pytest.MonkeyPatch + Fixture used to patch hydra and DataTransform. + """ + def fake_instantiate(cfg): + return object() + + class DummyTransform: + def __init__(self, **kwargs): + self.kwargs = kwargs + + def __call__(self, data: Data) -> Data: + data.calls = getattr(data, "calls", 0) + 1 + return data + + monkeypatch.setattr( + hydra.utils, + "instantiate", + fake_instantiate, + ) + monkeypatch.setattr( + "topobench.transforms.data_transform.DataTransform", + DummyTransform, + raising=True, + ) + + cfg = { + "liftings": { + "t1": {"_target_": "dummy.t1"}, + "t2": {"_target_": "dummy.t2"}, + } + } + transform = build_cluster_transform(cfg) + + from torch_geometric.transforms import Compose + + assert isinstance(transform, Compose) + assert len(transform.transforms) == 2 + assert all(isinstance(t, DummyTransform) for t in transform.transforms) + + d = Data() + d2 = transform(d) + assert d2.calls == 2 + + +def test_to_bool_mask_various_inputs(): + """ + Test to_bool_mask for several input types. + + Notes + ----- + Covers boolean masks, index lists and score vectors. + """ + N = 5 + + m_bool = torch.tensor([True, False, True, False, False]) + out = to_bool_mask(m_bool, N) + assert out.dtype == torch.bool + assert out.tolist() == m_bool.tolist() + + m_idx = torch.tensor([0, 2, 4], dtype=torch.long) + out = to_bool_mask(m_idx, N) + assert out.tolist() == [True, False, True, False, True] + + m_scores = torch.tensor([0, 1, 0, 0, 1], dtype=torch.float32) + out = to_bool_mask(m_scores, N) + assert out.tolist() == [False, True, False, False, True] + + m_bad = torch.tensor([1.0, 1.0]) + out = to_bool_mask(m_bad, N) + assert out.tolist() == [False] * N + + +def test_tensor_schema_entry_scalar_and_nd(): + """ + Test _tensor_schema_entry for scalar and 2D tensors. + + Notes + ----- + Ensures correct mapping to Python types and dict schema. + """ + t_int = torch.tensor(3, dtype=torch.int64) + assert _tensor_schema_entry(t_int) is int + + t_float = torch.tensor(1.5, dtype=torch.float32) + assert _tensor_schema_entry(t_float) is float + + t_bool = torch.tensor(True, dtype=torch.bool) + assert _tensor_schema_entry(t_bool) is bool + + t_2d = torch.zeros(4, 7, dtype=torch.float32) + entry_2d = _tensor_schema_entry(t_2d) + assert isinstance(entry_2d, dict) + assert entry_2d["dtype"] == torch.float32 + assert entry_2d["size"] == (-1, 7) + + +@pytest.fixture +def cluster_ds(tmp_path: Path, graph_getter): + """ + Create a ClusterOnDisk dataset instance. + + Parameters + ---------- + tmp_path : Path + Temporary directory for dataset storage. + graph_getter : callable + Function returning the full graph. + + Returns + ------- + ClusterOnDisk + Prepared on-disk dataset. + """ + root = tmp_path / "cluster_on_disk_ds" + ds = ClusterOnDisk( + root=str(root), + graph_getter=graph_getter, + num_parts=2, + recursive=False, + keep_inter_cluster_edges=False, + sparse_format="csr", + backend="sqlite", + ) + return ds + + +def test_cluster_on_disk_schema_and_meta(cluster_ds: ClusterOnDisk): + """ + Test schema discovery and stored metadata. + + Parameters + ---------- + cluster_ds : ClusterOnDisk + On-disk dataset under test. + """ + assert "edge_index" in cluster_ds.schema + assert "x" in cluster_ds.schema + assert "y" in cluster_ds.schema + assert "edge_attr" in cluster_ds.schema + assert "num_nodes" in cluster_ds.schema + + meta = cluster_ds.meta + assert "num_parts" in meta + assert "recursive" in meta + assert "keep_inter_cluster_edges" in meta + assert "sparse_format" in meta + assert "partition" in meta + + assert cluster_ds.num_parts == int(meta["num_parts"]) + assert cluster_ds.recursive == bool(meta["recursive"]) + assert cluster_ds.keep_inter_cluster_edges == bool(meta["keep_inter_cluster_edges"]) + assert cluster_ds.sparse_format == str(meta["sparse_format"]) + + +def test_cluster_on_disk_len_and_getitem(cluster_ds: ClusterOnDisk): + """ + Test length and indexing for ClusterOnDisk. + + Parameters + ---------- + cluster_ds : ClusterOnDisk + On-disk dataset under test. + """ + n_parts_meta = cluster_ds.num_parts + assert len(cluster_ds) == n_parts_meta + + data0 = cluster_ds[0] + assert isinstance(data0, Data) + assert getattr(data0, "edge_index", None) is not None + + for key in data0.keys(): + assert key in cluster_ds.schema + + +def test_cluster_on_disk_serialize_deserialize(cluster_ds: ClusterOnDisk): + """ + Test serialize and deserialize of a single cluster. + + Parameters + ---------- + cluster_ds : ClusterOnDisk + On-disk dataset under test. + """ + data0 = cluster_ds[0] + row = cluster_ds.serialize(data0) + assert "edge_index" in row + + data_rec = cluster_ds.deserialize(row) + assert isinstance(data_rec, Data) + assert torch.equal(data_rec.edge_index, data0.edge_index) + if hasattr(data0, "x"): + assert torch.equal(data_rec.x, data0.x) + + +def test_cluster_on_disk_perm_memmaps(cluster_ds: ClusterOnDisk, tiny_data: Data): + """ + Test shapes and permutation logic of permuted memmaps. + + Parameters + ---------- + cluster_ds : ClusterOnDisk + On-disk dataset under test. + tiny_data : Data + Original tiny input graph. + """ + mm_dir = Path(cluster_ds._memmap_dir()) + + partptr = np.load(mm_dir / "partptr.npy") + indptr = np.load(mm_dir / "indptr.npy") + indices = np.load(mm_dir / "indices.npy") + perm_to_global = np.load(mm_dir / "perm_to_global.npy") + global_to_perm = np.load(mm_dir / "global_to_perm.npy") + + N = tiny_data.num_nodes + assert perm_to_global.shape == (N,) + assert global_to_perm.shape == (N,) + + for perm_idx, global_id in enumerate(perm_to_global.tolist()): + assert global_to_perm[global_id] == perm_idx + + assert partptr.ndim == 1 + assert indptr.ndim == 1 + assert indices.ndim == 1 + + if hasattr(tiny_data, "x"): + X_perm = np.load(mm_dir / "X_perm.npy") + assert X_perm.shape == (N, tiny_data.x.size(1)) + x_np = tiny_data.x.cpu().numpy() + for i in range(N): + assert np.allclose(X_perm[i], x_np[perm_to_global[i]]) + + if hasattr(tiny_data, "y"): + y_perm = np.load(mm_dir / "y_perm.npy") + y_np = tiny_data.y.view(-1).cpu().numpy() + assert y_perm.shape == (N,) + for i in range(N): + assert y_perm[i] == y_np[perm_to_global[i]] + + if hasattr(tiny_data, "edge_attr"): + ea_perm = np.load(mm_dir / "edge_attr_perm.npy") + assert ea_perm.ndim == 2 diff --git a/test/data/utils/test_data_utils.py b/test/data/utils/test_data_utils.py index 2bdf39c53..23aa1f7bd 100644 --- a/test/data/utils/test_data_utils.py +++ b/test/data/utils/test_data_utils.py @@ -2,12 +2,13 @@ import omegaconf import pytest -import torch_geometric import torch -from topobench.data.utils import * -import toponetx as tnx +import torch_geometric from toponetx.classes import CellComplex +from topobench.data.utils import * + + class TestDataUtils: """Test data utils functions.""" @@ -17,29 +18,29 @@ def setup_method(self): self.complex.add_cell([1, 2, 3],rank=2) self.complex.add_cell([3, 4, 5],rank=2) self.complex.add_cell([5, 6, 7],rank=2) - self.neighborhoods1 = ['up_adjacency-0','2-up_adjacency-0','2-down_laplacian-2','2-down_adjacency-2','2-up_incidence-0','2-down_incidence-2'] - self.neighborhoods2 = ['down_incidence-1', 'up_laplacian-0', 'down_laplacian-1', 'up_adjacency-0', 'hodge_laplacian-1'] + self.neighborhoods1 = ["up_adjacency-0","2-up_adjacency-0","2-down_laplacian-2","2-down_adjacency-2","2-up_incidence-0","2-down_incidence-2"] + self.neighborhoods2 = ["down_incidence-1", "up_laplacian-0", "down_laplacian-1", "up_adjacency-0", "hodge_laplacian-1"] def test_get_complex_connectivity(self): """Test get_complex_connectivity.""" out = get_complex_connectivity(self.complex, 3, neighborhoods=self.neighborhoods2) - assert 'up_laplacian-0' in out.keys() + assert "up_laplacian-0" in out def test_get_combinatorial_complex_connectivity(self): """Test get_complex_connectivity.""" out = get_combinatorial_complex_connectivity(self.complex, 3) - assert 'adjacency_0' in out.keys() + assert "adjacency_0" in out def test_select_neighborhoods_of_interest(self): """Test select_neighborhoods_of_interest.""" connectivity = get_complex_connectivity(self.complex, 2) out = select_neighborhoods_of_interest(connectivity, self.neighborhoods1) - assert '2-down_laplacian-2' in out.keys() - assert 'incidence_1' in out.keys() + assert "2-down_laplacian-2" in out + assert "incidence_1" in out - with pytest.raises(ValueError) as e: - select_neighborhoods_of_interest(connectivity, ['invalid_neighborhood']) + with pytest.raises(ValueError): + select_neighborhoods_of_interest(connectivity, ["invalid_neighborhood"]) def test_generate_zero_sparse_connectivity(self): """Test generate_zero_sparse_connectivity.""" @@ -49,12 +50,12 @@ def test_generate_zero_sparse_connectivity(self): def test_load_cell_complex_dataset(self): """Test load_cell_complex_dataset.""" - with pytest.raises(NotImplementedError) as e: + with pytest.raises(NotImplementedError): load_cell_complex_dataset({}) def test_load_simplicial_dataset(self): """Test load_simplicial_dataset.""" - with pytest.raises(NotImplementedError) as e: + with pytest.raises(NotImplementedError): load_simplicial_dataset({}) def test_load_manual_graph(self): @@ -64,14 +65,14 @@ def test_load_manual_graph(self): def test_make_hash(self): """Test make_hash.""" - out = make_hash('test') + out = make_hash("test") assert isinstance(out, int) def test_ensure_serializable(self): """Test ensure_serializable.""" - objects = ['test', 1, 1.0, [1, 2, 3], {'a': 1, 'b': 2}, set([1, 2, 3]), omegaconf.dictconfig.DictConfig({'a': 1, 'b': 2}), torch_geometric.data.Data()] + objects = ["test", 1, 1.0, [1, 2, 3], {"a": 1, "b": 2}, set([1, 2, 3]), omegaconf.dictconfig.DictConfig({"a": 1, "b": 2}), torch_geometric.data.Data()] for obj in objects: - out = ensure_serializable(obj) + ensure_serializable(obj) @@ -81,7 +82,7 @@ def test_ensure_serializable(self): # assert out == 90. # with pytest.raises(Exception) as e: - # get_metric_value(self.metric_dict, "some_metric") + # get_metric_value(self.metric_dict, "some_metric") # def test_extras(self): # """Test extras.""" diff --git a/test/pipeline/test_pipeline.py b/test/pipeline/test_pipeline.py index ea9959ba1..eb97ed696 100644 --- a/test/pipeline/test_pipeline.py +++ b/test/pipeline/test_pipeline.py @@ -5,7 +5,7 @@ from test._utils.simplified_pipeline import run # Use your contributed dataset + a lightweight, well-supported model -DATASET = "graph/fake" +DATASET = "graph/cocitation_cora_on_disk" MODELS = ["graph/gcn", "cell/topotune", "simplicial/topotune"] # MODELS = ["graph/gcn"] diff --git a/test/tools/memory_usage_tracking/test_memory_plotting.py b/test/tools/memory_usage_tracking/test_memory_plotting.py index ea1d750fe..b3a7d3f2e 100644 --- a/test/tools/memory_usage_tracking/test_memory_plotting.py +++ b/test/tools/memory_usage_tracking/test_memory_plotting.py @@ -2,8 +2,6 @@ from __future__ import annotations -import builtins -import os from pathlib import Path from types import SimpleNamespace from typing import Any @@ -126,9 +124,10 @@ def memory_info(self): def fake_popen(args, cwd=None, env=None): return fake_proc - import psutil as real_psutil import subprocess as real_subprocess + import psutil as real_psutil + monkeypatch.setattr(real_subprocess, "Popen", fake_popen) monkeypatch.setattr(real_psutil, "Process", FakePsutilProcess) @@ -208,4 +207,4 @@ def test_plot_raw_time_memory_creates_file(self, tmp_path: Path): ) assert plot_path.exists() - assert plot_path.stat().st_size > 0 \ No newline at end of file + assert plot_path.stat().st_size > 0 diff --git a/test/tools/sweep_tools/test_sweep_cells.py b/test/tools/sweep_tools/test_sweep_cells.py new file mode 100644 index 000000000..e4bda260b --- /dev/null +++ b/test/tools/sweep_tools/test_sweep_cells.py @@ -0,0 +1,387 @@ +import tempfile +import unittest +from pathlib import Path +from unittest.mock import MagicMock, patch + +import numpy as np +import torch +from matplotlib.figure import Figure + +from tools.sweep_tools import sweep_cells as sc + + +class TestSweepCells(unittest.TestCase): + """ + Unit tests for sweep_cells cell-complex utilities. + + Tests cover permutation handling, incidence helpers, metrics, + sweep logic, and plotting. + """ + + def test_load_perm_to_global_missing(self): + """ + Test load_perm_to_global returns None when mapping is absent. + """ + with tempfile.TemporaryDirectory() as tmp: + handle = {"processed_dir": tmp} + result = sc.load_perm_to_global(handle) + self.assertIsNone(result) + + def test_load_perm_to_global_existing(self): + """ + Test load_perm_to_global loads a tensor from disk. + """ + with tempfile.TemporaryDirectory() as tmp: + processed_dir = Path(tmp) + perm_dir = processed_dir / "perm_memmap" + perm_dir.mkdir(parents=True, exist_ok=True) + arr = np.array([2, 0, 1], dtype=np.int64) + np.save(perm_dir / "perm_to_global.npy", arr) + + handle = {"processed_dir": str(processed_dir)} + result = sc.load_perm_to_global(handle) + + self.assertIsInstance(result, torch.Tensor) + self.assertTrue(torch.equal(result, torch.from_numpy(arr))) + + def test_resolve_true_global_ids_padded_identity(self): + """ + Test resolve_true_global_ids returns identity for padded batches. + """ + golden = MagicMock() + batch = MagicMock() + + batch.x_0 = torch.randn(4, 3) + batch.is_true_global_remapped = True + batch.true_global_nid = torch.tensor([10, 11, 12, 13]) + + result = sc.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(result, torch.tensor([10, 11, 12, 13]))) + + def test_resolve_true_global_ids_legacy_with_perm(self): + """ + Test resolve_true_global_ids uses global_nid and perm_to_global. + """ + golden = MagicMock() + golden.x_0 = torch.randn(3, 2) + + batch = MagicMock() + batch.x_0 = torch.randn(3, 2) + batch.global_nid = torch.tensor([2, 0, 1]) + batch.is_true_global_remapped = False + + perm_to_global = torch.tensor([10, 11, 12]) + + result = sc.resolve_true_global_ids(golden, batch, perm_to_global) + self.assertTrue(torch.equal(result, torch.tensor([12, 10, 11]))) + + def test_resolve_true_global_ids_no_global_nid(self): + """ + Test resolve_true_global_ids falls back to local indices. + """ + golden = MagicMock() + batch = MagicMock() + batch.x_0 = torch.randn(5, 2) + delattr(batch, "global_nid") + + result = sc.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(result, torch.arange(5))) + + def test_build_col_to_rows_mapping_dense(self): + """ + Test _build_col_to_rows_mapping for a dense tensor. + """ + M = torch.tensor( + [ + [1, 0, 0], + [0, 1, 1], + ], + dtype=torch.float32, + ) + mapping = sc._build_col_to_rows_mapping(M, n_rows=2) + self.assertEqual(mapping[0], {0}) + self.assertEqual(mapping[1], {1}) + self.assertEqual(mapping[2], {1}) + + def test_build_col_to_rows_mapping_sparse(self): + """ + Test _build_col_to_rows_mapping for a sparse COO tensor. + """ + indices = torch.tensor([[0, 1, 1], [0, 1, 2]]) + values = torch.ones(indices.size(1)) + M = torch.sparse_coo_tensor(indices, values, size=(2, 3)) + + mapping = sc._build_col_to_rows_mapping(M, n_rows=2) + self.assertEqual(mapping[0], {0}) + self.assertEqual(mapping[1], {1}) + self.assertEqual(mapping[2], {1}) + + def test_build_col_to_rows_mapping_invalid_shape(self): + """ + Test _build_col_to_rows_mapping returns None on shape mismatch. + """ + M = torch.ones(3, 3) + mapping = sc._build_col_to_rows_mapping(M, n_rows=2) + self.assertIsNone(mapping) + + def test_extract_1_cells_basic(self): + """ + Test extract_1_cells builds sets of 0-cell IDs. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + gids = torch.tensor([10, 11, 12, 13]) + + cells_list, cells_set = sc.extract_1_cells(data, gids) + self.assertEqual(len(cells_list), 2) + self.assertIn(frozenset({10, 11}), cells_set) + self.assertIn(frozenset({12, 13}), cells_set) + + def test_extract_2_cells_case_a_0_to_2(self): + """ + Test extract_2_cells when incidence_2 is 0→2. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + data.incidence_2 = torch.tensor( + [ + [1, 0], + [1, 0], + [1, 1], + [0, 1], + ], + dtype=torch.float32, + ) + gids = torch.tensor([10, 11, 12, 13]) + cells_1_list, _ = sc.extract_1_cells(data, gids) + cells_2 = sc.extract_2_cells(data, gids, cells_1_list) + + self.assertIn(frozenset({10, 11, 12}), cells_2) + self.assertIn(frozenset({12, 13}), cells_2) + + def test_extract_2_cells_case_b_1_to_2(self): + """ + Test extract_2_cells when incidence_2 is 1→2. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + data.incidence_2 = torch.tensor( + [ + [1], + [1], + ], + dtype=torch.float32, + ) + gids = torch.tensor([0, 1, 2, 3]) + cells_1_list, _ = sc.extract_1_cells(data, gids) + cells_2 = sc.extract_2_cells(data, gids, cells_1_list) + + self.assertEqual(cells_2, {frozenset({0, 1, 2, 3})}) + + def test_compute_structure_coverage_metrics_subset(self): + """ + Test structure coverage metrics in subset mode. + """ + gold = [frozenset({1, 2, 3}), frozenset({4, 5})] + cand = [frozenset({1, 2, 3}), frozenset({4})] + + m = sc.compute_structure_coverage_metrics(gold, cand) + self.assertEqual(m["gold_n"], 2) + self.assertEqual(m["strict_match"], 1) + # both gold structures are partially covered + self.assertEqual(m["partial_covered"], 2) + self.assertAlmostEqual(m["strict_recall"], 0.5) + self.assertAlmostEqual(m["partial_recall"], 1.0) + + def test_compute_structure_coverage_metrics_jaccard(self): + """ + Test structure coverage metrics in Jaccard mode. + """ + gold = [frozenset({1, 2, 3})] + cand = [frozenset({1, 2})] + + m = sc.compute_structure_coverage_metrics( + gold, cand, mode="jaccard", jaccard_thresh=0.4 + ) + self.assertEqual(m["gold_n"], 1) + self.assertEqual(m["cand_n"], 1) + + @patch("tools.sweep_tools.sweep_cells.load_perm_to_global") + @patch("tools.sweep_tools.sweep_cells.build_golden_and_candidate_from_cfg") + def test_run_single_experiment_basic(self, mock_build, mock_load_perm): + """ + Test a minimal run_single_experiment call for 1- and 2-cells. + """ + class Data: + pass + + golden = Data() + golden.x_0 = torch.randn(4, 1) + golden.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + golden.incidence_2 = torch.tensor( + [ + [1], + [1], + [1], + [1], + ], + dtype=torch.float32, + ) + + batch = Data() + batch.x_0 = golden.x_0.clone() + batch.incidence_1 = golden.incidence_1 + batch.incidence_2 = golden.incidence_2 + batch.is_true_global_remapped = True + batch.true_global_nid = torch.arange(4) + + handle = {"num_parts": 2} + mock_build.return_value = (golden, [batch], handle) + mock_load_perm.return_value = None + + cfg = MagicMock() + results = sc.run_single_experiment(cfg, num_parts=2, bs=1) + + self.assertIn(1, results) + self.assertAlmostEqual(results[1]["strict_recall"], 1.0) + self.assertIn(2, results) + self.assertAlmostEqual(results[2]["strict_recall"], 1.0) + + @patch("tools.sweep_tools.sweep_cells.run_single_experiment") + @patch("tools.sweep_tools.sweep_cells.hydra.compose") + @patch("tools.sweep_tools.sweep_cells.hydra.initialize") + def test_run_sweep_calls_single_experiment( + self, mock_init, mock_compose, mock_run_single + ): + """ + Test run_sweep integrates run_single_experiment over a grid. + """ + mock_init.return_value.__enter__.return_value = None + mock_init.return_value.__exit__.return_value = False + mock_compose.return_value = MagicMock() + mock_run_single.return_value = { + 1: { + "gold_n": 1, + "cand_n": 1, + "strict_match": 1, + "partial_covered": 1, + "strict_recall": 1.0, + "partial_recall": 1.0, + } + } + + batch_sizes, num_parts_list, results_by_dim = sc.run_sweep() + self.assertIsInstance(batch_sizes, list) + self.assertIsInstance(num_parts_list, list) + self.assertIsInstance(results_by_dim, dict) + self.assertIn(1, results_by_dim) + self.assertTrue(results_by_dim[1]) + + def test_build_metric_matrix(self): + """ + Test build_metric_matrix returns a dense percent matrix. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results_dim = { + (1, 4): {"strict_recall": 0.5}, + (2, 8): {"strict_recall": 1.0}, + } + + M = sc.build_metric_matrix(batch_sizes, num_parts_list, results_dim, "strict_recall") + self.assertEqual(M.shape, (2, 2)) + self.assertAlmostEqual(M[0, 0], 50.0) + self.assertTrue(np.isnan(M[0, 1])) + self.assertAlmostEqual(M[1, 1], 100.0) + + @patch.object(Figure, "savefig") + def test_plot_two_heatmaps_calls_savefig(self, mock_savefig): + """ + Test plot_two_heatmaps renders and saves a figure. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + strict_M = np.array([[50.0, np.nan], [75.0, 100.0]]) + partial_M = np.array([[60.0, np.nan], [80.0, 100.0]]) + + sc.plot_two_heatmaps( + batch_sizes, + num_parts_list, + strict_M, + partial_M, + save_prefix="cells_test", + title_prefix="Dim 1", + ) + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("cells_test_strict_vs_partial.png", args[0]) + + @patch.object(Figure, "savefig") + def test_plot_recall_by_dim_calls_savefig(self, mock_savefig): + """ + Test plot_recall_by_dim renders combined recall plots. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + M1 = np.array([[50.0, 60.0], [70.0, 80.0]]) + M2 = np.array([[10.0, 20.0], [30.0, 40.0]]) + + sc.plot_recall_by_dim( + batch_sizes, + num_parts_list, + M_dim1=M1, + M_dim2=M2, + save_prefix="cells_recall_test", + title_prefix="Recall test", + ) + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("cells_recall_test.png", args[0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/tools/sweep_tools/test_sweep_hypergraphs.py b/test/tools/sweep_tools/test_sweep_hypergraphs.py new file mode 100644 index 000000000..7d0e38bc1 --- /dev/null +++ b/test/tools/sweep_tools/test_sweep_hypergraphs.py @@ -0,0 +1,243 @@ +import tempfile +import unittest +from pathlib import Path +from unittest.mock import MagicMock, patch + +import numpy as np +import torch +from matplotlib.figure import Figure + +from tools.sweep_tools import sweep_hypergraphs as sh + + +class TestSweepHypergraphs(unittest.TestCase): + """ + Unit tests for sweep_hypergraphs functionality. + + Each test validates correctness of the small, self-contained utilities + used in the hyperedge coverage sweep pipeline. + """ + + def test_load_perm_to_global_missing(self): + """ + Test that load_perm_to_global returns None when no mapping exists. + """ + with tempfile.TemporaryDirectory() as tmp: + handle = {"processed_dir": tmp} + result = sh.load_perm_to_global(handle) + self.assertIsNone(result) + + def test_load_perm_to_global_existing(self): + """ + Test that load_perm_to_global loads and returns the perm array. + """ + with tempfile.TemporaryDirectory() as tmp: + processed_dir = Path(tmp) + perm_dir = processed_dir / "perm_memmap" + perm_dir.mkdir(parents=True, exist_ok=True) + arr = np.array([2, 0, 1], dtype=np.int64) + np.save(perm_dir / "perm_to_global.npy", arr) + + handle = {"processed_dir": str(processed_dir)} + result = sh.load_perm_to_global(handle) + self.assertIsInstance(result, torch.Tensor) + self.assertTrue(torch.equal(result, torch.from_numpy(arr))) + + def test_resolve_true_global_ids_with_global_nid_and_perm(self): + """ + Test resolving global node IDs when both global_nid and perm_to_global exist. + """ + golden = MagicMock() + golden.x_0 = torch.randn(3, 2) + + batch = MagicMock() + batch.x = torch.randn(3, 2) + batch.x_0 = torch.randn(3, 2) + batch.global_nid = torch.tensor([2, 0, 1]) + + perm_to_global = torch.tensor([10, 11, 12]) + + result = sh.resolve_true_global_ids(golden, batch, perm_to_global) + self.assertTrue(torch.equal(result, torch.tensor([12, 10, 11]))) + + def test_resolve_true_global_ids_without_global_nid(self): + """ + Test the fallback path where no global_nid attribute is present. + """ + golden = MagicMock() + batch = MagicMock() + batch.x = torch.randn(4, 2) + delattr(batch, "global_nid") + + result = sh.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(result, torch.arange(4))) + + def test_hyperedges_from_incidence_hyperedges_dense(self): + """ + Test hyperedge extraction from a dense incidence matrix. + """ + class Data: + pass + + data = Data() + H = torch.tensor([ + [1, 0], + [1, 0], + [1, 1], + [0, 1], + ], dtype=torch.float32) + data.incidence_hyperedges = H + gids = torch.tensor([10, 11, 12, 13]) + + hyperedges = sh.hyperedges_from_incidence_hyperedges(data, gids) + self.assertEqual(hyperedges, {(10, 11, 12), (12, 13)}) + + def test_hyperedges_from_incidence_hyperedges_sparse(self): + """ + Test hyperedge extraction from a sparse incidence matrix. + """ + class Data: + pass + + data = Data() + indices = torch.tensor([[0, 1, 2, 2, 3], [0, 0, 0, 1, 1]]) + values = torch.ones(indices.size(1)) + H_sparse = torch.sparse_coo_tensor(indices, values, size=(4, 2)) + data.incidence_hyperedges = H_sparse + gids = torch.tensor([0, 1, 2, 3]) + + hyperedges = sh.hyperedges_from_incidence_hyperedges(data, gids) + self.assertEqual(hyperedges, {(0, 1, 2), (2, 3)}) + + def test_compute_hyperedge_coverage_metrics_basic(self): + """ + Test metrics for a case with one exact match and one partial match. + """ + gold = [(0, 1, 2), (3, 4)] + cand = [(0, 1, 2), (3,)] + + metrics = sh.compute_hyperedge_coverage_metrics(gold, cand) + self.assertEqual(metrics["gold_n"], 2) + self.assertEqual(metrics["cand_n"], 2) + self.assertEqual(metrics["strict_match"], 1) + self.assertEqual(metrics["partial_covered"], 1) + self.assertAlmostEqual(metrics["strict_recall"], 0.5) + self.assertAlmostEqual(metrics["partial_recall"], 0.5) + + def test_summarize_hyperedge_differences(self): + """ + Test generating a readable summary of hyperedge differences. + """ + gold = [(0, 1, 2), (3, 4)] + cand = [(0, 1), (3, 4, 5)] + + summary = sh.summarize_hyperedge_differences(gold, cand) + self.assertIn("match exactly", summary) + self.assertIn("missing in the clustered pipeline", summary) + self.assertIn("appear only in the clustered pipeline", summary) + + @patch("tools.sweep_tools.sweep_hypergraphs.build_golden_and_candidate_from_cfg") + @patch("tools.sweep_tools.sweep_hypergraphs.load_perm_to_global") + def test_run_single_experiment_basic(self, mock_load_perm, mock_build): + """ + Test a minimal run_single_experiment evaluation path. + """ + class Data: + pass + + golden = Data() + golden.x = torch.randn(3, 2) + golden.incidence_hyperedges = torch.tensor([[1, 0], [1, 0], [0, 1]], dtype=torch.float32) + + batch = Data() + batch.x = torch.randn(3, 2) + batch.incidence_hyperedges = golden.incidence_hyperedges + batch.global_nid = torch.tensor([0, 1, 2]) + + handle = {"num_parts": 4} + mock_build.return_value = (golden, [batch], handle) + mock_load_perm.return_value = None + + cfg = MagicMock() + metrics = sh.run_single_experiment(cfg, num_parts=4, bs=1) + + self.assertAlmostEqual(metrics["strict_recall"], 1.0) + self.assertAlmostEqual(metrics["partial_recall"], 1.0) + + @patch("tools.sweep_tools.sweep_hypergraphs.run_single_experiment") + @patch("tools.sweep_tools.sweep_hypergraphs.hydra.compose") + @patch("tools.sweep_tools.sweep_hypergraphs.hydra.initialize") + def test_run_sweep_calls_single_experiment( + self, mock_init, mock_compose, mock_run_single + ): + """ + Test that run_sweep invokes run_single_experiment for each grid point. + """ + mock_init.return_value.__enter__.return_value = None + mock_init.return_value.__exit__.return_value = False + mock_compose.return_value = MagicMock() + mock_run_single.return_value = { + "gold_n": 1, + "cand_n": 1, + "strict_match": 1, + "partial_covered": 1, + "strict_recall": 1.0, + "partial_recall": 1.0, + } + + with patch.object(sh, "run_sweep", wraps=sh.run_sweep): + batch_sizes, num_parts_list, results = sh.run_sweep() + self.assertIsInstance(batch_sizes, list) + self.assertIsInstance(num_parts_list, list) + self.assertIsInstance(results, dict) + self.assertTrue(any(results.values())) + + self.assertTrue(mock_run_single.called) + + def test_build_metric_matrix(self): + """ + Test forming the recall matrix with NaN entries for missing values. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results = {(1, 4): {"strict_recall": 0.5}, (2, 8): {"strict_recall": 1.0}} + + M = sh.build_metric_matrix(batch_sizes, num_parts_list, results, "strict_recall") + self.assertEqual(M.shape, (2, 2)) + self.assertTrue(np.isnan(M[0, 1])) + self.assertAlmostEqual(M[0, 0], 50.0) + self.assertAlmostEqual(M[1, 1], 100.0) + + @patch.object(Figure, "savefig") + def test_plot_two_heatmaps_runs_and_saves(self, mock_savefig): + """ + Test that two-heatmap plot renders and triggers savefig(). + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + strict_M = np.array([[50.0, np.nan], [75.0, 100.0]]) + partial_M = np.array([[60.0, np.nan], [80.0, 100.0]]) + + sh.plot_two_heatmaps(batch_sizes, num_parts_list, strict_M, partial_M, save_prefix="test_cov") + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("test_cov_strict_vs_partial.png", args[0]) + + @patch.object(Figure, "savefig") + def test_plot_one_heatmap_runs_and_saves(self, mock_savefig): + """ + Test plotting a single recall heatmap and saving the output. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + strict_M = np.array([[50.0, 70.0], [80.0, 100.0]]) + + fig, ax = sh.plot_one_heatmap(batch_sizes, num_parts_list, strict_M, save_prefix="test_one") + self.assertIsInstance(fig, Figure) + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("test_one_strict.png", args[0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/tools/sweep_tools/test_sweep_over_epochs_cells.py b/test/tools/sweep_tools/test_sweep_over_epochs_cells.py new file mode 100644 index 000000000..7f8927c11 --- /dev/null +++ b/test/tools/sweep_tools/test_sweep_over_epochs_cells.py @@ -0,0 +1,432 @@ +import tempfile +import unittest +from pathlib import Path +from unittest.mock import MagicMock, patch + +import numpy as np +import torch +import torch_geometric +from matplotlib.figure import Figure + +from tools.sweep_tools import sweep_over_epochs_cells as sec + + +class TestSweepOverEpochsCells(unittest.TestCase): + """ + Unit tests for sweep_over_epochs_cells utilities. + + Covers permutation loading, ID resolution, incidence handling, + metrics, batch processing, multi-epoch runs, sweeping, and plotting. + """ + + def test_load_perm_to_global_missing(self): + """ + Test load_perm_to_global returns None if mapping is missing. + """ + with tempfile.TemporaryDirectory() as tmp: + handle = {"processed_dir": tmp} + result = sec.load_perm_to_global(handle) + self.assertIsNone(result) + + def test_load_perm_to_global_existing(self): + """ + Test load_perm_to_global loads a tensor from disk. + """ + with tempfile.TemporaryDirectory() as tmp: + processed_dir = Path(tmp) + perm_dir = processed_dir / "perm_memmap" + perm_dir.mkdir(parents=True, exist_ok=True) + arr = np.array([2, 0, 1], dtype=np.int64) + np.save(perm_dir / "perm_to_global.npy", arr) + + handle = {"processed_dir": str(processed_dir)} + result = sec.load_perm_to_global(handle) + + self.assertIsInstance(result, torch.Tensor) + self.assertTrue(torch.equal(result, torch.from_numpy(arr))) + + def test_resolve_true_global_ids_padded_identity(self): + """ + Test resolve_true_global_ids uses true_global_nid for padded batches. + """ + golden = MagicMock() + batch = MagicMock() + batch.x_0 = torch.randn(4, 2) + batch.is_true_global_remapped = True + batch.true_global_nid = torch.tensor([10, 11, 12, 13]) + + out = sec.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(out, torch.tensor([10, 11, 12, 13]))) + + def test_resolve_true_global_ids_legacy_with_perm(self): + """ + Test resolve_true_global_ids maps via global_nid and perm_to_global. + """ + golden = MagicMock() + golden.x_0 = torch.randn(3, 2) + + batch = MagicMock() + batch.x_0 = torch.randn(3, 2) + batch.global_nid = torch.tensor([2, 0, 1]) + batch.is_true_global_remapped = False + + perm_to_global = torch.tensor([10, 11, 12]) + + out = sec.resolve_true_global_ids(golden, batch, perm_to_global) + self.assertTrue(torch.equal(out, torch.tensor([12, 10, 11]))) + + def test_resolve_true_global_ids_no_global_nid(self): + """ + Test resolve_true_global_ids falls back to local indices. + """ + golden = MagicMock() + batch = MagicMock() + batch.x_0 = torch.randn(5, 2) + delattr(batch, "global_nid") + + out = sec.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(out, torch.arange(5))) + + def test_build_col_to_rows_mapping_dense(self): + """ + Test _build_col_to_rows_mapping on a dense tensor. + """ + M = torch.tensor( + [ + [1, 0, 0], + [0, 1, 1], + ], + dtype=torch.float32, + ) + mapping = sec._build_col_to_rows_mapping(M, n_rows=2) + self.assertEqual(mapping[0], {0}) + self.assertEqual(mapping[1], {1}) + self.assertEqual(mapping[2], {1}) + + def test_build_col_to_rows_mapping_sparse(self): + """ + Test _build_col_to_rows_mapping on a sparse COO tensor. + """ + indices = torch.tensor([[0, 1, 1], [0, 1, 2]]) + values = torch.ones(indices.size(1)) + M = torch.sparse_coo_tensor(indices, values, size=(2, 3)) + + mapping = sec._build_col_to_rows_mapping(M, n_rows=2) + self.assertEqual(mapping[0], {0}) + self.assertEqual(mapping[1], {1}) + self.assertEqual(mapping[2], {1}) + + def test_build_col_to_rows_mapping_invalid_shape(self): + """ + Test _build_col_to_rows_mapping returns None on shape mismatch. + """ + M = torch.ones(3, 3) + mapping = sec._build_col_to_rows_mapping(M, n_rows=2) + self.assertIsNone(mapping) + + def test_extract_1_cells_basic(self): + """ + Test extract_1_cells constructs 1-cells as 0-cell sets. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + gids = torch.tensor([10, 11, 12, 13]) + + cells_list, cells_set = sec.extract_1_cells(data, gids) + self.assertEqual(len(cells_list), 2) + self.assertIn(frozenset({10, 11}), cells_set) + self.assertIn(frozenset({12, 13}), cells_set) + + def test_extract_2_cells_case_a_0_to_2(self): + """ + Test extract_2_cells for 0→2 incidence. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + data.incidence_2 = torch.tensor( + [ + [1, 0], + [1, 0], + [1, 1], + [0, 1], + ], + dtype=torch.float32, + ) + gids = torch.tensor([10, 11, 12, 13]) + cells_1_list, _ = sec.extract_1_cells(data, gids) + cells_2 = sec.extract_2_cells(data, gids, cells_1_list) + + self.assertIn(frozenset({10, 11, 12}), cells_2) + self.assertIn(frozenset({12, 13}), cells_2) + + def test_extract_2_cells_case_b_1_to_2(self): + """ + Test extract_2_cells for 1→2 incidence with union over 1-cells. + """ + class Data: + pass + + data = Data() + data.x_0 = torch.randn(4, 1) + data.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + data.incidence_2 = torch.tensor([[1], [1]], dtype=torch.float32) + + gids = torch.tensor([0, 1, 2, 3]) + cells_1_list, _ = sec.extract_1_cells(data, gids) + cells_2 = sec.extract_2_cells(data, gids, cells_1_list) + + self.assertEqual(cells_2, {frozenset({0, 1, 2, 3})}) + + def test_compute_structure_coverage_metrics_subset(self): + """ + Test coverage metrics in subset mode. + """ + gold = [frozenset({1, 2, 3}), frozenset({4, 5})] + cand = [frozenset({1, 2, 3}), frozenset({4})] + + m = sec.compute_structure_coverage_metrics(gold, cand) + self.assertEqual(m["gold_n"], 2) + self.assertEqual(m["strict_match"], 1) + self.assertEqual(m["partial_covered"], 2) + self.assertAlmostEqual(m["strict_recall"], 0.5) + self.assertAlmostEqual(m["partial_recall"], 1.0) + + def test_process_raw_batch_to_lifted_basic(self): + """ + Test process_raw_batch_to_lifted remaps, pads, and flags metadata. + """ + raw_batch = torch_geometric.data.Data() + raw_batch.num_nodes = 3 + raw_batch.edge_index = torch.tensor([[0, 1], [1, 2]], dtype=torch.long) + raw_batch.x_0 = torch.randn(3, 2) + raw_batch.global_nid = torch.tensor([2, 0, 4]) + + perm_to_global = None + target_n0 = 5 + + def pad_to_global(val, sorted_gids): + if val.size(0) == target_n0: + return val + out = torch.zeros((target_n0,) + val.shape[1:], dtype=val.dtype) + out[sorted_gids] = val + return out + + def post_batch_transform(graph): + graph.lifted_flag = True + return graph + + lifted = sec.process_raw_batch_to_lifted( + raw_batch, + perm_to_global=perm_to_global, + post_batch_transform=post_batch_transform, + target_n0=target_n0, + pad_to_global_fn=pad_to_global, + ) + + self.assertEqual(lifted.num_nodes, target_n0) + self.assertTrue(hasattr(lifted, "lifted_flag")) + self.assertTrue(torch.equal(lifted.global_nid, torch.arange(target_n0))) + self.assertTrue(hasattr(lifted, "present_mask_0")) + self.assertEqual(lifted.present_mask_0.dtype, torch.bool) + + @patch("tools.sweep_tools.sweep_over_epochs_cells.process_raw_batch_to_lifted") + @patch("tools.sweep_tools.sweep_over_epochs_cells.build_golden_and_loader_from_cfg_cells") + def test_run_single_experiment_multi_epoch_cells_basic(self, mock_build, mock_process): + """ + Test run_single_experiment_multi_epoch_cells aggregates metrics over epochs. + """ + class Data: + pass + + golden = Data() + golden.x_0 = torch.randn(4, 1) + golden.incidence_1 = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + [0, 1], + ], + dtype=torch.float32, + ) + golden.incidence_2 = torch.tensor( + [ + [1], + [1], + [1], + [1], + ], + dtype=torch.float32, + ) + + lifted = Data() + lifted.x_0 = golden.x_0.clone() + lifted.incidence_1 = golden.incidence_1 + lifted.incidence_2 = golden.incidence_2 + lifted.is_true_global_remapped = True + lifted.true_global_nid = torch.arange(4) + + loader = [MagicMock()] # one raw batch per epoch + handle = {"num_parts": 2} + perm_to_global = None + post_batch_transform = None + target_n0 = 4 + + def pad_to_global(val, sorted_gids): + return val + + mock_build.return_value = ( + golden, + loader, + handle, + perm_to_global, + post_batch_transform, + target_n0, + pad_to_global, + ) + mock_process.return_value = lifted + + cfg = MagicMock() + results = sec.run_single_experiment_multi_epoch_cells( + cfg, num_parts=2, bs=1, num_epochs=3, accumulate=True + ) + + self.assertIn(1, results) + self.assertEqual(len(results[1]), 3) + for m in results[1]: + self.assertAlmostEqual(m["strict_recall"], 1.0) + + self.assertIn(2, results) + self.assertEqual(len(results[2]), 3) + for m in results[2]: + self.assertAlmostEqual(m["strict_recall"], 1.0) + + @patch("tools.sweep_tools.sweep_over_epochs_cells.run_single_experiment_multi_epoch_cells") + @patch("tools.sweep_tools.sweep_over_epochs_cells.hydra.compose") + @patch("tools.sweep_tools.sweep_over_epochs_cells.hydra.initialize") + def test_run_sweep_cells_multi_epoch_calls_single( + self, mock_init, mock_compose, mock_run_single + ): + """ + Test run_sweep_cells_multi_epoch integrates single-experiment metrics. + """ + mock_init.return_value.__enter__.return_value = None + mock_init.return_value.__exit__.return_value = False + mock_compose.return_value = MagicMock() + mock_run_single.return_value = { + 1: [ + { + "gold_n": 1, + "cand_n": 1, + "strict_match": 1, + "partial_covered": 1, + "strict_recall": 1.0, + "partial_recall": 1.0, + } + ] + } + + batch_sizes, num_parts_list, results_by_dim_epochs = sec.run_sweep_cells_multi_epoch( + num_epochs=2, accumulate=True + ) + + self.assertIsInstance(batch_sizes, list) + self.assertIsInstance(num_parts_list, list) + self.assertIsInstance(results_by_dim_epochs, dict) + self.assertIn(1, results_by_dim_epochs) + self.assertTrue(results_by_dim_epochs[1]) + self.assertTrue(mock_run_single.called) + + def test_build_metric_matrix_for_epoch(self): + """ + Test build_metric_matrix_for_epoch builds a percent matrix. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results_per_pair = { + (1, 4): [{"strict_recall": 0.5}, {"strict_recall": 0.75}], + (2, 8): [{"strict_recall": 1.0}], + } + + M1 = sec.build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=1, metric_key="strict_recall" + ) + self.assertEqual(M1.shape, (2, 2)) + self.assertAlmostEqual(M1[0, 0], 50.0) + self.assertAlmostEqual(M1[1, 1], 100.0) + + M2 = sec.build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=2, metric_key="strict_recall" + ) + self.assertAlmostEqual(M2[0, 0], 75.0) + self.assertTrue(np.isnan(M2[1, 1])) + + @patch.object(Figure, "savefig") + def test_plot_summary_4panel_dim_calls_savefig(self, mock_savefig): + """ + Test plot_summary_4panel_dim renders and saves the summary figure. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results_per_pair_dim = { + (1, 4): [ + {"strict_recall": 0.5}, + {"strict_recall": 0.75}, + ], + (2, 8): [ + {"strict_recall": 0.4}, + {"strict_recall": 0.9}, + ], + } + + sec.plot_summary_4panel_dim( + batch_sizes=batch_sizes, + num_parts_list=num_parts_list, + results_per_pair_dim=results_per_pair_dim, + num_epochs=2, + metric_key="strict_recall", + target_bs=1, + target_num_parts=4, + save_prefix="cells_dim1_epochs_test", + dim_label="Dim 1 (test)", + ) + + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("cells_dim1_epochs_test_strict_recall.png", args[0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/tools/sweep_tools/test_sweep_over_epochs_hypergraphs.py b/test/tools/sweep_tools/test_sweep_over_epochs_hypergraphs.py new file mode 100644 index 000000000..4af7f4319 --- /dev/null +++ b/test/tools/sweep_tools/test_sweep_over_epochs_hypergraphs.py @@ -0,0 +1,287 @@ +import tempfile +import unittest +from pathlib import Path +from unittest.mock import MagicMock, patch + +import numpy as np +import torch +from matplotlib.figure import Figure + +import tools.sweep_tools.sweep_over_epochs_hypergraphs as seh + + +class TestSweepOverEpochsHypergraph(unittest.TestCase): + """ + Unit tests for sweep_over_epochs_hypergraph utilities. + + Covers permutation loading, ID resolution, hyperedge extraction, + metrics, multi-epoch runs, sweeping, matrix building, and plotting. + """ + + def test_load_perm_to_global_missing(self): + """ + Test load_perm_to_global returns None when file is missing. + """ + with tempfile.TemporaryDirectory() as tmp: + handle = {"processed_dir": tmp} + result = seh.load_perm_to_global(handle) + self.assertIsNone(result) + + def test_load_perm_to_global_existing(self): + """ + Test load_perm_to_global loads a tensor when file exists. + """ + with tempfile.TemporaryDirectory() as tmp: + processed_dir = Path(tmp) + perm_dir = processed_dir / "perm_memmap" + perm_dir.mkdir(parents=True, exist_ok=True) + arr = np.array([2, 0, 1], dtype=np.int64) + np.save(perm_dir / "perm_to_global.npy", arr) + + handle = {"processed_dir": str(processed_dir)} + result = seh.load_perm_to_global(handle) + + self.assertIsInstance(result, torch.Tensor) + self.assertTrue(torch.equal(result, torch.from_numpy(arr))) + + def test_resolve_true_global_ids_with_global_nid_and_perm(self): + """ + Test resolve_true_global_ids uses perm_to_global mapping. + """ + golden = MagicMock() + golden.x_0 = torch.randn(3, 2) + + batch = MagicMock() + batch.x = torch.randn(3, 2) + batch.x_0 = torch.randn(3, 2) + batch.global_nid = torch.tensor([2, 0, 1]) + + perm_to_global = torch.tensor([10, 11, 12]) + + out = seh.resolve_true_global_ids(golden, batch, perm_to_global) + self.assertTrue(torch.equal(out, torch.tensor([12, 10, 11]))) + + def test_resolve_true_global_ids_without_global_nid(self): + """ + Test resolve_true_global_ids falls back to arange for missing IDs. + """ + golden = MagicMock() + batch = MagicMock() + batch.x = torch.randn(4, 2) + if hasattr(batch, "global_nid"): + delattr(batch, "global_nid") + + out = seh.resolve_true_global_ids(golden, batch, None) + self.assertTrue(torch.equal(out, torch.arange(4))) + + def test_hyperedges_from_incidence_hyperedges_dense(self): + """ + Test hyperedges_from_incidence_hyperedges with dense incidence. + """ + class Data: + pass + + data = Data() + # 4 nodes, 2 hyperedges: {0,1,2}, {2,3} + H = torch.tensor( + [ + [1, 0], + [1, 0], + [1, 1], + [0, 1], + ], + dtype=torch.float32, + ) + data.incidence_hyperedges = H + gids = torch.tensor([10, 11, 12, 13]) + + hyperedges = seh.hyperedges_from_incidence_hyperedges(data, gids) + self.assertEqual( + hyperedges, + { + (10, 11, 12), + (12, 13), + }, + ) + + def test_hyperedges_from_incidence_hyperedges_sparse(self): + """ + Test hyperedges_from_incidence_hyperedges with sparse incidence. + """ + class Data: + pass + + data = Data() + indices = torch.tensor([[0, 1, 2, 2, 3], [0, 0, 0, 1, 1]]) + values = torch.ones(indices.size(1)) + H_sparse = torch.sparse_coo_tensor(indices, values, size=(4, 2)) + data.incidence_hyperedges = H_sparse + gids = torch.tensor([0, 1, 2, 3]) + + hyperedges = seh.hyperedges_from_incidence_hyperedges(data, gids) + self.assertEqual(hyperedges, {(0, 1, 2), (2, 3)}) + + def test_compute_hyperedge_coverage_metrics_basic(self): + """ + Test compute_hyperedge_coverage_metrics on simple overlap. + """ + gold = [(0, 1, 2), (3, 4)] + cand = [(0, 1, 2), (3,)] + + m = seh.compute_hyperedge_coverage_metrics(gold, cand) + self.assertEqual(m["gold_n"], 2) + self.assertEqual(m["cand_n"], 2) + self.assertEqual(m["strict_match"], 1) + self.assertEqual(m["partial_covered"], 1) + self.assertAlmostEqual(m["strict_recall"], 0.5) + self.assertAlmostEqual(m["partial_recall"], 0.5) + + def test_summarize_hyperedge_differences(self): + """ + Test summarize_hyperedge_differences includes key phrases. + """ + gold = [(0, 1, 2), (3, 4)] + cand = [(0, 1), (3, 4, 5)] + + summary = seh.summarize_hyperedge_differences(gold, cand) + self.assertIn("match exactly", summary) + self.assertIn("missing in the clustered pipeline", summary) + self.assertIn("appear only in the clustered pipeline", summary) + + @patch("tools.sweep_tools.sweep_over_epochs_hypergraphs.build_golden_and_loader_from_cfg") + @patch("tools.sweep_tools.sweep_over_epochs_hypergraphs.load_perm_to_global") + def test_run_single_experiment_multi_epoch_basic(self, mock_load_perm, mock_build): + """ + Test run_single_experiment_multi_epoch aggregates metrics per epoch. + """ + class Data: + pass + + golden = Data() + golden.x = torch.randn(3, 2) + golden.incidence_hyperedges = torch.tensor( + [ + [1, 0], + [1, 0], + [0, 1], + ], + dtype=torch.float32, + ) + + batch = Data() + batch.x = torch.randn(3, 2) + batch.incidence_hyperedges = golden.incidence_hyperedges + batch.global_nid = torch.tensor([0, 1, 2]) + + handle = {"num_parts": 4} + loader = [batch] # one batch per epoch + + mock_build.return_value = (golden, loader, handle) + mock_load_perm.return_value = None + + cfg = MagicMock() + metrics_list = seh.run_single_experiment_multi_epoch( + cfg, num_parts=4, bs=1, num_epochs=3, accumulate=True + ) + + self.assertEqual(len(metrics_list), 3) + for m in metrics_list: + self.assertAlmostEqual(m["strict_recall"], 1.0) + self.assertAlmostEqual(m["partial_recall"], 1.0) + + @patch("tools.sweep_tools.sweep_over_epochs_hypergraphs.run_single_experiment_multi_epoch") + @patch("tools.sweep_tools.sweep_over_epochs_hypergraphs.hydra.compose") + @patch("tools.sweep_tools.sweep_over_epochs_hypergraphs.hydra.initialize") + def test_run_sweep_multi_epoch_calls_single(self, mock_init, mock_compose, mock_run_single): + """ + Test run_sweep_multi_epoch integrates multi-epoch metrics. + """ + mock_init.return_value.__enter__.return_value = None + mock_init.return_value.__exit__.return_value = False + mock_compose.return_value = MagicMock() + mock_run_single.return_value = [ + { + "gold_n": 1, + "cand_n": 1, + "strict_match": 1, + "partial_covered": 1, + "strict_recall": 1.0, + "partial_recall": 1.0, + } + ] + + batch_sizes, num_parts_list, results_per_pair = seh.run_sweep_multi_epoch( + num_epochs=2, accumulate=True + ) + + self.assertIsInstance(batch_sizes, list) + self.assertIsInstance(num_parts_list, list) + self.assertIsInstance(results_per_pair, dict) + self.assertTrue(results_per_pair) # some entries present + self.assertTrue(mock_run_single.called) + + def test_build_metric_matrix_for_epoch(self): + """ + Test build_metric_matrix_for_epoch builds percent matrix. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results_per_pair = { + (1, 4): [ + {"strict_recall": 0.5}, + {"strict_recall": 0.75}, + ], + (2, 8): [ + {"strict_recall": 1.0}, + ], + } + + M1 = seh.build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=1, metric_key="strict_recall" + ) + self.assertEqual(M1.shape, (2, 2)) + self.assertAlmostEqual(M1[0, 0], 50.0) + self.assertAlmostEqual(M1[1, 1], 100.0) + + M2 = seh.build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=2, metric_key="strict_recall" + ) + self.assertAlmostEqual(M2[0, 0], 75.0) + self.assertTrue(np.isnan(M2[1, 1])) + + @patch.object(Figure, "savefig") + def test_plot_summary_4panel_calls_savefig(self, mock_savefig): + """ + Test plot_summary_4panel renders figure and saves to disk. + """ + batch_sizes = [1, 2] + num_parts_list = [4, 8] + results_per_pair = { + (1, 4): [ + {"strict_recall": 0.5}, + {"strict_recall": 0.75}, + ], + (2, 8): [ + {"strict_recall": 0.4}, + {"strict_recall": 0.9}, + ], + } + + seh.plot_summary_4panel( + batch_sizes=batch_sizes, + num_parts_list=num_parts_list, + results_per_pair=results_per_pair, + num_epochs=2, + metric_key="strict_recall", + target_bs=1, + target_num_parts=4, + save_prefix="cora_hg_epochs_test", + ) + + self.assertTrue(mock_savefig.called) + args, kwargs = mock_savefig.call_args + self.assertIn("cora_hg_epochs_test_strict_recall.png", args[0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/sweep_tools/__init__.py b/tools/sweep_tools/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tools/sweep_tools/sweep_cells.py b/tools/sweep_tools/sweep_cells.py new file mode 100644 index 000000000..2316d59e6 --- /dev/null +++ b/tools/sweep_tools/sweep_cells.py @@ -0,0 +1,942 @@ +import os +import os.path as osp +import shutil +from collections import defaultdict + +import hydra +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch_geometric +from omegaconf import DictConfig +from torch.utils.data import DataLoader +from torch_geometric.utils import coalesce, remove_self_loops + +from topobench.data.preprocessor import PreProcessor +from topobench.data.utils import build_cluster_transform +from topobench.dataloader.dataload_cluster import ( + BlockCSRBatchCollator, + _HandleAdapter, + _PartIdListDataset, +) + + +# 1. BUILD GOLDEN & CANDIDATE (CELLS) +def build_golden_and_candidate_from_cfg(cfg: DictConfig, + num_parts: int = 10, + batch_size: int = 1): + """Build golden and candidate cell-complex graphs from config. + + The golden graph is obtained by global lifting on the full dataset. + Candidate graphs are built by partitioning, remapping to true node + IDs, padding node-aligned tensors to global size, and applying the + same lifting per cluster. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration with dataset and transform settings. + num_parts : int, optional + Number of graph partitions for the candidate setup. + batch_size : int, optional + Number of clusters per candidate mini-batch. + + Returns + ------- + tuple + ``(golden, candidate_batches, handle)``, where ``golden`` is a + single lifted graph, ``candidate_batches`` is a list of lifted + candidate graphs, and ``handle`` is the packed partition handle. + """ + dataset_loader = hydra.utils.instantiate(cfg.dataset.loader) + dataset, dataset_dir = dataset_loader.load() + transforms_config = cfg.get("transforms", None) + + # Golden: global lifting + golden_pre = PreProcessor(dataset, dataset_dir, transforms_config) + assert len(golden_pre.data_list) == 1, "Expected a single graph for transductive setting." + golden = golden_pre.data_list[0] + print("Golden keys:", sorted(golden.keys())) + + if not hasattr(golden, "x_0"): + raise RuntimeError("Golden data has no x_0; this script is for cell complexes.") + + # Candidate: raw, then partition + remap + cluster lifting + raw_pre = PreProcessor(dataset, dataset_dir, transforms_config=None) + + cluster_params = cfg.dataset.loader.parameters.get("cluster", {}) + if hasattr(cluster_params, "to_container"): + cluster_params = cluster_params.to_container(resolve=True) + cluster_params = dict(cluster_params) + cluster_params["num_parts"] = int(num_parts) + + handle = raw_pre.pack_global_partition( + split_params=cfg.dataset.get("split_params", {}), + cluster_params=cluster_params, + stream_params=cfg.dataset.loader.parameters.get("stream", {}), + dtype_policy=cfg.dataset.loader.parameters.get("dtype_policy", "preserve"), + pack_db=True, + pack_memmaps=True, + ) + + post_batch_transform = build_cluster_transform(transforms_config) + print("Post-batch transform:", post_batch_transform) + + adapter = _HandleAdapter(handle) + part_ids = np.arange(adapter.num_parts, dtype=np.int64) + part_ds = _PartIdListDataset(part_ids) + + active_split = cfg.get("cluster_eval", {}).get("active_split", "train") + + # IMPORTANT: do NOT apply the transform in the collator; we must remap first. + collate = BlockCSRBatchCollator( + adapter, + device=None, + with_edge_attr=handle.get("has_edge_attr", False), + active_split=active_split, + post_batch_transform=None, + ) + + loader = DataLoader( + part_ds, + batch_size=batch_size, + shuffle=False, + num_workers=0, + pin_memory=False, + collate_fn=collate, + ) + + # Load permutation to global for remapping candidate batches + perm_to_global = load_perm_to_global(handle) + if perm_to_global is None: + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + + target_n0 = int(golden.num_nodes) + + def _pad_to_global(val: torch.Tensor, sorted_gids: torch.Tensor): + """Pad node-aligned tensor to global length. + + Parameters + ---------- + val : torch.Tensor + Node-aligned tensor of shape ``(local_n, ...)``. + sorted_gids : torch.Tensor + Sorted global IDs for the local nodes. + + Returns + ------- + torch.Tensor + Tensor of shape ``(target_n0, ...)`` with values placed at + global positions and zeros elsewhere. + """ + if val.size(0) == target_n0: + return val # already global-sized + shape = (target_n0,) + tuple(val.shape[1:]) + if val.dtype == torch.bool: + out = torch.zeros(shape, dtype=torch.bool, device=val.device) + else: + out = torch.zeros(shape, dtype=val.dtype, device=val.device) + out[sorted_gids] = val + return out + + candidate_batches = [] + print("\n--- Loading, remapping, and transforming candidate batches ---") + for _i, raw_batch in enumerate(loader): + # 1) Map local node IDs to true global IDs + if hasattr(raw_batch, "global_nid"): + gids_local = raw_batch.global_nid.long() + else: + gids_local = torch.arange(raw_batch.num_nodes, device=raw_batch.edge_index.device) + + if perm_to_global is not None: + true_gids = perm_to_global[gids_local] + else: + true_gids = gids_local + + # 2) Remap edges to true global ID space + remapped_edge_index = true_gids[raw_batch.edge_index] + + # 3) Carry over features and attributes + batch_dict = raw_batch.to_dict() + batch_dict["edge_index"] = remapped_edge_index + + # Canonicalize node order for node-aligned tensors + sorted_gids, sorted_idx = torch.sort(true_gids) + + # Reindex then PAD to global size for all node-aligned tensors + for key, value in list(batch_dict.items()): + if isinstance(value, torch.Tensor) and value.dim() > 0 and value.size(0) == raw_batch.num_nodes: + val_sorted = value[sorted_idx] + batch_dict[key] = _pad_to_global(val_sorted, sorted_gids) + + # Provide identity global mapping over the full domain (x_0 is now global-sized) + device = remapped_edge_index.device + full_ids = torch.arange(target_n0, device=device, dtype=torch.long) + batch_dict["true_global_nid"] = full_ids + batch_dict["global_nid"] = full_ids + # Optional: remember which global nodes this part actually touched + present_mask_0 = torch.zeros(target_n0, dtype=torch.bool, device=device) + present_mask_0[sorted_gids] = True + batch_dict["present_mask_0"] = present_mask_0 + batch_dict["is_true_global_remapped"] = True + + # Keep PyG happy: set num_nodes to the global size + batch_dict["num_nodes"] = target_n0 + + remapped_graph = torch_geometric.data.Data.from_dict(batch_dict) + + # 5) Clean edges (self-loops) and coalesce + if hasattr(remapped_graph, "edge_index"): + cleaned_ei, _ = remove_self_loops(remapped_graph.edge_index) + remapped_graph.edge_index = coalesce(cleaned_ei, num_nodes=remapped_graph.num_nodes) + + # 6) Finally apply the (cluster) lifting after remapping + if post_batch_transform is not None: + lifted_graph = post_batch_transform(remapped_graph) + # Preserve helper attributes on lifted graph + lifted_graph.true_global_nid = full_ids + lifted_graph.global_nid = full_ids + lifted_graph.present_mask_0 = present_mask_0 + lifted_graph.is_true_global_remapped = True + candidate_batches.append(lifted_graph) + else: + candidate_batches.append(remapped_graph) + + print("--- Remapping and transformation complete ---\n") + + print("Num candidate batches:", len(candidate_batches)) + if candidate_batches: + b0 = candidate_batches[0] + print("First candidate keys:", sorted(b0.keys())) + if hasattr(b0, "global_nid"): + print("First candidate global_nid shape:", tuple(b0.global_nid.shape)) + + # Canonicalize golden edges too (mirror debug hygiene) + if hasattr(golden, "edge_index"): + cleaned_ei, _ = remove_self_loops(golden.edge_index) + golden.edge_index = coalesce(cleaned_ei, num_nodes=golden.num_nodes) + + return golden, candidate_batches, handle + + +# 2. PERMUTATION HANDLING +def load_perm_to_global(handle): + """Load permuted-to-global node ID mapping from disk. + + Parameters + ---------- + handle : dict + Partition handle containing ``processed_dir``. + + Returns + ------- + torch.Tensor or None + Tensor of shape ``(N,)`` mapping permuted IDs to global IDs, or + ``None`` if the mapping file is missing. + """ + base_dir = handle["processed_dir"] + perm_path = osp.join(base_dir, "perm_memmap", "perm_to_global.npy") + + if not osp.exists(perm_path): + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + return None + + arr = np.load(perm_path, mmap_mode="r") + perm_to_global = torch.from_numpy(arr).long() + print("Loaded perm_to_global of shape", tuple(perm_to_global.shape)) + return perm_to_global + + +def resolve_true_global_ids(golden, batch, perm_to_global): + """Resolve 0-cell global IDs for a candidate batch. + + Uses cached identity mappings when present, otherwise maps from + permuted IDs via ``perm_to_global`` or falls back to local indices. + + Parameters + ---------- + golden : Data + Golden reference graph with global 0-cells. + batch : Data + Candidate batch graph. + perm_to_global : torch.Tensor or None + Mapping from permuted to global IDs, or ``None``. + + Returns + ------- + torch.Tensor + Tensor of true global 0-cell IDs for the batch. + """ + if hasattr(batch, "x_0"): + n0 = batch.x_0.size(0) + device = batch.x_0.device + elif hasattr(batch, "x"): + n0 = batch.x.size(0) + device = batch.x.device + else: + raise RuntimeError("Batch has no x_0 or x; cannot resolve 0-cell IDs.") + + # If we've padded to global size, use identity mapping + if getattr(batch, "is_true_global_remapped", False): + # true_global_nid may be full identity already; if not, identity works. + if hasattr(batch, "true_global_nid") and getattr(batch.true_global_nid, "numel", lambda: 0)() == n0: + return batch.true_global_nid.to(device) + return torch.arange(n0, device=device, dtype=torch.long) + + # Legacy path (not padded) + if not hasattr(batch, "global_nid"): + print("Batch has no global_nid; using local indices as global IDs.") + return torch.arange(n0, device=device) + + gids = batch.global_nid.clone().detach().long() + true_gids = perm_to_global[gids] if perm_to_global is not None else gids + + # Optional sanity check on x_0 + if hasattr(golden, "x_0") and hasattr(batch, "x_0") and n0 > 0: + k = min(50, n0) + idx = torch.randint(0, n0, (k,)) + try: + diff = (batch.x_0[idx].cpu() - golden.x_0[true_gids[idx]].cpu()).abs().max() + print(" sanity max|x_0_batch - x_0_golden[true_gids]| =", float(diff)) + except Exception as e: + print(" sanity check failed:", e) + + return true_gids.to(device) + + +# 3. HELPERS FOR INCIDENCE HANDLING +def _build_col_to_rows_mapping(M, n_rows): + """Build column-to-row index mapping from an incidence-like matrix. + + Supports dense tensors, sparse COO tensors, and objects exposing a + ``.coo()`` method. + + Parameters + ---------- + M : Any + Incidence-like matrix or sparse structure. + n_rows : int + Expected number of rows. + + Returns + ------- + dict or None + Mapping ``col_index -> set(row_indices)`` or ``None`` if the + shape does not match or the type is unsupported. + """ + if M is None: + return None + + # torch.sparse_coo_tensor + if isinstance(M, torch.Tensor) and M.is_sparse: + M = M.coalesce() + if M.ndim != 2 or M.size(0) != n_rows: + return None + rows, cols = M.indices() + mapping = defaultdict(set) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + # torch_sparse.SparseTensor + if hasattr(M, "coo"): + row, col, _ = M.coo() + if hasattr(M, "sparse_sizes"): + sizes = M.sparse_sizes() + if sizes[0] != n_rows: + return None + mapping = defaultdict(set) + for i, j in zip(row.tolist(), col.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + # Dense tensor + if isinstance(M, torch.Tensor): + if M.ndim != 2 or M.size(0) != n_rows: + return None + rows, cols = (M != 0).nonzero(as_tuple=True) + mapping = defaultdict(set) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + return None + + +# 4. 1-CELLS & 2-CELLS AS SETS OF 0-CELLS +def extract_1_cells(data, true_global_ids: torch.Tensor): + """Extract 1-cells as sets of 0-cell global IDs. + + Assumes ``incidence_1`` represents 0→1 incidence with shape + ``(n0, n1)``, where each column is a 1-cell. + + Parameters + ---------- + data : Data + Cell-complex graph with ``x_0`` and ``incidence_1``. + true_global_ids : torch.Tensor + Global 0-cell IDs of shape ``(n0,)``. + + Returns + ------- + tuple + ``(cells_1_list, cells_1_set)``, where ``cells_1_list`` is a + list of frozensets for each 1-cell (possibly empty) and + ``cells_1_set`` is the set of non-empty 1-cells. + """ + if true_global_ids is None: + return [], set() + + gids = true_global_ids.cpu() + + if not hasattr(data, "x_0"): + return [], set() + n0 = data.x_0.size(0) + + M = getattr(data, "incidence_1", None) + if M is None: + return [], set() + + mapping = _build_col_to_rows_mapping(M, n0) + if mapping is None: + return [], set() + + n1 = max(mapping.keys()) + 1 if mapping else 0 + cells_1_list = [] + cells_1_set = set() + + for j in range(n1): + rows = mapping.get(j, set()) + if not rows: + cells_1_list.append(frozenset()) + continue + vs = frozenset(int(gids[i]) for i in rows) + cells_1_list.append(vs) + if vs: + cells_1_set.add(vs) + + return cells_1_list, cells_1_set + + +def extract_2_cells(data, + true_global_ids: torch.Tensor, + cells_1_list): + """Extract 2-cells as sets of 0-cell global IDs. + + Two interpretations of ``incidence_2`` are supported: + + * Case A: shape ``(n0, n2)`` (0→2 incidence). + * Case B: shape ``(n1, n2)`` (1→2 incidence), where each 2-cell is + the union of its incident 1-cells. + + Parameters + ---------- + data : Data + Cell-complex graph with ``x_0`` and optionally ``incidence_2``. + true_global_ids : torch.Tensor + Global 0-cell IDs of shape ``(n0,)``. + cells_1_list : list of frozenset + List of 1-cells as frozensets of 0-cell IDs. + + Returns + ------- + set of frozenset + Set of 2-cells represented as frozensets of 0-cell IDs. + """ + if true_global_ids is None: + return set() + + gids = true_global_ids.cpu() + + if not hasattr(data, "x_0"): + return set() + n0 = data.x_0.size(0) + + M = getattr(data, "incidence_2", None) + if M is None: + return set() + + # Try case (A): 0 -> 2 + mapping_0_2 = _build_col_to_rows_mapping(M, n0) + if mapping_0_2 is not None: + cells_2 = set() + for rows in mapping_0_2.values(): + if not rows: + continue + vs = frozenset(int(gids[i]) for i in rows) + if vs: + cells_2.add(vs) + return cells_2 + + # Try case (B): 1 -> 2 (use 1-cells' vertex sets) + n1 = len(cells_1_list) + if n1 > 0: + mapping_1_2 = _build_col_to_rows_mapping(M, n1) + if mapping_1_2 is not None: + cells_2 = set() + for one_cells in mapping_1_2.values(): + vs = set() + for oc in one_cells: + if 0 <= oc < n1: + vs |= set(cells_1_list[oc]) + if vs: + cells_2.add(frozenset(vs)) + return cells_2 + + # If neither interpretation worked, return empty + return set() + + +# 5. METRICS (STRICT + PARTIAL) +def compute_structure_coverage_metrics( + gold_structs, + cand_structs, + *, + # Partial coverage options: + mode: str = "subset", # "subset" or "jaccard" + min_subset_size: int = 1, # ignore tiny fragments + union_frac: float | None = None, # if set (e.g. 0.5), require union of candidate subsets + jaccard_thresh: float = 0.5 # used when mode="jaccard" +): + """Compute strict and partial coverage metrics between structures. + + Structures are sets of 0-cell IDs represented as frozensets. Strict + matches require exact equality. Partial matches depend on the + chosen mode: + + * ``"subset"``: candidate strict subsets above a size threshold, + optionally requiring their union to cover a fraction of gold. + * ``"jaccard"``: maximum Jaccard similarity above a threshold. + + Parameters + ---------- + gold_structs : iterable of frozenset + Ground truth structures. + cand_structs : iterable of frozenset + Candidate structures. + mode : {"subset", "jaccard"}, optional + Partial coverage criterion. Default is "subset". + min_subset_size : int, optional + Minimum size for subset fragments in subset mode. + union_frac : float or None, optional + Required coverage fraction of the union of fragments in subset + mode. If ``None``, any qualifying fragment suffices. + jaccard_thresh : float, optional + Minimum Jaccard similarity in jaccard mode. + + Returns + ------- + dict + Dictionary with keys ``"gold_n"``, ``"cand_n"``, + ``"strict_match"``, ``"partial_covered"``, ``"strict_recall"``, + and ``"partial_recall"``. + """ + gold_fs = set(gold_structs) + cand_fs = set(cand_structs) + + G = len(gold_fs) + if G == 0: + return { + "gold_n": 0, + "cand_n": len(cand_fs), + "strict_match": 0, + "partial_covered": 0, + "strict_recall": 0.0, + "partial_recall": 0.0, + } + + common = gold_fs & cand_fs + strict_match = len(common) + + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + partially_covered_gold = set(common) + + if mode == "subset": + for g in missing: + g_set = set(g) + # all candidate fragments that are strict subsets of g and large enough + subs = [set(c) for c in new if len(c) >= min_subset_size and set(c) < g_set] + if not subs: + continue + if union_frac is None: + # any single subset fragment is enough + partially_covered_gold.add(g) + else: + # require that the union covers a fraction of g + union_cov = set().union(*subs) + if len(union_cov) / max(1, len(g_set)) >= union_frac: + partially_covered_gold.add(g) + + partial_covered = len(partially_covered_gold) + + return { + "gold_n": G, + "cand_n": len(cand_fs), + "strict_match": strict_match, + "partial_covered": partial_covered, + "strict_recall": strict_match / G, + "partial_recall": partial_covered / G, + } + +# 6. SINGLE EXPERIMENT (1-CELLS & 2-CELLS) +def run_single_experiment(cfg: DictConfig, + num_parts: int = 10, + bs: int = 1): + """Run a single cell-coverage experiment for given partition settings. + + Builds golden and candidate cell complexes, aggregates candidate + 1-cells and 2-cells, and computes structural coverage metrics per + dimension. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration. + num_parts : int, optional + Number of graph partitions. Default is 10. + bs : int, optional + Batch size (number of clusters per step). Default is 1. + + Returns + ------- + dict + Mapping from cell dimension (1 or 2) to metric dictionaries. + """ + golden, candidate_batches, handle = build_golden_and_candidate_from_cfg( + cfg, num_parts=num_parts, batch_size=bs + ) + + requested_num_parts = int(num_parts) + actual_num_parts = int(handle.get("num_parts", -1)) + if actual_num_parts != requested_num_parts: + raise RuntimeError( + f"Partitioner produced {actual_num_parts} parts but requested {requested_num_parts}" + ) + + if not candidate_batches: + print("No candidate batches; abort.") + return None + + perm_to_global = load_perm_to_global(handle) + + # Golden 0-cells + N0 = golden.x_0.size(0) + base_ids = torch.arange(N0) + + # Golden 1-cells & 2-cells + gold_1_list, gold_1_set = extract_1_cells(golden, base_ids) + gold_2_set = extract_2_cells(golden, base_ids, gold_1_list) + + print(f"Golden: 1-cells={len(gold_1_set)}, 2-cells={len(gold_2_set)}") + + # Candidate aggregated + cand_1_set = set() + cand_2_set = set() + + for bi, batch in enumerate(candidate_batches): + print(f"Processing candidate batch {bi}...") + true_ids = resolve_true_global_ids(golden, batch, perm_to_global) + b1_list, b1_set = extract_1_cells(batch, true_ids) + b2_set = extract_2_cells(batch, true_ids, b1_list) + + cand_1_set |= b1_set + cand_2_set |= b2_set + + results_by_dim = {} + + # 1-cells metrics + m1 = compute_structure_coverage_metrics(gold_1_set, cand_1_set) + print( + f"[dim=1, bs={bs}, num_parts={num_parts}] " + f"strict={m1['strict_recall']:.4f}, partial={m1['partial_recall']:.4f}, " + f"gold_n={m1['gold_n']}, cand_n={m1['cand_n']}" + ) + results_by_dim[1] = m1 + + # 2-cells metrics (only if there are golden 2-cells) + if len(gold_2_set) > 0: + m2 = compute_structure_coverage_metrics(gold_2_set, cand_2_set) + print( + f"[dim=2, bs={bs}, num_parts={num_parts}] " + f"strict={m2['strict_recall']:.4f}, partial={m2['partial_recall']:.4f}, " + f"gold_n={m2['gold_n']}, cand_n={m2['cand_n']}" + ) + results_by_dim[2] = m2 + + return results_by_dim + + +# 7. SWEEP (STORE PER DIM) +def run_sweep(): + """Run a sweep over batch sizes and num_parts and collect metrics. + + Uses Hydra to instantiate configurations for each combination of + batch size and number of parts, then runs a single experiment per + combination and stores results per cell dimension. + + Returns + ------- + tuple + ``(batch_sizes, num_parts_list, results_by_dim)`` where + ``results_by_dim[dim][(bs, num_parts)]`` holds metric dicts. + """ + # Adjust dataset_name / splits_dir if needed + dataset_name = "graph/cocitation_cora_cluster" + splits_dir = osp.join("datasets", "data_splits", "Cora") + + batch_sizes = [1, 2, 4, 8, 16, 32] + num_parts_list = [2, 4, 8, 16, 32] + + # results_by_dim[dim][(bs, num_parts)] = metrics + results_by_dim = {1: {}, 2: {}} + + with hydra.initialize(config_path="../../configs", job_name="topo_cells_1_2_sweep"): + for num_parts in num_parts_list: + for bs in batch_sizes: + if bs > num_parts: + print(f"Skip bs={bs}, num_parts={num_parts} (bs > num_parts)") + continue + + if osp.exists(splits_dir): + shutil.rmtree(splits_dir) + + cfg = hydra.compose( + config_name="run.yaml", + overrides=[ + f"dataset={dataset_name}", + "model=cell/topotune", + "trainer.max_epochs=1", + "trainer.min_epochs=1", + "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + "paths=test", + ], + return_hydra_config=True, + ) + + print(f"\n=== RUN bs={bs}, num_parts={num_parts} ===") + m_by_dim = run_single_experiment(cfg, num_parts=num_parts, bs=bs) + + for dim, m in m_by_dim.items(): + if dim in results_by_dim: + results_by_dim[dim][(bs, num_parts)] = m + + return batch_sizes, num_parts_list, results_by_dim + + +# 8. MATRIX BUILDERS + PLOTTING PER DIM +def build_metric_matrix(batch_sizes, num_parts_list, results_dim, metric_key): + """Build a 2D matrix of a metric over batch size and num_parts grid. + + Parameters + ---------- + batch_sizes : list of int + Batch sizes in the sweep. + num_parts_list : list of int + Numbers of partitions in the sweep. + results_dim : dict + Mapping ``(bs, num_parts) -> metrics`` for a given dimension. + metric_key : str + Key of the metric to extract (e.g. ``"strict_recall"``). + + Returns + ------- + numpy.ndarray + Matrix of shape ``(len(batch_sizes), len(num_parts_list))`` with + metric values in percent, or NaN where missing. + """ + B = len(batch_sizes) + P = len(num_parts_list) + M = np.full((B, P), np.nan, dtype=float) + + for i, bs in enumerate(batch_sizes): + for j, nparts in enumerate(num_parts_list): + m = results_dim.get((bs, nparts)) + if not m: + continue + val = m.get(metric_key) + if val is None: + continue + M[i, j] = 100.0 * float(val) + return M + + +def plot_two_heatmaps(batch_sizes, num_parts_list, + strict_M, partial_M, + save_prefix, title_prefix): + """Plot side-by-side strict and partial recall heatmaps. + + Parameters + ---------- + batch_sizes : list of int + Batch sizes used on the y-axis. + num_parts_list : list of int + Numbers of partitions used on the x-axis. + strict_M : numpy.ndarray + Strict recall matrix in percent. + partial_M : numpy.ndarray + Partial recall matrix in percent. + save_prefix : str + Prefix for the saved figure filename. + title_prefix : str + Title prefix indicating the cell dimension. + """ + assert strict_M.shape == partial_M.shape + B, P = strict_M.shape + + fig, axes = plt.subplots(1, 2, figsize=(14, 6), constrained_layout=True) + + vmin, vmax = 0, 100 + xticks = np.arange(P) + yticks = np.arange(B) + + # Strict recall + ax = axes[0] + im0 = ax.imshow(strict_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_ylabel("batch_size") + ax.set_title(f"{title_prefix}: Strict recall (%)") + for (i, j), val in np.ndenumerate(strict_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + cbar0 = fig.colorbar(im0, ax=ax, fraction=0.046, pad=0.02) + cbar0.set_label("Strict recall (%)") + + # Partial recall + ax = axes[1] + im1 = ax.imshow(partial_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_title(f"{title_prefix}: Partial recall (%)") + for (i, j), val in np.ndenumerate(partial_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + cbar1 = fig.colorbar(im1, ax=ax, fraction=0.046, pad=0.02) + cbar1.set_label("Partial recall (%)") + + out_path = f"sweep_tools/outputs/{save_prefix}_strict_vs_partial.png" + fig.savefig(out_path, dpi=200) + print(f"Saved {title_prefix} heatmaps to: {out_path}") + # plt.show() + + +def plot_recall_by_dim(batch_sizes, num_parts_list, + M_dim1=None, M_dim2=None, + save_prefix="cells_recall", + title_prefix="Recall"): + """Plot strict recall heatmaps for 1-cells and 2-cells. + + If a matrix is ``None`` for a given dimension, that subplot is + omitted. + + Parameters + ---------- + batch_sizes : list of int + Batch sizes used on the y-axis. + num_parts_list : list of int + Numbers of partitions used on the x-axis. + M_dim1 : numpy.ndarray or None, optional + Strict recall matrix for 1-cells. + M_dim2 : numpy.ndarray or None, optional + Strict recall matrix for 2-cells. + save_prefix : str, optional + Prefix for the saved figure filename. Default is "cells_recall". + title_prefix : str, optional + Overall title prefix. Default is "Recall". + """ + mats = [] + + if M_dim1 is not None: + mats.append(("Dim 1 (1-cells)", M_dim1)) + if M_dim2 is not None: + mats.append(("Dim 2 (2-cells)", M_dim2)) + + if not mats: + print("Nothing to plot (no recall matrices provided).") + return + + ncols = len(mats) + B, P = mats[0][1].shape # assume same grid + vmin, vmax = 0, 100 + xticks = np.arange(P) + yticks = np.arange(B) + + fig, axes = plt.subplots(1, ncols, figsize=(7*ncols, 6), constrained_layout=True) + if ncols == 1: + axes = [axes] + + for ax, (subtitle, M) in zip(axes, mats, strict=False): + im = ax.imshow(M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_ylabel("batch_size") + ax.set_title(f"{subtitle}: Recall (%)") + + for (i, j), val in np.ndenumerate(M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + + cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.02) + cbar.set_label("Recall (%)") + + out_path = f"sweep_tools/outputs/{save_prefix}.png" + fig.savefig(out_path, dpi=200) + print(f"Saved {title_prefix} to: {out_path}") + # plt.show() + + +if __name__ == "__main__": + os.makedirs("sweep_tools/outputs", exist_ok=True) + repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + os.chdir(repo_root) + + batch_sizes, num_parts_list, results_by_dim = run_sweep() + print("Results by dim:", results_by_dim[2]) + + # 1-cells + if results_by_dim[1]: + strict_M1 = build_metric_matrix(batch_sizes, num_parts_list, + results_by_dim[1], "strict_recall") + partial_M1 = build_metric_matrix(batch_sizes, num_parts_list, + results_by_dim[1], "partial_recall") + plot_two_heatmaps(batch_sizes, num_parts_list, + strict_M1, partial_M1, + save_prefix="cells_dim1", + title_prefix="Dim 1 (1-cells)") + + # 2-cells (only if present anywhere) + if results_by_dim[2]: + strict_M2 = build_metric_matrix(batch_sizes, num_parts_list, + results_by_dim[2], "strict_recall") + partial_M2 = build_metric_matrix(batch_sizes, num_parts_list, + results_by_dim[2], "partial_recall") + plot_two_heatmaps(batch_sizes, num_parts_list, + strict_M2, partial_M2, + save_prefix="cells_dim2", + title_prefix="Dim 2 (2-cells)") + + plot_recall_by_dim(batch_sizes, num_parts_list, + M_dim1=strict_M1, + M_dim2=strict_M2, + save_prefix="cells_recall", + title_prefix="Recall") diff --git a/tools/sweep_tools/sweep_hypergraphs.py b/tools/sweep_tools/sweep_hypergraphs.py new file mode 100644 index 000000000..1dea7f75c --- /dev/null +++ b/tools/sweep_tools/sweep_hypergraphs.py @@ -0,0 +1,640 @@ +import os +import os.path as osp +import shutil +from collections import defaultdict + +import hydra +import matplotlib.pyplot as plt +import numpy as np +import torch +from omegaconf import DictConfig +from torch.utils.data import DataLoader + +from topobench.data.preprocessor import PreProcessor +from topobench.data.utils import build_cluster_transform +from topobench.dataloader.dataload_cluster import ( + BlockCSRBatchCollator, + _HandleAdapter, + _PartIdListDataset, +) + + +# 1. BUILD GOLDEN & CANDIDATE +def build_golden_and_candidate_from_cfg(cfg: DictConfig, num_parts: int = 10, batch_size: int = 1): + """Build golden graph and candidate cluster batches from config. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and transforms. + num_parts : int, optional + Number of graph partitions, by default 10. + batch_size : int, optional + DataLoader batch size, by default 1. + + Returns + ------- + golden : torch_geometric.data.Data + Full reference (golden) graph. + candidate_batches : list of torch_geometric.data.Data + List of cluster-wise candidate batches. + handle : dict + Partition handle with metadata and paths. + """ + # Load base dataset + dataset_loader = hydra.utils.instantiate(cfg.dataset.loader) + dataset, dataset_dir = dataset_loader.load() + transforms_config = cfg.get("transforms", None) + + # Golden: global lifting (Option A) + golden_pre = PreProcessor(dataset, dataset_dir, transforms_config) + assert len(golden_pre.data_list) == 1, "Expected a single graph for transductive setting." + golden = golden_pre.data_list[0] + print("Golden keys:", sorted(golden.keys())) + + # Candidate: partition raw graph, then apply same lifting per cluster (Option B) + raw_pre = PreProcessor(dataset, dataset_dir, transforms_config=None) + + # Ensure cluster_params is a plain dict and set num_parts explicitly + cluster_params = cfg.dataset.loader.parameters.get("cluster", {}) + # If it's an OmegaConf DictConfig, convert to a dict to avoid weird mutation + if hasattr(cluster_params, "to_container"): + cluster_params = cluster_params.to_container(resolve=True) + cluster_params = dict(cluster_params) # shallow copy + cluster_params["num_parts"] = int(num_parts) + + handle = raw_pre.pack_global_partition( + split_params=cfg.dataset.get("split_params", {}), + cluster_params=cluster_params, + stream_params=cfg.dataset.loader.parameters.get("stream", {}), + dtype_policy=cfg.dataset.loader.parameters.get("dtype_policy", "preserve"), + pack_db=True, + pack_memmaps=True, + ) + + # Same lifting used as post-batch transform + post_batch_transform = build_cluster_transform(transforms_config) + print("Post-batch transform:", post_batch_transform) + + adapter = _HandleAdapter(handle) + part_ids = np.arange(adapter.num_parts, dtype=np.int64) + part_ds = _PartIdListDataset(part_ids) + + # Batch size & split for eval come from cfg so we can sweep + active_split = cfg.get("cluster_eval", {}).get("active_split", "train") + + collate = BlockCSRBatchCollator( + adapter, + device=None, + with_edge_attr=handle.get("has_edge_attr", False), + active_split=active_split, + post_batch_transform=post_batch_transform, + ) + + loader = DataLoader( + part_ds, + batch_size=batch_size, + shuffle=True, + num_workers=0, + pin_memory=False, + collate_fn=collate, + ) + + candidate_batches = [batch for batch in loader] + + print("Num candidate batches:", len(candidate_batches)) + if candidate_batches: + b0 = candidate_batches[0] + print("First candidate keys:", sorted(b0.keys())) + if hasattr(b0, "global_nid"): + print("First candidate global_nid shape:", b0.global_nid.shape) + + return golden, candidate_batches, handle + + +# 2. PERMUTATION HANDLING +def load_perm_to_global(handle): + """Load mapping from permuted node IDs to global IDs. + + Parameters + ---------- + handle : dict + Partition handle containing processed paths. + + Returns + ------- + torch.Tensor or None + Long tensor of shape (num_nodes,) mapping permuted IDs to global IDs, + or ``None`` if no mapping is found. + """ + base_dir = handle["processed_dir"] + perm_path = osp.join(base_dir, "perm_memmap", "perm_to_global.npy") + + if not osp.exists(perm_path): + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + return None + + arr = np.load(perm_path, mmap_mode="r") + perm_to_global = torch.from_numpy(arr).long() + print("Loaded perm_to_global of shape", perm_to_global.shape) + return perm_to_global + + +def resolve_true_global_ids(golden, batch, perm_to_global: torch.Tensor | None): + """Resolve true global node IDs for a batch. + + Parameters + ---------- + golden : torch_geometric.data.Data + Golden reference graph. + batch : torch_geometric.data.Data + Candidate batch with optional ``global_nid``. + perm_to_global : torch.Tensor or None + Mapping from permuted IDs to global IDs. + + Returns + ------- + torch.Tensor + Long tensor of global node IDs on the batch device. + """ + n = batch.x.size(0) + device = batch.x.device + + if hasattr(batch, "global_nid"): + gids = batch.global_nid.clone().detach().long() + + if perm_to_global is not None: + true_gids = perm_to_global[gids] + else: + true_gids = gids + + # Optional sanity check on x_0 if available + if hasattr(golden, "x_0") and hasattr(batch, "x_0"): + k = min(50, n) + idx = torch.randint(0, n, (k,)) + try: + diff = (batch.x_0[idx].cpu() - golden.x_0[true_gids[idx]].cpu()).abs().max() + print(" sanity max|x_0_batch - x_0_golden[true_gids]| =", float(diff)) + except Exception as e: + print(" sanity check failed:", e) + + return true_gids.to(device) + + return torch.arange(n, device=device) + + +# 3. HYPERGRAPH STRUCTURE +def hyperedges_from_incidence_hyperedges(data, true_global_ids: torch.Tensor): + """Extract hyperedges from an incidence matrix. + + Parameters + ---------- + data : torch_geometric.data.Data + Graph data with ``incidence_hyperedges`` attribute. + true_global_ids : torch.Tensor + Global node IDs for rows in the incidence matrix. + + Returns + ------- + set of tuple of int + Set of hyperedges as sorted tuples of global node IDs. + """ + if not hasattr(data, "incidence_hyperedges"): + return set() + + H = data.incidence_hyperedges + if H is None or H.numel() == 0: + return set() + + H = H.cpu() + gids = true_global_ids.cpu() + + he_to_nodes = defaultdict(set) + + if getattr(H, "is_sparse", False): + H = H.coalesce() + rows, cols = H.indices() + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + he_to_nodes[int(j)].add(int(i)) + else: + rows, cols = (H != 0).nonzero(as_tuple=True) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + he_to_nodes[int(j)].add(int(i)) + + hyperedges = set() + for nodes in he_to_nodes.values(): + if len(nodes) <= 1: + continue + vs = sorted({int(gids[i]) for i in nodes}) + if len(vs) > 1: + hyperedges.add(tuple(vs)) + + return hyperedges + + +# 4. METRICS (STRICT + PARTIAL) +def compute_hyperedge_coverage_metrics(gold_hyperedges, cand_hyperedges): + """Compute strict and partial recall for hyperedge coverage. + + Parameters + ---------- + gold_hyperedges : iterable of tuple of int + Ground-truth hyperedges. + cand_hyperedges : iterable of tuple of int + Candidate hyperedges. + + Returns + ------- + dict + Dictionary with keys: + ``gold_n``, ``cand_n``, ``strict_match``, ``partial_covered``, + ``strict_recall``, ``partial_recall``. + """ + gold_fs = {frozenset(h) for h in gold_hyperedges} + cand_fs = {frozenset(h) for h in cand_hyperedges} + + G = len(gold_fs) + if G == 0: + return { + "gold_n": 0, + "cand_n": len(cand_fs), + "strict_match": 0, + "partial_covered": 0, + "strict_recall": 0.0, + "partial_recall": 0.0, + } + + common = gold_fs & cand_fs + strict_match = len(common) + + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + missing_sets = [set(h) for h in missing] + + partially_covered_gold = set(common) + + for mh_fs, mh_set in zip(missing, missing_sets, strict=False): + for c in new: + cs = set(c) + if len(cs) > 1 and cs < mh_set: # strict subset fragment + partially_covered_gold.add(mh_fs) + break + + partial_covered = len(partially_covered_gold) + + strict_recall = strict_match / G + partial_recall = partial_covered / G + + return { + "gold_n": G, + "cand_n": len(cand_fs), + "strict_match": strict_match, + "partial_covered": partial_covered, + "strict_recall": strict_recall, + "partial_recall": partial_recall, + } + + +def summarize_hyperedge_differences(gold_hyperedges, cand_hyperedges) -> str: + """Summarize overlap and differences between golden and candidate hyperedges. + + Parameters + ---------- + gold_hyperedges : iterable of tuple of int + Ground-truth hyperedges. + cand_hyperedges : iterable of tuple of int + Candidate hyperedges. + + Returns + ------- + str + Human-readable summary of matches, splits, and lost or new hyperedges. + """ + gold_fs = {frozenset(h) for h in gold_hyperedges} + cand_fs = {frozenset(h) for h in cand_hyperedges} + + common = gold_fs & cand_fs + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + missing_sets = [set(h) for h in missing] + + explained_missing = set() + split_fragments = 0 + unexplained_new = 0 + + for new_h in new: + hs = set(new_h) + found_parent = False + for mh_fs, mh_set in zip(missing, missing_sets, strict=False): + if hs < mh_set: + split_fragments += 1 + explained_missing.add(mh_fs) + found_parent = True + break + if not found_parent: + unexplained_new += 1 + + completely_lost = len(missing) - len(explained_missing) + + return ( + f"Hyperedges: {len(common)} match exactly, {len(missing)} are missing in the " + f"clustered pipeline ({split_fragments} explained as partition-induced splits of " + f"larger golden hyperedges and {completely_lost} completely lost), and {len(new)} " + f"appear only in the clustered pipeline ({unexplained_new} not explainable as " + f"subsets of golden hyperedges)." + ) + + +# 5. SINGLE EXPERIMENT (ONE bs, num_parts) +def run_single_experiment(cfg: DictConfig, num_parts: int = 10, bs = 1): + """Run a single hyperedge coverage experiment for given batch size and partitions. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and model. + num_parts : int, optional + Number of graph partitions, by default 10. + bs : int, optional + Batch size, by default 1. + + Returns + ------- + dict or None + Coverage metrics from :func:`compute_hyperedge_coverage_metrics`, + or ``None`` if no candidate batches exist. + """ + golden, candidate_batches, handle = build_golden_and_candidate_from_cfg(cfg, num_parts=num_parts, batch_size = bs) + + # loud runtime check + requested_num_parts = int(num_parts) + actual_num_parts = int(handle.get("num_parts", -1)) + if actual_num_parts != requested_num_parts: + raise RuntimeError(f"Partitioner produced {actual_num_parts} parts but requested {requested_num_parts}") + + if not candidate_batches: + print("No candidate batches; abort.") + return None + + perm_to_global = load_perm_to_global(handle) + + N = golden.x.size(0) + base_ids = torch.arange(N) + + gold_hyperedges = hyperedges_from_incidence_hyperedges(golden, base_ids) + + cand_hyperedges = set() + for batch in candidate_batches: + true_global_ids = resolve_true_global_ids(golden, batch, perm_to_global) + cand_hyperedges |= hyperedges_from_incidence_hyperedges(batch, true_global_ids) + + m = compute_hyperedge_coverage_metrics(gold_hyperedges, cand_hyperedges) + summary = summarize_hyperedge_differences(gold_hyperedges, cand_hyperedges) + + # Read batch size safely + print( + f"[bs={bs}, num_parts={num_parts}] " + f"strict_recall={m['strict_recall']:.4f}, partial_recall={m['partial_recall']:.4f}" + ) + print(summary) + + return m + + +# 6. SWEEP OVER (batch_size, num_parts) +def run_sweep(): + """Sweep over batch size and number of partitions and collect metrics. + + Returns + ------- + list of int + Tested batch sizes. + list of int + Tested numbers of partitions. + dict + Mapping ``(batch_size, num_parts) -> metrics dict`` from + :func:`compute_hyperedge_coverage_metrics`. + """ + dataset_name = "graph/cocitation_cora_cluster" # adapt as needed (string Hydra expects) + batch_sizes = [1, 2, 4, 8, 16, 32, 64, 128, 256] + num_parts_list = [2, 4, 8, 16, 32, 64, 128, 256] + + results = {} + + with hydra.initialize(config_path="../../configs", job_name="topo_debug_sweep"): + for num_parts in num_parts_list: + for bs in batch_sizes: + # clear cached splits each run + splits_dir = osp.join("datasets", "data_splits", "PubMed") + if osp.exists(splits_dir): + shutil.rmtree(splits_dir) + + cfg = hydra.compose( + config_name="run.yaml", + overrides=[ + f"dataset={dataset_name}", + "model=hypergraph/edgnn", + "trainer.max_epochs=1", + "trainer.min_epochs=1", + "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + "paths=test", + ], + return_hydra_config=True, + ) + + if bs <= num_parts: + m = run_single_experiment(cfg, num_parts=num_parts, bs = bs) + results[(bs, num_parts)] = m + else: + print(f"Run failed for bs={bs}, num_parts={num_parts}") + return batch_sizes, num_parts_list, results + +def build_metric_matrix(batch_sizes, num_parts_list, results, metric_key): + """Build a dense metric matrix in percent. + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row order). + num_parts_list : sequence of int + Numbers of partitions (column order). + results : dict + Mapping ``(batch_size, num_parts) -> metrics dict``. + metric_key : {"strict_recall", "partial_recall"} + Metric key to extract and scale to percent. + + Returns + ------- + ndarray + Matrix of metric values (%) with NaNs for missing entries. + """ + B = len(batch_sizes) + P = len(num_parts_list) + M = np.full((B, P), np.nan, dtype=float) + + for i, bs in enumerate(batch_sizes): + for j, nparts in enumerate(num_parts_list): + m = results.get((bs, nparts)) + if m is None: + continue + val = m.get(metric_key) + if val is None: + continue + M[i, j] = 100.0 * float(val) + return M + + +def plot_two_heatmaps(batch_sizes, num_parts_list, strict_M, partial_M, save_prefix="coverage"): + """Plot side-by-side heatmaps for strict and partial recall. + + Both heatmaps share axes and a [0, 100] color scale. + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row labels). + num_parts_list : sequence of int + Numbers of partitions (column labels). + strict_M : array-like, shape (B, P) + Strict recall values in percent. + partial_M : array-like, shape (B, P) + Partial recall values in percent. + save_prefix : str, optional + Filename prefix for the saved figure, by default "coverage". + """ + assert strict_M.shape == partial_M.shape + B, P = strict_M.shape + + fig, axes = plt.subplots(1, 2, figsize=(14, 6), constrained_layout=True) + + vmin, vmax = 0, 100 + + xticks = np.arange(P) + yticks = np.arange(B) + + # Left: strict + ax = axes[0] + im0 = ax.imshow(strict_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_ylabel("batch_size") + ax.set_title("Strict recall (exact match) %") + + # Annotate (skip NaNs) + for (i, j), val in np.ndenumerate(strict_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + + cbar0 = fig.colorbar(im0, ax=ax, fraction=0.046, pad=0.02) + cbar0.set_label("Strict recall (%)") + + # Right: partial + ax = axes[1] + im1 = ax.imshow(partial_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + # only show y tick labels on left plot to avoid duplication, but it's fine either way + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_title("Partial recall (exact or fragment) %") + + for (i, j), val in np.ndenumerate(partial_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + + cbar1 = fig.colorbar(im1, ax=ax, fraction=0.046, pad=0.02) + cbar1.set_label("Partial recall (%)") + + # Save and show + out_combined = f"sweep_tools/outputs/{save_prefix}_strict_vs_partial.png" + fig.savefig(out_combined, dpi=200) + print(f"Saved combined heatmap: {out_combined}") + # plt.show() + + + +def plot_one_heatmap(batch_sizes, num_parts_list, strict_M, save_prefix="coverage"): + """Plot a single heatmap for strict recall. + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row labels). + num_parts_list : sequence of int + Numbers of partitions (column labels). + strict_M : array-like, shape (B, P) + Strict recall values in percent. NaNs are not annotated. + save_prefix : str, optional + Filename prefix for the saved figure, by default "coverage". + + Returns + ------- + matplotlib.figure.Figure + Figure object containing the heatmap. + matplotlib.axes.Axes + Axes object for further customization. + """ + strict_M = np.asarray(strict_M) + B, P = strict_M.shape + + fig, ax = plt.subplots(figsize=(7, 6), constrained_layout=True) + + vmin, vmax = 0, 100 + xticks = np.arange(P) + yticks = np.arange(B) + + im = ax.imshow(strict_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax.set_xticks(xticks) + ax.set_xticklabels(num_parts_list) + ax.set_yticks(yticks) + ax.set_yticklabels(batch_sizes) + ax.set_xlabel("num_parts") + ax.set_ylabel("batch_size") + ax.set_title("Hyperedges: Recall %") + + # Annotate (skip NaNs) + for (i, j), val in np.ndenumerate(strict_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=8, color=color) + + cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.02) + cbar.set_label("Recall (%)") + + out_path = f"sweep_tools/outputs/{save_prefix}_strict.png" + fig.savefig(out_path, dpi=200) + print(f"Saved strict heatmap: {out_path}") + # plt.show() + + + return fig, ax + +if __name__ == "__main__": + repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + os.chdir(repo_root) + + os.makedirs("sweep_tools/outputs", exist_ok=True) + + batch_sizes, num_parts_list, results = run_sweep() + + print(results) + + strict_M = build_metric_matrix(batch_sizes, num_parts_list, results, "strict_recall") + partial_M = build_metric_matrix(batch_sizes, num_parts_list, results, "partial_recall") + + plot_two_heatmaps(batch_sizes, num_parts_list, strict_M, partial_M, save_prefix="cora_hypergraph_final") + plot_one_heatmap(batch_sizes, num_parts_list, strict_M, save_prefix="cora_hypergraph") diff --git a/tools/sweep_tools/sweep_over_epochs_cells.py b/tools/sweep_tools/sweep_over_epochs_cells.py new file mode 100644 index 000000000..e70ab77b5 --- /dev/null +++ b/tools/sweep_tools/sweep_over_epochs_cells.py @@ -0,0 +1,976 @@ +import os +import os.path as osp +import shutil +from collections import defaultdict + +import hydra +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch_geometric +from omegaconf import DictConfig +from torch.utils.data import DataLoader +from torch_geometric.utils import coalesce, remove_self_loops + +from topobench.data.preprocessor import PreProcessor +from topobench.data.utils import build_cluster_transform +from topobench.dataloader.dataload_cluster import ( + BlockCSRBatchCollator, + _HandleAdapter, + _PartIdListDataset, +) + +# 1. BATCH PROCESSOR (REMAP + LIFT) + +def process_raw_batch_to_lifted( + raw_batch, + perm_to_global, + post_batch_transform, + target_n0: int, + pad_to_global_fn, +): + """Remap a raw cluster batch to true IDs, pad, clean, and lift. + + Parameters + ---------- + raw_batch : torch_geometric.data.Data + Raw cluster-level batch. + perm_to_global : torch.Tensor or None + Mapping from permuted IDs to global IDs. + post_batch_transform : callable or None + Lifting transform applied after remapping. + target_n0 : int + Total number of 0-cells in the global complex. + pad_to_global_fn : callable + Function that pads node-aligned tensors to size ``target_n0``. + + Returns + ------- + torch_geometric.data.Data + Remapped and (optionally) lifted batch aligned to global nodes. + """ + # 1) Map local node IDs to true global IDs + if hasattr(raw_batch, "global_nid"): + gids_local = raw_batch.global_nid.long() + else: + gids_local = torch.arange(raw_batch.num_nodes, device=raw_batch.edge_index.device) + + if perm_to_global is not None: + true_gids = perm_to_global[gids_local] + else: + true_gids = gids_local + + # 2) Remap edges to true global ID space + remapped_edge_index = true_gids[raw_batch.edge_index] + + # 3) Carry over features and attributes + batch_dict = raw_batch.to_dict() + batch_dict["edge_index"] = remapped_edge_index + + # Canonicalize node order for node-aligned tensors + sorted_gids, sorted_idx = torch.sort(true_gids) + + # Reindex then pad to global size for all node-aligned tensors + for key, value in list(batch_dict.items()): + if isinstance(value, torch.Tensor) and value.dim() > 0 and value.size(0) == raw_batch.num_nodes: + val_sorted = value[sorted_idx] + batch_dict[key] = pad_to_global_fn(val_sorted, sorted_gids) + + device = remapped_edge_index.device + full_ids = torch.arange(target_n0, device=device, dtype=torch.long) + batch_dict["true_global_nid"] = full_ids + batch_dict["global_nid"] = full_ids + present_mask_0 = torch.zeros(target_n0, dtype=torch.bool, device=device) + present_mask_0[sorted_gids] = True + batch_dict["present_mask_0"] = present_mask_0 + batch_dict["is_true_global_remapped"] = True + batch_dict["num_nodes"] = target_n0 + + remapped_graph = torch_geometric.data.Data.from_dict(batch_dict) + + # Clean edges + if hasattr(remapped_graph, "edge_index"): + cleaned_ei, _ = remove_self_loops(remapped_graph.edge_index) + remapped_graph.edge_index = coalesce(cleaned_ei, num_nodes=remapped_graph.num_nodes) + + # Lifting + if post_batch_transform is not None: + lifted_graph = post_batch_transform(remapped_graph) + lifted_graph.true_global_nid = full_ids + lifted_graph.global_nid = full_ids + lifted_graph.present_mask_0 = present_mask_0 + lifted_graph.is_true_global_remapped = True + return lifted_graph + + return remapped_graph + + +def build_golden_and_loader_from_cfg_cells( + cfg: DictConfig, + num_parts: int = 10, + batch_size: int = 1, +): + """Build golden complex and DataLoader for multi-epoch cell experiments. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and transforms. + num_parts : int, optional + Number of graph partitions, by default 10. + batch_size : int, optional + DataLoader batch size, by default 1. + + Returns + ------- + golden : torch_geometric.data.Data + Golden (full) lifted cell complex. + loader : torch.utils.data.DataLoader + Loader over partition IDs producing raw batches. + handle : dict + Partition handle with metadata and paths. + perm_to_global : torch.Tensor or None + Mapping from permuted IDs to global IDs. + post_batch_transform : callable or None + Lifting transform applied after remapping. + target_n0 : int + Total number of 0-cells in the global complex. + pad_to_global_fn : callable + Function for padding node-aligned tensors to size ``target_n0``. + """ + dataset_loader = hydra.utils.instantiate(cfg.dataset.loader) + dataset, dataset_dir = dataset_loader.load() + transforms_config = cfg.get("transforms", None) + + golden_pre = PreProcessor(dataset, dataset_dir, transforms_config) + assert len(golden_pre.data_list) == 1, "Expected a single graph for transductive setting." + golden = golden_pre.data_list[0] + print("Golden keys:", sorted(golden.keys())) + if not hasattr(golden, "x_0"): + raise RuntimeError("Golden data has no x_0; this script is for cell complexes.") + + raw_pre = PreProcessor(dataset, dataset_dir, transforms_config=None) + + cluster_params = cfg.dataset.loader.parameters.get("cluster", {}) + if hasattr(cluster_params, "to_container"): + cluster_params = cluster_params.to_container(resolve=True) + cluster_params = dict(cluster_params) + cluster_params["num_parts"] = int(num_parts) + + handle = raw_pre.pack_global_partition( + split_params=cfg.dataset.get("split_params", {}), + cluster_params=cluster_params, + stream_params=cfg.dataset.loader.parameters.get("stream", {}), + dtype_policy=cfg.dataset.loader.parameters.get("dtype_policy", "preserve"), + pack_db=True, + pack_memmaps=True, + ) + + post_batch_transform = build_cluster_transform(transforms_config) + print("Post-batch transform:", post_batch_transform) + + adapter = _HandleAdapter(handle) + part_ids = np.arange(adapter.num_parts, dtype=np.int64) + part_ds = _PartIdListDataset(part_ids) + + active_split = cfg.get("cluster_eval", {}).get("active_split", "train") + + collate = BlockCSRBatchCollator( + adapter, + device=None, + with_edge_attr=handle.get("has_edge_attr", False), + active_split=active_split, + post_batch_transform=None, # transform applied after remapping + ) + + loader = DataLoader( + part_ds, + batch_size=batch_size, + shuffle=True, # shuffle so epochs differ + num_workers=0, + pin_memory=False, + collate_fn=collate, + ) + + perm_to_global = load_perm_to_global(handle) + if perm_to_global is None: + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + + target_n0 = int(golden.num_nodes) + + # Canonicalize golden edges + if hasattr(golden, "edge_index"): + cleaned_ei, _ = remove_self_loops(golden.edge_index) + golden.edge_index = coalesce(cleaned_ei, num_nodes=golden.num_nodes) + + def _pad_to_global(val: torch.Tensor, sorted_gids: torch.Tensor): + """Pad a node-aligned tensor from a batch to global size.""" + if val.size(0) == target_n0: + return val + shape = (target_n0,) + tuple(val.shape[1:]) + if val.dtype == torch.bool: + out = torch.zeros(shape, dtype=torch.bool, device=val.device) + else: + out = torch.zeros(shape, dtype=val.dtype, device=val.device) + out[sorted_gids] = val + return out + + return golden, loader, handle, perm_to_global, post_batch_transform, target_n0, _pad_to_global + + +# 2. PERMUTATION HANDLING + +def load_perm_to_global(handle): + """Load mapping from permuted node IDs to global IDs. + + Parameters + ---------- + handle : dict + Partition handle containing ``processed_dir``. + + Returns + ------- + torch.Tensor or None + Long tensor of shape (num_nodes,) mapping permuted IDs to global IDs, + or ``None`` if the mapping file does not exist. + """ + base_dir = handle["processed_dir"] + perm_path = osp.join(base_dir, "perm_memmap", "perm_to_global.npy") + + if not osp.exists(perm_path): + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + return None + + arr = np.load(perm_path, mmap_mode="r") + perm_to_global = torch.from_numpy(arr).long() + print("Loaded perm_to_global of shape", tuple(perm_to_global.shape)) + return perm_to_global + + +def resolve_true_global_ids(golden, batch, perm_to_global): + """Map local 0-cell IDs in a batch to true global 0-cell IDs. + + Parameters + ---------- + golden : torch_geometric.data.Data + Golden cell complex with reference 0-cell features. + batch : torch_geometric.data.Data + Batch with 0-cell features and optional ID metadata. + perm_to_global : torch.Tensor or None + Mapping from permuted IDs to global IDs. + + Returns + ------- + torch.Tensor + Long tensor of true global 0-cell IDs for the batch. + """ + if hasattr(batch, "x_0"): + n0 = batch.x_0.size(0) + device = batch.x_0.device + elif hasattr(batch, "x"): + n0 = batch.x.size(0) + device = batch.x.device + else: + raise RuntimeError("Batch has no x_0 or x; cannot resolve 0-cell IDs.") + + if getattr(batch, "is_true_global_remapped", False): + if hasattr(batch, "true_global_nid") and getattr(batch.true_global_nid, "numel", lambda: 0)() == n0: + return batch.true_global_nid.to(device) + return torch.arange(n0, device=device, dtype=torch.long) + + if not hasattr(batch, "global_nid"): + print("Batch has no global_nid; using local indices as global IDs.") + return torch.arange(n0, device=device) + + gids = batch.global_nid.clone().detach().long() + true_gids = perm_to_global[gids] if perm_to_global is not None else gids + + if hasattr(golden, "x_0") and hasattr(batch, "x_0") and n0 > 0: + k = min(50, n0) + idx = torch.randint(0, n0, (k,)) + try: + diff = (batch.x_0[idx].cpu() - golden.x_0[true_gids[idx]].cpu()).abs().max() + print(" sanity max|x_0_batch - x_0_golden[true_gids]| =", float(diff)) + except Exception as e: + print(" sanity check failed:", e) + + return true_gids.to(device) + + +# 3. HELPERS FOR INCIDENCE HANDLING + +def _build_col_to_rows_mapping(M, n_rows): + """Build a column-to-row index mapping from an incidence-like matrix. + + Parameters + ---------- + M : torch.Tensor or torch.sparse or COO-like + Incidence-like matrix where rows index lower-dimensional cells. + n_rows : int + Expected number of rows (lower-dimensional cells). + + Returns + ------- + dict or None + Mapping ``col_index -> set(row_indices)`` or ``None`` if shapes mismatch + or the format is unsupported. + """ + if M is None: + return None + + if isinstance(M, torch.Tensor) and M.is_sparse: + M = M.coalesce() + if M.ndim != 2 or M.size(0) != n_rows: + return None + rows, cols = M.indices() + mapping = defaultdict(set) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + if hasattr(M, "coo"): + row, col, _ = M.coo() + if hasattr(M, "sparse_sizes"): + sizes = M.sparse_sizes() + if sizes[0] != n_rows: + return None + mapping = defaultdict(set) + for i, j in zip(row.tolist(), col.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + if isinstance(M, torch.Tensor): + if M.ndim != 2 or M.size(0) != n_rows: + return None + rows, cols = (M != 0).nonzero(as_tuple=True) + mapping = defaultdict(set) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + mapping[int(j)].add(int(i)) + return mapping + + return None + + +# 4. 1-CELLS & 2-CELLS AS SETS OF 0-CELLS + +def extract_1_cells(data, true_global_ids: torch.Tensor): + """Extract 1-cells as sets of global 0-cell IDs. + + Parameters + ---------- + data : torch_geometric.data.Data + Cell complex data with ``x_0`` and ``incidence_1``. + true_global_ids : torch.Tensor + Global 0-cell IDs for the 0-cell axis. + + Returns + ------- + list of frozenset + Per-1-cell list of 0-cell sets (may contain empty sets). + set of frozenset + Set of non-empty 1-cells as unique 0-cell sets. + """ + if true_global_ids is None: + return [], set() + + gids = true_global_ids.cpu() + + if not hasattr(data, "x_0"): + return [], set() + n0 = data.x_0.size(0) + + M = getattr(data, "incidence_1", None) + if M is None: + return [], set() + + mapping = _build_col_to_rows_mapping(M, n0) + if mapping is None: + return [], set() + + n1 = max(mapping.keys()) + 1 if mapping else 0 + cells_1_list = [] + cells_1_set = set() + + for j in range(n1): + rows = mapping.get(j, set()) + if not rows: + cells_1_list.append(frozenset()) + continue + vs = frozenset(int(gids[i]) for i in rows) + cells_1_list.append(vs) + if vs: + cells_1_set.add(vs) + + return cells_1_list, cells_1_set + + +def extract_2_cells(data, + true_global_ids: torch.Tensor, + cells_1_list): + """Extract 2-cells as sets of global 0-cell IDs. + + Parameters + ---------- + data : torch_geometric.data.Data + Cell complex data with ``x_0`` and ``incidence_2``. + true_global_ids : torch.Tensor + Global 0-cell IDs for the 0-cell axis. + cells_1_list : list of frozenset + Per-1-cell list of 0-cell sets, used when 2-cells are defined over 1-cells. + + Returns + ------- + set of frozenset + Set of 2-cells, each as a 0-cell frozenset. + """ + if true_global_ids is None: + return set() + + gids = true_global_ids.cpu() + + if not hasattr(data, "x_0"): + return set() + n0 = data.x_0.size(0) + + M = getattr(data, "incidence_2", None) + if M is None: + return set() + + # Case 1: 2-cells defined directly over 0-cells + mapping_0_2 = _build_col_to_rows_mapping(M, n0) + if mapping_0_2 is not None: + cells_2 = set() + for rows in mapping_0_2.values(): + if not rows: + continue + vs = frozenset(int(gids[i]) for i in rows) + if vs: + cells_2.add(vs) + return cells_2 + + # Case 2: 2-cells defined over 1-cells, then expanded to 0-cells + n1 = len(cells_1_list) + if n1 > 0: + mapping_1_2 = _build_col_to_rows_mapping(M, n1) + if mapping_1_2 is not None: + cells_2 = set() + for one_cells in mapping_1_2.values(): + vs = set() + for oc in one_cells: + if 0 <= oc < n1: + vs |= set(cells_1_list[oc]) + if vs: + cells_2.add(frozenset(vs)) + return cells_2 + + return set() + + +# 5. METRICS (STRICT + PARTIAL) + +def compute_structure_coverage_metrics( + gold_structs, + cand_structs, + *, + mode: str = "subset", + min_subset_size: int = 1, + union_frac: float | None = None, + jaccard_thresh: float = 0.5, +): + """Compute strict and partial coverage metrics for cell-like structures. + + Parameters + ---------- + gold_structs : iterable of hashable + Ground-truth structures, typically frozensets of node IDs. + cand_structs : iterable of hashable + Candidate structures from the clustered pipeline. + mode : {"subset"}, optional + Partial coverage mode, currently only "subset", by default "subset". + min_subset_size : int, optional + Minimum size for candidate subsets when ``mode="subset"``, by default 1. + union_frac : float or None, optional + Minimum fraction of a golden structure covered by the union of subsets. + If ``None``, any subset presence counts as partial, by default None. + jaccard_thresh : float, optional + Unused placeholder for future Jaccard-based modes, by default 0.5. + + Returns + ------- + dict + Dictionary with keys: + ``gold_n``, ``cand_n``, ``strict_match``, ``partial_covered``, + ``strict_recall``, ``partial_recall``. + """ + gold_fs = set(gold_structs) + cand_fs = set(cand_structs) + + G = len(gold_fs) + if G == 0: + return { + "gold_n": 0, + "cand_n": len(cand_fs), + "strict_match": 0, + "partial_covered": 0, + "strict_recall": 0.0, + "partial_recall": 0.0, + } + + common = gold_fs & cand_fs + strict_match = len(common) + + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + partially_covered_gold = set(common) + + if mode == "subset": + for g in missing: + g_set = set(g) + subs = [set(c) for c in new if len(c) >= min_subset_size and set(c) < g_set] + if not subs: + continue + if union_frac is None: + partially_covered_gold.add(g) + else: + union_cov = set().union(*subs) + if len(union_cov) / max(1, len(g_set)) >= union_frac: + partially_covered_gold.add(g) + + partial_covered = len(partially_covered_gold) + + return { + "gold_n": G, + "cand_n": len(cand_fs), + "strict_match": strict_match, + "partial_covered": partial_covered, + "strict_recall": strict_match / G, + "partial_recall": partial_covered / G, + } + + +# 6. MULTI-EPOCH EXPERIMENT FOR CELLS + +def run_single_experiment_multi_epoch_cells( + cfg: DictConfig, + num_parts: int = 10, + bs: int = 1, + num_epochs: int = 5, + accumulate: bool = True, +): + """Run a multi-epoch coverage experiment for 1- and 2-cells. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and model. + num_parts : int, optional + Number of graph partitions, by default 10. + bs : int, optional + Batch size, by default 1. + num_epochs : int, optional + Number of passes over the partition loader, by default 5. + accumulate : bool, optional + If True, coverage accumulates across epochs; otherwise each epoch + is evaluated independently, by default True. + + Returns + ------- + dict + Mapping ``{1: [metrics_epoch1, ...], 2: [metrics_epoch1, ...]}``. + The list for dimension 2 may be empty if no 2-cells exist. + """ + ( + golden, + loader, + handle, + perm_to_global, + post_batch_transform, + target_n0, + pad_to_global_fn, + ) = build_golden_and_loader_from_cfg_cells(cfg, num_parts=num_parts, batch_size=bs) + + requested_num_parts = int(num_parts) + actual_num_parts = int(handle.get("num_parts", -1)) + if actual_num_parts != requested_num_parts: + raise RuntimeError( + f"Partitioner produced {actual_num_parts} parts but requested {requested_num_parts}" + ) + + # Golden cells + N0 = golden.x_0.size(0) + base_ids = torch.arange(N0) + gold_1_list, gold_1_set = extract_1_cells(golden, base_ids) + gold_2_set = extract_2_cells(golden, base_ids, gold_1_list) + print(f"Golden: 1-cells={len(gold_1_set)}, 2-cells={len(gold_2_set)}") + + metrics_dim1 = [] + metrics_dim2 = [] + + cumulative_1 = set() + cumulative_2 = set() + + for epoch in range(1, num_epochs + 1): + cand_1_epoch = set() + cand_2_epoch = set() + + for raw_batch in loader: + lifted_graph = process_raw_batch_to_lifted( + raw_batch, + perm_to_global=perm_to_global, + post_batch_transform=post_batch_transform, + target_n0=target_n0, + pad_to_global_fn=pad_to_global_fn, + ) + true_ids = resolve_true_global_ids(golden, lifted_graph, perm_to_global=None) + + b1_list, b1_set = extract_1_cells(lifted_graph, true_ids) + b2_set = extract_2_cells(lifted_graph, true_ids, b1_list) + + cand_1_epoch |= b1_set + cand_2_epoch |= b2_set + + if accumulate: + cumulative_1 |= cand_1_epoch + cumulative_2 |= cand_2_epoch + cand_1 = cumulative_1 + cand_2 = cumulative_2 + else: + cand_1 = cand_1_epoch + cand_2 = cand_2_epoch + + m1 = compute_structure_coverage_metrics(gold_1_set, cand_1) + metrics_dim1.append(m1) + print( + f"[dim=1, epoch={epoch}, bs={bs}, num_parts={num_parts}] " + f"strict={m1['strict_recall']:.4f}, partial={m1['partial_recall']:.4f}" + ) + + if len(gold_2_set) > 0: + m2 = compute_structure_coverage_metrics(gold_2_set, cand_2) + metrics_dim2.append(m2) + print( + f"[dim=2, epoch={epoch}, bs={bs}, num_parts={num_parts}] " + f"strict={m2['strict_recall']:.4f}, partial={m2['partial_recall']:.4f}" + ) + + results_by_dim_epochs = {1: metrics_dim1} + if len(metrics_dim2) > 0: + results_by_dim_epochs[2] = metrics_dim2 + else: + results_by_dim_epochs[2] = [] + + return results_by_dim_epochs + + +# 7. SWEEP (MULTI-EPOCH CELLS) + +def run_sweep_cells_multi_epoch( + num_epochs: int = 10, + accumulate: bool = True, +): + """Sweep over (batch_size, num_parts) for multi-epoch cell coverage. + + Parameters + ---------- + num_epochs : int, optional + Number of epochs per configuration, by default 10. + accumulate : bool, optional + If True, coverage accumulates across epochs; otherwise per-epoch + coverage is independent, by default True. + + Returns + ------- + list of int + Tested batch sizes. + list of int + Tested numbers of partitions. + dict + Nested results mapping + ``results_by_dim_epochs[dim][(bs, num_parts)] = [metrics_epoch1, ...]``. + """ + dataset_name = "graph/cocitation_cora_cluster" + splits_dir = osp.join("datasets", "data_splits", "Cora") + + batch_sizes = [1, 2, 4, 8, 16, 32] + num_parts_list = [2, 4, 8, 16, 32] + + results_by_dim_epochs = {1: {}, 2: {}} + + with hydra.initialize(config_path="../../configs", job_name="topo_cells_epochs"): + for num_parts in num_parts_list: + for bs in batch_sizes: + if bs > num_parts: + print(f"Skip bs={bs}, num_parts={num_parts} (bs > num_parts)") + continue + + if osp.exists(splits_dir): + shutil.rmtree(splits_dir) + + cfg = hydra.compose( + config_name="run.yaml", + overrides=[ + f"dataset={dataset_name}", + "model=cell/topotune", + "trainer.max_epochs=1", + "trainer.min_epochs=1", + "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + "paths=test", + ], + return_hydra_config=True, + ) + + print(f"\n=== EPOCH SWEEP bs={bs}, num_parts={num_parts} ===") + m_by_dim_epochs = run_single_experiment_multi_epoch_cells( + cfg, + num_parts=num_parts, + bs=bs, + num_epochs=num_epochs, + accumulate=accumulate, + ) + + for dim in [1, 2]: + if dim not in results_by_dim_epochs: + results_by_dim_epochs[dim] = {} + results_by_dim_epochs[dim][(bs, num_parts)] = m_by_dim_epochs.get(dim, []) + + return batch_sizes, num_parts_list, results_by_dim_epochs + + +# 8. MATRIX HELPERS + 4-PANEL PLOTTING PER DIM + +def build_metric_matrix_for_epoch(batch_sizes, num_parts_list, results_per_pair, epoch, metric_key): + """Build a metric matrix for a specific epoch across (bs, num_parts) pairs. + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row order). + num_parts_list : sequence of int + Numbers of partitions (column order). + results_per_pair : dict + Mapping ``(bs, num_parts) -> [metrics_epoch1, ...]``. + epoch : int + 1-based epoch index to extract. + metric_key : str + Metric key (e.g., ``"strict_recall"`` or ``"partial_recall"``). + + Returns + ------- + ndarray + Matrix of metric values in percent, with NaNs for missing entries. + """ + B = len(batch_sizes) + P = len(num_parts_list) + M = np.full((B, P), np.nan, dtype=float) + + for i, bs in enumerate(batch_sizes): + for j, nparts in enumerate(num_parts_list): + metrics_list = results_per_pair.get((bs, nparts)) + if metrics_list is None or len(metrics_list) < epoch: + continue + m = metrics_list[epoch - 1] + val = m.get(metric_key) + if val is None: + continue + M[i, j] = 100.0 * float(val) + return M + + +def plot_summary_4panel_dim( + batch_sizes, + num_parts_list, + results_per_pair_dim, + num_epochs: int, + metric_key: str, + target_bs: int, + target_num_parts: int, + save_prefix: str, + dim_label: str, +): + """Plot a 4-panel summary for one cell dimension. + + The panels show: + (0, 0) Epoch 1 heatmap. + (0, 1) Last epoch heatmap. + (1, 0) Ratio last/first. + (1, 1) Recall vs. epochs for a chosen (bs, num_parts). + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row labels). + num_parts_list : sequence of int + Numbers of partitions (column labels). + results_per_pair_dim : dict + Mapping ``(bs, num_parts) -> [metrics_epoch1, ...]`` for this dimension. + num_epochs : int + Number of epochs to visualize. + metric_key : str + Metric key to plot (e.g., ``"strict_recall"``). + target_bs : int + Batch size for the recall-vs-epochs curve. + target_num_parts : int + Number of partitions for the recall-vs-epochs curve. + save_prefix : str + Filename prefix for the saved figure. + dim_label : str + Human-readable label for the dimension (e.g., "Dim 1 (1-cells)"). + """ + first_M = build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair_dim, epoch=1, metric_key=metric_key + ) + last_M = build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair_dim, epoch=num_epochs, metric_key=metric_key + ) + + ratio_M = np.full_like(first_M, np.nan, dtype=float) + for (i, j), first_val in np.ndenumerate(first_M): + last_val = last_M[i, j] + if np.isnan(first_val) or np.isnan(last_val) or first_val <= 0: + continue + ratio_M[i, j] = last_val / first_val + + fig, axes = plt.subplots(2, 2, figsize=(12, 10), constrained_layout=True) + ax_first, ax_last, ax_ratio, ax_curve = axes[0, 0], axes[0, 1], axes[1, 0], axes[1, 1] + + vmin, vmax = 0, 100 + xticks = np.arange(len(num_parts_list)) + yticks = np.arange(len(batch_sizes)) + + # Epoch 1 heatmap + im_first = ax_first.imshow(first_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax_first.set_xticks(xticks) + ax_first.set_yticks(yticks) + ax_first.set_xticklabels(num_parts_list) + ax_first.set_yticklabels(batch_sizes) + ax_first.set_xlabel("num_parts") + ax_first.set_ylabel("batch_size") + ax_first.set_title(f"{dim_label} – Recall % (epoch 1)") + + for (i, j), val in np.ndenumerate(first_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax_first.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=7, color=color) + + # Last epoch heatmap + ax_last.imshow(last_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax_last.set_xticks(xticks) + ax_last.set_yticks(yticks) + ax_last.set_xticklabels(num_parts_list) + ax_last.set_yticklabels([]) + ax_last.set_xlabel("num_parts") + ax_last.set_title(f"{dim_label} – Recall % (epoch {num_epochs})") + + for (i, j), val in np.ndenumerate(last_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax_last.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=7, color=color) + + cbar_top = fig.colorbar(im_first, ax=[ax_first, ax_last], fraction=0.035, pad=0.02) + label = "Strict recall (%)" if metric_key == "strict_recall" else "Partial recall (%)" + cbar_top.set_label(label) + + # Ratio heatmap + if np.all(np.isnan(ratio_M)): + pass + else: + max(1.0, float(np.nanmax(ratio_M))) + im_ratio = ax_ratio.imshow(ratio_M, origin="lower", aspect="auto", cmap="Reds") + ax_ratio.set_xticks(xticks) + ax_ratio.set_yticks(yticks) + ax_ratio.set_xticklabels(num_parts_list) + ax_ratio.set_yticklabels(batch_sizes) + ax_ratio.set_xlabel("num_parts") + ax_ratio.set_ylabel("batch_size") + ax_ratio.set_title(f"{dim_label} – Final / initial recall (×)") + + for (i, j), val in np.ndenumerate(ratio_M): + if np.isnan(val): + continue + color = "white" if val < 1.0 else "black" + ax_ratio.text(j, i, f"{val:.2f}x", ha="center", va="center", fontsize=7, color=color) + + cbar_ratio = fig.colorbar(im_ratio, ax=ax_ratio, fraction=0.035, pad=0.02) + cbar_ratio.set_label("Final / initial") + + # Curve for specific (bs, num_parts) + metrics_list = results_per_pair_dim.get((target_bs, target_num_parts)) + if metrics_list is None or len(metrics_list) == 0: + ax_curve.text( + 0.5, + 0.5, + f"No data for bs={target_bs}, num_parts={target_num_parts}", + ha="center", + va="center", + ) + ax_curve.axis("off") + else: + epochs = np.arange(1, len(metrics_list) + 1) + vals = [m[metric_key] * 100.0 for m in metrics_list] + ax_curve.plot(epochs, vals, marker="o") + ax_curve.set_xlabel("epoch") + ax_curve.set_ylabel("recall (%)") + ax_curve.set_title( + f"{dim_label} – Recall vs epochs\n(bs={target_bs}, num_parts={target_num_parts})" + ) + ax_curve.grid(alpha=0.3) + ax_curve.set_ylim(0, 105) + + out_path = f"sweep_tools/outputs/{save_prefix}_{metric_key}.png" + fig.savefig(out_path, dpi=200) + print(f"Saved 4-panel summary for {dim_label}: {out_path}") + # plt.show() + + + +# 9. MAIN + +if __name__ == "__main__": + repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + os.chdir(repo_root) + + os.makedirs("sweep_tools/outputs", exist_ok=True) + + NUM_EPOCHS = 10 + TARGET_BS = 8 + TARGET_NUM_PARTS = 32 + + batch_sizes, num_parts_list, results_by_dim_epochs = run_sweep_cells_multi_epoch( + num_epochs=NUM_EPOCHS, + accumulate=True, + ) + + # 4-panel for 1-cells + results_dim1 = results_by_dim_epochs[1] + plot_summary_4panel_dim( + batch_sizes, + num_parts_list, + results_dim1, + num_epochs=NUM_EPOCHS, + metric_key="strict_recall", + target_bs=TARGET_BS, + target_num_parts=TARGET_NUM_PARTS, + save_prefix="cells_dim1_summary", + dim_label="Dim 1 (1-cells)", + ) + + # 4-panel for 2-cells, if any 2-cells exist + if any(len(v) > 0 for v in results_by_dim_epochs[2].values()): + results_dim2 = results_by_dim_epochs[2] + plot_summary_4panel_dim( + batch_sizes, + num_parts_list, + results_dim2, + num_epochs=NUM_EPOCHS, + metric_key="strict_recall", + target_bs=TARGET_BS, + target_num_parts=TARGET_NUM_PARTS, + save_prefix="cells_dim2_summary", + dim_label="Dim 2 (2-cells)", + ) diff --git a/tools/sweep_tools/sweep_over_epochs_hypergraphs.py b/tools/sweep_tools/sweep_over_epochs_hypergraphs.py new file mode 100644 index 000000000..92bf42a11 --- /dev/null +++ b/tools/sweep_tools/sweep_over_epochs_hypergraphs.py @@ -0,0 +1,708 @@ +import os +import os.path as osp +import shutil +from collections import defaultdict + +import hydra +import matplotlib.pyplot as plt +import numpy as np +import torch +from omegaconf import DictConfig +from torch.utils.data import DataLoader + +from topobench.data.preprocessor import PreProcessor +from topobench.data.utils import build_cluster_transform +from topobench.dataloader.dataload_cluster import ( + BlockCSRBatchCollator, + _HandleAdapter, + _PartIdListDataset, +) + + +# 1. BUILD GOLDEN & LOADER (for multi-epoch runs) +def build_golden_and_loader_from_cfg( + cfg: DictConfig, num_parts: int = 10, batch_size: int = 1 +): + """Build golden graph and candidate loader for multi-epoch runs. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and transforms. + num_parts : int, optional + Number of graph partitions, by default 10. + batch_size : int, optional + Batch size for the candidate DataLoader, by default 1. + + Returns + ------- + golden : torch_geometric.data.Data + Full reference (golden) graph. + loader : torch.utils.data.DataLoader + DataLoader over partition IDs producing candidate batches. + handle : dict + Partition handle with metadata and paths. + """ + dataset_loader = hydra.utils.instantiate(cfg.dataset.loader) + dataset, dataset_dir = dataset_loader.load() + transforms_config = cfg.get("transforms", None) + + golden_pre = PreProcessor(dataset, dataset_dir, transforms_config) + assert len(golden_pre.data_list) == 1, "Expected a single graph for transductive setting." + golden = golden_pre.data_list[0] + print("Golden keys:", sorted(golden.keys())) + + raw_pre = PreProcessor(dataset, dataset_dir, transforms_config=None) + + cluster_params = cfg.dataset.loader.parameters.get("cluster", {}) + if hasattr(cluster_params, "to_container"): + cluster_params = cluster_params.to_container(resolve=True) + cluster_params = dict(cluster_params) + cluster_params["num_parts"] = int(num_parts) + + handle = raw_pre.pack_global_partition( + split_params=cfg.dataset.get("split_params", {}), + cluster_params=cluster_params, + stream_params=cfg.dataset.loader.parameters.get("stream", {}), + dtype_policy=cfg.dataset.loader.parameters.get("dtype_policy", "preserve"), + pack_db=True, + pack_memmaps=True, + ) + + post_batch_transform = build_cluster_transform(transforms_config) + print("Post-batch transform:", post_batch_transform) + + adapter = _HandleAdapter(handle) + part_ids = np.arange(adapter.num_parts, dtype=np.int64) + part_ds = _PartIdListDataset(part_ids) + + active_split = cfg.get("cluster_eval", {}).get("active_split", "train") + + collate = BlockCSRBatchCollator( + adapter, + device=None, + with_edge_attr=handle.get("has_edge_attr", False), + active_split=active_split, + post_batch_transform=post_batch_transform, + ) + + loader = DataLoader( + part_ds, + batch_size=batch_size, + shuffle=True, # important: new cluster combinations per epoch + num_workers=0, + pin_memory=False, + collate_fn=collate, + ) + + return golden, loader, handle + + +# 2. PERMUTATION HANDLING +def load_perm_to_global(handle): + """Load mapping from permuted node IDs to global node IDs. + + Parameters + ---------- + handle : dict + Partition handle containing ``processed_dir``. + + Returns + ------- + torch.Tensor or None + Long tensor of shape (num_nodes,) mapping permuted IDs to global IDs, + or ``None`` if the mapping file does not exist. + """ + base_dir = handle["processed_dir"] + perm_path = osp.join(base_dir, "perm_memmap", "perm_to_global.npy") + + if not osp.exists(perm_path): + print("No perm_to_global.npy found; assuming global_nid are already true IDs.") + return None + + arr = np.load(perm_path, mmap_mode="r") + perm_to_global = torch.from_numpy(arr).long() + print("Loaded perm_to_global of shape", perm_to_global.shape) + return perm_to_global + + +def resolve_true_global_ids(golden, batch, perm_to_global: torch.Tensor | None): + """Resolve true global node IDs for a batch. + + Parameters + ---------- + golden : torch_geometric.data.Data + Golden reference graph with baseline features. + batch : torch_geometric.data.Data + Candidate batch with optional ``global_nid``. + perm_to_global : torch.Tensor or None + Mapping from permuted IDs to global IDs. + + Returns + ------- + torch.Tensor + Long tensor of global node IDs on the batch device. + """ + n = batch.x.size(0) + device = batch.x.device + + if hasattr(batch, "global_nid"): + gids = batch.global_nid.clone().detach().long() + + if perm_to_global is not None: + true_gids = perm_to_global[gids] + else: + true_gids = gids + + if hasattr(golden, "x_0") and hasattr(batch, "x_0"): + k = min(50, n) + idx = torch.randint(0, n, (k,)) + try: + diff = (batch.x_0[idx].cpu() - golden.x_0[true_gids[idx]].cpu()).abs().max() + print(" sanity max|x_0_batch - x_0_golden[true_gids]| =", float(diff)) + except Exception as e: + print(" sanity check failed:", e) + + return true_gids.to(device) + + return torch.arange(n, device=device) + + +# 3. HYPERGRAPH STRUCTURE +def hyperedges_from_incidence_hyperedges(data, true_global_ids: torch.Tensor): + """Extract hyperedges from an incidence matrix. + + Parameters + ---------- + data : torch_geometric.data.Data + Graph data with ``incidence_hyperedges`` attribute. + true_global_ids : torch.Tensor + Global node IDs for the incidence row index. + + Returns + ------- + set of tuple of int + Set of hyperedges as sorted tuples of global node IDs. + """ + if not hasattr(data, "incidence_hyperedges"): + return set() + + H = data.incidence_hyperedges + if H is None or H.numel() == 0: + return set() + + H = H.cpu() + gids = true_global_ids.cpu() + + he_to_nodes = defaultdict(set) + + if getattr(H, "is_sparse", False): + H = H.coalesce() + rows, cols = H.indices() + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + he_to_nodes[int(j)].add(int(i)) + else: + rows, cols = (H != 0).nonzero(as_tuple=True) + for i, j in zip(rows.tolist(), cols.tolist(), strict=False): + he_to_nodes[int(j)].add(int(i)) + + hyperedges = set() + for nodes in he_to_nodes.values(): + if len(nodes) <= 1: + continue + vs = sorted({int(gids[i]) for i in nodes}) + if len(vs) > 1: + hyperedges.add(tuple(vs)) + + return hyperedges + + +# 4. METRICS +def compute_hyperedge_coverage_metrics(gold_hyperedges, cand_hyperedges): + """Compute strict and partial hyperedge coverage metrics. + + Parameters + ---------- + gold_hyperedges : iterable of tuple of int + Ground-truth hyperedges. + cand_hyperedges : iterable of tuple of int + Candidate hyperedges. + + Returns + ------- + dict + Dictionary with keys + ``gold_n``, ``cand_n``, ``strict_match``, ``partial_covered``, + ``strict_recall``, ``partial_recall``. + """ + gold_fs = {frozenset(h) for h in gold_hyperedges} + cand_fs = {frozenset(h) for h in cand_hyperedges} + + G = len(gold_fs) + if G == 0: + return { + "gold_n": 0, + "cand_n": len(cand_fs), + "strict_match": 0, + "partial_covered": 0, + "strict_recall": 0.0, + "partial_recall": 0.0, + } + + common = gold_fs & cand_fs + strict_match = len(common) + + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + missing_sets = [set(h) for h in missing] + + partially_covered_gold = set(common) + + for mh_fs, mh_set in zip(missing, missing_sets, strict=False): + for c in new: + cs = set(c) + if len(cs) > 1 and cs < mh_set: + partially_covered_gold.add(mh_fs) + break + + partial_covered = len(partially_covered_gold) + strict_recall = strict_match / G + partial_recall = partial_covered / G + + return { + "gold_n": G, + "cand_n": len(cand_fs), + "strict_match": strict_match, + "partial_covered": partial_covered, + "strict_recall": strict_recall, + "partial_recall": partial_recall, + } + + +def summarize_hyperedge_differences(gold_hyperedges, cand_hyperedges) -> str: + """Summarize overlap and differences between golden and candidate hyperedges. + + Parameters + ---------- + gold_hyperedges : iterable of tuple of int + Ground-truth hyperedges. + cand_hyperedges : iterable of tuple of int + Candidate hyperedges. + + Returns + ------- + str + Human-readable summary of exact matches, splits, and new or lost edges. + """ + gold_fs = {frozenset(h) for h in gold_hyperedges} + cand_fs = {frozenset(h) for h in cand_hyperedges} + + common = gold_fs & cand_fs + missing = list(gold_fs - cand_fs) + new = list(cand_fs - gold_fs) + + missing_sets = [set(h) for h in missing] + + explained_missing = set() + split_fragments = 0 + unexplained_new = 0 + + for new_h in new: + hs = set(new_h) + found_parent = False + for mh_fs, mh_set in zip(missing, missing_sets, strict=False): + if hs < mh_set: + split_fragments += 1 + explained_missing.add(mh_fs) + found_parent = True + break + if not found_parent: + unexplained_new += 1 + + completely_lost = len(missing) - len(explained_missing) + + return ( + f"Hyperedges: {len(common)} match exactly, {len(missing)} are missing in the " + f"clustered pipeline ({split_fragments} explained as partition-induced splits of " + f"larger golden hyperedges and {completely_lost} completely lost), and {len(new)} " + f"appear only in the clustered pipeline ({unexplained_new} not explainable as " + f"subsets of golden hyperedges)." + ) + + +# 5. MULTI-EPOCH FOR A SINGLE (bs, num_parts) +def run_single_experiment_multi_epoch( + cfg: DictConfig, + num_parts: int = 10, + bs: int = 1, + num_epochs: int = 5, + accumulate: bool = True, +): + """Run a multi-epoch hyperedge coverage experiment for one configuration. + + Parameters + ---------- + cfg : DictConfig + Hydra configuration for dataset and model. + num_parts : int, optional + Number of graph partitions, by default 10. + bs : int, optional + Batch size for candidate loader, by default 1. + num_epochs : int, optional + Number of epochs (passes over the loader), by default 5. + accumulate : bool, optional + If True, union hyperedges across epochs; otherwise evaluate per epoch, + by default True. + + Returns + ------- + list of dict + List of metrics dicts (one per epoch) from + :func:`compute_hyperedge_coverage_metrics`. + """ + golden, loader, handle = build_golden_and_loader_from_cfg( + cfg, num_parts=num_parts, batch_size=bs + ) + + requested_num_parts = int(num_parts) + actual_num_parts = int(handle.get("num_parts", -1)) + if actual_num_parts != requested_num_parts: + raise RuntimeError( + f"Partitioner produced {actual_num_parts} parts but requested {requested_num_parts}" + ) + + perm_to_global = load_perm_to_global(handle) + + N = golden.x.size(0) + base_ids = torch.arange(N) + gold_hyperedges = hyperedges_from_incidence_hyperedges(golden, base_ids) + + if len(gold_hyperedges) == 0: + print("Golden has no hyperedges; aborting.") + return [] + + metrics_per_epoch = [] + cumulative_cand_hyperedges = set() + + for epoch in range(1, num_epochs + 1): + epoch_hyperedges = set() + + for batch in loader: # one pass over all parts, in random order + true_global_ids = resolve_true_global_ids(golden, batch, perm_to_global) + epoch_hyperedges |= hyperedges_from_incidence_hyperedges(batch, true_global_ids) + + if accumulate: + cumulative_cand_hyperedges |= epoch_hyperedges + cand_hyperedges = cumulative_cand_hyperedges + else: + cand_hyperedges = epoch_hyperedges + + m = compute_hyperedge_coverage_metrics(gold_hyperedges, cand_hyperedges) + summary = summarize_hyperedge_differences(gold_hyperedges, cand_hyperedges) + + print( + f"[epoch={epoch}, bs={bs}, num_parts={num_parts}] " + f"strict_recall={m['strict_recall']:.4f}, partial_recall={m['partial_recall']:.4f}" + ) + print(summary) + + metrics_per_epoch.append(m) + + return metrics_per_epoch + + +# 6. SWEEP OVER (bs, num_parts) FOR MULTIPLE EPOCHS +def run_sweep_multi_epoch(num_epochs: int = 4, accumulate: bool = True): + """Sweep over (batch_size, num_parts) for multi-epoch experiments. + + For each configuration, run :func:`run_single_experiment_multi_epoch` and + store per-epoch metrics. + + Parameters + ---------- + num_epochs : int, optional + Number of epochs per configuration, by default 4. + accumulate : bool, optional + If True, union hyperedges across epochs; otherwise per-epoch only, + by default True. + + Returns + ------- + list of int + Tested batch sizes. + list of int + Tested numbers of partitions. + dict + Mapping ``(bs, num_parts) -> [metrics_epoch1, ...]``. + """ + dataset_name = "graph/cocitation_cora_cluster" + batch_sizes = [1, 2, 4, 8, 16, 32] + num_parts_list = [2, 4, 8, 16, 32] + + results_per_pair = {} + + with hydra.initialize(config_path="../../configs", job_name="topo_debug_sweep_epochs"): + for num_parts in num_parts_list: + for bs in batch_sizes: + splits_dir = osp.join("datasets", "data_splits", "PubMed") + if osp.exists(splits_dir): + shutil.rmtree(splits_dir) + + cfg = hydra.compose( + config_name="run.yaml", + overrides=[ + f"dataset={dataset_name}", + "model=hypergraph/edgnn", + "trainer.max_epochs=1", + "trainer.min_epochs=1", + "trainer.check_val_every_n_epoch=1", + "trainer.accelerator=cpu", + "trainer.devices=1", + "seed=42", + "paths=test", + ], + return_hydra_config=True, + ) + + if bs <= num_parts: + metrics_per_epoch = run_single_experiment_multi_epoch( + cfg, + num_parts=num_parts, + bs=bs, + num_epochs=num_epochs, + accumulate=accumulate, + ) + results_per_pair[(bs, num_parts)] = metrics_per_epoch + else: + print(f"Skipping bs={bs}, num_parts={num_parts} (bs>num_parts).") + + return batch_sizes, num_parts_list, results_per_pair + + +# 7. MATRIX HELPER + SUMMARY PLOT +def build_metric_matrix_for_epoch(batch_sizes, num_parts_list, results_per_pair, epoch, metric_key): + """Build a metric matrix for a given epoch. + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row order). + num_parts_list : sequence of int + Numbers of partitions (column order). + results_per_pair : dict + Mapping ``(bs, num_parts) -> [metrics_epoch1, ...]``. + epoch : int + 1-based epoch index to extract. + metric_key : str + Metric key to extract and convert to percent. + + Returns + ------- + ndarray + Matrix of metric values in percent with NaNs for missing entries. + """ + """ + Build bs × num_parts matrix for a given epoch index (1-based). + + results_per_pair[(bs, num_parts)] = [metrics_epoch1, metrics_epoch2, ...] + """ + B = len(batch_sizes) + P = len(num_parts_list) + M = np.full((B, P), np.nan, dtype=float) + + for i, bs in enumerate(batch_sizes): + for j, nparts in enumerate(num_parts_list): + metrics_list = results_per_pair.get((bs, nparts)) + if metrics_list is None or len(metrics_list) < epoch: + continue + m = metrics_list[epoch - 1] + val = m.get(metric_key) + if val is None: + continue + M[i, j] = 100.0 * float(val) # percent + + return M + + +def plot_summary_4panel( + batch_sizes, + num_parts_list, + results_per_pair, + num_epochs: int, + metric_key: str = "strict_recall", + target_bs: int = 8, + target_num_parts: int = 32, + save_prefix: str = "cora_hypergraph_summary", +): + """Plot a 4-panel summary for recall across epochs. + + Panels: + (0, 0) First epoch heatmap. + (0, 1) Last epoch heatmap. + (1, 0) Ratio of last to first recall. + (1, 1) Recall vs. epochs for a chosen (bs, num_parts). + + Parameters + ---------- + batch_sizes : sequence of int + Batch sizes (row labels). + num_parts_list : sequence of int + Numbers of partitions (column labels). + results_per_pair : dict + Mapping ``(bs, num_parts) -> [metrics_epoch1, ...]``. + num_epochs : int + Number of epochs to summarize. + metric_key : str, optional + Metric key to visualize, by default "strict_recall". + target_bs : int, optional + Batch size for the trajectory panel, by default 8. + target_num_parts : int, optional + Number of partitions for the trajectory panel, by default 32. + save_prefix : str, optional + Filename prefix for saved figures, by default "cora_hypergraph_summary". + """ + """ + Make a 2x2 figure: + (0,0) first epoch heatmap + (0,1) last epoch heatmap + (1,0) ratio (last / first) + (1,1) recall vs epochs for (target_bs, target_num_parts) + """ + # --- matrices for first and last epoch --- + first_M = build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=1, metric_key=metric_key + ) + last_M = build_metric_matrix_for_epoch( + batch_sizes, num_parts_list, results_per_pair, epoch=num_epochs, metric_key=metric_key + ) + + # ratio (last / first) + ratio_M = np.full_like(first_M, np.nan, dtype=float) + for (i, j), first_val in np.ndenumerate(first_M): + last_val = last_M[i, j] + if np.isnan(first_val) or np.isnan(last_val) or first_val <= 0: + continue + ratio_M[i, j] = last_val / first_val # dimensionless factor + + # --- set up figure and axes --- + fig, axes = plt.subplots(2, 2, figsize=(12, 10), constrained_layout=True) + ax_first, ax_last, ax_ratio, ax_curve = axes[0, 0], axes[0, 1], axes[1, 0], axes[1, 1] + + vmin, vmax = 0, 100 + xticks = np.arange(len(num_parts_list)) + yticks = np.arange(len(batch_sizes)) + + # ---------- top-left: first epoch ---------- + im_first = ax_first.imshow(first_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax_first.set_xticks(xticks) + ax_first.set_yticks(yticks) + ax_first.set_xticklabels(num_parts_list) + ax_first.set_yticklabels(batch_sizes) + ax_first.set_xlabel("num_parts") + ax_first.set_ylabel("batch_size") + ax_first.set_title("Recall % – epoch 1") + + for (i, j), val in np.ndenumerate(first_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax_first.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=7, color=color) + + # ---------- top-right: last epoch ---------- + ax_last.imshow(last_M, origin="lower", aspect="auto", vmin=vmin, vmax=vmax) + ax_last.set_xticks(xticks) + ax_last.set_yticks(yticks) + ax_last.set_xticklabels(num_parts_list) + ax_last.set_yticklabels([]) # share y labels with left + ax_last.set_xlabel("num_parts") + ax_last.set_title(f"Recall % – epoch {num_epochs}") + + for (i, j), val in np.ndenumerate(last_M): + if np.isnan(val): + continue + color = "white" if val < 50 else "black" + ax_last.text(j, i, f"{val:.0f}%", ha="center", va="center", fontsize=7, color=color) + + # shared colorbar for the two recall heatmaps + cbar_top = fig.colorbar(im_first, ax=[ax_first, ax_last], fraction=0.035, pad=0.02) + label = "Strict recall (%)" if metric_key == "strict_recall" else "Partial recall (%)" + cbar_top.set_label(label) + + # ---------- bottom-left: ratio ---------- + if np.all(np.isnan(ratio_M)): + pass + else: + max(1.0, float(np.nanmax(ratio_M))) + im_ratio = ax_ratio.imshow(ratio_M, origin="lower", aspect="auto", cmap="Reds") + + ax_ratio.set_xticks(xticks) + ax_ratio.set_yticks(yticks) + ax_ratio.set_xticklabels(num_parts_list) + ax_ratio.set_yticklabels(batch_sizes) + ax_ratio.set_xlabel("num_parts") + ax_ratio.set_ylabel("batch_size") + ax_ratio.set_title("Final / initial recall (×)") + + for (i, j), val in np.ndenumerate(ratio_M): + if np.isnan(val): + continue + color = "white" if val < 1.0 else "black" + ax_ratio.text(j, i, f"{val:.2f}x", ha="center", va="center", fontsize=7, color=color) + + cbar_ratio = fig.colorbar(im_ratio, ax=ax_ratio, fraction=0.035, pad=0.02) + cbar_ratio.set_label("Final / initial") + + # ---------- bottom-right: trajectory for specific (bs, num_parts) ---------- + metrics_list = results_per_pair.get((target_bs, target_num_parts)) + if metrics_list is None or len(metrics_list) == 0: + ax_curve.text( + 0.5, + 0.5, + f"No data for bs={target_bs}, num_parts={target_num_parts}", + ha="center", + va="center", + ) + ax_curve.axis("off") + else: + epochs = np.arange(1, len(metrics_list) + 1) + vals = [m[metric_key] * 100.0 for m in metrics_list] + + ax_curve.plot(epochs, vals, marker="o") + ax_curve.set_xlabel("epoch") + ax_curve.set_ylabel("recall (%)") + ax_curve.set_title(f"Recall vs epochs (bs={target_bs}, num_parts={target_num_parts})") + ax_curve.grid(alpha=0.3) + ax_curve.set_ylim(0, 105) + + out_path = f"sweep_tools/outputs/{save_prefix}_{metric_key}.png" + fig.savefig(out_path, dpi=200) + print(f"Saved 4-panel summary: {out_path}") + # plt.show() + + + +# 8. MAIN +if __name__ == "__main__": + repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + os.chdir(repo_root) + + os.makedirs("sweep_tools/outputs", exist_ok=True) + + NUM_EPOCHS = 10 # how many "epochs thus far" panels you want + + batch_sizes, num_parts_list, results_per_pair = run_sweep_multi_epoch( + num_epochs=NUM_EPOCHS, + accumulate=True, # union of hyperedges across epochs + ) + + plot_summary_4panel( + batch_sizes, + num_parts_list, + results_per_pair, + num_epochs=NUM_EPOCHS, + metric_key="strict_recall", + target_bs=8, + target_num_parts=32, + save_prefix="cora_hypergraph_4panel", + ) diff --git a/topobench/data/datasets/base_transductive_on_disk_dataset.py b/topobench/data/datasets/base_transductive_on_disk_dataset.py new file mode 100644 index 000000000..767e3db5f --- /dev/null +++ b/topobench/data/datasets/base_transductive_on_disk_dataset.py @@ -0,0 +1,276 @@ +import os +import os.path as osp +import shutil +import urllib.request +import zipfile +from typing import Any + +import torch +from torch_geometric.data import Data, OnDiskDataset, SQLiteDatabase + + +class TransductiveOnDiskDataset(OnDiskDataset): + """ + Generic loader for an already-built `OnDiskDataset`. + + Layout + ------ + root/ + / + raw/ + processed/ + sqlite.db + schema.pt + handle.pt + /*.npy + + Parameters + ---------- + root : str + Root directory where the dataset should be stored. + name : str + Name of the dataset subdirectory under `root`. + url : str + URL of the zipped processed data. + backend : str, optional + Name of the database backend, by default "sqlite". + transform : callable, optional + Optional transform applied on each data example. + """ + + def __init__( + self, + root: str, + name: str, + url: str, + backend: str = "sqlite", + transform=None, + ): + self.name = name + self.url = url + self._table = "ClusterOnDisk" + + # Triggers raw/processed checks, `download()` and `process()` as needed. + super().__init__(root=root, transform=transform) + + schema_path = osp.join(self.processed_dir, "schema.pt") + handle_path = osp.join(self.processed_dir, "handle.pt") + + schema = torch.load(schema_path) + handle = torch.load(handle_path) + + self.handle = handle + self._db = None + self.backend = backend + self.schema = schema + + @property + def raw_file_names(self): + """ + List of expected raw file names. + + Returns + ------- + list of str + Filenames to check in the raw directory. + """ + # Derives the filename from the URL (e.g., "processed.zip") + return [self.url.split("/")[-1]] + + @property + def processed_file_names(self): + """ + List of files that must exist to skip processing. + + Returns + ------- + list of str + Filenames required in the processed directory. + """ + return ["sqlite.db", "schema.pt", "handle.pt"] + + @property + def raw_dir(self) -> str: + """ + Raw data directory. + + Returns + ------- + str + Path to the raw directory. + """ + return osp.join(self.root, self.name, "raw") + + @property + def processed_dir(self) -> str: + """ + Processed data directory. + + Returns + ------- + str + Path to the processed directory. + """ + return osp.join(self.root, self.name, "processed") + + def download(self): + """ + Download the zipped processed data. + + Raises + ------ + ValueError + If no URL is provided. + """ + if self.url is None: + raise ValueError("URL is not provided. Cannot download the dataset.") + + zip_path = self.raw_paths[0] + + print(f"Downloading {self.url} to {zip_path}...") + urllib.request.urlretrieve(self.url, zip_path) + print("Download complete.") + + def process(self): + """ + Unzip downloaded data and rewrite handle paths for the new root. + + Notes + ----- + - Unzips the archive into `processed_dir`. + - Detects and strips a leading `processed/` prefix if present. + - Loads `handle.pt`, rewrites `root`, `processed_dir`, + `memmap_dir`, and all `paths` entries to match the current + directory structure, and saves the updated handle. + """ + zip_path = self.raw_paths[0] + print(f"Unzipping {zip_path} to {self.processed_dir}...") + + with zipfile.ZipFile(zip_path, "r") as zip_ref: + names = zip_ref.namelist() + + # Detect 'processed/' prefix pattern + has_processed_prefix = all( + n.startswith("processed/") or n.endswith("/") + for n in names + ) + + for member in zip_ref.infolist(): + orig_name = member.filename + + # Skip root directories + if orig_name.endswith("/"): + continue + + # Optionally strip leading 'processed/' if present + name = orig_name + if has_processed_prefix and name.startswith("processed/"): + name = name[len("processed/") :] + + # If stripping makes it empty, skip + if not name: + continue + + # Final destination path + dest_path = osp.join(self.processed_dir, name) + + # Ensure parent directory exists + os.makedirs(osp.dirname(dest_path), exist_ok=True) + + # Extract file + with zip_ref.open(orig_name) as source, open(dest_path, "wb") as target: + shutil.copyfileobj(source, target) + + print("Unzipping complete.") + + # Rewrite handle.pt to be portable to the current environment + handle_path = osp.join(self.processed_dir, "handle.pt") + if osp.exists(handle_path): + handle = torch.load(handle_path) + + # Old memmap directory + old_mm_dir = handle.get("memmap_dir", None) + if old_mm_dir is not None: + mm_basename = osp.basename(old_mm_dir) + else: + # Fallback if not present; assumes "memmap" subdir + mm_basename = "memmap" + + new_mm_dir = osp.join(self.processed_dir, mm_basename) + + old_paths = handle.get("paths", {}) + new_paths = {} + for key, old_path in old_paths.items(): + filename = osp.basename(old_path) + new_paths[key] = osp.join(new_mm_dir, filename) + + handle["root"] = self.root + handle["processed_dir"] = self.processed_dir + handle["memmap_dir"] = new_mm_dir + handle["paths"] = new_paths + + # Ensure memmap directory exists (in case it wasn't created) + os.makedirs(new_mm_dir, exist_ok=True) + + torch.save(handle, handle_path) + print("Handle updated and saved.") + else: + print("Warning: handle.pt not found; skipping handle rewrite.") + + @property + def db(self): + """ + Database backend instance. + + Returns + ------- + Any + Initialized database object. + + Notes + ----- + Lazily opens the database and caches it in `_db`. + """ + if self._db is not None: + return self._db + + cls = self.BACKENDS[self.backend] + kwargs: dict[str, Any] = {} + + path = osp.join(self.processed_dir, "sqlite.db") + + if issubclass(cls, SQLiteDatabase): + kwargs["name"] = self._table + + self._db = cls(path=path, schema=self.schema, **kwargs) + self._numel = len(self._db) + return self._db + + def deserialize(self, row: dict[str, Any]) -> Data: + """ + Deserialize a database row into a `Data` object. + + Parameters + ---------- + row : dict of str to Any + Row returned by the backend. + + Returns + ------- + Data + Constructed PyG `Data` object. + """ + data = Data() + for key, val in row.items(): + if val is None: + continue + if key == "num_nodes": + if isinstance(val, int): + data.num_nodes = val + elif hasattr(val, "item"): + data.num_nodes = int(val.item()) + else: + data.num_nodes = int(val) + else: + setattr(data, key, val) + return data diff --git a/topobench/data/loaders/graph/base_transductive_on_disk_loader.py b/topobench/data/loaders/graph/base_transductive_on_disk_loader.py new file mode 100644 index 000000000..63192fda3 --- /dev/null +++ b/topobench/data/loaders/graph/base_transductive_on_disk_loader.py @@ -0,0 +1,79 @@ +from omegaconf import DictConfig +from torch_geometric.data import Dataset + +from topobench.data.datasets import TransductiveOnDiskDataset +from topobench.data.loaders.base import AbstractLoader + + +class OnDiskDatasetLoader(AbstractLoader): + """ + Generic dataloader for partitioned on-disk datasets. + + Attributes + ---------- + URLS : dict + Mapping of dataset names to their download URLs. + """ + + URLS = { + "Texas_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/WebKB/Texas/processed.zip?raw=1", + "Cornell_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/WebKB/Cornell/processed.zip?raw=1", + "Wisconsin_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/WebKB/Wisconsin/processed.zip?raw=1", + "PubMed_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/cocitation/PubMed/processed.zip?raw=1", + "Cora_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/cocitation/Cora/processed.zip?raw=1", + "citeseer_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/cocitation/citeseer/processed.zip?raw=1", + # "Reddit_on_disk": "https://github.com/dleko11/TopoBench/blob/main/for_download/Reddit/Reddit/processed.zip?raw=1", + # Add more datasets here... + } + + def __init__(self, parameters: DictConfig) -> None: + """ + Initialize the loader. + + Parameters + ---------- + parameters : DictConfig + Configuration containing dataset name, backend, and paths. + """ + super().__init__(parameters) + + def load_dataset(self) -> Dataset: + """ + Load an on-disk dataset using the configured parameters. + + Returns + ------- + Dataset + A fully initialized `TransductiveOnDiskDataset` instance. + + Raises + ------ + ValueError + If the requested dataset name is not defined in `URLS`. + RuntimeError + If loading the dataset fails. + """ + data_name = self.parameters.get("data_name", None) + backend = self.parameters.get("backend", "sqlite") + + if data_name not in self.URLS: + raise ValueError( + f"Dataset '{data_name}' not found in URL registry. " + f"Available keys: {list(self.URLS.keys())}" + ) + + url = self.URLS[data_name] + + try: + dataset = TransductiveOnDiskDataset( + root=str(self.root_data_dir), + name=data_name, + backend=backend, + url=url, + ) + except Exception as e: + raise RuntimeError( + f"Failed to load OnDiskDataset from {self.root_data_dir}" + ) from e + + return dataset diff --git a/topobench/data/loaders/graph/reddit_dataset_loader.py b/topobench/data/loaders/graph/reddit_dataset_loader.py new file mode 100644 index 000000000..a6a2646f9 --- /dev/null +++ b/topobench/data/loaders/graph/reddit_dataset_loader.py @@ -0,0 +1,32 @@ +"""Loaders for Reddit dataset.""" + +from pathlib import Path + +from omegaconf import DictConfig +from torch_geometric.data import Dataset +from torch_geometric.datasets import Reddit + +from topobench.data.loaders.base import AbstractLoader + + +class RedditDatasetLoader(AbstractLoader): + def __init__(self, parameters: DictConfig) -> None: + super().__init__(parameters) + + def load_dataset(self) -> Dataset: + dataset = self._initialize_dataset() + self.data_dir = self._redefine_data_dir(dataset) + return dataset + + def _initialize_dataset(self) -> Dataset: + return Reddit( + root=str(self.root_data_dir), + ) + + def _redefine_data_dir(self, dataset: Dataset) -> Path: + return str(Path(dataset.processed_dir)) + + + + + diff --git a/topobench/data/preprocessor/preprocessor.py b/topobench/data/preprocessor/preprocessor.py index e5c4a913a..57410d949 100644 --- a/topobench/data/preprocessor/preprocessor.py +++ b/topobench/data/preprocessor/preprocessor.py @@ -2,16 +2,23 @@ import json import os +import os.path as osp +import shutil +from typing import Any +import hydra +import numpy as np import torch import torch_geometric from torch_geometric.io import fs from topobench.data.utils import ( + ClusterOnDisk, ensure_serializable, load_inductive_splits, load_transductive_splits, make_hash, + to_bool_mask, ) from topobench.dataloader import DataloadDataset from topobench.transforms.data_transform import DataTransform @@ -34,6 +41,7 @@ class PreProcessor(torch_geometric.data.InMemoryDataset): def __init__(self, dataset, data_dir, transforms_config=None, **kwargs): self.dataset = dataset + self.data_dir = data_dir if transforms_config is not None: self.transforms_applied = True pre_transform = self.instantiate_pre_transform( @@ -42,21 +50,14 @@ def __init__(self, dataset, data_dir, transforms_config=None, **kwargs): super().__init__( self.processed_data_dir, None, pre_transform, **kwargs ) - self.transform = ( - dataset.transform if hasattr(dataset, "transform") else None - ) self.save_transform_parameters() self.load(self.processed_paths[0]) - self.data_list = [data for data in self] else: self.transforms_applied = False - super().__init__(data_dir, None, None, **kwargs) - self.transform = ( - dataset.transform if hasattr(dataset, "transform") else None - ) - self.data, self.slices = dataset._data, dataset.slices - self.data_list = [data for data in dataset] + super().__init__(str(data_dir), None, None, **kwargs) + self.load(data_dir + "/processed/data.pt") + self.data_list = [self.get(idx) for idx in range(len(self))] # Some datasets have fixed splits, and those are stored as split_idx during loading # We need to store this information to be able to reproduce the splits afterwards if hasattr(dataset, "split_idx"): @@ -71,11 +72,11 @@ def processed_dir(self) -> str: str Path to the processed directory. """ - if not self.transforms_applied: + if self.transforms_applied: return self.root else: return self.root + "/processed" - + @property def processed_file_names(self) -> str: """Return the name of the processed file. @@ -106,21 +107,11 @@ def instantiate_pre_transform( """ if transforms_config.keys() == {"liftings"}: transforms_config = transforms_config.liftings - # Check if this is a single transform config (has transform_name key) - # or multiple transforms config (each value is a dict with transform_name) - if "transform_name" in transforms_config: - # Single transform configuration - pre_transforms_dict = { - transforms_config.transform_name: DataTransform( - **transforms_config - ) - } - else: - # Multiple transforms configuration - pre_transforms_dict = { - key: DataTransform(**value) - for key, value in transforms_config.items() - } + pre_transforms_dict = hydra.utils.instantiate(transforms_config) + pre_transforms_dict = { + key: DataTransform(**value) + for key, value in transforms_config.items() + } pre_transforms = torch_geometric.transforms.Compose( list(pre_transforms_dict.values()) ) @@ -180,11 +171,12 @@ def save_transform_parameters(self) -> None: def process(self) -> None: """Method that processes the data.""" - if isinstance( - self.dataset, - (torch_geometric.data.Dataset, torch.utils.data.Dataset), - ): - data_list = [data for data in self.dataset] + if isinstance(self.dataset, torch_geometric.data.Dataset): + data_list = [ + self.dataset.get(idx) for idx in range(len(self.dataset)) + ] + elif isinstance(self.dataset, torch.utils.data.Dataset): + data_list = [self.dataset[idx] for idx in range(len(self.dataset))] elif isinstance(self.dataset, torch_geometric.data.Data): data_list = [self.dataset] @@ -252,3 +244,220 @@ def load_dataset_splits( f"Invalid '{split_params.learning_setting}' learning setting.\ Please define either 'inductive' or 'transductive'." ) + + def pack_global_partition( + self, + *, + split_params: dict[str, Any], + cluster_params: dict[str, Any], + stream_params: dict[str, Any], + dtype_policy: str = "preserve", + pack_db: bool = True, + pack_memmaps: bool = True, + ) -> dict[str, Any]: + """ + Build a global Cluster-GCN partition for a transductive + single-graph dataset, persist the resulting artifacts to disk, and + return a compact handle for block-streaming loaders. + + The returned handle dictionary contains paths and metadata required by + block-streaming dataloaders (e.g. `TBBlockStreamDataModule`) to build + Cluster-GCN-style mini-batches directly from disk without reloading the + full graph into memory. + + Parameters + ---------- + split_params : dict + Parameters for the split pipeline; must define a transductive + single-graph setting and produce train/val/test masks. + cluster_params : dict + Parameters controlling graph partitioning: + `num_parts`, `recursive`, `keep_inter_cluster_edges`, + `sparse_format`, etc. + stream_params : dict + Parameters for downstream streaming, including + `precompute_split_parts` to speed up split-aware sampling. + dtype_policy : {"preserve", "float32"}, optional + Policy for persisting feature/edge_attr dtypes. Recorded in meta + for downstream consumers. + pack_db : bool, optional + If True, keep the `OnDiskDataset` DB of per-cluster subgraphs. + pack_memmaps : bool, optional + If True, write CSR and permuted feature/label/mask memmaps. + + Returns + ------- + dict + A handle with root/processed/memmap paths, partition metadata, and + file locations for all relevant arrays. + """ + # HASH: if handle.pt exists and matching, do now partition again + cluster_config = { + "split_params": ensure_serializable(split_params), + "cluster_params": ensure_serializable(cluster_params), + "stream_params": ensure_serializable(stream_params), + "dtype_policy": dtype_policy, + } + config_hash = make_hash(cluster_config) + + root = self.data_dir + processed_dir = osp.join(root, "processed") + handle_path = osp.join(processed_dir, "handle.pt") + + # If handle exists, try to reuse + if osp.exists(handle_path): + old_handle = torch.load(handle_path, map_location="cpu") + old_hash = old_handle.get("config_hash", None) + print(old_hash, config_hash) + if old_hash == config_hash: + # Compatible cached partition: reuse it directly. + return old_handle + else: + # Config changed: drop old processed dir and rebuild. + shutil.rmtree(processed_dir, ignore_errors=True) + else: + # No handle, but there might be stale processed/ from some other run. + if osp.exists(processed_dir): + shutil.rmtree(processed_dir, ignore_errors=True) + + os.makedirs(root, exist_ok=True) + _ = self.load_dataset_splits(split_params) + + full = getattr(self.dataset, "data", None) + + # num_nodes + if getattr(full, "num_nodes", None) is not None: + N = int(full.num_nodes) + elif getattr(full, "x", None) is not None: + N = int(full.x.size(0)) + full.num_nodes = N + elif getattr(full, "y", None) is not None: + N = int(full.y.size(0)) + full.num_nodes = N + else: + raise ValueError("Cannot infer num_nodes from full graph.") + + if getattr(full, "train_mask", None) is None: + ds_train, ds_val, ds_test = self.load_dataset_splits(split_params) + full = ds_train.data_lst[0] + full.train_mask = to_bool_mask(getattr(full, "train_mask", None), N) + full.val_mask = to_bool_mask(getattr(full, "val_mask", None), N) + full.test_mask = to_bool_mask(getattr(full, "test_mask", None), N) + + # Checks: we require a single full graph with masks. + if getattr(full, "edge_index", None) is None: + raise ValueError("Full graph has no edge_index.") + if getattr(full, "train_mask", None) is None: + raise ValueError("train_mask must exist on the full graph.") + if getattr(full, "val_mask", None) is None: + raise ValueError("val_mask must exist on the full graph.") + if getattr(full, "test_mask", None) is None: + raise ValueError("test_mask must exist on the full graph.") + + # Resolve cluster config. + num_parts = int(cluster_params.get("num_parts", 10)) + recursive = bool(cluster_params.get("recursive", False)) + keep_inter = bool(cluster_params.get("keep_inter_cluster_edges", False)) + sparse_format = str(cluster_params.get("sparse_format", "csr")) + + # Build the ClusterOnDisk dataset (global partition). + # Root lives under the dataset directory. + # root = osp.join(self.data_dir, f"cluster_{num_parts}") + root = self.data_dir # self.processed_dir + # This version overwrite the processed .pt file. + # shutil.rmtree(root + "/processed") + # os.makedirs(root, exist_ok=True) + + ds = ClusterOnDisk( + root=root, + graph_getter=lambda: full, + num_parts=num_parts, + recursive=recursive, + keep_inter_cluster_edges=keep_inter, + sparse_format=sparse_format, + backend="sqlite", + transform=None, + pre_filter=None, + ) + # Touch to trigger process() if not already done. + _ = len(ds) + + # Save schema for future use + torch.save(ds.schema, osp.join(ds.processed_dir, "schema.pt")) + + # Write permuted split masks into the memmap bundle. + mm_dir = osp.join(ds.processed_dir, "perm_memmap") + os.makedirs(mm_dir, exist_ok=True) + + P = ds.partition + node_perm = P.node_perm.cpu().numpy() + + def _to_numpy_bool(mask: torch.Tensor) -> np.ndarray: + return mask.view(-1)[node_perm].to(torch.bool).cpu().numpy() + + train_mask_perm = _to_numpy_bool(full.train_mask) + val_mask_perm = _to_numpy_bool(full.val_mask) + test_mask_perm = _to_numpy_bool(full.test_mask) + + np.save(osp.join(mm_dir, "train_mask_perm.npy"), train_mask_perm) + np.save(osp.join(mm_dir, "val_mask_perm.npy"), val_mask_perm) + np.save(osp.join(mm_dir, "test_mask_perm.npy"), test_mask_perm) + + # Precompute which parts contain which split nodes. + if bool(stream_params.get("precompute_split_parts", True)): + partptr = np.load(osp.join(mm_dir, "partptr.npy")) + + def _parts_with(mask_perm: np.ndarray) -> np.ndarray: + pos = np.flatnonzero(mask_perm) + part_ids = np.searchsorted(partptr, pos, side="right") - 1 + return np.unique(part_ids.astype(np.int64)) + + np.save(osp.join(mm_dir, "parts_with_train.npy"), _parts_with(train_mask_perm)) + np.save(osp.join(mm_dir, "parts_with_val.npy"), _parts_with(val_mask_perm)) + np.save(osp.join(mm_dir, "parts_with_test.npy"), _parts_with(test_mask_perm)) + + # Record meta. + full_N = int(getattr(full, "num_nodes", train_mask_perm.shape[0])) + meta = { + "num_parts": ds.num_parts, + "recursive": ds.recursive, + "keep_inter_cluster_edges": ds.keep_inter_cluster_edges, + "sparse_format": ds.sparse_format, + "dtype_policy": dtype_policy, + "has_x": getattr(full, "x", None) is not None, + "has_y": getattr(full, "y", None) is not None, + "has_edge_attr": getattr(full, "edge_attr", None) is not None, + "N": full_N, + } + # torch.save(meta, osp.join(ds.processed_dir, "cluster_global_meta.pt")) + torch.save(meta, osp.join(ds.processed_dir, "cluster_meta.pt")) + + # Build and return handle for TBBlockStreamDataModule. + handle = { + "root": ds.root, + "processed_dir": ds.processed_dir, + "memmap_dir": mm_dir, + "num_parts": int(ds.num_parts), + "sparse_format": str(ds.sparse_format), + "has_x": bool(meta["has_x"]), + "has_y": bool(meta["has_y"]), + "has_edge_attr": bool(meta["has_edge_attr"]), + "paths": { + "partptr": osp.join(mm_dir, "partptr.npy"), + "indptr": osp.join(mm_dir, "indptr.npy"), + "indices": osp.join(mm_dir, "indices.npy"), + "X_perm": osp.join(mm_dir, "X_perm.npy"), + "y_perm": osp.join(mm_dir, "y_perm.npy"), + "edge_attr_perm": osp.join(mm_dir, "edge_attr_perm.npy"), + "train_mask_perm": osp.join(mm_dir, "train_mask_perm.npy"), + "val_mask_perm": osp.join(mm_dir, "val_mask_perm.npy"), + "test_mask_perm": osp.join(mm_dir, "test_mask_perm.npy"), + "parts_with_train": osp.join(mm_dir, "parts_with_train.npy"), + "parts_with_val": osp.join(mm_dir, "parts_with_val.npy"), + "parts_with_test": osp.join(mm_dir, "parts_with_test.npy"), + }, + } + # Store config hash in handle and on disk + handle["config_hash"] = config_hash + torch.save(handle, osp.join(ds.processed_dir, "handle.pt")) + return handle diff --git a/topobench/data/utils/__init__.py b/topobench/data/utils/__init__.py index a06d5aae9..5414ffcef 100644 --- a/topobench/data/utils/__init__.py +++ b/topobench/data/utils/__init__.py @@ -64,4 +64,20 @@ # add function name here ] -__all__ = utils_functions + split_helper_functions + io_helper_functions +from .cluster_utils import ( # noqa: E402 + ClusterOnDisk, # noqa: F401 + _tensor_schema_entry, # noqa: F401 + build_cluster_transform, # noqa: F401 + # import function here, add noqa: F401 for PR + to_bool_mask, # noqa: F401 +) + +cluster_helpers = [ + "ClusterOnDisk", + "to_bool_mask", + "build_cluster_transform", + "_tensor_schema_entry", + # add function name here + ] + +__all__ = utils_functions + split_helper_functions + io_helper_functions + cluster_helpers diff --git a/topobench/data/utils/cluster_utils.py b/topobench/data/utils/cluster_utils.py new file mode 100644 index 000000000..2d605584d --- /dev/null +++ b/topobench/data/utils/cluster_utils.py @@ -0,0 +1,557 @@ +import os +import os.path as osp +from collections.abc import Callable +from typing import Any + +import hydra +import numpy as np +import torch +import torch_geometric +from numpy.lib.format import open_memmap +from torch_geometric.data import Data, OnDiskDataset +from torch_geometric.loader import ClusterData + + +def build_cluster_transform(transforms_config) -> Callable | None: + """Build a post-batch transform for clustered training. + + Parameters + ---------- + transforms_config : dict or None + Hydra-style configuration for transforms. + + Returns + ------- + callable or None + Composed transform or ``None`` if no transforms are defined. + """ + # Build a post-batch transform for ClusterGCNDataModule. + + # Semantics match PreProcessor.instantiate_pre_transform. + if not transforms_config: + return None + + # Handle nested `liftings:` block like in the original code. + if set(transforms_config.keys()) == {"liftings"}: + transforms_config = transforms_config["liftings"] + + # Resolve Hydra interpolations / _target_ side effects. + # (We ignore the output, mirroring PreProcessor.) + hydra.utils.instantiate(transforms_config) + + from topobench.transforms.data_transform import DataTransform + # Now wrap each config in a DataTransform, like PreProcessor does. + transform_dict = { + key: DataTransform(**value) + for key, value in transforms_config.items() + } + + if not transform_dict: + return None + + if len(transform_dict) == 1: + # Single transform: no need for Compose. + return next(iter(transform_dict.values())) + + return torch_geometric.transforms.Compose(list(transform_dict.values())) + + +def to_bool_mask(mask: torch.Tensor, N: int) -> torch.Tensor: + """Convert an index or score tensor to a boolean mask of length ``N``. + + Handles index lists, existing boolean masks, and length-``N`` score + vectors. + + Parameters + ---------- + mask : torch.Tensor + Input mask or index tensor. + N : int + Desired length of the output mask. + + Returns + ------- + torch.Tensor + Boolean mask of shape ``(N,)``. + """ + mask = mask.view(-1) + + # Case 1: already [N] bool + if mask.dtype == torch.bool and mask.numel() == N: + return mask + + # Case 2: index list (what load_transductive_splits gives us) + if mask.dtype in (torch.int64, torch.int32, torch.int16, torch.int8): + out = torch.zeros(N, dtype=torch.bool) + if mask.numel() > 0: + out[mask.long()] = True + return out + + # Case 3: length-N 0/1 or float scores + if mask.numel() == N: + return (mask != 0) + + # Fallback for ruff check: + return torch.zeros(N, dtype=torch.bool) + +def _tensor_schema_entry(t: torch.Tensor) -> dict[str, Any]: + """Create a schema entry for a tensor value. + + Scalars are mapped to scalar Python types; higher-dimensional + tensors are stored with shape ``(-1, ...)`` and fixed trailing + dimensions. + + Parameters + ---------- + t : torch.Tensor + Example tensor. + + Returns + ------- + dict or type + Schema description for the tensor field. + """ + # Make a schema entry for a tensor: (-1, ...) with fixed trailing dims. + if t.dim() == 0: # scalar tensor -> store as scalar type + if t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64): + return int + if t.dtype in (torch.float16, torch.float32, torch.float64, torch.bfloat16): + return float + if t.dtype == torch.bool: + return bool + # fallback: store as variable-length 1D + return dict(dtype=t.dtype, size=(-1,)) + size = (-1,) + tuple(int(d) for d in t.size()[1:]) + return dict(dtype=t.dtype, size=size) + +class ClusterOnDisk(OnDiskDataset): + """On-disk storage and metadata for Cluster-GCN training. + + Builds a global partition using :class:`ClusterData`, infers a + generic schema over all cluster subgraphs, stores them on disk, and + writes permuted structural and feature arrays as NumPy memmaps. + + Parameters + ---------- + root : str + Root directory for the on-disk dataset. + graph_getter : callable + Callable returning the full :class:`torch_geometric.data.Data` + graph. + num_parts : int, optional + Number of clusters for partitioning. Default is 10. + recursive : bool, optional + Whether to apply recursive partitioning. Default is False. + keep_inter_cluster_edges : bool, optional + If True, inter-cluster edges are kept. Default is False. + sparse_format : {"csr"}, optional + Sparse adjacency representation. Default is "csr". + backend : {"sqlite", "rocksdb"}, optional + On-disk backend. Default is "sqlite". + transform : callable, optional + Transform applied on loaded cluster subgraphs. + pre_filter : callable, optional + Filter applied before writing samples to disk. + """ + def __init__( + self, + root: str, + *, + graph_getter: Callable[[], Data], + num_parts: int = 10, + recursive: bool = False, + keep_inter_cluster_edges: bool = False, + sparse_format: str = "csr", + backend: str = "sqlite", + transform=None, + pre_filter=None, + ) -> None: + self._graph_getter = graph_getter + self._cfg = dict( + num_parts=int(num_parts), + recursive=bool(recursive), + keep_inter=bool(keep_inter_cluster_edges), + sparse_format=str(sparse_format), + ) + + # Bootstrap once to know the REAL schema and partition --- + full = self._graph_getter() + + cluster_data = ClusterData( + full, + num_parts=self._cfg["num_parts"], + recursive=self._cfg["recursive"], + keep_inter_cluster_edges=self._cfg["keep_inter"], + sparse_format=self._cfg["sparse_format"], + save_dir=None, + log=False, + ) + + # Discover schema across ALL parts: + # - edge_index is always present (2, -1) + # - other tensor/int/float/bool fields gathered via union + discovered: dict[str, Any] = { + "edge_index": dict(dtype=torch.long, size=(2, -1)) + } + + for i in range(len(cluster_data)): + part = cluster_data[i] + if getattr(part, "edge_index", None) is None: + raise ValueError("Cluster part without edge_index; cannot store.") + for key, val in self._iter_data_items(part): + if key == "edge_index": + continue + self._schema_union_update(discovered, key, val) + + # Stash bootstrap so process() can reuse without recomputing: + self._bootstrap_full = full + self._bootstrap_cluster_data = cluster_data + + # Initialize OnDiskDataset with the discovered schema: + super().__init__( + root, + transform=transform, + pre_filter=pre_filter, + backend=backend, + schema=discovered, + ) + self._meta: dict[str, Any] | None = None + + @property + def raw_file_names(self) -> list[str]: + """Raw files used by this dataset. + + Returns + ------- + list of str + Empty list (all data comes from ``graph_getter``). + """ + # We don't rely on raw files here; everything comes from graph_getter. + return [] + + def download(self) -> None: + """Download raw data (no-op). + + Notes + ----- + All data are provided via ``graph_getter``, so nothing is + downloaded. + """ + # Nothing to download; graph_getter is user-provided. + + @staticmethod + def _schema_union_update( + schema: dict[str, Any], + key: str, + val: Any, + ) -> None: + """Update a schema dict with a sample field value. + + Parameters + ---------- + schema : dict + Mutable schema mapping field names to schema entries. + key : str + Field name. + val : Any + Sample value used to infer the entry. + """ + # Add/validate a schema entry for key based on a sample value. + # Skip Nones or non-serializable objects + if val is None: + return + + if isinstance(val, torch.Tensor): + entry = _tensor_schema_entry(val) + # If already present, assume trailing dims are consistent. + schema.setdefault(key, entry) + + elif isinstance(val, (int, bool, float)): + schema.setdefault(key, type(val)) + + # Else: skip (e.g., strings, objects, SparseTensor not handled here). + + @staticmethod + def _iter_data_items(d: Data): + """Iterate over all public attributes of a Data object. + + Parameters + ---------- + d : Data + Graph data object. + + Yields + ------ + tuple + ``(key, value)`` pairs, including ``num_nodes`` if set. + """ + # Yield (key, value) pairs for all public attrs in a Data, + # including num_nodes if set. + for k in d.keys(): # noqa: SIM118 + yield k, getattr(d, k) + if getattr(d, "num_nodes", None) is not None: + yield "num_nodes", int(d.num_nodes) + + # Processing: build DB + memmaps once + def process(self) -> None: + """Build on-disk cluster database and permutation memmaps. + + Uses the bootstrapped partition to store per-cluster subgraphs + in the DB and writes global permuted structural and feature + arrays as memmaps. + """ + # Use bootstrapped objects; avoid recomputing partition. + full: Data = self._bootstrap_full + cluster_data: ClusterData = self._bootstrap_cluster_data + + # Write cluster subgraphs into the OnDiskDataset DB. + buf: list[Data] = [] + for i in range(len(cluster_data)): + buf.append(cluster_data[i]) + if (i + 1) % 1000 == 0 or (i + 1) == len(cluster_data): + self.extend(buf) + buf = [] + + # Persist partition/meta info. + meta = { + "num_parts": cluster_data.num_parts, + "recursive": cluster_data.recursive, + "keep_inter_cluster_edges": cluster_data.keep_inter_cluster_edges, + "sparse_format": cluster_data.sparse_format, + # Partition object from PyG; torch.save-able and used later: + "partition": cluster_data.partition, + } + os.makedirs(self.processed_dir, exist_ok=True) + torch.save(meta, self._meta_path) + + # Write global permuted CSR + X/y/edge_attr memmaps. + self._write_perm_memmaps(full, cluster_data.partition) + + # Drop bootstrap references. + self._bootstrap_full = None + self._bootstrap_cluster_data = None + + # (De)serialization for OnDiskDataset + def serialize(self, data: Data) -> dict[str, Any]: + """Serialize a cluster subgraph into a schema-compatible row. + + Only fields present in the inferred schema are stored. + + Parameters + ---------- + data : Data + Cluster subgraph to serialize. + + Returns + ------- + dict + Dictionary of stored fields. + """ + # Convert a Data object into a row matching the schema. + # Only attributes present in the schema are stored. + row: dict[str, Any] = {} + # edge_index is mandatory + if getattr(data, "edge_index", None) is None: + raise ValueError("Data object without edge_index cannot be serialized.") + row["edge_index"] = data.edge_index + + for key in self.schema: # .keys(): + if key == "edge_index": + continue + if hasattr(data, key): + val = getattr(data, key) + if isinstance(val, (torch.Tensor, int, bool, float)): + row[key] = val + # else: silently skip unsupported types + + return row + + def deserialize(self, row: dict[str, Any]) -> Data: + """Deserialize a stored row into a Data object. + + Parameters + ---------- + row : dict + Stored field dictionary. + + Returns + ------- + Data + Reconstructed cluster subgraph. + """ + # Rebuild a Data object from a stored row. + return Data.from_dict(row) + + # Meta properties + @property + def _meta_path(self) -> str: + """Path to the stored cluster metadata file. + + Returns + ------- + str + Full path to ``cluster_meta.pt``. + """ + return osp.join(self.processed_dir, "cluster_meta.pt") + + @property + def meta(self) -> dict[str, Any]: + """Cluster metadata dictionary. + + Returns + ------- + dict + Metadata including partition and configuration. + """ + if self._meta is None: + self._meta = torch.load(self._meta_path, map_location="cpu") + return self._meta + + @property + def partition(self): + """Partition object from :class:`ClusterData`. + + Returns + ------- + Any + Partition object used for permuted structures. + """ + return self.meta["partition"] + + @property + def num_parts(self) -> int: + """Number of cluster parts. + + Returns + ------- + int + Total number of partitions. + """ + return int(self.meta["num_parts"]) + + @property + def recursive(self) -> bool: + """Whether recursive partitioning is used. + + Returns + ------- + bool + True if recursive partitioning is enabled. + """ + return bool(self.meta["recursive"]) + + @property + def keep_inter_cluster_edges(self) -> bool: + """Whether inter-cluster edges are kept. + + Returns + ------- + bool + True if inter-cluster edges are preserved. + """ + return bool(self.meta["keep_inter_cluster_edges"]) + + @property + def sparse_format(self) -> str: + """Sparse format used for structural data. + + Returns + ------- + str + Name of the sparse format (e.g. ``"csr"``). + """ + return str(self.meta["sparse_format"]) + + # Memmap writers + def _memmap_dir(self) -> str: + """Directory for permuted memmap arrays. + + Returns + ------- + str + Path to the memmap directory. + """ + return osp.join(self.processed_dir, "perm_memmap") + + def _write_perm_memmaps(self, full: Data, P: Any) -> None: + """Write permuted structural and feature arrays as memmaps. + + Creates CSR structural arrays and permuted feature, label and + edge-attribute arrays under ``processed/perm_memmap``. + + Parameters + ---------- + full : Data + Full, unpermuted input graph. + P : Any + Partition object with permutation and CSR attributes. + """ + out_dir = self._memmap_dir() + os.makedirs(out_dir, exist_ok=True) + + # Save structural arrays from Partition P (PyG's object): + # P has: partptr, indptr, index, node_perm, edge_perm + np.save(osp.join(out_dir, "partptr.npy"), P.partptr.cpu().numpy()) + np.save(osp.join(out_dir, "indptr.npy"), P.indptr.cpu().numpy()) + np.save(osp.join(out_dir, "indices.npy"), P.index.cpu().numpy()) + + # Node-level perm: + node_perm = P.node_perm.cpu() + N = int(full.num_nodes) + + # Save permutation maps + # node_perm[i] = original_node_id for permuted row i + perm_to_global = node_perm.clone().to(torch.long) + np.save(osp.join(out_dir, "perm_to_global.npy"), perm_to_global.numpy()) + + # Inverse: global_id -> perm_index (handy for debugging / analysis) + global_to_perm = torch.empty_like(perm_to_global) + global_to_perm[perm_to_global] = torch.arange(perm_to_global.numel(), dtype=torch.long) + np.save(osp.join(out_dir, "global_to_perm.npy"), global_to_perm.numpy()) + + # X_perm.npy (features) + if getattr(full, "x", None) is not None and full.x.numel() > 0: + x = full.x + # ensure 2D + if x.dim() == 1: + x = x.view(-1, 1) + F = int(x.size(1)) + X_path = osp.join(out_dir, "X_perm.npy") + X_mm = open_memmap( + X_path, + dtype="float32", + mode="w+", + shape=(N, F), + ) + X_mm[:] = x[node_perm].to(torch.float32).cpu().numpy() + del X_mm # flush & close + + # y_perm.npy (labels) + if getattr(full, "y", None) is not None: + y_src = full.y.view(-1)[node_perm].to(torch.int64).cpu().numpy() + y_path = osp.join(out_dir, "y_perm.npy") + y_mm = open_memmap( + y_path, + dtype="int64", + mode="w+", + shape=(y_src.shape[0],), + ) + y_mm[:] = y_src + del y_mm + + # edge_attr_perm.npy (edge features aligned with CSR edges) + if getattr(full, "edge_attr", None) is not None: + ea = full.edge_attr + if ea.dim() == 1: + ea = ea.view(-1, 1) + ea_src = ea[P.edge_perm].to(torch.float32).cpu().numpy() + E, F_e = ea_src.shape + ea_path = osp.join(out_dir, "edge_attr_perm.npy") + ea_mm = open_memmap( + ea_path, + dtype="float32", + mode="w+", + shape=(E, F_e), + ) + ea_mm[:] = ea_src + del ea_mm diff --git a/topobench/dataloader/__init__.py b/topobench/dataloader/__init__.py index 47d9ac146..5009a7bd2 100644 --- a/topobench/dataloader/__init__.py +++ b/topobench/dataloader/__init__.py @@ -1,6 +1,7 @@ """This module implements the dataloader for the topobench package.""" +from .dataload_cluster import ClusterGCNDataModule from .dataload_dataset import DataloadDataset from .dataloader import TBDataloader -__all__ = ["DataloadDataset", "TBDataloader"] +__all__ = ["DataloadDataset", "TBDataloader", "ClusterGCNDataModule"] diff --git a/topobench/dataloader/dataload_cluster.py b/topobench/dataloader/dataload_cluster.py new file mode 100644 index 000000000..10e8f04de --- /dev/null +++ b/topobench/dataloader/dataload_cluster.py @@ -0,0 +1,436 @@ +# topobench/dataloader/dataload_cluster.py + +import os.path as osp +from collections.abc import Callable, Iterable +from typing import Any + +import numpy as np +import torch +from lightning.pytorch import LightningDataModule +from torch.utils.data import DataLoader +from torch_geometric.data import Data + +from .utils import ( + _HandleAdapter, + _PartIdListDataset, +) + + +# Collator: stream CSR blocks + masks +class BlockCSRBatchCollator: + """Collate Cluster-GCN mini-batches from CSR memmaps. + + Streams cluster blocks from disk (CSR structure, optional features, + labels and edge attributes) and builds a :class:`Data` batch with + node-level supervision masks and global node IDs. + + Parameters + ---------- + ds_like : _HandleAdapter + Adapter providing access to cluster metadata and memmaps. + device : torch.device or None, optional + Device to move the batch to. If ``None``, stays on CPU. + with_edge_attr : bool, optional + If True, reads and includes edge attributes. Default is False. + active_split : {"train", "val", "test"}, optional + Active split whose supervision mask is used. Default is "train". + post_batch_transform : callable or None, optional + Optional transform applied to the assembled batch. + """ + def __init__( + self, + ds_like: _HandleAdapter, + *, + device: torch.device | None = None, + with_edge_attr: bool = False, + active_split: str = "train", # "train" | "val" | "test" + post_batch_transform: Callable[..., Any] | None = None, + ) -> None: + self.ds = ds_like + self.device = device + self.with_edge_attr = with_edge_attr + self.active_split = str(active_split).lower() + assert self.active_split in ("train", "val", "test") + self.post_batch_transform = post_batch_transform + + mm_dir = osp.join(self.ds.processed_dir, "perm_memmap") + # Structural memmaps: + self.partptr = np.load(osp.join(mm_dir, "partptr.npy"), mmap_mode="r") + self.indptr = np.load(osp.join(mm_dir, "indptr.npy"), mmap_mode="r") + self.indices = np.load(osp.join(mm_dir, "indices.npy"), mmap_mode="r") + + # Optional arrays: + self.X = None + self.Y = None + self.EA = None + x_path = osp.join(mm_dir, "X_perm.npy") + y_path = osp.join(mm_dir, "y_perm.npy") + ea_path = osp.join(mm_dir, "edge_attr_perm.npy") + if osp.exists(x_path): + self.X = np.load(x_path, mmap_mode="r") + if osp.exists(y_path): + self.Y = np.load(y_path, mmap_mode="r") + if with_edge_attr and osp.exists(ea_path): + self.EA = np.load(ea_path, mmap_mode="r") + + # Split masks (permuted) + m_train = osp.join(mm_dir, "train_mask_perm.npy") + m_val = osp.join(mm_dir, "val_mask_perm.npy") + m_test = osp.join(mm_dir, "test_mask_perm.npy") + if not (osp.exists(m_train) and osp.exists(m_val) and osp.exists(m_test)): + raise FileNotFoundError("Permuted split masks not found in memmap dir.") + self.train_mask_perm = np.load(m_train, mmap_mode="r") + self.val_mask_perm = np.load(m_val, mmap_mode="r") + self.test_mask_perm = np.load(m_test, mmap_mode="r") + + assert self.ds.sparse_format == "csr", f"Expected CSR, got {self.ds.sparse_format}" + + # small helper to choose active split mask array + def _active_mask_array(self) -> np.ndarray: + if self.active_split == "train": + return self.train_mask_perm + if self.active_split == "val": + return self.val_mask_perm + return self.test_mask_perm + + def __call__(self, parts: list[int]) -> Data: + """Build a union batch from a list of cluster IDs. + + For the given cluster IDs, collects their CSR rows, node + features, labels and (optionally) edge attributes, then returns + a single :class:`Data` object. + + Parameters + ---------- + parts : list of int + Cluster IDs to merge into a mini-batch (length == ``q``). + + Returns + ------- + Data + Batched graph with fields such as ``edge_index``, ``x``, + ``y``, ``edge_attr``, ``supervised_mask`` and ``global_nid``. + """ + # ranges for selected clusters (sorted for monotonic slices) + parts = np.asarray(parts, dtype=np.int64) + starts = self.partptr[parts] + ends = self.partptr[parts + 1] + order = np.argsort(starts) + starts, ends = starts[order], ends[order] + + # gather node features/labels and build global_nid list + offsets = np.zeros(len(starts), dtype=np.int64) + total_nodes = 0 + xs, ys = [], [] + global_ids = [] + for i, (s, e) in enumerate(zip(starts, ends, strict=False)): + offsets[i] = total_nodes + # append features + if self.X is not None: + xs.append(torch.from_numpy(self.X[s:e])) + # append labels + if self.Y is not None: + ys.append(torch.from_numpy(self.Y[s:e])) + # append global permuted ids for these rows + if e > s: + global_ids.append(np.arange(s, e, dtype=np.int64)) + total_nodes += (e - s) + + x = torch.cat(xs, dim=0) if xs else None + y = torch.cat(ys, dim=0) if ys else None + global_ids = np.concatenate(global_ids, axis=0) if len(global_ids) else np.empty((0,), dtype=np.int64) + + # 3) stream CSR rows for each [s:e) -> make row/col (global ids) + row_chunks, col_chunks = [], [] + ea_chunks = [] if self.EA is not None else None + + for s, e, off in zip(starts, ends, offsets, strict=False): + rowptr = self.indptr[s:e+1] # shape (e-s+1,) + deg = rowptr[1:] - rowptr[:-1] # per-row degrees + beg, fin = int(rowptr[0]), int(rowptr[-1]) # contiguous span in indices + cols = torch.from_numpy(self.indices[beg:fin].astype(np.int64, copy=False)) + rows = torch.arange(e - s, dtype=torch.int64).repeat_interleave( + torch.from_numpy(deg.astype(np.int64)) + ) + int(off) + row_chunks.append(rows) + col_chunks.append(cols) + + if ea_chunks is not None: + ea_chunks.append(torch.from_numpy(self.EA[beg:fin])) + + row = torch.cat(row_chunks, dim=0) if row_chunks else torch.empty(0, dtype=torch.int64) + col = torch.cat(col_chunks, dim=0) if col_chunks else torch.empty(0, dtype=torch.int64) + edge_attr = torch.cat(ea_chunks, dim=0) if ea_chunks else None + + # keep only edges whose dst is inside the union of selected ranges + starts_t = torch.from_numpy(starts) + ends_t = torch.from_numpy(ends) + offsets_t= torch.from_numpy(offsets) + + idx = torch.bucketize(col, starts_t, right=True) - 1 + valid = (idx >= 0) & (col < ends_t.gather(0, idx.clamp_min(0))) + + row = row[valid] + col = col[valid] + idx = idx[valid] + if edge_attr is not None: + edge_attr = edge_attr[valid] + + # global->local column ids: col_local = col - starts[idx] + offsets[idx] + col_local = col - starts_t.gather(0, idx) + offsets_t.gather(0, idx) + edge_index = torch.stack([row, col_local], dim=0) + + data = Data(edge_index=edge_index) + if x is not None: + data.x = x + if y is not None: + data.y = y + if edge_attr is not None: + data.edge_attr = edge_attr + data.num_nodes = int(total_nodes) + + # ---- split-specific masks & ids ---- + active_mask = self._active_mask_array() + supervised_mask = torch.from_numpy(active_mask[global_ids]).to(torch.bool) + global_nid = torch.from_numpy(global_ids.astype(np.int64, copy=False)) + + # Apply transforms on the full batch + if self.post_batch_transform is not None: + data = self.post_batch_transform(data) + + data.supervised_mask = supervised_mask + data.global_nid = global_nid + + # Backwards-compatible attributes expected by existing code: + if self.active_split == "train": + data.train_mask = supervised_mask + elif self.active_split == "val": + data.val_mask = supervised_mask + elif self.active_split == "test": + data.test_mask = supervised_mask + + if x is not None: + data.x_0 = data.x + data.batch_0 = torch.zeros(data.num_nodes, dtype=torch.long) + + # Reproduce collate_fn behavior for batch_k and cell_statistics + + # Ensure batch_0 exists for nodes: + if hasattr(data, "batch_0"): + pass # respect whatever the transform set + elif hasattr(data, "batch"): + # Backward-compat: if someone set `batch`, alias it: + data.batch_0 = data.batch + else: + # Single graph: all nodes belong to graph 0 + data.batch_0 = torch.zeros(data.num_nodes, dtype=torch.long) + + # For every x_k (k >= 1) or x_hyperedges, create corresponding batch_k + # if it doesn't already exist. This mirrors TBDataloader.collate_fn. + for key in list(data.keys()): + if key.startswith("x_") and key not in ("x", "x_0"): + if key == "x_hyperedges": + cell_dim = "hyperedges" + batch_key = "batch_hyperedges" + else: + try: + cell_dim = int(key.split("_")[1]) + except Exception: + continue + batch_key = f"batch_{cell_dim}" + + if not hasattr(data, batch_key): + num_cells = getattr(data, key).size(0) + device = getattr(getattr(data, key), "device", None) + setattr( + data, + batch_key, + torch.zeros(num_cells, dtype=torch.long, device=device), + ) + + # If transform produced `shape`, map it to cell_statistics: + if hasattr(data, "shape") and not hasattr(data, "cell_statistics"): + shape = data.shape + shape = torch.as_tensor(shape, dtype=torch.long) + + # ensure shape is 2D: [1, max_dim+1]. + if shape.dim() == 1: + shape = shape.unsqueeze(0) + + data.cell_statistics = shape + delattr(data, "shape") + + if self.device is not None: + data = data.to(self.device, non_blocking=True) + + return data + +# DataModule-like wrapper +class ClusterGCNDataModule(LightningDataModule): + """Streaming DataModule for a single global Cluster-GCN partition. + + Uses one shared global partition and memmap bundle; train, validation + and test loaders differ only in which cluster parts they cover and + which supervision mask is active. + + Parameters + ---------- + data_handle : dict + Handle dictionary describing dataset paths and metadata. + q : int, optional + Number of clusters per mini-batch. Default is 10. + num_workers : int, optional + Number of worker processes for the dataloaders. Default is 0. + pin_memory : bool, optional + If True, pin memory in dataloaders. Default is False. + with_edge_attr : bool, optional + If True, batches include edge attributes. Default is False. + eval_cover_strategy : str, optional + Strategy for evaluation coverage (e.g. ``"all_parts"``). Default is "all_parts". + seed : int, optional + Random seed for part shuffling. Default is 42. + device : torch.device or None, optional + Device to move batches to. If ``None``, stays on CPU. + persistent_workers : bool or None, optional + If True, use persistent workers in dataloaders. If ``None``, + inferred from ``num_workers``. + post_batch_transform : callable or None, optional + Optional transform applied to each batch after collation. + """ + + def __init__( + self, + *, + data_handle: dict[str, object], + q: int = 10, + num_workers: int = 0, + pin_memory: bool = False, + with_edge_attr: bool = False, + eval_cover_strategy: str = "all_parts", + seed: int = 42, + device: torch.device | None = None, + persistent_workers: bool | None = None, + post_batch_transform: Callable[..., Any] | None = None, + ) -> None: + super().__init__() + + self.handle = data_handle + self.q = int(q) + self.num_workers = int(num_workers) + self.pin_memory = bool(pin_memory) + self.with_edge_attr = bool(with_edge_attr) + self.eval_cover_strategy = str(eval_cover_strategy) + self.seed = int(seed) + self.device = device + self.persistent_workers = ( + bool(persistent_workers) + if persistent_workers is not None + else (self.num_workers > 0) + ) + + self.ds_adapter = _HandleAdapter(self.handle) + self._paths = self.handle.get("paths", {}) + self.post_batch_transform = post_batch_transform + + # Preload part-lists for splits if available + self._parts_with = {} + for split in ("train", "val", "test"): + key = f"parts_with_{split}" + path = self._paths.get(key, None) + if path and osp.exists(path): + self._parts_with[split] = np.load(path) + else: + self._parts_with[split] = None + + # in TBBlockStreamDataModule + def _part_ids_for_split(self, split: str) -> Iterable[int]: + """Return cluster IDs to iterate for a given split. + + Prefers precomputed ``parts_with_{split}`` collections to avoid + batches without supervision; falls back to all parts otherwise. + + Parameters + ---------- + split : {"train", "val", "test"} + Split name. + + Returns + ------- + Iterable[int] + Iterable of part IDs for the split. + """ + split = split.lower() + + key = None + if split == "train": + key = "train" + elif split == "val": + key = "val" + elif split == "test": + key = "test" + + if key is not None: + arr = self._parts_with.get(key, None) + if arr is not None and len(arr) > 0: + return arr.astype(np.int64) + + # Fallback: if parts_with_* is missing, use all parts. + return np.arange(self.ds_adapter.num_parts, dtype=np.int64) + + # internal: build one loader + def _build_loader(self, *, split: str, shuffle: bool) -> DataLoader: + part_ids = self._part_ids_for_split(split) + part_ds = _PartIdListDataset(part_ids) + + collate = BlockCSRBatchCollator( + self.ds_adapter, + device=self.device, + with_edge_attr=self.with_edge_attr, + active_split=split, + post_batch_transform = self.post_batch_transform, + ) + + g = torch.Generator() + g.manual_seed(self.seed) + + return DataLoader( + part_ds, + batch_size=self.q, # q clusters per step + shuffle=shuffle, + num_workers=self.num_workers, + pin_memory=self.pin_memory, + persistent_workers=self.persistent_workers, + collate_fn=collate, + generator=g if shuffle else None, + ) + + # Public API similar to LightningDataModule + def train_dataloader(self) -> DataLoader: + """Return dataloader for the training split. + + Returns + ------- + DataLoader + Training dataloader. + """ + return self._build_loader(split="train", shuffle=True) + + def val_dataloader(self) -> DataLoader: + """Return dataloader for the validation split. + + Returns + ------- + DataLoader + Validation dataloader. + """ + return self._build_loader(split="val", shuffle=False) + + def test_dataloader(self) -> DataLoader: + """Return dataloader for the test split. + + Returns + ------- + DataLoader + Test dataloader. + """ + return self._build_loader(split="test", shuffle=False) diff --git a/topobench/dataloader/utils.py b/topobench/dataloader/utils.py index 4670e41a0..b16f94b8a 100644 --- a/topobench/dataloader/utils.py +++ b/topobench/dataloader/utils.py @@ -1,10 +1,13 @@ """Dataloader utilities.""" from collections import defaultdict +from collections.abc import Sequence from typing import Any +import numpy as np import torch import torch_geometric +from torch.utils.data import Dataset from torch_sparse import SparseTensor @@ -168,3 +171,29 @@ def collate_fn(batch): batch["cell_statistics"] = torch.Tensor(cell_statistics).long() return batch + +# Helpers for BlockCSRBatchCollator +class _HandleAdapter: + """ + Minimal dataset-like object used by the collator. + Exposes the few attributes the collator needs: + - processed_dir (str) + - num_parts (int) + - sparse_format (str) + """ + def __init__(self, handle: dict[str, object]) -> None: + self.processed_dir = handle["processed_dir"] + self.num_parts = int(handle["num_parts"]) + self.sparse_format = str(handle["sparse_format"]) + + +class _PartIdListDataset(Dataset): + """Dataset that yields part IDs from a provided list.""" + def __init__(self, part_ids: Sequence[int]) -> None: + self._parts = np.asarray(part_ids, dtype=np.int64) + + def __len__(self) -> int: + return self._parts.shape[0] + + def __getitem__(self, idx: int) -> int: + return int(self._parts[idx]) diff --git a/tutorials/tutorial_on_disk_transductive_pipeline.ipynb b/tutorials/tutorial_on_disk_transductive_pipeline.ipynb new file mode 100644 index 000000000..d587e2383 --- /dev/null +++ b/tutorials/tutorial_on_disk_transductive_pipeline.ipynb @@ -0,0 +1,755 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "779c9d47-4d89-4e80-a532-a5c48bd03f51", + "metadata": { + "id": "779c9d47-4d89-4e80-a532-a5c48bd03f51" + }, + "source": [ + "# Transductive On-Disk Pipeline\n", + "\n", + "## Tutorial Overview\n", + "\n", + "In this tutorial, we present three transductive dataset pipelines designed for scalable higher-order learning in TopoBench. \n", + "These pipelines progressively increase in memory efficiency, moving from fully-in-memory processing to a fully on-disk workflow suitable for large graphs.\n", + "\n", + "The goal of this notebook is to demonstrate:\n", + "\n", + "- **How each pipeline works**, \n", + "- **How to configure and run them**, and \n", + "- **How to evaluate and compare their memory and performance characteristics**.\n", + "\n", + "---\n", + "\n", + "## Why Three Pipelines?\n", + "\n", + "TopoBench was originally built around the `InMemoryDataset` class from `torch_geometric`, which works well for small and medium-sized graphs. \n", + "However, when dealing with larger datasets or applying computationally expensive topological liftings, the memory requirements quickly become prohibitive.\n", + "\n", + "To overcome these limitations, we introduce two additional pipelines for transductive datasets that extend the original design and enable more memory efficient transductive processing:\n", + "\n", + "### 1. Standard TopoBench Pipeline\n", + "- Loads the entire graph into memory as an `InMemoryDataset`.\n", + "- Applies all preprocessing, liftings, and split generation fully in RAM.\n", + "- Simple and fast for small graphs, but becomes slow and memory-intensive for large datasets or heavy lifting operations.\n", + "- Not suitable when the full lifted structure exceeds available memory.\n", + "\n", + "### 2. Cluster-GCN–Style Partitioning Pipeline\n", + "- Loads the full graph into memory once, runs a Cluster-GCN–style partitioner, and writes the partitioned representation to disk.\n", + "- Used primarily to prepare datasets for the fully on-disk pipeline (Pipeline 3).\n", + "- During training, batches are formed by selecting a few clusters, collating them together, and performing liftings at batch level. This preserves message passing across clusters inside the batch while keeping memory usage low.\n", + "- After partitioning is complete, subsequent runs no longer require the full graph in RAM.\n", + "\n", + "### 3. Fully On-Disk Transductive Pipeline\n", + "- Downloads a pre-partitioned dataset prepared via Pipeline 2 and hosted online.\n", + "- All data structures (features, edges, adjacency/chains, and cluster assignments) are accessed from disk, so we never load the graph into memory.\n", + "- The training loop performs the same batch-level lifting as Pipeline 2.\n", + "- Enables training on very large graphs by preparing the partitioned dataset once on a high-RAM machine once (via Pipeline 2) and then training anywhere using only the lightweight on-disk representation.\n", + "\n", + "---\n", + "\n", + "## What This Notebook Covers\n", + "\n", + "This notebook walks through the following:\n", + "\n", + "### 1. Understanding New Pipelines\n", + "We explain:\n", + "\n", + "- Motivation\n", + "- What they add to TopoBench\n", + "\n", + "### 2. Using the Transductive Pipelines in TopoBench\n", + "We will demonstrate:\n", + "\n", + "- How to instantiate each pipeline via Hydra configuration \n", + "- How to integrate them into the existing TopoBench mechanisms \n", + "- How to apply lifting transformations at the batch or global level \n", + "\n", + "### 3. Evaluation, Testing, and Memory Tracking\n", + "Finally, we compare the pipelines:\n", + "\n", + "- Performance characteristics \n", + "- Memory footprint (via `memory_plotting.py`) \n", + "- Behavior under randomized cluster batching \n", + "- Recall convergence experiments for higher-order structures" + ] + }, + { + "cell_type": "markdown", + "id": "f8d03a93-21d5-485d-9d26-10211b0c2eba", + "metadata": { + "id": "f8d03a93-21d5-485d-9d26-10211b0c2eba" + }, + "source": [ + "# Understanding New Pipelines\n", + "## Motivation: Cluster-GCN\n", + "\n", + "Training GNNs on large transductive graphs presents two core challenges:\n", + "\n", + "#### 1. Full-batch GCNs do not scale\n", + "\n", + "Standard GCNs operate on the entire graph at once. This requires storing all node embeddings for all layers:\n", + "\n", + "$$\n", + "\\text{Memory} = O(N \\times F \\times L)\n", + "$$\n", + "\n", + "where:\n", + "- $N$: number of nodes \n", + "- $F$: feature dimension \n", + "- $L$: number of layers \n", + "\n", + "As graphs grow, this quickly exceeds available RAM.\n", + "\n", + "---\n", + "\n", + "#### 2. Simple mini-batching breaks down on graphs\n", + "\n", + "If we try to create a mini-batch by sampling a small set of nodes, we cannot run a GNN on them directly. GCN-style message passing requires all their neighbors to be present:\n", + "\n", + "- A 1-layer GCN needs 1-hop neighbors \n", + "- A 2-layer GCN needs 2-hop neighbors \n", + "- An L-layer GCN needs all L-hop neighborhoods\n", + "\n", + "So even if we start with only a few nodes, we must:\n", + "\n", + "- Gather all 1-hop neighbors \n", + "- Then all neighbors of those neighbors \n", + "- Continue for L steps\n", + "\n", + "This process quickly pulls in a very large part of the graph, meaning the “mini-batch” becomes almost as large as the full graph.\n", + "\n", + "This is the key reason standard SGD-style mini-batching does not work for GCNs.\n", + "\n", + "---\n", + "\n", + "Our solution is based on the Cluster-GCN algorithm proposed in Chiang et al., *Cluster-GCN: An Efficient Algorithm for Training Deep and Large GNNs* (KDD 2019). This approach is also used in PyTorch Geometric’s `ClusterData` implementation.\n", + "\n", + "### Cluster-GCN’s Key Insight\n", + "\n", + "Cluster-GCN avoids both problems by batching clusters, not individual nodes:\n", + "\n", + "1. **Partition the graph.**\n", + " Into clusters with strong intra-cluster connectivity (using METIS graph partitioning algorithm)\n", + "\n", + "3. **Each mini-batch consists of one or more clusters.** \n", + " All message passing occurs inside the induced subgraph of these clusters.\n", + "\n", + "4. **No recursive neighbor expansion** is needed, \n", + " because the cluster subgraphs already contain the relevant neighbors.\n", + "\n", + "**Benefits:**\n", + "\n", + "- Memory scales with the number of nodes in the batch, not with the total graph size: \n", + " For a batch containing $b$ nodes: $O(b \\times F \\times L)$ with $b \\ll N$\n", + "\n", + "- Clusters preserve local neighborhood structure: \n", + " Effective message passing inside each block\n", + "\n", + "- Mini-batches are small but structurally meaningful:\n", + " Avoids low-signal subgraphs caused by purely random node sampling\n", + "\n", + "---\n", + "\n", + "### In TopoBench\n", + "\n", + "TopoBench applies topological liftings that transform graphs into higher-order datasets. \n", + "These operations:\n", + "\n", + "- require more memory than standard GCN preprocessing, \n", + "- make fully in-memory workflows impractical on larger datasets.\n", + "\n", + "By incorporating a Cluster-GCN–style partitioning strategy (following Chiang et al. 2019):\n", + "\n", + "- liftings can be applied at the mini-batch level, \n", + "- memory usage is bounded by cluster size instead of graph size, \n", + "- features and adjacency blocks can be streamed directly from disk, \n", + "- lifted models can be trained on graphs that would otherwise not fit in memory.\n", + "\n", + "This forms the foundation for the new transductive pipelines we implemented." + ] + }, + { + "cell_type": "markdown", + "id": "cd338572-973d-486f-800c-563862197007", + "metadata": { + "id": "cd338572-973d-486f-800c-563862197007" + }, + "source": [ + "# Using the Transductive Pipelines in TopoBench\n", + "\n", + "All three transductive pipelines are selected and configured purely through YAML files.\n", + "\n", + "For the Cora dataset, we use three separate YAMLs:\n", + "\n", + "1. `cocitation_cora.yaml`: standard in-memory pipeline \n", + "2. `cocitation_cora_for_partitioning.yaml`: partitioning pipeline (build on-disk dataset) \n", + "3. `cocitation_cora_on_disk.yaml`: fully on-disk training pipeline \n", + "\n", + "Below we present the other two.\n", + "\n", + "---\n", + "\n", + "## Cluster-GCN–Style Partitioning Pipeline (`cocitation_cora_for_partitioning.yaml`)\n", + "\n", + "To build the on-disk, partitioned dataset, we start from the in-memory YAML and add the lines required for Cluster-GCN-style partitioning.\n", + "\n", + "**Important:** \n", + "We keep the same loader (`PlanetoidDatasetLoader` in this example), because partitioning still requires loading the entire graph into memory once.\n", + "\n", + "```yaml\n", + "# cocitation_cora_for_partitioning.yaml\n", + "\n", + "loader:\n", + " _target_: topobench.data.loaders.PlanetoidDatasetLoader # same as in-memory\n", + " parameters:\n", + " data_domain: graph\n", + " data_type: cocitation_on_disk # NEW: output directory for the partitioned dataset\n", + " data_name: Cora\n", + " data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type}\n", + "\n", + " # NEW: activate Cluster-GCN–style global partitioning\n", + " memory_type: on_disk_cluster # \"in_memory\", \"on_disk\", or \"on_disk_cluster\"\n", + "\n", + " # NEW: global partition settings\n", + " cluster:\n", + " num_parts: 32\n", + " recursive: false\n", + " keep_inter_cluster_edges: false\n", + " sparse_format: csr\n", + "\n", + " # NEW: streaming parameters (these affect how batches will be formed later)\n", + " stream:\n", + " q: 4 # batch size\n", + " num_workers: 0\n", + " pin_memory: false\n", + " with_edge_attr: false\n", + " precompute_split_parts: true\n", + "\n", + " # NEW: how features are saved on disk\n", + " dtype_policy: float32\n" + ] + }, + { + "cell_type": "markdown", + "id": "038e5283-e49c-476b-8350-7700caf184a5", + "metadata": { + "id": "038e5283-e49c-476b-8350-7700caf184a5" + }, + "source": [ + "---\n", + "\n", + "## Fully On-Disk Pipeline (`cocitation_cora_on_disk.yaml`)\n", + "\n", + "The fully on-disk pipeline is entirely autonomous. It does not require the user to run the partitioning step (Pipeline 2) locally.\n", + "\n", + "Instead, TopoBench provides a registry of pre-partitioned datasets that were already produced using the partitioning pipeline and then uploaded online.\n", + "\n", + "The `OnDiskDatasetLoader` downloads, extracts, and loads this structure directly from disk, without ever loading the full graph into memory.\n", + "\n", + "Because the dataset is already partitioned, the loader used is:\n", + "\n", + "```yaml\n", + "loader:\n", + " _target_: topobench.data.loaders.OnDiskDatasetLoader" + ] + }, + { + "cell_type": "markdown", + "id": "4769f308-97f0-48bc-89d5-81f099777f61", + "metadata": { + "id": "4769f308-97f0-48bc-89d5-81f099777f61" + }, + "source": [ + "This distinguishes Pipeline 3 from the partitioning pipeline, where `PlanetoidDatasetLoader` (in the Cora example) is still required to hold the full graph in RAM temporarily.\n", + "\n", + "### Where these datasets come from\n", + "\n", + "Several datasets in TopoBench were already partitioned offline using Pipeline 2 and then hosted in the public repository. \n", + "Pipeline 3 simply consumes these ready-made on-disk datasets via the URLs defined in:\n", + "\n", + "```python\n", + "OnDiskDatasetLoader.URLS" + ] + }, + { + "cell_type": "markdown", + "id": "4691e613-54c7-419d-953f-3569d4de7d8f", + "metadata": { + "id": "4691e613-54c7-419d-953f-3569d4de7d8f" + }, + "source": [ + "This allows Pipeline 3 to run immediately, without requiring the user to\n", + "perform any partitioning locally.\n", + "\n", + "Below is the configuration used for the fully on-disk pipeline:\n", + "\n", + "```yaml\n", + "# cocitation_cora_on_disk.yaml\n", + "\n", + "loader:\n", + " _target_: topobench.data.loaders.OnDiskDatasetLoader\n", + " parameters:\n", + " data_domain: graph\n", + " data_type: cocitation_on_disk\n", + " data_name: Cora_on_disk # must match a key in URLS\n", + " data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type}\n", + "\n", + " memory_type: on_disk # fully on-disk mode\n", + "\n", + " cluster:\n", + " num_parts: 32\n", + " recursive: false\n", + " keep_inter_cluster_edges: false\n", + " sparse_format: csr\n", + "\n", + " stream:\n", + " q: 4\n", + " num_workers: 0\n", + " pin_memory: false\n", + " with_edge_attr: false\n", + " precompute_split_parts: true\n", + "\n", + " dtype_policy: float32" + ] + }, + { + "cell_type": "markdown", + "id": "395be936-0802-4339-8529-43a28ffef640", + "metadata": { + "id": "395be936-0802-4339-8529-43a28ffef640" + }, + "source": [ + "The only differences between Pipeline 2 and Pipeline 3 are:\n", + "\n", + "- `memory_type` changes from `on_disk_cluster` to `on_disk` \n", + "- the loader switches from `PlanetoidDatasetLoader` to `OnDiskDatasetLoader`\n", + "\n", + "Everything else (cluster settings, stream configuration, `dtype_policy`) remains identical, because Pipeline 3 uses the already partitioned dataset.\n", + "\n", + "## Adding a New Dataset to the On-Disk URL Registry\n", + "\n", + "To make a new dataset available for the fully on-disk pipeline, you only need to add one entry to the `OnDiskDatasetLoader.URLS` dictionary.\n", + "\n", + "Follow these steps:\n", + "\n", + "### 1. Run Pipeline 2 (on_disk_cluster) on your dataset\n", + "This produces a `processed/` directory containing the partitioned graph:\n", + "- permuted features \n", + "- CSR adjacency \n", + "- labels and masks \n", + "- cluster boundaries \n", + "- metadata \n", + "\n", + "### 2. Zip the `processed/` directory\n", + "Create a file named `processed.zip` containing all files inside `processed/`.\n", + "\n", + "### 3. Upload the ZIP file\n", + "You can host it anywhere that provides a direct download link:\n", + "- GitHub \n", + "- HuggingFace \n", + "- Your prefered platform \n", + "\n", + "### 4. Add an entry to the URL registry\n", + "In `OnDiskDatasetLoader.URLS`, add:\n", + "\n", + "```python\n", + "\"YourDataset_on_disk\": \"https://your-host.com/path/to/processed.zip\"" + ] + }, + { + "cell_type": "markdown", + "id": "1b629a49-20c7-40fb-bcb3-fb7d026599de", + "metadata": { + "id": "1b629a49-20c7-40fb-bcb3-fb7d026599de" + }, + "source": [ + "### 5. Use it in a YAML file\n", + "\n", + "Set:\n", + "```yaml\n", + "data_name: YourDataset_on_disk" + ] + }, + { + "cell_type": "markdown", + "id": "b1ac1847-7aac-4377-8277-e6efec01444e", + "metadata": { + "id": "b1ac1847-7aac-4377-8277-e6efec01444e" + }, + "source": [ + "and the `OnDiskDatasetLoader` will automatically download, extract, and load the dataset.\n", + "\n", + "That’s it, your custom dataset is now fully compatible with the on-disk pipeline." + ] + }, + { + "cell_type": "markdown", + "id": "ddd6bf2b-ff84-4965-bf76-723f160dd1a1", + "metadata": { + "id": "ddd6bf2b-ff84-4965-bf76-723f160dd1a1" + }, + "source": [ + "# Evaluation, Testing, and Memory Tracking\n", + "\n", + "## Memory Comparison Across Pipelines\n", + "\n", + "To evaluate the practical memory benefits of our transductive pipelines, \n", + "we measure and visualize RAM usage during training on several variants of the Reddit dataset.\n", + "\n", + "The Reddit dataset is a large-scale, node-classification benchmark introduced in \n", + "*GraphSAGE: Inductive Representation Learning on Large Graphs*. \n", + "It contains:\n", + "\n", + "- **232,965 nodes** \n", + "- **11,606,919 edges** \n", + "- **602-dimensional features**\n", + "\n", + "(See the official PyTorch Geometric implementation: \n", + "https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.datasets.Reddit.html)\n", + "\n", + "Because of its size, Reddit is an ideal test case for comparing memory footprints.\n", + "\n", + "---\n", + "\n", + "### What We Compare\n", + "\n", + "We evaluate three versions of the same dataset, each processed by a different pipeline:\n", + "\n", + "1. **reddit (in-memory)** \n", + " - Standard PyG `InMemoryDataset`. \n", + " - The full graph, features, and adjacency are resident in RAM. \n", + " - Serves as the *baseline* for maximum memory use.\n", + "\n", + "2. **reddit\\_cluster\\_2 (partitioning pipeline)** \n", + " - Produced with Pipeline 2 (`on_disk_cluster`). \n", + " - Loads the full graph once, partitions it, and trains using cluster-wise batches. \n", + " - Greatly reduces peak memory use during training.\n", + "\n", + "3. **reddit\\_cluster\\_3 (fully on-disk pipeline)** \n", + " - Produced with Pipeline 3 (`on_disk`). \n", + " - No full graph is stored in memory: features, adjacency, and cluster blocks \n", + " are streamed from disk on demand. \n", + " - Achieves the lowest memory footprint.\n", + "\n", + "---\n", + "\n", + "## How Memory Tracking Works\n", + "\n", + "For each configuration, we run the training process under a memory profiler:\n", + "\n", + "1. A template test file is patched with the selected dataset and model. \n", + "2. Training is executed while memory usage is measured continuously. \n", + "3. The profiler outputs:\n", + " - raw memory vs. time, and \n", + " - normalized memory vs. relative progress, \n", + " allowing comparison when runtimes differ.\n", + "\n", + "The following plots summarize the results for the three Reddit variants." + ] + }, + { + "cell_type": "markdown", + "id": "c50dc4f6-3bcd-44ac-a04c-91ee593a8153", + "metadata": { + "id": "c50dc4f6-3bcd-44ac-a04c-91ee593a8153" + }, + "source": [ + "### `graph/gcn` model\n", + "\n", + "![memory_plot_raw.png](data:image/png;base64,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)\n", + "\n", + "![memory_plot_normalized.png](data:image/png;base64,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)\n", + "\n", + "These plots show memory and time savings produced by our pipelines for a large transductive datasets." + ] + }, + { + "cell_type": "markdown", + "id": "73466984-78a5-4271-967e-c9882e6c6649", + "metadata": { + "id": "73466984-78a5-4271-967e-c9882e6c6649" + }, + "source": [ + "# Challenges With Liftings Under Graph Partitioning\n", + "\n", + "Topological liftings are global operations: they detect higher-order structures that may span large portions of the graph. \n", + "However, in a Cluster-GCN–style pipeline, we intentionally partition the graph into many small blocks.\n", + "\n", + "This leads to the central issue:\n", + "\n", + "---\n", + "\n", + "## Local Liftings Lose Global Structure\n", + "\n", + "If liftings are applied inside each cluster independently, then:\n", + "\n", + "- each cluster produces local higher-order structures,\n", + "- any structure spanning multiple clusters is lost,\n", + "- when clusters are later combined into a batch, their lifted structures remain disjoint, \n", + "- and the dataloader has no mechanism to merge them back into a consistent global structure.\n", + "\n", + "In other words: lifting before batching destroys global higher-order structures.\n", + "\n", + "---\n", + "\n", + "## Our Solution: Batch First, Lift Second\n", + "\n", + "To capture global topological structures as faithfully as possible, we redesigned the pipeline:\n", + "\n", + "1. The Cluster-GCN loader samples several clusters for each batch. \n", + "2. These clusters are collated into a single subgraph. \n", + "3. Liftings are applied to the collated batch, not to each cluster.\n", + "\n", + "This allows:\n", + "\n", + "- structures spanning multiple clusters to be discovered if those clusters co-occur in a batch,\n", + "- randomized batching across epochs to progressively reveal additional global structures.\n", + "\n", + "We therefore sweep two parameters:\n", + "\n", + "- `num_parts`: number of METIS partitions, \n", + "- `batch_size`: number of partitions gathered before lifting.\n", + "\n", + "When `batch_size = num_parts`, all partitions are assembled at once and the full graph is reconstructed, producing liftings identical to the global “golden” lifting, which is our fallback position.\n", + "\n", + "---\n", + "\n", + "## Structures Comparison\n", + "\n", + "To quantify how much global information is preserved, we compare against a global lifting:\n", + "\n", + "- Set $G$: all higher-order structures (hyperedges, 1-cells, 2-cells, …) produced by lifting the entire graph, called golden in the rest of the notebook.\n", + "- Sets $C^{(i)}$: structures observed in epoch $i$ of the cluster pipeline.\n", + "\n", + "At epoch 1:\n", + "\n", + "- each batch produces lifted structures,\n", + "- they are collected into $C^{(1)}$,\n", + "- and compared against the golden set $G$.\n", + "\n", + "Across multiple epochs:\n", + "\n", + "- shuffling the batches reveals new cross-cluster structures,\n", + "- giving the cumulative set $C^{(\\le n)} = \\displaystyle \\bigcup_{i=1}^{n} C^{(i)}$.\n", + "\n", + "---\n", + "\n", + "## Recall Metrics\n", + "\n", + "We use recall to measure how many global structures are recovered.\n", + "\n", + "### Recall after 1 epoch\n", + "\n", + "$$\n", + "\\text{Recall}_{1}\n", + "= \\frac{\\lvert\\, G \\cap C^{(1)} \\,\\rvert}{\\lvert G \\rvert}\n", + "$$\n", + "\n", + "This quantifies how many golden structures appear after a single randomized sweep.\n", + "\n", + "---\n", + "\n", + "### Cumulative recall after $n$ epochs\n", + "\n", + "$$\n", + "\\text{Recall}_{n}\n", + "= \\frac{\n", + " \\left|\\, G \\cap \\displaystyle \\bigcup_{i=1}^{n} C^{(i)} \\,\\right|\n", + "}{\n", + " \\lvert G \\rvert\n", + "}\n", + "$$\n", + "\n", + "This measures the fraction of global structures recovered after repeatedly mixing clusters across $n$ epochs.\n", + "\n", + "---\n", + "\n", + "Below we present the following:\n", + "\n", + "1. Recall after a single epoch \n", + " — shows how much structure is captured in one pass.\n", + "\n", + "2. Recall after many epochs\n", + " — shows how much structure is recovered through repeated random batching.\n", + "\n", + "3. Final / initial recall ratio \n", + " — quantifies how much improvement comes from multi-epoch mixing.\n", + "\n", + "4. Recall progression over epochs for a selected configuration of `batch_size` and `num_parts`.\n", + "\n", + "The heatmaps and line plots that follow illustrate these effects \n", + "for hyperedges, 1-cells, and 2-cells across different `batch_size` and `num_parts` configurations for the Cora dataset." + ] + }, + { + "cell_type": "markdown", + "id": "9ecb6c9d-2bdc-4fce-85eb-975a16d46fba", + "metadata": { + "id": "9ecb6c9d-2bdc-4fce-85eb-975a16d46fba" + }, + "source": [ + "### Recall after a single epoch for the Cora hypergraph\n", + "\n", + "![cora_hypergraph.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "dL3Wf0qJKZ2F", + "metadata": { + "id": "dL3Wf0qJKZ2F" + }, + "source": [ + "### Recall after a single epoch for the Cora cell complex\n", + "\n", + "![cora_cells.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACvAAAASwCAYAAAAn7Z9pAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3QeYXGXZBuB3k00vpEMqhBJClyodEQEp0vxpFooioICCIF06CAKCFCnSLRSlFwVBeguhdwgkkEJJJb3t7n99J86wm+xuNsnu7M7ufXuda8/MnHPmmz2zg3nmPe9XUlFRUREAAAAAAAAAAAAAQEG0KszTAAAAAAAAAAAAAACJAl4AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQAp4AQAAAAAAAAAAAKCAFPACAAAAAAAAAAAAQAEp4AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXABrAqFGjoqSkJFtWWmmlxh5Os3TppZdmv99WrVrF8OHDG3s4Remggw7Kv09vuummardJ9+e2Sds3lDlz5mR/K+l5tt9++wZ7Hgondz7Tkj4Tl/Y92Jw/J95+++1o3bp1NsZzzz23sYcDAAAALIbct+Hdc889+d/xXXfd1djDKUp1yXQL+V7eb7/9sufp06dPTJkypUGfi5bxvcLLL7+cz1X/8Ic/RFPj+w4AYEko4AWgxfnWt76VDw4WXtq3bx/LL798rLbaarHlllvGUUcdlQUNn376aWMPu8kYOXJk3HHHHXH88cfHtttuG127dq3yOyyEL774Ik4//fRsfd99942NNtqoxm0rKiri/fffj7/+9a/xq1/9KjbffPPo2LGjoL2JadeuXZx55pnZ+qOPPtro4XxtnxNp6dKlSwwaNCi++93vxnnnnRdjx45t1PGybJ8T6QuLn/3sZ7Hiiitm78X0ZcIee+wRzzzzTJ2fb8KECdGzZ8/s/fGLX/yiTvustdZaccABB2Tr6X00evToOj8fAAAAUJXcd+lNnjw5/vGPf2SZRspPUzbStm3bLPtdZZVVsgLMv/3tbzFv3rwGHcesWbPimGOOydY33XTT2GuvvZr8mFm8c845J0pLS2P8+PFx2mmnNepYzjjjjFpz3w4dOsQKK6yQfU4ce+yx8eqrrzbqeKn+O58jjzwyysvLszz3iCOOqHHb6dOnZ+d87bXXzr4X6tatW2y11VZx8803Z8epq2222SZ7f6y77roxf/78ovu+AwBo2kobewAA0NSuiv3yyy+zZcSIEfHss89m96fujalQ75e//GXsuOOO0RJ99tlnsc4668TEiRMbeyhZ8DF16tQsMKkt8EsdN7fbbrtsW5q+H/3oR3HWWWfFxx9/HCeccELstttuWbDbFKXgLy2p4PLhhx/OQsBTTjklez8WqpCd+vmceOqpp2LXXXeNadOm5e9LXybce++9cd9992UdHI4++ujFPl+6qGHSpEnZl0WpGLeu0vvmL3/5S8ycOTMb54033ljnfQEAAIC6kftWL+Vb+++/fzzyyCMxd+7cRR5Pxa8pM0l53e233x6nnnpqVvi29dZbN8h4Lr/88vxMTilvK4Yxs3irrrpq/OAHP4hbbrklrrrqqqzRRiqybopmz56dLak5QPqcSNng3nvvHddcc0107969sYdHRFa4/8ILL2TrJ510UlYsW9N3Wt/+9rfjvffeq3KRQGrakJYHHnggbrvttqyTb23S+zZlyClnTu/fun5nUUzfdwAAjcv/QwCgRdt4441jk002yd9OV+x+9dVX2TROaWrzTz75JH//Qw89lC1pup/LLrss68DZ0kLuplC8mwLc6667LlvffffdY4011qhx2xTmKt4tHikoO+6447KuGemLlNQF5ZBDDmlynxNJ+px4/fXX480338x/MZC+VEifHZdcckkjjZQl/ZxIn2kpgM8V76633nrZ+U77p84IqQtD6rSx4YYbZp0ZavLcc8/lp4u78MILs04OS/IFxve///2ss3kq5D3xxBNj9dVXX8JXDAAAAFQm962blJ+mIrbKUqfiNJNR6kKaMq/XXnst3njjjeyxlJmkhgl33313dkF0fUo57gUXXJCtf+Mb36ixoLopjZm6SwWMqRAydS9Ns2alGfMaW79+/WLPPfescl+6yP6jjz6K559/Pt+9ORWMjhkzJv773/9m3bxpPGVlZflZ19LfffrcrsmPf/zjfPFuOtc77LBD9vmRPu/Tef7nP/8Z559/ftZgoSbpvxm/+c1vsvX0XFtssUXRf98BADQ9CngBaNF23nnnGq/kTz7//POsoCoFtymgSdI/slPI++STT2bTKVVnpZVWWqLpd4pJ586dY4MNNsgC8BSEp6vRDzzwwII9/8UXX5wPzmqbGqmydGV8CnDTeNPy/vvvZ0VyND0pVEudTFOQlgohf/rTnzZ6R9vaPidS4Wbq+JGbbvHSSy+NH/7wh9n7jcZT18+Jq6++Ouu8k9sudXnJvd/SFIupS0L6Iu/ss8/OurrUFBqnEDZ95qci3wMOOGCJx/vzn/88K+BNx7roooviz3/+8xIfAwAAAPia3HfJpPw0ZRoHH3xwdoHzwlK3yvT4yJEjswLMlH998MEHWQFdfUl5SJrdqK65b1MYM3W35pprxjbbbJP9faWup+eee26suOKKjTqm1VZbLa644opqH0szr6X3zxNPPJHdTgW9V155ZXaxP43nnnvuyRflpmLYmrrvpu7Jjz32WLaevstK6+m7reSdd96JzTbbLLtoIGWxxxxzTHTs2LHa46Ti3pQf9+jRI3+BQbF/3wEAND2tGnsAANCUpSv209W17777btalMeell16q9cre5igFm2+99VbWqSKFbCls2GeffWLQoEEFG0N67tz08oMHD846J9QmBbcffvhhFvym4rsUCu6xxx5C2iYshWj77rtvtp4C9XQ1fFO2+eabx7333lsldLv22msbdUwt3ZJ8TuS6tXTt2jX7fKh8HtOXOrmOCo8//njWlaE6qeg3dWNO05/96U9/Wqoxf+tb38o68Sap+8iECROW6jgAAABA3ch9F2jbtm2cdtppWZfadGF6dYWwyZZbbpl1H00ZSpIK39L29SVd1JwylqRTp06x3377Nfkxs+Ry3UfT+a6pcLapGDhwYNx///3Zz5xrrrmmUcfEggYaOakYtiaVu3Snwttc8W6umPyoo47Kd9hNxb7Vefnll7MGEMl5550XvXv3bvbfdwAAjUMBLwDU8R/Zt99+e+yyyy75+1K3xKeeeipaitR1Yq211opWrRrv/z6kczBjxoxsPQXri7tSOXVhyBXFUTxSYXjODTfcEE1dmtIvFWDmtKTPhaZoST4nct0aNtxww1huueUWeTxX/Ju6tKRpzhb22Wef5ads+9WvfhVrr732Uo8792Vh6mp+6623LvVxAAAAgLpr6blv6ip55pln5otca5O6Dx9++OH52w8++GC9jSN1x/zkk0+y9XQuKhfbNdUxs+R23333fMfUW265JcvcmrL0PswVHSepWUjq3k3jSAWwqbN2rqtuat6wuNw3NV1Is6YtrHLTh3Qhx8LSrGxp1rX0Mz3Xz372sxbzfQcAUHgKeAGgjlIRWAqVunTpkr8vdWysTrr6P22flhQS1nbM3JLz2muvZdOpr7766llAlJZvfvObWWfH6gKt4cOHZ10h1lhjjaw7Qc+ePWPbbbfNpn9vbiq/ptRJtxj961//isMOOywr9Evnqk2bNtGtW7fYYIMNsvvvu+++OgWXKVQ6+eSTs/AodRROnSfSFeDpvZI6UIwbNy4KLXUoOfLII7PXkoqnUziWCr/79u0bm266afa+Tl+A5Iora/Ltb387X0yZrpRPV8EXQxFvTl1/9/V9DlPnivT7TVO7pc+PdA7S+yu9z9IxU4Fp+jKkpmkeUxj59NNPZ8+9ww47ZN2109RhKVRP5zCdl/SZ19S7wy7J58S0adOynzV15U6ve+FtK/v1r3+ddW/p379/rdNy1sWee+6ZX09deAEAAIDCkPvWXW62otzvohhy34Ya88LeeOONOPHEE7Nzmjo8p6wvneN0vlMHzuuvvz6bOWpxJk6cGBdffHFsv/32WffX9u3bZ/lx6hp6xBFHZO+LQhs9enRWNL311ltnOVrKC9PrS+/J1AH5Bz/4QVx11VWLLW5Nf2O5wskvv/wy/vOf/0Qx5b5JXTLbhjiHqXA15bvrr79+9OnTJ8t9UxH7OuusEwceeGDWEGDWrFm1ZtGXXHJJ7LXXXtl7Mp2LdIyUR2+00UZxzDHHxDvvvBPNLfft1atXtG7deolz3z//+c8xbNiwrKFN+oxelsY2xfh9BwBQYBUA0MJss802qXotW04//fQl3v+oo47K719SUlIxceLERbYZOXJkfpsVV1yxxmPltsn9J/mCCy6oaN26dZX7Ky877rhjxezZs7Nt58+fX/Hzn/+8xm3Tst9++2XbNaTHH398kdfRECZNmpT/3XTp0qVi3rx5S32sG2+8sU7npz699dZbFRtttFGt5yu37LvvvjUeJ53/ww47rNb3SVo6dOhQcfnll9c6pgMPPDC/ffqdLO53lbavTjoXhx56aJ1eW1pOOeWUxf6+dt111/z2d9xxR0VT/5w4+eST89u3adOm1m3r8xzmPPXUUxVDhgyp0+//hBNOWGT/uXPnVvTv379O+3fq1KniL3/5y2LHlP62cvukz8SlfQ825OdEt27dsm233Xbbah8/44wz8uN74403qjz26KOP1ut7tKysrGK55ZbL/7fliy++WOZjAgAAQEsi92149913X34MHTt2rJdjpkykV69e+eN+/vnnFU19zJVNnjw5y3PTe2Zxudryyy9f67GuuOKKfD5U05Ke5yc/+UnFnDlzajxOXTLdur6Xr7nmmiynrEtuuMUWWyz293XRRRflt//FL35RUWjpsyH3/OkzY3EeeeSRKq/x2WefLcg5zBk9enTF9ttvX6ff/ze/+c1qj7H33nvXaf80rqOPPnqxny319b3Cklp//fXzx3zhhRdq3XaPPfbItistLc0+Yxb2xBNP5I912WWXVXls/PjxFT169KjX92hjf98BADRtpYUuGAaAYpemOb/88suz9ZTFpiufd9ttt2U+7jXXXBMnnHBCtr7uuutmV3anK4NffPHF/JXPDz/8cPzyl7/Mtk3T91x77bXZlb8bb7xx1okh10Fz5MiR2fa33XZbdgV8uvK/2P33v//NOowmqZtr6u5aLJ544onsPVL5Su7U3TR1Xk1TvqWOtO+//368/vrrMW/evJg9e3a1x0nb7bjjjvHss8/m71tllVViww03zLqtTpo0KXssdQFIV9sfddRRWXfQ1OW1If3mN7/J3os5qRtpem3p6v30nkwdB9J7OL3GukrTWqWr0ZPUiSH93dWkcieT008/fZk7oS6Nyp0Xaurm2lDnMP2dp6676b2TM2TIkKwbQ7qyP+3/9ttvZ0s6H9W9v9Lf1tixY7P11BlkrbXWipVXXjnr4pCOO2bMmHjhhReyY6XX8OMf/zjr0JC6hxTz50T63Hz++efjlVdeyf4+K3faSR5//PHsZzpOOk85c+fOzbplJKlbcW3vz7pKn+Wbb7551qU7/bfl0UcfzbqXAAAAAIUh9128N998M7+eOovWh1dffTU/49Nqq61Wa7bWVMackzK81F2zcu6ZOq2mrr+pw2fK1T799NN4+eWXs1ytptw3Ofroo+OPf/xj/nbqHLrZZptl3XzTfun39NZbb2XvzRtuuCF77gcffHCZOoMuzj333JPNGpeTssI0pgEDBmR5Weoo/MEHH2TjSnlZXXPfnMV14P3Wt74VTz75ZLa+zTbbZDl7oS3ccbe292d9n8OU56Yuvp999ln+vtR9N2WIKXtPx/zoo4+y46Ysuab3V3oPJumcpS7A6e8svU/T51DqhJxm1kvZcBrXpZdeGnPmzMm6zjYl6TMidTFP0qx/KU+vTfrcTO/f1N085e2V33eVc99k6NChVR47/vjjs5w+/a5r6sa+pJbk+w4AoOUpnsoXAGgiUjCQgo1ckVgqaquPIDdNf5SCnDTVUQqmKkvTLR133HHZegp2UqCQQtwUQqTtU1ibk8aVtk1BS5IChlQEmKZZK2Yp0M5JQXexSNOLpTAmV7w7ePDgLPz67ne/u8i2kydPjjvuuCNGjBhR7bFSeJ8r/EwFminQX/i9ks5/em+kKa9S0HbaaadlU+uloLAhpOLcK664IltPfxdpKrhUTFq5qDYnBY3//Oc/o2PHjks0NVmaqqopSyHgY489lr+dCkdrUt/nMIWzBx98cL54NxXtpunq0lR9C0tT2P31r3/NvvBZWAqJ03HSuUtfMKTi3IWlsVx22WVZMXF6zYcffnjssssuWcFvsX5O7LzzzlkBb/qyIRV+p8/anLvuuiv/BUH6Iqby+/aiiy7KvphJ0wXm3v/1Ib3vUwFv7n2vgBcAAAAKR+5bu5Qp/eUvf8nf/s53vtPkc9+GGnOS8rF99tknX7ybigovvPDCOPTQQxfJ1lJxayrSTue4Oun+XOFnKpJN74sDDzxwkeOkosN0YX0qtvz3v/+dZVSp2LChnHnmmfn1I488Mi644IJqs93p06dnmVYqVF6cddZZJ/939uGHH2aZeGps0FSl85aTimZT04NCnMNU8L3nnnvmi3dTMXDKZvfbb79FsvfUcOHee+/NGgJUJ2XLxx57bNZYIo1tYalwNxWX/vSnP43x48dn+XLKJbfccstoKlJWuqC5eWRFyItr3JBy39/97nfZ+kknnZQVzaa/0SR9/5J+l5UL7nNSdn/TTTdl6+nvOT1eH4rp+w4AoPAa7pI8AGimUkBV+Ur9L774ol6Om0KXFLAsHOImKVzJhYspGPz1r3+dXf2brjivHOImKfxKoc/qq6+eD8/SVdzF7o033qjxiuimLIVDuQ4SK664YlYsWF3xbpKCytTRIAVDC0sdNm655ZZsPXUCTUFSde+VdP5//vOfx9VXX53dTkHoWWedFQ0lvZ70nkxSeJhCyeqKd5PUdSJ9qZCCwMVJX1JU7jSQe46m6Pzzz88KtXNSSF+dhjiH6feZ66yw0UYbxVNPPVVt8W6SvihKX/JUFwi3bds2C5nTeKor3k1SsWrqtnzOOedkt6dMmVLlC5Bi/JxIf28p/E7+8Ic/xAYbbJCdv/Q3+n//93/54uZTTz01v88nn3yS77yQfpepY0V9qfy+Tx25AQAAgMKR+9YuNSV477338nlJyq+aeu7bUGNOUpFf7kL9lKelQs80Y1N12VrK3r73ve/F3XffvchjqfFDeh/ktnvkkUfikEMOqfY4qRAzFSK2b98+u/373/8+Zs6cGQ0hvb9yHU/T30UqeKypMUO6wD81sUg56eKkIsqUk1d3/puadHH/P/7xj/ztn/3sZ9Vm3w1xDtP9qcA5SbOspY7g+++/f7XPn4r4U8FtTQXiqZA1nZ/qineTdMz0/rz//vvz9+W6kTcVS/o5kYqPU9fmJP2dpmYaP/nJT7IZ5VIxbSocT1Jenntfpxw+NeBIhcJbb7111uyivhTT9x0AQOEp4AWApZACk5zcP/SXVSokS9PW1ySFM5WlLpgpzK1OCnPT1f/N6Yre3PRwSZqiqxikq+hvv/32/O1UkLm0U8Cl4sKcdPV+ruiwJgcddFA+yErhceqU2xBSJ4DKHQjqSyr2zU0dlsKs9LtsStLrTgW5KRj97W9/m78/dc1N05oV4hym7iS5LwlSyHrzzTcXpBtu6tSbU1NXh2L5nEjv2TTlZC6kTR2N//znP2e/7xTUpt9rOleVp1hL01mmUD11004F+tV1Kk6dKnLdepZE//798+ujRo1a4v0BAACAZSP3rV4qOKucg6QL9Gt7TU0h923IMSeVZ3JKhdeV86MlkYou04XySSoerOni/MqFgKmJQpLywtTFtaFz3549e9bYtGFpNOUMbNasWfHmm29mmW/qWJsrtEwFoelvsxDnMOWLV155Zf52KozOFe43pDTuXKFp5RnnmoKl+ZxIzSdWXXXVbH3MmDFx4403ZjMgpo7FSWrgcOKJJ+a3T0XqqVA4dfdNxf8LS3lvyn3T+Wlu33cAAI2r9rkFAIBqVS6SS1dX14dct8fappZaku3XXnvtasONYlW540UKDItBKm7MBXypS2dNnXcXJx0jXZWfpKvkd9111zrtl67mTx0mUiFiKvSsjyn/Fla5K8ldd92VheI1fcGwJFJIlr4wyX1R8vnnn1fpzFBZbuqshpwqrvJ0cdVJ78nUnfaEE04o2DmsHOxut9122dRh9TW1YJruLnXYSMFmCuvnzZtX7ba5LhzF/DmRfnep223qRJG6Y6RjpPfe5ptvnnVgqPzlS5pK7r777st3ochNu5akYv3UBSf97tL5St020rHPPvvsbArOuqhc1J3e8wAAAEBhyX0XlQoT99hjj6wjay7nrHyhelPMfRt6zGmGplxn3+TII49c6mM99NBD+fXULKAuvv3tb8c111yTrafOrHvttVfUt5RTpS6xafavt956K8smt9hii3o7dl0ysNSJuqE77C6uMDllfD/60Y/ij3/8Y9bpthDn8IUXXsgXBHfp0iVf7FsfPvjggxg+fHh89NFH8dVXX2XFqJXz9XRfrrA4zTpXOf9vTEvzOZHGnl5rymzvvPPO7PMync/0mZs6JKcOu7mi2nHjxsXpp5+erR999NFViv3TMdJj6fueuXPnZvelmdzS7Gypo299f98BALQ8CngBYClUDm9rmnZoSVUOXqvTvXv3/Hr6h37lq9Sr06NHj2qvli9Wuauik5qm6mpqUtCWU90UeXWVrvrOvf407davfvWrOu330ksv5ddT2NYQNt100ywIS8f/9NNPs2ArdWhNU26lK/ZTILa00nnOBVqVz39TkzqfXHDBBVkXj0Kew8rvr1Tou6xSkXHqMnDJJZdkhbt1MWHChGgOnxOpE8P111+/2O4bqftusvvuu8cuu+ySfywVb6cguLIU5v7rX//KulWkqfbqUkBfeczpy5FUTJ0LkQEAAICGJ/etKuUTKQcZMWJE/nfyz3/+s15ngarv3LcQY66cy6Xi4GXpHPz888/n16+99tpslq3FqZzdNVTum3LdVASdZq9KuWEqOE3FiqnAfOutt45u3bot9bErn+emnPsmP/nJT7K8NBUzF+ocVn5/pfy9chOBpfXggw9mXYXTDGR1lbLfplLAu7SfE+kzNTVYSEttUhft9Pmf/pZzhbzJPffck3U9X7jBxSuvvBL77bdf1uAiNYZoTt93AACFp4AXAJZC7irkhQPT+pqeraYrdOu67cLb19Q9s1g1dMfVmiyuk0IKaysXZla+KnzllVde6udNV3/npCvfK0+fVVf1NeXfwlIxapqKKnWUTR0tUqh34YUXZksKNTfaaKMs0N15552zjqZLMtVaY53nhW288caxySab5G+n15mKlZ977rmsQ0GaOitdsf/xxx/HueeeW7BzWF/vryS9jlRgmjrQLon66kTTEOr7/XPeeedlXRpS0Jo6blTuypsr3k1fZFxxxRXZ+UidMw466KAsjE/dHFJXlhVWWKGgYwYAAACWjNz3a6loMxVsPvXUU9ntlPWlmYnWXXfdBnvOZc1GlnbMKev58MMPa90mZT71nculnLFyvnbdddc1mdw3SYWrabap9LtJF6unHDgt6YLz1MghzVy1/fbbx0477RTt2rWr83GbSgbWr1+/2HPPPfO302tMWV5qqpBrXHD11Vdnr//++++vtpC2Ic5hfea+yRlnnLHYGeaKKfut7/dPasCQZlfLvedzxf4p00/dj9PnbOqWe8MNN2RdqNP3AIcffnj2OXP++edn33+kv4FCjxsAaD4U8ALAEkpXxla+OnpxBVl1tSSFjUuybXORpqfKBeipE2ZjWFzR5TbbbFOlgLdywLUsHR4qf3GwLOF1Q0mv+/XXX89CwNRpNHd+UreLVMSYllT8OGTIkKxTbercUBeVz3NN05MVQio+TiHnwtI0V+nK/FtvvTW7nV7jeuutl12RX4hzWF/vrySdu1zxbvp8Sa/h+9//fjadWAqyUzidirUX/gxqaqFjQ31OpJA+FaUnp556apXpzdJ7OtfN5e67785359luu+2yUHeHHXbIxvSnP/0pzjrrrFqfp/KY0xdMuu8CAABA4ch9v5ZmBUoXJqfi11zRcMr9Ug5Y3yrnfsuS5yzLmFOm8+STT9a5gLel5L7pb2D48OFZLvbnP/85X1iaftdvvvlmtqTMK3WRPv7447NZqtJsZcWS+6aGHJXPa+XxpZnKTj755Oy1pgLPlANfddVVRZf7/uc//6lSvLvZZptlM+ilphWpu246fuXi6zSTYO5vIb32pqK+PicWloq2jzjiiGx9xx13zDpM56Tznetynroq5z5L1lhjjawz76BBg7IC7tSBty4FvE3lfQ8AND2+EQaAJZQCq9Rxs/IURjS8yoF57ur3pq5Lly759RTkLK3KYU7qFpGKJpd0qa4AtT6lTgApxBo/fnz8+9//zooct9122ypdCT744IOso8Ef/vCHxR4vXdU+ZcqUev/CpD6lMf31r3/Ngr2cn//859V2vWiIc1hf76/Ufffyyy/P377pppuyqfH23nvvGDp0aFaQWrl4t6l2XmjIz4kU4qbfU/p9HHvssVV+F6kTc5KmTFt4as3UgWTVVVfN1h9++OHFPk/6+2nK73kAAABozuS+X0vdJf/2t79l6+kC41tuuSWbgasp5zmFHHND5L7JpEmTljgzfOKJJ6Ihpbzr7LPPjrFjx8YLL7yQFfOmBg29evXKb5Py0JNOOilrCFCXC/6begaWMu0TTjihysX4qRNvdb/rhjiH9fX+SnJNCZKf/OQn8eyzz8bPfvaz+MY3vhE9e/ZcpHNyU81+Gyr3TTOrvf/++9nvYeFi7lyemxqTLHwhQCpaT3lwkvLhxZ2nYvi+AwBoPAp4AWAJpav2c1IQuOWWWzbqeFqKwYMH59crd8IopCUN2pZffvn8+siRI5f6eSsfJ3V9bcpSYJkKWlOo+9///jcmTpyY/c2kTq45KcxNgW9tPvvss3zYm7pl9O/fP5qi9BmQpkXLBbUpoE2deAtxDuvr/TVs2LB8wJimvjvggANq3f6TTz6JlvQ5cccdd2SdKnJduNu2bZt/7KOPPsp3okhBbnVy96cC9sWp/Hex0korLfPYAQAAgLqT+y5wzDHHZN1Wc6655prYf//9m3Ses6xjTrnu4rLfhsjlunXrVqWAsilnv6mz7je/+c047rjjso7FqRvv008/Hbvttlt+m3vvvTfuvPPOZpOBnXjiibHBBhvkb6ei3kKcw/p6f6ULEnLddNNnWuoUu7gu359++mm0lNx31KhRce6552brqYN0rhFDTi7PXVzum37PKSduDt93AACNQwEvACyBVIyYuozmfPe7343llluuUcfUUqSupTnpiuhiULlLx+OPP77Ux0lXw+dCwC+//DJGjBgRxSJ1K0jTTqUQPBc8pmmpFteN9N13382vp6LSFGo1VQMGDIijjz46fztdqb9wUNsQ57Dy+ysVSy+tcePG5dcrF1rX5KmnnoqW8jmRCpvT9HhJ+tLn29/+9iJTa+Z07Nix2mPkirvr0i2j8vt+vfXWW+pxAwAAAEtG7rvAKaecEpdeemn+9iWXXBKHHHJIk85zGmPMlXO5VOS3LAWFm2yySX49dUctFrki93vuuSebhSrnvvvuq3W/mTNnVmkQ0JQzsFS0fMEFF1RphJBeb0Ofw8rvr+effz5mzZq1VMdJnWpTFp/06dMnW2rzzjvvNNnZDxvi+6Ff/epX2fsxzS548sknL/J4LvtdXO5bl+y3mL7vAAAKTwEvANRRujr2wAMPrPIP8VNPPbVRx9SSVA7BXn/99SgGKbjMBTEffvjhYotWayuCrVw4+Kc//SmKTY8ePWKLLbbI304dGmpT+RxXPvdN1bHHHpuf2mz27Nnx+9//vsHP4U477ZRff+yxx6qEgEsatuekwLI2qdvstddeGy3lc+L000/POoKkqQIvvvjiRR6vPJ1dTV/U5O5Px1icYnvfAwAAQHMg910gdaKsPLPUWWedVeWi9aaY5zTWmFdcccVYY4018rfTrE1La9ddd82vX3XVVYt0+23qUkfX733ve3XOfd966638jFarrbZa1sG2KfvOd75TJddOM8819DlMBbzdu3fP1qdNmxa33HLLMue+dSkCTmNvqjbeeON89+BUaDx//vxlOt4DDzyQLza/7LLLon379jVmv4vLfeuS/cp9AYDaKOAFgDpI4e1+++0XDz74YP6+H//4x7HZZps16rhaklT8mK54T1588cVlDmgKoV+/frHvvvvmbx922GGLDTBrUnl6rssvvzweffTROu/bkFOvpe4kdTV69Oj8+uKu9k/Tr+VU7uDQVKVA9aijjqoyTd/48eMb9BymoC8XHqdQ+IADDqhTl9eFpQ4DOWlKta+++qrGbS+88MImXUBfn58T6cuEFN7mvvzp27fvItukadVyRfqV//tQeWq0l19+OVtfc801a32+9MXFc889l62nMDp9OQAAAAA0LLnvAn/84x+rFC2n6eR/+9vfFuS5119//ejVq1e2nmatqmt+2phjTnKzNiXpwu/KeeaSSJlxroj1lVdeiTPPPLPO+6ZuqWVlZdEQUuForntrS859cxf556RztHAOWN/nMM3k9otf/KJKrrw0XWd79uyZ7ySeMt+U/dYkdQ5uygW86TMizXKXK0bOZa5LI+2fy/L32GOP2GWXXardLlekn56rus+lVASctGnTJitGb27vewCgcBTwAsBiiuYuuuiirPDqjjvuyN+/+eabx5///OdGHVtLkwokc8WKKTx86aWXohj87ne/y7rPJmlqsBT+19SJd8qUKVl30xQ2L2ybbbbJOoEkqSgxhUrp2DUVbKYusGk6r9133z122223aCipEDUFZyncq6lQOI0xTWWXO2epwHKHHXao8Zjp9eUCrbZt2y420ErFjrnljDPOiMaSQvvOnTvnO9ku3LG1Ic5hKjBNgW4yfPjw2HrrrbPC1do+z1IR7sJfkvTv3z8f5O69994xbty4KtvMmTMnTjvttDjxxBOrTA3WXD8nUkF0CsnTeUrT+B155JHVbpemT8t1Vk6FzTfccEOVgtz0t5z7oqNyJ47qpCA4VzydOkos7ssOAAAAYOnJfb+W8oxjjjkmf/uII46ICy64oGDPn7qE7rzzzvnb//3vf5v8mJODDjooe78k8+bNi+9+97vZrFtpfWEpH7r//vtjzz33XOSxVGB5ySWX5G+n4s+UIX766ac15lap2DJlV4MGDapTZ9WlkbKqlVZaKctbU8fT6qTC09tvvz3LiKubNaw6lc/v4vKyb33rW/ncN603lpRPp664NXXhbYhzmHLFVVZZJVtPmeGWW24Zt912W7XdfVMWfeutt8ZPfvKTWv+20nt22LBhi+yfPgPTdul8NuXst3Kn57p8TtTWuXvUqFFZtpsuBKhJ7v2ZsvFURJ3rHJ2k73HefPPNbH277bartoPv0n7fAQC0PAvaRQFAC/XQQw9lVzjnpH+AT506NSukTKHUyJEjF9nnZz/7WRbG5IrmWpJUwJebVihn4eLD3FXQlaXulfVRRPrDH/4wnnrqqWw9FTbWpRPGIYcckhU2VjZp0qT8eipUrG7M1113XWy00UbLPOaBAwdmAVi6kjv9rtJ7KoW5aZq11EE1Ffem+z/44IN47bXXsoA3FWxWJ3V1TR09H3nkkSz0Pfnkk+Occ86Jb37zm1nQl96T6b370UcfZd1DU7CUbLjhhtGQUuFiChtTUJ5CxbXXXju7Ij69ljTe1FW08vskFYGm30tNUviWK2RMRa5NfRq1yh0NKn9ZkKbOS0FrroC7Ic7hBhtsENdff30WvqYg8NVXX83C5NVXXz0rzE3hcfpdps+z3PR0v/rVrxYJclPonAt4//Of/8SQIUOyLyDS+zR1WX7iiSdi8uTJ+XAy/S02VUvzObGwNC1dClXTlwPpi5dcV9/qpE4v6XeWwvOf/vSn8be//S37O0jv+7fffjvbJnXvPfTQQ2t9zrvvvrvKawAAAACWnty3blIBWnrduaLAVLyX1mu6mHlhKWdaXOfJukhZSMpjcnnO/vvv3+THnGZlSsWr6eLuDz/8MCuiTNlgamSQLjBPeVDK61JTh1QMm95/uW6oC0vZ3scff5wvDE2/i5Qxpdx66NChWdOAlK+OGTMmy5Brm0GrPqUcMxWjpmWFFVbIxpN+pteeOpKm11W5EcBWW22VdbSuSbrg/rHHHsvW08XrxVTImLrw5oqTUwOFlO9WblJR3+ewa9eucdddd2W/oy+//DL7PEt/F0cffXSW2/bu3TtrAJFy5NT1NxUBp0YE1WWX6W8qPZ6KVlN2nPLSlP+mfPr555/Pfx6mv6v0PUVtnXobU/qcSN81Jek1nXTSSUt8jPT6cg0uUsfulMnXJHVWvvTSS7Pf/80335x9z5R+d+n3lXsfp2x9cZ2/i/X7DgCggCoAoIXZZpttUrK3REvr1q0rdt1114pHH320Ts8xcuTI/L4rrrhijdtVfo76OmbO448/nt8+veb6cOCBBy7x7y4tN954Y708/5QpUyo6deqUHXPw4MEV5eXlDXK+05J+f/Xptddeq1hvvfXq9Nw//OEPazzO/PnzK377299WdOzYsU7HatOmTcURRxyx2PNZ0zlK9+e2Sdsv7KKLLqrz77Rt27YVZ5555mJ/V4ccckh+n/vvv3+x21d+jtNPP72iPlR+3yzJMb/88sv8ezQtp556aoOew5zHHnss+5uoy/FOOeWUao9x8skn17pf+/btK66++uo6f3alz6ncNunza2nfg4X4nKhs8uTJFX369Mn2/8lPflKnfS6++OIaf29du3ateOaZZxZ7jNVWWy3/ex4/fvwSjRkAAACQ+y6NysdqzAw15WW5LCnlOtOmTWvyY86ZOHFixZ577lmn5+7fv3+tx7r99tsr+vXrV+fXsskmm1TMnj17iTPdurzvXnjhhYrS0tI6j+X//u//KqZOnVrr6/vrX/+a3/7YY49dor/p+vqOI2W9S3vM9PvO7bvllls26DnMGTVqVMXWW29dp2NtscUW1R7jnnvuWWwWfeihh2bjqPw7r+lvpT6+V1ha6feejllSUlLx8ccfL/H+22+/fbb/0KFDK+bOnbvY7Z988smKzp07V/s7S2P44x//WO/fdwAALU+rQhYLA0BTl6avSZ1DU/fEdJV8umr/xhtvzK5MTlNcpalwaDypQ8HBBx+craernB999NEoFunq99QdNV01f8ABB2RdHtJV9KmzZ/fu3bMOqz//+c+z7iC5bhPVSdunq8zTezJN85e6+aarxNN0T23atMm6wKaurGmKrptuuinGjh0bV1xxRYO9rmOPPTY7F6kra+oykF5HGkMaS+pWsvzyy2fTm6Uxp6vbUxfn2qQuBGkqsCT9jtIV6cUkdT5I5zEnTR+XOrs09DlMnT7ef//97L2zzz77xMorr5x1dUjHS59pqbNCmlYwdaZNHX9rmjosdZ3dd999o3///tnnYRpLeu+mKcLeeOONrOtAc/+cSF2RU1eF1Dm5rlMv/vrXv846U6RO4+n3nX7vqct06gCeOlSn/57UJu2bOrXkOkmkYwAAAAD1R+7btKW87KijjsrWZ8yYEbfeemsUi5Qhpcx32LBhWXfU1HE1vdfSa0r5XOq+mrrSppwv5Xe1Sble6uKatk3dVlddddUs60rHSlnyGmusEXvttVfWKTodK3WCbaiO0WnGsJSRpdnlfvnLX2bddfv165c9X+rAm173xhtvnJ23NI5//OMf0aVLl1qPmWa9S9LrqWvH5Kakcrb9zDPPxOOPP97g5zDNkJayw5Rxpmx2zTXXzL5PyB1vnXXWyXL59PtPnV6rk2b8S7Ozpd956rzbvn377L2Z1lOOmo6fZo4rhu7j6W8sSddJ5N5PdZXey2kmtdzseSnDXZytt946y8VTzpsy/FzennLg9HtLfxvN+fsOAKAwSlIVb4GeCwBgmaVQPQVL8+bNy4KnNFUSzcdVV10Vv/jFL7L1VBScpu2C5v45kYqmU4CcgvcUpqcvdgAAAABakmnTpsXgwYNj4sSJ2QXlr732WmMPiXr0zjvvxNprr50VXv7gBz+Iv/3tb409JIpQeXl5rLXWWvHee+9lzUNSDpwKkpsq33cAAHWhAy8AUFRWWmml7Grn5L777ot33323sYdEPSkrK8s60iapG0quiyo058+Jjz76KO68885s/Uc/+pHiXQAAAKBFSt1bjz/++Gw9zWj073//u7GHRD36/e9/nxXvpu69Z555ZmMPhyLVqlWr/Pvniy++yDodN1W+7wAA6koBLwBQdE4//fRseqgU+J111lmNPRzqSeq6kKYXSy644IIszIXm/jlx7rnnZmFux44dm/Q4AQAAABraUUcdlV2YnchJmo90Afvf//73bP3www+PVVddtbGHRBHbe++9Y9NNN83Wzz///JgzZ040Rb7vAADqSgEvAFB00tRIuausb7/99nj55Zcbe0gsoxSynXbaadn6d77znfj+97/f2EOiyBXD50SaOvCWW27J1k8++eQYNGhQYw8JAAAAoNF06NAhLrnkkmz9+eefj7vuuquxh0Q9OPXUU2PevHnRu3fvOPvssxt7OBS5kpKSuOKKK7JuvJ988klceeWV0dT4vgMAWBIlFaklFQAAAAAAAAAAAABQEDrwAgAAAAAAAAAAAEABKeAFAAAAAAAAAAAAgAJSwAsAAAAAAAAAAAAABaSAFwAAAAAAAAAAAAAKSAEvAAAAAAAAAAAAABSQAl4AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQAp4AQAAAAAAAAAAAKCAFPACAAAAAAAAAAAAQAEp4AUAAAAAAAAAAACAAiot5JNRWLNnz44333wzW+/du3eUljrdAAAAQHGZP39+jB8/PltfZ511on379o09JIBGI/MFAAAAmgO5Lywg3WvGUpC7ySabNPYwAAAAAOrFsGHDYuONN27sYQA0GpkvAAAA0NzIfWnJWjX2AAAAAAAAAAAAAACgJdGBtxlLU6hVvlKhb9++jToeAAAAWJzyL7dq7CHQxHz2xfzYdOcxi2QdAC2RzBcAAIBiI/OlOnJfWEABbzNWWvr16U1B7oABAxp1PAAAALA45ZX+LQu1ZR0ALZHMFwAAgGIj82Vx5L60ZK0aewAAAAAAAAAAAAAA0JIo4AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAApIAS8AAAAAAAAAAAAAFJACXgAAAAAAAAAAAAAoIAW8AAAAAAAAAAAAAFBACngBAAAAAAAAAAAAoIAU8AIAAAAAAAAAAABAASngBQAAAAAAAAAAAIACUsALAAAAAAAAAAAAAAWkgBcAAAAAAAAAAAAACkgBLwAAAAAAAAAAAAAUkAJeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggBTwAgAAAAAAAAAAAEABKeAFAAAAAKr15ZdfxgMPPBCnnXZa7LTTTtGrV68oKSnJloMOOmiJj/evf/0r9txzzxgwYEC0a9cu+5lup/vrav78+XH11VfHVlttFb17944OHTrEKqusEocddli8/fbbSzwmAAAAAICWRO7bdJQ29gAAAAAAgKZp+eWXr5fjlJeXx6GHHhrXX399lfvHjh2bLffcc08ccsghcc0110SrVjX3HJgwYULsvPPO8dJLL1W5/+OPP45rr702br755rjiiiuyYwEAAAAAsCi5b9OhAy8AAAAAsFiDBg2KHXbYYan2PeWUU/Ih7vrrrx+33nprDBs2LPuZbifXXXddnHrqqTUeo6ysLOvakAtx99prr6yDw4svvhiXXXZZ9OnTJ+bMmZN1ZFiSzg4AAAAAAC2V3LdxlVRUVFQ08hhoIGPGjImBAwdm66NHj85aUwMAAEBTVv75ao09BJqYMePmx4objsrW5RuFd/rpp8fGG2+cLakrw6hRo2Lw4MHZYwceeGDcdNNNiz3GBx98EGuttVY2BdpGG20UTz31VDb9Wc7MmTNjm222ieHDh0dpaWm8++67seqqqy5ynBtuuCF++tOfZuu/+MUv4sorr6zy+IgRI2LDDTeMqVOnZvun46TjQXMi8wUAAKDYyHypjty3ccl9mw4deAEAAACAap155pmx6667LtOUapdeemkW4iaXX355lRA36dixY3Z/kra75JJLqj3ORRddlP3s0aNHXHjhhYs8nsLbk046KR/q3n333Us9ZgAAAACA5kru23Qo4AUAAAAAGkSa/Ovee+/N1ocOHRqbbrpptdul+1dfffVsPW2/8KRhqZtD6qyQ7LPPPln4W52DDjoov97cglwAAAAAgKZA7lt/FPACAAAAAA1i5MiRMW7cuGw9TZdWm9zjY8eOzaZsq+yZZ55ZZLvqrLDCCjFkyJBs/dlnn12msQMAAAAAsCi5b/1RwAsAAAAANIh33nknv546MdSm8uO5rgvLcpzRo0fHjBkzlnjMAAAAAADUTO5bf0rr8VgAAAAAUBTmz58fn3/+eTQHn332WfTu3TtKS2uP+gYMGBCFNmbMmDo//8CBA/PrKYRd1uOk6djSfrkp2gAAAACA5qs5Zb6J3Ldl5L4KeAEAAABocVKQWzk4bAlSsFlo06ZNy6937ty51m07deqUX58+fXqDHAcAAAAAaJ5aYuabyH2LW6vGHgAAAAAA0DzNnj07v962bdtat23Xrl1+fdasWQ1yHAAAAAAAlo3ct/7owAsAAABAi/bCvwZG3z6to9h89mVZbLrTginHhg0bFn379o2mpn379vn1uXPn1rrtnDlz8usdOnSo9TiVby/JcQAAAACA5q9YM99E7tuycl8FvAAAAAC0aCnIHdCvTRSzFOIOGDAgmpouXbrUeVqzGTNm1Dhd2sLHqS3Ire04AAAAAEDz1xwy30Tu2/xz31aNPQAAAAAAoHmqHC6PGTOm1m1Hj17QVSIZOHDgMh+npKSkSYbbAAAAAADFTO5bf3TgBQAAAKBFK4+KKI/yKMZxN3Vrrrlmfv29996rddvKj6+xxhq1Hucb3/jGYo+TwuBOnTot1bgBAAAAgOJVrJlvIvdtWbmvDrwAAAAAQIMYPHhw9OvXL1t/8skna932qaeeyn72798/VlpppSqPbbnllvn12o7z+eefxwcffJCtb7HFFss0dgAAAAAAFiX3rT8KeAEAAACABpGmM9t9993zHRJeeOGFardL9+c6KKTt036VDRkyJN+d4Y477oiZM2dWe5ybbropv77nnnvW2+sAAAAAAGABuW/9UcALAAAAADSYo48+Olq3bp2tH3XUUTFr1qwqj6fb6f6ktLQ02746xx13XPZz0qRJcfzxxy/y+EcffRS/+93vsvVVV1212QW5AAAAAABNhdy3fpTW03EAAAAAoCiVVZRnS7EpxJifeeaZGDFiRP72hAkT8uvp/sqdD5KDDjpokWOkLgq/+c1v4vzzz4/hw4dnU5ydcMIJscoqq2Th6wUXXBCvvvpqtm3abrXVVqt2LAceeGDccMMN8eyzz8aVV16ZTZv2s5/9LLp37x7Dhg2Ls88+O6ZOnRqtWrWKyy67LAuFAQAAAICWp1gz30Tu+3mLyn1LKioqKhp7EDSMMWPGxMCBA7P10aNHx4ABAxp7SAAAAFCr8s+rD3BoucaMmx8rbjiq3vONyrnJiOEDY0C/0qL83ay60egGzX5SMHvzzTfXefuaosby8vIsdE1BbE1++tOfxrXXXpsFsTVJQfLOO+8cL730UrWPt2vXLq644oo45JBD6jxmKCYyXwAAAIqNzJdC5b7NIfNN5L4tK/et+bcCAAAAAFAPUjh7/fXXx4MPPhi777579OvXL9q2bZv9TLcfeuihuO6662oNcZNevXrFc889F3/6059iyy23jJ49e0b79u1j5ZVXzoLil19+uVmGuAAAAAAATY3cd9npwNuM6cYAAABAsdGNgYXpwNu4nRiApkXmCwAAQLGR+VIdHXhrJvdtWYrzXQoAAAAA9aQ8KrKl2BTjmAEAAAAAGlqxZr5JsY6bpVN7b2IAAAAAAAAAAAAAoF4p4AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFVFrIJwMAAACApqYiyrP/FeO4AQAAAABoHplvIvdtWXTgBQAAAAAAAAAAAIACUsALAAAAAAAAAAAAAAXUrAp4hw8fHmeddVbssMMOMWDAgGjXrl107tw5hgwZEgcffHA888wziz3GTTfdFCUlJXVa0rZ1MWPGjLjyyitju+22i/79+2fjWn755WODDTaIo446Kh555JF6ePUAAABAQ3l/xNy44vopcfCvvoj1tv002g4YEa37johzL5m02H0ffWpm7PLDcdFnzY+j0+CPYs0tP4lTfzcxps+ofRqsESPnZs83aIOR0WHFEdnPdPvjT+bVuM/f75oW62zzabb9ShuOijMvmhhlZRXVbjtjZnmsvPGoWPdbn8bcudVv01KUVVQU7QItgdwXAAAAaAhy3+arsXNbuS91VRrNxNZbbx1PP/30IvfPnTs3Pvzww2xJwesBBxwQf/7zn6Nt27YFGdfjjz+ehciffPJJlfu//PLLbHn11VezcafwGQAAAGiarr75q7jsuq+WeL9Lr5kSx54xIUpKIrb6Zvvo07s0nnlxVvzusslx14PT46l7B0Svnq0X2e/ZYbPiu/uNi5mzKmKt1dvGFpt0iLffmxu33DEt7nxgejxyR//YdMP2VfZ54D8z4sdHfBHdu7WKnbfrFK+/PSfOunhyTJxcHped23uR5/jt+RPj07Hz46l7+0fbtiVL/NoACkHuCwAAADQUuS/Q2JpNAe+4ceOyn/369Yu99947ttpqqxg0aFCUlZXF888/HxdffHGMHTs2brnllpg3b178/e9/X+wxH3744ex4NUndHmrz6KOPxve+972YPXt2dOvWLQ4//PD41re+FX369ImZM2fGu+++Gw888EB88cUXS/GKAQAAgEJZa2jbOPbn3eIba7eLDdZplwWxf/3ntFr3efXNOXHcmROideuIe2/uGztt1ym7f+bM8tjjoM/isadnxc9P+DL+cV3fKvulx/c77PMsxD3xqO5x7sk984+dct7EOP/yybHfoZ/Hu88Mig4dvp5c6fTfT4xUt/bcAwNiyCpts04Lm+w4OguhT/5V91ihz9cx0PDXZscVN3wVhx+4XGy+cYd6/E0B1C+5LwAAANBQ5L5AY2s2BbxDhw6N8847L77//e9H6/QJWcmmm24aP/7xj2OLLbaIDz74IG699dYsVE3dG2qTpmBbaaWVlmo848ePj/322y8Lcb/xjW/Ev//972z6tMrSeA455JCsWwQAAADQdB3yw+Wq3G71dX5aoxS4ppmuDtq3az7ETTp2bBV/vrhPrLrpJ3HXgzPivQ/nxtDVvu4YefMd02Lc52UxZJU2cfaJPaocM92+66Hp8cFH8+KWf0yLww5YMK40Fdqb786NbbfokIW4SaeOreKH3+8Sv71gUgx7dU7stuOCGChNrXb4b8bHCn1ax3mVQmKApkjuCwAAADQUuS/Q2OrwsVMcUkeDffbZZ5EQN6dXr15ZN4acf/7znw06npNOOikmTpwYHTt2jHvuuWeRELeyQk3rBgAAABRGClYfenRGtr7/Xp0XeXzFgW1ii40XTIV2z7+mV3ns7v/d3nf3ztGqVdUpztLtfXZbcLy7H/p6vylTy6KsLKJH96q5SO729Bnl+fsuvXZKvPrWnGx6ta5dmk00tEzKo6JoF2ju5L4AAABAUyH3LR6NndvKfamrFvXXuu222+bXP/roowZ7nsmTJ+enavvRj34UK664YoM9FwAAAND0fPDx3GwqtGSj9RYEtgvbcL122c9X36raofG1N+f87/Ga9ltw/2uV9uvTqzQ6dijJujpUlrvdf4UFXRhGjZ4XZ1w4KfbYqVPssdOiATNAMZL7AgAAAIUg9wXqW4sq4J0zZ8EHYVJTx4b66goxa9asbH233XbL3z9z5swYMWJEfP7551GReqkDAAAAzdLIT+dnP7st1yq6dK4+fhnYr032c9Sn8/L3TZteHhMnL+iaMKh/aQ37Lbh//MSymDHz6w4L39uxU7zxzty45OrJMXVaeTzyxMy46fap0adX69h0wwXh7y9OGB+lpSVx+Xm96+21AjQ2uS8AAABQCHJfoL61qALeJ598Mr++xhprLHb7gw8+OPr165dNdZamYtt0003j1FNPjbFjx9a63wsvvJBfX2eddeKll16KHXbYIbp06RKrrbZa9O3bN5ta7cgjj4wvvvhiGV8VAAAA0NSkQDbp1LHqVGiVdeq04LGp/9u28n617dv5f/tl+077evvzTu4Zy/duHcedOTG6D/k4dtp/XMyeUxHXXNQn2rUriVvvnhYPPz4zzjulZ/T7X2eGZPbs8igrU3AGFC+5LwAAAFAIcl+gvlVf0t8MlZeXx/nnn5+/vc8++yx2nyeeeCK/PnHixGx58cUX4+KLL45LL700DjvssGr3e+edd/Lrjz/+eBxyyCExf/6CKzByxo8fH1deeWXceeed8e9//zvWW2+9JX5NY8aMqfXxzz77bImPCQAAABSnlQa2iTceHxQ33jY1Roycl4W6P9irSwxdrW1MnlIWvz5tQmyxcfs4/ICu2fa33zstm1btg4/mRZs2Ed/ZumPWoWHwoAUdIlqSFIeXRfGF2V/H+NByNbfcV+YLAAAAVCb3bVmZbyL3bVlaTAHvJZdcEsOGDcvW99prr9hwww1r3HbllVfOttlss81i4MCB2X0ff/xxFrr+85//jNmzZ8fhhx8eJSUlceihhy6y/6RJk/Lrue3OOeecOOCAA7IODGk6tQsvvDBuuummbFq1PfbYI15//fXo2nXBB2ld5cYGAAAANC256dNmzKw5IJwxY8FjXStNtVZ52rWa9p3+v/2yfbtUnVypV8/W8Zsjui+yz2/OmhBTppbF1Rf2z3KKe/89PX5w+Bex5Sbt49yTesbnX86PU8+fFNt9f2y88cSg6NypRU3aBBSx5pb7ynwBAACg6ZL7AvWttKVMoXbiiSdm63369Imrrrqqxm333HPPOPDAA7MPtco23njj2HfffeOBBx7IQt558+bFMcccE7vttlussMIKVbadMWNGfj2Fvrfcckv8+Mc/zt+35pprxo033phN0XbttdfGqFGjsjGdcMIJ9fiqAQAAgMay0sAFkcuUr8qz6dEqB7Q5o8fNy36u+L9tk7Rdj+6tYtLk8vh07PxYb6121ey3oNtjrx6tolPHxQeuTz43K266bVqcekz3WHP1ttl9v79icjZV2z03943u3Vpn97VqVRJHnDg+/n7XtDj0x8st9WsHKBS5LwAAAFBIcl+gvjX7svq33347C2fTVGbt27ePf/zjH1mYW5PllltukRC3sl133TVOO+20bH3mzJlx/fXXL7JNep6cddddt0qIW9l5550X7dot+EC+/fbbY0mNHj261iXXeQIAAAAorNVXaRsdOyzIF4a/PrvabV5+fU72c4N1qoa16//v9ss17je7yna1mTOnIn5+/Jex+ipt4qRf9sjf/9rbc2ON1drmQ9xky28uyDNef3vBuACasuaa+8p8AQAAoOmS+wL1rVkX8I4cOTJ22GGHmDx5crRu3Tpuu+222HrrrZf5uGn6tFzYm7o8LKxLly759fT8NenZs2dstNFG2XqaSm3u3LlLNI4BAwbUuvTt23eJjgcAAADUj7ZtS2Ln73TK1m+9a/oij38yel48N3xBILvHTp2rPLbn/27ffu/0KC+vOp1aun3HfQuOt+fOVferznl/nBQffDwvrvp9n2jX7uvCtbQ2Y2Z5lW1zU7fVVuDWXJVHRdEu0BI159xX5gsAAABNl9y3eDR2biv3JVp6Ae+4cePiO9/5TvYzfQDdcMMNsfvuu9fLsVMnhxTCJmPHjl3k8YEDB1a7Xp3c4+Xl5TFp0qR6GR8AAADQ+E44slukTPSm26fGv//79bTrM2eWx8+O/TLKyiL22qVTDF1twfRmOQfu0yX6rdA6PvhoXpx2QdWsIN1O9w/oVxoH7P11IVl13nl/bvz+ysnx0x90ja0361DlsdT94d0P58Wzw2bl7/vzX7+qc4cHgMYi9wUAAAAak9wXqE+l0QxNmDAhtt9++/j444+z25dffnkccMAB9foctV2VsNZaa2VTtiVl6VO5FpUfLy1tlqcDAAAAit4rb8yOI08an7/90ah52c9r/zo1Hnz065D2zhv6Rt/lF/z7foN128dFp/eKY8+YELv+6LPYZrMO0btX63jmxVnx2Rdl2fRmV12w6HTvHTu2ituuWSG+u9+4+N1lk+P+R2bEWkPbxtvvzY233psbnTqWxO3XrhAdOtR8XXZFRUUc/psvo0e31nHBbxcUo1V28tHdszHtuO+4+M42HeOLL+fHsFfnxKqD28T+eyy+wwNAY5D7AgAAAPVJ7gs0tmaXHH711Vex4447xjvvvJPdPv/88+OII46o1+cYP358FhYn/fr1W+TxytO15cLkmnz00UfZz/bt20ePHj3qdZwAAABA/Zg6vTxefGXOIvePGTc/W3LmzK06tdXRh3WLtddoG3+4ekq89NrsbLqyQf1L48SjusaJv+weXTpXH8ZusUmHePWxgXHOJZPjsadnxl0PTo/ePVvHj/fuEr/9dY9YZaU2tY732r9MjWdfmh23XbtCdFuu9SKPf/fbneKem/vGOX+YFA8/PiM6dmgV++7ROQueU5AM0NTIfQEAAID6JvcFGluzKuCdOXNm7LLLLvHKK69kt0855ZQ44YQT6v15rr322uyKhmSbbbapNsjt3bt3Fvjef//9cemll0br1ot+aI4cOTJee+21bH2LLbaIVq18UAIAAEBT9K3NO0bZZ6su1b7f2bpjtiypVQe3jZsuW36pnvOwA5bLltrsun2nbCGirKIiW4pNMY4ZlobcFwAAAGgIct/mq1gz36RYx83SaTbJ4dy5c2PPPfeMZ599Nrv9q1/9Ks4555wlOsaoUaPi1VdfrXWbBx54IM4666xsvUOHDnHwwQcvsk0KbY877rhs/ZNPPomzzz57kW3mz58fv/jFL6K8vDy7ffjhhy/RWAEAAAAAmju5LwAAAADQXDWbDrz7779/PPLII9n6t7/97fjpT38ab731Vo3bt23bNoYMGbJIkLvtttvGZpttFt/73vdivfXWiz59+uSnRPvnP/+ZLbkuDBdddFH079+/2uP/8pe/jNtvvz3rCnHmmWfG+++/HwceeGB2vDR92iWXXBLPP/98tu3OO+8c3//+9+vtdwEAAAAA0BzIfQEAAACA5qrZFPDedddd+fX//ve/se6669a6/YorrpgFt9VJAWsuZK1Ox44dsyD20EMPrXGb9u3bZ10bUiD88ssvx2233ZYtC0shbrq/pKSk1vECAAAAALQ0cl8AAAAAoLlqNgW89WHDDTeMv/71r1mIO3z48Pjss89iwoQJ2bRn3bt3j7XWWiu22267OOSQQ/IdGmrTt2/feOGFF+L666+PW2+9Nd55552YMmVK9OzZMzbZZJM46KCDsunfAAAAAGg8aaL7BZPdF5diHDM0BrkvAAAAQMtSrJlvFPG4aeEFvLnpzZZFly5d4oc//GG21JfS0tI47LDDsgUAAAAAgLqT+wIAAAAAzVWrxh4AAAAAAAAAAAAAALQkCngBAAAAAAAAAAAAoIBKC/lkAAAAANDUlEdFlEVFFOO4AQAAAABoHplvIvdtWXTgBQAAAAAAAAAAAIACUsALAAAAAAAAAAAAAAWkgBcAAAAAAAAAAAAACqi0kE8GAAAAAE1NWVoqoijHDQAAAABA88h8E7lvy6IDLwAAAAAAAAAAAAAUkAJeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEClhXwyAAAAAGhqyv+3FJtiHDMAAAAAQEMr1sw3injcLB0deAEAAAAAAAAAAACggBTwAgAAAAAAAAAAAEABlRbyyQAAAACgqSmPkiiLkijGcQMAAAAA0Dwy30Tu27LowAsAAAAAAAAAAAAABaSAFwAAAAAAAAAAAAAKSAEvAAAAAAAAAAAAABRQaSGfDAAAAACamvKKBUuxKcYxAwAAAAA0tGLNfJNiHTdLRwdeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggEoL+WQAAAAA0NSURUm2FJtiHDMAAAAAQEMr1sw3KdZxs3R04AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAAqotJBPBgAAAABNTVmUZEuxKcYxAwAAAAA0tGLNfJNiHTdLRwdeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggEoL+WQAAAAA0NRUVESUV5REMY4bAAAAAIDmkfkmct+WRQdeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggEoL+WQAAAAA0NSURUm2FJtiHDMAAAAAQEMr1sw3KdZxs3R04AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAAqotJBPBgAAAABNTVm0ypZiU4xjBgAAAABoaMWa+SbFOm6WjrMNAAAAAAAAAAAAAAWkgBcAAAAAAAAAAAAACkgBLwAAAAAAAAAAAAAUUGkhnwwAAAAAmpqKipIoryiJYhw3AAAAAADNI/NN5L4tiw68AAAAAAAAAAAAAFBACngBAAAAAAAAAAAAoIBKC/lkAAAAANDUlEVJthSbYhwzAAAAAEBDK9bMNynWcbN0FPACAABQcOWfr9bYQ6CJunLKwMYeAk3M5KmzI2JUYw8DAAAAgFrIfKnJKncc3thDoAmaP2VKRJzT2MOARteqsQcAAAAAAAAAAAAAAC2JAl4AAAAAAAAAAAAAKKDSQj4ZAAAAADQ1ZRWtsqXYFOOYAQAAAAAaWrFmvkmxjpul42wDAAAAAAAAAAAAQAEp4AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFVFrIJwMAAACApqY8SqK8CK9zT+MGAAAAAKB5ZL6J3LdlKc53KQAAAAAAAAAAAAAUKQW8AAAAAAAAAAAAAFBACngBAAAAAAAAAAAAoIBKC/lkAAAAANDUlEdJlEVJFOO4AQAAAABoHplvIvdtWXTgBQAAAAAAAAAAAIACUsALAAAAAAAAAAAAAAWkgBcAAAAAAAAAAAAACqi0kE8GAAAAAE1NWUWrbCk2xThmAAAAAICGVqyZb1Ks42bpONsAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggBTwAgAAAAAAAAAAAEABlRbyyQAAAACgqSmPkmwpNsU4ZgAAAACAhlasmW9SrONm6ejACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAApIAS8AAAAAAAAAAAAAFFBpIZ8MAAAAAJqa8mgVZUV4nXsaNwAAAAAAzSPzTeS+LYuzDQAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAApIAS8AAAAAAAAAAAAAFFBpIZ8MAAAAAJqasopW2VJsinHMAAAAAAANrVgz36RYx83ScbYBAAAAAAAAAAAAoIAU8AIAAAAAAAAAAABAASngBQAAAAAAAAAAAIACKi3kkwEAAABAU1MeJVFehNe5p3EDAAAAANA8Mt9E7tuyFOe7FAAAAAAAAAAAAACKlAJeAAAAAAAAAAAAACig0kI+GQAAAAA0NeUVJVFWUVKU4wYAAAAAoHlkvonct2XRgRcAAAAAAAAAAAAACkgBLwAAAAAAAAAAAAAUkAJeAAAAAAAAAAAAACig0kI+GQAAAAA0NWXRKluKTTGOGQAAAACgoRVr5psU67hZOs42AAAAAAAAAAAAABSQAl4AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQKWFfDIAAAAAaGrKK1plS7EpxjEDAAAAADS0Ys18k2IdN0vH2QYAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAAqotJBPBgAAAABNTVm0ypZiU4xjBgAAAABoaMWa+SbFOm6WjrMNAAAAAAAAAAAAAAWkgBcAAAAAAAAAAAAACkgBLwAAAAAAAAAAAAAUUGk0I19++WUMGzYsW1566aVsmThxYvbYgQceGDfddNNijzFz5sz497//Hf/5z39i+PDhMWLEiJg+fXp07do1hgwZEjvuuGMcfvjhscIKK9RpTOlY6XnTmD7//PMoLy+P3r17xwYbbBA/+MEPYu+9945WrdRRAwAANAXvj5gb/3lyZrz8xpx45Y058e6Hc6OsLOKs43vEKcf0qHXfR5+aGZdcMyVeenV2zJhVESv2L429dukcJ/6ye3TuVPO/+0aMnBvnXjo5Hnt6ZoyfWBa9e7aO7bbqGL/9dY9YecU21e7z97umxe/+ODlGjJoby/cqjYP37xKnHtMjWrcuWWTbGTPLY51tPs3GMPyRgdG27aLbsOwmjZsdj13/abz/3KSY/NmcqKiI6Nq7bay6UbfY9qCB0X9o58Ue4+m/j41/nP1Btr7p9/vGD84Zusg2c2aWxb0XfRSvP/JlzJpWFv2HdorvHbNKDNm0e7XHfOvxCXHtL96MXY8eHDsctlI9vNLmqTwiyipKinLc0BLIfQEAAFgWcl+Wxvi/3RYzhg2vdZtBF/0uWrVZ9HzOGT0mvnr0vzF7xMdRPnt2lHbtEh3WWjO67fidaN2lS7XHmvrE0zH16Wdi/uQpUdq9e3T91lbRdastqt12/pSvYuzvLox2Kw6KFX5x6FK+wuatWDPfRO7bsjSrAt7ll19+mfZ/4403YosttsiC24VNmjQpXnjhhWy55JJL4tprr4199923xmPNmTMnfvjDH8add965yGNjxozJlvvuuy+uvPLK7Ge3bt2WaewAAAAsu6tv/iouu+6rJd7v0mumxLFnTIiSkoitvtk++vQujWdenBW/u2xy3PXg9Hjq3gHRq2frRfZ7dtis+O5+42LmrIpYa/W2scUmHeLt9+bGLXdMizsfmB6P3NE/Nt2wfZV9HvjPjPjxEV9E926tYuftOsXrb8+Jsy6eHBMnl8dl5/Ze5Dl+e/7E+HTs/Hjq3v5C3AYy6vWv4sqfvh5zZpTFcsu3i9W36BGpZmvse9Nj2L2fx/AHv4gDL1wz1v9unxqPMWH0rLj34o+y91Aq/q3JX096N15/ZHz0Xa1TrLheh6xg+E8/ez1+9Zf1Y/A3lquy7ZwZ87OC4H5DOsV2PxlUny8ZoKDkvgAAACwLuS/Lot3glaK0d69qHyup5uLdGa+9HuNv/ltEeXm0HTQwSnv2iLmfjolpTz8bM157I/r+6ohos9Dxpj71TEy6+95o3bVrdFxrjZgz6pOY9M+7o2LevFju299a5DnSY1FeFj33+X49vlKgMTSrAt7KBg0aFEOHDo1HHnmkzvtMnTo1H+KmQHfXXXeNjTbaKHr27Bnjx4+Pu+66K/785z9n26WQNnVn2Gmnnao91i9/+ct8iNunT584/vjjs+4Lbdq0iTfffDMuuOCC+OSTT+Lpp5+O/fbbL+vYAAAAQONaa2jbOPbn3eIba7eLDdZplwWxf/3ntFr3efXNOXHcmROideuIe2/uGztt1ym7f+bM8tjjoM/isadnxc9P+DL+cV3fKvulx/c77PMsxD3xqO5x7sk984+dct7EOP/yybHfoZ/Hu88Mig4dvg4BT//9xGjbNuK5BwbEkFXaZp0WNtlxdBZCn/yr7rFCn6//qT/8tdlxxQ1fxeEHLhebb9yhHn9TVHbb6e9nxbub79Mv9j51tWjdZsH5Ki+viH9dPjIevvqTbJu1t+0ZbdotGuin7f520ruRYvaNd18hht3zebXPM+bdaVnxbuq2+4vr1otWrUvi/ecnxZU/eT0eufqTOOzqdats/8AfR8aUL+bEQX9YKz8mgGIn9wUAAGBJyX1ZFp03+2Z0+ebGddp2/ldfxYS/3ZYV7/bc9/+iy+abZvdXlJdn988Y/kqMv+Vv0ffXv4ySVBn+v8em/Ps/0apTp+h3wrHRunOnKJs2Lcaed2F89chj0XWbraIkvRH/Z8brb8bMN9+K7rvtEm16ff3+AopTsyrgPe2002LjjTfOltSVYdSoUTF48OA675+mNNtnn33i9NNPjzXXXHORx3fYYYcsuN1zzz2jrKwsjjrqqPjwww/zH6g5X3zxRVx33XXZevfu3ePll1+OAQMG5B/fcsstsyB4vfXWy8b48MMPZ9O2pdAYAACAxnPID6t2MK3LzNcpcE0dUw/at2s+xE06dmwVf764T6y66Sdx14Mz4r0P58bQ1drmH7/5jmkx7vOyGLJKmzj7xKrTtKXbdz00PT74aF7c8o9pcdgBC8Y1d25FvPnu3Nh2iw5ZiJt06tgqfvj9LvHbCybFsFfnxG47LvinfllZRRz+m/GxQp/WcV6lkJj6NWPyvBj3/oxsfZdfDa5SKNuqVUnsdOTg+O9No2PW1Pnx+UczY+Cai06P9uQtY+Kjl7+KvX87JKZNmlvjc41+e8GXCpt+v29WvJusvlmP6D2oQ4x8rWoHkU/enBpP/W1MbLV//0U68wIUG7kvAAAAy0LuS6FMfeLpqJg7L9oPWS1fvJvr1Ju65c58+52Y++nomP3eB9FhjdWzx+ZPmhTlM2ZkhcKpeDdp3aVLdFxvnZj+/Isx7/Mvom3/ftn95bNnx6Q778lud/3W1o30KoH61Kzar5x55plZ94SlnVJt8803j9tvv73aEDdn9913j7322itb/+ijj+LVV19dZJsXX3wxysvLs/WDDz64Soibk7o4HHPMMfnbzz///FKNGQAAgMaTgtWHHl1QvLn/Xp0XeXzFgW1ii40XTIV2z7+qTtt99/9u77t756zQs7J0e5/dFhzv7oe+3m/K1LIoK4vo0b1qF9fc7ekzFvxbNLn02inx6ltzsunVunZpVv/8b1JKl2B6us7d2yxy3xcjZ8YDf/w4Vt24W2y5/4IQtiYzpszLfnZcrur12B27tYk5M8vyt8vml2cdf5fr0y52PWblOo+vJSuPVkW7QEsg9wUAAKCQ5L4srZlvvJX97LTh+os81qpdu+i49lrZ+ow33szfXz5j5oLHO3asuv3/bpfP/brpw+QHHsq68/bcb+8qXXlZVGPntnJf6srZXgrbbrttfj2FuQubW+mDc+WVa/6ibJVVVql2HwAAAIrDBx/PzaZCSzZab0Fgu7AN12uX/Xz1rar/7nvtzTn/e7ym/Rbc/1ql/fr0Ko2OHUqyrg6V5W73X2FBYeeo0fPijAsnxR47dYo9dlo0YKb+tOtUGqtsuKBTxoN/HBll874O08vLK+JfV4yMebPLY82tekT3vlXPdXlZRfz1xHcjNXjc/5yhi3R6XFiP/gumw/viowWBbpKeb8Kns7Ji3ZzHbxodY9+dnnX0bd+pWU2+BNCg5L4AAAAkcl8qm/3hiJh0930x4bZ/xOT7H4oZr78ZFfPnL7Jd6o47f8KEbL3doIHVHqvdwAUXA88dMzZ/X2mP7tnPeV98WWXb3O3S5bouGMeoT2LaM89H1623rPH4QPHxLc5SmDNnwX9sk9bVXM2w+uoLWpwnH3/8cY3HqRwCV94HAACA4jDy0wUhXbflWkWXztVfIzuw34Kuq6M+XdA9NZk2vTwmTl5Q6Dmof/X/NB/Yb8H94yeWxYyZ5dmUacn3duwUt98zPS65enL89IfLxQsvz46bbp8afXq1jk03XBD+/uKE8VFaWhKXn9e7Xl8v1dvv7KFx9WGvx3N3jIu3n5wYg9buknXTGPPutJjyxZzYeLfl4/9+O2SR/R674dP45I2pseeJq0bvQQuKc2szZNNu0a5T6/jvTaNj5Q2Xi94rdoiHr/ok68y70fcWdKWcOGZW/PtPo+IbO/aOdb7dq0FeL0BzJfcFAAAgkftS2YyXXl7kvtZdu0bPH+wTHdcYmr9v/qTJ+fXS7t2qPVbrbgvunz9x0tf3dekS7VZaMWa9825Mf+XV6LjmGjHz7Xez22369Y3SHj2ioqwsJt72z2jdvVt023nHen6FQGPSgXcpPPnkk/n1NdZYY5HH11lnnWxatuSmm26KcePGLbLNtGnT4tJLL813a9hhhx0adMwAAADUvxTIJp061tw5tVOnBY9N/d+2lferbd/O/9sv23fa19ufd3LPWL536zjuzInRfcjHsdP+42L2nIq45qI+0a5dSdx697R4+PGZcd4pPaPf/zozJLNnl0dZ2YKuEdSv5Qd3jF/fumEM3aJ7fPXFnHjzsQnx+n/Gx8Qxs7PC3FU36R4dOlcN7Md9MD0eunxkDF6/a2zz40WnYK9O5+5tY7djV8me4+J9Xo4Tv/lM1m13+VU6xk5HrJRtc/uZH0Tr0lbx/ZNXq7Lv3Fll9fiKAZonuS8AAACJ3Jekbb9+0WOv3aPficfFoAvOiYHnnB7L//zQaDd4pSibOjW+/PONMevDEfntyytdGFzStm21x2zVrl2+W29lPb6/R5S0aRMTbv5bfHrCqTHhlr9lx+i1397Z41/994mY99ln0XPvvfLHyI4zd15UVDj/UMx04F1Cr7/+ejz44IP5wLa6IDe58cYb47vf/W6MHDkyNthggzj++OOzn6WlpfHWW2/F73//++yxXr16xd/+9rdoW8MHd23GjBlT6+OfffbZEh8TAACApm2lgW3ijccHxY23TY0RI+dloe4P9uoSQ1drG5OnlMWvT5sQW2zcPg4/YMG0WrffOy2bVu2Dj+ZFmzYR39m6Y9ahYfCgBR0iWHYfvzIlrv/lW9GqdUkceNGasdo3u0dpm5L4+JWv4u4LRsStp74XI1/5Kn5w7oJuDGXzy+OvJ72bden9wblrZD/raqv9+8eANTpnBcKzp5dF/9U7xzf3XCHadmgdL93/ebz3zKTY98zVY7k+7bKi3Xsu/CiG3/95tm2n7m1iy/36xU5HDM7GytfKKlplS7EpxjFDU9VUcl+ZLwAAQMsk9216ltt266p3tG8fHYZ2ifarrxZfXn9TzHrz7Zh0933R//hfL/NztRs0MPqfeGxMHzY85k/5Kkq7d4/Om2yUdfKdN2FCfPXwo9Fpg/Wz7rzJ1Keeia8eezzKpnyVFf52XGft6PF/e0TrTp2WeSzNRbFmvkmxjpulo4B3CadQO+SQQ6KsbEHXmnPPPbfGbYcMGRIvvfRSXHXVVXHBBRfEscceW+XxNm3axHHHHRe/+tWvYsCAunXaWdjAgQOXaj8AAADqR276tBkza77CfcaMBY91rTTVWuVp12rad/r/9sv27VI1rOnVs3X85ojui+zzm7MmxJSpZXH1hf2jpKQk7v339PjB4V/Elpu0j3NP6hmffzk/Tj1/Umz3/bHxxhODonMnIdCymjl1Xlx31FsxY/K8OObWDWKl9ZbLP7b2tr1ihVU7xfm7D4sX7vosNtpt+Rjyze7xyDWfxJh3psdux66cde9dUoO/sVy2VDZjyry4+/wRscqGy8Xme/fN7rvl+Hfizf9OiG8fPChW3nC5ePPRCfHwVZ/E3FnlsecJq9bDqwdoHppS7ivzBQAAaHxyX2qTzkH3nXbMCnjnjR0X8ydPyQptK3fGrZg7N0o6dFhk31yX3lbt2y/yWGmPHtHtu4vO5DPx9juzIt0ee+2W3Z765NMx6a57o8M6a0WX/9sz5n7+RUz51yNZoW/fY46KklbOPxQTBbxL4Mgjj4zhw4dn6wceeGB873vfq3X7+++/P+uyMH369EUemzdvXtxxxx3Ru3fv+M1vfpN9uAMAAFBcVhq44J/VU74qz6ZHqxzQ5oweNy/7ueL/tk3Sdj26t4pJk8vj07HzY7212lWz3/zsZ68eraJTx8UHbk8+Nytuum1anHpM91hz9QXd/n5/xeRsqrZ7bu4b3bu1zu5L3V6POHF8/P2uaXHoj6sWgbLk3n5yYkyfNC96DepQpXg3p9fADrHiul3jwxenxAfPT84KeN94dEL22FtPTIx3nppUZftJYxdMnfbOkxPjsgNezdZ/ecv6ix3HPb8fkXXZ3e+s1bOM4YuRM7Pn2XDX5WP341bJtlln217x2YgZ8dTfxsTOR64U7TqJhQASuS8AAACVyX1ZnDbL98mvz5+yoIC3tMfXxdepqLdtNQW8ZVOmZD8rb1ub6cNeitkffBg9998nWnfpkt331aOPR+se3aPPwQdESevWWffd8lmzY+pjj2fbdhi6ej28QqBQlNzX0e9+97u47rrrsvWNN944rrzyylq3T50XDj744Hjvvfdijz32iGeffTYLdGfNmhWvvPJK9tinn34aJ5xwQvzf//1fvrvDkhg9enSty7Bhw5b69QIAALB4q6/SNjp2WFCYM/z1BYWXC3v59QVX1G+wTtWwdv3/3X65xv1mV9muNnPmVMTPj/8yVl+lTZz0yx75+197e26ssVrbfIibbPnNBVf2v/72gnGxbCZ/tuD32L7T17/jhXXoXJrvklvZxy9/FSNemlJlmTRuwXmfOmFu/r7F+eDFyfHi3Z/H9ocOiuVXXjBF2th3p2U/B39jwZR6OalDb9m8ivj8o5lL/FoBmqOmlvvKfAEAABqf3JfFKZvxdb6a67ybuuqW9uqVrc/5dHS1+80ZPSb72Xbg4mftKZs+Iybdc3+0X22V6LLpJgvumzotyqZOjXaDBmbFuzntVx6c/Zw7dtwyvS6g8LRaqYNrrrkmTj755Gx96NCh8dBDD0WnTgu+EKvOgw8+GH/4wx+y9YMOOihuvPHGKo+vv/76ccMNN2RTqJ199tlx1113xZ/+9Kc46qijlmhcSzMFGwAAAPWnbduS2Pk7neKf90+PW++aHttu0bHK45+MnhfPDV8QyO6xU+cqj+25U+d47KlZcfu90+O0Y3tkHRJyyssr4o77FnT123PnqvtV57w/TooPPp4X/72zf7Rr9/Vx0tqMmeVVts1N3aYjYP3o1mdBOJs63s6aNj86dKkatZTNK4/R7ywopu05YEGIfsLdG9d4vIeuGBn/vnJUbPr9vvGDc4Yu9vnnzS2PO854P5ZfpWNs/7MVv37gf+d37qyqhWNzZv7vttNfRXmUZEuxKcYxQ1PSFHNfmS8AAEDjk/uyODNeeS37WdK+fZVuvB3XXTum/veJmPHyq/mi25zyOXNi1lvvZOud1l1nsc8x6Z77omLu3Oi5z/99fef/Tm/FnLlVtk3b0Twy36RYx83S0YF3MW699db4xS9+ka2vuOKK8Z///Cd6/e9qiZrkOjak/yiec845NW6XwuHOnRf8BzkFuwAAABSfE47sltVK3nT71Pj3f2fk7585szx+duyXkRrv7bVLpxi62oLpzXIO3KdL9FuhdXzw0bw47YJJVR5Lt9P9A/qVxgF7L5gWqybvvD83fn/l5PjpD7rG1ptVnZIrdX9498N58eywWfn7/vzXr+rc4YHFW2PrHtG2Y+uYN7s8bj3tvZgzY8EUeMn8ueVx1/kjsi69rduUxDd2/DrIrS8P/2lUjP9kVux/1upR2vbrmGfgmgvyhuEPfBFzZy8o2p0+eW688ej4aNOuVaywSs0FagAtgdwXAACA2sh9W7Y5Y8bGzDffjoqFZtapKC+Pac+/GFMefCi73XXrLat0wu36ra2ipG2bmP3BhzHtuReq7DfxH3dF+axZ0XbQwGg/dEitzz/r/Q9ixksvx3I7bB9t+vTO39+6S5do3W25mD1iRMybMOHrMb24YMaeti4MhqKjA28t7rvvvjjggAOivLw8+vbtG4899lidOiC8++672c8+ffpE//79a9yuffv2sdZaa8WLL76YTbkGAABA43rljdlx5Enj87c/GjUv+3ntX6fGg49+HdLeeUPf6Lv8gn9Sb7Bu+7jo9F5x7BkTYtcffRbbbNYhevdqHc+8OCs++6Ism97sqgsWLdzs2LFV3HbNCvHd/cbF7y6bHPc/MiPWGto23n5vbrz13tzo1LEkbr92hejQoeZrbysqKuLw33wZPbq1jgt+23ORx08+uns2ph33HRff2aZjfPHl/Bj26pxYdXCb2H+PxXd4YPG69Ggb+54+JP52ynvx2r/Hx4hhU2LQ2l2idZtW8elb0+KrL+ZESauI75+8WvQaWDVoX1affTgjHrvh09h8n36x8gbdqjzWe8WOseEufeLlB7+M331vWAxYs0uMfOWrmDZxXmx/6KBo1/HrUBmgpZH7AgAAtCxyX5bU/EmTY/z1N0Wrjh2yotjWXTpnxbdzP/s8yiZPybbptMH60e2721fZr3S55aLXD/aL8bf8LSbe/s+Y9sKwKO3RI+Z+OjrmT5wYrbp0id4H/LDWTsnlc+fFxDvujDZ9+8Zy231rkce77bh9duzPLvpjtF9tlZj35fiY9/kX0W7wStF+yKoN8NsAGpIC3hqk0HafffaJ+fPnR8+ePbMODKusskqd9i0tXfBrTfsuzrx586rsAwAAQOOZOr08XnxlziL3jxk3P1ty5sxdMB1ZztGHdYu112gbf7h6Srz02uxsurJB/UvjxKO6xom/7B5dOlcfxm6xSYd49bGBcc4lk+Oxp2fGXQ9Oj949W8eP9+4Sv/11j1hlpTa1jvfav0yNZ1+aHbddu0J0W27RgszvfrtT3HNz3zjnD5Pi4cdnRMcOrWLfPTpnwXMKkqkfG++2QvQb0jmeuGV0jBg+JT54YUoWsi/Xu11s9L3lY5sfDYgV1+1ar8+Zjn/b6e9F5+5tYrdjq88rfnjeGtG9b/usC+9bj0+Ibiu0i92PWyW+/ZOB9TqW5qC8olWUVbQqynEDS0buCwAA0PLIfVlSbfv3ja7bbBVzRo+JeV98GXNGjoyKitQBt3N0/Ma60XmTjaPjWmtUu2+n9deL0l4946tHHovZH38cc8eMjdbLdY0uW20e3XbYPlp3rb378lcP/yfmT5wUfY8+skp335wum28a0bp1TP3vEzHz7XejVYf20XnzTaPHbrvUWhjc0hRr5pvIfVsW6WE1nnvuudh9991jzpw5sdxyy8XDDz+cdUyoq8GDB8fbb78dEydOzLoyrLFG9R/YkyZNirfeeiu/DwAAAI3rW5t3jLLPlu4K9e9s3TFbltSqg9vGTZctv1TPedgBy2VLbXbdvlO20LD6D+2cFcwuq52PHJwti5OC2GP+vmGt25S2bZUV99ZU4AvQ0sh9AQAAWia5L0uqTc+e0WOv3Zd6/3YDB0Sfnx64VPt2/97O2VKbLt/cOFuA4qdceyGvvfZa7LLLLjFjxozo1KlTPPjgg7HhhrV/Ibaw733ve/n1o48+OubOnbvINml6tl/+8pf5x3bdddd6GD0AAAAAAAuT+wIAAAAATU2z6sD7zDPPxIgRI/K3J0yYkF9P9990001Vtj/ooIOq3P7oo49ixx13jClTpmS3zznnnKwTQ65bQnX69OmTLQsf99JLL826MDzyyCOx0UYbxVFHHRXrrbdetG7dOt5555246qqr4vnnn8+2X3755ePXv/71Mr56AAAAAIDmR+4LAAAAADRHzaqA97rrroubb7652seeffbZbKktyH366afjyy+/zN8+5phjFvucp59+epxxxhlV7mvbtm3861//yqZje/311+PNN9+MQw89tNr90xRqd911V/Tq1WuxzwUAAABA/SuLkigrwomq0rihJZD7AgAAALAkijXzTeS+LUuzKuBtSlZcccV46aWX4rbbbot//vOf8corr8T48eOjoqIievToEeuuu27sscceccABB2RTtgEAAAAA0LTJfQEAAACA+tKsCnjTVGkLT5e2JFJnhoW7MyyLNm3axI9//ONsAQAAAABgycl9AQAAAIDmqDj7RAMAAAAAAAAAAABAkWpWHXgBAAAAYEmVV5RkS7EpxjEDAAAAADS0Ys18k2IdN0tHB14AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQAp4AQAAAAAAAAAAAKCASgv5ZAAAAADQ1JRHqygrwuvc07gBAAAAAGgemW8i921ZnG0AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQAp4AQAAAAAAAAAAAKCASgv5ZAAAAADQ1JRXtMqWYlOMYwYAAAAAaGjFmvkmxTpulo6zDQAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAApIAS8AAAAAAAAAAAAAFFBpIZ8MAAAAAJqasijJlmJTjGMGAAAAAGhoxZr5JsU6bpaODrwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggBTwAgAAAAAAAAAAAEABlRbyyQAAAACgqSmvaJUtxaYYxwwAAAAA0NCKNfNNinXcLB1nGwAAAAAAAAAAAAAKSAEvAAAAAAAAAAAAABSQAl4AAAAAAAAAAAAAKKDSQj4ZAAAAADQ15RFRFiVRjOMGAAAAAKB5ZL6J3Ldl0YEXAAAAAAAAAAAAAApIAS8AAAAAAAAAAAAAFJACXgAAAAAAAAAAAAAooNJCPhkAAAAANDXlFa2ypdgU45gBAAAAABpasWa+SbGOm6XjbAMAAAAAAAAAAABAASngBQAAAAAAAAAAAIACKi3kkwEAAABAU1NW0Spbik0xjhkAAAAAoKEVa+abFOu4WTrONgAAAAAAAAAAAAAUkAJeAAAAAAAAAAAAACggBbwAAAAAQK3mzp0b1113Xey4447Rt2/faNeuXXTu3DlWX331OPjgg+O5556r03H+9a9/xZ577hkDBgzIjpF+ptvpfgAAAAAACkPm2zSUNvYAAAAAAKAxVURJlEdJFOO4C+GTTz6JXXbZJd5+++1FAt4PPvggW2666aY46qij4o9//GOUlCw6rvLy8jj00EPj+uuvr3L/2LFjs+Wee+6JQw45JK655ppo1UrPAQAAAACg5WW+hcp9Zb5Nh98MAAAAAFCtefPmVQly11133Sy4ff755+ORRx6J0047LTp16pQ9dvnll8cFF1xQ7XFOOeWUfJC7/vrrx6233hrDhg3LfqbbSer2cOqppxbstQEAAAAAtDQy36ZFB14AAAAAoFr33ntvPsjdbLPN4umnn47WrVvnH99+++1jt912yx5LwW8Kc4877rgoLf06dkzdGi666KJsfaONNoqnnnoqOnTokN3eeOONs/232WabGD58eFx44YXxk5/8JFZdddWCv1YAAAAAgOZO5tu06MALAAAAAFTrueeey6+fdNJJVYLcnA033DB23XXXbH3KlCnx7rvvVnn80ksvjfnz5+c7NuSC3JyOHTtm9ydpu0suuaRBXgsAAAAAQEsn821aFPACAAAA0KKVVbQq2qWhzZ07N7++8sor17jdKqusUu0+FRUVWUeHZOjQobHppptWu3+6f/XVV8/W0/ZpPwAAAACApdHYuW1Tzn1lvk2LAl4AAAAAoFq5gDX5+OOPa9zuo48+yn6WlJTEaqutlr9/5MiRMW7cuGw9TZlWm9zjY8eOjVGjRi3z2AEAAAAAqErm27Qo4AUAAAAAqrX//vtH165ds/ULLrggysrKFtnm1VdfjQcffDBb/8EPfpDfPnnnnXfy66kbQ20qP77wlGwAAAAAACw7mW/TUtrYAwAAAAAAls1nn3222G0GDBiwxMft1atX/OUvf8lC3WeffTY23njjOProo2PIkCExffr07L6LL744m0Jtgw02yNYrGzNmTJ2ff+DAgfn10aNHL/FYAQAAAACak4bIfWW+TYsCXgAAAABatPIoifKKkijGcedssskmi92+oqJiqZ5nt912i5dffjkLaq+//vo48MADqzy+/PLLx9lnnx0/+9nPomPHjlUemzZtWn69c+fOtT5Pp06d8uspKAYAAAAAaEmZb6FyX5lv09GqsQcAAAAAADRdqdPCLbfcEvfee2+1YfAXX3wRf/3rX+PRRx9d5LHZs2fn19u2bVvr87Rr1y6/PmvWrGUeNwAAAAAAi5L5Nh068AIAAABAkRs2bFj07du33o87Y8aM2GmnneLpp5+O1q1bx/HHHx8HH3xwrLzyyllQ++KLL8ZZZ50VzzzzTOyxxx5x0UUXxa9//ev8/u3bt68SCtdmzpw5+fUOHTrU+2sBAAAAAGjpua/Mt2lRwAsAAAAARS6FuAMGDKj3455xxhlZkJssPJVa6q6w/fbbx7bbbhs77LBDPP744/Gb3/wmtttuu1hvvfWybbp06VLnKdJScFzXqdcAAAAAAJq7hsh9Zb5NS6vGHgAAAAAANKayKImyaFWES0mD/l7S1Gk33HBDtj5kyJAqQW5lpaWlcfbZZ2fr5eXlcdNNN+UfqxwujxkzptbnGz16dH594MCByzx+AAAAAKBlKt7Mt2FzX5lv06OAFwAAAABYxBdffBGTJk3K1tdff/1at91www3z6++9915+fc0116z2/upUfnyNNdZYqjEDAAAAAFA9mW/TU9rYAwAAAJqv8s9Xa+wh0ETdMX25xh4CTdTzU1Zp7CHQxMycmqbYer6xh9EipS4LOfPnz69123nz5lW73+DBg6Nfv34xbty4ePLJJ2s9xlNPPZX97N+/f6y00krLMHIAAAAaisyXmgx+8GeNPQSaqA4T9ZdkUa2mel80Bplv0+MvAQAAAABYRI8ePaJr167Z+vPPP19roFs5qE0Bbk5JSUnsvvvu+W4LL7zwQrX7p/tz3RjS9mk/AAAAAADqj8y36VHACwAAAECLVlFREuVFuKRxN6RWrVrFLrvskq2nbgrnnntutdtNnjw5TjjhhPztXXfdtcrjRx99dLRu3TpbP+qoo2LWrFlVHk+30/25Tg5pewAAAACAlpb5NnTuK/NtehTwAgAAAADVOu2006Jjx47Z+hlnnBG77bZb3HnnnfHqq69mHRouueSS+MY3vhHvvPNOts12220XO+ywQ5VjDBkyJH7zm99k68OHD48tttgibr/99mw9/Uy303qStlttNdOxAgAAAAA0BJlv01La2AMAAAAAAJqmoUOHxr333hv7779/TJgwIe6///5sqc63v/3t+Mc//lHtY6mTw5dffhk33HBDFgTvt99+i2zz05/+NM4555x6fw0AAAAAACwg821adOAFAAAAAGr0ne98J95777244IIL4lvf+lb07t072rRpEx06dIjBgwfHPvvsE/fcc088+uij0b179xqnZrv++uvjwQcfjN133z369esXbdu2zX6m2w899FBcd9112XYAAAAAADQcmW/ToQMvAAAAAC1aebTKlmJTyDH37Nkzjj/++GxZFjvvvHO2AAAAAAA0lGLNfJNCjVvm2zQU57sUAAAAAAAAAAAAAIqUAl4AAAAAAAAAAAAAKCAFvAAAAAAAAAAAAABQQKWFfDIAAAAAaGrKKkqypdgU45gBAAAAABpasWa+SbGOm6WjAy8AAAAAAAAAAAAAFJACXgAAAAAAAAAAAAAooNJCPhkAAAAANDXlFSXZUmyKccwAAAAAAA2tWDPfpFjHzdLRgRcAAAAAAAAAAAAACkgBLwAAAAAAAAAAAAAUkAJeAAAAAAAAAAAAACig0kI+GQAAAAA0NRUVraK8olVRjhsAAAAAgOaR+SZy35bF2QYAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAAqotJBPBgAAAABNTVmUZEuxKcYxAwAAAAA0tGLNfJNiHTdLRwdeAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggEoL+WQAAAAA0NSUV6SlJIpx3AAAAAAANI/MN5H7tiw68AIAAAAAAAAAAABAASngBQAAAAAAAAAAAIACUsALAAAAAAAAAAAAAAVUWsgnAwAAAICmpryiVbYUm2IcMwAAAABAQyvWzDcp1nGzdJxtAAAAAAAAAAAAACggBbwAAAAAAAAAAAAAUEAKeAEAAAAAAAAAAACggEoL+WQAAAAA0NRUREmUR0kU47gBAAAAAGgemW8i921ZdOAFAAAAAAAAAAAAgAJSwAsAAAAAAAAAAAAABaSAFwAAAAAAAAAAAAAKqLSQTwYAAAAATU1ZRUm2FJtiHDMAAAAAQEMr1sw3KdZxs3R04AUAAAAAAAAAAACAAlLACwAAAAAAAAAAAAAFpIAXAAAAAAAAAAAAAAqotJBPBgAAAABNTXlFq2wpNsU4ZgAAAACAhlasmW9SrONm6TjbAAAAAAAAAAAAAFBACngBAAAAAAAAAAAAoIAU8AIAAAAAAAAAAABAAZUW8skAAAAAoKkpj5IoryiJYhw3AAAAAADNI/NN5L4tiw68AAAAAAAAAAAAAFBACngBAAAAAAAAAAAAoIBKC/lkAAAAANDUVKTp1IpwWrI0bgAAAAAAmkfmm8h9WxYFvHXw6aefxvXXXx8PPvhgfPLJJzFt2rTo3bt3rLTSSrHtttvGPvvsE2uvvXadjjVz5sxs25EjR2a3V1xxxRg1alQDvwIAAKCy90fMjf88OTNefmNOvPLGnHj3w7lRVhZx1vE94pRjetS676NPzYxLrpkSL706O2bMqogV+5fGXrt0jhN/2T06d6p5kpMRI+fGuZdOjseenhnjJ5ZF756tY7utOsZvf90jVl6xTbX7/P2uafG7P06OEaPmxvK9SuPg/bvEqcf0iNatF/2H+4yZ5bHONp9mYxj+yMBo29Y/7hvChHFz4/4/fx5vPjs1W4+KiG592sTQjTvHLgcvHyuu0bHK9vuv9nKdjvvz368UW+/ZM3979syy+Pvvx8aL/54cs6aVxaChHWK/4/rH2pt1rXb/V/47JS487KPY99f9Yo+f913GV8mSmv7ZtLh/r9vrtO12f9ol+qxf8zn68M53YvhFz2XrK39vSHzz5K0X2Wb+rHnx2hXD4tPHR8a8GfOi+6o9Yt2fbxwrbNSv2mOOfebTeOo3j8S6h20Uax30jTq/LoDmTu4LAADNi9yXpTHxhjtixnO157gDrzonStp8fT6nPzs8Jt34j1r36X30T6LD2qsvcv/UR5+J6Y89F/MnT4nSHt2iy3e2jC7f3rzaY8yf/FV8dtrF0W7woOjz60Pq/JpoOMdtv1UcsuVG2fqljz0bVz81rMrjW626Uuyw5qqxxgp9ok/XztGtQ7uYV1Yen06aEk99OCpufP7lmDJz9iLH7dCmNI7bYavYcc3Voku7dvHeF+PjD48+Gy+OHF3tOL41ZHBc/cM94pJHn4lrnn6pgV4tUAgKeBfj8ssvj5NOOilmzJhR5f4xY8ZkyzPPPBNTp06NSy+9tE7HO+200/IhLgAA0DiuvvmruOy6r5Z4v0uvmRLHnjEhSkoitvpm++jTuzSeeXFW/O6yyXHXg9PjqXsHRK+erRfZ79lhs+K7+42LmbMqYq3V28YWm3SIt9+bG7fcMS3ufGB6PHJH/9h0w/ZV9nngPzPix0d8Ed27tYqdt+sUr789J866eHJMnFwel53be5Hn+O35E+PTsfPjqXv7C3EbyIjXZsR5B30Qs2aUR4/l28S6W3aNVq1K4pN3Z8bTd0+K5+6fFEf+YeXYdKfu+X0qF+UubMJnc+OdF6Zl76c1Nulc5bGrjh8Vwx6eEgOHtI/VvtEpKxg+/ycfxul/Xz1WW7/qtrNnlMUNZ3waA1fvELseskIDvHIWp02HNjF459VqfPyrkVNi0rvjo7Rjm+gxtFeN200fOzVeu3JYZBfXV9T8fC+c/WSMfnxULLdy9+i1dp/4fNjYeOLof8V3rv5edruyeTPnxfCLno3lVukea/xo3aV7gQDNkNwXAACaH7kvy6LdqitFaZ8a8tyS6ou4S3v3jHarrVTtY//P3n2AN1Xvfxz/pE33Li1Qdtl7L2UqCKKoiAsHote99xY3Xtdfce/tdaCCiKCCyEam7L1nS/feTf7POYG2oS2zTRN4v57n3Jyc+QvNRfrJN9+fd3j5ZgyZfy9U2vdT5B0WooAOrZW/fbdSv50se2GRQoeW/yK/sU/FNkWOvvh4Xw6qQZeGMbr+zK6y2ezmZwMVuaBja13YqY12JqdqS0KSUrNzFR7orw716+qW/j11Sdd2uu6Ln7U1MdnpvJcuPldD27XQ5gNJWrU3Xmc2baRPRl+saz6bYD4vK9DXR0+df7Y2xSfq0wXH1kQEgPuigPcIXnjhBY0dO9Zcb9mypW666Sb16NFDYWFhSk5O1ooVKzRp0iR5eVX+bauyjOONwNff318+Pj5mRwcAAAAArteuta8euC1cndv7qWsHPzOI/eanI//7fMWafD34bJK8vaXJX8Zo2KAgc3tOjk0jrovTzHm5uu2RBP34iXNnTWP/qFvizRD30bsiNO7x0gDwiReT9dLbqRp1c7w2zG+kgIDS3y2efiVZvr7Swt8aqGUzX7PTQs+he8wQ+vF7IlS3dumvc8tW5umdz9J165gwndkjoAr/pFDWx2N3mcW7g66I0nVPN5LVxxHQGWHdT2/u16T34vXJk7vU9eww+fp5lXTWrcynT+82C3jbnxmi6Pp+Jdt3rs8xi3eN7Y991kJe3hatXZihcWO2mPd4+OPmTtf54fX9SjlQqHvebFoyJriWX7i/eo8dUOn+2ff/YT42PqeprAEVd16x2+xa9MJcGZ8UxQ5roR3TtlR4XOrmZLN4t073eho4/lx5eXspfuk+zbr7d637fIUG/N9Qp+NXf7hMuYk56vPCIHlZjy2/AIBTHbkvAAAAcGoi98XJCOrXQ8F9HJ1Vj5VRvFvrP5cf07F2m03pv/4lr+Ag1X3mPnmHBKk4I0txY/9P6VP/VsigPrJYSwvFc/5dq9wV6xR+6XlmoTBqlr+PVf8dMVSJmdlas/+AzmnjnNMf8tnC5Xpl+lwlZeWUK7odd9EQDWvfUi9cNFijPimd0a113WizeHfhtt268euJstnt6h3bUF9cd6lu699LtxqF3GXcO6iP6oQG674fp6rIZqumVwzAVSjgrcTMmTNLQtxrr71Wn3zyiRm+ljVo0CA9+OCDKigoOOr1iouLzSDYeHz66afNqdkIcgEAAICacePVYU7Pj6U2wwhc7XbpuitCS0JcQ2Cglz7+v9pq3nuXJk7N1sYtBWrdwrdk/5cTMrU/vlgtm/no+Uedp2kznk+clqXN2wr11Y+ZuuVax7gKCuxas6FAZ/UJMENcQ1Cgl66+JERjX07RkhX5unCo49e54mK7bn0oUXVre+vFMiExqlZmapF2b8w11y+/r55ToazxTftL766nqZ8dUHZGsfZtzVNsu8AjXq8g36Z/fksx18+6zLkj6451jmBv4CVRZvGuof2Zoarb2E+bV2Q5Hbttdbb+/CZB51wdXa4zL9xDTkK24hfvM9ebXlB+yrxDNv2wVokr49X9wTOVl+p4r1UkZWOS41rDW5rFu4a6PeoruEGoktYkOB2bvD5RW35ar+Yj25TrzAtnNruxWDxy3ACOD7kvAAAAcOoi94U7K0pKlS0rW0H9e5rFuwbv0GAFdG2n7HlLVRiXIN+GjkJxW16+Ur+bLJ+G9RRyTt8aHjkM9w/uqyZREbr5m0ka1q5lpcdtjE+scHtOQaFe/nOOWcDbuWE9Bfn5KjvfkTu0q+fIbieuWGsW7xoW7dhjdvE1ji2rfb06urpnJ323dFW5zrw4NTJfA7nv6YXWKxWw2Wy67bbbzPVOnTqZoevhIW5ZvsbXo47izTff1PLly9WqVSs98sgjVTpeAAAAANXLCFan/eWYXvnKkeWLJBs39FGfHo6p0H753bnActLB51dcFFxuSiXj+eUXOq43aVrpeWkZxSouliIjnKdlO/Q8K7v0G9XjP0rTirX55vRqoSH8ilddfI5jerrQyKN/V3bJH6lmsW9wuLe6Dw4vVyxsCAp3/vkHh1uVl1P6sy8usuvjJ3cporaPRt1f/5jHB9faMW2z2V03rGmEotpVXESbsSvN7JRbu0tds9j2SPIz8sxH39DSrs0GvzA/FeUWljy3Fdm05KX5CogKVKdbj69zCACcqsh9AQAAAJRF7gtXsh3syOod6Nz8wTvIUcxrz88v2Zb28+8qTs9S5JhLZDHaQ6NG9WzSQNf07KxfVq7X3C07T/g6xQerMottNhUZfxkcFB7g6LCdluvIfg9Jy8kzO/ce4u1l0XMXDlZCZrbe+GvBCY8DgHvhv/IVmD59urZscUxVaYSuVuvJNSretWuXnnrqKXP9gw8+OKbgFwAAAID72Ly9wJwKzdC9kyOwPVy3To5iuhVrnTu1rVzjCN26VXqeY/vKMufVjrIqMMBidnUo69Dz+nUdv6Ps3FOoZ15N0YhhQRoxjO6r1ck/yFutuzv+jCe8sV9FhaVff7bZ7Prprf0qyLOr84BQ1Yo5+u98s39ONh/7XlhLPn7Ov5pHN3Ccv39baVhn3C9+d54i65SGdUbH310bcnX9M40UEEyI6662T91S0jG3IrZimxY9P0eyWNTz8f6yWI5cLB5cN8R8zNiZVnqNIpsy92YoILo0/N/4/RqlbUlWtwfPlE8QOQQAGMh9AQAAAJRF7ouy8jduU+oPvyn5q5/NAtqcf9fKXuhotlCZooRkpU360zwn9Ycpypq/VMWZjqLww1mjIszHwnjnWbQOPfeOcHRqzt+2S1mzFylk0Jnya9Kgil4dTpRRQDvuoiFKys7Ri7/PPuHr+Hh7677Bfcz1hdt2K7+otIB3X1qG+dgsurSbt9XLS40jw5WQWfolgOvO6Ka2MbX13NS/lV1Q2swBgGc7uYTyFPXjjz+aj8aHZsOHDy/ZnpKSouTkZNWqVUuRkc5TIBzJ7bffruzsbI0ePVoDBw6sljEDAAAAqD47djtCuvAwL4UEV/w9yIb1HIWVO3eXhiaZWTYlpzq6JjSqX/GvXw3rObYnJhcrO8dmTplmuGBokH74JUtvfJCqG64O06LlefrihwzVjvJW726O8Pf2RxJltVr09ovRVfp6UbGbxjXWyzdu0cwfkrRidrqadgg0u2nsXJ+jlAOF6jciUtc91eio10ncm6/1ixxTaw+8rPz0d+16hyogyEtTPz2gVt2CVbeJnya+G6es1GL1vcBxfMKefE18J069zg1X90HOHXzhPhL+jVPW3gx5+XgpdliLCo/Z+L81Sl6XqC739FZIg9CjXrNO93qyBvpo43drFN2prkIahmrt5ytUkJ6vJkObm8dk7c/U2k9XqOFZsWrQr3GVvy4A8FTkvgAAAADKIvdFWdn//Ftum3dYiCKvv0wB7VtVeE7+1p3mUpbFx6qwC89R6DDn3xO9Q4Pl26yRcldvVPaSlQro2Ea5qzaYz30axMhaK0L2omKlfDVR3pHhChsxtIpfIU7Ew0P6q2FkmO747ldl5JV2ST4ao9B2dK/OZgYRERigDvXrKDIoUKv3xuuJydOdjl20Y7ey8vJ1/RndtHzXfu1KSdPtA3opIihAU9ZsNI+pHx6qOwb21h/rNmvWpu1V/joB1BwKeCuwaNEi87FJkyYKCQnRt99+q//+979au3ZtyTEtW7bUTTfdpLvuukt+fs7TVpb1/fffa9q0aYqIiND//d//uWT8AAAAAKqWEcgaggIr74wZFOTYl3Hw2LLnHenc4IPnmedmlga5Lz5eS7MX5OrBZ5PNxWDM8PzVO7Xl52fRd5My9eesHL3zUrTqHezMYMjLs8nHxyJv7yN38cTxq9fUX8/92FrvPbhTq+dnKOVAesm++s391aZniAJDvI+p+67dLrMAuHFr5+nSDKGRVl35UAN99sxuPXnJxtJ7NPPXJXfHmOufPr1b3laLxox1LhjOz7XJL4DJdtzFtt82m4/1+zaWX3j5bixp21K05pPliupQW60ub3dM1zSu0/mOHlr26kJNv2FyyfbQJuHqcENXc33pKwvkZfVSt/vPcDq3KK9IVn+ioIrY7F7m4mk8ccxATSL3BQAAAFAWuS8MRvFsxKgL5demmaOItqBQBXv2K/3Xv1SwbZcS3/5Ste+7Qf6tmzkV9oaef7YCOrWVNTrSLNotjE9U1swFyl60wuzga7fZFHb+2U73irjyIiW8+qGSP/quZJslwE+R115irmdMn6vCffGKvud6efmVzvJiKyg073G02btQtfo0a6RRPTpq6pqNmrlx23GdGxMWoou7OGe+C7bt0tNTZirhsC7NaTl5eu2v+Xpm+CD9dMtVJdu3JiTrnVn/mOvGvqLiYo2b5twF2N/HqryjdIo+XXlq5mvw1HHjxPCpzWFsNps2bnR8QBoVFaV77rlHb731VrnjNm/erIceekiTJk3S1KlTFR5evuNRamqq7r33XnP9pZdeUnR01X47au/evUfcHxcXV6X3AwAAAOA6TRr6aPWsRvr8+wxt3VGoOtHeumpkiFq38FVqWrHufypJfXr469ZrHR07f5icaU6rtnlboRn4Du4faHZoiG3k6BCBk7dpeZZev2ObWTh75+uxandGiKw+Fm1enqWv/7tXHz2+S5v/zdIt/21S6TVsNrvmTnQE8wMviar0uHOujlaTtgFa8meacrOK1ahNgAaMjDKLc+dPTtbqeRm68flGiqjtYxbt/u/lveb23CybQiKsOueqaF1yV4y8CPRrTGF2gfbM2mGuN72gZbn9tiKbFj0/xwzdez3RXxavY/9ZtRjZVhEto8zrF2YXKqJFpGLPb2kW5+78c6viF+9Vj0f6KiAq0CzaXfn2YnO7caxRANz84jZqf0MXeXkTAgI4fXhK7kvmCwAAAJzayH3dT+iQfs4b/P0U0K6l/Nu2UNK7Xyl35Xql/jBFMU87fg80GB15D+/K69ekgfxuuEI+DWOUNmGq0qfMVHDfHmaxb9ljYp67X9kLl6soNV3WyHAFndnNfCxMSFbGbzMV2LOzAjq0No/PnLlAGX/MUXFquiy+Pgro3E4RV10o7+Cg6v5jOe0F+/nqhYuGKDkrR89Pm3Xc5xsFv62ffkNeFovqhgbrjGaNdNfAMzTl9tF6dNKf+nP9Fqfjv1+6WhviEjSkbQvz3hvjEzVp5XqzOHd4h9bq16KJnvr1LyVmZZtFuw8N6acLO7ZRiL+fUrJz9N3S1Xp39iLZjO4hADwKBbyHSU9PN8Ncw5o1a7R06VLFxMTo1Vdf1XnnnSd/f39z2yOPPGJ2bFi4cKH+85//aOLEieWuZQS9Bw4c0BlnnGF2bahqDRs2rPJrAgAAACjv0PRp2TmVBx/Z2Y59oWWmWis77Vpl52YdPM88N8S5mC6qlrceuiOi3DkPPZektIxiffBqfbP4b/IfWbrq1gPq29Nf4x6rpfiEIj35UooGXbJPq2c3UnAQRXonKzujSK/fvk2ZqUV6bkJrNe9cGpB2PTtc9ZsH6JHh6zX7p2T1vaiW2vUuDWXLWrsgU0n7C+Trb1GfC488RXeLLsHmUlZWWpG+fnGvWncP1tlXOAqA331gh5bNTNPwG+qoVbdgLfsrTRPfjVNebrFGP8bvjTVl14ztKs4rUmDtIMX0alBu/7ovVyp1U7I63dFDoY3LF4cdTVT72uZSVn56nv59c5GiO9dVs4scHyD888ws7Zu3W62v6qDojnW0d+4urft8hYryCtX17t4n8QoBwLN4Su5L5gsAAAC4DrkvjsT4GYRddI5ZwFu4J05FKWlmoe3RhAzuq4xps2XLylbe+i0KOsMxa9YhRpffsAsGlzsv5euJsvj4KGLUBebzzL8WKPX7XxXQua2CrrpIhXEJSv91hooSklTn8Ttk8eLnX50eHzbQ7KJ774SpZofcE2UU1O5Pz9TP/67Tou17NOWOa/XiiCFavnufkrJynI5dtTfeXMoKC/DTY+cO0NKdezVh+Rpz2ysjz9Wg1s302cLl+nfXfg1q00x3DOytQF8fvfzn3BMeK4CaQQHvYbKzS9uU5+XlKTAwULNmzVKrVqXfnOnfv7/+/vtvM6BdtWqV2Y1h8eLF6tWrV8kxc+fO1WeffSar1aoPPviANvYAAACAB2vS0PGrU1q6zZwerWxAe8ie/YXmY+ODxxqM4yIjvJSSatPufUXq1K78NMx79jumNoqK9CqZRu1I5izM1RffZ+rJ+yLUtpVjCq1X3kk1p2r75csYRYR7m9u8vCy649FEfTsxUzePDjvh1w6HFbPSlZFSpDqN/JyKdw8xtjfrFKT1izK1dmFGpQW8s39OMh97Do1QYIjjZ3U8vvnvXrMj740vNDZ/z9y/PU9LZ6SpzwWRuuphR5Fot0Hh2rslT9O/TtRld9eTf9Dx3wcnb/tvm8zH2PNaVNhdd++cnebj/vm7Fbdwj9O+7Lgsx76FezTz9t/M9UHvDT/qPVe8vdjsstvzkb7m+yNjV5r2ztmlxkOaqfMdPc1j6vdrrPQdqdry03p1uLGbfALp1gLg9EDuCwAAAOBw5L44Gp+Y0i/QG11wj6WA1yistdappYKsbLPL7rHIWrBc+Ru2KvK6S+Ud6mjqkPH7LHnXilDUbdfI4u0tdWkne06eMv6YrbwNW80uwag+g1s3U2Fxsa7q0dFcyoqNcjTnuLRre53ZtJESs3L0wE/TjnrNfWkZWrJjjwa2aqozmzbWr6s3HPWcR4YOMDvyPjXlL8e9a0WYXXqnrN6g/5sx39w2a/N2NY+upat7dtLbs/5RToHj7y0AnoEC3sMYnRbKuvHGG51C3EMCAgI0btw4DR/u+ADthx9+KAly8/PzdfPNN8tut5tTsXXs6PwXeVXZs8f5A76KplPr2dPxAR0AAACAE9eqma8CAyzKybVr2ao8ndUnsNwxy1flm49dOziHtV06+Gnm3FwtX5WnC4aUL/w0th867mjy8+267eEEtWrmo8fuLu3eunJdgdq38i0JcQ19ezl+t1m1zjEunJykuALzMaCCEP+QQwW5Rpfcihjbl81IM9fPuszRPfd4rFuUqTkTk3XJ3TGq38zx8921wfEN/ZZdnd9brboHa+uqbO3dmqfmnZhOzdWMAtnkdYmSRWo6/MhBeuKqA5Xuy0vONZdjcWD5fu2YukXtb+yq0CaODxJStySbj1Ed6jgdG92xrjm+jB2pqtXOuYvv6cpmt5iLp/HEMQM1xVNyXzJfAAAAwHXIfXE0tjIdUi3+fsd9ntcxnFOcma20H3+TX+tmCu7bw7EtPdNcArp1cBTvHuTXoon0h1S4ez8FvC7g4+2tnrGVz5TTICLMXPYdY6G2IafQUVxbKzjgqMf2atJAI7u0M4tydySlmtta1402H1fsiXM69t/d+9S5YYyaRUdqzb7KM+fTiadmvgZPHTdODAW8hwkJce6SNGTIkEqPHTRokNlpoaioyJxe7RAj4N20aZM53dmzzz5bbWNt0KD8FJwAAAAAqp6vr0XnDQ7ST1Oy9N3ErHJB7q49hVq4zBHIjhjm+Hb8IRcPCzaD3B8mZ+mpByLNDgmH2Gx2TfjV0Wnz4vOcz6vIi2+maPP2Qv39c335+ZVex1jLznFMCX341G10hasakXUcXS+Mjrc5mcXluucWFdq1c50jlI1uUHEoO//XFBUW2M1uvW16Hv3nXVZhvk2fPrXLLNwdcUvd0h0Hf7x5h/3883OKHbv58deIbVMc3XfrdK2n4PqhFR4z7KuRlZ6/5pPlWvvpCjW9oKV6Pd7/qPcrLijW0lcWmIW7ba/tVLLdcvANUpTn3HGh5DlvEACnEU/Jfcl8AQAAANch98XRZC9ZZT5aAvzkU8dROHk0Bbv2qeiAYyY23yaVF38ekjrhN9nzCxQ5ukxeePDna2wvy3boOT//atfzpfcr3fffEUN0cZd2Gj9zgT6Yu+S4CoK7Napvru9MSjvqsc9cMEhbE5L10bzSezj+BpACfJxnVgvwdTy3HzoAgMc4ep/+04yfn5+io0v/o2uEsUfq2hAV5eialJiYWLL95ZdfNh8HDx6sKVOm6Pvvvy+3HJqyzXg8tM2Yng0AAACAe3rkznAzE/vihwz98XfpFMw5OTbd9ECCioulkecHqXULR6HnIWMuD1G9ut7avK1QT72c4rTPeG5sb1DPqmsvcy4qOdz6TQV65d1U3XBVqPqf4fzNbKP7w4YthVqwpLRT58ffpB9zhwccXef+ofIL9FJBnl0fPbFLedmOAllDUYFNX7+4R0n7C+TtY1GvcyMqvMbsnxyh7cBLax13wD7x3TjF78zXTeMay+pb+qt8bDvHhwoLpqSoIM8R5mekFGnJ9DT5+FlUv7lzt0FUP1uRTTv/2GquGwW4rrDu8xXK3JOuno/2lbdPaXF5RKta5uOuP7epKM/RGTo/LU97Zu+Ut6+3wmKPPuUfAJwqyH0BAAAAVITc9/RWsHu/claul934QZdht9mUNW+J0if9YT4PGdRHFqt3SRFt5t8LZcsr3wU5b/N2Jb7/dUm3XL+mRy7gzVu/RTn//KvQ4YPkU6d01jbv0GB5R4Qpf9M2FSYkl4wpe4HjS6a+jR1FoHAvkUEBGtWjo4L8nP++MNQOCdIrI89VndBg7U1N14Ltu454rdsH9FLjyAiN/fUvFRaXFvKvj3N0172gY2v5HXxPhgf665w2zZVXWKRtiY73CwDPQQfeCrRr106zZ88214sP+4/04Q7tNzoyHFJQ4PjGy+eff24uR5KUlKQrr7zSXB8wYIDOPvvskx4/AAAAgCP7d3We7nystBhj205HN8qPvsnQ1L9KQ9qfP4tRTB3Hv/W7dvTXa09H6YFnkjT8mjgNOCNA0VHemr84V3EHis3pzd5/ufxU9IGBXvr+w7o6d9R+/fetVE2Znq12rX21bmOB1m4sUFCgRT98VFcBAZV/v9KYpvnWhxIUGe6tl8c6CvLKevzeCHNMQ6/Yr8EDAnUgoUhLVuSreayPrhxxfJ1eUbHQWj664blG+vDRnVr8e6o2LM5U0w6BsvpYtH1NjlIOFMriJY15sqHZYfdwO9blaNeGXHl5S/1Hlv8ZHsmeLbma8skBDRoVpVbdnH+edRv768zhEVr4W6oeGrZOTdoFavO/WcpILtJFt9aVf6Bzp2BUv33zdys/NU8+Ib5qOLBJtd8vfXuqNnyzWs1HtFZ0pzLdmY0PFhqGqfE5zbRrxjZNu/pnRbaqpcTVB8zxGZ16rQHOXRoA4FRH7gsAAACc2sh9cbyKklOV9O5X8goMkE/j+mbhrC0nT4X74lWc4uiQGtizs8IuGFx6UnGxUr+drNQJU+XbqJ6skeFmca3Rddc4z+BTv66ibrn6iPe2FRQq5etJ5rGhQweU2x82fJBSvp6o+Bfeln+rpo7r7z8gv+ZN5Ne6WVX/UaAKGF1xnxk+SI+fO0Ab4hO1Ly3DnCUtJixYbWNqy9dq1YGMLN3x3a8qKKo8l2geXUs39OmuH5av1oo9+5327U5J12+rN2p4x9b67Y4xWh+XoC6N6ikqOEgfzl2i3EJHIwcAnoMC3gr079+/JMjdvn27unTpUuFxGRkZZhBrqF+fb7cAAAAAniIjy6bF/5b/dvze/UXmckh+gfNcQ/feEq72bXz1+gdpWroyz5yurFF9qx69K1SP3h2hkOCKw9g+PQO0YmZDvfBGqmbOy9HEqVmKruWt0ZeFaOz9kWrW5MhFdB99naEFS/P0/Ud1FR5WviDz3LOD9MuXMXrh9RT9OStbgQFeumJEsBk8G0Eyqka/i2qpUcsA/f5FgjYszdS6fzLN6ajCa/uoz4WROvfa2mreKajCc2f/7PjdsWPfUEXWKf/t+yOF+J88uUuhkVZd+VDFU2rf9nITRdXz1fxfU7T873TVquujqx6ur+E31jnBV4qTsf23TeZjk3OayduvemMX4/2x5KV58gv3V6fbe1Z4TK+x/RVYN8jswrtv3m4F1glS5zt6qvXVHap1bJ7GJou5eBpPHDNQk8h9AQAAgFMbuS+Ol2+DGIUM7quCXXtVFJ+ggq07zczXKOQN6NZBwX26K6Bja6dzLL4+Zsfcgp17VRifaBbV2gsLzSJg/zbNFdi9o4L6dJOlzBdCK5Ix5S8VJaWozmO3l3T3LSt4QC/J6q3MP+cqd/VGeQX6m9vCLxl23DO8wTWSs3P00h9z1L1xfbWoHaVmUZHy87EqMy9fq/bGa9am7fph+Rpl5zu+IFyZ5y4crNScXP3fjPkV7n/slz+1Pz3T7MJ7Vqumis/I1CvT5+qzBcur6ZV5Jk/NfA2eOm6cGIvd+LQHTlavXq1OnTqZ61dffbW++eabCo/78ssvdd1115nrzz//vJ588sljvkeTJk20a9cuNW7cWDt37lR12Lt3b8lUcHv27FGDBhV/2AsAAABUF1t8i5oeAtzUhKywmh4C3NSvSRUXU+H0lZOQrckXfVfl+UbZ3OTcSaMVWNvzOtfkJGTpj4sd0zKS/QCnR+5L5gsAAICaRuaLysROvammhwA3FbCbmcBQXmFGmraPf65KM45TIfM1kPueXvhKTgU6duyoYcOGmevfffedZs6cWe6Y+Pj4kuDW19dX119/vcvHCQAAAAAAAAA4NuS+AAAAAAAAANwJBbyVGD9+vMLDw2Wz2TR8+HA99thjmjdvnpYtW6b33ntPPXr0MKv2D3VhYCo1AAAAAAAAAHBv5L4AAAAAAAAA3IW1pgfgrlq2bKkpU6bo0ksv1YEDB/TSSy+ZS1kWi0VPPPGEHn744RobJwAAAAAAAE6O3W6RzW6RJ44bwPEh9wUAAAAAADj1eWrmayD3Pb1QwHsEffv21bp16/T222/rl19+0Y4dO1RQUKCYmBgNHDhQd911l7p06VLTwwQAAAAAAAAAHCNyXwAAAAAAAADugALeo6hVq5aeeeYZc6lKO3furNLrAQAAAAAAAACODbkvAAAAAAAAgJrmVdMDAAAAAAAAAAAAAAAAAAAAAE4ndOAFAAAAAADAac1mt5iLp/HEMQMAAAAAAABAdfPUzNfgqePGiaEDLwAAAAAAAAAAAAAAAAAAAOBCFPACAAAAAAAAAAAAAAAAAAAALkQBLwAAAAAAAAAAAAAAAAAAAOBCVlfeDAAAAAAAAHA3NrvFXDyNJ44ZAAAAAAAAAKqbp2a+Bk8dN04MHXgBAAAAAAAAAAAAAAAAAAAAF6KAFwAAAAAAAAAAAAAAAAAAAHAhCngBAAAAAAAAAAAAAAAAAAAAF7K68mYAAAAAAACAu7HZLebiaTxxzAAAAAAAAABQ3Tw18zV46rhxYujACwAAAAAAAAAAAAAAAAAAALgQBbwAAAAAAAAAAAAAAAAAAACAC1ldeTMAAAAAAADA3diNaclk8chxAwAAAAAAAABOjczXQO57eqEDLwAAAAAAAAAAAAAAAAAAAOBCFPACAAAAAAAAAAAAAAAAAAAALkQBLwAAAAAAAAAAAAAAAAAAAOBCVlfeDAAAAAAAAHA3NrvFXDyNJ44ZAAAAAAAAAKqbp2a+Bk8dN04MHXgBAAAAAAAAAAAAAAAAAAAAF6KAFwAAAAAAAAAAAAAAAAAAAHAhCngBAAAAAAAAAAAAAAAAAAAAF7K68mYAAAAAAACAu7HJIpvdIk8cNwAAAAAAAADg1Mh8DeS+pxc68AIAAAAAAAAAAAAAAAAAAAAuRAEvAAAAAAAAAAAAAAAAAAAA4EIU8AIAAAAAAAAAAAAAAAAAAAAuZHXlzQAAAAAAAAB3Y7NbzMXTeOKYAQAAAAAAAKC6eWrma/DUcePE0IEXAAAAAAAAAAAAAAAAAAAAcCEKeAEAAAAAAAAAAAAAAAAAAAAXooAXAAAAAAAAAAAAAAAAAAAAcCGrK28GAAAAAAAAuBub3WIunsYTxwwAAAAAAAAA1c1TM1+Dp44bJ4YOvAAAAAAAAAAAAAAAAAAAAIALUcALAAAAAAAAAAAAAAAAAAAAuBAFvAAAAAAAAAAAAAAAAAAAAIALWV15MwAAAAAAAMDt2C2y2y3yOJ44ZgAAAAAAAACobp6a+Ro8ddw4IXTgBQAAAAAAAAAAAAAAAAAAAFyIAl4AAAAAAAAAAAAAAAAAAADAhSjgBQAAAAAAAAAAAAAAAAAAAFzIWtMDAAAAAAAAAGqSTRZz8TSeOGYAAAAAAAAAqG6emvkaPHXcODF04AUAAAAAAAAAAAAAAAAAAABciAJeAAAAAAAAAAAAAAAAAAAAwIUo4AUAAAAAAAAAAAAAAAAAAABcyOrKmwEAAAAAAADuxma3mIun8cQxAwAAAAAAAEB189TM1+Cp48aJoQMvAAAAAAAAAAAAAAAAAAAA4EIU8AIAAAAAAAAAAAAAAAAAAAAuZHXlzQAAAAAAAAB3Y7dbzMXTeOKYAQAAAAAAAKC6eWrma/DUcePE0IEXAAAAAAAAAAAAAAAAAAAAcCEKeAEAAAAAAAAAAAAAAAAAAAAXsrryZgAAADg12eJb1PQQ4KbiirJqeghwUxty29b0EOCmVsTVr+khwM0UJmXU9BAAAAAA4LRD5ovKdFpyZU0PAW7KO40SJFQscL+9pocAN1SQzfsCMPBfTwAAAAAAAJzWbHZjscgTxw0AAAAAAAAAODUyXwO57+nFq6YHAAAAAAAAAAAAAAAAAAAAAJxOKOAFAAAAAAAAAAAAAAAAAAAAXIgCXgAAAAAAAAAAAAAAAAAAAMCFrK68GQAAAAAAAOBu7HaLuXgaTxwzAAAAAAAAAFQ3T818DZ46bpwYOvACAAAAAAAAAAAAAAAAAAAALkQBLwAAAAAAAAAAAAAAAAAAAOBCFPACAAAAAAAAAAAAAAAAAAAALmR15c0AAAAAAAAAd2O3W2SzW+SJ4wYAAAAAAAAAnBqZr4Hc9/RCB14AAAAAAAAAAAAAAAAAAADAhSjgBQAAAAAAAAAAAAAAAAAAAFyIAl4AAAAAAAAAAAAAAAAAAADAhayuvBkAAAAAAADgbuzGYvyPh/HAIQMAAAAAAABAtfPUzNfgocPGCaIDLwAAAAAAAAAAAAAAAAAAAOBCFPACAAAAAAAAAAAAAAAAAAAALkQBLwAAAAAAAAAAAAAAAAAAAOBCVlfeDAAAAAAAAHA3NlnMxdN44pgBAAAAAAAAoLp5auZr8NRx48TQgRcAAAAAAAAAAAAAAAAAAABwIQp4AQAAAAAAAAAAAAAAAAAAABeigBcAAAAAAAAAAAAAAAAAAABwIasrbwYAAAAAAAC4G7vdYi6exhPHDAAAAAAAAADVzVMzX4Onjhsnhg68AAAAAAAAAAAAAAAAAAAAgAtRwAsAAAAAAAAAAAAAAAAAAAC4EAW8AAAAAAAAAAAAAAAAAAAAgAtZXXkzAAAAAAAAwN3Y7BZz8TSeOGYAAAAAAAAAqG6emvkaPHXcODF04AUAAAAAAAAAAAAAAAAAAABciAJeAAAAAAAAAAAAAAAAAAAAwIUo4AUAAAAAAAAAAAAAAAAAAABcyOrKmwEAAAAAAADuxm53LJ7GE8cMAAAAAAAAANXNUzNfg6eOGyeGDrwAAAAAAAAAAAAAAAAAAACAC1HACwAAAAAAAAAAAAAAAAAAALiQ1ZU3AwAAAAAAANyO3SK73SKP44ljBgAAAAAAAIDq5qmZr8FTx40TQgdeAAAAAAAAAAAAAAAAAAAAwIUo4AUAAAAAAAAAAAAAAAAAAABciAJeAAAAAAAAAAAAAAAAAAAAwIWsrrwZAAAAAAAA4G7sdou5eBpPHDMAAAAAAAAAVDdPzXwNnjpunBg68AIAAAAAAAAAAAAAAAAAAAAuRAEvAAAAAAAAAAAAAAAAAAAA4EIU8AIAAAAAAAAAAAAAAAAAAAAuZHXlzQAAAAAAAAB3Y7NbzMXTeOKYAQAAAAAAAKC6eWrma/DUcePE0IEXAAAAAAAAAAAAAAAAAAAAcCEKeAEAAAAAAAAAAAAAAAAAAAAXooAXAAAAAAAAAAAAAAAAAAAAcCGrK28GAAAAAAAAuBu73bF4Gk8cMwAAAAAAAABUN0/NfA2eOm6cGDrwAgAAAAAAAAAAAAAAAAAAAC5EAS8AAAAAAAAAAAAAAAAAAADgQhTwAgAAAAAAAAAAAAAAAAAAAC5kdeXNAAAAAAAAAHdjtxuLRZ44bgAAAAAAAADAqZH5Gsh9Ty8U8B4mIyND06ZN09KlS7Vs2TLt27dPiYmJys3NVXh4uNq2bavzzjtPN9xwg2rVqlXhNQoLCzVz5kz9+eefWrx4sTZv3qz09HQFBQWpadOmGjRokG677TZzHQAAANVn09YCzZiTo+Wr8/Xv6nxt2FKg4mLpuYcj9cR9kUc896+5OXrjwzQtXZGn7Fy7Gte3auT5wXr07ggFB1U+kcXWHQUaNz5VM+flKDG5WNG1vDWoX6DG3h+ppo19Kjzn24mZ+u+bqdq6s0B1oqy6/soQPXlfpLy9y/9SmZ1jU4cBu80xLJveUL6+nvmLp7vbv79Y776Xrdmz8hUXX6ygIIs6dvDRf/4TqEGD/Cs9z2az6+ef8/TzxFytX1+orCy7wsO91Ly5Veef568xYwKdjs/JsWncuCxNnZanzEyb2rTx0WOPBqtPH78Kr//XX3m67vo0PfJwsO66K7jKXzeOLj0uRws/36rt/yQqPT7XDFFCovzVqFukel/bTHVbhTkfH5+rrfMOKG59uuLWpylha6aKC23qcnEjXfBs50rvU5BTpL/eWK8NM/YrL6tIdVqGatA9bRTbK7rC4zfPidf3dy3RWXe1Vr+bWlb568axsRcWK3X6MmUuWKf8vYmy5xfKOyRQfo3rKOysTgrt277k2Kx/tyjznw3K3xmvwuRM2bJyZbF6y6duhIK7tlDEhWfIGur8d4bBlleghK9mmOfacvLk16Suoq8ZpKAOsRWOKWvZZu198TtFXXW2oi7tV62vHwDcGbkvAADAqYPcFyfDZuQ3fyxX+oL1yt+TKJuR34QGyr9xbUWc3Ulh/dod8fzkacsU9+Hv5nrE4M6qf9cF5e+RV6D4L2YqfaEjv/FvUkd1rj1bwR0rzm8ylm7W7hd+UO1rzlLty/pW0SvFyXikfz/d0qOHuf5/8xfo3cWLyx0T5u+vm7t31znNm6lBaJjyi4u0KSlJ369eo182bKjwugFWqx4d0F/DWrRQiJ+fNiQm6tV58/XPnj0VHn9201h9cvHFem3efL23ZEkVv0oczbBerXVGuyZq2SBaUWFBCgn0U15BkXYdSNWsFVv0/d8rlZtfWHK8xSJ1aBqjM9vFqkfrhoqNiVSQv6+ycgu0aU+Cpixcp98Xb6zwXv6+Vt17aX8N6tZCwQF+2rwnUe9Mmq+lGyt+b/TrGKs377rYPOazabw3AE9GAe9hlixZoiuvvLLCfUagO2fOHHN59dVX9c0332jo0KHljmnTpo2Sk5PLnW+EuStWrDCXt956S6+88oruueeeanstAAAAp7sPvkzXW5+kH/d54z9M0wPPJJm/aPfr5a/a0VbNX5yr/76VqolTszR3cgNF1fIud96CJbk6d9R+5eTa1a6Vr/r0DNC6jQX6akKmfv4tS9Mn1Ffvbs7Fn7/NyNboOw4oItxL5w0K0qp1+Xru/1KVnGrTW+PKF+qNfSlZu/cVae7k+oS41WTlykJdMzpFaWl21antpbMG+ik11aaF/xRoztwC3XtvkB58IKTceRkZNl3/n1QtXlyokBCLunXzUViol+Lji7VuXaGyMm3lCnjvvS9d06blq1Urq7p28dHcefm6+ppU/fxzpLp19XU6NjvbpsefyFDr1lbdemtQtf85oLy9q1P1zS3/qCC7SCG1/dX0jNry8pbiN2Zo9ZS9Wvv7Po18qZvaDqlXco5RgDv91XXHfa/JT67Qhr/iVLt5iOp3jNT2RYn6322LdN3nfdSgU2S5Yt9p49aodosQnXld8yp5rTh+hUkZ2vP8NyrYk2h+6BPQupG8/HxUlJShnPW7zPWyBbwZc9eYi09MpPwa1ZY1LFDFmbnK3bJPyRPnK23mCjV69lpzX1lxb/2izEUbzO0+LRsoe9U27XnuGzV+4XoFtGrgdKwtt0DxH02VX+PaqjXiTJf9WQCAOyL3BQAAOHWQ++Jk8pudz/xP+XuSzPwmsE1DM7Mxtmev222uH6mAtyA+VQe+/EsyfkRH6I64d/xkZfyzUX6No+Xbqr6yVm7Xzme+VdP/jlHgYflNcW6B4j743cxvoi8+oypfLk5Q13oxurFbN9nsdnkZf2FUoGFYmP532aVqEBamlNxcLdy9W/5WqzrXi9Hr5zXQmY0a6eE//yx33mvDztWwli21KTFJK+Li1LdxY31xyUhd8cMErYyLczo20MdHzw0apI2Jifpo2bJqe72o3KUDOqlTs3raEZ+sjbsTlJ6dp1qhgWaRbvvYurqoT3vd+OoEJaVnm8c3iArXF486soe0rFxt2HVAGdl5qh8drt5tG5vL0B6t9OD7U1RUbHO613P/OVeDu7XUlr1JWrM9Tr3aNNY794w0r288LyvAz0ePXjVIW/Ym6qs/eW8Ano4C3go0bNhQZ511lrp162aux8TEyGazae/evfrpp580ceJEJSUl6cILLzSD306dOpWcm5+fXxLidu7cWRdddJF69eqlOnXqmEHu77//rrffflt5eXm69957FRAQoJtvvrkGXy0AAMCpq11rXz1wW7g6t/dT1w5+ZhD7zU+ZRzxnxZp8Pfhskry9pclfxmjYoKCSTqkjrovTzHm5uu2RBP34SYzTecb+UbfEmyHuo3dFaNzjpV27nngxWS+9napRN8drw/xGCggo7eTw9CvJ8vWVFv7WQC2b+ZqdFnoO3WOG0I/fE6G6tUv/yb5sZZ7e+Sxdt44J05k9AqrwTwqH5OXZdfMtqWbx7oUX+Ov//i9MAQGWksLe0demaPz4bPXs4av+/Uu75Nrtdt1wY5pZvHvNNQEa+2SIgsp07CgosGvDhiKnexlFvUbxbt++vvrfNxFm54358/M16spUvfVWtr78wrmA9+VXshQfb9P774fLx4cQvyZMfW6VWbzb9dLGGvZYB3n7OH7Gdptds9/bpHkfbdZvz65SywF1ZPVzfNgT0SBQPa+KVd02YYppE6Z1f+7X/I+3HPE+8RvTzeLd2F5RuvqDM+TlbTELeL+5+R/N+3iLrnynl9Pxf7+1QZkJubr01b4lY4JrGZ1a9jz7tQr2JSnqigGqdUk/s5tu2f0F+50LviIvOlO1xwyRNSK4XNFt3LuTlblwveLem6ImL91Qsi9vR7xZvBvYMVYNx14ji7eXsldv155nvlbST3PV8ImrnK6V+O1MFaVkqv4DlzmNBwBOV+S+AAAApwZyX5wII5/Z+fQ3yt+brNpX9lf0pX3L5Tf5+8p/Ye8QIwPc++avRo9NhZ/VUWl/r67wuNzt8WbxblDHWDV55iozv8latUM7n/pGiRPmq/HYUU7HJ3wzS4UpmWr68CXkN27AKMJ9dei5SsjO1ur4AxraouKGCW+ef55ZvPvP7j267ddflZGfb25vHB6uz0eO1KXt22n5/v36Yc2aknPaREebxbsLdu3SmJ8nmgXCZzZqqG8uu0x39uqlG3/5xekeD/TtozrBwbrzt6kqsjkXe8I13vhxjnYfSFNGTp7T9rAgf71+x4Xq0qKB7r98gB7/eJq53S67lmzYbRbVLlq/y/wZH9K1ZQO9ddcI9e/UTNcP66mPf1tUsq9lw2izeHfx+l26Y7zjvdGzdUN98MBluvH8Xrrnbef3xh0j+qh2RLAe/WhquUJgAJ6HAt7DGAHu7t27K91/+eWX65dfftHFF1+sgoICPfvss2awe4jFYtE555yj5557Tr17967w+pdccon5aEzP9vDDD5udH0JCynfwAgAAwMm58Wrnqey9jqGuzQhcjd+nr7sitCTENQQGeunj/6ut5r13aeLUbG3cUqDWLUoLLL+ckKn98cVq2cxHzz/q3B3TeD5xWpY2byvUVz9m6pZrw0qKOtdsKNBZfQLMENcQFOilqy8J0diXU7RkRb4uHOr4J3txsV23PpSourW99WKZkBhV648/8rR/v01hYRb997+hJcW7hs6dfXTvvcF6+ulMjR+f5VTA+8MPufrnnwINGOCrl/7r/L4zGF0zOnVynkpv9RrHtEpXXB5QMm1e375+atLEW8uWFTgdaxQPf/FFjq69NrBcZ164Rk5agQ5szjDXz7qztVOhrMXLogG3tdI/X21TXmahErdnmcW6hlZnxZjLIUZh7tHErU8zHzuPaGQW7xqa9o5WZKMg7VmZ4nTsvrWpWvr9DnW/IrZcZ164jtEx1yjeDT+nq6KuGFhuv9G9xT+2rtO2w5+XHBvgq9rXDTELePM271VxTr68Ax1/3+Rt228+hp3dxfzwxxDUsanZxTd3k/NUakYn39Tflyp8aPdynXlRnl0W2e0Wjxw3gGND7gsAAHDqIPfFiUj8aYFZvBsxtKtqjxpQYX4T0LTivMaQPGWxctbvVswtw1R0sNtmRXK3OfK/iMGdSvKb4E6x8o2JVM5G5/wmZ8t+JU9bqshh3ct15kXNeKhfX8VGRug/EyfpvJYtKzymS0yMOsfEmEW1j02fXlK8a9iVlqZxc2br4xEjdFfvXk4FvB3q1DEff1y7rqSwc+HuPdqZmqqu9UpndTN0rFNH13burG9WrSrXmReus3ZHfIXbjU6870xaoE8fvsLsqnvI3sR03fr6TxWe8+/mvfr8j6Vm8e3wM9o6FfC2aex4b0xeUPreWLJxj3YfSFXHZs7vjbZN6uiKszvrx9mrynXmxamR+RrIfU8vtOY5jLfxlbujGDFihFq1amWuz5s3z2lf/fr1NX369ApD3EOMzgy33367uW50Z5gxY8ZJjxsAAAAnzwhWp/3lCN6uHOncEdHQuKGP+vRwTIX2y+9ZTvsmHXx+xUXB8vJy/qXKeH75hY7rTZpWel5aRrGKi6XICOd/gx56npVd+q3Z8R+lacXafHN6tdAQ/hlfXVatchTVdujgo7Cw8n/O/fo6iuiWLitUQkJxyfbPPs8xH2+7tTT8P5rUVMfPNzzc+T4REV7KySn9VnZRkV2PPJquOnW89Ogj5d+XcA2r77H//y4wwveki4UNAWHO1zGeF+SUdnK2FdnMrsAh0f46++42J3VPnDh7UbHSDk5TFjmiT5Vc03Lok0cvS8kHPYbizFzz0TvYuRuP8dyWV1r4by+2Kf6D32SNCFH0NYOqZEwA4OnIfQEAAE5f5L4w8puUP5ab61EXn3Hc5+fvTdKBb2YpsH1jRQ7rdsRjS/KbkMPym5Dy+c3+dx35TZ1rzjruMaHq9WrQQGO6dNHP69Zp9o4dlR7Xsa6j0HtveoZ2p6eX279gl+PLo/VCQ9Xp4LGG8ADH3zNpec7dXFNz8xToW9oAxNti0bgh5+hAdrZemze/Cl4ZqkPxwc63hUWlnxUdzabdCeZjncNmZQsPcrw3MrLzyhUKB/qVeW94WfTk6HOUmJatdyby3gBOFfwL8AQd6pxgTIl2IoxODIds27atysYFAACAE7d5e4E5FZqheyfHL8uH69bJUcC5Yu1hHVLXOL5h3a3S8xzbV5Y5r3aUVYEBFrOrQ1mHntev6+jCsHNPoZ55NUUjhgVpxDAKOKtT9sHC2YjDimoPiYx0hPTGF6DXrHUUUiYmFmv9+iJz+r1u3Xy1a1eR3nk3S48+lq7nn8/Qb7/lmR8SHK5hA0dgv3VraUFmYaFdO3cWqW7d0nD/o4+ztW5dkca9EKrgYH6Fqym+gVY16urosjLrnY0qLrQ5TZ835/1NKsorVvO+tRVW9+SmOgyvH2g+Ju0onfrRuF/KnmyF1i69ttHxN35jhoY93lF+QUywU1PytsepOCNH1sgQs5NK3q4DSvphtuLfn6KEr/9S1rLN5nvkWNkKi5T4v79Luusa3V8O8akdbj4W7Et0+gCqMD5FPpGhJdtSfv1H+TviVeem8+QdUNotHABwdOS+AAAApx5yX+Ruiy/Jb/yM/GbnASV8P0f73puq+C9nKnPZlkrzG6PQdu+bvxrTcqj+ncPN2TmOxLe2oxNz/p6k0msUFasgLkXWMvlN0uRFyttxQPVuObdk9iXUnEAfH708dIiSsrP1/KzZRzw2yMeR16XlOYq1D5dXVKTcwkKnrruHCn4NzSNLu3lbvbzUOCJcB7JKvwRwQ/duale7tp6eOVPZB68D92IU1d5yoePLAHNWHfvv/o0O5rtJh3Xx3p/seG/ExpR5b3h7qUF0uBLSSt8b15zTTa0b1dZL385UTj7vDeBUwSd8J2DTpk1auXKlud66desTukZ+mRb6x9L9AQAAANVvx25HIWV4mJdCKimUbFjPEczs3F36i3Fmlk3JB7upNqpf8T+xG9ZzbE9MLlZ2js2cMs1wwdAg/fBLlt74IFU3XB2mRcvz9MUPGaod5a3e3Rzh7+2PJMpqtejtF6Or9PWivKhajp/L7oPvhcPt2l36Teo95jF+2rChqKRz7nff5+j55zPlnKnlqHEjb338SbjatiktxOvTx0/BwRZ9+FG2evTwVWyst958M0upqXZdfLFfyTjeeCNb55/vpyFDKv6QAK4z/OnO+u6ORfr3p13aMveA6rULl8XLoviN6cpMyFPH4Q007PEOJ32f2J5R8g2y6p8vt6lhl0jVahSsuR9tUm5agTqcV988JnVvtuZ+sFltzolRq7Mqn9oP1S9/1wHz0Vor1CzYTfllgTG/VYmUSQvkF1tXDR4dJZ9o5yk+DXnb4pQybbF5TnFGtvK27jc/UPJvXk9177jQ6djADrHyCvBVyuR/FNC6kXzr1VLShDlmZ5fQ/o73XsGBVHNbyBltFdLT0UUSAHBsyH0BAABOTeS+ML5wbfCpFWIW7CZNWuiU3yRNXCj/pnXV6PHL5XtYfpM06R/lbt6nujcMMYt/jyaooyO/MQp0A9s2Ms9JmDDPzG/CB5TmNwnfz1XomW0U2ov8xh08PqC/GoWH65bJk5VR5ve6iiTlOmbkaxBWPuszRAUGKuBgkW/ZY/7Zs1uZ+flmge6yffu0Iy1Nd/XupciAAE3esMFxfGio7j7jDE3btFkzt22vwleIk9G7bWOd26u1vCwW1QoNVIemMQoO8NOCNTv01s/OM/hUxt/XqlGDupjrM//d4rRv6cbdysrN1zVDumnF1n3afSBNNw3vpYiQAP2+2PHeqBcVqpsvOEMzlm3W3FW8N4BTCQW8xygnJ0f79u3TlClT9Morr6ioyPGP/HvvvfeErjdnzpyS9TZtmOoUAADAHRiBrCEosPJv0AcFOfZlHDy27HlHOjf44HnmuZmlQe6Lj9fS7AW5evDZZHMxGLnOV+/Ulp+fRd9NytSfs3L0zkvRqnewM4MhL88mHx+LvL2P/G1/HJ8+fXz11tvZWr2mSGvXFqp9+9KCW8M3XzuCOUNWliPhTT0Y4qel2fTUU5lmse199warYUNvbdxUpGeeydSKFYUafU2q/voryiz0NURGeunxx0L0+BMZGn6B42dvaNHCW/ff5+i48djjGeb74blnSzszGHJz7QoI4GfvalGxwfrP1/006Yl/tX1hojYlxJfsi24WosY9ouQX7PyeORGBEX4afG8bTRu3Rp9eVRr+RTUN1oDbHYH+tBdWy8vHonMfdS4YLswtkk8Av+q70qFpEfN2xClvyz6FD+uhyPN7yTs82Hx+4ONpZjfcveO+VZPXbpbF6lzMVZiUroxZq5y2BXZsqrq3DpdPLef/71tDAxU9erAOfDRNux75pGS7b4MoRV0x0Fw/8OFUWby9VOeGc53OteUXOnXzhTPjb/Rj75PsPjxxzIC7IfcFAAA49ZH7ojjjUH4Tr9wt+xV5XnfVGt5T1ohgszh3/4e/K297vHY9/52av35TSX6TtytBCd/NUWDrBubxx8LIb+qMGaS4D37X9gc/Ldnu1yBKta/sb67vf/93WaxeirlpqNO55Dc1o2/jxrqqUydN2bhRM7YevZvqot17ZLPbzULdc5o3K3fO1Z06lawH+/qWrKfm5umVefP0/ODB+uWaq0u2b0lO1psL/zHXjX1FxcV6dtYsp2v6W61mZ1/UjKYxkbrwzHZO26Yt3qDXf5ijrFznbuuVefTqQY6OuqlZ+mzaEqd9aVl5ZiHw49cM1jdPlL43tu9P1odTHO+Nx692vDde/f6w94avVXkFvDdOpcxXHjxunBg+1TuCL774Qtdff32l+x999FFdddVVx33duLg4ff755+Z6dHS007Rqx2Pv3r1HvQ8AAADcW5OGPlo9q5E+/z5DW3cUqk60t64aGaLWLXyVmlas+59KUp8e/rr1WkcR1w+TM81p1TZvKzQD38H9A80ODbGNCPWqgtEVt1cvHy1eXKjr/5OqF8eFqlcvX7NI96uvcvTTz3nmn7vRYddysFmH/eBv0UZ21q2bjz78IKLket26+uq7byPUr3+SDiTY9OWXObr33tLp8K69NlDt2ls1bVqeWRBsdOi9/PIAszh34qRczZlToJdeClWdOt5m0e4LL2Sa2zMz7YqMtGj06ECz2JdA3zV2r0jWj/ctlZfVSyNf6qomvaLk7eOlPStSNP21dZry9ErtWZmiC5/tfNL36n5FrOq2DtOGv+KUn12kOi1D1fmihmZx7pqpe7VtYaLOf6qjQqL9zaLdGa+vN7fnZxUpMMJX3S5vogG3tpIX743qV/KXgE2h/dqr7k3nlewK6tRUDZ8ere13vaP83QnKmL9WYQNLA3xDSK/Waj3xaXM6xqLkDGWv3q6k72drx73vKebuixV6Zlun4yPO7SH/2BhlLlovW06+/JrUVdjZnc0Pd9LnrFb2ym1m8a8xJaTxoU/Cl9OVMXeNeax3aKDCh3ZX1OUDzCJfADhduXPuS+YLAABwaiD3dTeO/MZeZFNY/3aqd8uwkj3BnZuqyXPXaMvt7yl/V6LS5q1TxFkdzaxm75uTJS+L6t91gTkT17GqNay7AprWVcbCjSrOzZd/kzqKGNTJzG/SZq9R1optqnf7+fI5mN/Ef/6X0uaU5jeR53ZT7VH9yW9cIMTXVy8NHaKknBw98/ffx3TO7vR0/bJ+g0a2a6uXhwxVoM8szdmxwyyyvahNG93Wq6cKiovl6+0t+6Hs8KD/rVqtdQmJOrdFC7O4d2Nion5at84szr2odWsNiG2ix6fPUGJ2tnm9xwb014g2bRTi56fknBzz/Lf++ccsIIbrfDtzhblYvb1UNzJEAzo3043n99aZ7Zrowfd+1b9b9h3x/BvP72UWABuFto98+JvSs/PKHfPTnNXatCdRg7q2UJC/rzbvTdSUhevMc4b1aq0z2zfRC1/NUFJ6tlm0e++l/TWsVxuFBPopNTNHP85erY+m8N4APBEFvCegc+fO+uijj9SjR4/jPtf4j/Mtt9yizMxM8/nYsWPl739iU+E2bNjwhM4DAABAxQ5Nn5adU/kvt9nZjn2hZaZaKzvtWmXnZh08zzw3xDl0i6rlrYfuKC36POSh55KUllGsD16tL4vFosl/ZOmqWw+ob09/jXusluITivTkSykadMk+rZ7dSMFBhHlV4cMPwnXTzWlautQo4k1z2nfjDYFaurRAq1YXKTzc8ecdHFwa3F5zdWC56wUHe2nkxf768KMczZuf71TAe6jI11jKMgqGn302U716+ujqqwLMbXfdnabp0/N1yy1B6tnDR3/8ma8338xWbo5dTz3l3KUTVS8vo1AT7l2qnLQCswtvg46l/59tOaCu2YH3g5GztXLSbnU4v4Fie0ad9D0bdIo0l7Jy0wv05ytr1ahrpLpe0tjcNunxf7VpVrzOGNNcDbtEmuvzPtxsFvYOebD9SY8DR+YV4FeyHj6kW7n9PtFhCu7aQpmLNih79Y5yBbyHGB/I+NQOV/jgrmYH3h33vKf4dyYrsE0jsxtMWQGtGpjL4Z2AEz7/UwFtGynsnK7mtv3jJypr6SZFXniGAto0UtaSjUr+ca5seQWqc71zhxcAgHvkvmS+AAAAVY/cF2Xzm8ih5fMb3+gwhXRrrox/Nip71Q6zgDfxx3nK2xZvdtM1uucer8BWDcylrKLMXMV9Nl2BbRspYkgXc9ve1ycpY8lmRY3obeZAGYs3KXHCPLOwN+Y/55zQ68WxG3vWQNULCdGdU34zO+Qe83l//aUgX18NbdFcb5xXWhBu+G3TJvl4eZv70vLKX3NlXJy5lBXm768nzhqoJXv36vs1a8xtxnUHN2umT5Yt19J9+zSkeXPdfUZvBfpY9eKcuSf8mnHiiozC/sR0/W/Gv1q1db++ePRKPX/DMI0c+4XyCyvugnv1OV11+4g+5n6j2HfVtv2VXn/N9jhzKSs00F8PXD5Q/27eq4nzHO+NF24YZhYRfz19uVZu2aeBXZrr5gt6K8DPqjd+5L0BeBoKeI9gxIgR6t69u7mem5urbdu2acKECZo0aZKuvPJKjR8/XsOHDz+ua7744ovmdGwGowPDHXfcUS1jBwAAwPFr0tDxz+O0dJs5PVrZgPaQPfsLzcfGB481GMdFRngpJdWm3fuK1KmdXwXnOX5xj4r0KplG7UjmLMzVF99n6sn7ItS2laO485V3Us2p2n75MkYR4Y4pvLy8LLrj0UR9OzFTN48OO+HXjlJRUd6a+HOk5s0r0IKFBWYxbXSUl4YM8VenTj7q1i3BPK51a8d7oFGj0vdCo0aOn8vhDh2TkFA67d6RPP98prKybHr55UgzxN+2rUh//JGvESP89cTjIeYx55zjr82bi/TFlzl64IFgBRHkV6st8w4oJ7VAEQ0DnYp3D4loEKT6HSK0c2mSdixKrJIC3ooYnX6NjrzDn+5kvjeSdmRp48x4tT+vvgbf5+jU2mpgXSVuzdTS73Zq4O2t5RvIr/7VyadORIXrTsfUdWwvSnUUdR2Nb+1wBbZvouzlW5S9alulRb9lJXwxXbbcfNW99QLzvZG/L0lZizcqtF8H1b7W8WFPSI9Wyt+dqLTflyp61FnyCnD+8gAAnC7IfQEAAE4v5L7wrRNesu5TZt3pmIP5TWFqlvmYsWiT+Zi5dLMyl291OrYwwdH4wdi+/YmvzPWm46496jjiP5thdtmtf8f5jvxmb5J5n7D+7VV3zGDzmNCeLc38JmXqUtW+coC8yW+qlVEUW1hcrGs6dzKXsppFOporXN6hvfo0bmR2xb1n6jRzW25RkW779Vd1iYkxu+ZGBwUpPS9Pc3fu0qI9e/TjlaPM4zYlJR3TOJ4Y0N/sBvz4jBnm89iICA1t0UKTN2zQy/Pmmdv+3r5dLWrV0ujOnTV+4T/KMaYKRI1ZuyNe2+OS1bx+lNo2qaMVFXThveLszmbxbUFhkR56f4oWrtt53Pe5//L+Cgrw1QtfO94bjetE6OyuLTRt8Qa99bPjvTF39XY1q1dLV5zVWR/8+o9y83lvAJ6ET/GOIDw83FwOMTovjBo1Sl9//bXGjBmjiy66SJ9++qmuu+66Y7re//73P7PzgiE2NlbffvutvLxO/EP2PXv2HHU6tZ49e57w9QEAAE43rZr5KjDAopxcu5atytNZfcp3U12+Kt987NrBOazt0sFPM+fmavmqPF0wJKiC8/JKjjua/Hy7bns4Qa2a+eixu0u7b65cV6D2rXxLQlxD316Orl6r1jnGhaphhKf9+/uZS1k7dxbpQIJNEREWdWjvmL6uaVNvswtvVpZdKSkVF+gaIb8hKOjo06wtWJivCT/m6v77g9W8ueNXtnXrHGFL927OU+YZnXhXrCg0C3m7dCHIrU7pcbnmo19Q5dMW+oVYS7rkVocdS5K0avIeDbitlaJiHYXcBzalm48NOzt36jU68e5bk6rEbZlmYTGqj3/TGMn4v7ZdKs7IkU9U+Q/VjO0GL/9j//+pl5/j2KL07KMem71mh9JnrVTUFQNKOsLk74g3HwNaO3d6MTq55G3Zp/y9iQpoUf+Yx3Oqs9st5uJpPHHMgDtw59yXzBcAAKDqkfvCv1mZ/CYzR4oun98UHcxvvP2d87+c9ZX/G70oNctcjkXW6p1K+3uVal/ZvyS/ydtxwHwMPDy/adtQuZv3KX9PogJbkt9UNx9vb/U+wmwoDcPCzGVvuiOLLWtFXJy5lBXk46O20dFmYbBRzHs0xr0vbd9e4xcu1PaUVHNb29rR5uO/+527tS7bv09d6sWoea1aWh3vyP9Qcw4VykaElP/vyuUDO+mRK892FO9+MEXz1+w47ut3b9VQF/Zprw9+Xaid8Y73RquGjvfG6q3O7w2jgLhD0xg1jamldTt5b3hy5mvw1HHjxFDAewJGjx6t3377zezKcOedd+rCCy9U5MFv3lRm6tSpuv76682p1OrWrasZM2aYjyejQQPnf8QBAADg5Pj6WnTe4CD9NCVL303MKhfk7tpTqIXLHIHsiGHO05lfPCzYDHJ/mJylpx6INDskHGKz2TXhV0eId/F5zudV5MU3U7R5e6H+/rm+/PxKr2OsZec4F4gemrrNKDhF9fvwQ0ch3dVXBZrvF4PVatHQoX76+ec8zZ9foGHDyk+VPG+uI2jv3Lny4s9DIf5jj2WoRQtv3XlH6QcCh368xocMZeXw83eZkNqOn2vSzizlZRbKP8T5Z1lcaFP8BkeAG16/fFh3sooKijXt+VWKahqsvje2KN1x8EdfkOM8PVdh7sHnvDWqnTUiWAFtGil3/W5lr97uKOgtw15UrJx1u8z1Yy2YtRUWKXfjbnPdt16tox574MOp8m0QpVoj+5XuOPj3gi3PuduCLb96CswB4FTgDrkvmS8AAEDVI/eFT0Sw+aXmnPW7lbVyhwIqyG+y1+12ym+aj7+50usd+G6OEr+fq4jBnVX/rguOen8jv9n//lSzcDfqkr6lOw7+eG2Hdcu0H8pz+PlXu87vvlfpvleGDtWl7dvp/+Yv0LuLFx/zNa/p3FkBPj76dcNGJeU4CsMr4+vtrRcGD9KW5GS9v3hJyXb7wY8CjOuUFWj1cT4ANSY82F8tDxbT7j7gKK495JIBHfXo1YNKinfnrT7+4l0fq7cev2aQtu9P1mfTyrw3Dj4G+Dm/Nw49t5ccAcBTMMfqCTK6MBiys7P1xx9/HPHY2bNn69JLL1VhYaEiIiL0559/qlmzZi4aKQAAAI7HI3eGm5nYFz9k6I+/S7se5uTYdNMDCSoulkaeH6TWLZy7KI65PET16npr87ZCPfVyitM+47mxvUE9q669zNE1szLrNxXolXdTdcNVoep/RoDTPqP7w4YthVqwxNEJ1PDxN+nH3OEBx8boZpuZ6RyYFxXZ9fbbWfrmf7lq0sRbd9/t3G3jrjuDZeRo336Xo7/+coT9h7z/QbaWLC2Ut7c05tojF3a++WaWduwo1isvh5UUCBvaH+z2O2lSnnIPFvEa3X5//yNffn5Sy5al3TlQPZr3rS2fAG8V5RXrt2dXORXMGsW7019da3bp9bJa1HZIvSq//9wPNyt5d7aGP91J3j6lv8rHtHF0C1k7bZ8K84rN9ZzUfG2cGSern5eimx757xxUjajLB5iPyRPnK3fT3pLt9mKbEr6YrsIDqfIK8FXY2Z3N7UVp2Ur9Y6mKc8p30SlMzlDcm5NUlJIpn9rhCup05Pwg+ce5KohLVt3bLpDFp/TvgkOFxBlz15R8CGR0kslctFEWX6v8DobLAABn5L4AAACnJnJf1B7V33xM+nmBcg7Lb+I+m6HCeEd+EzG4U5XfO/GHeSqIS1G9O4fLq2x+Y3QGNmb/muOc36T/48hv/Bs6OvXC/TQKC1NkgPP/lw2XtW+n+/qcqdTcXI2bM+eo17mzdy81iYjQ49NnqNBW+rnEuoQE8/Gi1m3kZ3X0ZowI8NfQFs2VV1hkFvyiesXGRGpYr9bytZb//KVRnXC9fMsF8vOxavW2/dq6L6lk38X9Ouixq06ueNdw0/BealQ7Qs9/NUNFxaXvjY27HO+NYb3amPc/VEx8dtfmyisoMgt+AXgWOvCeoOjo0g+6du1ydNKpyJIlS3TBBRcoLy9PwcHB+v3339WxY0cXjRIAAOD09u/qPN35WGLJ8207HQHYR99kaOpfpSHtz5/FKKaO45/GXTv667Wno/TAM0kafk2cBpwRoOgob81fnKu4A8Xm9Gbvv1y73L0CA730/Yd1de6o/frvW6maMj1b7Vr7at3GAq3dWKCgQIt++KiuAgIq/w6d0bXr1ocSFBnurZfHlu+4+Pi9EeaYhl6xX4MHBOpAQpGWrMhX81gfXTni6B0ecGz+922OvvkmRx07+qhuHW8VFNj174pCJSbazOLd776NMH/eZTVvbjWLbh94MF3XXZ+mTh2tatDQW5s2FWnr1mKzePfFF0PVpk3lHXg3bSo0i32vuTpAPXo4f1AQG2vVRRf5a/LkPA0anKT27a1atqxQSUk2s1Pv4eNB1QuK9NP5Yzvq16dWav30/dq5NEn12ofL2+ql/evSlJmQJ4uXdO6jHRTRoLTAOzMxTxPuXVryPOOA44OYTbPjlXD1vJLt5z3RQTFtS6fyLitha4YWfr5V3S5trEZdnP9uiGwUrPbD6mvt7/v0/sWzzILePStTlJ1SoD43tJBvIL/2u0JQx6aKuvIsJX03S7ue/FwBzevLOyJY+dvjVJiQZn7gUu++S2QNd/xdbSso1IGPpinhsz/lF1tXPtHGz96uwqQM8xyj64s1MkT1H7lCXr6V/wzzdyco+ZcFCh/SzewiU5ZvTKRC+7VXxry12nHve/KPjVHOxj0qTs9WrZF95eXv/PfMac/4boQnNqfwxDEDbo7cFwAAwP2R++JEBHeKVe2rByrhf7O1/bEvFdiinjmzUu62+JL8puGDI0vym6qStztBSZMWKnJoNwW1aei0zy8mUmH92yl97jptuesDBTStq5yNe838JurSPuQ3bmxQs6Z6tH9/s9B2f0am+QWBDnXqqEFYmJKys3X9xElKzC79+6giLWrV0s09eui7Vau1fP9+p3270tLMDr4XtmmtP8dca96nW716igoK0nuLFyu3yHlGNlS9yJBAjbvxPD1xTYE27UnQgdQs+Xh7q26tELVuVFveXl5mseyjH00tOcfoyPvENYPNbu37DqRrULeW5lKRZz7/s9J7N61XS2OG9tDPc1dr1Tbn98aexDT9vnijWVz847PXauPuBHVqVk+1QoP02bTFZhEvPDzzlQePGyeET/JO0L59+0rWjYC2IqtXr9a5556rrKws+fv7a8qUKerVq5cLRwkAAHB6y8iyafG/5bsb7t1fZC6H5Bc4/xZ07y3hat/GV69/kKalK/PM6coa1bfq0btC9ejdEQoJrjiM7dMzQCtmNtQLb6Rq5rwcTZyapeha3hp9WYjG3h+pZk0qL940fPR1hhYszdP3H9VVeFj5b/See3aQfvkyRi+8nqI/Z2UrMMBLV4wINoNnCjirztln+WnvnmKtWVuo1asLzU64TZtadfPNQbpuTKACAiqetuyyywLUooVV772fpSVLCrV+Q5EiIrw0fLi/brk5UF26+B4xxH/k0QxFRnrpsccq7tbxxuthql/fW5Mm5WrGjHzVi/HWE0+E6NZbjtzVF1Wn4/CGqt0iVIu/2a7dy5O1Y3GSGaIER/upw/n11fOqpqrfIcLpnOICm/atcZ4+y5CTWmAuh+RnF1X63vjtuVVmAfGge9tWeMxFL3RRaEyA1k7daxYGh9UN0OD72uqM6+gA6EpRl/U3p1hM+W2Rcjfvk23bPvMDn7CzOivy4j7mFImHWMOCVPu6IcpZv8sswi3YmyhbQZG8g/zl37KBgru3NItyvQMr77JjvDfi3/9N1tAgRV8zuMJjYu4cIWtUmNmFN3PZJvnUClPktYMVedGZ1fJnAACnAnJfAAAA90fuixNV+/J+CmhRT8lTlpj5Te7W/WZ+E352J0VfcqZTflMVjPxm/7tT5R0apDrXnl3hMfXvvkg+UWFKm7NWmUs3m1lOnTGDFHXxGVU6FlSt5fv2648tW9Spbl21jIoyf9Z70tP11j+L9Ony5crML/931OHGnTNYKTm5emVeaaOHsh764w/tz8zQhW3aaFCzZorLzNR/58zVx8uWVcMrwuG27U/WO5Pmq0vz+moSE6lWDWvL6u2l9Ow8LdmwW3+v2KpfF6xTYZFjZjxDSICfWbxriI2pZS6VOVIB75OjBys1M1dvT6z4vfH0538oPiXD7MI7oFMzxadkavyPc/XVdN4bgCey2I3/iuC4nX/++Zo2bZq5PmvWLA0cONBp/+bNm9W/f38dOHBAPj4++uWXX3Teeee5dIx79+5Vw4aOb3Dt2bNHDRo0cOn9AQDA6cMW36KmhwA3FVeUVdNDgJv6KLVnTQ8BbmrC1i41PQS4GaMz8bab36jyfKNsbtLkgwfMAmdPU5icrp23/p+5TvYDnB65L5kvAABwFTJfVKbTkitreghwU9lbKp5hDAjfWNMjgDsqyE7Tuu+er9KM41TIfA3kvqcXvq51mC+++MKc9uxI3njjjZIQNzY2Vv369XPav3v3bg0ePNgMcb29vfXtt9+6vHgXAAAAAAAAAOBA7gsAAAAAAADA3VhregDu5plnntEDDzygSy65RH379lWzZs3MqdIyMzO1Zs0a/e9//9OCBQvMY319ffXRRx+ZYe0hycnJZohrVL8bjGu1bt1aa9eurfSeERERql+/vgteHQAAAAAAAMqxW2S3O6a38yg1MGajgPHTTz/V1KlTtWvXLjMzi46OVpMmTXTWWWfp8ssvV/v27Ss9//fffzfztKVLlyoxMdE8t0ePHrr55ps1bNgwl74WnF7IfQEAAAAAAE4jnpr5Glw8bjLfmkUBbwVSUlL08ccfm0tljNbUn332mRnalmWEvVu2bCl5/sorr5jLkYwZM8bsAAEAAAAAAAC4q7fffluPPfaYsrOzy01NZyzz589XRkaGxo8fX+5cm81mBrZGEFzWvn37zOWXX37RjTfeqA8//FBeXkwahupB7gsAAAAAAACUIvOteRTwHubPP/80q8mNbgtbt241p0MzuisEBASodu3a6ty5s4YPH25WlgcGBtb0cAEAAAAAAIBq98ILL2js2LHmesuWLXXTTTeZXRTCwsLM7GzFihWaNGlSpUHsE088URLkdunSRQ8//LDZAXXbtm1mEaRx/ieffGJ2Z3jxxRdd+tpweiD3BQAAAAAAAEqR+boHi91ut9f0IFA9jCr4hg0bmuvG1G5G9wgAAIDqYItvUdNDgJuKK8qq6SHATX2U2rOmhwA3NWFrl5oeAtxMYVKGtt38RpXnG2VzkybvPyhrrTB5mqLkdO287bVqz35mzpxZ0o302muvNUNXHx+fCo8tKCiQr6+v07bNmzerXbt2KioqUvfu3TV37lyzaPKQnJwcDRgwQMuWLZPVatWGDRvUvHnzanktgKcj8wUAAK5C5ovKdFpyZU0PAW4qe0t4TQ8Bbip8Y02PAO6oIDtN6757vkozjlMh83VV7kvm6z7oTQwAAAAAAIDTmvH1dk9dqpsxDdptt91mrnfq1MnsqFBZkGs4PMg1GNOrGUHuoSnZyga5BqPbqbHdYBz3xhuOgm0AAAAAAAAAOBE1ndu6c+5L5uteKOAFAAAAAAAAUKHp06dry5Yt5vojjzxidks4HsbkX5MnTzbXW7durd69e1d4nLG9VatW5rpxPJOGAQAAAAAAAEDVI/N1LxTwAgAAAAAAAKjQjz/+aD5aLBYNHz68ZHtKSooZ8hqPR7Jjxw7t37/fXDemTDuSQ/v37dunnTt3VsHoAQAAAAAAAABlkfm6Fwp4AQAAAAAAAFRo0aJF5mOTJk0UEhKib7/9Vh06dFCtWrXUsmVL89HoovDaa68pPz+/3Pnr168vWTe6MRxJ2f0bNmyo0tcBAAAAAAAAACDzdTfH1/8YAAAAAAAAOMXY7RZz8TRlxxwXF3fU4xs0aHBc17fZbNq4caO5HhUVpXvuuUdvvfVWueM2b96shx56SJMmTdLUqVMVHh5esm/v3r3HfP+GDRuWrO/Zs+e4xgoAAAAAAAAAnp75VnfuS+brfijgBQAAAAAAADxcz549j3qM3W4/rmump6ebga5hzZo1Wrp0qWJiYvTqq6/qvPPOk7+/v7ntkUceMbs2LFy4UP/5z380ceLEkmtkZmaWrAcHBx/xfkFBQSXrWVlZxzVWAAAAAAAAADjVVHXuS+brfrxqegAAAAAAAAAA3E92dnbJel5engIDAzVr1ixdffXVioiIUEBAgPr376+///5bnTp1Mo8zOjIsXrzY6bxDfH19j3g/Pz+/kvXc3NwqfjUAAAAAAAAAcHoj83U/dOAFAAAAAAAAPNySJUvMTglVyei2UNaNN96oVq1alTvOCHXHjRun4cOHm89/+OEH9erVq9w1CgoKjni//Px8p2sCAAAAAAAAwOmsqnNfMl/3QwEvAAAAAAAATm92i2PxNGXGbIS4DRo0qNLLh4SEOD0fMmRIpccOGjRIVqtVRUVF5hRrFV3jaFOkle3+cLSp1wAAAAAAAADglMt8qzn3JfN1P141PQAAAAAAAAAA7seY3iw6OrrkecOGDSs91ui6EBUVZa4nJiaWbC8bLu/du/eI99uzZ88x3QsAAAAAAAAAcPzIfN0PBbwAAAAAAAAAKtSuXbuS9eLi4iMee2i/0ZXhkLZt25asb9y48Yjnl93fpk2bExovAAAAAAAAAKByZL7uhQJeAAAAAAAAABXq379/yfr27dsrPS4jI0NJSUnmev369Uu2x8bGql69eub6nDlzjnivuXPnlpzfpEmTkx47AAAAAAAAAMAZma97oYAXAAAAAAAApzW73XOX6nbJJZeUrE+aNKnS44x99oMD6tevX8l2i8Wiiy66qKTbwqJFiyo839h+qBuDcbxxHgAAAAAAAACciJrObd059yXzdS8U8AIAAAAAAACoUMeOHTVs2DBz/bvvvtPMmTPLHRMfH68nn3zSXPf19dX111/vtP/ee++Vt7e3uX7XXXcpNzfXab/x3Nh+aCo243gAAAAAAAAAQNUj83UvFPACAAAAAAAAqNT48eMVHh4um82m4cOH67HHHtO8efO0bNkyvffee+rRo4f27t1rHvv88887TadmaNmypR566CFz3TinT58++uGHH8x149F4bqwbjONatGhRA68SAAAAAAAAAE4PZL7uw1rTAwAAAAAAAADgvowwdsqUKbr00kt14MABvfTSS+ZSljH92RNPPKGHH364wmuMGzdOCQkJ+uyzz7RixQqNGjWq3DE33HCDXnjhhWp7HQAAAAAAAAAAMl93QgEvAAAAAAAATm/2g4unceGY+/btq3Xr1untt9/WL7/8oh07dqigoEAxMTEaOHCgOR1aly5dKj3fy8tLn376qS655BJ99NFHWrp0qZKSkhQVFWV2c7jllltKpm0DAAAAAAAAgNMy85Xrxk3m6x4o4AUAAAAAAABwVLVq1dIzzzxjLifqvPPOMxcAAAAAAAAAQM0i8615XjU9AAAAAAAAAAAAAAAAAAAAAOB0QgEvAAAAAAAAAAAAAAAAAAAA4EJWV94MAAAAAAAAcDd2u8VcPI0njhkAAAAAAAAAqpunZr4GTx03TgwdeAEAAAAAAAAAAAAAAAAAAAAXooAXAAAAAAAAAAAAAAAAAAAAcCEKeAEAAAAAAAAAAAAAAAAAAAAXsrryZgAAAAAAAIBbstf0AAAAAAAAAAAAVYbMFx6ADrwAAAAAAAAAAAAAAAAAAACAC1HACwAAAAAAAAAAAAAAAAAAALiQ1ZU3AwAAAAAAANyN3W4xF0/jiWMGAAAAAAAAgOrmqZmvwVPHjRNDB14AAAAAAAAAAAAAAAAAAADAhSjgBQAAAAAAAAAAAAAAAAAAAFyIAl4AAAAAAAAAAAAAAAAAAADAhayuvBkAAAAAAADgduwHF0/jiWMGAAAAAAAAgOrmqZmvPHjcOCF04AUAAAAAAAAAAAAAAAAAAABciAJeAAAAAAAAAAAAAAAAAAAAwIUo4AUAAAAAAAAAAAAAAAAAAABcyOrKmwEAAAAAAADux3Jw8TSeOGYAAAAAAAAAqG6emvnKg8eNE0EHXgAAAAAAAAAAAAAAAAAAAMBTO/Cmp6frp59+0j///KP4+Hjl5OTo888/V+PGjUuO2b9/v9LS0uTv76+mTZtW5e0BAAAAAAAAAFWM3BcAAAAAAAAA3LiA95133tETTzyhrKws87ndbpfFYlF2drbTcbNnz9Y111xjBrl79+5VZGRkVQ0BAAAAAAAAAFCFyH0BAAAAAAAAoHp4VcVFnn76ad1zzz3KzMyUr6+vunXrVumxo0aNUt26dZWfn6+ff/65Km4PAAAAAAAAnDi7By9wmYKCAs2cOVNPPfWUzj//fLVp00YRERFmHhoUFKT69evrjDPO0I033qiPP/5Yu3btkqcj9wUAAAAAAIBHquncltzXIxS4QeZ70h14ly9frhdeeMFcNzosvP322woLC5OXV8W1wcb2yy67zDxuxowZuummm052CAAAAAAAAABQLebOnatPP/1Uv/zyS0kX2kOdaA8pKipSbm6u4uLitGTJEn3++efm9k6dOmn06NG67rrrzODXk5D7AgAAAAAAADgVzXWjzNdaFVOoGQM/88wz9dVXXx3TOUZVshHkrlmz5mRvDwAAAAAAAABV7qeffjILWA9lmGXD29jYWNWuXVuRkZFmSGsEuSkpKUpNTdX27dtLQt+VK1dq1apVevLJJ81A97HHHlODBg3kCch9AQAAAAAAAJxKfnLDzNdaFdXIFotFd9555zGf06RJE/Nx3759J3t7AAAAAAAAAKgyRt557733miHsoQC3Q4cOuuSSS9S7d2/17NlT4eHhlZ5vnLN+/XqzK4Mx/drkyZOVnZ2tDz74QJ999pl57SeeeELBwcFyZ+S+AAAAAAAAAE4Fc9048z3pAl6jRbChVatWx3yOv7+/+Zifn3+ytwcAAAAAAABOjpHXlX7R3nN44pg9wMCBA81Ho9PCzTffrKuuukrt27c/5vONotd27dqZy/XXX292ajAC3U8++UR///23XnnlFQUGBmrs2LFyZ+S+AAAAAAAA8FiemvnKg8ftxga6ceZ70gW8vr6+ZiCblpZ2zOccOHDAfDxS1TIAAAAAAAAAuFpUVJQefPBB3X777VXSJTcgIECjRo0yl0WLFum5556TJyD3BQAAAAAAAHAqiHLjzPekC3gbNWqkdevWacuWLTrrrLOO6Ryj6vh4uzcAAAAAAAAAQHXbtWuXGcBWB2M6tmnTppkdGtwduS8AAAAAAACAU8EuN858T7qAd9CgQVq7dq0++OADs73w0ezbt08fffSR2VZ4yJAhJ3t7AADgQrb4FjU9BLiphOLsmh4C3FSazaumhwA39U9ybE0PAW4qJzmwpocAN1OUWlDTQ8BpprqCXFff42SR+wIAcHog80Vlevx7eU0PAW4q2D+/pocAN1WYZqnpIcBN+acV1/QQ4IYsObaaHgJOIwFunPme9Kfpd955p3x8fLRq1So9//zzRzx206ZNOvfcc5Wenq7AwEDdcsstJ3t7AAAAAAAA4OTYjcXigUtN/8HhVEbuCwAAAAAAAI/lsZkvue/p5qQ78DZr1kzjxo3Tww8/rGeeeUZTp07VyJEjS/b/+OOPZtC7YMECTZ8+XTabzezCMH78eEVHR5/s7QEAAAAAAADALWRnZysjI0OhoaEKCgqSJyP3BQAAAAAAAHC6y67mzPekC3gNDz74oOx2u5588kktWbJES5cuNcNaw3PPPVdynHGMt7e3XnvtNd1www1VcWsAAAAAAAAAqDEFBQVm3vnFF19o27ZtJdubNm2qMWPG6KGHHpKfn588EbkvAAAAAAAAgNNNgQszX68quYpkDmrlypW6/vrrFRUVZYa2ZRejAvnKK6/UihUrdM8991TVbQEAAAAAAACgRmRlZalfv34aO3astm7d6pSHGsHu008/rb59+yozM1OeitwXAAAAAAAAwOkiy8WZb5V04D2kTZs2+vTTT8313bt3KyEhQcXFxapVq5ZZfezlVWX1wgAAAAAAAECVsNsdi6fxxDGfaowutEZX2tatW+uFF15Qnz59FB4erj179uh///ufxo0bp3///dc87tVXX5WnIvcFAAAAAACAJ/HUzNfgqeM+VTzn4sy3Sgt4y2rUqJG5AAAAAAAAAMCpaMKECeZUabNmzVKdOnVKtjdv3tzsxBAQEKBHH31UP/74o0cX8JZF7gsAAAAAAADgVDXBxZkvrREAAAAAAAAAoIwxY8YoMTHxqMfFx8erWbNmTkFuWcZUa4eOAwAAAAAAAADUjDFumvmedAGvt7e3uRhTpa1Zs+aYzlm3bp05rZrVWm0NgAEAAAAAAADghHz99dfmFGnvvPOObDZbpcfFxMRo27ZtOnDgQIX7586daz7WrVtXnobcFwAAAAAAAMCp4ms3zXxPuoDXbreby86dO9WnTx9Nnjz5uM4FAAAAAAAAapTdgxdUi4ceekhZWVm655571K1bNy1cuLDC4y655BLl5+dr0KBBZi5qdHAoKCjQ9u3b9fzzz+upp56SxWLRZZddJk9D7gsAAAAAAACPVdO5Lbmv23nITTPfky7gNRgD8vHxMV+g8QJefPHFqrgsAAAAAAAAALjcyy+/rJUrV2rgwIFatWqVOS3addddp4SEBKfjnn76aXXu3Fnr16/XyJEjza4LAQEBatGihZ555hkVFhaa+41Q1xOR+wIAAAAAAAA4FbzspplvlRTwGr7//ntzkEZ74bFjx+rqq682K5EBAAAAAAAAwNO0adNGM2fO1LfffmtOm/bVV1+pVatWevvtt0umWAsJCTE7NRihbmxsbEnXWmNp0qSJGeguWLDAPM5TkfsCAAAAAAAAOBW0ccPMt8oKeI0XsmTJErN1sDFYI9gdMGCA4uLiquoWAAAAAAAAQNWzWzx3QbUbNWqUNm3apPvvv1/Z2dm69957naZY8/f3N8PcrVu3KiMjQ3v27FF6erq2bdtmdmEw9nsycl8AAAAAAAB4nJrObcl93dooN8p8q6yA1xAWFqY//vhDt99+uxnmLl26VD179tS///5blbcBAAAAAAAAAJcJCgrSa6+9Zk6x1r9//0qnWAsODlb9+vU9uuNuRch9AQAAAAAAAJxKgtwk863SAl6Dt7e33nnnHb333nvm+r59+8wXNmHChKq+FQAAAAAAAAC4TNu2bTVr1ix98803qlOnToVTrJ2qyH0BAAAAAAAAnGra1nDmW+UFvIfceuut+vPPPxUZGanc3FxdeeWVZvtgAAAAAAAAAPBkV111lTZv3mxOrVZ2irUFCxboVEfuCwAAAAAAAOBUc1UNZb7VVsBrOOuss7Ro0SKzItmYWm3cuHG69NJLzRcIAAAAAAAAuAOLsdg9cKnpP7jTRHFxsdavX69//vnHfCwqKiqZOu3111/X8uXL1adPH3OKNWOqtTFjxjhNsXYqIvcFAAAAAACAO/PYzJfc97TLfKu1gNfQvHlzLV68WEOHDjXD3EmTJmnkyJHVfVsAAAAAAAAAOGGpqam65ZZbFBYWpg4dOqhv377mY3h4uG6++WalpKSYxxnb5s6dqy+//FK1a9fW119/bRa2vvXWWy6ZYq2mkPsCAAAAAAAA8CSpbpj5VnsBryE0NFRTp07V3XffbYa5cXFxrrgtAAAAAAAAABy35ORk9e7dW5988olycnLk7e1tBrXGo/H8008/NfcnJSWVnDN69Ght2rRJd911l7KysnTfffepa9eu1T7FWk0i9wUAAAAAAADgCZLdNPM96QLeRo0amYuvr++Rb+TlpfHjx+vDDz+U1Wo92dsCAAAAAAAAQLV4+umntWXLFoWEhOjbb79Vbm6uWZxqPBrPjcLVbdu26ZlnnnE6z9j+5ptvmlOsnXnmmVq9enXJFGuehtwXAAAAAAAAwKniaTfNfE+6gHfnzp3asWOHOWXasbjpppu0Zs0azZo1S3///ffJ3h4AAAAAAAA4OXYPXlAtJk+eLIvFopdfflmjRo0yuzAYjEfj+UsvvWR2nDWOq0jHjh01b948ff7554qKitI333wjT0PuCwAAAAAAAI9V07ktua/bmeymmW+NtERo2bKluQAAAAAAAACAu0lMTDQfO3fuXOH+Q9sPHVcZowvDiBEjNHbsWJ0OyH0BAAAAAAAAuKNEN818T7oDLwAAAAAAAACcSurVq2c+zp07t8L9RqcFQ0xMzFGvFRYWprfeequKRwgAAAAAAAAA8PTMlwJeAAAAAAAAACjjsssuM6dLM7oovPLKK9q9e7cKCwu1Z88evf7663rqqafM6daM4wAAAAAAAAAA7u0yN818rcd6YNOmTc1HY5Dbtm0rt/1EHH4tAAAAAAAAwOXsFsfiaTxxzB7CCHH//vtvLV++XI899pi5lGUEvcaUalU1TVpNIvcFAAAAAADAKcdTM1+Dp47bzY1108z3mAt4d+7cWRK+VrT9RBx+LQAAAAAAAACoacHBwZo/f77ZieHLL7/U9u3bS/bFxsZq9OjReuSRRxQQECBPR+4LAAAAAAAA4FQX7KaZ7zEX8I4ZM+a4tgMAAAAAAACAp/Lz8zO7LRhLVlaW0tPTFRoaqpCQEJ1KyH0BAAAAAAAAnA783DDzPeYC3s8///y4tgMAAAAAAADAqdKdwVhOReS+AAAAAAAAAE43wW6S+R5zAS8AAAAAAABwSrIfXDyNJ44ZAAAAAAAAAKqbp2a+8uBx44R4ndhpAAAAAAAAAHDqycvLOyXuAQAAAAAAAACQW2e+Lingzc/P18yZM/XDDz9oyZIlrrglAAAAAAAAABy32NhYvf7668rNza3yaxvZ6PDhw/Xqq6/qVEDuCwAAAAAAAMDdxbpx5nvSBby7du3Sww8/bC5paWnl9i9atEjNmjXTkCFDdNVVV+mMM85Q9+7dzfMAAAAAAAAAwJ0cOHBADz30kJo0aaKnn35amzdvPunOCxMmTNDQoUPNbPT333+XJyD3BQAAAAAAAHAqOODGme9JF/BOnDhRr732mv766y+Fh4c77cvIyNCIESMUFxcnu91esvz77786//zzVVhYeLK3BwAAAAAAAE6O3YMXVDkj52zXrp0SExP1wgsvqE2bNurRo4deeuklzZ49W5mZmUe9xoYNG/Tll1/q2muvVZ06dXTllVdqxowZCgwM1BNPPKH77rtP7o7cFwAAAAAAAB6rpnNbcl+38pcbZ75WnSRjEBaLRRdddFG5fR999JESEhLM/XfffbcGDRqkP//8U++9917JC7rxxhtPdggAAAAAAAAAUCXOPvtsrVq1St99953GjRtn5pjLly83i1MNRtbZtGlT1a5dWxEREeZiTL2WkpKi1NRUbdu2TVlZWSXXMwpbAwICdN111+mpp54yw11PQO4LAAAAAAAA4FRwthtnviddwLt9+3bz0Zge7XBGm2DjxY0cOVLjx483t11wwQVmJfOPP/6on3/+mSAXAAAAAAAAgFsxMs2rrrrKXIzuDJ988ommTJlihrZGOLt161YztD2csa+sjh076qabbtI111yjsLAweRJyXwAAAAAAAACnCoubZr4nXcBrhLKGmJgYp+3p6eklFcpGpXFZo0aNMoNco6oZAAAAAAAAANzV4MGDzSU/P1+LFy/WvHnztHDhQu3du9fMRo0uDP7+/oqOjjaXDh06qF+/fubSuHFjeSpyXwAAAAAAAACnosFulPmedAFvZmam+VhcXOy03XhBNptNVqtVAwcOdNrXsGFD89F4oQAAAAAAAECNMr5A7/wles/giWP2YH5+furfv7+5nA7IfQEAAAAAAOCxPDXzlQeP2wP5uUHm63WyFwgPDzcf9+/f77R99uzZ5mPnzp0VFBRU4blGlTIAAAAAAAAAwL2Q+wIAAAAAAACAmxfwtmvXznycNGlSyTajK8OECRNksVjKdWEw7Nu3z3ysU6fOyd4eAAAAAAAAAFDFyH0BAAAAAAAAoHpZT/YCF198sebMmaOvv/7aDGb79etnru/atcsMci+//PJy5yxbtsxpSjUAAAAAAAAAgPsg9wUAAAAAAAAAN+/Ae8stt6hNmzay2+167bXXdNFFF+mnn34y911wwQXq3r17uXOMrg1GyNu7d++TvT0AAAAAAABwcuwWz12AakLuCwAAAAAAAI9V07ktuS9cVcDr5+enmTNnauTIkbJarWag6+Pjo9GjR5sdGQ43d+5crV+/3lwfOnToyd4eAAAAAAAAAFDFyH0BAAAAAAAAoHpZq+IidevWNbsv5OfnKyUlRbVq1ZKvr2+FxxrTp82aNctc79u3b1XcHgAAAAAAAABQxch9AQAAAAAAAMDNC3jLdmWIiYk54jGxsbHmUpnExES9//775vpTTz1VlcMDAAAAAAAAABwncl8AAAAAAAAAcPMC3qqQkJCgZ555RhaLhSAXAAAAAAAA1c5idyyexhPHjNMXuS8AAAAAAABcxVMzX4OnjhsnxusEzwMAAAAAAAAAAAAAAAAAAABwAijgBQAAAAAAAAAAAAAAAAAAAFzI6sqbAQAAAAAAAG7HmJLME6cl88QxAwAAAAAAAEB189TMVx48bpwQOvACAAAAAAAAAAAAAAAAAAAALkQH3gokJCRoyZIl5rJ06VJzSU5ONveNGTNGX3zxxXFf86+//tI333yj+fPnKy4uTlarVXXq1FHHjh01aNAgjR49WsHBwdXwagAAOPVt2lqgGXNytHx1vv5dna8NWwpUXCw993Cknrgv8ojn/jU3R298mKalK/KUnWtX4/pWjTw/WI/eHaHgoMq/67R1R4HGjU/VzHk5SkwuVnQtbw3qF6ix90eqaWOfCs/5dmKm/vtmqrbuLFCdKKuuvzJET94XKW9vS7ljs3Ns6jBgtzmGZdMbyte3/DE4efv2F+vdd7P09+x8xcUVKyjIoo4dfXTjf4I0eJB/pefZbHb99HOuuaxbX6SsLJvCw73UorlVw8/313VjgpyOz8mx6flxmfptap4yM21q28ZHjz8Wor59/Cq8/oy/8nTtdal69JEQ3XMX/0asCXH7i/XZ+5maNztfB+KN94aX2nbw0dXXBWlABe+NebPyNOP3PG1cX6iE+GKlp9vk42NRw8be6neWv8bcGKSISO9y5xnvjddfzND03/OUlWlTqzY+uvfhUPWq5L0xe2ae7vxPiu5+KEQ33xlSLa8dlcuNz9D8Kz8/pmO7j79UEZ3qm+t5CZlKWrRTGZsTzCVrZ7LshcWqd147tXtocKXXKM4t1OYP5yth7hYVZRUouFmUWtzUR5FdG1Z4fOI/27Xy8SlqfsMZir2m5wm+SpyI5M8mKPuf5Uc8puF7L8jiU/pvhKwFy5TyxY9HPCf6nv8ooH2rctsz/pqvrL8Xqig1TdbIcIUM7quQs86s8BpFqemKe/r/5BfbSLXvu/GYXxNwOtu9e3e1XLdRo0bVcl0cO3JfAAA8C7kvToatsFhJv/+r1HkblLc7Sbb8QllDAxXQJFqRgzsqsn/bcufYbXal/L1GKX+vVe6OAyrOKZB3iL/8G0Ypok9rRQ/v5nR8cV6B9n32t9IWbFRxdr4CYuuo/nUDFdKpSYVjSl+yRdue/VH1rh2gulf0qbbXjqO/Nw5MXamUuRuVsyvZfG/4hAWY743oc9oramCbkmMXDX3lmK7Z7MHzzHPLvjd2fzJHKfM2qSg7X4FNa6vRf/orrHPjCs9PXbRVm56eqIbX9VP9K8+ogleJk/XgkH66sV93c338Xwv0wZwlJfssFqlzgxj1bdFEvZs2VLPoSAX5+Sorr0Dr4xI0acV6/bZ6Y4XXDfCx6sGh/TS0XQuF+PlpY3yiXp+xQIt37Knw+IEtY/XB6BF6Y8Z8fTh3aTW9WlTE29tLnds0UO8useratqEaxIQrwM9H6Vl5Wr81TpNnrNbCf7dXer7xPjm3fzud27+tmjeJVlCArzKy8rRrX4pm/bNZE6evdDre389Hd1zTX2f1bqmgQD9t3ZWoD76dq+VrK35vnNm1qV57bKQ++Haevpq0uMpfP3Cq2e3GmS8FvBUwAtaqkpqaquuvv16TJ08uty8jI0NbtmzRzz//rDPOOEOdO3eusvsCAHA6+eDLdL31Sfpxnzf+wzQ98EyS+QtUv17+qh1t1fzFufrvW6maODVLcyc3UFSt8gV3C5bk6txR+5WTa1e7Vr7q0zNA6zYW6KsJmfr5tyxNn1Bfvbs5F/j9NiNbo+84oIhwL503KEir1uXruf9LVXKqTW+Niy53j7EvJWv3viLNnVyfELearFxZoKuuSVFqml116njprLP8lJpq08KFBZozp0D33xushx4sXyCZkWHTmOtTtWhxgUJCLOrezVdhYRbFxdu0dl2hMrPs5Qp47743XVOn5al1K6u6dfXRnLn5uvLqFP3ycy116+brdGx2tk2PPp6uNq2tuv1W5+vANdasKtCt1yYrPc2u6Npe6jfQX2mpNi35J18L5+br1nuCdef9oU7n/PZLrqb+kqtGTbzVvJVVkZHeSkuzae3KAn3ybpYm/pCjz76rpeYtnT/oeeL+NLPwt0Urqzp18dU/8/J1y7XJ+vLHKHXq6vzeyMm26YUn09WitVXX30IRSE3wDvBRzNDSAP9w2btSlLHxgLwDfRXasnbJ9gNzt2rzu3OP+35rX5quhLlbFRxbS2FtYpS8fLf+ffgXdX/rUoW3jXE6tii3QBvHz1Jw01pqPMr5wyS4jl/zJrJG16p4p6XiD4iN443zKuId7vx3jSHz74VK+2GKvMNCFNChtfK371bqt5NlLyxS6JD+5Y439qnYpshrLj7elwOctmJjY6v8mhaLRUVFRVV+XRwfcl8AADwLuS9OVEFShraO/d4s3LWGBiiobQN5+/uoIDFTWWv3yMvfp1wBb3F2nrY996Njf6CfgtvUl3eQvwqTM5W77YBsOfnlCnh3vT5FaQs2yb9xtIJa1VfGyh3aMvZ7tXpltIJa13e+fm6Bdr/3p/ybRKvOJb1d8ueA8vITM7Xx8QnK3Z0sa1iAQtrVN98bxvbMNXvN9bIFvFFlinIPV5CQoYxVuyWLFNrR+Qv3216dppT5mxXQJErBrespfcVObXz8R7X9v6sU0qZeuffGjndmKDA2WjGX8aV8d9ClYYyu79PVbObi5VX+7+qGEWH67uZR5npaTq7W7jug9Lx8c3uf5o3N5fwOrXT391NUWGxzOvelS841i3c3H0jSqj3xOrNZI30y5mJd88kErdob73RsoK+PnrrgbG2KT9Sn84/cPABVr0vbBnrrqcvN9aTULK3euE+5+YWKbVBL/bo3N5dfZvw/e/cB3VT5hgH8aZOme+/Slln23nvvJSAiIkNEVFQcKAqCgOJeiAMFxx9RZIqAIFv23qvM0kn3btOkTZr+z/0uHaGlLXQGn985Obm5I7mhH23y5M37nceny3YVOtbWRoVP3xqJVo39kJ6RiYvXIpGu1sLdxQ4BtTxgY60qVMD7zkuDRPFuUFgcLt+IQrvmNbFozmhMm7da3C7I2soCb0ztK4p8V25mYTeRqWe+LOAtRZV0w4YNsXPnzvs+NiUlBf369cPp0/If0pEjR2L06NGoW7cuFAoFwsPDsX//fhHkEhER0YNr0lCF16c5oWVTS7RuZimC2N/XpxV7zNmLmXjj3XgoFMCmX70xqI9tXjfMEU9FYc9BDaa9FYt1PxkXSEnbxz4XLULcWdOd8cHb+UU6cz5MwMffJGHss9G4csgf1tb5hTrzP02ASjPbaQgAAQAASURBVAUc2eKL+nVVotNC+wHhIoR++xVneHnkvyw7dU6Lb39JwfOTHNG5nXU5/ktRLq02B1OeTRLFu48Mt8KiL5xgbW2WX9g7IRFffpWO9u1V6NE9vxNqTk4OJk+Ri3cnjLfB/HfsRWfWXFlZOQi8ojN6LKmoVyre7dZVhVUr5c4bBw9lYszYRHz1dTp++9W4W8hHn6QhOtqAZd87iw6uVLkytTl47fkkUbw7cJgV3v/cGVZWZnmFvdMmJeKHxelo3U6Fzt3yP7CZ/KwdZs5xgJuHolDR7Tszk7Fjqxbz30zGyo35H9xcvawTxbsdu6iw9DdXMTaOHcrEM08mYOk3aVjyP+MiwMWfpYnuvl9858axUUVUjtZoOqv/PbefmbVRXHv1qi+KfXNZeznAb2QLUdRrH+COmH03EPx78aFa2s04Ubwrddtt/ekImCnM5QLeN/5C8G8n0OqjR4z2v/nTUWjj1Wg3fzDMlYU/hKTKYdu1Hey6yJ05Sksq3nV9Wg6CS5JjMCDl790wt7OF1/zXoLC3RXZqOqLmfYGUrf/CvncXmBX4+WecuQTNuctwGj343oXFRFSI9JqPHn7MfYmIiKo/5r70IKRuqjfmrEJmRAK8n+wGrzGdjd4rG7Q6aG8nFnoPELRwvSjedRvUCjWm9IHCWmXUsVUTEmt0TEZQjCjelbrt1ls4VmQ3UgHvzTmrELX6MOotMH6vH7linygGrjNrpNH5UOWOjSuz10AbngjfCV3gM7ajUY6WXcTYqPfG4HveX/A3O0UBr2OrWrD0dMxbrw6KEcW7Di1rotGHj4mxkXI2FFdmrcHtP46g4cLRRvcTvvwgshLSETDnEeZ61YCVhRIfjRqAuDQ1Lt6OQb/G9QrtI8UGR4PC8POhUzgSFAZDgRyhXa0a+GH8CPRqWAdTu7XDkn35nVEbermL4l3pmGd+3SCOkzr4Lp88GtN6dsDzvxt/QfTVvl3g6WCH19Zshd5gXAhMFU/627D32HWs3Xoa56/eNtrWp3MDzH95CEb0ayEKe7cfCDTa/vHMEaJ496+d5/Dtb/uh0eZ/dqhUmqOev/GXfAJquYvi3ZMXQvHaB+tF8Xibpv74Zv4YPPVoR8z8+C+j/Z97oqsoBn7ny7+RfVeROBGZXubLAt4izJs3D+3atRMXqStDSEjIA1VhT58+XYS4lpaWWLt2LYYPH260vW3btiLcXbRoEbKl+V6IiIjogTzzZH4wIjG/9wxoeaTAVXqN9tTjDnkhrsTGxhw/fuGBeh1DsWGrGldvZKFhQH5Q9+vaNERGZ6N+XQssnGVceCnd3vBPOq4H6bBiXRqem+iYV9R58UoWenWxFiGuxNbGHE8+ao93PknEibOZGD5AflmWnZ2D52fGwctDgQ8LhMRUvrZt1yIy0iA6537ykWNe8a6kZUsVZrxqj3fmp+LLr9KMCnhXr9HgyNEs9OxhiU8/Nh53EqlrRssWxl1TL1yQ35SPfdwmb9q8bl0tUbuWAqdOZRntKxUP/295Bp6aaFOoMy9Vjj07NIiOzIaDgxnmfeCUV7wradZCJbrvfrwgVRTxFizgbdik6CkUbWzN8cZcR1HAe/6sDulpBtjZy7+kLl+Uf/4jx+SPjY5dLUUX33OnjceGVDy86lc1xk6wLdSZl6oHbVw6Ek7K0+/UGNzEaJtH17rikiv2YFCJ95d6LUZc+wxqLEJ+iWsbf1jXcETyZeNv26dcjUb4xvPwe6R5oc689HDRxyfBkK6Gbbf2onhXonCwg3XrJlAfPAlddCxUvvIYMGgzkbRqEyz8fGDft2sVnzmRafnf//5X1adAFYS5LxERkWlh7ksPInrtEVG86zawJbzHdSu0Xeq+a1PXeGaGhF0XkH4xDA6t68D/pUGFj7FQwDbgrqLvm3I+49q/RV5249CyNix9nKG+EmG0r/p6JOK2nIb74NaFOvNS5bm9+pgo3vUY3AK+47sU2i5137W9a2zciyFLj/h9V8Sy+4BmRtvUN+Rcz2NAs7yx4diqJqx8nJAWGGm0b/q1KERvPgPPoa0KdealqjGjX1fUcnPGsyv+wqCm9YvcJzwpBZOXF/2FzZMht/HjwZOi+PaRlo2NCnib+Miztm04cymv6PfYrXCEJCShpZ/xz79pDU882aEFVp04X6gzL1WO05fCxaUoe45cEx1yh/dpjkE9mhgV8A7p1VQU3x47F4zPftxd6Fi93oCrt+TfE7ka1JF/92zZe1EU78qPH4bwqCQ0a2A8NhrV9cKjA1thw45zhTrzEpFpZr4s4C3Cu+++W+b7OHToEH777Tex/P777xcKce9up6xU8kdBRERUWaRg9Z/darH8xKjC09DX9LNAl3ZWOHhci43b0jErID+w/Wtburh+/BG7QtPmSLfHDLfD+4uS8Nc/6XlBbnJqNqTPbF2cjb85nXs7XZ3/zcivliXj7KVM/PmLFxzuFPlR+Tt3Xi6qbd7MAo6Ohf+du3WTA/eTJ3WIjc2Gx52uqj//Io+bF6blh/8lSUqSf75OTsbjxdnZHBG38z/M1+tzMPOtFHh5mmP2LPsHel5UdpfujI3GzSzgUMTY6NRFLug+eyoL8bHZhTruFiW3aYL0IZOyQOfclGR5bDg6GT+Ok7M5Iu8aG+/OSoa7pzleeZNjo7qK3BEIGHJgW8sVjo29ynx/ulStuLZwMJ6aU+VgDW1MfrchQ7YBV774F5autqj3TOcyPy5VbwZ1hrhW2NoYrVfYyn+XcrSZeeuSN2wT3XndXpwEM6n1FBGV2qRJk6r6FKiCMPclIiJ6uDH3pRx9NuL/OSOWPR7tWOrj4u5MP+7xaIdSH6NP04hrhZ1xdqOwt0ZWbEr+OWUbEPbNNli42MFnUs9S3z+VL4M+GzFb5enqfUa3L/P9JR66huz0TCjtreDSOcBomz5VHhvStoKUDtbIjE01Ghu3Fu+AysUO/pMLF5tT5WtfyxfjO7TExrOBOHAj5J4FvCW5EhUnrr0djf8WOdnI3deTM+TsN5d028fRIe+2wtwM7z3SF7FpaizadfiBzoEq3vVguTO7h5vx5zaPDW4trlduKn4WvoIc7eSxkZpuPDZS0jTwcjceG2891w/xielY+sfBMp0/0X/NpGqc+TI9rCDffvutuHZ0dMRLL71U1adDREREBVy/lSWmQpO0bWEcoORq08JSBLlnL93VIfWiXBjT5p7HyevPFTjOw00JG2sz0dWhoNzbNbzkl2Qh4Tos+CwRIwbZYsSgwgEzlR/1nfBcKqItiquLvF76AvTFizr06aNAXFw2LgfqxfR7bduoEBqqx+a/tQiPyIatrRlat7LAgP5WogtvQX5+cmB/46YevXvJ63S6HASH6OHllR/uL12mxqXLeiz/xRl2dgzxq0pGhvy7wfEeY8OpwNgIvKRD997FF8VlZeZg8WdyKNupm6VRR18fX/n//q2benTtmT82wkKy4emZf78rfkrH1UA9vvnJBbYcG9VW5Hb5G/Y1Bjcul/uz8pJDOXVoItza18r7oCHjdjIs3fL/RoStPYO0m3Fo8f4wKG3YnbmqZV4Lgu52tOh+q7CzgaqWH6ybNYSZxb3jF31cApL/2oHstHSYW6pgUcML1i0a53XYLUjp6iyudVHG03bm3lY4yx8iZwaFIn3fMdj36QLLWr7l/CyJiP7bmPsSERFVX8x9KeNmtCietHC1g5WPCzQhsUg+cg26hDQo7Kxh18QPDm3rwqxAkbYuKR0aqQjL3Ax2jXyRGZWEpINXRBGuuZUKtg184NixvujCW5Clp/weXBueAMe2dfMKiKXjLVzzi7li/joOza0Y1HlnNBQ2+bO9UeVS34yBPuXO2KjhjIzgOCQevo6shHQo7axg39QXTu3qGI2N4sTuuCiu3fo0gblKWeTY0IQniPvMzfW0kclQFRgbUX+eREZQLOovGMmxUQ3YqCzwwcj+iFdn4MN/9pXpvmq6OonruDT5SyW5bifLnxXUdXfBoZuhYllpbo6aLk6ITZO/SCJ5qnMbNPb2wLSVm6DOkpuOUPXj5y1ntQlJ+T9nZ0cb1K/lAX22ARevR8LHwxF9OjcQRbgarU50zD146qbowltQVJw8NmrVcMXxcyFiWaEwh6+XE+IS88fG2KFtUb+2J9785C9kaDk2iB4WLOCtAFlZWdi0aZNY7tevH6ys5Dd00nRpkZGR4trLyytvPREREVWu4DC9uHZyNIf9PYrh/HwsxHVIWP6bn7R0AxLudFP1r1H0yyg/H3l9XEI21BkGMWWaZNgAW6zZmI5FPyRhypOOOHZai+VrUuHhpkDHNvJrghfeioNSaYZvPnQv1+dLhbm5yWFraFjR09mGhuavDwuXlwOv6POKfv9YlYF3F6ZCd9d745o1FfjlR2c0biyPH0mXLpawszPD0qVqdGinQu3aSixanI6kpByMGimHcmFhenyxKB1Dh1iJImCqOi6u8v/ZiHuMjYLrb98ZGwUFXszCyuVqUeCblGDApQs6JCUa0LSFBd77VA7tcnXorIKtnRl+/TEdrdqpULOWEku/TkNykgFDRsiFexFhenz/VTr6D7ZCr34cG9VV4rkIaG6nwMxCAe/+jcrlPl1a+0Fho0Lo2rNwauYDG19n3FpxXHTm9erbUOyjiUpB0Irj8OhRDx5d5A8DqGqpj8pdfgpSONrD5anHYN20QZHHZN4MEZeCpIJfx2H94DDIuDOPwsEOqrr+0Fy8CvWJc7Bu3gia81fEbQtfb1HgK31YmPjbBihcnOA4YkA5P8OHl/TxnJn8Ob9JKd3HikRUXpj7EhERVW/MfUkq2JVYuDrg9v/2IubPo0CB93ox64/Cuq4n6s4dDZXHnSLLkLi87qjxO87h9s97kHNXYZXKywl15o6GTW2PvHX2zWvB3FqF2L+Ow66JLyx9XBC9+hCyUzVw6dlE7JMZnYzoPw7BqUtDOHV8sE6eVD4ybsk/Z5WbPcJ+3o/IdceNxgbWHodNPQ80mD8Klh753S6Loo1OQer5MLHsPqBZoe0OLf1FricV6No38RUFw7dXHhHF5W695S//a6OTEfH7Ebh0awCXTsYdfKlqvDmgO/xcHPHiH5uRWmCWq/tlZaHEhI6txPLOwJtG247dCkO6NhOTu7TB6bBIhCYk44WeHeBsa42/L1wV+9RwcsCLvTpi+6Xr2Hv1VhmfFVUUFycbDL7zu37fset56+vVlP/Wp6ZpMLx3M0yf1BMWudM03nE7OhmzPtuIoLD4vHWnL4VBnZGJJ4a1xYWrtxEelYTJozvBycEGOw+dFvt4ezji6cc649+j13DoVFAlPVPTZqqZr4S5738LC3grwPnz56HVym3NmzVrhtTUVMybNw+//vorkpOTxXqVSoXu3btjzpw56NmTU2UQERFVJimQldja3Pulr9RRVZJ6Z9+CxxV3rN2d48SxaflB7odvu2LfYQ3eeDdBXCQWFsCKbz1gaWmGVX+lYcfeDHz7sTt87nRmkGi1BlhYmEGh4Mv08tS1iwqLvwYuXNDh4iUdmjXNL7iVrPhdnqJckpYuv7NLuhPiJycbMHdeqii2ff01O9Fh9+pVPeYtSMWZszqMm5CIf3e7w+VOB1epm+/ct+0x6+1UDBoq/+wlAQFKvDFD/rb9W7NTxXh4/z3jYFDqGCJ18aDK06GzJZZ9m47AizpcuaRDo7vGxtqV+d+kTi/wOyFXVGQ2Nq2Xp0jL1bGrCvM/coJngY7LEmcXBV6b5YD356bgieH5QU2dekq88Jo8NhbOTYHSApi9QP5AIZdGY4C1NbvxVheR2+Tuu+6da0PlKE91VVbS/QQ82wVXv9qLE9PW5K23remCuk/J0zleWbQX5gpzNJxu/J4yW6uDwsp47FLFsvDzhnPN4bBsWFcuos3SISsiEimbdyMrKBRx3/4Kj9emwKqB3JEnt7DXYXBvWLdsDKWbiyja1UXHIf3fw1AfO4vkDduQYzDAcUhvo8dyHvsIYj9fioQfV+WtM7O2hMvER8Vy6s4Doguw+8uTRUffXIYsnXgMaTp3IiJ6MMx9iYiIqjfmviQVSEo0t6KRcT0S7kPbwH14W1g420F9LRLh3++AJigGNxesRaOvn4aZUgF9qpwF69O0iFi6SxTbeo/rCpWnE7ShcQhftgsZ1yIRNG81Gn33DJQONmJ/paMNakzuhfAlO3DtteV552Dl5wrvcd3Ecvh322GmNIff8/2NztOg1cGc2U2l0qfJYyMjKAbqa1HwHNYKXiPawMLZVtwO/m4XMm7G4uo769Hsu0kwv6vgrqC4nRdF8a9tfS/Y1skv6s5l4WgDv6d7IOTbXbj08m956639XeE7votYDv56lxgbtab1MTqWuV7V6FLXH2PbN8fWC1ex50rZCiPnD+0tCoFjUtOxdP8Jo23JGVp8vvMQFgzvg/XPj8tbfzM2Ad/+e1QsS9v02dn4YOu+QoXBWp38RRWqWgpzM8yfPgT2tla4GRqHjbvP521ztJO/vONgZ4UZU/qIYttf1h1FVFwK6vi54ZWneqFpfR98OWc0Jry+HKnpcsaQkqbBkpUHMHNqP/z88fi8+wuOSMDPa4+I5ZlT+4qxseiXf43Ox1KlRGYWxwaRKat2BbxSwOnv7w9zc9P9MDowUP7wVmIwGNC2bVvcuHGjULeG3bt3Y8+ePfjoo4/w1ltv3ffjREREFLs9Kirqvu+TiIiIKkYtPwtc2OuP/61Oxc1gHTzdFRg3yh4NA1RISs7GjHnx6NLOCs9PlAs412xKE9OqXQ/SicC3b3cb0aGhtj+Dm/LQtYslOnZQ4djxLDw1OREffegobktFustXZGDdeo34d5c67ObOmCV1VJXo9UDbNhb4cak8NY6kTRsV1qxyQeducYiJMWD5r2rMeDV/KqxJE23RtIkFtv6jFQXBTRorMWaMjSjO/XODBvv2Z+LTjx3h6akQRbsL308V69PScuDiYo5JE2zw+gw7BvqVoEMXS7TtoMKp41l46ZkEvPO+E9q0V4nC7dUr1Nj8p0YU1OqlsVHEW5Y+A6xxKdQa2dk5iInKxtFDmViyKA0j+8Xhwy+d0H+IcXHn2Am2aNTEAru2aaBOz0GDRhZ45DFrUZy75a8MHN6fifkfOcLdUyGKdr/4IBVbNmqQnpYDZxdzPD7eBtNetefYqEJ6dSZiDsjv92oMkr9xX178HmkO+wB3xB64Cb06C/Z13eAzsLEI8aN2XUXCyVA0mtEblq62Ity//sMhRO++Kva1cLSG7/BmqDupA8wUpvv+2lQ49JM/mMtjZQnrxvVh1SgA8UtWQHMuEEmr/4b3/FfzdpE68t7dldeyli8sn35cdNNNXrcVKVv2wK5bOygc7I328X53BtRHTkOflAKlixNsO7cR17rYBKRu3QOb9i1h3Uzu1Jy25zBSd+xHdlIKzFQWsG7ZBM5PDIfCTu70TUSFrVixokLud+LEifgvY+5bOsx8iYiITAtz3+pJ6qDr3KMx/Kblz0zj0Ko2At5/ApefWyoKcxMPBMK1d7P8LqzZBtg2rIE6b4/KO0a6LY6Z+gN0iemI23oG3k90zdvuPqQNbOp6IenwVRgyMmFd2xOufZuL4tzEvZeQeuYW/F8aBAsXO1G0G/HLHiTuvSz2lTr+ug1uLYp9md1Ugpz8seHasxFqv9Qvb5Nj61po9NHjODflJ2hC4pGw7yrc+xad8+UYchC365JYdu9fuPtuLq9hrWBbzxOJh64hOyMLNnU84N6vqcj14v+9jJTTwaj9Sn+oXO1Erhf20z7E77ks9lU6WsNzSEtR7MuxUfHsLFV4f2R/JKRnYOHWvWW6r2k9O2Bk6yai0PbVNVuRrJGLMwtaffICrkTFon+TAPHYV6Pj8NfZQHHM0OYN0S2gFuZt2o24dLUo2p05oBuGt2gEeytLJKozsOrEBXy39xgMuR9aUaWb+Ww/tGteE8mpGZjzxWboC3Rtz22eoFQqcPHabcz98u+8bZdvROHVheuw5ptn4O5ih1EDWmL5n8fytv+18zyuB8eiZ8f6sLVW4WZIHLbuuySKc/t3bYSOLWvjk6U7kZCsFkW7L03ogQHdG8POxhJJqRni+F/WHYHBwLFBZGqZb7Ur4A0ICEBIiPHUkaYmMTExb/mTTz4RXRkGDhyI9957D82bNxedGf7880/MmjULKSkp4rphw4Z45JFH7utx/Pz8KuDsiYiIHn6506epM+79Bkatlrc5FJhqreC0a/c6Nv3OceJYe+Ngxc1VgZkv5hd95pr5XjySU7Pxw2c1xBu7TdvTMe75GHRtb4UPZrsiOlaPuR8nos+jt3Fhnz/sbBnYlIcflzrh6alJOHlSh0mTk4y2TX3GFidOZuH8eR2cnOR/bzu7/ALJCePlLgsF2dmZ49FR1vhhqRoHD2ZhRn6NVl6Rr3QpSCoYnv9uKjp0UGH8k3Jh50vTk7BjZyamPWeL9u1V2L5di0WL00Vh74J5xU/dReXjiyXOePW5JJw9lYWXpuS/tpdMmGKLMyezcPmCDo53xkZRpIJaH18lHh2rRMculhjRLw5zZyajdTsV3DyMuze0aK0Sl4JSkg34dGGqKB4e/YQ83ma9koy9u7R46lk7cT97dmjxw9fp0GTkYOY7xh16qfJE/3sdBq0elu52cG1Xs9zv36mxt7gUpEvV4tqSA3Bq7oMaQ5uKdZc+3IHYw7dQa0xrODXzQeyhIAT/dkJ8ANDghe7lfl5UOtLfdcfh/UQBry4iCvrEZFFoWxL7vl2Rum0fDOlqaC/fgG2n1kbbpS6/jsP6Fjou8fcNMLOwgPPjw/KKd5NWbxZdfm3HPQJdZCxS/t4FfWw8PGe/CDMTLqIjqkhPPfVUuXerlu7vv17Ay9y3dJj5EhERPTjmvmRunZ+xuQ2Sp7AvSOXhCMd2dZF8+BrSzoWIAl6FTfHHKGws4dKrKWL/Oo60c8FGBby5Rb7S5e5urxE/7oZdEz+4Dmwp1gV/vgkpx2/Ac2QH2DbxQ8rR64hefRiGTB18nyn8Hp/Kl6LA2PAc0qLQdksPBzi3r4PEQ9eRcjbkngW80ras2FSYWyrh1rtxsY9p38hHXO7uEh3yw17YN/WFxyD5PG5+ugVJR2/C+9F2cGjqi8QjN3D7j6Oi6Lvmc8YzM1H5e3twT3g72ssFtxmFC25L66nOrfFKn87I1Onx0h+bcTYs8p77no+IFpeCHK0tMXtQD5wMicDaUxfFuk9HD0SfhnXxy+HTOBMaiT6N6uLFXh1ho7LAJ9sPPPC50oN7dXIvDO/THKnpGry6cD3Co4w/X1RrsvKWN+66UOj4DK0OOw4EYtzwdqIIuGABb26Rr3QpyN7OSnTuPRcYjk275fuc//JgdGtXD6s2n8L5qxHo3j4AT4/uBGtLC3yzwrh7MxFV/8y32hXwPgzU6vxpdaUQt1+/ftiyZQsUCvmDend3dzz//PNo2rQpevToIbo1zJ49G8OHD+dUlkRERJWglp/8Eig5xSCmRysY0OYKj9SJ65p39pVI+7k4myMxyYCw23q0aGJZxHHyFCVuLuZ506gVZ/8RDZavTsPc15zRuIEcIH36bZKYqm3jr95wdpJfP5ibm+HFWXH4Y0Manp3AQr3y4OamwKYNrjhwMAuHDmeKYlp3dwUG9LdEyxYqtGwTI/Zr1FAeA/7++UWX/v5Fv4yueWef2NjsUp3DuwtTkZ5uwGefOIrXgTeD9Ni2PRMjR1hh7hy5WLd/Pytcu67H/5arMfN1O9gyyK9wrm4KrFjvKrrnHj+ShZQkA1zdzNGrvxWaNlehVzs5WAtoULrOKDX8lGjXSYUD/2biyKFMDB9VuAD8bp+9nyLGhtR9VxobwUF6UbA75BFrzJgtj42efa0QdEOHP1ao8eIMe9hwbFSJyG1yJz6pM65ZbsvuCnb9+wPIVmeh8et9xPhQhyUh9mAQvPo0QMBz8odI7p3rQB2SiPCNF1B3ckcoC3xIQZXLwjt/KkWpC25pCnilwlqlpyuy0tWiy25ppB85jcwrN+Hy1GgoHOzEutRte6FwdYbb8+NhJmUSLZsgR6NF6vZ90F65Cesm9cvwzB4yOWbyxdSY4jmbiBx2sqEiMPclIiKq3pj7kqVX/ntuS6/CRdUS1Z31Ukdd+XbBY4p+z567XpeY/3qwOBE/7UF2Rib8pw8SrwO1EQmiYNe5ZxPUeFouyHTqEABNWBzi/j4N7ye7GxWYUvmz9HYs+efsXfLPOW6HXFjp0rU+lLaFf1eUJHTZXjE26rwyQIwNTXgCkg7fgGuvRqj5TE+xj3PHetCExiP677PwndiVY6OC9W1UF7rsbIxr31xcCqrt5iKuR7dpis51/RGXnoHX1/5T6D7Gd2iJWYN6IEuvx8urt+DQzdD7Po+3BvYQHXml7rvyYzujf+MA/H3+Cr7YeUis23vtFup5uOLJDi3wzb9HkZEl/02jyjF9Yk+MGdwGqelaUbx7PSS20D6RsflZbmRMcpH3Exkj7+PqVLoZ0l6e2BM21ip8snSXuO3v44yeHepjx8FALFkpF3IfPn0LtX1d8ejAlvhp7WFotBwbJp35Skz1vKu5nGqa+ZZbAe+VK1ewbNkyHDx4ELdu3UJaWpoIKIsjvSDRS3MQP2SsrKyMbkvdGHJD3IK6du2KUaNGYf369eLf7+LFi6JTQ2mFh4eXOJ1a+/bt7+PMiYiI/hsa1FXBxtpMdDQ9dV6LXl0KF9OdPp8prls3Mw5gWjWzxJ4DGpw+r8Ww/oXfWEnrc/crSWZmDqa9GYsGdS0w+2U5BJCcu5yFpg1UeSGupGsH+fXF+cvyeVH5kF6P9uhuKS4FhYToERNjgLOzGZo1k4s069ZRii686ek5SEws+nVu7nob25LfVB0+nIk1azV4Y4YdAurJL8svX5bfULdraxzISZ14z5zV4fp1PVq1YlhXWWOjczcrcSkoLFSPuFgDnJzN0bhp6ac2tLaRx0RifPHvkSQnjmRi4zoNXnjNHnXqyY9xNVAeGy3v6uLcqq0KF87qEHRDj2YtOTYqW3pIAlKuRANmcgFvZUg8G47I7VdQ56kOsPWX/3ak3YwT105NjDv1Sp14pfOTCnkdG3lVyvlRYYb0jLxlMyvL+z7OvBTHZKepkbxuCywb1IVdl3byutQ0ZKekwbpNM7l49w7LerXEtS48kgW8RPcQHBxc1adQrTD3rdzcl5kvERHRg2PuSzZ1vUROgxyp02kGVO6FZzTLTs19vy3nblY1XEXnXoMmS3RHLYo+9xjrkvPAtPMhSNx9Ad5PdoOVn5tYl3FLbhZh18i4U69dYz9kXIuENiwetg2MO7VS+bKt51lgbGhEx9276VM0xf6cpeOk7rgS9wGlr+vIlXIuFHG7LsF3QhdY+7uKdeoguQDQvrHx2LBv4ov0q1HQhCbArqFx5kflz0KhQPva954NxdfZUVxuF/FF+3HtW2Du0F5y8e6qLdh//f4zhQ61fTGqdRNRlBscL3d0bejlLq7Phhl3Yz0Tehst/bxR190FF2/Lv1uo4r0wvjueGNYWaWotXnt/Pa7e+b1+t/DIRKgzMmFrYwlHB3nmzbvlri9NkW3rJn4Y0qspflpzGKGR8qxAAbXkhhEXrxl3eb5w9Taa1vdBLV9XXLlp3OGZiFCtM99yKeD98ssvRScBKZStrpXKlcne3j5vWeq60KpV4ak2cg0YMEAEuZKTJ0/eVwGvr69vGc+UiIjov0mlMsPgvrZY/3c6Vm1ILxTkhobrcOSUHMiOGCR3sMs1cpCdCHLXbErHvNddRIeEXAZDDtZulr+1P3Kw8XFF+XBxIq7f0uHfP2vA0jL/fqQldYbxB+K5U7exa1Pl+H6p/A378U/aiPEiUSrNMHCAFdb/qcHBQ5kYPMj4w3vJ/oNy0N6qhEJKKcR/a3YKAgKUmP5S/ljJ/fFm3DVVX+5t/vir3vJl8v/x0eNsYHFnbJQkKzMHZ0/K0ybVqqMscd/35iSjTj0lpr5QeGxoNMa/GzSaO2OFY6NK3P7nsrh2aekLG5+K75JjyNLjyqJ/YVvTBbXHyUWaBX/+2XcFfnm3OT6qlPrkeXFtZm0JC085eC9JVuht6GPixbKqmA8PciWt3YKczCy4TBhVYK38g5fWF2TIunObf1SI7qlmzZpVfQrVBnPfys99mfkSERE9OOa+ZOFiJ4pi0y+HI+1ciFzQW0COPhtpF8PEsm19uWDWTGEOp071kfjvJaSeC4ZT5waF7ldaX/CYezHo9Aj7bjus/Fzh+VjnvPVm98huDLnv2fnjr3AqFztRFJt2KQIpZ0Pkgt4CDPpspF6Uv0xn16Dogtn4vYHI0WWLTr0OzUvOa4zuP0uP4G92isJdn8c75q3P/b9vYK5XZdp/+P09t300sj9Gtm6Cr3Yfxg/7TxTa/ni75pg3rHde8e6+ByjelYqHFwzvg5uxCVh2IP8xct+BW6uMC8pzb/MdeuWZ9mQ3jH+kvSjelTrvXgm6d3FstiEHB07exKAeTdCuWU0cOHGz0D7tmsu5U+BN4+Lsu1koFZj5bD8ERyRgxcbjeetz4xlrS+OxYXXniykcHESml/mWuYB3+/bteOONN/JeXHTs2BFt2rSBi4v0xua/OYWrn59fqQPXgvvGxcldk4iIiKjivfWSE/7cko7la1IxaogtBvaWuypkZBgw9fVYZGdDrG8YYFyIOWmMvRzABukw75NEvD9b/pa0RLotrff1UWLiY/kf7BYl8FoWPv0uCVPGOaB7J+NvYErdHw6f1OLwCQ26tJe3/fh7Sqk7PFDpXLuug4+3Avb2+a9Z9focfPe9Gr/9noHatRR49WXjQP7l6XbYtFmDlX9koHcvS/Trm1/Eu+T7dJw4oYPUgGvypMLdPQpatDgdt4KzsXGDa16BsKTZnY6uG/7S4OnJtrC2NkNCogH/bNNCasBYv365TaBBxQi6roOntwJ2d42NX35Ix7qVGfCvpcCzBQqvE+KzsWubFkNHWBsdI4mJzsan76UgNsaAGr4KdOpa/P/hH75OQ2hwNn5d52pUIJzb7XfLRg3GPWUHKyszJCVmY/d2LSwtgboBHBuVTQr1o3dfFcs+g5tUymPe+u0EMiKS0W7xYzC3yO/W41Bf/sZ91O5r8BvVEgpLJbJSNIg9eBPmKgXsaub/raLylxUWCX1iMqybNTDqdJtjMEB9+BRS/toubtv37gIzpSLvAzr1kVOw7dSmUIdd7fVbSPhlbV63XMsSCni1gTeQcewMHEcMgIWn3NlHonCwg8LZEZnXgqCLTYCFh6t8TodOiu0qf+POLkREd2PuWxhzXyIiouqPuS95jeuKm3NWIXrtEdg18YNtQ/n9b062ARE/7UFWdLLouOvaL/8LVl5jOiPpQCASdpyDY9u6cGwfkLct5s9jUF+OAMzN4D60TbGPHb3qEDIjE1H/0wlG2Y31nULipH2X4TGsLcwtLaBPyUDykWswUylh5Z//fp4qju/4Lrgyaw1urz4O+6Z+sG/kkzc2wpbtRWZUMhQ2Krj3b1bk8bE7LoprjwHN7rvo/vYfR6G9nYQmX4wzGhu5hcTx/wbC65HWYmzoUjKQdPi6GBvWzPWqrcfaNMX8oWUr3pW80LMDaro448mf10KXnf8lj8BIucPrsBYN8fuxs8jUZ8PJxgr9GteDVqdHUGxCuT0Xurdnx3bBhBEdkJoud94trng314oNx9G3S0MM79scR88G48iZW3nbxg1vh5aNfKHPNuDPHeeKvZ/JozvCz8sZ0+atgl6fPzauBctjo3+3Rli3/SyysvRwtLdGz/YByMzSiYJfIjItZf6U96uvvhLXzs7O2Lx5M7p06YL/uiZN8j+8zZbeBRaj4Halkh+6ExERPYgzF7R4aXb+B6JBIfI3k5f9noqtu+VOqpI/f/GGt6f897Z1cyt8Pt8Nry+Ix9DxUejRyRrubgocOq5BVEy2mN7s+0/kgqiCbGzMsXqpFwaOjcRHXyfh751qNGmowuWrWbh0NQu2NmZYs8wL1tb3/kBb6lz1/MxYuDgp8Mk7hcOXt191Fuc04PFI9O1hg5hYPU6czUS92hZ4YkTJHR6odH5fmYHff89As+YW8PZSIDMrB2fO6BAXZxDFu2tWuYifd0EB9ZT4/FNHvPZ6CiY+lYQWLSzg56vA1Ws63LyZLYp3P/7QEY0a3XsqtWvXdKLYd8J4G7RvZ/xBQe3aSox8xAp/bdKiZ584UdB78lQW4uMNmP6SbaHzoYqxblUG1q1Uo3EzFTy8zKHLAs6fzUJCnEEU7/74u6vRz0KrycH7c1PwyXspaNjYAj6+CvEN5+jIbARe1onjPTzNsfhHF1ha3TvYvXldh1+WpuOxJ23Qup3xhzb+tZQYPNwa/2zWYETfWDRqaoGzp7KQGG/AMy/acWxUgfijwchK0kBpZwmP7vWK3TczQY3z72zJu62Nk7v2xB25hRMvrMlb3/DVXnnFuHdLD05AyOrT8B3WDE7NjLu92NRwglfv+oj+9zqOTv4N9gEeSL4UKc6v1ri2UJRiekd6cPqEJMQvWQFzG2tY1KwBhb0dDBotdLejkZ2YLPaxad8SjsP65h+UnY2kPzYhae1WqPx9oHRxEsW1Utdd6TiJRQ0vuD33ZLGPbcjSIfH3v8S+DgN6FNruOLQPEn/bgOgPvoFVgzry/UfGyIXBDeuW9z+Facsx0e4UpnjOZDKY+xbG3JeIiKhyMfelB+HQsja8J3RH1G8HcO3N30TXXAtnW2QERSMrJgVmlkrUfnMELJzz/82t/NzgP30wQhdvRdC762AT4A2VhyM0oXHIlAqhzM3g/+JAWN+Ztrwo0r5Ssa/boFaiC3BBVj4ucO7RGEn7AxE47UfY1PNEemAE9MkZ8BzTGQqr4md0o/Lh2KomfCd1RcSvhxD4+h+wbeANlbMt1DdjkBmTAnNLJerNGibW3U3aJyMoVi7k7t/0vh43IyQekeuOw2NwS9EFuCCrGs5w7dkICfuu4Pyzv4iC3rTA29AlZ4hOvRwb1VNDL3e8O7yv6NYenpCCAU0CxKUos//aec/7qefhiild22LNqQs4GxZptC0sMQVbLlzF0OYNsWX6JARGxaKVvw/c7GyxdP8JaHT6cn9eZKxr27p46tFOYvl2dDJGDWxZ5H4pqRp8+9v+vNuhkYn4+IedePuFAfh89ihcuRmNqLgU1PFzQy1fV1G8+/mPu3ArTJ6BrSi1fV3x5CPtsXH3eVy8Zjw2pHPZeegK+ndthJVfPoXrwbFo1sAHLk62+HXDMWgzjTt6/6eZauYLEz5veiBlTg5PnTolvl00b948hrgFWi77+/sjLCwMISEh4s3avb6BFRQUlLdcowa73xARET2I1HQDjp/JLLQ+IlIvLrmkAs2CXn3OCU0bqfDlD8k4eU4rpivzr6HErOkOmPWyM+ztig5jpe4IZ/f44f1FSdhzMAMbtqbD3VWBCY/Z450ZLqhbq/hCqWW/pYpOC6uXecHJMf+b1rmkrhAbf/XG+18mYsdeNWyszfH4CDsRPLNIr/z06W2F8IhsXLyow4ULOtEJt24dJZ5/1haTn5K73xZlzGM2qB+gxLdL1Dh+IguBgTo4O5tj2FArTHvOFq1a3TtQk14XznwrBa4u5pgzu+huHV8tckKNGmmiC+/OXVr4+Cjwzhx7THu+cGhIFaNbL0tERmQj8JIOly9mibFRq44Sk56xw7inbEX324Jc3Mwxc64DTp/Iwo1rOty6qUemNgf2DuZo0UqFHn2s8Ng4m0Ldee8eGwtmJcPFxRyvveVQ5D4ffOEE7xoKbNmYgb27tfDyVmDGbAdMfo5joyrc3hYorr36NIBCVfxba4MuGylXCn8zX5esQUqyJu+2PuPOtIlFjI/AL/ZA5WSNelOLft/dZFZ/WHnaiy68UmGwlYc9Ap7ripqPt77PZ0b3S+XrDfu+XZEVEgF9VCyybko5gNwB17pNM9h1aQvrZg2NjjFTWcBhaB9xjC46ThTV5uh0ogjYqlE92LRtDtvObWBWQsFX6pbd0McnwnPWC3ndfQuy694B0rdL0nYegObCVZjbWIl1To8O4vSsRFQi5r6FMfclIiKqXMx96UF5j+0qCndjN52E+lokMm5EQulsB5e+zeE1uqMo2L2ba9/mohNuzPqjSL8cDk1wDBT21nDq2hCeozrCtoHxF6oLkl4Xhn2zDUpHG9R4qleR+9R8bRhU7o5I3HcJKcdvwMLNATWe7g2PUR3K9blT8XzHdYZdA29E/3Ua6Vcjob4eJQq83fs1hc+YDrD2dy22+65T29pQuRbfifvusXFr8Q4xNvynFP7ytaTuG4Nh6eEguvAmHbsJlbsD/J/pAe/R7R/wWVJFc7CyFMW7krruruJyL8UV8L43vC+SMjT4Yuehoo/dsAORyWmiC2+vBnUQnZqGT7cfwC+HT5fDs6CSONjlz8LZqJ6XuBQlKjbFqIBXsm3/ZYREJGD8iPZo0bAG6tVyR0qaBnuOXMMff58URb3Feeu5/khOzcD3Kw8Uuf3977YhJj5VFPFKhcax8WniHP7YLM++RkSmxSxHesVQBjY2NsjMzMSJEyfEFGoPIymMrV27tlieNGkSli9fXuIxM2bMwKJFi8Tyrl270LdvgU47BfTq1Qv79u0Ty1LwW3BqtbKKiIjIu7/w8PASp3UjIiIqiSG66G+PEsVm53e8ICooIZsFYlS01249VtWnQNXUtZv3/kCM/pv0icmIfOujcs83CuYmfvPfgdLJCaZGn5yM8HcXimVmP5VLKs6UutKeP38e8fHx0Gg04oPZe5GKPPfs2QNTwty3eua+zHyJiKi8MfOle2l3ZkxVnwJVUyolO39S0ZIOFl3gSORytfhZbOi/KTMjGWf++aBcM46HIfOVMPf9b2W+Ze7AK3UPuHXrFrKyiu4U9F/16quv4vvvv4dWqxWh7qFDh+DgYNxJ6/fff88LcYcMGVKuxbtERERERERERERUvjIyMvDiiy/it99+KxTeFtWNNXcfU+x6zdy3aMx9iYiIiIiIiIiIHh4ZVZz5lrmAd9iwYVi8eDEOHz6MTp064WEgha43b97Muy1VVOeS1t/dieGpp54qdB/SVGrvvfce3nzzTVy8eBHt27fHW2+9hebNmyM1NRUbNmwQQa9ECnhzuzYQEREREREREVElk/K2Ms1RVUVM8ZxNmBTMjhw5Ert37xbLbm5uovvFuXPnRFjbrVs3JCYm4tq1a9Dr9WJdgwYN4OVlmh2ImPsy9yUiIiIiIiIiMlmmmvnChM/bBOVUg8y3zAW8b7zxhqg+/uKLLzB+/HiTDaQL+umnn/Drr78WuU0KrKVLSUGuZObMmeIH+Mknn4gf4tNPP11oHw8PD2zcuBEBAZyehoiIiIiIiIiIqLpat24ddu3aJULa+fPn45133kFgYKAo3JTs379fXKvVavz444+YN2+eyAal5a5du8LUMPdl7ktERERERERERPQwW1cNMl/zst6Bj48PNm3ahOzsbHTu3Bn//PNPuZzYw+Kjjz4Swe+ECRNQq1YtWFpawtHREe3atcPChQtx/fr1h6aDBRERERERERER0cPqjz/+ENdSlieFuebm5kVOk2Zra4tXX30Ve/bsQVpaGkaNGoXIyEiYGua+xWPuS0REREREREREZNr+qAaZb6k78Pbu3bvY7S4uLiKUlKZWc3JyEp0FbGxsij1GerLSk6pupKnS7p4urSykHzDDWiIiIiIiIiIiItN16tQpkWdOnTq1VPtLhZzTpk3DokWL8PXXX+Pjjz9GdcTc98Ex9yUiIiIiIiIiIjJdp6pB5lvqAt59+/aJk83JySlye27lsbQ9KSkJJ06cuOd95d5PUdXKRERERERERERElcksR76YGlM8Z1MWHx8vruvUqZO3zsLCIm9Zo9HA2tra6JghQ4aIMHfLli3VtoCXuS8RERERERERET1sTDXzlZjqeZui+GqQ+Za6gLd79+4MXomIiIiIiIiIiOg/SalUQqfTwd7ePm9dweXo6GjUrl3b6BhHR0dxHR4ejuqKuS8RERERERERERH9FymrQeZ7Xx14iYiIiIiIiIiIiP6LfHx8EBQUhLi4uLx1Xl5eogODVqvFmTNnCoW5N27cENd6vR7VFXNfIiIiIiIiIiIi+i/yqQaZr3m53AsRERERERERERHRQ6xFixbi+uLFi3nrpM61HTp0EMtLliwx2l/q3PDll1+K5YCAgEo9VyIiIiIiIiIiIiKq/pkvC3iJiIiIiIiIiOi/LceEL1RpevfujZycHGzfvt1o/dNPPy3WS51se/bsie+++w6ffvop2rdvj1OnTonAd8yYMVV23kRERERERERERP85VZ3bMvc1Cb2rQebLAl4iIiIiIiIiIiKiEowcOVIEs3v37sWtW7fy1o8fPx4DBw4Uge7Bgwfx8ssvY/bs2bhw4YLY3rJlS8yYMaMKz5yIiIiIiIiIiIiIqmPmW+YC3iNHjkChUMDa2hq3b98ucX9pHysrKyiVSpw+fbqsD09ERERERERERERU4by8vMQUaVqtFnXq1DHa9tdff2HOnDnw9PQUoa50cXR0xIsvvijCXykPNTXMfYmIiIiIiIiIiOhh5lUNMt8yF/CuXr1anNzQoUNRo0aNEveX9hk2bBgMBgP++OOPsj48ERERERERERFR2VT1dGicSs1kmJubi6LWu1laWmLhwoWIjIxEfHw8oqOjkZCQgG+++QYODg4wRcx9iYiIiIiIiIjIZFV1bsvc12SYV3HmW+YC3kOHDok2woMGDSr1MUOGDBHXBw4cKOvDExEREREREREREVUbLi4u8PDwEJmpKWPuS0RERERERERERIQKzXzLXMAbFBQkrhs3blzqYxo2bCiub968WdaHJyIiIiIiIiIiIqJyxtyXiIiIiIiIiIiIqGIpy3oHWq1WXFtZWZX6GKm9sEStVpf14YmIiIiIiIiIiIgqXEpKChYvXiyWp06dCm9v72L3j4qKwo8//iiWX3/9ddja2sKUMPclIiIiIiIiIiKih1lKNch8zcujPbAkLCys1MdERESIaycnp7I+PBERERERERERUZmY5ZjuhSrPypUrsWDBAnFdUpAr8fLyEvu+++67WL16NUwNc18iIiIiIiIiIjJVVZ3bMvc1DSurQeZb5gLe3CnUNm/eXOpjNm7cKK4bNGhQ1ocnIiIiIiIiIiIiqnDbtm2DmZkZxowZU6r9pX3Hjh2LnJwc/P333zA1zH2JiIiIiIiIiIjoYbatGmS+ZS7gHTx4sDihFStW4ODBgyXuf+DAAfz222/iyQwdOrSsD09ERERERERERERU4c6dOyeuO3fuXOpjOnXqZHSsKWHuS0RERERERERERA+zc9Ug8y1zAe9zzz0HNzc3ZGdni1D322+/hVarLbSftO7rr7/GkCFDoNfr4ezsjGnTppX14YmIiIiIiIiIiIgqXGxsrLguzVRqBadUk8TExMDUMPclIiIiIiIiIiKih1lsNch8lWW9Azs7O/zxxx8ixM3IyMArr7yCt99+G23atMl7YlFRUTh16pTYLnVtUCqVWLVqFRwcHMrjORARERERERERET24HDP5YmpM8ZxNmJWVFdLT00XGWVq5+yoUCpga5r5ERERERERERGSyTDXzlZjqeZsgq2qQ+Za5gFfSt29f7NixAxMmTEBkZKR4UtKUaQVJAa6kRo0aYiq1nj17lsdDExEREREREREREVU4qWj1xo0bomC1tFOqSfsW7Mpgapj7EhERERERERER0cPKuxpkvublci8AevXqhaCgICxduhTDhg0Tga2lpaW4SMvDhw/Hjz/+iJs3bzLEJSIiIiIiIiIiIpPSrVs3Uay6ZMkS6HS6EveX9pH2NTMzQ9euXWGqmPsSERERERERERHRw6hbNch8y6UDby4ptJ06daq4EBERERERERERET0sJk+ejJ9//ll0ZBg3bhx+/fVX2NjY3HMatYkTJ+L69esizJWONWXMfYmIiIiIiIiIiOhhM7kaZL7lWsBLRERERERERERkknKq+gSoupOmUBs7dixWr16NDRs24MSJE6KgVerSIE21JomKisKBAwfw008/ISIiQgS5o0ePRo8ePar69ImIiIiIiIiIiP5bmPmSCWS+ZS7grV27NszNzbFjxw7Uq1evVMeEhYWJ6dSkJyNNv0ZERERERERERERU3f3yyy+Ij4/H7t27RVg7f/78IveTpl2T9OvXT3RtMEXMfYmIiIiIiIiIiOhh90sVZ77mZb2D0NBQhISEICsrq9TH6HQ6cYx0ISIiIiIiIiIiIjIFVlZWoqD1q6++Qo0aNURoW9TFz88PX3/9NbZv3y6OMUXMfYmIiIiIiIiIiOhhZ1XFmW+ZO/ASERERERERERER/VdI3WVffvllTJ8+HefOncPZs2dFhwaJm5sbWrdujRYtWoj9iIiIiIiIiIiIiKh6M6vCzLdKCnhTUlLEtY2NTVU8PBERERERERERUR6zHPliakzxnB8mUljbqlUrcSEZc18iIiIiIiIiIqoOTDXzlZjqeT8MzKog8zVHFfj999/Fdc2aNavi4YmIiIiIiIiIiIionDH3JSIiIiIiIiIiIqrADry9e/cucv3kyZNha2tb7LGZmZm4desWYmNjRbVy//797/fhiYiIiIiIiIiIiKpcUFAQjh49iujoaGRkZOCFF14Q06mZKua+RERERERERERE9F8WVAWZ730X8O7bt0+EsDk5+b2apeWTJ0/e1/3UqVMHs2fPvt+HJyIiIiIiIiIiIqoyZ86cwauvvorDhw8brR89erRRmPvdd9/h3XffhaOjIwIDA2FhYYHqjLkvERERERERERER/RedqcLM974LeLt37y6C3Fz79+8Xt9u0aVNsJwZpHysrK3h7e6Nz584YO3ZsiZ0biIiIiIiIiIiIKpxUr5hfs2g6TPGcTdyWLVvw2GOPISsry6jQtWBemmvixImYNWsWEhISxHEjR45Edcbcl4iIiIiIiIiIHhqmmvnChM/bRG2p4sz3gTrwFmRubi6uly9fjsaNG5f5hIiIiIiIiIiIiIiqm6ioKDzxxBPIzMxEkyZN8Pnnn6Nr166wt7cvcn9p/fDhw7F69Wps27at2hfwMvclIiIiIiIiIiKi/5KoapD53ncBb1FVxVK1sbOzc5lPhoiIiIiIiIiIiKg6WrRoEdRqNWrWrImDBw/CycmpxGN69uyJVatW4fTp0zA1zH2JiIiIiIiIiIjoYbaoGmS+ZS7glTowEBERERERERERET3Mtm/fLgpaX3/99VIFuZKGDRuK6+DgYJga5r5ERERERERERET0MNteDTLfMhfwEhERERERERERmbQcwCwHpscUz9mEhYaGiuv27duX+hgHBwdxnZ6eXmHnRURERERERERERA9J5isx1fM2QaHVIPOtkALe7OxsJCUlQaPRICen+BHl7+9fEadAREREREREREREVG70er24NhgMpT4mJSVFXNvZ2eFhwNyXiIiIiIiIiIiIHhb6apD5llsBb3x8PL755hts3LgRgYGBpXpSUvvh3H8EIiIiIiIiIiIiourKy8sLISEhuHXrFjp27FiqY06cOGHyxazMfYmIiIiIiIiIiOhh5FUNMl/z8riTI0eOoGnTpnj//fdx8eJF0YlB6sBQmgsRERERERERERFRddetWzeRZ65bt65U+2dlZWHp0qWimLVnz54wRcx9iYiIiIiIiIiI6GHVrRpkvmXuwJuQkIBHHnlEXEttgZ955hk4OTlhwYIF4kR/+uknJCYm4tSpU9i8eTO0Wi26dOmCKVOmlMsTICIiIiIiIiIiKhOp1tAU6w1N8ZxN2FNPPYUVK1aIjHPXrl3o169fsUHuxIkTERQUBHNzc0ydOhWmhrkvERERERERERGZLFPNfGHC522CnqoGmW+ZC3i//fZbEeJaWlri6NGjaNKkCS5fviyCXMnkyZPz9o2KisK4ceNw4MABdOrUCZ988klZH56IiIiIiIiIiIiowkkdFR5//HGsWbMGw4YNwyuvvIJHH300b7s01VpycjIOHz6MZcuWiWnXpELX559/XmSmpoa5LxERERERERERET3MelaDzLfMBbzbtm0TJ/X000+XeFLe3t74559/0KJFC3z++ecYMGAAevfuXdZTICIiIiIiIiIiIqpwy5cvR1pamsg4pXxTukjZqEQKeHNJ065JRo0ahcWLF8MUMfclIiIiIiIiIiKih93yKs58zct6Bzdv3hTXffv2zVuX+wQk2dnZRvtbW1vjtddeE0/ohx9+KOvDExEREREREREREVUKqRvtli1bsHTpUtSpU0dknEVdfH19sWTJEqxfvx4KhQKmiLkvERERERERERERPewsqzjzLXMH3tTUVHFds2bNvHVWVlZ5y1J1spOTk9Exbdu2FdfHjx8v68MTERERERERERGVjfTFefnL86bFFM/5ITF16lRxCQwMxKlTpxAbGysKWl1dXdGqVSu0bt3aqNjVFDH3JSIiIiIiIiIik2WqmS9M+LxN3NQqynzLXMBrZ2eHlJQU6PX6vHUuLi55yyEhIWjZsqXRMVqtVlxLT5KIiIiIiIiIiIjIFDVu3FhcSnL69Gm0adMGpoS5LxEREREREREREf3XNK7kzNe8rHdQr149cR0WFpa3Tuq84OXlJZb37t1b6JhDhw6Ja1tb27I+PBEREREREREREVG1dOTIEQwaNAgdOnSAqWHuS0RERERERERERFSxmW+ZC3hzT+TkyZNG6wcOHIicnBx8+umnuHHjRt76Y8eO4bPPPhPthNu1a1fWhyciIiIiIiIiIioTsxzTvVD1tGfPHvTq1QvdunXDzp07RU5qapj7EhERERERERGRqarq3Ja578NnTwVlvmUu4B0wYIA4mQ0bNhitnzFjBpRKpZgurUmTJiK0lVoLS08gOTlZ7PPKK6+U9eGJiIiIiIiIiIiIKkRu7vnCCy9g2LBhGDVqlMg9pS4LRdm3bx86d+6M/v3748CBA+J46dKvXz+YGua+RERERERERERE9LDJqWaZr7I8gtyJEyciOzsbwcHBqF27tljftGlTfP/995g2bRr0ej1Onz5tdNyCBQtEtwYiIiIiIiIiIiKi6iY0NBSPPPIILl68WGjb4sWL8dhjj2HlypVQKBRISEjAM888g82bN4vtUoArdaKVjp8zZw7atm0LU8Pcl4iIiIiIiIiIiB4modUw8y1zAa+FhQWWL19e5LYpU6aga9euYvvly5dFoBsQEIAJEyaYZGhNRERERERERERED7+srCwMHTpUZJr3sm7dOvj7+2P69Ono0aOHCH+lEFcKd8eMGYO3335bdKg1Vcx9iYiIiIiIiIiI6GGRVU0z3zIX8JakQYMG+Oijjyr6YYiIqBwZogOq+hSomorNVlf1KVA1lZBtVtWnQNVUuN6xqk+BqqmoVIeqPgWqphQpFR5VkInJSeOYoMondVmQglypo0LNmjUxd+5cNGvWDCqVCleuXMFnn32Gs2fPik60R48eRUhIiDju0UcfxYcffiiKWR92zH2JiEwLM1+6l35XhlX1KVA1lZFpUdWnQNWUPtu8qk+BqinLlKo+A6quLNKzq/oUqBoyaA1VfQr0H7Oymma+FfYJiNR1ISkpSSw7OztDqeSHLURERERERERERFT9bdiwQVz7+vriwoULsLOzy9vWokUL0W2he/fuOHLkCA4fPiw6MPz888+YOHEiHnbMfYmIiIiIiIiIiMjUbKimmW+5fjUqMDAQL7/8Mho3bgwrKyt4eXmJi7TcqFEj0Vr40qVL5fmQREREREREREREROXq/PnzohPDzJkzjYLcXObm5njvvffEsrTfhAkTHuriXea+REREREREREREZMrOV9PMt1wKeA0GA15//XVRifzdd9/h6tWrYl1OTo64SMvXrl3DkiVL0KpVK7z22mtiHREREREREREREVF1k5CQIK6bNm16z32aN2+etzx69Gg8jJj7EhERERERERER0cMgoZpmvuUyv9m4ceOwbt06EdpKmjRpgvbt28PT01PcjomJwcmTJ0UXhuzsbHz99deIjIzEmjVryuPhiYiIiIiIiIiIHpwUacmxlmkxxXM2ERqNRnRZ8PDwuOc+bm5uecvStGsPI+a+RERERERERERkkkw184UJn3c1p6mmmW+ZC3hXr16NtWvXiicndWJYtmwZ2rVrV+S+Upj7/PPP4+zZs1i/fr04duzYsWU9BSIiIiIiIiIiIqIqo1SWS5+EaoW5LxEREREREREREf1XKSsp8zUv6x1Iwa2kfv36OHTo0D1DXIm07cCBA2jQoIHo2rB06dKyPjwRERERERERERERlTPmvkREREREREREREQVq8xlwufPnxddGN566y3Y2tqWuL+0j7Tv008/LY4lIiIiIiIiIiIiqo6WLFlS7JRq97PfvHnzYEqY+xIREREREREREdHDZkk1y3zLXMCblZUlrps3b17qY3L31el0ZX14IiIiIiIiIiKiMjHLkS+mxhTP2dR8//33xW6XClxLs58pFvAy9yUiIiIiIiIiIlNlqpmvxFTP21R8X80yX/Oy3kHNmjXFdUpKSqmPSU1NNTqWiIiIiIiIiIiIqDrJyckpt4spYu5LRERERERERERED5Ocapj5lrkD76OPPoqFCxfizz//RK9evUp1zPr160Wl8siRI8v68ERERERERERERETlau/evfivY+5LRERERERERERED4u91TTzLXMB74wZM7By5UosXboU3bt3x5gxY0oMcaV9a9eujTfeeKOsD09ERERERERERERUrnr06IH/Oua+RERERERERERE9LDoUU0zX/Oy3oGjoyN2796N1q1b44knnsCIESOwceNG3L59GzqdDnq9XixL66TOC48//rjYd8+ePeJYIiIiIiIiIiKiKpdjgheiCsTcl4iIiIiIiIiITFpV57fMfak8O/AqFIoS98nJycHff/8tLsXtc+rUKdSpU0dMpyYFvURERERERERERERU+Zj7EhEREREREREREVXzAl4pgC2v/Up7X0RERERERERERERUcZj7EhEREREREREREVXzAt758+dX7JkQERERERERERERUaVi7ktERERERERERERUNVjAS0RERERERERE/21S01BTbBxqiudM1Q5zXyIiIiIiIiIieuiYauYLEz5veiDmD3YYERERERERERERERERERERERERERERPQgW8BIREREREREREREREREREREREREREVUiFvASERERERERERERERERERERERERERFVImVlPhgREREREREREVF1Y5YjX0yNKZ4zERERERERERERUUUz1cxXYqrnTQ+GHXiJiIiIiIiIiIiIiIiIiIiIiIiIiIgqEQt4iYiIiIiIiIiIiIiIiIiIiIiIiIiIKhELeImIiIiIiIiIiIiIiIiIiIiIiIiIiCqRsjIfjIiIiIiIiIiIqNrJuXMxNaZ4zkREREREREREREQVzVQzX5jwedMDYQdeIiIiIiIiIiIiIiIiIiIiIiIiIiKiSsQCXiIiIiIiIiIiIiIiIiIiIiIiIiIiokqkrMwHIyIiIiIiIiIiqm7McuSLqTHFcyYiIiIiIiIiIiKqaKaa+UpM9bzpwbADLxERERERERERERERERERERERERERUSViAS8REREREREREREREREREREREREREVElYgEvERERERERERERERERERERERERERFRJWIBLxERERERERER/bflmPClirz11lswMzPLu+zbt6/EY7Zt24aRI0fC19cXlpaW4lq6La0nIiIiIiIiIiIiKjdVndsy92XuW0rK0u5IREREREREREREdO7cOXz55Zel3t9gMODZZ5/Fzz//bLT+9u3b4rJx40Y888wzWLp0KczN2W+AiIiIiIiIiIiIqLIx960a/JchIiIiIiIiIiKi+wpl9Xo9PDw8SnXMnDlz8kLcVq1aYdWqVThx4oS4lm5LfvrpJ8ydO7dCz52IiIiIiIiIiIiICmPuW3VYwEtERERERERERESl8vXXX+PkyZNo2LAhpkyZUuL+169fx+effy6W27Zti8OHD2Ps2LFo166duD506JBYL/nss89w8+bNCn8ORERERERERERERJSPuW/VYQEvERERERERERH9t+WY8KUShYWF4Z133hHLP/zwA1QqVYnHfPXVV6Jrg+Sbb76BtbW10XYbGxuxXiLtt2jRogo5dyIiIiIiIiIiIvoPqerclrkvc99SYgEvERERERERERERlejFF19Eeno6Jk2ahB49epS4f05ODjZt2iSWpc4NHTt2LHI/aX2DBg3EsrS/dBwRERERERERERERVTzmvlWLBbxERERERERERERUrLVr12LLli1wcXHJmxqtJMHBwYiMjBTLJQW/udtv376NkJCQcjhjIiIiIiIiIiIiIioOc9+qxwJeIiIiIiIiIiIiuqfk5GS88sorYvmTTz6Bm5tbqY4LDAzMW5Y6MRSn4PYrV6488LkSERERERERERERUcmY+1YPyqo+ASIiIiIiIiIioqpkliNfTE3Bc46Kiipxf19f3wd6nDfffBPR0dHo0qULpkyZUurjIiIiSv3Yfn5+ecvh4eEPdJ5EREREREREREREppz5Spj7/rewgJeIiIiIiIiIiMjEtW/fvsR9cnLuP7E+ePAgfvrpJyiVSvzwww8wMzMr9bFpaWl5y3Z2dsXua2trm7ecnp5+3+dJRERERERERERE9LBh7vvwM6/qEyAiIiIiIiIiIqLqJysrC88++6wIgF977TU0bdr0vo7XarV5yyqVqth9LS0t85Y1Gs0DnC0RERERERERERERlYS5b/XCDrxEREREREREREQm7sSJE/D29i7X+/zwww9x9epV+Pv7Y/78+fd9vJWVlVEoXJzMzMy8ZWtr6/t+LCIiIiIiIiIiIqKHDXPfhx8LeImIiIiIiIiI6L9NmmHs/mcZq3oFzlkKcX19fcvtrqUA96OPPhLL33zzjdFUZ6Vlb29f6unR1Gp1qaddIyIiIiIiIiIiInooM18Jc9//FBbwEhERERERERERkZFFixaJ7gl16tRBRkYGVq9eXWifS5cu5S3/+++/iI6OFsvDhg0TwW/BYDkiIqLYxwsPD89b9vPzK6dnQURERERERERERES5mPtWPyzgJSIiIiIiIiIioiKnNrt16xaeeOKJEvdfuHBh3nJwcLAIchs3bmzU2aE4Bbc3atToAc+aiIiIiIiIiIiIiO6FuW/1Y17VJ0BEREREREREREQPn9q1a8PHx0cs79+/v9h9Dxw4IK5r1KiBWrVqVcr5EREREREREREREdH9Ye5bvljAS0RERERERERElGOClwq0fPly5OTkFHuZP39+3v579+7NW58bxJqZmeGRRx7J67Rw7NixIh9LWp/biUHaXzqOiIiIiIiIiIiIqEyqOr9l7svctxRYwEtEREREREREREQV4tVXX4VCoRDL06dPh0ajMdou3ZbWS5RKpdifiIiIiIiIiIiIiKov5r7lR1mO90X3kJWVhRUrVmDdunW4cOECEhMTYWFhIVpDd+7cGVOnThXXRERUvGs3s7BrfwZOX8jEmQuZuHIjC9nZwHtvumDOay7FHrv7QAYWLU3GybNaqDU5qFlDiVFD7DDrZWfY2d77+yw3g7PwwVdJ2HMwA3EJ2XB3VaBPNxu8M8MFdWpaFHnMHxvS8NHiJNwMyYKnmxKTn7DH3NdcoFAU/jaROsOAZj3CxDmc2ukHlYrfOKoItyOz8d136fh3XyaiorJha2uG5s0t8MzTtujbx+qexxkMOVj/p0ZcLgfqkZ5ugJOTOQLqKTF0iBWemmRrtH9GhgELP0jDlq1apKUZ0LiRBd6ebY+uXSyLvP9du7WY+FQSZr1lj1em25X786aSRUVm45fv03BwXyZioqWxYY7GzSzw5FO26FHM2Cho9Qo13n8nRSyPetwG733qVGgfaWx8+WEqdm7TIj3NgAaNLPDqmw7ocI+xsW+PFi89nYiXZ9rj2Zfsy/gs6UHERuqwflkCzhxSIy5Sh5wcwMVDiabtbDBqigvqNCo8PtKSs7H+xwQc3ZWGmAgdVJZmqNXAEgMfd0afkY5FPo42w4CfP4nFoW2pUKcZUKeRJZ56wwMtOxv/fsl1/N80LJgagUmvu2PsC27l/rypdAy6bCRtP42Uw4HIDI+DIVMHhYMNrGp6wLl3Czh2a1Ls8Qn/nELU0m1i2blvS9SYPqzwY2izEL18D1KOXIEhQwurWp7wnNgbds1rF3mfqSevI+z9NfAY3wsej3Utp2dKZfFW9254rl07sfzFocP47vjxQvs4Wlnh2bZt0a9eXfg6OCIzW49r8fFYfeEiNl65UuT9WiuVmNWjOwYFBMDe0hJX4uLw2cFDOBoeXuT+vevUxk8jR+Lzg4ew5MSJcn6WRCWrX78+Zs6ciY8//hinTp1Cly5d8NZbb6Fu3boICgrCJ598grNnz4p9pf0CAgKq+pSJSoWZLxFR+WHuS/dLE52Co+N+KdW+rRY9BucWvkbrEk+HInzdGaRejUa2VgcrTwe4dw9AzXHtoLRWFboPQ7YBIb8eQ9SOy8hK1sDG1wm1J3SER8/6RT5m2s1YnJq2Ct4DG6Ph6/0e8FlSWeVI+c3OU0g7fBmZEXHIkfIbextY1vSEY68WcOjaNG/f9DM3kHb0CjJDoqFLSIMhXQMzpQIWXs6wax0A5+GdoHSwKTK/iV2xSxwr5TeWtbzgPr4PbJsVnd+kn7qOiA9XwW1cb7iN7lahz5+Kz/YSt59G8iEp24sX2Z4yN9vr0xxOBbK96D/2I3b1wWLvr/6S52Hla5zV5mQbELPqAJL+PQ99cgYsa7jA4/FucOrauMj70NyKxo3Xf4FLnxbwfWlIOT1TKq3BbRuic8OaqF/DHe4OtrC3sYQ2S4/Q2CTsuXATq/afgyZLV+SxUjPJoe0aY2i7Rqhfww12ViqkqDMRHJOAXeduYO2hC0b7W6uUePWRbujXIgB21pa4fjsOX/99GCduFJ3tdW9SG988NwJf/30IP+86WSHPn4qmUJijRTM/tG9TG62a+6OGjzOsrSyQkqrB1etR2PzPORw7eavQeGjcsAY6tK2NVi1qoqafK2xtVEhXZ+JmUCy27b6I3XsDi3w8K0sLPD+lJ3p0bQBbW0sE3YrFsuX7cfZ8WJH7d2pfFx+/Oxo/Lt+P39cU3f2UqCIx9y0/LOCtYKGhoRgyZAguX75cKOC9fv26uEitqaWK88WLF7NVNBFRMX74NQVf/yQXyd2Pr5Ym4/UF8eIFc7cOVvBwV+LQcQ0++joJG7am48AmX7i5yt8MKujwCQ0Gjo1EhiYHTRqo0KW9NS5fzcKKtWn4c0s6dq6tgY5tjAu4tuxSY8KLMXB2MsfgPrY4fzkT732RhIQkA77+wL3QY7zzcQLCbutxYFMNhrgV5Ny5LIwbn4ik5Bx4epqjVy9LJCUZcORIFvbvz8KMV+0w843CBZKpqQZMmpyEY8ezYG9vhrZtVHB0NENUtAGXLuuQlp5TqID35VdTsPUfLRo2UKJNawvsP5CJJ55MxMY/XdGmjXHwq1YbMOvtFDRqqMQLzxddqEcV6+L5LDw/MQEpyTlw9zBHt55WSE4y4MTRTBw5kInnX7HDSzMcir2P8DA9vvgoVfx+kQo872XOjGTs2qZFQAMlWrRS4ejBTDw3MQG/rnNDi9bGYyNDbcD7c1MQ0FCJyc+xsLsqXD2nwduTwqBJN8DVS4nW3Wxhbm6GW1e02PNXCvb9nYK3FtVAt8H54yMqLAuzxoch9rYODs4KUYCbqTWI+7p0MhLnjqgx41PvQq/3P58ZicPb01CrviUatrLA2UNqzJ0chs9W10KjVtZG+2rUBnw3L1oUBY+e6lpp/x5kTBefipAFK0W4LxXt2jTyg7mlhVivvhwmlosr4M2KTkLMr7sBaSgU83sj4qtNSD16FZY13aFqUAPp524hZMEfqPPRJNg0MP7gMVuThagftsGypgfcR3Yqz6dLD6i1jzeeadMGhpwcmN/jfb6foyNWPjYavo6OSNRocCQsDFZKJVr6eOPLwb7o7O+PN3fsKHTc54MGYlD9+rgWF4+zUVHoWrMmlj86Co+vWYtzUVFG+9pYWOC9Pn1wNS4Oy06dqrDnS1SSDz74ALGxsfjll19EaDt27NhC+0yZMgXvv/9+lZwf0f1i5ktEVL6Y+9L9Ulir4DWg6CI4iTokAWnXYqCwUcGhvqfRtrB1Z3Dz+/3ifblTsxpQOdsg+eJthK48gbgDN9D668ehcjTOZIKWHUL4utOw8naEW4faSDoXjkvvbUVTM8CjR/1CRXtXv9gNC0cr1H2OBZpVRcppwhf+jqzwOJHfWDf0F5mNPj4VGYGhYrlgAW/qgYviYuHtAkt/DygdbZCdpoHmxm0kbDiE5D1n4f/uRLGtoKivNyLt2BWx3qK+L9TngxD+3u+o+f5kWN+V3xg0WYhetlXkN64j+EWvqpIVn4rg+X8YZ3tWFtDFpSJdyvasLIwKeHNZ1faEdW3j3ye5FDaFG3VE/fov4jceg8rLCfZt60F9MRRhn24Q1X1OXRoV+r0R8e1WUUTs/VSfcny2VFpjujRHi9o+CI5JxJWIWKSotXC1t0Hz2t5oWtMLIzo0wZSv1yEuVW10nFSsu/jZR9C2ni/SNJk4Hxwprj0c7dDQ1wO2VpaFCngXjh+Ifi0DcCMyHhdCo9GxgT+WvDASkxevxcWQaKN9rVUWePux3qLI99c9pyvl34LytWzmhy8/kjOshMR0XLwcAa1Wh1r+bujSMUBcpCLeL77Jz3B9vJyw5MvxYlkq9L12Ixpp6Vr4eDmibeta4tKnRyO88/5f0OsNRo83+40h6Nm1AW4FxyHwaiTatqqFz98fg+kz/xC3C5IKiV97sT+CgmOxaj2bNlDVYe5bPljAW4F0Op1RkNu8eXPMmDEDDRo0QFpaGg4dOoQvvvgCarUa33zzDXx8fDBr1qyqPm0iomqrSUMVXp/mhJZNLdG6maUIYn9fn1bsMWcvZuKNd+Mhde7f9Ks3BvWxzeuGOeKpKOw5qMG0t2Kx7idvo+Ok7WOfixYh7qzpzvjg7fxCqTkfJuDjb5Iw9tloXDnkD2vr/E4O8z9NgEoFHNnii/p1VaLTQvsB4SKEfvsVZ3h55P/pPXVOi29/ScHzkxzRuZ1xIEjlQ6vNwZRnk0Tx7iPDrbDoCydYW5vlF/ZOSMSXX6WjfXsVenTPD1hycnIweYpcvDthvA3mv2MvOrPmysrKQeAV42/aSkW9UvFut64qrFopd944eCgTY8Ym4quv0/Hbr8bdQj76JA3R0QYs+94ZFhYM8StbpjYHrz2fJIp3Bw6zwvufO8PKyiyvsHfapET8sDgdrdup0Lmb1T07NM99PVl8SDT8UWtsWm88LUiuq5d1oni3YxcVlv7mKsbGsUOZeObJBCz9Jg1L/mdciLn4szTERmfji+/cODaqyNdzokTx7qCxTnhhgReUd34O0s/896/isOq7BLFPhz52UFnKvxs+efW2KN5t3sEGc7/3hb2j/AFhZEiWKMjdvSEFjdtYY9BY57zHCQrUiuLdlp1t8P5yfzE2zh5W4+2JYVj9XTze/cnP6Lx+/SIWCTF6zP7GN++cqHJJ3ThC5v+OzIgEeDzRHe6ju4puLAW3Z95OuOfxOYYcRCzeLH0PH069miP5X+PwtmDHDal417Z5bdRaMA5mCnOknw9GyLzfEbf2EGq+YxyAxP6+F7rENNR581Gj86GqIRXhfjZgIGLValyIjsGAgHpF7rd4yGBRvHs0LBzTNm9GamamWF/TyQn/GzUKo5s2wenISKy5eDHvmEbu7qJ493BoKCb9uUEUCHf298Pvjz2Glzp0wDMbNxo9xutdu8DTzg4vbdkKvcE4ECZjZjnyxdSYyjmbm5vj559/xqOPPoply5bh5MmTiI+Ph5ubG9q1a4fnnnsOgwYNqurTJCoVZr5EROWPuS/dL6nAtvFbA+65/fysv8S1Z6/6UFjnd1ROuxGLmz/sh5m5GZp/8AhcO8hdUqUuvBfmbkLSmXBcW7QbzRbkz5STlZSBiI3nYFvTBW2/HweFlQXUYYk48cxvCP71WKEC3vAN50TxcNN5Q2BhV7oZvqh8SflM+Lu/Iet2PNwe7wHXR7sVym+yIo3zG5dHOsNjUn8one0KFd1GfbcJaUcCEbXkb9T6eEreNm1wtCjetWleG37vjBf5jfrCLYQv+A3x6w/Ab844o/uK+2MP9IlpqPH6Y8xvqoj0sw+et1Jke55PdIfHY11Kne05dKgPr3E9SvU4+mQ1ErachKWfGwK+nCIKxrUR8bjx8jLRlffuAt74LSehuRkF/zdHQcHfG1Xii40HEBqXhNQMOZ/L5Whjha+mDkfrujXw+sjumPWrPKtaLmmbVLy77tAFcR8Fu/QqFeao72P8JZ8GNdxF8e6xa2GYtkTO9trX98OPL43Gs/07YPqyTUb7Tx/aBR5Odpi5nNleVZB+PvsOXcOfG0/hwuUIo229ujfE3DeHYfjglrgUGIEde+SMQIrqTp8Lwer1J3DqbIj4XCmX1M1X6pjbuUM9PDmmI37940jetnp1PETxrnTMzLlrxXGtW9bEoo/GYsLYTpi94E+jx39mUne4udphwUebkJ3NsfGwZb4SUzlv5r7l495zx1CZbdq0KS/I7dSpE86cOYNJkyahY8eO6NevH959913s379fTK0mkVpH6/X6Kj5rIqLq65knHfHpPDeMG2WPhgEqmJfir5gUuEpdMZ963CEvxJXY2Jjjxy88xH1s2KrG1RtZRsf9ujYNkdHZqF/XAgtnGRdeSrel9eGReqxYl2ZU1HnxSha6d7QWIa7E1sYcTz5qL6Z8O3E2/01fdnYOnp8ZBy8PBT4sEBJT+dq2XYvISIPonPvJR455xbuSli1VmPGq3Hn3y6+MPxBYvUaDI0ez0LOHJT792NGoeFcidc1o2cK4a+qFC/Kb8rGP2+RNm9etqyVq11Lg1Cnj8SUVD/9veQaemmhTqDMvVY49OzSIjsyGg4MZ5n3glFe8K2nWQiW670qkIt57+f0XNU6fyMKMWQ7w8b134Hr5ovzzHzkmf2x07GoJ/1oKnDttPDak4uFVv6oxdoJtoc68VDlSk/QIvir/vp44w92oUFbqwvvkK+6wtDJDeqoBYTfln9+VMxm4dl4LcwXwykfeecW7Ep9aKjw7R+7MsOrbePEFgVw3L2nFdf/HnPLGRqsutvCpaYHAMxlG53XtggZ//5aEIU86F+rMS5Unbv1hEfA7D2gNj7E9Cn3YIoXx1nW87nl8wt/HkREYBs9JfWDh4XTP/TRBchdV574txIc/ErsWtaHydkHGVeOp1DJuRCLhn5NwGdS2UGdeqhozu3VFbRdnzNm1G2l3inLv1srbGy29vUXwPnvnzrziXUlocjI+2L9PLE/v2MHouGae8u+TdZcuiwBZciQsHCFJSWjt42O0b3NPT0xs2RK/nz9fqDMvUXlZsGCB+NsmXXr27Fni/oMHD8bGjRtx+/ZtZGZmimvpNkNcMiXMfImIyh9zXypPmXHpSDgVKpa9B+d3WJWE/nFCVNZ4DWySV7wrkYpyG77RHzA3Q9yBm6JAN1d6cDxydNnw7NtI7Cex9XeBUwtf0elXr87/+WtjUhH8vyNw7VgbHj2NC3up8kgdc6XiXad+reH2eM8i8xur2sb5jXT77uJdsa+1Ch5P9RfL2usRyC5Q3KcNkrshOvZulZff2DavI7r4aq4Z5zdSJ9+kbSfhNKBtoc68VHli72R7LgNaiQLe+832SksTGoscfTacezQV9ymx8nWDbZOayAyLMxpHWXEpiFm5D/btAuDU9d6dxaliXQyNLlS8K0nJ0OLrvw+L5U4NaxptG9GxCdoF+OHwlRC8v3aPUfGuRJ9tQGB4jNG6xn5yF++Nxy7lZXsnrocjNDZJdAAuqIm/J8Z2b4G1B88X6sxLlePs+TDM/2BjoeJdyd4DV7F9l9x4oX+f/NcbkVHJmDF7DU6cDjYq3pWcvxiOP9YeK3SMpH49+XfPtp0X8o47cy4UEbcT0bRxDaN9G9b3wshhrbFp69lCnXmJygtz38rFAt4KdORI/rclZs+eDYX0NeC7tGnTBkOHDhXLycnJuHLlSqWeIxHRw0wKVv/ZLU9l8sSowsFLTT8LdGknf5N14zbjIr2/7tx+/BE7UbBVkHR7zHD5/v76J/+45NRsEdi6OBv/vs+9na7O//bbV8uScfZSpphezcGef44ryrnz8pvl5s0s4OhY+N+5Wzc5cD95UofY2Oy89T//Io+bF6blh/8lSUqSf75OTsbjxdnZHOqM/Ddoen0OZr6VAi9Pc8yeJRcQU+W7dGdsNG5mAYcixkanLnJH5rOnshBfYGzkCg7S4+vP0tC2owqPT7Ap9rFSkuWx4ehk/DhOzubIuGtsvDsrGe6e5njlTY6NqmKhKv3vZMc7v9+vX5ALcT1rWMCnZuHC65Zd5N8lcVF6UeibKzVJHlsFC37FbWcFtBn5fzOy9Tmi46+LhxJPvVF4Wk6qHFLonrhdnqbMbWSn+z4+MyIeMb/vhU3TmnAZ1KbYfaUpGiUKe+Nibem2QZtlNL1e5HdboHS2h+f4Xvd9TlT+Ovj6YlKrVvjz8mXsCw6+537NveRANiIlFWEphacKPhwaJq59HBzQ4s6+Eidr+bVrsjb/d4kkSaOFjSq/q5TCzAwf9O+HGLUanx88VA7PjIiIcjHzJSKqesx9qThROy5LLfNgW8sVjo3yOzAbdNmIPy6/T/Pq07DQcdZeDnBsIhdPxR26mbdelyq/R7ewz5/BTdx2kMdYtia/YOva4n+lSXfQ4NU+5f68qPT5TfKOU2LZZUSXcrlPs9xvFZib5RXqGuU3dnflN3aF85voH+T8xn08x0ZVjo2EbWfEsvsDZHv3457ZnoN1XmfnXLd/2A5pmr8azw+s0HOiB5d9p/Ntlt74s6InurcU18v3yL9zSsPR1jqvMLgg6bbNnWJvicLcDPPG9kVcihpfb5ELiKn6uREkF2h7uNuX+RjHO68rUtPuGhtpWlhbqYzGxhsvD0RCYjqWLT9QpvMnouqD7xwrUFZW/guvOnXq3HO/unXrFnkMERGVzfVbWWIqNEnbFkVPOdOmxZ0ivUt3dUi9KH/Lss09j5PXnytwnIebEjbWZoW6OuTeruElT6MWEq7Dgs8SMWKQLUYMKhwwU/lR3wnPpSLaori6yOulL7levCgHrXFx2bgcqBfT77Vto0JoqB7ffJuON2el4N2Fqfh7i0Z8SHA3Pz85sL9xM7+zkk6Xg+AQPby88sP9pcvUuHRZjw8/cISdHV+KVZXcwlnHe4wNpwJjI/CS8bempU4qc15PkjI1vPepE8ykhWL4+Mr/92/dNTbCQrLh6Zk/Nlb8lI6rgXrMXegEW46NKmNta46md6a3XPFlHPS6/P/v0reeVy6OQ6Y2B2172MLdRw7UNHeKbR3u+iAvl5W1uejaK7l5SQ5vJZ6+8vHhQfnf7JceLypUB1fP/LBuw8+JuBWYiRff9YKNHafXqyqaoGhkp2ZA6WIPS28XaENiELt6P24v2YroX/cg7dQN5Nz1jfqCH9RELN4sh/EvDS3x94bKw1FcZ4bH59+HPhtZUYlQujjkrYvfdAza4Bj4PDcQChvjDxKp8tlYWOCTAf0Rr1Zj4V65g+692N7pypiszf+dUJBWr4dGpzPquptb8Cup55LfKUxpbo6azk6ISc8vMJjStg2aeHhg/p49UN+5HyIiKh/MfImIqh5zXypO1I5Ace09yLizXUZEEgxaOZ+zb5D/Pqsghzvr02/E5q2z9pTfoxfsyivuLzQRZhYKWDjKOVLMvmtIOBaMOlO6wMqDX86vKtpbUXn5jTSTkTY0BvFr9iH6+78R+9tupJ+6fs/8pigGnR5xK//N666b201Vkju7UtbtOKP8RhedCIsC+U3i5qPIDI6G59TBUFgzv6kW2Z6PCzQhsYhZdQAR321F1K//IvXkvbM9cfytaLFfxLdbEfm/3Ujaf8mok25R2Z42Ij/by836pK6/Cge5KUjyoUCknbwBr/E9oXKXj6HqRSqqnTaoo1jef/FW3noXexs09PUQXXbPB0eihqsjnu7bDnPH9MGMR7qhX8sAKAsU/OeKTJSzvTqextmen5sTYlPys70JvdqI+/9w3b/IyGS2V1351pB/jgmJ6jIfEx0jj42afvkzOCgU5qjh7YT4hPyZIcaMaoeAup5Y9N0uaAp8GYCITJv8jpIqRIMGDfKWb926hSZNmhS5X1BQkLiWPsQNCAiotPMjInrYBYfJYZyTozns71EM53en+CokLP/NT1q6AQl3uqn61yj6T6Wfj7w+LiEb6gyDmDJNMmyALdZsTMeiH5Iw5UlHHDutxfI1qfBwU6BjGzn8feGtOCiVZvjmQ3ZRrGhubnKhW2hY4Q6qYn1o/vqwcHk58Io+r+j3j1UZomj37rqXmjUV+OVHZzRunB/WdeliCTs7MyxdqkaHdirUrq3EosXpSErKwaiRcigXFqbHF4vSMXSIFQb0L/pDAqocLq7y/9mIe4yNgutv3xkbuf63NB0Xzurw1jwH+Ncs+eV0h84q2NqZ4dcf09GqnQo1aymx9Os0JCcZMGSE3Jk1IkyP779KR//BVujVj2Ojqr3yoTfemRKObauTcWJfOuo3tYK5wgxBgVrEx+jRZ4Qjpi3I/6DHyVX+XRMdXnSQlhinF0W/d+/TopMNrO3M8efPiWjc1gY1aqmw6tt40Zm313A55I8Oz8LKb+LQdZA9Ovblhz9VSfrAR2Lhai8KduP/OiKm3cwVv+EIrOp4wf/tMYUC9/i/jkJz/Ta8pvQXxb8lsW1eW0zRKBXo2jT2F8fErj0ounc49Wgm9smKSULs6gNw6NwIDh3y33tS1Xm7R3f4OznhuU2bkJpZ9Ac4ueI1GeLa17HoD2fcbGxgfafIt+A+R8PDkJaZKQp0T92+jeDkZEzv2AEu1tbYdKe7o6+DA17u1An/XLuOPUH5HyxQCaT/z6X/DLf6MMVzJjJxzHyJiKoec1+6l6TzEdDcThaFtV79Gxlt00bJs58o7SyhtCk8g5LE8k43PE20XEQjsavnDitPB0RtD4RrhzpwbOyFyH8uIf1WPNw614G5hQK6dC1ufLsPDg294DtC7shIVSPzTn6jdHUQBbuJGw8bvW9K/OswLGt7wXfWWFgUUTCpDYpC4j/HxTHZqWpob0aKok+rej7wenG40b42zeT8JnHTUVg39IfKxxXxa/eL/Mahe35+I62z79QY9u2Z31QlTcidbM/NXhTixm0wzvbi/oTI9mrNeazIYtq0EzfEpSBzW0vUmDoAzr2bG623qu0FCw9HJO0+D4e29WDTwBeJO89CGxILh/b1xe+N7HQtIn/cCev6PnAd0q6injbdp04N/TGoTUOYm5nB1d4GzWt7w87KEocCg/HV5oN5+9X3cRPXKWoNRnVqhtdHdIeF0rj5Rnh8Ml776W/ciMwv5D5xPQzp2kxM7N0GZ29FIiwuGc8O6ABnO2v8c+qq2KeGiwOeH9gRO89ex/5LzPaqKxdnWwzsK39Z6MDha6U6xtJSiUeHy7PzHThkfMyZ86FQZ2RizKPtcTEwAhG3kzDxic5wcrTB7r3yl5O8PB0x6cku2HfwKo4cz58tgB7CzBcmfN70QFjAW4GeeOIJzJ07F6mpqfjkk08wePDgQlOqnT17Flu3bhXL48aNg4ND/rfxiIiobKRAVmJrc+8ud7a28rbUO/sWPK64Y+3uHCeOTcsPcj982xX7DmvwxrsJ4iKRai9WfOsBS0szrPorDTv2ZuDbj93hc6czg0SrNcDCwgwKRfEd+ej+dO2iwuKvgQsXdLh4SYdmTfMLbiUrfpeLZyRp6fKr4KQ7IX5ysgFz56WKYtvXX7MTHXavXtVj3oJUnDmrw7gJifh3tztc7nRwlbr5zn3bHrPeTsWgofLPXhIQoMQbM+Tg963ZqWI8vP+e8d97qWOI1MWDKk+HzpZY9m06Ai/qcOWSDo3uGhtrV+Z/8zW9wO+EG9d0+G5RGlq2scCTk+Xi25I4uyjw2iwHvD83BU8Mzw9q6tRT4oXX5LGxcG4KlBbA7AXGwaBGY4C1NbvxVjbfOpZYtK4WPnsjEmcOqnE0Ov+b7/4BKjTraANb+/zX9c072oqOzCmJ2TiyMw2d+xsX2v7zR1LeckaB8eToosTTb3rgu3nReHVkSN56v3oqPPmK/GHft+9Eiw//ps0z7gyj1RhEZ1+qPNl3pszUBkdDcyMSLoPbwnVoeyid7URxbuTSbdDeikbowlWo9+VU0U1D7B8ai9hV+2HT0FfsXxpKBxt4TuqDqB+24dYbP+ett/R1g8cT3cVy5PfbYKY0h/fUAUbHGjJ1Rt1gqHJ0rVkT41q0wN9Xr2LXTblgqzjHwsJhyMkRhbr96tUtdMyTLVrkLdup8j9YTtJo8enBg1jYty82jn8yb/2NhAQsPnJULEvb9NnZeHfvXqP7tFIqRWdfIiIqG2a+RERVj7kv3UvUtkvi2q1THajudMbNpdfIxdwKq3u/Z1ZYy9uy1fkd7aRCu/rTe+Li/C04/9aGvPUqV1sEvNBDLActOwRdihYtP30UZub5P+tsra7Yx6PyJxXPSrTBUdDeuA2nQe3gMqQDFE524nbMj/+IbrgRH/yBWp8/m5ff5NLFpyB173mjdTbN68Dr+aGwcHUolN+4T+iLmGX/IPStn/LWq3zd4PZ4T7Ecs3QrzBTm8Jwy0OhY5jdVODZuRUNzPRKug9vCbVg7ke1lXL+N20u3i20h761GwKJn8saGpbczvCb0gn2buqIoV5IZFo/YP4+I7rnhX20GzM3g3FMu2s79vVHj2QEI+Wg9guevyluvdLGD9zP9xHLUr3ugT81A7XfHGf3e4NioWnW8XPFIB+MvaW49dQWf/3UA6dr8vw1OtvKXdxxsrTBrdC9RbLt0+zHcTkhFPR9XvDmqJ5rX8saSaSMx+qPfkJKhFfsnq7X4avMh0an3jzfG5d1fUHQCvt8mZ3tzHu8DXXY2PvnTeIYvKwsltDpme9WBwtwMc2YOhb2dFYKCY7H5n3OlOu61F/vDx9sJcfFp+H2N/PPOlZKqwdJf9mHGSwOwdPGkvPUhYfH438pDYnnGS/2h1xuw+PvdhQqDMzM5NohMGQt4K5Cbmxt+++03EeoePnwY7dq1w6uvvor69esjPT1drPviiy/EFGqtW7cWy/cjIiKi2O1RUVFlfAZERHS/avlZ4MJef/xvdSpuBuvg6a7AuFH2aBigQlJyNmbMi0eXdlZ4fqIc9KzZlCamVbsepBOBb9/uNqJDQ21/vjkvD127WKJjBxWOHc/CU5MT8dGHjuK2VKS7fEUG1q3XiH93qcNubj6Sc+fbbFJ9S9s2FvhxqXPe/bVpo8KaVS7o3C0OMTEGLP9VjRmv5hfqTZpoi6ZNLLD1H60oCG7SWIkxY2xEce6fGzTYtz8Tn37sCE9PhSjaXfh+qliflpYDFxdzTJpgg9dn2DHQrwQduliibQcVTh3PwkvPJOCd953Qpr1KFG6vXqHG5j81oqBWL42NOzWSen0O5sxIFmNl4WfOMC8QqpVk7ARbNGpigV3bNFCn56BBIws88pi1KM7d8lcGDu/PxPyPHOHuqRBFu198kIotGzVIT8uBs4s5Hh9vg2mv2nNsVJLLpzLw/gsRUCjN8NYiH7TobAulhRkCT2fgxw9i8dWsKLH82sc+Yn+fmir0fsQRezamYNGsSGgzvNC2h63ourt3cwrWfB+fN57M7qq5HfqkM+o2tsLh7amiuLdOI0v0fdRJFOf+uykFpw+qMf19L7h4WIii3Z8/jsW/G1PEvg4uCgwZ54wnX3bj2KgU8h+IHL0Bjt2bwOe5QXlb7FrWQa33xuPGC0uQGRqH5IOX4dyrOXKyDYhYvEn8kakxfZhRGF8S10FtYV3HC6lHriJbkwmrWp5w7tNCBPjJ+y4i/WwQfF4YAgsXexHsR/9vN5L3X4QhI1NMw+cysA08xnYXHxJRxbJXqfDxgP6Iz8jAgn/laTVLEpaSgo2BVzCqSWN80n8AbCz2Yn9wsCiyfaRRI0zr0B5Z2dlQKRTIyX1xcsfK8xdwOTYOAwMCRHHv1bg4rL98WRTnPtKwIXrUroW3d+5CnFot7m92j+4Y0agR7C0tkZCRIY7/+uhRUUBMRET3j5kvEdF/E3Pf6k+vzkTsAbk7ps+gojvkPyi3znXRbtmTiPn3GnTJGbDxdYb3oKawcLBC8sXbiNx6ETWfaAe7Om4iCwhecQy3N1+ALkUDha0KXn0bod5z3VjMWxnyAn4DHLo1hdfUwXmbbFvUgd/8Cbg1/VtkhsUi9dAlOPbM/wKtxL5DQzTcMF/8HPUJqVBfuIX41fsQ/OoSeL88Eg6dGxvt7zywHaxqeyPtWKDIZCxrecGxd0uR36TsvwD1uSBR/Ku8k9/E/roTqQfy8xunAW3hNqYH85vKcGdoSNmeU/cmqPF8flG1fcs6qPPek7g27XtoC2R7ktzrgpSN/VC78eO4vWwHEracROTPu+DYpbEo3M0lddqtv3gqkvdfgj4lA5Y1XODctyWU9tZQB4aJjrzuj3aGdS0PMd5iVh9AwrYzouOzuY0lnHs2hffkvizmrWQr950VF6W5Obxc7NGrWV1M7d8BXRrVEt10zwTdvrOnnPNaKBQ4FxyJmf+Tv8ApuRgSjee++xN/vzMZHo52eLxbCyzbcTxv+7pDF3A1IhZ9WwTAzkqFa7fjsPl4oCjOHdy2oXis91bvRnyqWhTtvjaiG4a0bQR7a0skpmeI43/YdozZXhWaMX0A2raqheSUDMz7YKMoqi2J1E13UL9myMzUYcFHm5CaJhd1F7Rp6zncCIpF9y71YWtjiaBbsdi2+6Iozu3bqzE6tK2Dz7/ejsQktSjanTalF/r1bgI7W0txLpu2nsXylYdhMHBsEJkaFvBWsOHDh+P06dMiqP35558xaVL+NyUknp6eWLhwIaZOnQobG5v7um8/P79yPlsioodL7vRp6ox7v0hVq+VtDgWmWis47dq9jk2/c5w41t44WHFzVWDmi/lFn7lmvheP5NRs/PBZDTGF5qbt6Rj3fAy6trfCB7NdER2rx9yPE9Hn0du4sM8fdrYMbMrDj0ud8PTUJJw8qcOkyfldMCVTn7HFiZNZOH9eBycn+d/bzi6/uGrC+MJ/m+3szPHoKGv8sFSNgwezMONV4+1Ska90KUgqGJ7/bio6dFBh/JNy54eXpidhx85MTHvOFu3bq7B9uxaLFqeLwt4F89idqTJ8scQZrz6XhLOnsvDSlESjbROm2OLMySxcvqCD452xITr2XtJhxmx71K57/y+jW7RWiUtBKckGfLowVRQPj35CHm+zXknG3l1aPPWsHVq3U2HPDi1++DodmowczHyn6KnWqfykp2Zj4bQIpCZl48v1tdCwZX63lg697eFfzxLTBt/CznUpomi3RSe5E/NLC72Qoc7G0V3p+Oz1SKP77D7YHjpdjthm72jc1UPSqJW1uBSUlpyNZe/HoGk7awwa6yTWfTYjEsd2p2HUM65o0tYaR3elYdW38cjUGDD1beMOvVT+zK0t85ZdBsjTXBUkTa1n36YeUo9ehfp8sAj349YdhDYoWnTTlbrn3i9pej3pUpA+TYOoX3bCprE/nPu3EusivvwLqSeuw21ER9g08kfq8WuIW3tQfDDk/bTc1YMqzju9esLH3h4v/b1FdMgt9XG7d8NWpcKAgHpYNDi/IFyy5do1WJgrxLZkbeH7PBcVJS4FOVpZYU6vnjgREYHVFy+KddL99q1bFz+dOo2Tt2+jf716eLlTR9hYKPHh/gMP/JyJiP7rmPkSEVUt5r5UlJi912DQ6mHpbgeXdrUKbVfmdtfVyp14i5Kd26XX1jjDk9jVdoPdFOP39gZdNq5+uRvWPk6oNbGjWHdz6UGErz8D78FN4d65jijwDVt7GlmJajR7d1iZnyeVPr9x6l84v7Fwd4Rd6wCkHbsC9YXgQgW8uaSCWgsPJzj1bS068Aa/sgTR324SuYvUsbUg6wa+4nJ3t9fY/+2AdWN/OPZrLdZFfrUB6SevwWV4J1g38kf6iatIWHcABm0WPCcbz7BE5c/cOv//tctA+Wdyd7bn0LYeUo5cRfo5OdsriecT3ZHwzylkp2SIGbpsm/gbbbfydxfde+/+vRHx3T9QeTnDc6w801bU8j2I33Qczv1awrFDfagvhyNu41HoktSoNXt0GZ41PSi9wYCI+BT8tvcMzt2KxIrXxuLDCQPxyAfLkanLRkZmfjfe9YflHK6gjEwdtp68gkl92qJDA3+jAt7cIl/pUpCDjSVmjuyB0zcj8OcR+T4/nDgQPZvVxYp/T+PsrUhRUPzcwI6wVlngi43M9qrC9Of6YOjAFkhN0+CNOWsQcdv4s+eijBnZDlMmdkNmlh5zF/6FS4G5heCFBV6NFJeCpE6/Lz3bG+cvhuPvbXKX+Lkzh6JLxwCs2XACFy9HoGun+pg0rgusLC2w5CfjmdmIqPpjAW8FkzotrFixAps2bSrUNUcSExOD33//HbVr1xbBLxERlZ9afvKfueQUg5gerWBAmys8Ug7kat7ZVyLt5+JsjsQkA8Ju69GiiWURx8nTULi5mOdNo1ac/Uc0WL46DXNfc0bjBnJI8Om3SWKqto2/esPZSS7okjp6vjgrDn9sSMOzE1ioVx7c3BTYtMEVBw5m4dDhTFFM6+6uwID+lmjZQoWWbWLEfo0aymPA3z+/uM7fv+iXSjXv7BMbm12qc3h3YSrS0w347BNHEeLfDNJj2/ZMjBxhhblz5GLd/v2scO26Hv9brsbM1+1gyyC/wrm6KbBivSuOHsrE8SNZSEkywNXNHL36W6FpcxV6tZPDk4AGcri/Z4c8xda+3Zk4sDfT6L4iI+SxcOBfLZ56PF4sL19TcrHeZ++niLEhdd+VxkZwkF4U7A55xBozZstjo2dfKwTd0OGPFWq8OMMeNhwbFerE3nSkJGbD29/CqHg3l7e/Cg1bWOP8sQycPazOK+C1sjHHvB/8cOVMBk4dUCMxVg97JwXadLMV+8wYHSL2q9Wg8N+Uovz4YYzosvvyB95ibETcysSRnWnoOdwBU97yEPt07GOP0BuZ2PxbEsa/4g5rjo0KpfKUC6klFgWWjfbxkj/I1SWli+vUY9fEddrJ60g7fdNoX11ssrzt9E3cmrNCLNf5YGKJ5xH9yy7RpaXGi0PE2MiMiBeP49i9Kbwm9c3r8JEZFofErSfh8UQPKAp8QEHlTyqKlaa1G9+yhbgUVNfFRVyPadYUXWr6i664r2z9R6zT6PWYtnkzWnl7i6657ra2SNFqcSAkFMfCw7HuibFiv2vx8t+Vkszp0V10A3571y5xu7azMwYEBGDTlSv45OBBse7fW7cQ4OqKCS1b4qsjR5EhTUNAglmOfDE1pnjORA8DZr5ERFWLuS8VJWrbZXHtPaBJkTPgWHnJ/+769EzoM7KgtCn8XjkzLk3e17N0DRZC/ziBjNBEtPz8UShUSnG/EZvOw7GJNxq90S+ve682Ng2xe68jIzwJNn6Fi8Cp/Fh4Ohe5bLTPnfxGnyT/vEui8nCCTdNaUJ++AfX5oHsW/RYUu3wnDJpMeD0/TM5vbscj/fhVOHRrBo+J8tiwb9dA5DfJ207CfWwvowJTKn+5uZ1Yvle252mc7ZVE6qardLKFPjEdWfGpkJPi4sWtP4zM8HjUWfgkzFVKZGdkImHrKdg09IXf9KF52V5WfApSDgYi83YCLGu4lup8qGJcDI3GregE1PNxQ2M/L5y9dRsRCSl526VC36Lk7uPuUJqRAbwxogdsrVSi+66kpocz+rQIwNZTV/DV5kNi3f5Lt1DX2xVju7fAkn+OQpPFbK8yvfBML4we0RZpaVq8MWet6JZbklHDW+PFZ3sjS6fHvPf/wonTwff9uC9O7Q0bG0vRfVfiV8MF3bs0wK69l7H0l/1i3ZHjQahV0w0jh7fG/34/BE0xX1j6LzHVzFdiqudND4YFvBVIrVZj0KBBOHjwIBQKBd58801MnjwZderUgVarxfHjx/Hee+/h0KFDGDFiBD7//HPMmDGj1PcfHh5e4nRq7du3L4dnQkRkmhrUVcHG2kx0ND11XoteXQp3vTl9Xi7Ca93MOKxt1cwSew5ocPq8FsP6F35jJa3P3a8kmZk5mPZmLBrUtcDsl+UiDsm5y1lo2kCVF+JKunawEtfnLxsXB1LZSAFZj+6W4lJQSIgeMTEGODuboVkzuUizbh2l6MKbnp6DxMSipzzJXW9jW/JU6IcPZ2LNWg3emGGHgHryS6/Ll+U3Te3aGgdyUifeM2d1uH5dj1atGNZV1tjo3M1KXAoKC9UjLtYAJ2dzNG5qPEWV1Jn3XuLjDIiPu/f2gk4cycTGdRq88Jo96tSTH+NqoDw2Wt7VxblVWxUunNUh6IYezVpybFSkuDsf8Nnc1WWnoNxtaSmFi/gbtbYRl4Iy0rNx64oWCiXyCn6Lc/6oGrv+TMH4V9zgV1f+vRUUKP9daNzauKi4SRsbXDunRdjNTDRoUbjgmMqPVV1veWa0HKmLSgbgXvgDV31qhri+e0rMjMB7v3fTJ6WLS2mkXwhB8r/n4fFE97yOvtpg+YsoUshfkE1jP9H5IzM8Djb1a5Tq/unBSdPldSymY6Kfo6O4RKQUDvTPRkWJS0G2FhZo7O4uCoOlYt6SSI89umlTfHXkCG4lyl0fGnu4i+szkcYdG05F3kYrH2/Uc3XFhWjjTh9ERFQyZr5ERFWPuS/dTR2SgNQr0eJ9u/fAxkXuIxXOmlspRZfetGsxcG5V+D1c6jX5PbZ9fY+SHzMsEaF/nITXgMZwaS133VSHJiBHlw3HJj5G+zo1rSEKeNOCYlnAW8Gs6hTIb1IzYOFWOL+R1kvMrUqfs5pbyvvqU9Ql7qu+GIyUvefg9niPvPwmM1h+/219d37TyB/aG7eRGREH6wDmNxXJuq5XgbGhKTbbK+3YyMk2IFst/15X2JT8d0MbkYDY9Yfh3Kc57FrUFuukYt4cfTZsGhmPDdtGfqKAVxMcwwLeaiC3UNbFXs7gQ2OTkK7NhJ2VJZztjD9fyuVsJ+9bsFvvvbQL8MUjHZuIotyQWDnba1hDzvbOBxvnhmeDbqN5LW/U9XLBpTD57xZVvOef7onHH22PtHQt3pi7BtdulJyrjhjaCq9M63eneHcjjp28dd+P26q5Pwb1b4ZffjuEsAh5NtF6deXXKXd38pU68TZp6IOa/m64et143BBR9cYC3gq0YMECEeRK7p5KTaVSoV+/fujVqxf69++PvXv3YubMmejTpw9atCj5W3sSX1/jF3FERGRMpTLD4L62WP93OlZtSC8U5IaG63DklBzIjhhkPOXRyEF2Ishdsykd8153ER0SchkMOVi7WS60GTnY+LiifLg4Eddv6fDvnzVgaZl/P9KSOsO4QDR36japqJAq3vdL5bBt/JM2YrxIlEozDBxghfV/anDwUCYGDyr8xnv/QTmQaVVCIaUU4r81OwUBAUpMfyl/rOT+eDPumqov9zZ//FVv+TL5//jocTawuDM2/tx27+D+u0Wp+P6rdIx63AbvfVr0t/cLysrMwXtzklGnnhJTXyg8NjQa498NGs2dscKxUeFcPeW3SBFBWVCnZcPWPv/DNolel4Ogy/LfDi/f0gW5W1YmIVObg57DHODsVvxbsKxMA755Jxp+9VQY87xbobGhvev3hjZ3rHBsVDgLZzvxoUpGYJiYRs9a+kCoACloV18OE8u5H7jU++rZe95fzKr9iFt9AM59W6LG9JKn0DTo9Ij8fqv44Mft0a75G+787A2Zxt+oz8n9hj3/qFS4lt8tuee2TwcMwOimTfDFocP47rjxVHnFGd+yJawtLLD5ylXEZ8gfHt2LSqHA+3374EZCAr4/fiJvfW5DSOl+CrJR3rldRMdIIiIqGTNfIqKqx9yX7ha57ZK4dm7pB2uforM5cwsF3DrURuz+G4jec7VQAa8mOhWpl+UvQLp3rVfs40kd+K8t2gOFnSUCpvXIW29250169l1d73Jv526niqN0toN1I39oAsOgvnBLLui9K7/JuBwqlktbMCtlMpqrcuaj8nEtcd+YpVuh8nWD66hu+Rvu/N833DU2DKUo7KPyy/akolh1YDjSzgfLBb2Fsj15bNjUNy7Cv5fUE9eRI2VyZoB1PeOxVtTvjdtLtkJhYwXvp+UuzILZXVkeis76qOo42Vqh/p1iWqlwV5JtyMHeC0EY1r4xOjTwx78Xggod17FBTXF9KbT4IlsLpQJzx/RBUHQCft5VINu7c22tMs72rC3l20z2Ks+zk3vgicc6yMW7c9bg6vWSi3eHD26J117sn1e8e/RE4TFSEgsLBWZM74+QsHisXHs0f0Nu7ntXI5H82xwdRKaGc6xWEOkF2C+//CKW69evbxTkFqRUKrFw4UKxbDAYsHz58ko9TyKih91bLzmJXGT5mlRs/zf/m9EZGQZMfT0W2dnAqCG2aBhgXIQ1aYw9fLwUuB6kw7xP5G+z5ZJuS+t9fZSY+Jh9sY8feC0Ln36XhCnjHNC9k3FnRKn7w5UbOhw+oclb9+PvKaXu8EClc+26DmlpxoG5Xp+Dxd+k47ffM1C7lgKvvmwcyL883Q5SrcvKPzKwa7cc9uda8n06TpzQQaEAJk8q3N2joEWL03ErOBuff+qYVyAsaXano+uGvzR5hZkJiQb8s00LK0vptQO/Y1UZgq7rkF7E2Fj2bRrWrcyAfy0Fni1QeF2efvg6DaHB2VjwsWNegbAkt9vvlo0aaLXy2EhKzMbu7VpYWgJ1Azg2KlrbHnawsjETBbeL346CRp0/RnRZOVj2QQxiI/WQ6t+6Dsr/GxAZmoXkBHmazYLvCXasS8Zvi+Jg76TA1LdL7t6y6tt4RIZk4ZUPvI3GRr0m8pcJ9m5OQaZWPqeURD2O7EiDytIMNevx70Zl8BjbXVzH/3kYGdcijLptRP2yC7roJDHdoXPf0hXo3I+4NQeRFZUIn5eGig8djToDS+Nh/8W8YF/qFpJy9CrMVEpY+eUXglP14u/oCBfrwp2zH2vaBK916YwkjQYf7JenQCvOSx07oJazM97euQs6Q/7vrMux8hRujzRsBEul/PfD2doKAwLqQavTi4JfKiDHhC9EVGmY+RIRVR/MfSmXQZ+N6N1XxbL34KbF7lvziXaiWC56+2UknAgxKrC9+vlO5Bhy4N69Hmz98zsqFyXqn0tIPh+BgBd6wMIhvwGETS0X8Z497tBN6FK1efcdvfuKWLYLKDkborJzGyMXVSdsOATNXflN7PKd0MXI+Y1j75ZivT5ZjaTtJ5GdUbhDti4hFVGL/4I+MQ0WHk6wbVG32MdOWHcAWVEJ8Jo2DGYF85s7hcSpB4zzm7Rjcn5j6ScXB1LFkma1ksStPwz1VeOxEfnLbmRFJ8vZXh8528uKS0HS3oswZBnnvpKUY9cQ8e1WsezUo6koEC5O4q5zUF8Kg/cz/aC808VVIv3spbEi3Z8+Tf67IY2R5H0XxbJ1HeNCYyp/dbxcMLhtQ6iUxs08JDXdnfD500NhaaHE+eBI3IzKz9N+2nkCOn02Hu3UDN2byB2Vc03q3Qat69aAPtuA1QfPFfv4zw7oAH93Z7y3arfYP9eVcLnwVzo3yzu/T6Ri4j7N60GbpcetaGZ7lWHKxG54ckxHpKWVvnh36MAWZS7elUx8ojN8fVzw2eLt0Ovzx8b1m/I59O3VBCqVnPs6OlijW+f6yMzUISSUYyNPVee2zH2plFgBUEFiYmKQmCi/8W/VqlWx+7Zp0yZv+epV+Q0mEREVduaCFi/Njsu7HRQihxzLfk/F1t35Ie2fv3jD+04Hxf+zdxfQUZxtG8evJBt39+DuTotLXagLLW2p9627u/erO7W3XuqlBWpQihd3dyKEuG42/p2ZJbIkAV5Klmz7/50zJ5vZmZ1nycPKvdfe07enj55/OEK3P5KlUy/eoxHH+CoywkPzFpVoz95K8/Rmbz3bsGjm5+euyZNidOIFaXr61Vz99FuxunX20rqNZVq7sUz+fm768p0Y+fq6H/CDvWvvzFBYiIeefbDht7LvuyXUHNMJ56dp7Ag/7c2o0OIVpWrfxlMXntE8ocF/o08/s+rTT63q0dNTsTEeKi2r1vLl5crMrDLDu19+EWb+vevr0N5ihm5vvT1fl1yWq169PJWY4KGNm8q1dWulGd595qlgdeni+M3G+jZtKjfDvhMu9tPAAY4fFLRpY9GZ43z0/RSbRo7JNAO9S5aWKSurSjfe4N9gPGgeX39h1defFatrDy9FxbirvExataJM2ZlVZnj33U/Dm+VvsXVzuT6YVKRzL/JT3wGOH9oktbbo5NN9Nf3HEp0xNkNduntqxdIy5WRV6crrA5gbThASbtGNj8fqxbvTNHd6oVb/tVUde/qY3bk3r7UpO71C7u7StQ/FKDap7v/2oj+K9P4ze82gbWScp9nYcssamzJSyxUS7qHHP0hUWFTTjxmGXZtL9c272TrpwhB16+/4BYG41l5mB98/fyrQtSduV7tuPlq/zKq87Eqdf124fJgbTmGc2i7qopHK+OxPbb/3I/l1iDM7u5RsS1d5Rp75gUviHWfJEnJkn8dtuzOU9f0ChZ3Qz+wUUp93bJiCh3dT/px12nLj22ZR37oxRZX5xYo4Z8j/dDpIONeYdm11z/DhZtA2raDQDB/0iI5WQnCwsoqLNfG775VZfOBTc3YID9fVAwboi1WrtSzN3imqxq68PLOD7+ldOuvXSy8xj9MvLk4R/v56c9EilVQ0/PAJAHBg1HwBoHlQ98Xfkb1wh8pzrbIEeCty2IE75wZ2jFb7a0do61uztere7xXSK0FeIX7KW5Oqsuxi+SWGqtOtYw94G2U5xdr6zlyFDWytmDGdHa6z+Hop8dy+2vX5Ei26/CMFd49T4ZYM2fYUKHp0J/nFH/zMXfj7/Hu2VcSFo5T1xSzteuC/8m0fL4/QAJVu31Nbv4m79eza+k1VWbn2vjNdGR/8Ku82MfKMNP5O1SrPKjD3MTqzWsICFX/3+XLfF5RqTOnuDGX/MF8hx/czz+JUn1dsmIKGdVfB3LXaccub8mkTK+vGZLN+E37WUOo3ThLYq42iLxqhvZ/N1rZ7P65X2zPmRr45N5LuOLM2jFtZWKLkl6Yo9e2f5dsmWpbwQFWXVciWnKWyNPv7Av8erRR/3ckHPG55bpHSP5ypwL7tFDrC8YsGHr5eihg3SJnfLNDmGybJv0uCWWss25unkOHd5B134C8U4O8LC/DT05ecpAfPH6ONKZnam1coTw8PxYQGqktilDzc3c3uuHd9ON1hv50ZuXp08gw9Ov44vXbNGVq7K11pOQVqHxuutjHhZhj3ya9mOoR+99cuJlwTx/TXNwtWa+UOx9pecla+pi/daAZ4v7v3Um1IyVDvNnEKD/I3w8MljQTLcWQdO6i9GaI1pO7J1Rmn9m10u/yCEr313izzcvu2Ubr9xhPMszzsScnXiKGdzKUxz7zoOKfqa50UoQvPGaSffl6ptetTHa5L3ZOnGbPWa+yorvro7Su0edte9egar7BQf306eaFsdPAGXA4B3mZidFmoUXGQD8XKy8sb3Q8A4KigqEqLljf8BnRKWoW51DACmvXdck2Iunfx0otv52nJSpt5urKkeIvuuTFI99wUqsCAxouxQwb6asXMRD3xUq5mzrXqu2lFigz30IRzA/XgbWFq1/rAQax3PinQ/CU2TX4nRiHBDb+1eeJof/3wUayeeDFHv84qlp+vu84/I8AsPBPSO3LGjPZRckql1qwp1+rV5WYn3HZtLbr2an9NvMxfvr6Nn7bsvHP91LGDRa+/WaxFi8u0fn25QkPdddqpPrruGn/16eN1wCL+nXfnKzzMXfff23i3jpdfClF8fKHZhfe3322Ki/PQg/cH6rpr/Y/YfceBDRvlrbSUSq1fW651a8rMudG6rUWXXhmg8Zf5y8fnyJ/Szpgbj9yTp7Awd916d1Cj2zz5Qohi4z009QerZs2wKSbWQ7fdG6SJ1zA3nGX0GcFq3clbP/w3R2uWWLVygdX8omtYpEWjxgVp3KVh6tTLsbtO136+GnJCkDavLtHOzaVmEC8m0UsX3hChs64IU0BQw+eB/efGq/fvUXCYRZff1Xg3ltueizPDwbOm5GvRzEJFxHrqirvDdfZVFHGdKeq8YfLtEKfsnxarZHOqSrammR/4hIzupcizj5V3wpHteGvMjbQ3pskjyF/Rl4xudJv4m8bJMyJYebPXqnDJZlkighV96RhFnHnMER0LjqxlqWn6ZcsW9YqJUceICPNvnZyfr1cX/qX3ly1TYWnD1737e/K4scqxlui5fady39+dv/yitMICnd6li8a0a6c9hYV6evYcvbt0aTPcIwD456PmCwDNg7ov/o60n9eaP6PHdJbHAcKVNZLO7auAtuHa/fVyFWxMV1VJubyjA9Vq/AC1Gj9QFr8DByk3vzFb1eVV6nRL4+/R214xRJYAH6VNXa2s+dvlFeqnpAv6q+1EewAIzhFx7nD5dohXztS/zPpN1bZUs34TPKq3ws4c4lC/sQT7K+qy42Vdv8sM4ZalZJodVz38feTTMUEB/TuaoVwPv6Y7aBvv6dPfmipLkL8iL248BB57wxlmzcbowlu4dJM8w4MVdslYhY1jbjhT9PnD5NcxTlk/LpZ1c1ptbS90TE+ztudTb254RgSZ60q2pKl0T45KtqebgW6PID8FDuhgBmxDhnWTm/uBP0tIe+83c7/4605q9PqYCaPkEeCrnF+WK3/RZnmG+JvHjR5v7yaN5mWEc1/9aZ7ZMbdNdJg6J0TK4uGu/OJSLd6crJmrtuqHRevMbrv7+2nxerMT7sSxA9S3bZw6xUcqr9imX1ds1sczl2rtbnsX3aY8eMFY5RaV6JUf5zV+/We/Kj230AzxjuzeVul5hXrxhzn66I9lR+z+o2lBgXVd9jt3jDWXxuzZm18b4A3w9zbDu4ZWSeHm0pQDBXjvuOkE5eVbNemDPxu9/ukXp2lvZoGOG9VVQwa1V0ZWgTmGyd8uPuT7B6DlcKs2Xk3iiDNOjRYaGqqCggLFxcVp165dTRZqp06dqtNOO828fOONN+rVV189ImNISUlRYqK9O1NycrISEhKOyO0C+OerSu9wtIeAFiqj8sBd4PDvlV155MOu+GdIrgg+2kNAC3Xn2nOO9hDQQhVvoSMRHFXk5Sn5icePeH2jft2k01UPyTPQ9eZeeWGeNr37mHmZ2g/Q/Kj5AnBl1HzRlOM22J+vgP2l5TXegADwsjQMMgKm32k2gcaFbCk72kNAC1Rqy9eiP58+ojWOf0LN10Dd99+Fr3k2E3d3d51yyinm5bS0ND355JONbpebm6u777679vdTTz3VaWMEAAAAAACAeXZU110AOA01XwAAAAAAABdxtOu21H1xiDh3VzN66KGHNGXKFFmtVj3yyCNatmyZLr30UrVt21Y2m01//fWXXn75Ze3evdvcfsyYMTr++OOP9rABAAAAAAAAAI2g5gsAAAAAAADgSCHA24w6d+5sFnMvvPBCZWVl6aeffjKXxowePVpff/2108cIAAAAAAAAADg01HwBAAAAAAAAHCkEeJvZ2LFjtXHjRr3//vv6+eeftW7dOuXl5clisSgmJkYDBgzQ+PHjdfrpp8vNze1oDxcAAAAAAAAAcADUfAEAAAAAAAAcCQR4nSA8PFx33XWXuQAAAAAAAKBlMeJ1rhixc8UxA/8U1HwBAAAAAABaLlet+cqFx43D436Y+wEAAAAAAAAAAAAAAAAAAAA4DAR4AQAAAAAAAAAAAAAAAAAAACciwAsAAAAAAAAAAAAAAAAAAAA4kcWZBwMAAAAAAABanOp9i6txxTEDAAAAAAAAQHNz1ZqvXHjcOCx04AUAAAAAAAAAAAAAAAAAAACciAAvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnsjjzYAAAAAAAAECLUy25Vcv1uOKYAQAAAAAAAKC5uWrN1+Cq48ZhoQMvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnIsALAAAAAAAAAAAAAAAAAAAAOJHFmQcDAAAAAAAAWpzqfYurccUxAwAAAAAAAEBzc9War1x43DgsdOAFAAAAAAAAAAAAAAAAAAAAnIgALwAAAAAAAAAAAAAAAAAAAOBEBHgBAAAAAAAAAAAAAAAAAAAAJ7I482AAAAAAAABAi1R9tAcAAAAAAAAAADhiqPnCBdCBFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJzI4syDAQAAAAAAAC2NW7V9cTWuOGYAAAAAAAAAaG6uWvM1uOq4cXjowAsAAAAAAAAAAAAAAAAAAAA4EQFeAAAAAAAAAAAAAAAAAAAAwIkszjwYAAAAAAAA0OIYpyRzxdOSueKYAQAAAAAAAKC5uWrNVy48bhwWOvACAAAAAAAAAAAAAAAAAAAATkSAFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAE1mceTAAAAAAAACgpXGrti+uxhXHDAAAAAAAAADNzVVrvgZXHTcODx14AQAAAAAAAAAAAAAAAAAAACciwAsAAAAAAAAAAAAAAAAAAAA4EQFeAAAAAAAAAAAAAAAAAAAAwIkszjwYAAAAAAAA0OJU71tcjSuOGQAAAAAAAACam6vWfOXC48ZhoQMvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnIsALAAAAAAAAAAAAAAAAAAAAOJHFmQcDAAAAAAAAWhq3avvialxxzAAAAAAAAADQ3Fy15mtw1XHj8NCBFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJzI4syDAQAAAAAAAC1O9b7F1bjimAEAAAAAAACgublqzVcuPG4cFjrwAgAAAAAAAAAAAAAAAAAAAE5EgBcAAAAAAAAAAAAAAAAAAABwIgK8AAAAAAAAAAAAAAAAAAAAgBNZnHkwAAAAAAAAoMWp3re4GlccMwAAAAAAAAA0N1et+cqFx43DQgdeAAAAAAAAAAAAAAAAAAAAwIkI8AIAAAAAAAAAAAAAAAAAAABORIAXAAAAAAAAAAAAAAAAAAAAcCKLMw8GAAAAAAAAtDRu1fbF1bjimAEAAAAAAACgublqzdfgquPG4SHAC/yLVaV3ONpDQAuVUVl8tIeAFiqv6miPAC1VWmXg0R4CWqi0itCjPQS0UMVW76M9BLRQFqvb0R4CWpjqEuYEAACHipovmtJj0fijPQS0UD6eFUd7CGih3N1JjqBxJaWeR3sIaKF8j/YA0GJZrJVHewhogSpKmReAwZ1/BgAAAAAAAAAAAAAAAAAAAMB5CPACAAAAAAAAAAAAAAAAAAAATmRx5sEAAAAAAACAFomzwwIAAAAAAADAPwc1X7gAOvACAAAAAAAAAAAAAAAAAAAATkSAFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAE1mceTAAAAAAAACgpXGrrjYXV+OKYwYAAAAAAACA5uaqNV+Dq44bh4cOvAAAAAAAAAAAAAAAAAAAAIATEeAFAAAAAAAAAAAAAAAAAAAAnMjizIMBAAAAAAAALY5xRjJXPCuZK44ZAAAAAAAAAJqbq9Z85cLjxmGhAy8AAAAAAAAAAAAAAAAAAADgRAR4AQAAAAAAAAAAAAAAAAAAACciwAsAAAAAAAAAAAAAAAAAAAA4kcWZBwMAAAAAAABaGrdq++JqXHHMAAAAAAAAANDcXLXma3DVcePw0IEXAAAAAAAAAAAAAAAAAAAAcCICvAAAAAAAAAAAAAAAAAAAAIATEeAFAAAAAAAAAAAAAAAAAAAAnMjizIMBAAAAAAAALU71vsXVuOKYAQAAAAAAAKC5uWrNVy48bhwWOvACAAAAAAAAAAAAAAAAAAAATkSAFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAE1mceTAAAAAAAACgpXGrti+uxhXHDAAAAAAAAADNzVVrvgZXHTcODx14AQAAAAAAAAAAAAAAAAAAACciwAsAAAAAAAAAAAAAAAAAAAA4EQFeAAAAAAAAAAAAAAAAAAAAwIkszjwYAAAAAAAA0OJU71tcjSuOGQAAAAAAAACam6vWfOXC48ZhoQMvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnIsALAAAAAAAAAAAAAAAAAAAAOJHFmQcDAAAAAAAAWhq3avvialxxzAAAAAAAAADQ3Fy15mtw1XHj8NCBFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJzI4syDAQAAAAAAAC1O9b7F1bjimAEAAAAAAACgublqzVcuPG4cFjrwAgAAAAAAAAAAAAAAAAAAAE5EgBcAAAAAAAAAAAAAAAAAAABwIgK8AAAAAAAAAAAAAAAAAAAAgBNZnHkwAAAAAAAAoCVyqz7aIwAAAAAAAAAAHCnUfOEK6MALAAAAAAAAAAAAAAAAAAAAOBEBXgAAAAAAAAAAAAAAAAAAAMCJLM48GAAAAAAAANDiVFfbF1fjimMGAAAAAAAAgObmqjVfg6uOG4eFDrwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJyIAC8AAAAAAAAAAAAAAAAAAADgRBZnHgwAAAAAAABoadyq7YurccUxAwAAAAAAAEBzc9War8FVx43DQwdeAAAAAAAAAAAAAAAAAAAAwIkI8AIAAAAAAAAAAAAAAAAAAABOZHHmwWB3991367nnnqv9fdasWRo5cuRRHRPQkmzaWqbfZ1u1bHWplq8u1YYtZaqslB67K0z33xp2wH1nzLHqpUl5WrLCpuKSarWKt+isUwJ0z02hCvBv+jsLW3eU6cmXczVzrlWZ2ZWKDPfQmGF+evC2MLVt5dnoPp9/V6inX8nV1p1lio6waOKFgXrg1jB5eLg12LbYWqUeI3abY1j6W6K8vBpug78vNa1Sb7xRpD/+LNWePZXy93dTz56euvJyf40d49PkflVV1frm2xJzWbe+QkVFVQoJcVeH9hadeoqPLrvU32F7q7VKjz9ZqKnTbCosrFLXLp66795ADR3i3ejt/z7Dpksuy9U9dwfq5hsDjvj9xsHtSavUe28Vae6sUqWn2+dGtx6euniiv0YeYG7U9/nHxXr8gQLz8tkX+OqJ50IabGPMjeefKtRv0+1zo3MXT916d6AGNzE3Zs2w6T+X5+qWuwJ1zQ3MjaMhI61cX03K0ZLZxcpKr5Cvv7s6dPfWGZeGatDopv8my+cV69v3c7VptU02a5Wi4j017MQAXXBduHkb+6usqNYnr2brt2/zlZ9dqfjWnrr4pggNPzmw0dvftt6mG87YpePPCdatT8Uc0fuMQ5OdVqpf3kvVuvl5ytlTpurqaoVEeqnjgCAdPzFOiZ0dnxumvLZbP76ecsDbfGJ6b8W282swN358PVnzv89QYXa5otv46rT/JGjASRGN3sbuDcV64pzVGnJWlC59vN0RuKc4HNUVFSqYsUTFf61ReUqmqsvK5R7oJ6/EaAWM6KuAY3o02KdkzVblT1+g0q0pqi4tkyUyRH4Duylk3HC5+zR8nqiurFTet7NUOHu5KguK5RkbodCzRsl/cPdGx1S6c4/SHnhLgSP6KuKqM5rlfuN/c+eYYbrq2P7m5Zdmzddb8xYfdJ/x/XrqkZPHmJe/XrFG90+d0WAbX0+L7hozTCd06aBAH29t3JupF/6Yr792Jjd6myM7tNE7F5yhF/+Yp7fnL/nb9wsA0DTqvsCBUffF31FdXqmcX5eqYP56lSZnqrq0XB5BfvJuFaWQ0b0VPLRb7baFy7aocOFG2XakqyKnUJWFJXKzeMgzJlQB/dorfNwxsgQ5vj83VNnKtPejGSpYsEFVVpu8W0cresIY+fds0+iYCpdsVvKTkxV50ShFnjusWe8/mlZVXqmsn5crd+4G2XZnqaq03Pz7+raOVNjYngob3rXBPtVV1cr5Y41y/lirkh17VWktk0egj3wSIxQ6pLMiT+3nsH2lrUypH/yhvPkbVVlcKt820Yq/bKQCe7VudEz5i7do26NfK+6SEYo5f0iz3XccGI8baEp1eYXyf1+qwgXrVLavtudh1PaSohQ0so8Ch9jrb9VVVbJtSZF1xVZZ1+5QWWqmqkpK5e7nI+/WMQoa1UeBQ3vIzc2t0bmR9elvKvprvaqspfJqFa2I8WPl16Nto2MqWrZJe575XOEXjlHYWcOb/d8Ajk7u31nHdm6ljvGRigzyV6Cft2xlFdqVkauZq7fqi9krVVJW3ui+xp//1AFddeqALuoYH6EAHy/lF5dqx95s/b5yi76at9phe18vi24ZN0zH9eqgAF9vbU7N1Ks/zdfiLY3X9oZ3a6PXrjlDr/40T+//Tm3P2RISw9R/QFt17BijDp1i1CopQh4Wd33w3mx99sn8JvcLDPTReRcM1pBhHRUTE6yysgrt2J6paVNXasZvaxvdx8fHU1dfO1rDR3SWv7+3tm3bq/fe+VMrV+xqdPvBx7TXk8+cp/ff/VOff7rgiN1nAM5HgNfJVq5cqRdffPFoDwNo0d7+KF+vvpf/P+/38qQ83f5IlvkiedggH0VFWjRvUYmefjVX300r0pwpCYoI92iw3/zFJTrxgjRZS6rVrZOXhgz01bqNZfr4q0J9O7VIv30Vr8H9HAN+U38v1oTr9yo0xF0nj/HXqnWleuyFXGXnVunVJyMbHOPBZ7K1O7VCc6bEU8RtJitXlmn8xTnKzatWdLS7Ro3yVm5ulRYsKNPs2WW67ZYA3XlHw6BcQUGVLp2Yq78WlSkw0E39+3kpONhNe9KrtHZduQqLqhsEeG+6JV/TptvUuZNF/fp6avacUl14UY5++DZc/fp5OWxbXFyle+7LV5fOFv3nWsfbgXOsWVWmqybkKD+vWpFR7ho+0lt5uVVavLBM8+eU6T83B+jG2xsPUdZI3lWhF54qNB9fqqub3u7eW/P12882dehkUa8+nlowt9Q89iffhKt334Zz4/EH8tWxs0WXX8PcOBo2rSrRfRNTVJhXpbAoD/Uf4a/C3Eqt+suqZXOtuvjGcF1ya8MQ5bfv52jSk5nmfOg+wFehERatXWLVF2/maO4vRXrpq0QFhzm+zH7/uUx9816uYpM8NXCkv3mMJ25I0wOvxzUI8VZWVuule/cqONRDV93T8DkFzW/7qkK9MHG9bMWVCo32UrchwXL3cDPDswt+yNSiqVm66vkOjYZsEzv7KbFL4/+nfQMbvv365oVd+u2DNEUmeqvnyFBtXJSvt2/ZbM6v/ic63n5VZbU+emCrAkItOvfOVkfwHuN/UZGdr/SnP1J5aoYZ2vXulCR3by9zvW3jTrl5ezUI8OZPn6+cT342q7k+nVrJIzhAtk07lf/DbFkXr1Psw1fJI8hx3uR88ZsKps2XJSpUfn06ybZ+uzJemawotwvkP8gxxGt8mJD17g/mBw2h409wyr8DDqxPQqwuH9xXVdXVcm/kQ5zGJIYE686xww66z7PjTtSJXTpoU0aWVqama0jbJL0//kyN/+grrUpNd9jWz9NTj5w02gz5vrdw2d++X/9oxmu8A7zOa7FccczAPxR1X+DgqPvicJVnFWj3o5+ZATwjfOfXOVHuPl4qz8qXdd1u8z1Z/SBewZy1yp+9Rl6xYfJOijTfb1UWWlWyJU3Z385X3oyVavX4BPkkRTkcJ/WVKSpcuEHeSVHy7BSv4pXbtevRz9T6qcvk1ynBYduqkjLtmTTdDAJGnHms0/4t4Kgsq0BbH5xsBnctQb7y75ogDx9PlWUWqmhtstx9PBsEeCuLbdr22Nf26/28FdAlXh7+PirPLlTJtr1m0G7/AO+uF39S3vxN8mkVKf9O8SpYuUNbHpysTs9NkH/neMfbLynT7jd/lU/rSEWfPdgp/w5oiMcNNKU8O19pT3xiBneNWppv50SznmfU9ko27DLnRk2At3xvrlIeeN+87B7gK592cXL39zXXl6zZbi5F89co9vbz5ebpWPvd+/r3Klq0Xl6JUfLpkCDr6u1KffITJTx2uXw7Jjpsa4SCM9+dJq+kaIWeTuj/aDhvSE/1ahOnHXtztCElQ/nFNoUH+qlnm1h1bxWjMwZ10xWvfq3MgmKH/Yyw7itXj1P/9gkqLCnVqh1p5s+o4AB1ToiSv493gwDv4xefqON6d9CWtCyt3pWuwZ2S9OZ/ztTEV77Smp2OtT1fL0/dd+5oM+T70Uxqe0fD6eP66uxzB/5P+8TGhuj5l8YrJjZE+XlWrVi2U17enurSNU733n+6+vZtreeemdpgv7vvPU3DR3bW9u0ZWr8+Vf36t9Gzz1+gW278RBvWpzls6+PrqZtuPUHbt2Xoyy/++tv38x/LVWu+cuFx47AQ4HWiqqoqXX311aqoqFBUVJQyMjKO9pCAFqlbZy/dfl2Ienf3Vt8e3mYh9tNvCg+4z4o1pbrj0Sx5eEhTPorVSWP8a7thnnHZHs2cW6Lr7s7Q1+/FOuxnXH/BNelmEfeeG0P15H3htdfd/1S2nnktVxdcna4N85Lk61vXyeHh57Ll5SUtmJqgju28zE4LA09INovQ990cqpiouofXpSttev2DfF17abCOHeB7BP+lUMNmq9YVV+ea4d1xp/vopRdC5OvrVhfsnZCjF18u0sCBXhoxvK7DndFNceIV9vDuhIv99PCDgfKv17GjrKxa6zc4fpvSCPUa4d1hQ730xWf2zhtz55XqvAty9PKrRfrkI8duIU8/W6j09Cq981aoPD0p4jtbqa1aN1+Ta4Z3TzrNR0+9ECIfH7faYO/Vl+TozVeK1HeAl4bUmxv7d2i+9/Z8yU0ad7avfvimpNHtNqwrN8O7g4d46b1P7XNj4bxSXT4+R2+/WqS3P3ScG688V6i96VV68U3mxtFQVlqlx/6TZoZ3R5waqDuei5G3j3ttsPf+y1P16WvZ6tbfV/2G1YXqtq6z6Z2nMuXuIT32brwGjrR36bWVVOnhq1K1YoFVrzywVw+9WVe4z82q0JSP89Sqg5de+6GVfHzdtXtbqa49eac+eTWrQYD3hw9ztXmNzQz3BgQ1/AASze+jB7eZ4d0R50dr/INtZPF0r308mPJqsqa+laKPH9qm3qPD5Ont2Ompz9gwjbsx6ZCOU5Bdpj8+2aO49r564Jue8vb10J5tVj08bpWmvJ7cIMA745M92rm2WNe+3FF+QbyVOxqqysqV/tSHKk/LVMjZoxVyxgizG0vt9aVlKt+T7bBP6Y405Xz6i+Turug7L5Zf74612+59/lPZ1m5X1vs/KvrWC2v3qcwvUsGvf8kzPkpxT15rfnBgdPhIvft15X7zR4MAb8EvC1W2PVVRN18gD39ebx5tPhaLnjn9BGUWFWtN2l4d17n9QfcxXgk8c/rx5heFfli9Xmf1qvsQsb4u0ZFmeHfB9t26/PPvzLDvMa0T9dGEc/SfoYN0zZdTHLa/ddQQRQcG6OZvp6miquqI3UcAgCPqvsChoe6Lw2F0U931yKcqS8lS5AUjFHHO0P3eh5WrLNXxfZjRKTP6suNkCQ1oEJ5Le+1HFSxYrz1v/KQ2z15Re51te7oZwjO6ZiY9fJHcPNxVtGq7dj/8qbK+nqukB+resxkyPvvD7NKZcOc5DuOB8xh/+y33f6HSlGzFXjRMMecd6zg3bOWypeY47GN8JrDt8W/M8G7ESX0Uf8UYefh6OXTzLdnp+Dxu3bbXDO8a3XbbP36BOTeMAO/W+7/Qnsnz1f6R8xy2T/v4TzMM3PaeM5kbRwmPG2iK8bdPffxjladmKey8kQo7c3jD2l5avbnh5ibf7m3MUK1fz3bm37iGdd1OpT39mYqXbVbOD/MUfm7dmTdKd+wxw7u+Pdoq/v4J5n7WNduV+thHyvl2juLvvchhXNlfzFRFToESbjuXuXGUvPDDHO3KzFWBtdRhfbCfj16+6nT1bRev288crns++tnheuM6I7z79bzV5m3U79Jr8XBXxzjHL4B1io80w7t/bdqt69601/YGdkzUuzeco6uPH6Qb33Gs7d146hBFhQTozg+p7R0tO3dkmgHZrVvTtWXzXo2/+Fgdf0LDM/DVd/9D48zwrtE59+EHvlVRkc1cHxcfqmeeO18nnNRTa9emaPrUlbX7tGsfZYZ3ly3doXvunGx+HtWnb2szCHzxhCG6/96vHY5xxZUjFRERqMcf+V6VlcwNwNU1fV4hHHGvvvqqlixZos6dO+uKK+pe3ANwdOVFwXruoQiNPytQnTt4GVmHgzIKrsaH3ZedH1RbxDX4+bnr3ReizNv4blqxNm4pc9jvo68KlZZeqY7tPPX4PY7hOuN3Y31yWoU+/rrQIdS5ZkOZhg/2NYu4Bn8/d110dqB5yrfFK0oduihee2emYqI89FS9IjGOrJ9/sSktrcrsnPvs08G14V1D795euu0WezjuxZcdPxCY/GWJFiws08gR3nrumWCH8K7B6JrRu5dj19TVq+1vvC4436/2tHnDhnqrTWsPLV3qOL+M8PB/P7Tqskv8GnTmhXPM+NWmPWlVCgpy0yNPBdeGdw09ennpPzfb58ZbrzT9YdHHHxRr2eIy3X5voOITmi6crFtjnxtn15sbxwz1VlJrD61c5jg3jPDwZx9ZdeElfg0688I55v9apMw9FQoIctfNT0TXhncNnXr56qIb7Y/Zn73mWMid/FaO+XxzwjnBteFdgxHKve3ZGPP5Zt4vRWZAt8bOTaUqL6vW6NODzO0MSe281WOgn3ZtLlNxYWXtthmp5fropSwNGu3fINgL5yjKLVfKJqt5+cxbkmrDuwZ3dzeNuzFRXj7ushZUKm2bfbvDlbLZqoryag0+LdIM7xpi2/mp04AgpW0pUUlRRe222Wml+uGV3eo1KrTRzr9wjvwps83wbuCY/go9Z3SDgroRtPVu7RgcyJ8yx2zfHjCiT214t2bbiKvPND8IMLrwGgHdGmXJe6WKSgUM7WluZ/CKj5RPl9YqT8kwT8lYoyIrT7lfzZRv307yH+wY7MXRcfvooWoTHqoHp81QYalj0b8plw7qowGtEvT8zLlKzStocrtusfZOP9+sWmsW+A0LdyZrZ3au+iTGOWzbIzZaFw/opc+XrmrQmRcAcGRR9wUODXVfHI6sb+eZIbyQ4/uaQbyG78M85dM2xmGd8fv+ITxzW18vRU88zrxcsilVlfVCOiXb9pg/Q8b0rg1oBfRqa3bjtG50PKV1yZZU5UxfotAT+zfosAnnSf9qgRnejTixt2LHD2s4N3w85dcu2mFd9u+rVbRmt4L6tlXSDSc5hHfNfTw95N9hvy8EbLXPjfDje9XOjaDebeQdF6riDSkO2xZvTlPm1GWKPLlvg868cB4eN9CU3O/nmuHdoLH9FH7uqMZre23qHgO8YsKU8PBl8u/TwSG8a/Dr1lphZw41LxfOXuVwnW27vVNm0Kg+tfv59Wgrz5gw2TY5zg3b1lTl/bJYwScMaNCZF86zZld6g/CuId9q06s/zTcvH9PZ8ax4ZwzupgEdEjV/w0498dVMh/CuoaKySuuNOm89XRPttb0f/qqr7S3enKxdGblmB+D6uiVF64LhvfTV3FUNOvPCeaZPW6V33v5Df8xYr+Td2aquOnBb1K7d4tWla7wqK6r0/HPTasO7hrTUXL31xkzz8sWXOHbb7tjR/tjzy8+rzPCuYcXynUpJyVHX7o7PG506x2rcmf3045TlDTrzAnBNBHidZPfu3XrwwQfNy2+//ba8jK9wAzgijMLq9Bn201VceFbDN9etEj01ZID9VGg//FzkcN33+34/f1yAGcqpz/j9vNPtt/f99Lr98goqzYJtWKjjm7qa34uK677h9PI7eVqxttQ8vVpQIA+5zWXlKvsbop49PBUc3PDfedgw+2PukiXlysioC8q9/4F93vznusZPdd6Y3Fz73zckxHG+hIa6q9ha94K9oqJad96dr5hod917DyG8o2XNvrnRtYenghqZG8cMtc+N5UvLlVlvbtTYsa3C7JQ7YLCXLpzgd8Bj5e2bG8H7zY2QUHdZ95sbD9+Tr6hod916F3PjaNm02v6GuUN3n0a73PYdYv97r1tWopxMe4jSCOEummV/Phh1elCDfaLjPdW1n29tQLhGQZ59bgWGOB4naN/zhq3e/Hjt4b3mKUFvfMzxwwU4j8Xr0J+vA0M9/9axinPtc8s/2LGbrn+I/XdbvdcUnz223fx58cNt/9YxcfiqKypV8Pti83LwqcMOcZ8KWVduMi8HDOnV4HrPyFB5d7J3bLYuWV+73jhFo8Hd3/G5xzitn6HKVhdOyPrvT2b71ojLTzuMe4UjbWCrBE0Y2Fvfr1qv2Vt3HtI+RtjX6JS7aGeyPl/meEq9/YX42p9n8kvqCr+GvBKb/LzqHpM83Nz0+KljlVFYrBdn2T9kAAA0D+q+QPOh7gvjfVjuL/bTRR+x083XBLDc3RzCWDXvwzwCHbspG7/Xfw9WXVmlPW9OkyU0UFETRh+ZMeGw5kbW9OXm5aizBx/yfpk/Ltm3z6BD3qei0H5GNo8A++PNgebG7td+lmdYgOIurevECeficQMHmhv5v9kfA4yOukdCzRf5K7LzHdZXFtU8buw/N/z2mxuVypj0oyxhgYoYP/aIjAlHXuW+zrdlFY6fI144vLf588OZSw/5toL3nT3NCAbXZ/zu512vtufupocuGKvM/GK9OpXanisxwrWG9PQ87UnLa3D98mU7zJ/R0cHq3KUutB0UbJ8bhQWOc6Mgv0S+9b5w5O7hplvvOEnZ2UV6/50/m+1+AHAuzrvqJNdff72Kiop06aWXasSIEZo1a9bRHhLwj7F5e5l5KjRD/16OBZQa/Xp5a+4im1as3a9D6hr7N+n6Nbmfff3KevtFRVjk5+vWoKtDze/xMfaH1p3J5Xrk/3J0xkn+OuOkhgVmHDnF+4rnRoi2MeFh9vXGFxnXrCnXmDEeysys1Lr1Febp9/r389KuXRX68SebklMq5e/vpr59PHXC8T5mF976EhPtBfstWys0epR9XXl5tXbsrFBMTF1xf9I7xVq7rkIffhCqgACK+EeLdd/cMEK0jQmtNzfWry3XiNEeDp1U7rktT25ubnriuWDz54HUdOfdtrVCw0bWzY3dOysUVW9ufPhusTasq9Ab74XKn7lx1JRYqxxCtPurWW/Mja1rbRo4KkApO8pUuu/5pmOPxp83jPVrl5Ro2/q6b2pHJ9iLLvW78hqSt5bJ08ut9lizpxVo0R/Fuu6hKEXF/b1gKA6fj7+HOvQP0palBfr+5d0a/2Cb2i68xreep7yWrDJblXoMD1FYrHeD/XetK9Y3z+9ScX6FfAM8lNTVX71GhZmX9xeeYN8/bZu9oFtjz7YSWTzdFBhqf02xZHqWVs3K1YX3t2n0mHCO0p1pqiq0yiM0UJ4x4Srbna7ixetVmVcgd39f+XRqLd/eHeRWr41Y+Z5sVZfav0zi3bbxzjvG+tKNu1S20961pSbYa+6fVteV1/zd6NJr8ZBHkD3IW7RwjUqWb1LYpafIEh7SLPcbh87P01NPn3a8soqsevK3Qyueuru56dnTTzCfb+6b+vtBt0/Nt3fnbRcRprnbdpmXLe7uahUWor0FdeGTiYP7qWtMlK79coqK9+v+gca5VdkXV+OKYwb+aaj7As2Hui9Ktu9RZYHVDDYZHS1tO/eq8K+NKs8pNMOUfl2TFNDXeB924LpdjaryCmV8+od52b9XW7MLZw3PKPt7qtKULAX0bV8b9irbkyPPsLovcmdPWSjbjnQl3ne+PHx5j360WLemq6KgRJ7hAfKJC1PJzgzlLdik8mxjbvgqoFuigvq3c5gb5blFKtmRYYYwA7okqHRPrnLnblBZRr7cfbzk3ylOwYM7ml146/OODjZ/2pKzFdy/Xe3cMPb3DK9r0LD3+0Uq2b5XbR88Rx5+zI2jhccNNKV0xx4zdG3U9rxiw1W6a6+KFq9XhTE3/H3l26WV/Pq0d6jtHUxZuv0MfsZt1ucZaZ8bxhm3jO69tXMjPcecmzVypy5U6c50xd51odyZGy2SEaq97iT7F0Vmr7E32TCEBfqpc0KU2WV31Y40xYcH64Q+HRUXFiRraZnZ0XfWmm3m9fWl5dhre22jw7RgQ11tLzEiRBn5dbW9CaP6mbd/0ztTZN1XX4ZrqAnbFhQ4fu5To7S0QjZbuXx8PNWxU4w2brB30E1Pt38RIKlVuJYsts81Dw93xceHKiur7qwh5543SB06xOiBe79WSYnj+xb8c2q+BlcdNw4PAV4n+OqrrzR16lSFhYXp+eefP9rDAf5xduy2d68LCXZXYBNhuMR9Qaidu+te4BYWVSl7X8fMpPjGHw4T4+zrM7MrVWytMk+ZZjjtBH99+UORXno7V1dcFKy/ltn04ZcFiorw0OB+9uLvf+7OlMXipteeijyi9xcNRUTYC2q7djfsoGqu31W3fney/fL6DRW1od/Pv7Dq0ccLVL7f+59WrTz0wbuh6tq1riAzZIi3AgLcNGlSsQYN8FKbNha99EqRcnOrddaZ9jfXu3dX6IWXinTqKT5mCBhHT9i+uZHSxNxIrrc+Zd/cqPHB28VavaJc9zwUpKTWB3/JNHiIt/wD3PThO8XqN8BLrVpb9NarRcrLrdZpZ9jnRsruCr35cpFOONlHo5kbR1VIuH1u7Kn3vFBfenJ5g8vpKfafAUHu8mvi+SYy1tJg/3ZdfBQdb9Fv3xSYQeAuvX3085f52r6xVMeMDTBDvEUFlXrrsQx16uWjcZcQwjvaLnu8nV6+er1mf7lXq//MVavuAXL3kHavL1be3jIdMy5SFz3UptF9jaCtsdTnG+ih8Q+00bFn2E+PVSOps7/C4701/7sM9RwZqna9AzTn6wylbLKq9+hQsxuwtaBCXzy1Q216Bmj0xY6n9oNzle2yn6bMEhasnC9+Vf5P8+wp/33yNVderWMVfftFskTY/x9XZNjngru/T5NFeEu4/YPA8sy6eePVOsa8jcLZy+Xbp6N82ieqcNYyMzTs16+z3CwWVRaXKOfjafJul6Cg4w+9cxCaz93HDVdiaLD+89WPKrA1POVeY648pr96J8TqyV//VHKuY7eWxvy1Y7eKSkt1+eB+WrY7TTtz8nT9sEEK9fPVj2s2mtskhATphuGD9fP6zfpjc90HCwCAI4+6L9C8qPuidGeG+dMSHqi9H89Q9vcLpHpnLc7+boF52vvEe8+XZ6T9vVV9xuntc6YaZ1KpVmW+VSVb08xgn0+HOMXd4HgWE/+ebeTu62UG7fy6JJrhrsyv5qiysETBI3qY25TtzVXml3MUeGwXBQ7s1Nx3HwdgBHYNnuFBSv3vLO39dqHD3Nj7zUL5totWuwfOkVeUfW6U7LR/SdYS5KusX1cq9f2Zqq5wTEZ4xYSo7QPnyK9NXQ0nsGdrc25kfL9IAd0S5B0XpvTJ81RZUKKwkd3MbUrT85T++TyFDOmskMEdnfFPgCbwuIGmlNbU9sKDlPXp78r9cb5DbS93yjx5t4lV7J0X1AZwD6SqtEx50xeZlwMGdXG4zq+7MTe8lffTQvl2biXP2DDlfDPbbA4QNNQ+N8r35irn6z8VMLirAgZ0PsL3FofrmM5JOqlfZ/NL9+GBfurZJlYBPt6at36HXv5xbu12HeMizJ/5xSU665geuv2M4fK0OH4BJDkrT7e+95O2pGXVrlu8ebeKbKW6ZHQ/rdiept2Zebr6hEEKDfDV9KX22l58WJCuPXGwfluxWbPXUttzNXm59jOIxMQ2/jgSGuZvhnfNbWLqtlmxfKeKi0vNgO7aNSlKScnRhEuGKjjETzNnrNu3fbAmXDpUs//coIULtjjl/gBwDgK8zSwvL08333yzefnZZ59VRIT9iRzAkWMUZA3+fk1/W9boqGoo2Ldt/f0OtG/Avv3MfQvrCrlP3ReuP+eX6I5Hs83F4Okpffx6lLy93fTF94X6dZZVrz8Tqbh9nRkMNluVPD3d5OFxaN/sxaEZOsRLr7wqrV5drjVry9Wju2Pnyo8/tZ/GyFBYZH8znruviJ+XV6UHHioww7a33xpgdtjduLFCDz1SoOUryjV+Qo7+mBGpsH0dXI1uvg/cF6h77ivQSafa//aGDh0suuM2+7dm7763wJwPTzxW9w1rg9ExxOjiAecZfKyXJr0mrVtTbnbY7brf3Piy3twoLqwr1GzeVK7XXipUn36emnC54+nLm2J087393kA9dn+Bzjutbm60a2/R9bfa58aj9xfI4ind96jj3CgpqZYvc8Opeh/jpy/eyNGWtTZtXWdT+26Ogeqpn9ed1qZ43/NFyb6fPvueCxrj62+/zlpUFwg3Arr/eSRaj12XqvsuTaldHxbloWsfsH/Y996zmcrPrdTTHyU6nNrTVlIlH186NTtbTFtf3fdlD71311atm5en3L05tdfFtfdVp4FB8g1wfCsVmeijs25LUo/hoQqP29dZd6tVP7+bagZ63797q/m3HXx63Qe8RkDXCPa+eeMmvXTF+tr1wZGeuuA+e0DY6OZblFuh297v6jA3Sksq5e3beAdpNI+qIvtzRunOPSrdlqLA4wcp+MRj5BEcYP6e/d+pZhfd9Oc+UfxT/5GbxUNV+0Kcbt5Nn0q75rrqkrrApxHQDb/sVO196XPtffqj2vUeIYEKm3CyeTn3i1/NriEx917m0BnE+PDA/QDHQ/MY0jZJF/brqalrN2rGpm2HtE+HyHDdNGKwliWn6ePFKw5pn9wSm/5v5jw9evIYfXvl+Nr1WzOz9dqcheblR04ao4qqSj3xq2MXYB+LRbYKewgGAPD3UfcFmh91X9Scnt7oXGnbkqbQkwco7JSBsoQGqGRLqtIn/Szb9nTtfvwLtX3xKvN9WH3lmfnKn7XKYZ1/rzaKve5UM/hZnyXIT1GXjFX6pOnacef7teu9EiIUecEI8/Ket6fLzcNdMVee6LBvVWm5Q1dOND+j+66hZHu6rJvTFHlqP0We3l+eoQEq3pSm5Ld+Vcm2vdr6yFfq8url5tyoKLDPp4pCm1Im/W6GbWPHD5VXdIhsuzKV/M7vsm5K07aHJqvLG1eac8JgCfZT/MRRSn7zV2269cPaMfgkhit2/DDzcvIbv8jN4q7Ea493GGeVrVzu+0I6cA4eN9AUI1htKN2RrtKtqQo+YaBCTh4kj5AA8/eM96aZXXrTnv5MSc9d22Bu7C/j3Wnml/eN7rthZw13uM4jyF/hF41V5nvTlHzvO7XrveIjFXae/fSeGe9OlZuHhyIvt9f6alDbO7raxoRr3CD7lzNqTFu6Qc9/P0dFtrpupyH+9s+Ugvx9dM85o8yw7aRf/lJqdoHax4XrrrNGqmfrWL153Zk65+lPlG+1mdvnFdv08o/z9MB5Y/T5HXW1vW3p2XrrZ3tt7/7zx6i8slLPfrtfbc/TIls5tb2WbsWKXebZHEND/TVkaEfNn7fZ4frTTu9be9nfv67pR0F+id6dNEu33Hai3pw0sXb9rp1Z+ui/9vD4zbedqMqKKr3+ym8Ot+ntbTE7+wJwXQR4m9ldd92l9PR0DRkyRFdcccURve2UlLoASGP27Kk7BSuAI6t1oqdWz0rSfycXaOuOckVHemj8WYHq3MFLuXmVuu2hLA0Z4KNrL7G/mf9ySqF5WrXN28rNgu/Y4X5mh4Y2Sbw5PxKGDvHW4EFe+mtRmS6bmKOnnwo2fzdCuh9+bNXX35SY/+5Gh92a7FPNl2qNDEP/fp56d5L9VNWGfv289OUXYTp2WKb27q3Shx8V67Zb6k5pc+kl/urezVPTptvMQHC3rhadd56fGc799rsS/Tm7VM89E6zoaA8ztPv4EwXm+sLCaoWFuevSCX66/bYACvpOYHTF7T/IS0sXlen6K3L00BPB5u95uVX64hOrpnxbNzfc9mWfKiqqde+teeZcefL5EIfA3MFcOMFfXbp56vefbSoqrFanrhadea6fGc796fsSzZtdqkefDlZUtIcZ2v2/JwvM9ca2RgD4ggl+uv4W5oYz9DnWXz0G+mrN4hI9dHWqbnwsWj0H+Kogr1I/fZqnGd/Zw9YVxuPGEcjPHjMmQG9Nba1ZPxYoL6dSCW28dMK5wQoK8dDaJVb9PDlf518bpjadvVVZWa1PX83W1M/ylJ9TaXb7HXNGkK66N5Iwr5NsWVZghmrdPdx09Qsd1HlwsCye7tq6vEBfPrNTH96/TVuXF2riU/ZT4xn2765r6NAvyFw+f2K7Zn6SrslP71D/E8PN4G6N3qPD9PAPvbRoaqYKcyoU3dpHQ8+OUkCIp7YsLdCcr/bqpKvjldDJX1WV1frx9WTN+iLdDPX6BniYgeBz72pFmNcZar7nUVkp/2N7KmJiXdcV3x7tFXPfZUq57WWVJ+9V0cLVChzW528dzui0G//09SpasFpVBcXyjI1QwMi+8gjwk23jThX+sUzBpw+TV1KMqquqlPftHyr4fbHZycPN11sBQ3sr7KITKPg7QYC3l5469XhlF1v1+C+Hdtp0Dzc3PTvuBFVVS/f99Fv9ZkAH9cWy1VqfnqETOncwj71xb6a+W7XeDOee1r2zhrdvrQenzlBmUbEZ2r177DCd3qOLAn28lVNs1efLVuv1OX+pql6XGQBAy6n7UvMFji7qvi1MzUvWiioFDeuu2KtPqr0qoFdbtXr0Ym29/g2V7s5Q/tx1ChnV02H3oMGd1fWHh1RdWaXy7AIVr9qhzMl/attNbyn+ljMUdGxXh+3DTupvduYsXLhBldZS+bSOVsiY3mbILn/2GhWv2KbY606RZ1igGb7b++Hv5voqa6k8gvwUemI/RZ4/wgzrwTmMDrqhI7oq8boTatcF9WmjDk9cqHXXTDKDuTlz1it8dI967+ur5N85Xm3vO6t2H+N3c5+r3lZ5TpEypy1X7IVDa6+PPKWf/NrFKHf+RvPv7dsmWuFje5rh3JxZa1WwfLuSbjhJnmEBZmg35YOZypm1ztzW6PgbcXJfM+zL3HACHjdwsMlRWamAIT0UdeUptdf49Wyn+Acv0a6bX1NZcoYK569V0IheTd5S9jd/qnD2Srl5WhR723nyCGzYCCbkhIFmR9+iv9arqqRU3q1jFDTSmBteKpi7WtZVWxV19WmyhBpzo0xZn/ymwjmrzW2N2ws+foDCzh3J3HCyz/5cYS4Wd3fFhAVqVI92uur4QRrSpbXZTXf5ttR9W9o/x/P08NDKHWm687/Tam9jzc50XfPGt/rpwYmKCg7Q+cN66Z1f7d2aDV/PW62NKRka26uDAny8tCk1Uz8uWm+Gc0/u39k81mOTZyiroNgM7d56xjCd0r+LAn29lVNkNfd/+2dqey3VnrQ8zfh9rY4/oYfuuPsU+fp6avGi7fLytmjs2G4af/GxKi+vlKenR4O/4U9TlmvrlnQNG97ZDPdu27ZXv/682gznjhnbTQMHtdOLz09XTk6xGdq95roxGnNcNwUE+Cgvz2ru//GHc80AMQDXQoC3Gc2dO1fvvfeeLBaL3n77bbm5HdkwTmJi4hG9PcBV1Zw+rdja9AuR4mL7dUH1TrVW/7RrTe1btG8/c99AxzdIEeEeuvP6utBnjTsfy1JeQaXe/r948//9lF+KNP7avRo60EdP3huu9IwKPfBMjsacnarVfyYpYF+3Rvw9704K0eVX5WrJknJdOtHx1OVXXemvxUvKtGpVuUJC7P/eAQF1j8kTLm74xjogwF1nn+WrtycVa+7cMt12i+P1RsjXWOozAsMPP1qgQYO8dPFFvua6G27M1a+/leq6a/w1cKCXfvnFppdeKTKDvY885PhtbTSPl98K0U1X52r50nL95wrHuXHJFf5avqRMa1eXK3jf3Jj0WpHWr60wu+m2afe/v1Tq3dfLXOozOj0/81iB+g300rnj7XPjrptz9cdvpZp4tb/6DfDSjN9seuuVIpVYq3X3g8wNZ3jg9Tg9dl2a1i0r0cNX1RRd7M6cGKp1S0u0eY1NgSH2YKTvvucNm9Xx1Hr1lRTbr/MLaBimbN3RWxPvcDy9ZnlZtV6+f69ikzx18U3h5rp3n87Udx/k6sTzgnXMcQFmwPebd3OVm1mhh96KPwL3HAdiLajQGzdsNAOyRhfetr3qvsDRa1SY4tr76aHTVmretxk65vRIM9x7MKffkKhZn6ebAd3tq4vUsb/j//H4Dn4669ZWDusqyqr00UPbFJnko9Ovt7/u/+q5nfr9wz0adk6Ueo8JMwO+v36QpvysMl3/GqdZa27Gae9qBI4Z0OB6S0SIfPt0knXxOtnWbDMDvO4+9n2qS+u6M+yv5jojdLs/r8RohZ1/nOP2FRXKem+KLNFhCjnL3rEj57NfVDB9gQJG9ZN/vy5mwDd/2nxV5hcq+ta6Tg5oHvcfP1KxwYG6+dtpZofcQ3HdsEHqHhut52bM1Y5sx9cnh2JVarq51Bfs4637jh+hJbtS9OWKNea65888UWM6ttP7fy3Tst1pGtupnW4YPlh+np56Zsac//m4/2jGWz9XrG274piBf4DmrPtS8wXqUPeFcWr6GqEn1HUrq+EZGayAfh3M4Fzx6u0Ngng1jPCTV1SIvI7rY57y3gjipb36o/y6JJldOevz65RgLvt3bUz/4Ff5dU1SyPH2caS+9L0KF29S+Lhj5NclUYWLNinrq7lmeDPmcscurGjeuRFxUsMv0HpFBSt4QDvlzd+kwpU7zQCvh9+B9/Hw81bYqO7K+H6RClfucAjw1oR8jaW+isISpbw7QwHdEhV+Ym9z3Y7npyh/0RZFnzlI/t0Slb9ws9InzzfDmwlXjj0i9x9N43EDTamp0xmCj+vf4HrPyBD59+2ookXrZV2zrckAb+5PC5Tz5Sx7ePfOC+TbOanJY/p2TDSX/btEZ334i3y6tFLQ2H7muvRXv1Pxko0KPf1Y+XRupeLFG5Tz7Wwz2Bt5qWP3ZjhHRVWVUrLy9cms5Vq5PU0f33qBnppwosY9+aFKyytlrVfv/Wa+vQ5Xn7W0XNOWbNClY/prUKckhwBvTcjXWOoL8vPWnWeO0LKtKfp2gf02n7rkRI3s0U4f/7FMK7anmYHia04cLF8vT73wA7W9luqVF3+Rn5+Xhg7rpHsfGOdw3aw/1pvhXeO6wn1nFKhvw/o0c6kvMNBH190wVqtX7da0n1aa64zbPXZIB3395SKtXZNsdvudcOlQ+fh46u03ZzbzPXQhrlrzlQuPG4eFAG8zKSsr09VXX63q6mrdeuut6t69+9EeEvCP1TrR/lCWl19lnh6tfoG2RnJaufmz1b5tDcZ2YaHuysmt0u7UCvXq1jA0kZxmP9VARJh77WnUDmT2ghJ9OLlQD9waqq6d7EWC517PNU/V9sNHsQrdFwIzOnpef0+mPv+uUFdPOHjwBwcXEeGhKd+Fa87cMs2bX2qGaSMjPXTC8d7q3ctLvfvtNbfr0tk+B5KS6sJ1SUmNPx222rdNRkblIY3h0ccLVFRUpf97Ntgs4m/dVqGffynVmWf46IH77WGt44/z0abNFfrvh8W68/YA+VPIb3bhER769NtwLZhbpkULSs3uu+GRHhpznLe69/LS8P72udFx39yY8as9ePPnDJvmzKo7nbkhNcU+F2bPLNUl59lPo/jxV/bQ5YE8t29uPPaMfW7s2FahGb+U6tQzfHTHffa5Meo4H23dXKHPPirWDbcxN5whNMKiF79K1PJ5Vq1caDW77xrrjh0boI49fXTB4K3mdm062Z8fYuLt3XOKCqpkLaoyO+PuL3OP/XkjOuHQXmZPfitbu7eW6dlPE+Tl7W7ertEBuGs/H932TExt996MtArNnlqolO1lSmhLN83mtPrPXDNoG5Xk4xDerRGZ6KO2PQO0cVGB1i/MO6QAr9FNNzDMU/mZ5cpNd3xcacq0d1K1Z1uJ7viwmzy93VVSVKlZn6WrfZ9AXfZk+9ruvdl7SrVkerbSd5Qopo39CwJoHpaoug/wPaMbfphvrt+3TUVeoX2fyBDzZ1WxzeyeUT8EXKMiO99h24PJ+2GOylMzFXP/RLl7eZq3W/DbInl3TFLk1WfWdu81brd44RqV78kyu/ei+RzXuZ15Wrvx/XqaS31tI8LMn+f07q5j2yQpq9iqW7+bruM6tTPXj+7YViPat3bYJz7E/tpgRPu2+mTCOeblCZ98c9Bx3HPcCLMj74PTZpi/twkP1fGdO+jHNRv0/Mx55rpZW7arQ2S4Lh7QS6/OXiircRoCAMD/hLov4DzUfVH/vZdXE+/DvKLt76UqcooO6TaN7f17tFbR0i0qWtl0eK++9P/+ZnbLjP3PqWZtrzQ1S4V/bVTQ8O6KvtQeyAwc2EmlyZnKnb5EUReOdAgR4sjzjql7D+0d08Tc2Lfe6Khr/73+Po2/B69ZX55TfEjjSHlvptl1NenGk8y5YUvJNgO7oSO7Kf7y0eY2IYM6qGR3pjJ/WqbYi4bLg7nRrHjcwKHMjSZre/vWV+Y2Pjfyfv5LWR//KjeLh2JvP1/+fTr8z+PI/PhXs54Xfc1p5twoS80yA7uBQ3so4mJ7kDugfyeVpWQq/5fFCj9vVKM1RTjPml3p2p6erfZxEeqaGKMV21OVsq+mazCCvo2p2SYyyP+QjnPHGSPk7+Nldt81tIoK1ZheHTRt6Qa9/KO9tjd77Xa1iw3XBcN76c3pC1VSRm2vJbLZyvXwA9+qa7d4DRjYVmHhAWZYd+mSHVq5YpdefeMSc7sd2zMP6fauvX6M/P289eLzP5u/JySGadjwTman33cn2c8It3DBVrVqHalxZ/bTh/+dI1sJcwNwJQR4m8lTTz2ljRs3KikpSQ8//HCzHCM5Ofmgp1MbOHBgsxwbaEk6tfOSn6+b2dF06SqbRg1p2E112Sp7WKZvD8c3OH16eGvmnBItW2XTacc3fPFsrK/Z7mBKS6t13V0Z6tTOU/feZP+g3rByXZm6d/KqLeIahg7yMX+uWndoIR4cGuON7ojh3uZS386dFdq7t0qhoW7q0cMewGvX1mJ24S0qqlZOTuPdNGvW+/kfvJPO/Pml+vKrEt1xW4A6tLc/va5bZ39hPKC/Y9HF6MS7fEW5Nm+uUJ8+FGScNTeGDPc2l/p276xQZkaVQkLd1LW746kNly1p+o1NVmaVsjKb7qZYnxEa/v7rEt1wa4Da7psbG/bNjd77dXE2OvGuXlGubVsq1LM3c8MZjLnRb5i/udSXtqtMORmVCgr1UPtu9sdsIzjr7eum0pJqszNv72MaPt8Y6w01+xxI8vYyTX4rR8efHaQ+x9qPv2trqdmVt2tfxyBm9/6+ZoB32wYbAd5mZgRiDT6NdFGu4Rto/79cnGf/wPdgqiqrzQCuebv+Td9ujfTtJZo+KUVDzopUl2PsH/ju2WZVRXm12vVxDBV36BdkBniTNxQT4G1mXm3ijAcNqbpalQVWWcIbfthndNCo39HDMy5Cbt6eqi4tV+n2VPl2a9tgH2O9wbt13EHHUJaWqfwf5yhgRB/5drcHQMtSM6SKSvl0dOz24dOplRngLd25hwCvExinyxvUuumOiYmhweaSkudY0O+f1HRn9ahAf3M5FINaJejs3t3MUO72fR19u0Tbu76vSHE81fqy5FT1TohV+8gwrU6zf5EJANBy6r7UfIE61H3h2y7WfobqaqPTqdXsnLk/o8ul4X8Jvhmntjf3zT94SLN4zQ7l/7FKkReMkHeC/b2VbYf9dbRfZ8f3AL5dElWyOdUM5Pl25CxKzcmvXUzd3Ciwyiuy4RnNjPfuBncf+9/bJz7cnCdVJWWqaKTjnaGiZh9fx1pxYwpX7VTOjNWKvWiYfBLtc8O63T43Aro4/v0DuibKuilNtt1Z8u908Pf/OHw8bqAp3m1i62p7xtyIaGxu2B8D3Hwazo28XxYp84OfzfBuzB3ny79fx/95DNa1O1T450qFnTdSXvH2uk3pvi6sPp0c54ZP5yTZtqSYQV6fDo4dnuF8NUHZsEB7DX5XRq6KbKUK8PFWaEDjnweFBti3rd+ttykDOiRo3OBuZih3Z4a9ttd53xxZtcOxtrdiW6p6to5Vu5gwrd1Nba8lW78u1Vzq8/X1Urv20aqoqDTDvAfTu08rnXhSL334wRwl77Y3l2rfPtp++2sdb9voxGuEhlu1itCmjY7zBkDLRoC3GRgF3Kefftq8/Nprr8nf/9A+cPtfJSTwQg0weHm56eSx/vrmpyJ98V1Rg0LuruRyLVhqL8iecZLjaW3OPCnALOR+OaVID90eZnZIqFFVVa2vfrR/w/LMkx33a8xTr+Ro8/Zy/fFtvLy9627HuFS83+nWa07ddiRPsYimvTXJXlC5+CI/c74YLBY3nXiCj775tkRz55Xq5JMavrmaPddeaO9zkCClUcS/+958dehg0Y031M2Vmj+vdb9T9dX8zp//6PvgHfvcOG983dz4/hf7G+LGvP5iod54uUhnX+CrJ547eKfEstJqPXJfvtq1t+iq6xvOjRLmRov1zbs55s+TLwiW5765YfwcNCpAc6YXataPBQ0CvHtTy7V+ub34O+SEAz9vGN26Xrk/Xf6B7rr6/qja9TV/e9t+c8O273mE543mFxrtVRuitRZWyG9fWLdGRXmVdq23vz6ISDh4UNuw8o8clZVUmX/f1t0PPjc+fnibedzz7q7XlXPfn760xLErfKl13+9MjWZnCQmUd6cklW7cpZK12+RtBHrrqa6olG3DDvOydzv7By5uFov8endS8aK1Kpq/qkGAtzwzV6Wb7SEdvwFdDzo3st+bIjdfb4VdfFLterd9f/wqm2Mh2DjFnnk9jxvNrv//vdXkdc+cfrzO6tVNL82ar7fmLa5dP+7dz5rc58bhg3XjiGP09Yo1un+qvePGwcLDj54yRlszszWp3jFqnkl8PR0/eK75vZpTcAFAi6z7UvMF6lD3hXGaeuN09db1u1W8aod828Y2eB9WvNYefPDtcGihyKryClk32N+HecWFHXTbPW9Nl1dChCLOHtrw+v3ehxlf3jTx5292nmEBZii2aF2yClfutAd695sbhWt2m5f9O9rnhpuHu0KO6aicP9aqYOUOhRzbqcHtGuvr73OgubH7jV/kkxiu6HOPrV1f81+/0lbe6Ht05kbz43EDTbGEBtpDsRt2qWT1NvkYgd795kbJ+p3mZZ/2jmHqvN+WKPP96bXh3YB+DR8/DsaYGxnv/GQGd8POGFZ3xb6/fVXNXKgZT81c4TXFURfi76OO+8K0RnDXUFlVrVmrt+m0gV01qFOS/li9rcF+gzu1Mn+u3XXgkK2nxUMPnDdG29Kz9f7vjdT2vPar7e37QgGlPdc07oy+8vHx1MwZ65Sbe+AvhXh6euiW207Urp1Z+uKzBbXra/72Pvt94ciHTu6Ay+LczM3gpZdeMk+l1rZtW1mtVk2ePLnBsnbt2trt//jjj9r1xcWHdkoWAI7uviHEfP/y4ZcF+uWPuv9HVmuVrro9Q5WV0lmn+KtzB8cXLZeeF6i4GA9t3lauh561h7VqGL8b6xPiLLrk3Ian0K5v/aYyPfdGrq4YH6Thxzh2vzO6P2zYUq75i+u+0f3up/mH3OEBh2bT5nIVFjoWzCsqqvXKa0X65FOr2rT20C03ORbkb7oxQEZ+4bPPrfp9hr3YX+PNt4q0eHG5PDykiZc27O5R30uvFGn7jko9/1xwbQjU0GNfR9fvvi9RSYn9pXR2TpWm/2yT0ZivY0e+R+MMWzeXq6iRuTHp9SJ99ZlVSa09dM2NB/+w5nC8+WqRdu2o1GPPOs6Nrvs6QU/9oUQ2m31u5OZUacYvNnl7S+06MDecYdeWUhUXOoYhKyuq9cUb2Zr2Rb7iWnnqwuvDHa4//9ow8/nm12/ytWR23fONraRKL96drqpKaeiJAUpqd+DH91++ytfqRSW69oEoBdXr1NOqvbcZFF7wW6EK8iprb3vmDwXm5XZded5obj2Gh8rbz11ltip99MA22Yrr5khFWZW+fHqnctLK5OHppv4n2udHdlqpFk7JVHlpw47uy2dk68MH7MW7QadFKjjywAWUud9kaNPiAp1/b2sFhNQVX+La+cni5aYVM3JUlFdeG+b966cs83JS1+b50iAchZ5tP/1l/pQ5sm2p645XXVmpnE9/VkVGrhmwDRzRr/a64HHDzUJ70ewVsq7c7PDhXdY73xvpAfkN7FbbdaMpRbOWybZhp8IvOVkeAXWvTTwTIuXmaZF16XpVFllrb7to3irzsldrxw8j8M9z/bBBah0WqgemzlB5Vd3j0Lo99g8HTu/RWd4W+3NNqK+Pju/cXrbyCm3NsndsgJ1btesuAJyHui/gfNR9EXH+cPNn1rfzZN2UUru+urJKe//7u8r35ppdNEPG9DbXV+QVK+fnpaq0NuyCXJ5doLSXflBFTqE8o0Lk39t+ZpOmZH01R2V7shV3/aly8/Rw7PBpvDecs7Y2cGV0bi1YuFFuXhZ5Jx74/R2OjJjx9nBk+lcLVLwx1WFupLw3U2XpeebcCD+uZ90+5x0rN4u7sn9dqfzFWxxub++3f6l4XYrk7qbIU+ve1zcm/Yt5Kk3LUdJNJ8vdYW7Yg8S5f66rmxv5VuUt2GTODZ8kzpDjDDxuoCnh5440f+Z8P08l+75UX1Pby/z4131zw1tBo/rUXpc/Y6ky35v2t8K75jG/ma3y9BxFXXu6Wctz6AxsdPWeu7p2blQWFKto8QZzO68E5kZzaxsTppP7d5bXvvpZfa0iQ/T85afK29OiVTvStHVPXT3tvd8Wq7yiUmcf00PDu7Vx2O/S0f3Ut128KiqrNHnuygMe/+oTBikpMlSPfTHD3L7GhmR7bc8Ym/e+xxMjTDymZ3vZyiq0PZ3aXksVGxei4OCG+YITT+6py64YoYJ8q95+4+CNGy6+ZKjiE8L0wv9NV0VF3dzYstneuXvM2G7y8rI/ngQF+2rYsE4qLS03A7+wO9p1W+q+OFSkQ5pBaan9xf327dt14YUXHnT7xx9/vPbyjh07mq1jL+Aqlq+26YZ7M2t/37bT/mblnU8LNG1GXZH22w9iFRttfxjr29NHzz8codsfydKpF+/RiGN8FRnhoXmLSrRnb6V5erO3nq3rcFjDz89dkyfF6MQL0vT0q7n66bdidevspXUby7R2Y5n8/dz05Tsx8vV1P2A3tGvvzFBYiIeefdAx6GW475ZQc0wnnJ+msSP8tDejQotXlKp9G09deEbzhAb/jT79zKpPP7WqR09PxcZ4qLSsWsuXlyszs8oM7375RZj5966vQ3uLGbq99fZ8XXJZrnr18lRigoc2birX1q2VZnj3maeC1aVL06fL2rSp3Az7TrjYTwMHOH5Q0KaNRWeO89H3U2waOSbTDPQuWVqmrKwq3XiDf4PxoHl89bnVDOp26+GpqBgPlZdVa9WKcmVlVpnh3Q8+azg3joQtm8r1wdtFOu8iP/Xdb260am3RKeN8NG2KTaeNyVTX7p5avrRM2VlVuvp65oazTP8iX9O+yFOH7j6KiLGorKxaG1eUKDer0gzvPvNJonz3f9zo7qOr74vUpCcz9cDlKeo5yFch4RatWWJVTkalEtp66eYn7KeuaUpuZoXeeyZT/Uf4a/Q4x9P7+fq76+wrQjX5rRxdfcIOde3nq63rSpWeXK5RpwUqvjXfnm1ugWGemvBIO/33vq1a+ku2Ni3OV+seAfKwuGvX2iLl7i2Tm7s0/v42iky0d+Atzq/Qe3dt0SePbFNS1wCzi68RAN6zzaq9O+1fEOk8KEgTHnHsvrq//Kwyff1/u9R9WIgGn+ZYmPXx99DxE+M0fVKqHjp1pdr3DdSudcXKSinVoFMjFN3K8YNkNA/f7u0Ucu4Y5X09U3sefVfe7RLkERKgsh1pqsjMk5uXp6JuOM9cV8Po1Bt28YnK+eRn7X3uE/l0aS2PIH/ZNu5SZV6hPOMiFHHF6Qc8bmVekXI+/1W+vTooYEgvh+vcfbwVdPKxZqg49c5X5d2xlcp2pplhYv9je8ozpuHrU/xztI8M15XH9tfkZau1PCXN4brdufn6ae1Gnda9s6Zfe6nWpWeob0KcIgL89fa8xSoprzhq4wYAV0XdF/h7qPvicAT0aqvI8SOV+fmf2nnfh2bHTEtIgGzb01WeYbwPsyj+9rPMdQYj/JQ+abr2vv+rvNtEyysqxGxTVp6dL9u2dLPDoiUsUIn3nif3fYGHxth2Zyjr+wUKPaGf2c2zPq/YMAUN666CuWu17aa35NM2ViUbk1WZX6zws4fIvZFTr+PIC+rdRrEThmvPJ3O06a5PzK65nqH+sm5LV9nefLl5W9TmrjPkGVr3/9EnMUJJN56sXa9M07ZHv5Zfh1h5RQWrZFemSlOyzfBu0vUnyrd1w8eVGsa2Rtg34qQ+Zhfg+nziwhQ6oqtyZ6/X+uvelV/7aBWtT1FFnlXR5x0rD+aGU/C4gab49Wir8AtGK3vyH0p56AOz065Rxyvdvqe2thdz8zm1c6N0xx5lvDPVPI2RJTpURQvXm0tjYm44s8njliZnKHfKfAWP7SffzvvPjXAFDOmhovlrtOu2N8zOwCWbdptzI/TMYcwNJwgL8NPTl5ykB88fo40pmdpr1Gw9PBQTGqguiVHycHc3u+Pe9eF0h/12ZuTq0ckz9Oj44/TaNWdo7a50peUUqH1suNrGhJth3Ce/mukQ+t1fu5hwTRzTX98sWK2VOxxre8lZ+Zq+dKMZ4P3u3ku1ISVDvdvEKTzI3wwPl5RR23OGDh2iddOtJ9b+Hhcfav489fQ+GnxM+9r1Dz/wjXJy7O9pjjm2g665brQZtM3IKDDPotexU4xiYkOUm1Ose++aXLttU1q1jtD5Fw7W1J9WaN3aui+jGNJSc80OvkaA9/2PrtLWzXvVrUeCQsP89fmn82Xb70wAAFo+ArwAWpyCoiotWt7wW64paRXmUsMIaNZ3yzUh6t7FSy++naclK23m6cqS4i2658Yg3XNTqAIDGi/GDhnoqxUzE/XES7maOdeq76YVKTLcQxPODdSDt4WpXeumw5uGdz4p0PwlNk1+J0YhwQ2/mXfiaH/98FGsnngxR7/OKpafr7vOPyPALDwT0jtyxoz2UXJKpdasKdfq1eVmt9N2bS269mp/TbzMX76+jZ9i5rxz/dSxg0Wvv1msRYvLtH59uUJD3XXaqT667hp/9enjdcAi/p135ys8zF3339t4t46XXwpRfHyh2YX3t99tiovz0IP3B+q6a/nQzllGjPZRWkql1q8t19o19rnRpq1Fl13lr4su85ePz5E//ZAxNx6+J1+hYe66/Z7G58ZTL4QoNq7Q7MI7a4ZNMbEeuuO+QF1+DXPDWQaM8ld6arm2rrVp8xqb2fk2sa2Xzr4yTOMuCZG3T+OP0WdfEaY2nbz1zfu52rSqRDarTVFxFl1wXbAuuC5cfk0839R46/EMlZdX66bHGw/6TrwjQgHBHpr+RZ4WzihSaIRF518TpktupUOHsxwzLlIJnfz0+0dp2rykQBsW5ptF++AoLw0+LUJjLolV2551/7fDYrx00lXx2rGmSBm7S7R7fZEqyqsVEGJRr1GhZsB2wMkRDqdsbczkp3aqsryqyaDvWbcmyT/Iotlf7tXKmbkKCvc0j3vGTY4fFqF5hZ41St7tE1Tw80KVbk1W6bZUs9AfMKKPgk8b3mgn3eCTh8grMVr50+ardFuKeXpEj/BgsztvyLgRZmePA8n+eJr5YVF4E0Hf0POPk7u/rwpnLpF12QZ5BAco+PRhCj13zBG732iZHj9lrHKLS/T8H/Mavf6eKb9qT36hGeId3bGt0vML9eyMOXp/4TKnjxUAAIC6Lw5X5HnD5dshXjk/LVLJllSVbE0zw1XBo3sp4qwh8k6oq5lYQvwVPfE4WdftNsN0RSlZqiqrkIe/j3w7xStgQEeFHt9PHn7eB6zt7XlzqixB/oqa0Pj7qvibxskzMkj5s9eqcMkmeYYHK+rSsQo/45hm+TdA42IvGGoGdzOmLFHxpjRZt6TJEhqgsLE9FXPOYDOwu7/wsT3NTrh7v1moonXJKtmxVx6BvgoZ2lnRZw2Wf6e4A86N3a/9LEuwn+IvG9XoNq1uPU1ekcHK+XOt8hdtkWdEkOIvH62oswYd0fuOA+NxA00JO3uEvNvHK2/aX7JtSVHVvrkROLK3ws4Y6lDbq7TazPCuoTw1y1ya0lSA15gbGZN+lEeQn8IvOq7xfa8/Q9kRwSqct1pFSzeZjxuhFx+nkNOH/O37i4Mzwrmv/jTP7JjbJjpMnRMiZfFwV35xqRZvTtbMVVv1w6J1Zrfd/f20eL3ZCXfi2AHq2zZOneIjlVds068rNuvjmUu1dre9i25THrxgrHKLSvTKj43X9h787Fel5xaaId6R3dsqPa9QL/4wRx/9QW3PWfz8vdW1W3yD9VFRQeZSw7PeFzyMwO3c2ZvUqUusWreJND9f2rMnT598NE9ff7VIxUUN3xPt77Y7TlJ+nlXvTZrV6PXPPf2TMvbma8xx3XXMkA7KzCjQpLdm6qvJiw77vgI4etyqjVcMcLpHHnlEjz76qHl51qxZGjnSfrqGIyklJUWJifYP85OTk5WQkHDEjwHXVpXe4WgPAS1URiWndUTj8hqeHR4wJVc4dpIFaiSX0/0TjXti+clHewhooSxbGp5eDP9u5fl52vnCY0e8vlG/btLv5Afk7RciV1NqzdOy6U+Yl6n9AP+Oui81XxwMNV80pcei8Ud7CGihfDzp4IfG2crpBYbGlZc3/GILYPCd03hTGyBiVcnRHgJaIFtpvhYseu6I1jj+CTVfA3XffxdedQMAAAAAAODfzfh+uyt+x90VxwwAAAAAAAAAzc1Va74GVx03Dgvn8AEAAAAAAAAAAAAAAAAAAACciAAvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnIsB7lDzyyCOqrq42l5EjRx7t4QAAAAAAAPxruVW77gKgZaHuCwAAAAAAcPQd7botdV8cKgK8AAAAAAAAAAAAAAAAAAAAgBMR4AUAAAAAAAAAAAAAAAAAAACciAAvAAAAAAAAAAAAAAAAAAAA4EQWZx4MAAAAAAAAaJGqj/YAAAAAAAAAAABHDDVfuAA68AIAAAAAAAAAAAAAAAAAAABORIAXAAAAAAAAAAAAAAAAAAAAcCKLMw8GAAAAAAAAtDRu1fbF1bjimAEAAAAAAACgublqzdfgquPG4aEDLwAAAAAAAAAAAAAAAAAAAOBEBHgBAAAAAAAAAAAAAAAAAAAAJyLACwAAAAAAAAAAAAAAAAAAADiRxZkHAwAAAAAAAFqc6mr74mpcccwAAAAAAAAA0NxcteZrcNVx47DQgRcAAAAAAAAAAAAAAAAAAABwIgK8AAAAAAAAAAAAAAAAAAAAgBMR4AUAAAAAAAAAAAAAAAAAAACcyOLMgwEAAAAAAAAtjVu1fXE1rjhmAAAAAAAAAGhurlrzNbjquHF46MALAAAAAAAAAAAAAAAAAAAAOBEBXgAAAAAAAAAAAAAAAAAAAMCJCPACAAAAAAAAAAAAAAAAAAAATmRx5sEAAAAAAACAFqd63+JqXHHMAAAAAAAAANDcXLXmKxceNw4LHXgBAAAAAAAAAAAAAAAAAAAAJyLACwAAAAAAAAAAAAAAAAAAADgRAV4AAAAAAAAAAAAAAAAAAADAiSzOPBgAAAAAAADQ0rhV2xdX44pjBgAAAAAAAIDm5qo1X4OrjhuHhw68AAAAAAAAAAAAAAAAAAAAgBMR4AUAAAAAAAAAAAAAAAAAAACciAAvAAAAAAAAAAAAAAAAAAAA4EQWZx4MAAAAAAAAaHGqqu2Lq3HFMQMAAAAAAABAc3PVmq/BVceNw0IHXgAAAAAAAAAAAAAAAAAAAMCJCPACAAAAAAAAAAAAAAAAAAAATkSAFwAAAAAAAAAAAAAAAAAAAHAiizMPBgAAAAAAALQ41fsWV+OKYwYAAAAAAACA5uaqNV+58LhxWOjACwAAAAAAAAAAAAAAAAAAADgRAV4AAAAAAAAAAAAAAAAAAADAiQjwAgAAAAAAAAAAAAAAAAAAAE5kcebBAAAAAAAAgJbGzViq5ZLjBgAAAAAAAAD8M2q+Buq+/y504AUAAAAAAAAAAAAAAAAAAACciAAvAAAAAAAAAAAAAAAAAAAA4EQWZx4MAAAAAAAAaHGMU6lVu+D51FxwyAAAAAAAAADQ7Fy15mtw0WHj8NCBFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJzI4syDAQAAAAAAAC1OteRWLdfjimMGAAAAAAAAgObmqjVfg6uOG4eFDrwAAAAAAAAAGrV06VI99thjOv7445WQkCBvb28FBASoY8eOmjhxoubNm/c/3d7PP/+sM888s/a2jJ/G78Z6AAAAAAAAAEDzo+7bctCBFwAAAAAAAEADw4cP19y5cxusLysr05YtW8zlww8/1CWXXKJ3331XXl5eTd5WVVWVrr76ar3//vsO61NTU83lhx9+0JVXXqlJkybJ3Z2eAwAAAAAAAADQHKj7tiz8qwAAAAAAAABoIC0tzfwZFxenm2++Wd98840WL16shQsX6sUXX1R8fLx5/ccff6zLLrvsgLd1//331xZx+/Tpoy+++MK8LeOn8bvhvffe0wMPPNDs9wsAAAAAAAAA/q2o+7YsdOAFAAAAAADAv1v1vsXVNPOYO3furKeeekpnn322PDw8HK4bPHiwJkyYoCFDhmjz5s1mQfbaa681uzfsz7j++eefNy/3799fc+bMka+vr/n7gAEDdPrpp2vEiBHmadv+7//+T5dffrnat2/fvHcOAAAAAAAAwD+Xq9Z8DdR9/1XowAsAAAAAAACggalTp+q8885rUMStERERoRdeeKH2d6NTQ2NefvllVVRUmJdfe+212iJuDT8/P3O9wdjupZdeOoL3AgAAAAAAAABQg7pvy0IH3n+JqoxhqrLw54ajjMrioz0EtFB5VUd7BGip0ioCj/YQ0EKlV4Qc7SGghdpqiz7aQ0ALVZnvdbSHgBbKp+RojwAtTbXtaI8ABzJq1Kjay9u2bWtwfXV1taZMmVLb2cHo4NAYY32nTp20adMmc/vXX39dbm5uzThywPVR80Vj+i49/2gPAS1URUXjH8wCJdW85kLjykp5nYHGlRd7Hu0hoIUKy+JDZjTOUlh6tIeAFshSVna0h4ADoO7rPHTgBQAAAAAAAHBYSkvrPoBprGPDjh07lJaWZl42Tpd2IDXXp6amaufOnUd8rAAAAAAAAACAg6Pu6zx8bQ4AAAAAAAD/am7V1ebialrCmGfPnl17uUuXLg2uX79+fe1loxPDgdS/fsOGDWrTps0RGycAAAAAAACAfw9XrfkaWsK4qfs6DwFeAAAAAAAAwMXt2bPnoNskJCQc0WNWVVXpmWeeqf39vPPOa7BNSkrKIR8/MTGx9nJycvIRGycAAAAAAAAAuCLqvv98BHgBAAAAAAAAFzdw4MCDblN9hDs3vPTSS1q8eLF5+ayzzlK/fv0abFNYWFh7OSAg4IC35+/vX3u5qKjoiI4VAAAAAAAAAFwNdd9/PvejPQAAAAAAAAAArsU4hdo999xjXo6KitJbb73V6HY2m632speX1wFv09vbu/ZySUnJERsrAAAAAAAAAODgqPs6Hx14AQAAAAAA8O9WtW9xNfXGbHREiI2Ndcph161bpzPPPFMVFRXy8fHR119/bRZzG2NcX6OsrOyAt1taWlp72dfX9wiOGAAAAAAAAMC/iqvWfA3Uff9VCPACAAAAAAAALs4o4iYkJDT7cXbs2KHjjz9eubm58vDw0OTJkzV8+PAmtw8MDDzk06MVFxcf8mnXAAAAAAAAAOCfjrrvP5/70R4AAAAAAAAAgJYvLS1NY8eONX+6ubnpgw8+0Lhx4w64T/3ickpKygG3TU5Orr2cmJh4BEYMAAAAAAAAADgQ6r5HFwFeAAAAAAAAAAeUlZWl4447Ttu3bzd/f+2113TJJZccdL+uXbvWXt64ceMBt61/fZcuXf7WeAEAAAAAAAAAB0bd9+izHO0BAAAAAAAAAEeTW3W1ubgaZ405Pz9fJ5xwgtavX2/+/swzz+j6668/pH3btGmjuLg4s3vD7NmzD7jtnDlzzJ/x8fFq3br1ERg5AAAAAAAAgH8jV635Gqj7/rvQgRcAAAAAAABAo6xWq0455RQtX77c/P3+++/X3Xfffcj7G6dcqzndmtFp4a+//mp0O2N9TScGY3tjPwAAAAAAAADAkUfdt+UgwAsAAAAAAACggbKyMp155pmaP3+++fvNN9+sJ5544n++nVtuuUUeHh7m5RtvvFElJSUO1xu/G+sNFovF3B4AAAAAAAAAcORR921ZLEd7AAAAAAAAAABangsvvFC//fabeXn06NG64oortHbt2ia39/LyUseOHRusN9bdeeed5inYli5dqiFDhpjdHNq1a6dt27bp2Wef1YoVK8xtje06dOjQjPcKAAAAAAAAAP69qPu2LAR4AQAAAAAA8O9WvW9xNc085u+++6728h9//KGePXsecPtWrVpp586djV735JNPKiMjQx988IFZtL3gggsabGMUig+n0wMAAAAAAAAA/CNqvgbqvv8q7kd7AAAAAAAAAAD+2dzd3fX+++9r2rRpGjdunOLi4szODcZP4/fp06frvffeM7cDAAAAAAAAALR81H3/PjrwAgAAAAAAAGiguvrIt3o4+eSTzQUAAAAAAAAA4HzUfVsWos0AAAAAAAAAAAAAAAAAAACAE9GBFwAAAAAAAP9y1UbbAbkeVxwzAAAAAAAAADQ3V635Glx13DgcdOAFAAAAAAAAAAAAAAAAAAAAnIgALwAAAAAAAAAAAAAAAAAAAOBEBHgBAAAAAAAAAAAAAAAAAAAAJ7I482AAAAAAAABAS+NWbV9cjSuOGQAAAAAAAACam6vWfA2uOm4cHjrwAgAAAAAAAAAAAAAAAAAAAE5EgBcAAAAAAAAAAAAAAAAAAABwIoszDwYAAAAAAAC0ONXV9sXVuOKYAQAAAAAAAKC5uWrN1+Cq48ZhoQMvAAAAAAAAAAAAAAAAAAAA4EQEeAEAAAAAAAAAAAAAAAAAAAAnIsALAAAAAAAAAAAAAAAAAAAAOJHFmQcDAAAAAAAAWhq3KvvialxxzAAAAAAAAADQ3Fy15mtw1XHj8NCBFwAAAAAAAAAAAAAAAAAAAHAiArwAAAAAAAAAAAAAAAAAAACAExHgBQAAAAAAAAAAAAAAAAAAAJzI4syDAQAAAAAAAC1OdbV9cTWuOGYAAAAAAAAAaG6uWvM1uOq4cVjowAsAAAAAAAAAAAAAAAAAAAA4EQFeAAAAAAAAAAAAAAAAAAAAwIkI8AIAAAAAAAAAAAAAAAAAAABOZHHmwQAAAAAAAIAWp3rf4mpcccwAAAAAAAAA0NxcteYrFx43DgsdeAEAAAAAAAAAAAAAAAAAAAAnIsALAAAAAAAAAAAAAAAAAAAAOBEBXgAAAAAAAAAAAAAAAAAAAMCJLM48GAAAAAAAANDSuFVXm4urccUxAwAAAAAAAEBzc9War8FVx43DQwdeAAAAAAAAAAAAAAAAAAAAwIkI8AIAAAAAAAAAAAAAAAAAAABORIAXAAAAAAAAAAAAAAAAAAAAcCKLMw8GAAAAAAAAtDjV1fbF1bjimAEAAAAAAACgublqzdfgquPGYaEDLwAAAAAAAAAAAAAAAAAAAOBEBHgBAAAAAAAAAAAAAAAAAAAAJ7I482D/NkuXLtX06dM1b948rV+/XpmZmfL09FRcXJyGDBmiK664QkOHDtW/1aatZfp9tlXLVpdq+epSbdhSpspK6bG7wnT/rWEH3HfGHKtempSnJStsKi6pVqt4i846JUD33BSqAP+mc+lbd5TpyZdzNXOuVZnZlYoM99CYYX568LYwtW3l2eg+n39XqKdfydXWnWWKjrBo4oWBeuDWMHl4uDXYtthapR4jdptjWPpbory8Gm6Dvy81rVJvvFGkP/4s1Z49lfL3d1PPnp668nJ/jR3j0+R+VVXV+ubbEnNZt75CRUVVCglxV4f2Fp16io8uu9TfYXurtUqPP1moqdNsKiysUtcunrrv3kANHeLd6O3/PsOmSy7L1T13B+rmGwOO+P3Gwe1Jq9R7bxVp7qxSpafb50a3Hp66eKK/Rh5gbtT3+cfFevyBAvPy2Rf46onnQhpsY8yN558q1G/T7XOjcxdP3Xp3oAY3MTdmzbDpP5fn6pa7AnXNDcyNoyEjrVyTJ+Vo8WyrstIr5Ovvpo7dfXTmpSEaPLrpv8myecX65v1cbVxtk81areh4i4adGKjx14XJt5Hnm8qKan38arZ+/bZAedmVSmjtqQk3hWvEyYGN3v7W9Tb954zdOvGcYN32VPQRvc84NFlppZr+7h6tXZCv7LRSqVoKjvJSp/6BOmlijJK6OD431H9Omf9DluZPyVLyRqtKiirlH2JRXDtfDTghTGMvcvx7llorNfm53Vrya45KCiuV2NlP592eqK7HBDd6+ytm5eqlazbrnFsTdPp18c1y33Fg+Xus+uu/W7TzrwwVpFvNM9UERPgosV+4Bk7ooOhOjf/tdvyVocWfbNWetbkqL6lQUKyfOo+N0zFXdJKXX8O3X1UVVZr79kat+XG3rDmlCmsVoCHXdFaX4xv/u+/dmKcPL/pTPce10kkP9Tni9xsHlv3hlyr+a9kBt0l87Um5eda9tyjdtlPFi1aoLDlVlTl5qiy2ys3dTR5hofLp3F5BY4fLEtHw/U91ZaXyp81Q8cKlqiwskmdUpIJPGSu/fj0bPW5ZcprSn35V/sf2V/jF5xyBe4u/6/YTh+mK4f3Ny6/8Pl+TZi1udLtj2iXp0qF91SMhRr5enkrLK9Dva7fo3dlLZC0rb7C9h7ub/jN6sM7o203hAb7amZWnt/74S7+u3dLo7XeOjdSX/7lQ3y9br0d+mHGE7yUA/PtQ8z0war74u6rKK5X983LlzVuv0uQsVZWWyxLkJ59WkQod20uhw7rWbpv++Rzt/WLuAW+v05vXyCcxwmFddWWV0r+Yo9yZq1WRZ5V3fJiiLximkKFdGr2Nku2Amb+KAADnVElEQVTp2nzbfxU2tqcSbzjlCN1T/K+qyyuU99tSFS5cp7KUTFWXlssj0E9eSVEKHtVHgUO627erqpJtc4qKV26Vde0Oc9uqklK5+/nIp02Mgkb2UeCwHnJza/h/ucpWpsxPflPRX+tVZS2Vd6toRVw0Vn492jY6pqKlm5T2zOcKv3CMws8e3uz/BmhcdXmlcn9dqoL561RaMzeC/OSdFK2Q0b0UNNQ+NwxFy7ao4K8NKt2RrvKcQlUVlsjN4iHPmFAF9OugsNOPMR9zGpsbGR/9roKFG1Rltcm7dYyiLh4j/55tGh1T4ZLNSnnqC0VeNFoR5wxr1vuPplVXVCj/9yUq/mut/XGjrFzuxuNGYrSCRvRRwLE9GuxjXbNN+dPmy7YtVdW2MlkiQ+Q/sKtCzxgudx/vRus3ud/MUsHsFaosKJZXbLhCzx6lgMF1866+0p17lHL/2woc0VdRV49rlvuNpmW//5WKFyw/4DaJbz/uUNurz7pinYrnLlXpjmRVFZeYzy2WqHD5du+o4NPHNqzt/ThTxfOX2Wt70REKPm2M/AY0Udvbnab0J16X/5D+Cr/0rL9xL/G/8vBwV5/OCRrcq7X6dklUYkyIfL09lV9k0/pt6fp+5iotWLmj0X2DAnx00Sn9NaRPW8VHhchicVduvlVrtqbp619XaOXG1Ab7+HhbdMOFIzR6UAf5+3pr6+5MvTl5rpatT270GMZtv3DnmXrry7n6aErj9UU0n4RW4eo7uL06dIlVhy5xSmoTIQ+Lhz58Y6a+eH/OId/OqecO0I33nmpe/vn7ZXr58R8bbOPt46krbzlew8Z0lX+At7Zv3qsPXp+hVUsan3+DhnXUY69cpP++PkOTPzjw+yIALRsB3mYyfPhwzZ3b8AGyrKxMW7ZsMZcPP/xQl1xyid599115eXnp3+btj/L16nv5//N+L0/K0+2PZMmorQwb5KOoSIvmLSrR06/m6rtpRZozJUER4R4N9pu/uEQnXpAma0m1unXy0pCBvlq3sUwff1Wob6cW6bev4jW4n2PAb+rvxZpw/V6Fhrjr5DH+WrWuVI+9kKvs3Cq9+mRkg2M8+Ey2dqdWaM6UeAq5zWTlyjKNvzhHuXnVio5216hR3srNrdKCBWWaPbtMt90SoDvvaBiUKyio0qUTc/XXojIFBrqpfz8vBQe7aU96ldauK1dhUXWDAO9Nt+Rr2nSbOneyqF9fT82eU6oLL8rRD9+Gq18/x/+zxcVVuue+fHXpbNF/rm087IXmtWZVma6akKP8vGpFRrlr+Ehv5eVWafHCMs2fU6b/3BygG29vPERZI3lXhV54qtB8fDGCWk2599Z8/fazTR06WdSrj6cWzC01j/3JN+Hq3bfh3Hj8gXx17GzR5dcwN46GjatsumdiigrzqhQe5aEBI/xUkFullX9ZtXSuVRNuDNNltzp+kGMwgrtvPZlpzoceA3wVGuGhNUtK9PmbOZr7S6Fe+SpJwWGOzzfvPpelr9/LVWySpwaN9DeP8dgNe/TQ62oQ4q2srNaL9+5VcKiHrr6n4fHR/LatKtKzl22QrbhKodGe6j40WO7ubtq9wWqGc/+amq3rXmingSeFO+xnLazQS9du1qYlhfIN8FCHPgHyC7Iod2+Zdq0vNsO8+wd437l7m5b8mquEjr5q1ztA6+YX6P+u2KT7P++i9r0d54atuFIfPbJTiZ18dfKVsU75t4Cj1NU5mnztfJUVVygwykdtjokyA5cZm/K19qdkrf85Rac/PaBByNYI7s58fo3kJiX2DZd/uI+Sl2dpwXubtXFGmiZ8OFx+oY6F/lmvrNPij7cqJMFf7YZFa/eSLP1w52K5uQ1U5+Mcb7+qslrTH1sh3xAvjbqlm1P+LdA473atZYl0fGyo5e4YLilZu1FFcxbKIyxElphIeQcGqKrEZgZ6i/5cYAZ0I/8zUT6d2jnsl/f9zyqcMccM9/p27yLb5m3KevdTRejiBiFe4wPqnE+/kXuAv0LPIlDQEvROitVlQ/uaX/gwnluacsmQPrrnlJHmdst2pSq7yKp+reJ1zahBOq57B1086UvlWW0O+9x2wlBNHNZfu7PzNHvTDg1sm6iXxp+qWz6fqt/2C/G6u7np0TPHKq/Yphd+oYh7QMbr/yq5ngO8bwFw5FHzPThqvvg7yrIKtP2hL8zgrhG+8++SIHcfL3N98bpk83L9AG8NnzZR8m0T0+htevg3DFvt+fAPZf6wSF4xIQoa0F5Fq3dp17PfSW5nKWRIlwZh3+TXpssS5Ku4y8YcwXuL/0V5dr5SH//EDOAZc8O3U6Lcvb3M9SUbdplzoybAW743V8kPvG9edg/wlU+7OHn4+6osI1fW1dvNpXD+GsXdcb7cPB0/Jk1//XszvGuEgn06JJjbpjzxiRIfv1y+HRMdtjVCwRnvTZNXUrTCxg1x4r8G6ivPKtDuxz5VWbJ9bvh1TpK7j6e53rremBueDgHe/DlrVDBnjTxjw+STFGXuU1lYopItqcr+dp7yZqxQq8cukXdSlMNx0l79QYULN5jrPTsmqHjVNvO4rZ+cKN9OCQ7bVpWUKf2dafJuFaXwM4512r8FHFVk5yvt6Y9UnpJphnZ9OiXJ3dtTFdkFsm3caV7eP8CbN22Bsj/5WcYLEp/OreQR7C/bxl3K+2GOihevV/wjV8ojyPFznuzPfzcDv5aoUPn36aiS9Tu09+UvpVvUIMRr1G8y35lifvkg/KLjnfLvgMZ5t29lBm8b5ebeaBg8+90vZV26Rm5envJqmySP4ABV5heqPC1DhTMXNAjw5n3ziwp/mytLZJh8e3aWbeM2Zb39uSLc3OTXv0fD2t5H39lre+eedGTvLA6qb5cEvXbfueblrNwirdqUKltphVrHh2lYv3bmYoR4n33f8Yvx8VHBeuuh8xUVFqi8whIt35AsW1m52sZHaMygTubyyqd/6ovpjg0hHrr2JI0e1NEM7q7dskcDe7TSK/ecrWse+1Lrtu5x2NYIEt85cYy57adTlzrhXwONBW/PHH/M37qNmPhQXXnzcaqqqpL7fp8f1HfnY2dq2Nhu2rFlrzauSVGfQW311OsTdPuVH5i/1+fj66Ub7jlF27ek6+uP5/+t8f2juWrN10Dd91+FAG8zSUtLM38anRfOPfdcDRs2TElJSaqsrNTChQv1wgsvKDU1VR9//LHKy8v1+eef69+mW2cv3X5diHp391bfHt5mMfbTbwoPuM+KNaW649EseXhIUz6K1Ulj/Gu7YZ5x2R7NnFui/2fvPsCbKts3gN9tRpM03bu0hbL33nsjIAioqCiK4t57D8Tt5yduceECcSBD9pC99yp7dO82HWmSZvV/nfe0TUPLEGlKv//9u67YjJPkxDyc5Ly5z/M+8Fw2/vjWPewi3X7zfZliIPf5R4Lw1ouuL+QvvZ2Hdz814OZ7M3F0cxy0WtcH5mvv50EaZ9+6JAbNm6hFt4XuI1LEQPSLjwUhMtz1T2j3fgs+m1WI++8IQO9u2iv4f4oqWCxlmHqvQYR3rxurwYz/BkKr9XIFeyfn48OPjOjeXY0B/V0Ds2VlZbhzqhzenXybDq+94gffKl07rNYyHDnq3tlKCvVK4d1+fdWYO0fuvrFpcykm3pyPjz4x4ucf3TuGvPNeMTIznfj6yyCoVBzI97RSSxkeu88gwrsjx2jw9n8DodF4VQZ77709H198bETnbmr0qVIbVUmhiReeKhShq+uu12LhPHONyx1NsInwbs8+anw7W66NbZtLcdekfMz8xIiZP7jXxsfvFyMr04kPv2Bt1AVrqROvP5guwrsDr/XDs+9HwEfjXRnsfeGuVPz8aT7adtWiaz/XwNvJBAtmvp0DbwXw5jcNRBhXYjE78co96di71YQZL2dh2hfRlfcx5Nqx8KcCNGymxhcL46DReiP5tBX3jEoUXXnPDfAu+KEAxw+V4tXPoqD3r/4jJNW+WS+fFeHdQTeFY/KrDaFUeVduD+Z/koq/vkjHrFfOouPgIKh9vCs/Uz5+UA7vDro5HLc8FweNr+v9s1udSD5ucnseKdQrhXdb9/LHs7NawlvhhYSthXhvyjEs+iIdT33dwm35eTNSRBj44Y9bV64TedaKN/aJ8G7H6xth+AsdoCh/H8qcZdj4xVFs/eY4Vkzfh2YDIqH0kd//zKMF+Pu/h+Cl8MKNn/REk77yj8dSF955j21H4o4crHhzPyb8t0fl85TklWLP3DMIbeyHKb8MhEqrRN7ZYnx7w9/Y9OXRagHe3b+cRmZCAcb9pzs0/v//wiBXE98+3aHv3fXSlu3eCfo+3at12ZUG/gvmL0Px2s3I++FXRL/1ArzKB+8cRUYUr98CVVQEIl54BN5qNWyZ2ch4YwYKl66uFuCVHsOalIrQe26Dt477InVNo1Li7RtGIKe4BIdTszC0TdMal2sVFYZnRw6A3eHEQz8vwqYTiZX3/3zydejVNA6vjRuKJ35ZUnmfYF8tbu3VEaey8jDxi19gsdkRHxaEhY9MxkNDelYL8N7Wu6Po7Cs9RrGltJZfORHR/z6O+V4cx3zpckmdds+88gtKU/MQMakfIm7sI7piVt5usaE0Pa/G+wb0bIHISZfW/dRWUILcJbvhExuK5h/eJcJ9lpRcnHj0G2T9sqlagDd38S6YT2Wg4XMToNBf2gxfdOVrI236T7Cm5SJk4kAET+jvXhulVlir1oaXF7Rt40WoVte+CbwUrn//poREpL0zByV7TiB/4WaE3Diw8jbL2QwR3pW67TZ4ebK4nwjwTv8R+fM2osGLt7qtV+7cv2HPL0Lskze6rQ95tjaSp/0saiP05gEIvb7fObVhc68NQARqI6YMhzJIXy10m/7ZIhRvPYKMzxej0XtTK2+znM0U4V1d+3jEvXqbqI2Sg2eQ/NrPyP1jI2JfnuT2WNlzpNooRszTrI264rTakP7WD7Cl5yLohkEIGjeg2nbDluFeG6Vn05E3e4U4MDvymVtFGLdi2cz/zIH58BnkfPsXIp+8pfI+9kIjClduhyomDDFv3S8OLLCm5SDl2c+RP29dtQBv4fLtKD2ThojHbxIHFlDd8e3XDfq+lza2J5HCtVJ4V9upNYLvuB4KP1+38K31rHuwToztrd0KVXQ4Il5+WD7oJCMbGa99jMJFa6oFeIvXbIE1MRWh90/i2F4dkH4TWrvjBH5bsVeEd6sa2rMFpj00CuOHdMDBE+lYvulI5W2P3TZQhHc37z2Nlz9dIkK/Fa4b3A4v3D0cD93cD2u2H0dOvlFc36xhmAjv7jqchMfe+RPOsjJ0bROHz166EXeO64GnP1jo9vz339QXYcF6vPTJEjgc9TWFWL8lnsoWAdnTxzJw6lgGbr6rH4Ze2/GS7y/N+vD06+NE87A1Sw5g+NiaZ1Zs3DxShHf37TiNFx/6WdRlx+7xeG/mFEy6uz9efcx9fGHKQ0MQEu6Pt57/Aw47a4OovmMioJa0bNkSv/32G5KTk/HRRx/h+uuvR7du3dCzZ0888cQT2L9/P5o3l7/4z507Fxs3Xnpr9f8Vd98agPdfDcWkCX5o2Ux9bqOqGkmDrtIH25Sb/CsHciU6nTe++W+4eIz5S0tw7KTV7X4//l6M9EwHmjdR4Y3n3X84ly5L16ek2/HTH8Vuoc5DR63o31MrBnIlvjpv3Hq9n5j2bee+Urcuivc/k4PIcAXerjJQTFfW8hUWpKc7Refc994JqAzvSjp2VOPJx+Vw3Icfuf8o8OtvZmzdZsXAAT54/90At/CuROqc0bGDewjm4EE50HvzTbrKqfP69fVBfCMFdu92ry8pPPz9DyZMuV1XrTMvecaalRZkpDvh7++FaW8HVIZ3Je06qPHgY3JtfPnx+X8w+mlWCfbstOKpF/zQIOb8g2oJh+TauL5KbfTq64O4Rgrs3+NeG1J4eM6PJtxyu65aZ17yjM0rjcjOsEPv740n3gyvDO9KWnbQYPIj8jZbCvFWNffLfPF5c80N/pXhXYkUyn36vQjxebNphVEEdCucPW6FzVqGIWP9xHKSuCZqtO+uQ+IJK0qKHZXLZqXZ8P2MXPQc7Fst2EueUWywIaU8aHv9EzFuQVmpU+KER2Kg1njDVORA+mlXoH/jnzk4uqMY7foF4M7p8W7hXYlS7Y3G7dx/AEhMKBF/+98QJsK7kja9AxDR0Aen9rlvl84cNGL17CwMmRRRrTMveYapoBTZJ4rE+QEPt64M70qkLrz9HmgFpUYBS7ENuWdc79+2WSfE0bDtr4urDO9KpFDuqGmdReOG42vSRUC3Qs6pQjhsTrQZHSuWk4TE+yGuayhyTxej1Og6wKgww4SNnx9B0/6R1Tr/0tVNCuGeG96VeCmVCLx+tOj45DAUwpaRVXmbLT0DsDug695JhHfF40RKHaAaw5aeJTr4VrDnG1C4eBU07VpVC/ZS3XhiRF80Cg3CtAVrLhiavWdgd/GZs2BvQmV4VyKFcl+ZvwoOpxMj2jYTAd0KzSNDoVYqsWT/UbGc5GyOAbvOpqJZRCh8fVzfOaMC/PDo0N5Yd/QMVp4T7CUiosvDMd+L45gvXa7sP7aK8G7wiE6IvMU9oCmRgrbaxjV32f0nLEnZKLM7EDSwrXhMiSY2FL5tG8KSnAOHyVUD1uxCZM7ZILr0BvZ1D/aS5+Qv2CQCmgHDuiBk4qDqteGjhibeFfBXRwYjdtoU+HZq5hbelejaNELwuL7ifNGGA263lZ6RD9LwH9yp8n669o2higyG+YT7lNaWU2koWLETgSO6VevMS54jdcyVaiNweGeE3TSwhtpQQXNOd27p8rnhXbGsVo2IO+WOqOYTqW7bAstpuTYCh7hqw1eqjahgmI6714bUydewfBeCrularTMveY7UMVcK7/oP6YrgGwbXuN3waeR+YJBh0UYxNaPfwE6V4d2KZcPuGy8ODpC68EoB3QrW5CwxfuPXp4NYTqJuEAZt60awpWbDWWVGHVtuAfJ//xu6zi2qBXvp6mY5cgolW/dC1SACofff6hbelUgH5Ps0iXO7zpaaKY/t9exUWRuqqHBoWsRXH9vLK0DhwtXQdGgJXTeO7dWFPUdS8OLHi6uFdyVS+HbZxgRxftQ5M0F0aSO/79/N3+YW3pUsWnsIyRn5UCoVaF3lO2zLeHn2xsXrD4vwrmR3QjJSMg1o19zVNEjSqnEEbhjeEfNXH6jWmZc8Z8XCvfj2o1VYt+IQUhJzRbD2nxg3qSfadW6E7z5ZjayMgvMu16yV/P6vXLSv8jn27zyLtOQ8tG7v/n2zeetojL2pO5b8sataZ14iqp8Y4K0lS5YswcSJE6GQ2gbUIDQ0VHRkqDBv3jwPrl39JA2uLlsjB2BumVB957phrAp9uslHwC9cLh/BVGFB+eWbrtNXm75UujxxrPx4C5a57ldQ5BCDtsFB7u9hxWVjiesolo++LsC+w6ViijV/P/6zqi37D8ghlvbtVAgIqP7/uV8/eQdo1y4bsrNdQbnvZsl18+AD7jtUF2IwyO9vYKB7vQQFeaPE5PpSZreX4ZnnChEZ4Y0XnmfQqq4cKq+N1u1U8K+hNnr1lWtj724bcqrURoWzp+2iU263nmrcMll3wecqKK+NgHNqIzDIG6ZzauO15wsRHuGNJ55lbdSVYwflQZDmbTU1drnt3Ed+vxP2mJGfI+9cSyHcHevk7cbgsf7V7hPRQIU2XbSVAeEKRQVybfkHuj+Pf/nnhrlKfXzyWraYFvSx6e5TsZHnqNSX/nntF+TqvrT6JzlgN2qq+wDvhRgL5NrSB7hPfqEPVMJicn2fcNjLRMffoHA1bnySP/7UFaX60juj6ILkzxcphHt6Y6Y432Zk9fcuIFqHmI7yD/7H18o/+kjMBXIA4dxuutoA+bLV5Br0W/X2AXGk9oiXOvzDV0RXPekDoTzQW8FhlA8w8D6nG4u3Xv7ccpa6fkjMnyt3ZQi+ZbxHVpcurFt8DG7t2REL9x7Bxiqh3HOpFN7o3yJenF964Fi129MLirEvSd5eDG3t6uAbWN6FpdDsHgwuKP/hR6eWQyiSl8cOFrNsvfHX3//6dRERkYxjvlcex3xJIgVqc5fvFefDJ/Ss1edyFMkH6Sr83LvpKv20lV04K6TNXCG+rzd4gFNZ12VtFK7aJc4Hje1zRR7Tpzzsa88tdLveUVxeG3r3/TBpqnunxVUXZQ4Hsmb+BWWQH0InuU+XTp6tDcNKeSrxkHFXpjYqjzrx9nILf5+/NrTn1IYTGV8uEbURdtuQK7NOdHnbjdU7xfnAMX0v8T52mPadEOf9+lQPUKrCAqFpIQf1Sna5um86K8Zvzq2N8stV6yN31hIxA2TYXWMu41VRXSr+e6v46zes7yV31XaUnGdsz1dXrTby55SP7d027oqtM11ZxxOzxV+p225V1vKD6y+moPxzRBJQvn0oMrpC3JLCYjN0GtfvBApvLzx/93DkGkrw5W+b/tX6U92JaRiCKQ8OxoHdZ0XY9kL8A+XaKC7fX6lQVGiCRueqDW+FNx57eSzyc4rx/WdramnNicjT3FME5FGDBg2qPH/69Ok6XZf64MQZq5gOTdK1Q81TVXXp4INNOyzYd/icDqmH5B83u5z3fvL1+6vcLzxUCZ3Wq1pnh4rLDSLlfz6JKTZM+08+xo30xbiR1QeZ6copKR9Al0K0NQkJrpjeHDh0yIYhQxTIyXEg4YhdTMHXtYsaSUl2/LXYgpRUB3x9vdC5kwojhmtEF96qYmPlHbCTp+wYXP5P1WYrw9lEOyIjXTtnX31dgsMJdvwwKwh6PQfy64qpvDakEG1NgqrUxpHDNgwYrHDrpvL8kwUiFPXm+wHi74VUdOc9fcqOfgNdtZGcaEd4ldr44ZsSHE2w4/Nvg+DL2qgzlvLQrP95aiOg/Ac6qTZOHragxyA9Us9aYSn/vGnRrubPjebtfHBolxmnjrh2sCNj5M+FpCpdeSXJp0qhUntVPtf6pcXYvrYED70ahvBoV8iGPEvqnNuiqx+O7y7GnzNSMfnVhpVdeKUjW+d/mgqrxYn2/QMQEuUjri/MtSH5mAneCqBZZz9kJ1uwY3k+ctNKodF5o0kHPToPCRJdeKsKbSDfX+rk275/oDhvtzmRlVSKoAjXTveK7zOQfNSEx79sDq2e0+vVFbVOidjOIUjZm4cNnx3B8Bc6VHbhLXOWYdOXR2G3ONC4bwT8I+UB1/xEI2wWOcQf2UZ+j88V2TpQPGbWsUK3YK+kalfeisvSc+qC5No5ujIVpzZmYuiz7Sufk+pW6YnTokuu01IKha8v1I1ioW3bUnTTvVTS9HqFS9egzGqTu/SGubq6KUPkjqvS1HpVictKBRR6+cC0kt0HYDl0FEETx0IZXHPtkedI4dk3rx+OPKMJ7y5Zf8FlG4YGVYZtD6e6ui9XdTgtC13jY9Aq2nXAT5pB3oY0DnfvMtg4LBhWux0FJnmA95p2zTGoVWO8vXgdMgvdw05UM6+yMnGqb+rjOhP9r+OY7z/DMV+SmE5nwlFkgjJYD5/oYJgTs1G47RhseUYo9Bro28TCr0tTMStKTcynM5H+w1o4jGYodBpoG0fAv3szKHTyPlVV6ogA8bc0xX3qdEtKrgjlKPzlfa6CTUdQtOsUou8ZDnVY9QO8yTMsZzJEbSiC/aCOCkFpUhaMO47AbigWoShtq4bw7STVxqWPv9oy5PdeEeQewlGFy/tU1tQc0b23IghozcyHskpgx7B4G0oTMxH93C3w1lavMfJsbUjvjToqGJakLBRvPwp7fjEUUm20joO+c7PzbjfO5bTZkTNnrTjv26Gx6N57bm2UpuZA37lpZW3YMvKhCnZtH/L/2obSs5mIeeFmKFgbdab0bDqcxSbxb1wVGYLS5EzROddRvt3QtGwIXcdmbtsNa0YeykrlRjE+jWue+Uq63nIsCaWJri6YyvIZc2xVuvKKx5MuV/lMMW47BNPe4wi5YxSUofLnENWt0uNnYEvLFEFahV4HdXwMtO2qj+1J43eWo6fEeZ/m8XAUFqNk5wHYM3PEwfiquGjoukhd/d3/zVeO7aWfZ2zPT66Nkl0HYTlwDEG3jOHY3lUsNlJ+b/IK5AMPK2w7cBaj+rXB1Am98NInS1BqdQV6rxvUDnFRwTiVnIPDJ11NPTJy5LG9Rg2Csf2gfPC/QuGNmMgg5OS7xvBuGdUVLRqF45kPFsJkcc3UR/WHdFDp09Plphszpi+66PJZ6XJ33tj4MOzeKm93FEpvRMcEIy/b9RvS9bf1QtOWUXjt8V9gNrnv19L/zpivpL6uN10eBnjrUGmVrknn69pALmeT5S88gQHe8DtPGC62PAiVmOz6ElNsdCKvvGNmXIOaSz42Wr4+J8+BEpNTTJsmGTPCF78tNGLGTAOm3hqA7Xss+OG3IoSHKtCzizwA/OBzOVAqvfDp22FX9PVSdaGh8r+TpOTqHVTF9Umu65NT5PNHjtorQ7+/zDXh9TeKYDvnO27DhgrM+iYIrVu7BmT69PGBXu+Fr74qQY9uasTHKzHjYyMMhjJMGC/vhCUn2/HfGUZcO1ojQsBUd4LLayP1PLWRUuX61PLaqDBrZgkO7rPh+Vf9Edfo4h+LPfv4wFfvhR++LkGXbmo0bKTEl58YUWAow5hxcm2kJtvxxUdGjBilwWDWRp0KDJFrI6PK50JVGSmu6zNS5O1FRqp8nd7fG7rzfN6ER8nbi8wq92/SSoOIBkqsnFeEnoN80aqjBst+K8KZY1b0HuorQrzGIgc+n56Nlh00GHc7B2Pq2l1vxuO/9xzHut+ysX+9AfFt9SKcm3TEBEOWFX2uC8XtrzWsXD7luKmyc+7637Mx971kOGzuO0/hsT549PPmiGvpClm27ukPja83ls/KQPMufohopMGiz9NEZ97eY+XAXk6KBQs+S0O3a4JFCJjq1sjXOuH3h7Zh/5+JOL0pE5FtgsRgS9axAhRnW9D22lgR7K1QkCYP3Gn8VPDxrTmYXxG8rVhWEtEyUIR4Dy5KQpN+EWjQPhgH5ici+0QRmg2MFCFeS5EVq98/iKi2Qeh6S+Naf+10aUq276l2nSLAD8G3T4S2TYsa72PPN6Dwr1XivNNkgjUlHQ5DoQjuhtxzq9sPR+rYaCiCg1CybTe07VrBJz4Oxi07YUvLgLZ9a/EDgdNkhuH3v0R4WD+wdy2+WrpUz4zsj9jgADzy818osrh3yD1XTJD8g12h2QKTtebvKZmF8sBsgyDXD8LHMnJEiHd859bYcOwMDqRk4oaubdEyKgxrj5yGzeGEn8YHL4weiIMpGZizff8VfY1ERHRxHPP9ZzjmSxJLeVczdai/COLmzN8GMZVAuZw/t4lQbqOXboQ6vHrwqWjnSUA6VeHt64MG9w5H8GD3Toqa+EiowgOQv+YA/Ls2ha5lA+Sv2i/Wwb9HM3irFHAYLUj7ZhV0zaMRem3X2nrZdAlKk+TZbqSQZM7s1TAs2iIfiV/OsHCz6Kgb/ezNokPmxThLrShYtkOc9+vZyu02Xdt4EciVArpSMFgVFYz8eRtEENC/XzuxjC3LgLw/1kPfszX03Vpe4VdL/4QlUT4QUhnij+yf1iBvoVQbVRZYsAU+jSMR+7xUG9W3G+bTGTAs3SHuYy8qgeVUuggEa5pGI+qhsW7L6tpJtaEWAV1dqzioo0OQ+/sG0ZnXv79cG9YsA3J+2wC/Xq3h173mcQHyDGtyeW0EByDvl1UoWLzZbbuBvzZB3SgKkU9Pgiq0vNlCtkH89fbVnDeYrwyR68ie7Zr+3KdRJJShgSjasA+6Ti2gaRaDonV7xDrourQU4zeOEjNyf1wGnyYxCBjRozZfOv0DJVvlzv/VxvbuvAHadq5/w/acfJSVygE56+lk5M9eWHm5QsEfyxB63y3QtHLNoKSOi4IiJBAlW/ZA274lfJrEwbhxF2ypmdB2bOUa25u7GOr4WOgH96rV10uXLzhAh9H924jz6875vvnZnI2IbxCCvp2bYNGn94qgrsVqR+OYEDSMDsbmvafxzrer4XC6tkG7j6SgxFSKSaO64sDxNKRkFuCu8T0R6KfFyi1HxTJRYf4iFPz3juPYtJcHhdZXN9zeB63axWLmB8uRkSp/zlzI/l1nUWK0iIBuwr4kpCXn49Z7BiAgyBdrlx8Sy0REB+K2ewdi4+oEbN943AOvgog8hQHeOrRhw4bK861auQ8UUHXSoKzEV3f+o2WljqqSovJlq97vQvfVl99P3LfYNZj79oshWL/FjKdfzxMniUoF/PRZOHx8vDB3QTFWrjPhs3fDEF3enUFisTihUnlBobi0I3vp0vTto8bHnwAHD9pw6LAN7dq6B2R+mi0HqyTFRvmLsKF8IL+gwImXXy0SYdunntCLDrvHjtnx6rQi7N1nw6TJ+Vi7JgzB5V06pW6+L7/oh+dfLMLIa13dGJo1U+LpJ+Wj7Z97oUjUw5vT3TswSF1DpE4e5Dk9e6vx1adAwiGb6LDb+pza+K1KbZQUu3aSThy34dMZxejURYXJd11aR0Opm+9TL/hh+ktFmDjGVRtNmirx0BNybbz+UhGUKuDF191rw2wug5a14VGdeukw5/N8nDhcipMJFjRr4x6oXvyLqxOmqfzzwlz+V+qoej7a8s+NkiqfMVJA9+Fp4Zj2QDqeuyOt8vqQcAUeeFn+we/r93JRaHDgvR9j3Kb3tJid0GjZqdnTohpr8ervbTDzmdM4vLkQhizXDnSDplq07OEHrd71+W40yD8slxQ6MPvNJBG2Hf9wA9FhN/WkCXPeSsLpAyX44O5jeGtxO/gFydsiv2AVbnomDj9OS8S0GxIqHy+6iQbjH4kR53+Ylih+HJ78siswLCk1O+Cj5Y/+nhbSyA+3/zQAi1/ajbPbslGc7eqsEdrYD3FdQ+Gjd33WWE1ybagu8F6pdfJtVqPrKHwpoDvsufaY/9QO/PaAPBWbRB+mwZBn5B+Z132UAHOBFTfP7OPWNcZmtkOl5e6cp6liokS3W5+WTUVXjDKrHdbUdBQuWQ3rmSTkfPEDwh+9G5oWTard11lirhb8VcU1QMjtN0IdHel2vTSIH3Tzdcid+RNyPvnW7YeEoBvlqRYLFiyD01iC4Mfudgv/Oq1WeKtd3b3JM3o3jcNNPdpj6YFj+PvoxQfWfcu7OZnPE96VmMq7/+h9XO+nFNB9a/F6fHzrtfj2rusrr88uMuLdpfIYw1PX9EWgrwZ3f/+n22+UGpUSlkuc2o+IiC4fx3z/GY75ksRePk2s+UwmTCfSETK6C8LGdIMySC8up81cAfOZLJyd/huafzS1cvpqdWQQIm8fCP8uTUQoV1KanIvseVtF99yUGYvFd+WggW0rn0sK6Da4bzgS3/4TZ16bW3m91P03+u5h4rwUIpbWqfH0SW77YU6LDd4azqbkSU6jXBuWxExYTqUh4JruCBrVA4pAvbic/e1SlJ7NQNo7c9Dw/fsvOrV59jdLYcs2iI6+wRP6u92m8PdF6G1DxTLJz39deb06JgwhE+Xu6lnfLIGXQoHwqaPc17PUCu8q39up9knhWYnlbAYsJ9MQNLIbgkb3ENsN6XLm18tQeiYTKW/+gvj/3lutNuy5hShcd8DtOqnzbuT910IV4j6ur/TXIfz2ocj8ahkSn3Xto6tjQhF2szxNX+ZXS+Gl8EbE3de43ddZanPr5ku1z2GUfw+SOuWWnk6F//AeCLimJ5TSduN0GnJnLYY1MQOZ7/2MmHceFLXhNMsHYHld4N+xd/nU9k6zxW38JvTO0cj8cC4y3vmx8nqp+2/o7SPF+fxfVsFRbELUi3e4j99wu1EnVLFRotutT6vysT2bDdaUDBT+tQbWU0nI+fQnhD95FzQt5bE9Z3k9SfJ++BM+TeMQOHE0VJFhsOfkoeDPlbAcOi7uF/nao1BFhLrG9iaNRe4Xs5EzY5b72N7N14rzBfOWy2N7T05lbVylFN5eeP2hUfDz1YhOugv+dv/cyC8y4cE3fsezdw3FyH6tRZC3QmZuEfYcSUFBkauGJIXFZnz+6yZxn+/fvK3y+rOpefj2T/k3Auk2u8OBD39c53ZfH7XSrcsvXb0aNgnH5PsHIWF/MhbOlQ8eu5iiAhNmfbIGj7x4LT6dfV/l9UlnsjH7K7kWHn3xWtjtDnz5n2Vu9/XRqFDKTs1E9Rp/8a0jTqcT7777buXliRMn/uPHSE1NveDtGRmuoAFdnkaxKhxcF4fvfy3CqbM2RIQpMGmCH1o2U8NQ4MCTr+aiTzcN7r9d3pn/bVGxmFrtxGmbGPQd2l8nujTEx3Hn/Ero28cHPXuosX2HFVPuzMc7bweIy1JI94efTPhjnln8f5c67FaMq1b8YG23A127qPDNV66uhl26qPHb3GD07peDrCwnfvixBE8+7poK647bfdG2jQpLl1lEILhNayUmTtSJcO6f881Yv6EU778bgIgIhQjtvvFmkbi+uLgMwcHeuGOyDk89qeegvgdIXXG79lBj9w4rHpqaj1ffDBCXCwxOzP3ZhEV/umrDq3wf2G4vwwtPFIhaeeuDQLcw5cXcMtkXrdqosHq5BcbiMrRorcT4G3UinLt4gRmbN5Ti9XcCEB6hEKHd/7xVJK6XlpUCwDdP1uGhx1kbntCptw7tu2txcKcZr9ybjkenh6N9Ny2KChz4a3YhVs+Xw9b2KrXxb/QeosfXSxri77+KUZjvQEy8CtfcGAD/QAUO7TJj2a+FuPn+YDRu6QOHoww/fZKHxXMKxbK+em8MGeeH+14IY5jXQ07sKcYnD58Q/xYf+LAJWvcMgFLlhRN7i/HLO8n47sWzOLnXiLvflruelpW38XDYy9C0kx6PfCJPpyhp2tEPz37fCs8OP4CCbBv+/iUb4x5yTbc2ZFIEGrbWYddKAyxGB2Jb6tBvQqgI5279KxeHNhXizunxCAxXi9Dur+8lY+tfeTAbHfALUmLwpAgRFvbmdsMjUvfl4c8nd4j/32Pf7YpG3cPgrfIW1//9wSEsm7YPqfvzMfr1zv/6uZoNjMJdvw3GkeUpMBmsCG6oR/txDaENUCNlby72z09Er7uaI7xZAJyOMmyeeRR7/zgLs8EKH70SbUbHYvATbRnm9RD/oe4/8EIDaFs3h6ZVMxG2NR9IgOGPvxD18hPV7it11Y2b+T7KysrgKCgSgd+CxauQ+fYnCLrhWvgN7uu2vK59a0S+/DhMO/fDYTRCFR4G3z7doPDVwXLqLIybd8J/xECoG0SJ6fykELFx43Yx8O+l0cC3RycEXj+aYV4PkAK2b0wYjjyjCW8tdh9Yrw3rj53B9Z/OwegOLRDkq0NSrgHz9xxGobkUnRtG44au7fDtxl04mZUHby8vPDikJ27u0R7BvjoUW0qxeP9RfLB8E8O8RES1gGO+9QPHfK9G8v52md2JwP5tEHO/KwDn1zFeBGmPPTATlqQcGDYeQfBgueNlxd+qlK1jEf/qTUj7aiVyl+xG+rerEdCnlQjuVgjo3hwtPr4bhg2HYS8ywSc6BMHDOkDpp4UxIQX5q/Yh/Ibe0DYKR5nDiay5m5C7fK/ozumt8xGB4Og7hzDM6wmVA/wO+PVth4i7R1fe5Nu+CWJeuR2Jj30Ka3I2ircchv8A12w555I65xat3w8vtRLRT06snL68qsAR3UVHX+P2IyLQ59MwEv6DOoogVdHGgzDtP4Xw+8ZAGeQnAlY5P61C8aaDcJpKofDXIWB4N4TcOFAEOam2VdSGE/792iLy3lFuQdy4aZNx+uHPUJqcjaLNhxEw0L02/Hq0RKsFr4l/4/a8IpQcPIOcX9fjzGNfIPqx8fDv3dpt+aBrukETH4WibeW10SgSgYOl2lChcMNBlOw7jcgHroUqWKoNG7J/WIXCjYcqayNoRFeE3jSAteHJ7YbDAX3vdgi7Sw5LSnTtmiDqpSlIeeJjWFOyYdx6CH79O/6rp/Pt0hKx7z6I4i0HxeeEOioEfoM6Q6HXwXwsCUVr9yBwbD/4xEWK8RvDvHUoXL1TdPeWuv3q+3VAyK0jGNj0EP/h/dyv0PpA26YZNK2bIvezn2HefwSGX5cgatpj8u1VjoxWBPkj/Imp8FIpK8f6wh69A5nTPoYtLQtFy9Yj5M4bKpfXdWyNyNceg2nHfjiKS0S417dvV1EblpOJoiOv/8gBUMfItSGFiI3rdshje1of+PbshMAbR7E26tBzU4ehW9uGKCg244WPFsPucB1EKJG67H7w9DjRPff9WWtEt9wSsxUtGobjkVsH4LHbBqJn+0Z44r35cFappflrDuB4YjYGdW8GX60ap5JysGRjggjnjujTEr06xOOdb1chr6BEhHYfmTQA1/RtBb3OB4Yik7j/d39uc3tMunp4K7zxzPTxKHOW4cPXF4rfAy7Vknm7cOp4BvoOaQ2drw/OnMjE6sX7RTh30Mh26Nq7GT568y/k5xpFaPfux4djyMj28PXToMBQgqV/7MLsr9fDWaXrMxHVD/yVt47MmDEDO3fuFOcnTJiALl26/OPHiI2Nxf8nFVOolZjO/2FTUiLf5l9lurWqU6+d777G8vuJ+/q57zyHhijwzEPVp7J+ZnouCoocmPmfBvDy8sKiFUZMuj8Lfbtr8NYLIcjMtuPld/Mx5Po0HFwfB70vd8qvhG++CsRd9xiwa5cNd9zpPtXAPXf7YucuKw4csCEwUP7/rde7gk6Tb6s+IKfXe+P6CVrM/KoEmzZZ8eTj7rdLIV/pVJUUGH7t9SL06KHGbbdqxXUPP2LAylWleOA+X3TvrsaKFRbM+Ngogr3TXnU/Wptqx0dfBuLRew3Yu9uGB6e618btU32xd5cVhw/aEFBeG199asSRw3bRTTe+yT//OOzYWS1OVUmdnt+dXoQu3dW4cZJcG88+ZsDaVaW4815fdOmmxppVFnz5sRFmUxmee4W14QmvfhYluuIe3mPBK/eku912/Z2BOLzbjOOHSuFfXhva8s8Ni8l9R7wqc/nnhhS6PVej5j6Y+rT7NFs2axk+fCkL0XEq3P5osLjuq3dy8OesAoyc6I/ew/Qi4PvHNwYYchyY9mX0FXjldCElRXZ8/NAJ0VVX6sLbpIO+8rZOg4LQoIkWL445hI3zctB7bIgI92p8XT/2DbopvNpjavUKsezyWZlI2FroFuCtCPlKp6qMBXbMeTsJLbr6YeBNcqfmmU+fxt6/DRg1NQrNu/hhzxoDFn2ehlKTA5NecO/QS1eepciKP5/YDlOBVXThbdBe/jcraTYgCqFN/PHd9X/j4MIktB0di4bdw6DWyZ8jNrPjvI9rNcm3qat0da4Q1tQfAx6Rp+Gq4LA5sfyN/QiK9UXf++RpOdd+eAi7Zp9Gh/ENRfA3ZV8edvx4EiW5pZjwIafgq0vS/kDAmGEiwGtLzYA9v0B08TjfssqgACi7tBfB34zX/wvDH4vh07wx1DHu23+pM696nHv3njK7Hfmz/4QyNBgBo4eK6wr+XIrivzeJgK+2QxuUnjyL4jUb4SgqRth9t9fiKyfJC9cORFSgH56cuxQFJlcnngspKe+uq1WfP/ShK+/SZDxnakbJqew8fLza1blbolJ44/XxQ5GSX4Av1m4X1z09sh+m9O2CebsOYe3RM+jSqAHu7NsFoXpfPP7Lkn/0Ov/nSV/v6uMPH/VwlYn+l3HM95/jmC9JFFrXGFvINZ2q3a4OD4B/16Yo3HoMxgNnawzunitiUn/kLtsDe6EJphNp0LeJc7td0zAMUbfLXVUrOG0OpH6+THT2jbhZDvikf/83chftFAFf/57NUZKQgpwF22E3GNHoRVdIh2qHFGCqEDCsa7XbVWGB8O3cXARuTQdPnzfAa1i8FXm/rROhq+hnboa2pXs9VKVtHitOVUndM3N+WAFtq4YIGCpv2zM/ng/j7mMIGtNbXG/ceRT58zaIqdXD7nDfj6MrTwo+VggcXv3zVhUWAH2XZijedhQlB85WC/BWkAK1qvBABA7tDF37xjjz6BfI+HQRdK3iRDffqrQtYsTp3E7AWbNWQts6DoHD5AO902fMR/Gu4wi5rhe0reJQvOMYcv/YKELfEXeOuEL/B+h8vDWu2vAf2q3a7arQQOg6NUfJziMwHT4tArwV9ST9+z0fp0W+zVvrPsufRB0bgZCb5S7uVcdvcr5ZBFVEEIKulzs1581eicJlW+E3qAt8u7aE5VgSCpZsgaPAiMgnb/kXr5quyNjeuKEiwGtLcY3teVWpJ33vLpXh3cr7eXtDP6AHDL/8BcuRU9UeV90gAuoJI6qP7f04H8qwYASMHSKuK/h9GYpXb4Zvv67QdmyN0pOJKF65CY7CYoQ9NLnWXjed3xO3D8LYQe1QaDTj0bfnISXTUK077zuPj0FsZBBe/Hgx1u44UXnbvmOpeOzdeZj7/hT0aN8II/u3xtINrtkZJQmnMsSpKn9fDR67bRD2HU3ForWHxHWvPzgK/bo2wS9LduPAiTT079IUUyf0gtZHhU/muGZ/oavHLVP7o1mraHz78SqkJrlm871Uxw6lilNVfv5a3P/UNTi0NxHL58uz/D375gT0GtASf/68FYf3J6H3wFa49d6B0GjV+HrGyiv2euq9+jrmK6mnq02XhwHeOppG7fnnnxfnw8PD8eWXX9b1KtULjWLlci0odIop0qoO0lZISZd/BG1YvqxEWi44yBv5BieS0+zo0ManhvvJnYdCg70rp1K7kA1bzfjh12K8/EQQWreQBxff/8wgpmtb+GMUggLlgI/U0fOh53Pwy/xi3DtZnsKL/p3QUAUWzQ/Bxk1WbN5SKsK0YWEKjBjug44d1OjYJUss16qlXANxca6wVVxczZu8huXLZGefP3RT1etvFMFodOI/7wWIHbpTp+1YvqIU48dp8PJLciBz+DANjp+w4/sfSvDMU3r4cjC/1oWEKjD7zxBs3WTFjq2lovtuSJgCQ4b5oG0HNfp3lWujeXltrFkphyvWr7Fg4zp5eqQKaalyLWz4uxS3T5S/WP/0e8hF1+H98tqY/q5cG2dP27FmRSmuHafB0y/KtTFomAanTtgx58cSPPwka8MTgkKV+Oj3WOzZbML+bSYUFTgRFKpA76F6tGivwcSe8jTX8S3kz4fIBuVhmSInTEYndDV83mRnyJ83ETGX1mll7pf5SD5lxQezY6D28RaPK3UAbtNFg6ffjazs3pudbsf6JcVIOWNFbGMeVV2bDqwvQHG+HeFxPm7h3QrhcRpx/dHtRUjYWiQCvOGxru8QVc9XFRYrD+AW5FzaVDVz300SHXnvfCNebDcyzpixZ7UBvcaE4KZn5B+TOg0OQtpJE9bMzsKER2PcgsR05Z3alCU64QbG+rqFdysExfgiul0QknblInFHtgjwBjSQDxKyFNtQWmKDj2/1bUNRpjxVVmB09QOKarL1u+PIO1OMW77uC6WPQjzu3t/OokHHYIyaJv8gJIV4izJMOLoyDXmJxQhp5B4QJ89SRbqC/Y6CwvMGeKvy1mmh7dgWxg1bYT5wpFqAtyZFK9bBnpmN8MfvhZdKBafFguINW6Fu3BAhk2+s7N7rMBTAtPsAbFk5UEXIBwhQ7RjSuglsDofociudqmocJm9Hru/SFr2axCHXaMLTvy5DmqFQXB+g1UCnVsFkrf65ERkg/5tONxRd0nrcM6A7moSH4M5v58Fqd4jHndSzA/YmpePVBWsqu/dKYeNR7VugYUggkvIK/vXrJyIiGcd8Lw/HfEkiBWZrOu++jPz92pZvvKTHlLrpKgN9Yc83wpZbfEn3yZ63BaUpuWj85q3wVivhMJUib+ke6FrFIPbRayu799pyilCw6QhK0/Lg0+DiY4Z0+aTgW03na1pGClXXxLBsO3J+XAkvpQJRT98E306uGZUuVc5PK0XX1Yj7x4jxG2targjsSl2BwyYPF8vou7aANSUHBct3ImTiILeAKV156oiLbzdctXFp2wB1eCB82zaCcc9JlBw4fd7Qb1VZP6wStRH1gFwbpWm5IrDr378dwm+XA51+3VqgNCUHhmW7EHazVBsc961NygjXeJ4qvPrYnri+fBlHeW0ow+TPGGeJRbyfNf37tecVui17MYaFG2FLy0HUy3fCW60Sj1u4agc0zeMQft+4yu699twCGLcdhjU9F+ro0H/8eunKUUVVGdvLl8f2lKFBUrpXhL+kwG1NKq6XwraXomjpetgzshH+9N3y2J65FMXrtkHdtCFCptxQ2b3XkVcA066DsGXmQBXJsT1PevTWAbjpms4oKrHgsXf+xImk7GrLtGkahcYxoaJr7vqdJ6vdXlxSim0HEjFmYFt0b9uwWoC3xue9bYDoyPvud6vF5bioIAzs3gwrtxzF579uEtdt3nsGjWNCcMPwjvhm3laYy5sE0NWjzyC5IUvP/i3QrY/7986IaPkzpHvf5nj/6yni/LP3/nDRx7z3yRGiI+/Hby4Wl2MahqDv4NZYu+wgvvtErpcdG0+gYZMwjLmpO36auQ4W8/kPSiGiqw8DvB6WkJCA8ePHw263Q6PR4I8//hADupcjJSXlotOpde/eHf8rWjRRQ6f1Eh1Ndx+wYFCf6uGHPQfkEF7ndu47Vp3a+eDvjWbsOWDBmOG+NdzPUrncxZSWluGBZ7PRookKL5R3UZTsT7CibQt15UCupG8POcRzIME9HEj/jjQIMqC/jzhVlZhoR1aWE0FBXmjXTg7ONGmsFF14jcYy5OfX3E2z4nqd78WnJd+ypRS//W7G00/q0aypvAlNSJC/GHfr6j7oInXi3bvPhhMn7OjUiQMynqqNPv19xKmq5EQ7crKdCAzyQuu27qGqPbvOv2OTm+NEbs6lfbmVQsML/jDj4Sf0aFxeG0fLa6PjOV2cpU68B/fZcPqkHe07sjY8VRtd+/mKU1XpSVbkZTvgH+SNZm3kbbYUnNVovWAxl+H4IQs69ar+eXPikLxdr7jPhUhh3F++zMeI6/3Rqbf8WEmnSkVX3jad5U7NFdp11YgA7+mjpQzw1rK89NLKrrnnoyu/raRQ/tE3spEWGl9vWEqcKDbUPO240SD/u9dcwo/DR7YXYtP8XIx/pAGim8i1kHRUDnk26+QeKpY68Z4+UIK0U+YaA8d05VQEbX18z7+r5KOXP0vMhfL7LQVnVRoFbBYHMhMKRKj3XJlH5JBcRKuLD/JLYdxt351Au7FxaNRDfqzc08WiK29MB/eB4phOISLAm328kAHeOuYskWtH4uVz6T/UepVPg+covngQwZaZjcIV6+Dbqys0LZvK12Vki+lkfZq4d+j2adJIBHitKekM8HqASqFA98bn75gYExwgThXB3cRcgwjtSiHbtjER2Hmm+nTpbRtEiL9H0qv/SHCuRqFBuGdANyzYk4AdZ+SxgqbhIVArldif5D4Dwd7ENBHgbRUdzgAvEdEVwjHfy8cxX5Jom0QC0tBsGWCXph8Pqz5rlXT9ud16L6TM4YSzpPSS72NJzUP2H1sRNKQ9/Do0kq9LyUWZ3QHflu4dN31bx4gAr/lMFgO8tUwTH1UZnJKmpleFVg/NS9dLvDXV3+eC5TuQM2t5ZXhX36X5P14H0+GzKFq3HyETB0LdQN63Kk3MFH+1Ldz3AaTOvpaTqShNzYG2mXvd0JWlaRxVud24nNo4H6/yZe2FJRddtuTQWRSu3Y/QmwfAJ0YOXpaeragN9/df6uhrOZEmgrza5u6zdtGV5VN1u1FcAmVNtVHsXhtScNbLR4WyUhtKz6RB26ZxtftI11c+/kVY03NQsGgT/AZ0gq6t/FjW1PLxm3M6fGtaNJQDvEkZDPDWMaexytheeeddqaOzMjIU9owcOIw1bxcqrvcuH+O7ECmMW7hsPXz7dIGmVcXYXlbNY3vNGokArzUlgwFeD3r4lv6YNLorikV4dx6OnZUbRJ0rIkT+vmqx2uA8T3dPo6m0srPuxXRuHYtrB7QVodyk9HxxXfOG8j7lwRPuY3sHjqejbbNoxMeE4Mhp+XOHrj5tO51/Rs2QMD9xuhQdujbC8LGdRCg3JTFXXNekhdwc6shB9/GDhH3JaNUuFg0bh+F4gvy5RUT1AwO8HnT27FkMHz4cBoMBCoUCv/76K/r373/ZjxcT8/9r51+t9sKoob6Yt9iIufON1QZzk1Js2LpbHpQdN9I92DJ+pF4M5v62yIhXnwoWXRIqOJ1l+P0v+cfy8aMuHoh5++N8nDhjw9o/G8DHx/U40rmSc6Zbr5i+TQqOUe378it5B+m2W3WiXiRKpReuGaHBvD/N2LS5FKNGVv+CvGGT/OW500WClNJA/nMvFKJZMyUeedhVKxVvr+mc6foqLvPtr3uzvpZrY+IkV20sWHH+nd3PPizG5x8Zcf3NWrz5/sWDVtbSMkx7sRBNmipxz0PVa8PM2rhq/f6NPOXN6JsDoSqvDelvj0G+2LDMiLV/FVUL8Gal2ZCw1yzO9x1x4c+NsrIyzHgpC75+3rj/JVfNVbz3lnM+NypqhbVR+4Ii5G1+xhkLTMV26PzcvxbbbU4kHpG3HWEx8mCdQumFLkODsWVRLhK2FqLr8OpH3B/eIndJbNz+wrVhszrxw2uJiG6iwZj7XB03K977UrN7bVRcZm3UPr9wOUydl2gUHXU1fu4Hfkgh2sxjcuAtsLzzrkLljSb9I3FsVRoSlqdUC/AWppuQekAedGsxOPqi240Vb+wXIeEhT7umha14761m9xkDbBWXWRx1rmTXfvHXS6P5R4Pqpcfl6fUuFrKVaiN/znwxVWPgDddWv/2cbgtlVvkgJO6L1L6eb5y/w+Jb1w/H+C5t8PHqLfhqnTylusTmcGLj8bO4pl1zjO7QslqANzrQDx3j5O3FmhqmYDzXtHFDUFxaiveXuabOKyufY0urdt+OVVyWaoqqkP5/1Mf/J/VxnYn+x3DM99/hmC9JVEF6+LaORUlCCowHzkInBXqrkEK0JYeTxXlts4vPWiEp2nkCTuk7spd0nwuHraTvRamfL4PCV4PoqUMrr694iyumTa/gtJR/92YN1DplkJ8IxZqPJsF06LQc2jynNsxHEsV5TTP3UGTByl3I/m6ZK7zbtcU/fn6nzY6srxdDHROG4PH9XDdU1MY5+2HOUu6HeYoySA9tqziYjySj5MCZGmvDlJBUY21c6P02H5W3NerokIsumzlzKdQxoQidULU2vGrcR6/cjrA0ap0y0A+aFnGwHEuC6fAZ+MRH17DdOCvO+zSVv3d5KZXQdWqOku0JKN5ysFqA15ZTAMsJOSTl2631RT9Tcr75C946H4RMvubitVG+3eBnSt0r2XlA/PXS+riN7em6tkPR4rWwHDkF/+FV/r2XsyTI4zbqCxzYXTm299N8eOs0CJw4usotFbXh/n2j4jIrw3MevLkfbhvTTYR3H31nHo6eqTm8K8kp7+AdoNciNjIQKZkFNXbplaTnyAf0n49KqcBzdw3F2dQ8/LhoR+X1FWN3Wp9zxvY08u9ZHNu7Oj14y8zz3nbbfQMx+b5BWL5gDz5646+LPpZKpcAjL45B0pls/DZL7sIsqXjrNVr32tCUH7jI2vgfGPOV1Nf1psvCebs9JD09HUOHDhV/pR33WbNm4brrrqvr1ap3nns4UOy//PBbEVasdR3lZjI5cc9T2XA4gAmjfdGymXsQ846JfoiOVODEaRtefU8OT1SQLkvXx0QrcfuNFz7K5chxK97/3ICpk/zRv5d710SpA8TRkzZs2SmHuiTfzC685C4PdGmOn7ChuNh90NxuL8PHnxrx82wT4hsp8Pij7oPyjz6ih0oFzPnFhNVr5AH/Cl98acTOnTYoFMCdd1x4SusZHxtx5qwDH7wfUBkClbQr7+g6f4EZZrP8IZqX78Sy5RZIB2g2b85jJTzh1AkbjDXUxlefGfH7HBPiGilw3yO107Xyi0+MSDrrwPT33GujdXkn6CULzbBY5Now5DuxZoUFUmO+Js1YG56QeLIUJcXugTeHvQxzPs/DkrmFaNBQhVsfcg9i3nx/sPi8WTGvCDs3uD5vLGYnPnguC04H0O8aPeKaXDj4v+z3IhzYYcaDL4fBv0q3noZNfURQePMqI4oKHJWP/fdCOfzZtDU/N2pb+wGB8NF5w2pxYtbLZ2EpcdWI3erEL28nIy/dCoXKC91GuOpjzP3R4rr1f+Rg3zo5AF5h6bfpOLGnGN4KYOitctfE81n0eRqyEi24683GUKpdX8kbtZG7Rm39K0+sm6Q434bdq/Kh8vFCg6bu3z/oymvSJwIqrQJ2iwPLp++D1WR3C++u+c8hFGWY4a30Qothrh+Aet3VXIymHlyUjNNbXAN7NrMdy6btRZmjDC2GRiMk/sLfNw8sSELy7lwMfaYdtAGubUxoE38o1N44sTYd5kJr5WMnLJV/PIhoyal7a5vUydZ0IAFl0k5HFWVOJ4xbdqJw0Qpx2W9wH3hJXy7LFa5YW2N3Xaljb/6vC2FNSoWXVgNdl/YXfP6SLTtRevIMgm4cA4Wv63urKipCOmoNpv2H4SjvAuy0WlGyY598e+ylBRzI877ZsEuEi8Z3boO+zVwdGTQqJd6YMBxKhTdWHj6Jsznunzfnur5rW9H9972lG1BodnUCPJ2dj1KbHUNbN0VA+fSf0mOP6dhKnD96CZ19iYjowjjme2VwzJckEbfIgRipC27JsTS3Trrp362BNbNATDsfPFT+3mzNLoRh3SE4rdVnyCncdhwpny4T54MGtBUB4QvJX7VfBISl8K7Sz1UDPrFh8FIpULj9OOzF5srwrmH9YXFe2/jC+/50ZYTcOFD8zV+wGebyAJ1E2jfL+XElbFkGMd29/6BOlbcVrN6N7G+X/qvwrnjOeRtgy8hHxP1j4aVyjeVWdOAs2nSwMsTrKCqBccdReKmVIvBLtS/spgHib+78zTAfT3XbbmT9sKq8NtQIHNJRXG8vKIFhxS44yjsiVmXLK0L6Rwtgzy+GKjwQvh2aXPC5c3/fCGtGHqIeHCO2ExUqgsSFGw9V1obUQbx4+zFRG9J2hWpf0PWDxN+ChRthOem+3cibvQL2bIMIafoN6Oy6z3X9RYi2eP0+mPafdAvY5ny1QDo6CL7dW1d24j6f4nV7YDmaiJDJI6HQu8ZvpO2CtB0p2XUEjvJOr9JjGzfLoVGfRhfv7Ev/jjU5Hab9R2oe29u0C4XzV4rLfkP6iM+PCtJlb50WlkPHUbzeFa6UlOw4ANMO+aB+vyG9L/j8JZt2ofT4WQTddK1bbaiiw+WxvX0JbrVRsr18bK/8AG+qXffd2Ae3j+2OoksI70oOncxAdp4c4n3hnuEIrPIdUtq3mTymO9o3l9+7VVuPXfCx7hrfE7GRQXjn21WwO1y/dR9PlMfuRvRpCZ/y7yEBfloM7NZMdP49m5b3L14x1QeT7hmABnHBIuxrt7u2XaeOZYi/g0e2h9pHrg3/QB36DG6FUosNSWdy6mydiejyMDnkAbm5uRg2bBjOnDkjLn/66ae4/fbb8f/d3oMWPPyC64PjdKK8I/v17CIsXeMaqP1zVhSiIuRS7dxegw9eC8VT03Jx7W0ZGNBLi7BQBTbvMCMjyyGmOPvyverT0+l03vj1q0hcc3M63vnEgMWrStCmpRoJx6w4fMwKX50Xfvs6Elrt+TPt0lEq9z+TjeBABd57pfqRty8+HiTWacRN6Rg6QIesbDt27itF03gVbhnHqa6vlNlzTJg924R27VWIilSg1FqGvXttyMlxivDub3ODxftdVbOmShG6feKpQtw+xYAOHVSIjVHg2HEbTp1yiPDuu28HoFUr9yOUqjp+3CbCvpNv06F7N/cfC+LjlRh/nQYLFlkwcEiOCPTu2m1Fbq4TjzzsW219qHb8/otJBHXbtFMhPFIBm7UMB/bZkJvjFOHdWXOq18aVcPK4DbNmGjHxVh06n1MbDRspMfo6DZYusmDMkBy0bqvC3t1W5OU6ce9DrA1PWTq3UAR1m7f1QWikElZrGY7us8CQ6xDh3fd/joH2nPeieVsN7n8xDF++lYMX70pD+x5aBIUocGiXGXnZDsQ2VuGJNy/8I01+jh3fvJuDbgN0GHKd+9SPWl9v3DA1CHO/zMfUEYlo00WLUwmlyEixYfAYPzRodOnTutHl8Q9WYcrr8fj2hTPYuTwfR3cUoXE7veiye/awEYYsG7y8gckvN0R4nKt7e3QTLe56Ix7fvngGM+47gfi2vgiN8UHqCZPo5iuFd++YFo/YFuc/KCT1pAlLv83AoJvD0byL+w/JEQ016HltCLYvycMLow6iURsdTuw1oijPLjr1+uhcA4dUO3TBPrjm5Y5Y+tpe0VE3eVcOotoGwVvpjcwEA4qzLaI2hj3XAUExrml6I1sFYshT7fD3B4fw+0NbEdclFL7BPkjZlwdjjgXBjfTicS+kJM+CdTMOo3GfCLQZ5d6xQa1Tovvkptj23Ql8M2ENYjqGIOtoAQrSTGg9MgbBcfy+WdvsefnInfmTGLBXxTWAwk8Pp9kCW3omHPlyhwVdt44IGO3q2CUpXLgChX+tgqpBJJShIfBSeMNRUCgCwVInDSm8G3rPbVD4nz9Y4igqRsH8ZdC0aQHf7q4fpSum8vMf2g9FK9Yh4/X/wqdJI1hT0uDIzRfrowrn9ItXKylA+/7yDXh+9EDMvGM8diWmIt9oQpdGDRDur8eZnHy8vnDNBR8jRK/D09f0w6bjZ7H0wHG320xWG37cshf3DuyOvx67A3uT09E6OhyxwQFYcuAYkvMv3P2DiIgujGO+NeOYL10uvw7xiLxtADJnb8Cp53+Crnk0VIG+MJ/OFGFdKfjW8JlxlWFch9GM5A//gveXK0SQVhXiB2epHZaUXFjLpx3Wt2+IBg+OvODz2gxGZPywFn6dGyNoYFu32xRaNcLG9RCh4uMPfQXfVrHy+mQVILB/G/hEV5+Zh648XfvGCLl5MPJ+XYuUV2ZB07QBlIF6WM5mwJ5dAC+1CpGP3yCuk0jXZ3+9RHSsUkUEwbj9iDjVJPLh8ed93tKUbOQv2oKAYV1EF+Cq1FEh8OvbDsWbDyHpic/h0zgK5mPJcBSWiE693hqO7XmCb/vGCJs0CDm/rEPiS99D26y8Ns5kwCZqQ4noJ6+vrA2n1YbMr5Yh67uV8ImPFEFdqU7suUXiPlJnVmWwH2Kevwne6vP/hF6anI28hVsQOLwLdK3OrY1g+Pdri6JNh3HmsS9EoNd0LEXURsj1fVkbHqJr1wTBE4cg//e/kTbtW2iaxEARqEfp2XTYc+TtRsQjN1bWhkTq1Bty2zXI+3k5Mt77GZpWjaDw94XleBIchmKookMRdvfYCz6vvcCIvDmroO3QDH59O1QbvwkY1RsFizYi5elPoWkeh9JEaTtmgL53O6giL9z1mf49e64BuZ//LI/tNWwAhb8eTpMZtrQs19hejw4IGDvE7X4KP1+E3D8JuZ/+CMPPC2D8eyuUUeGw5+TBlpwulvEfMxja9i3P+9yOwmIU/LEcmrbN4duzY/WxveF9UbRsPTJenQGfpg1hTUqXx/Z6dIAqgmN7ta1f5ya4c3xPcT41swA3DKt5HL+g2IJPf5Fnv3I4nHj9y+X44Onx6NwqFvNmTEXCqQyYLFY0jQsTgVzJDwu348Bx18Fp54pvECK6/i5cewAHT8j1VCE1qwArtxzFiD6t8Mt/7sDxs9kiFBwc4IsfFu2ApbT6gWx05TVtGYWHX3B1zY6KkfcBRl/fFT36N6+8fvpTvyI/t3ojj8vVsHEYbryjD5b9uQdHDrgORpGkp+Rj3fKDGDSyPb7+4yER6G3dIQ5BIXr8OmujCPESUf3CAG8tKywsxIgRI3DkiDw48O677+Khhx6q69W6KhQZndixt/pRrqnpdnGqIAU0q3r8vkC0baXGhzMLsGu/RUxZFtdAiecf8cfzjwbBT1/zgGyf7lrs+zsWb84w4O9NJsxfakRYiAKTb/TDK08Go0mj84c3JV//XIQtuyz49etIBAZUD89cM9gXC3+Mwpsf5mPluhLotN64aZxeDD4zpHflDBmsQUqqA4cO2XDwoE10O23SWIn77/XFnVN8odXWPJHIxBt1aN5Mic++KMGOnVYcOWJDUJA3xlyrwQP3+aJTJ/UFB/Kfea4QIcHeeOmFmoMVH80IRIMGxaIL76rVFkRHK/DKS3544H5XsIdq14DBGqSnOnDksA2HD8m1Ed9YiSn3+OLWKb7QaK78JDNSbbz2fCGCgr3x1PM118bb/w1EVHSx6MK7bo0FkVEKPP2iH+66j7XhKT0G+SIzzYZTh0tx/FCpqI2YxirceHcQxt0eCB9NzdtoKWAb30KNP74z4NgBCyymMoRHK3HLAwGY9EAwdOf5vKnwxRs5sNnK8PgbNQd9pz4dAr8AbxEu3rrGiKBQJW6+LwhTnuBgjKf0uS4Usc21WPljJo7vKsaRbYViNpLAcBV6jw3BsMmRaNKh+g+y/SaEiU64S79Jx/HdxUg+boI+UInuI4Mx8q6oGu9Tdbvx/Stn4R+kxMSna55S6953GyMkSo1ti/Owd20BQiLVuOnZWIyayi4MntL22jiENQvArtmnkLI3D4k7cqS56KEP04hgbddJjRHdrvoPtVLANqyZP3b+dArph/NhMzvgH6lFr6nNxcnH98LfN1e/f0h0+R3xkvsAf4UBj7SGxl+FffMScXJ9hggI97yzGfo/dOGp++jKUMdEw29wX1iTU2HPzIH1dKLYZkiD/drO7aDv1RXadnJn06qCbh6H0lNnRajWcvwUyiylYmBeFR0JTevm8BvQ64LhXYnh979Ed5DgW2r+cTngumvEjw/GTTtgPpAgHs9/xEAEjBl+xV4/1Y6ftuzDycw8TOnbGe1iI6FVqZBRWIyv1+8UJymEeyHPjx4AlcIbry9aW+PtH63agiKzBRO7t8fgVo2RZzSJzr+frdlaS6+IiOj/B475nh/HfOnfiLipL3TNopHz106YTqTDfDJdhKuChrRH+PW9oIl1jZmoQv0Rdn0vmE9moDQjXwRrpfCdwl8H/25NETigLQL7tYaX94XHBNO/XS3uF3OeoG/k5IFQ6DXIW7EPhTtOiFCx9LyRt8qdP8kzQm4YIIK7hqXbYTmZCstpuTb8B3VE8Li+bh0xnSWWyulmrWm54nQ+5wvwSuM3WTP/EvUUeuuwmu/70DgoQwNQvOkgjLuPQxXij6DJwxA0ts+/fr106UJv7A9NswbIX7wdlhNpMJ9KE7URMLgjQsb3gU+Ma7uhDPBF+JThMB1JEiFca2qO6OKt8NVA2zwG+m7NRShXoTt/h3WpNjK+XAKlvy/CJ7sfwFsh+pFxUIUGiC68xbuk2ghAyO1DETzuwt056coKmjAQPk1iULh8KyynUuE8LdeG34BOCBzbr8ZOuoGje0MdF4GCJVtQejoVZaU2KEMC4HddfwSN6y+6fV9I3k/LxGdK2NQxNd4efPNQeOu1KFqzCyV7jkERoBfrEjxx8BV73XR+6tgo+A3rA2tiGuyZ2bCeqjK216Ud9H27nDeEq23TDJHTHkPR0nWwHD0F8/4joh407VrAb2gfaNu6Qnw1Mfy6RB7bmzyuxtsDJoyAt68Wxg07xWNL6+Q/cgACxtX8GURXlr/e1cSldZNIcapJRk5hZYBXsudICm59/kfcMqoLurWJQ4cWDaBQeMNQZML6nScxf80B7DycdMHnfuHuYWL5z+duqvH2N2auQFZesQjx9uvSRJyX1mHOkt2X/Xrpn9H5+qBVu+q/54VFBohTBVWV2RquhMdeHotCgwnffbq6xts/eG0hsjMLRRfengNaICezCN98tArzftpyRdeDiDzDq0za06BaYTKZMHz4cGzZIm8gX3rpJbz55psee/7U1FTExsofJEl7Gonpwoiqyna4ul4QVVXgmp2DyE26/cIBI/r/K80uH01MdK6jZk7xRTWbs61XXa8CXaV8k7jvSu5sRQU49fl0cT4lJQUxMTFXfNykf+vHoVG7z5pQH1isRdh45KMr/v+GiM6PY750teu8+6a6XgW6SplL2fmTaqZQ8AcBqpm1lN8zqGa2kgsfJEX/f0Wt4XaDahZwrKiuV4Gu1rHNhCs7tvm/MOYr4bjv/y88RLyWWK1WjB8/vnIg97HHHvPoQC4RERERERERERERXTkc8yUiIiIiIiIiIqIriYe/1JJbbrkFq1atEucHDx6MqVOn4vDhw+ddXq1Wo3nzC0+tQERERERERERERER1g2O+REREREREREREdCUxwFtL5s+fX3l+7dq1aN++/QWXb9iwIRITEz2wZkRERERERERERET0T3HMl4iIiIiIiIiIiK4kBniJiIiIiIiIiOj/Na+yMnGqb+rjOhMRERERERERERHVtvo65iupr+tNl4cB3lpSxn9IRERERERERERERP8zOOZLREREREREREREV5L3FX00IiIiIiIiIiIiIiIiIiIiIiIiIiIiuiAGeImIiIiIiIiIiIiIiIiIiIiIiIiIiDxI6cknIyIiIiIiIiIiuuqUlcmn+qY+rjMRERERERERERFRbauvY76S+rredFnYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIAZ4iYiIiIiIiIiIiIiIiIiIiIiIiIiIPEjpyScjIiIiIiIiIiK6+pQBZWWof+rjOhMRERERERERERHVtvo65iupr+tNl4MdeImIiIiIiIiIiIiIiIiIiIiIiIiIiDyIAV4iIiIiIiIiIiIiIiIiIiIiIiIiIiIPYoCXiIiIiIiIiIiIiIiIiIiIiIiIiIjIg5SefDIiIiIiIiIiIqKrTlmZfKpv6uM6ExEREREREREREdW2+jrmK6mv602XhR14iYiIiIiIiIiIiIiIiIiIiIiIiIiIPIgBXiIiIiIiIiIiIiIiIiIiIiIiIiIiIg9igJeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDlJ58MiIiIiIiIiIioquOs/xU39THdSYiIiIiIiIiIiKqbfV1zBf1eL3psrADLxERERERERERERERERERERERERERkQcxwEtERERERERERERERERERERERERERORBDPASERERERERERERERERERERERERERF5kNKTT0ZERERERERERHS18SorE6f6pj6uMxEREREREREREVFtq69jvpL6ut50ediBl4iIiIiIiIiIiIiIiIiIiIiIiIiIyIMY4CUiIiIiIiIiIiIiIiIiIiIiIiIiIvIgpSefjIiIiIiIiIiI6KojTUlWH6clq4/rTERERERERERERFTb6uuYr6S+rjddFnbgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iAGeImIiIiIiIiIiIiIiIiIiIiIiIiIiDyIAV4iIiIiIiIiIiIiIiIiIiIiIiIiIiIPUnryyYiIiIiIiIiIiK46zjL5VN/Ux3UmIiIiIiIiIiIiqm31dcxXUl/Xmy4LO/ASERERERERERERERERERERERERERF5EAO8REREREREREREREREREREREREREREHsQALxERERERERERERERERERERERERERkQcpPflkREREREREREREV50y6ST9p56ph6tMREREREREREREVOvq65ivpJ6uNl0eduAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIAZ4iYiIiIiIiIiIiIiIiIiIiIiIiIiIPIgBXiIiIiIiIiIiIiIiIiIiIiIiIiIiIg9SevLJiIiIiIiIiIiIrj5lQFkZ6p/6uM5EREREREREREREta2+jvlK6ut60+VgB14iIiIiIiIiIiIiIiIiIiIiIiIiIiIPYoCXiIiIiIiIiIiIiIiIiIiIiIiIiIjIgxjgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iClJ5+MiIiIiIiIiIjoqlNWJp/qm/q4zkRERERERERERES1rb6O+Urq63rTZWEHXiIiIiIiIiIiIiIiIiIiIiIiIiIiIg9igJeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIKUnn4yIiIiIiIiIiOiq4yyTT/VNfVxnIiIiIiIiIiIiotpWX8d8JfV1vemysAMvERERERERERERERERERERERERERGRBzHAS0RERERERERERERERERERERERERE5EEM8BIREREREREREREREREREREREREREXmQ0pNPRkREREREREREdNUpc8qn+qY+rjMRERERERERERFRbauvY76S+rredFnYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiD2IH3/4lchwlqh6KuV4OuMjkOZvipZpkOfV2vAl2lcuz+db0KdJU6ZYmo61Wgq1SaJbCuV4GuUooSfhelminMdb0GdLVxWup6DYiIrk6D94yHKon76eSurMyrrleBrlJlZXW9BnS1cjq53aCa2Uyqul4FukopChgzoZqpStgxkmrmZSqt61Wgq5CXjXVBJOEvpkRERERERERERERERERERERERERERB7EQ6OIiIiIiIiIiOj/N6klXX1sS1cf15mIiIiIiIiIiIiottXXMV9JfV1vuizswEtERERERERERERERERERERERERERORBDPASERERERERERERERERERERERERERF5EAO8REREREREREREREREREREREREREREHqT05JMRERERERERERFddZxl8qm+qY/rTERERERERERERFTb6uuYr6S+rjddFnbgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iAGeImIiIiIiIiIiIiIiIiIiIiIiIiIiDxI6cknIyIiIiIiIiIiuuqUlcmn+qY+rjMRERERERERERFRbauvY76S+rredFnYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIAZ4iYiIiIiIiIiIiIiIiIiIiIiIiIiIPEjpyScjIiIiIiIiIiK6KpWV1fUaEBEREREREREREdGVwjFfqgfYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIAZ4iYiIiIiIiIiIiIiIiIiIiIiIiIiIPEjpyScjIiIiIiIiIiK66pSVyaf6pj6uMxEREREREREREVFtq69jvpL6ut50WdiBl4iIiIiIiIiIiIiIiIiIiIiIiIiIyIMY4CUiIiIiIiIiIiIiIiIiIiIiIiIiIvIgBniJiIiIiIiIiIiIiIiIiIiIiIiIiIg8SOnJJyMiIiIiIiIiIrrqOJ2AlxP1cr2JiIiIiIiIiIiI6H9jzFfCcd//V9iBl4iIiIiIiIiIiIiIiIiIiIiIiIiIyIMY4CUiIiIiIiIiIiIiIiIiIiIiIiIiIvIgBniJiIiIiIiIiIiIiIiIiIiIiIiIiIg8SOnJJyMiIiIiIiIiIrrqlJXJp/qmPq4zERERERERERERUW2rr2O+kvq63nRZ2IGXiIiIiIiIiIiIiIiIiIiIiIiIiIjIgxjgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iAGeImIiIiIiIiIiIiIiIiIiIiIiIiIiDxI6cknIyIiIiIiIiIiuuqUlcmn+qY+rjMRERERERERERFRbauvY76S+rredFnYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIAZ4iYiIiIiIiIiIiIiIiIiIiIiIiIiIPEjpyScjIiIiIiIiIiK66jjLAK8y1Mv1JiIiIiIiIiIiIqL/jTFfCcd9/19hB14iIiIiIiIiIiIiIiIiIiIiIiIiIiIPYoCXiIiIiIiIiIiIiIiIiIiIiIiIiIjIgxjgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iClJ5+MiIiIiIiIiIjoalNW5hSn+qY+rjMRERERERERERFRbauvY76S+rredHnYgZeIiIiIiIiIiIiIiIiIiIiIiIiIiMiDGOAlIiIiIiIiIiIiIiIiIiIiIiIiIiLyIKUnn4yIiIiIiIiIiOiqUwbAKf2nnqmHq0xERERERERERERU6+rrmK+knq42XR524CUiIiIiIiIiIiIiIiIiIiIiIiIiIvIgBniJiIiIiIiIiIiIiIiIiIiIiIiIiIg8iAFeIiIiIiIiIiIiIiIiIiIiIiIiIiIiD1J68smIiIiIiIiIiIiuOmVl8qm+qY/rTERERERERERERFTb6uuYr6S+rjddFnbgJSIiIiIiIiIiIiIiIiIiIiIiIiIi8iAGeImIiIiIiIiIiIiIiIiIiIiIiIiIiDyIAV4iIiIiIiIiIiIiIiIiIiIiIiIiIiIPUnryyYiIiIiIiIiIiK46Tqf0H9TP9SYiIiIiIiIiIiKi/4kxXwnHff9fYYC3FmVnZ2Pnzp3itGvXLnHKy8sTt91xxx344Ycf6noVr2pp6Q58/rkRa9eXIiPDAV9fL7Rvr8Ldd/li6BDNee/ndJZh3p9mcUo4YofR6ERgoDeaNVXi2tEaTLnD1215k8mJN94qxpKlFhQXO9G6lQovvuCHvn18anz81WssuH2KAc8/54fHHtFf8ddNF5eZbsesL43YvN6CrEypNrzRup0Kk6bo0b+G2ti0zoI1y804fsSG7EwHCgudUKm8ENtQib6DfHD73XoEBSuq3U+qjRlvF2H1cjOMxU40b6XCY88GoMd5amPD32Y8clc+HnnGH/c87Fcrr50uLDvdht+/yseuDSXIzbRD6+uNZm19MO6OIPQYfP5/r3s3l+DP7ww4ftACi8mJ8AYq9LtGj5sfCBGPcS6HvQw/f5KHVX8WojDPgQaNVLjt0VD0H1Xz+376iAUPj0vC8BsC8MTbkVf0NdOlyU0vxZJvMnF4a5E4jzIgMFyFll39MPLOSDRspTvvZ8rmhXnYvCgPycdMMBsd0AcqEd1Eg+4jgjHs1nC35S0mB+a+n4qdK/NhLnYgrqUONz0Vgza9/Gt8/L3rCvDf+05i4hMNcN0D0bXy2unCCjNM2Pr9KZzZloPCTDPKygC/UA3iugSj5+1NENkiwH35TDNObcpCxpFCZBwpQPapYjhsTnQaH4cxr3c87/NYTXasmXEER1enw2K0I6K5P4Y81grxPcJqXP7Ehkz8+shODHqkJfrd0/yKv266MGN6MeaPn3dJy46YORIRneRt+/5v9uHgt/svuPx1v41HQKNAt+ucdicOfLsfp5eehMVggX+cP9pP7YhGQ+JrfIz8E3lYOmUxml7bDL1e7HPJr4tqx3P9+uO+bt3E+f9u2YzPd+yotkyARoN7u3bFsCZNERPgj1K7A8dzc/HroYNYePRojY+rVSrxfP8BGNmsGfx8fHA0Jwf/2bwJ21JSalx+cHxjfDt+PD7YvAlf7Nx5hV8lXYrRnVuid8uGaBEdhlB/X/jrfGCx2pGYbcDfh07hl037Ybba3O5zaMYTl/TYL85ZgcW7XbWiVSvx5Jh+GNahGfQaHxxPz8HHS7Zg56ma66N/63h8fs84fLx0M75ds+tfvlIiov/fOOZ7ZZTZHDCs2o3iLQkoTc1BWakNCj8dfBpGIGBQB/j3bVu5rHHvSRRvO4rSxEzY8orhNJrhpVRAFRkEfedmCBrbC0r/6vv1TosV2T+tFvd1mizwaRSJsNuGwLddzd+zjbtPIPXtuQidNBihN/Sr1ddP51dms6NAqo2t1WvDf1BH+PeRa6PM6YTlRCpK9p2C6fBZlKbmwmkuhULnA5/4KAQM6gi/fu3g5eVVY23k/CzVxpHK2gi9VaqNxjWuk3H3caS9I9dGyPX9a/3/AZ2/NgpXy7VhlWrDKteGOi4c/gM7wa9qbZxMham8NqxpOaI2vHUa8V77D+oEv77nr43c2atg3C7VRinUDSMQOmkodOerjT3HkfHuLwi5ZQiCJ7A26gq3G3SuvO9+R8mWvRdcJvarN+ClUtV4m2lfAko27UbpmRQ4S8xi+6EMD4G2XXMEjB3qtmyZw4HCRX+jZMseOIqNUEWEImDsEOi6ta/xsa3J6ch84zP49umKkCkT/sWrpCuFY3ukUHijY5sY9Ogcj45tYxETFQStRoXCYguOnszAXysOYNueM5f0WONGdsRT9w8T55esPoj3PltZbRmNjwoPTBmAgb2bw1fng9OJ2fjqp03Yeyi5xsfs3bUx3nvlenz980b8PK96fVLtiokPRec+zdGsTQM0bdMAcY3DoFAq8ONHqzB35toa7xMaGYDuA1qI5aX7NWwWCbVaiRV/7MJHr/x53ufy0apw99Oj0HdEW/j6aXDmWAa+/3AlDuw4XePy3Qe2xPSZU/D9jBX47av1V+w1E5HnMcBbiyIiIup6Feqt/futmHRbPgwFZYiI8MagQT4wGJzYutWKDRusePJxPZ55unpQrqjIiTvuNGD7Div8/LzQtYsaAQFeyMh04nCCDcXGsmoB3kcfL8TSZRa0bKFEl84qbNhYiltuzcfCP0PQpYvabdmSEieef7EQrVoq8eD97o9DnnH4gBUP3J6LwoIyhIV7o+9ADQoMTuzcVoqtG0tx32N+eOhJ96DcsoUmLF1oRlwjBZq2UCEo2BuFBU4c2m/Fd5/bsOA3E76dG4qmzd131F9+0oA1yy1o2kKJ9p3U2L6pVDz393+EoUNn99owlTjx1suFaNZSiSn3MdhdF44fMOPFO1NRXOBEcLgCXQf4otjgwIHtJuzZZMJtj4Tg9idCq93vz+/y8dVbOZDG5Np20yIoVInDu0yY+0U+Nq0wYsbvsQgIdv+4/O79HMz71oCoOBW6D/QVz/Hmw+l4+bPoaiFeh6MMM17IQkCQAvc8X3NQj2rXqQNGvDPlOCwlTgRFqNCubwC8vYGko2ZsWpiHrUvy8dB/G6PHyGC3+5mK7fjv/adwbFcxtHoFmnXSw9dfgfwsKxKPyGHecwO8M587i10rDYhprkXTjnoc3lKE96aewCu/tESzju7bBkuJAz9MS0JsCy1G381gd11IPWjA7Pu2wVpih1+4Bo17hcNbAWQeK8LBxak4vDwNE97tgtbDXeFqKYC76j8J//i5Fr28D0fXZCC8qR8atA/Gme05mPPAdkz5vg9iOgRXC/sue+sQwpv5ofeUplfktdI/o9Sp0GT0+f/fF5wtQN6RXKh0KgS3DKl2e1CzYAQ3d39fK6j07t8hJHs/340jvyRA38APMX1ikLknExtfXA+vt73QcEgjt2WdDie2vb0VmkANujzS9bJeH105naOicXeXLnCWlcG7hh/4JLEBAZhzw42ICQhAvtmMrcnJ0CiV6BgVjQ9jRqF3XByeXVl9IPeDa0ZiZPPmOJ6bg30ZGejbsCF+mHA9bvr9N+zPyHBbVqdSYfqQITiWk4Ovd++utddLFzaxT3t0bBSNM9n5OJqajSKTBcF+OnRoFIV2DSMxvkcb3PnZH8gpKqm8z6Kd5/9MiQzyQ49mceKAot2nU91ue3PSNRjeoRlOpufiYGImeraIw8z7x2PKp7/jYFKm27JatQov3zAYJ9Jz8MPaPbXwyomI/n/hmO+/Z8stQsobs2FNyYHCXwdtyzh4+6hgzy2C6UiSOF81wFu08ZA4qaKC4RMXDmWADo5iM8wn05A3fzMK/t6HuNdvF7dVlfHJQhRvPyquVzWPQcmB00iZPhsN37wT2hYxbss6zVZkfr0UPg3DETKut8f+X5A7W14hUqfPFuFMURst4uCtUYmakWrDS6qN8iCeLcuA5JdmifPeei00TaKh0GvE9aaDZ8SpaPNhNHhmIrxU7mN7GZ8ugHH7URH81JbXRuobsxEn1UbzWLdlpXBf1jdLxbLB1/EAyrqsjfQ3f5Zrw0/absTCy0cNe14hzEel7Ya6MsAr1UDqy9+51Ya3r1Zcbz50RpyMWw4h6qmbqtVG1mcLYNxxBOrYcGiaxYg6SnvrZ8RMv6vG2sgRtRGBoLGsjbrC7QZdiE/ThlBGVB+7E7yqN28ps9uR9/VvMO0+BC+1CuomcVD46+EoLIYtPRvFa7ZWC/AWzFuB4pWboAwLhrZ9S1iOnUbul78g1MsLuq7t3B/f6UT+D/PhrfdF0MSRV/bF0mXh2B5JpNDuR9MnivN5+UYcOpoGc6kNjWJC0Ld7U3FatOIAPvhy1QUfJyoiAA/cMUCM5Xl711xPkpceH4mBvVvgdGIOEo6no1vHRvjvtBvw0AtzceSEe21IQeIn7x8mlv1lAQ/Krwujb+6J8Xf0/Uf36Tu8Le5/ccw/fq6n352IfiPa4eyJTBw7kIJOvZvirW/vwtO3zRSXq9Lo1Hj41XE4ezwD877b+I+fi4iuLgzwekhcXBxatmyJVasu/KFOgMVShqn3GkR497qxGsz4byC0Wi9XsHdyPj78yIju3dUY0N/VCbWsrAx3TpXDu5Nv0+G1V/xEZ9YKVmsZjhx173YkhXql8G6/vmrMnRMMhcILmzaXYuLN+fjoEyN+/tE9ePHOe8XIzHTi6y+DRAdX8qxSSxmevD9fhHevGaPF9A+CoNF4VQZ7H7wjD199XIzO3dTo1c/VifeOe/V46qUAhIYrqoVuX32mAKuWmjHtWQNmL3QN8h9LsIrwrtRtd+bPIaI2tm+24N5b8/DNp0X47Hv3IOgn/ykS3X3/83kYa6MOWEudmP5gugjvDrjWD0+/HwkfjXdlsPelu9Iw+9M8tOmqRZd+rvD9qQQLvn47RwT2pn/TAN0HygFLi9mJ1+5Jw76tJnz8chZe/aJB5X0MuXYs+qkADZup8enChtBovZF8uhT3j0rEz5/kVgvwLvzBgBOHLCLcq/ev3umZat93LyeK8O7gm8Jwx6txUKrk2pB2oP/8JA0Lv8jAt68kotPgQKh9vCs/Uz58UA7vDr45DLc+FwuNr+v9s1udSD5udnseKdQrhXelbrvPz2oOb4WX6PgrhYcXfpGOZ75276L6+4xUEQZ+5ONWletEnrV0+gER3u18Q0OMfKEdFOXvQ5mzDOu/OI5NX5/AktcPoPmACCh95Pc/KEaH7pPiEdkqAFGtApCwMh2bvzl5wefJPFYowrvxPUJx68xeojakAO/se7dh0zcncctnPdyWX/vJURRnm3HDf/pWrhN5lhSO7fPq+Ttu/f24/J2+0bB4qLTVO3XEDohDx3s6XdJzmfPNOPbHUQTEB2L0D2Og1ChRmFiAxbcuwoFv91UL8B77/Sjyjuai/9sDofareVYA8gxpoP4/14xAdkkJDmZlYkTTZjUu9/Go0WKAf1tKMh746y8UlZaK6xsGBuL7CRNwQ5u22JOejt8OHaq8T6uwMDHAvyUpCXfM/1P8iNA7Ng6zb7wRD/fogbsXLnR7jqf69EWEXo+Hly6BndMq1ZkPFm1EUq4BRSb5Pa4QoNPg46lj0aVxAzx9XX889/Pyyttennv+MYKXrh8sArzbTyYjw1Bceb3U4VcK724/kYz7Zs4X9dGjWSy+ffAG3DusBx7+dpHb4zw6ug/CA/R4+selrA8ioiuMY77/nLPUhpTXf4Y1LRehNw1AyPX9RDfdqrdb0+WOxhWCr+uN8DuGQxmkrxa6zfh8EYq3HkHGF4vR6N2plbdZzmaK8K6ufTxiX7kNXgpvlBw8g5RpPyN33kbEvjTJ7bFyfvkb9vxiNHjqRrf1Ic+R3vvU8toIuWkgQiacWxtW99qQglHt4kV96No3Ee9xBVNCIlLfnoOSPSeQt2AzQicOrLzNcjZDhPCk+8a8MrmyNlJf/wl58zYi5sVb3dYr55e1ojbiWBt1Whtpb/wEW1ougicORPD4/tVqw3ZObWjbxotQbU21kf6OXBv5Czcj5EZXbZRKtbHjCLTtGqPBS3JtmA6dQdr0H5H/50Y0eMG9NvLmStuNIsQ8ydqoK9xu0MX49u8Gfd9LPwBeCtdK4V1tp9YInnI9FH6+buFb61n3g2sdRUYU/70VquhwRLzysDiYwJaRjYxXP0bhojXVArzFa7bAmpiK0AcmwVunvQKvkP4Nju1RBfGb0Nbj+GPxHhw8kuZ22+C+LfDKk9fiums64NCxNKxcV/PB+FL++8XH5GC+tMzIIa4DEqtqGh8uwru7DyThqWl/iN8qu7SPw0dv3IQ7JvbCc2/Od1v+ntv6ITRYj1ff/wsOB2ujLiSdzMK87zbg1NF0nEpIx833DcLQcZ0veJ/MVAMW/bwFp45I90lD/5HtccsDgy94n8Yto0R4d9/Wk3jp7lmiNjr2bIJ3f7hH3Pe1+390W37K4yMQEuGPt5+YA4edtUFU3zERUIteffVVLF68GJmZmUhKSsJXX31V16tULyxfYUF6ulN0zn3vnYDK8K6kY0c1nnxcDsd9+JHrB0zJr7+ZsXWbFQMH+OD9dwPcwrsStdoLHTu4dzw7eFAO9N58k04ENCX9+vogvpECu3db3ZaVwsPf/2DClNt11Trzkmf8vdKMzHQH/Py98PJbgZXhXUnbDmrRfVcy82P32mjZRl0tvCvR+Xrj6Zflbr0H99lgLHZ9sTlySK6NcRNdtdGzr0Z08d2/x702pPDwrz+W4KbJvtU685JnbFlpRE6GHXp/bzz2ZkRleFfSooMWtz4iH2E951P3H4B+/TIfZWXAiBsCKsO7EimU++R7kaJL6+YVRhHQrZB4vBQ2axkGj/UXy0nimvigXXcdkk5YUVLsqFw2O82GH2fkosdg32rBXvKMYoO9Mmh74xMN3IKy0tGv1z/SAGqNN0xFDqSfdgVyN/yZi6M7itG+nz+mTm/kFt6VKNXeaNzOvRN7YoLcTW/ADaEioClp29sfEQ19cHKf0W3Z0weNWDU7G8MmhVfrzEueYSqwIutEkTg/6OGWbkFZL28vDHigBZQaBSzFNuSccb1/LQZF4Zrn26HjdXGIaB5Q+V5fSMaRAvG347i4yuUb9wxDcJwvUvbnuy2bdtiAXb+eRdeb4qt15qWrgym7BOk70sX5pmPdg/mXo+C0AU6bE42vaSzCu5KARoGI6ByJgjMFsBpd3zuMmUbs/2ovYvrGotGQmqf9Jc95pm8/xAcF46U1q1FcPnB/rk5RUegYFSUG3l9YtapygF+SVFCAt9ZvEOcf6dHT7X7tyjv7/ZFwWAzwS7amJCPRYEDnaFdXcEn7iAjc3rEjZh84UK17B3nWoeTMauFdSaHJgk+WbhHne7doeEmPpVYqMKpzC3F+/vbDbre1jpUPPFyww1UfO06mICnHIDoAV9UmNgK39O2A37YcqNaZl84h/b+sryci8iiO+f47UsdcKWgVOKwzQm8aWC3YJHXf1cS7z1IjXT43vCuW1aoRPmW4OC9Nie6o8jlsOS1/Zw8Y3KkyoOXbvrHo4ms+7t65SOrka1i+C4EjulbrzEuekz9/k6iNgGFdRHCuem2ooYmPqrysjgxG7LQ74NupmVsIT6Jr0wgh4+UuWUUbDrjdZjktf2cOGHJObUTWUBun0lCwYicCR3Sr1mGTPMewYJMI7/oP7YKQGwfVWBs+59RGzGtTzlsbweW1UXxubZyRtxv+g1y1oWsn14blnNqwlNdGAGujTnG7QVeS5cgplGzdC1WDCIQ+cKtbeFfi5e0NnyZxbtfZUjMBuwO6np1EvUlUUeHQtIiHLS0LTrOlcll7XgEKF6yGpkNL6Lq199Crogvh2B5V2HsoGa+891e18K5k7ebjWLFWHpu7ZlCb8z7GjWO6oGObWHz54wZkZBeed7kWTeTaWLrmkAhoSvYcTEZKugFtW7rXRsumkZgwqhMWLt9frTMvec6Kebvw7X+WY/2SA0g9myOaQF3M9rVH8OVbi7F6wR7RTfdSwtfN2sgNxVbO311ZG/u3n0ZaYi5ad3QfU27eNgZjbu2FJXO3V+vMS+eo63FbjvvSJWKAtxa9/vrruPbaazmt2j+0/4AcnGzfToWAgOol2q+fvAO0a5cN2dmuoNx3s+Tg1IMPuO9QXYjBIH9QBga6h2+CgrxRYnJtDO32MjzzXCEiI7zxwvMM4dWVhANygKV1OzX8a6iNnn3kLnT7d1uRW6U2LqQinCsFNZVVOucWFMi1ERDo/jwBQd4wnVMb058vQFiEAo8+K4eByfOOH5QHQZq11dTY5bZzH534m7DHjPwcuzgvhXB3rJNDeYPGVn/vIhqo0LqLtjIgXKGoQK4tv0D35/EPki9bqtTHp69liSMuH5nOz4G6olJfekdsvyDXxAQrf8oSf0dPdQ3wXkxxgVxb+gD3CQ70gUpYTK4dM4e9DN+9koSgcBUmPskfBuuKFMK+VLog9b8OC0u0Ae6PI122muS6kTjtTtEV2C9Mg8GPtvpXz0m159TSU+KI/MDGgQhrG/avH6+0UB70Vfu7d9P1Kb9sN7tqZOd/tgNeQI9n3QeEyfN6xMTgjk6d8GdCAtafPXve5dpHyuGT1KJCJBdWH7jdkpwk/kb7+6ND+bKSQI38HaTA4vqhR2KwmKFTubYlCi8vvDVsOLJKSvDB5k1X4JVRbakYpLXaL20/ZVj7ZvDXaVBQYsbaQ6fdbgv01VYGg6sqKLFA5+PqCq7w9sJrE4cip7AEH5cHiImI6N/jmO/lK7M7ULBSnhI4eNyVmVJcCtMI3l5uYSxHsXyQrkLv3t1Ouuy0uA6SK3M4kTlzCZRBfgi7bcgVWSe6zNpYVV4b1/W+Io9ZEei058oH71ZwGE0114bfubXhQNbMxXJt3MraqMvaKFwlTxctddS9EnwalddGnvs+msN4nu2Gn65abWR/9ReUwX4InTT0iqwT/XPcbtCVJnXSlfgN63vJnZMrasO7fD+9grde/k2qan3kz5Y7rgZPHnfF1pkuH8f26J84cSZb/A0PrTknEtsgSHTK3XcoWYRtLyTAT66NovL9lQrSZa2mSm14e+GZh4Yj12DEV7M3XoFXQVc7v0D5s6O44JzaKDBBo3PVhrfCG49On4D87CL8MGOFx9eTiGoHA7x01SkpcVaGaGsSElwxvTlwqLxLak6OAwlH7FAogK5d1EhKsuPTz4x49vlCvP5GERYvMcNqrX50QmysvAN28pQrGGGzleFsoh2Rka6ds6++LsHhBDvefisAej3/2dSViuBs4HlqI7BKbRw9LNfGhVhLy/DJf+SBmJ79fNw6+jaIkd//s+fURkqiA+ERrtr46Vsjjh2x4cU3AuDL2qgz5vJwZEWI9lwV10u1ceqwvLOcetaKUrNcU83baWq8X8X1p4+4jqiNiJFDEVW78kpSTllFWLTiuTYsLcKOtSWY8lQYwqOrT69OniF1zm3RVe7S88eMNNhtriCtdPTin5+mwWpxokP/AIREyWG5wlwbko+Z4a0AmnfWIzvZgr++ysB3ryZizrvJ2LE8H3Zr9SMlwxrI96/ayVd6vqykUgRHuGpg2feZSDpqwpTXGkKr5xRqdUWtUyKus9zhdt1nx+CoUhtSOHPDl8dhtzjQtG84AiL/3XRmgQ3kne7cs64O8dLz5aeUwD/c9djbfjqNzGNFGPlie/j4ugfB6epxesnJi3bfzT+ehz2f78a2t7dg9ye7cGbladhKav5uoo+St1GFZ+VOzRUKEwvgrfKGT6C8bUlccxapm1PQ6f4u8I1g5+66pFOp8N7wEcgtKcEb69ddcFlflbz9L6jScaUqi90Os83m1pmj4kcBSdNgVydupbc3GgYGIcvoOrBoapeuaBMejtf+/hsl5Y9DVx8pVPvANXLwfn3CmUu6z7geckePJXuOweZwD/2m58v7MI0j3OsjLjQQWYWu+rh9YBe0ignHW3+uhamU9UFERHXPciYDjiKTCL2po4JhScpC7m/rkfnlYmT/vAbG3SfE/tilctrsyJmztrITotS9t4IqPFD8tabluIW9bJn5UAW7DuTO/2sbSs9mIuKeUVBo3Q+qo7qqjRCUSrXx+3pkzlyMnJ9Xw7hHqo1/Ni2sNUOeiUtxTvdmVZhcG6WpuReujcWu2vBmbdSZ0rMZcBSboAhy1UbeH+uQ9dVfyJ29GiWXUxuZFbXhV2NtnLvdsGbmi9qsYFiyDaWJmQibOpq1UYe43aBLUXrsDAy/LkHeD/NRMG8FTHsOo8zm+t2vglQrUgdeiU+LeDgKi1G0ajPyf1oAwy+LYdyyB05L9Q6tytAg8deWIYf7KtjSswGlQhwAICnZeRCWA8cQOGEElMFyPVHd4dge/VMxUfK/27x899k2K2b7fOmxUaIr67ufrbzoY1V0520UK88eK1EovNEgKhA5+a7fkG66rhuaN47AjK/WwGxmbfx/kJVmEH/jmsizr0kUSm9ENwxBXrbr4KIJU/qiaetofD59Ecwl7jNHE1H9xWQAXXVCQ+UwU1JyzZ2JkpJc1yenyOePHLVXhn5/mWsSod1zv+M2bKjArG+C0Lq1ayC3Tx8f6PVe+OqrEvTopkZ8vBIzPjbCYCjDhPHyznVysh3/nWHEtaM1GDG85pAfeUZwiFwbqcnVd67l6121kZZSfZkjh6z45YcS8QXakOdEwkEbDPlOtO2gwuvvyzvZFbr39oGv3gs/flOMTt3UiGukxNefFKPA4MSocb6V6zHzo2IMG6XBoGH/LtxF/05geW1kJNe8A5OZYqt2PjNV/qv394buPOHrsChltfs3aaVBRAMlVs0rQvdBerTqqMHy3wpx5lgpeg3VixCvsciBL6dno0UHDa67nYMxde3uNxvhP/ecxNrfcrBvfQEat/WFt8ILiUdMMGRZ0fe6ENzxmmvqkeTjpsrOuet+z8Gc91LgsFX9ATEL4bE+eOLzpohrKQ/ASdr09IPG1xtLZ2WieRc9IhtpsODzdBgL7OgzVt7Zyk4pxYLP0tH9miB0GeK+3SHPu/a1jpj70HbsnZeEkxuzEN0mEF7eXsg8VojibAvaXxuDkS+2+9fPE989FGpfJbb9eBqxnYIREqfHxq+Pw1xgRbtR8pQ4htQSbJx5Aq2GRaHFIPfpYunqkbk3E8WpxSJY23hkk/Mul7opRZyqUunV6P5UDzQZ1dTt+qDmwfCN0uP0klOI6ROL0LZhOPXXCRhOGRDTLxYKlQLW4lLs+nAHQtuEouWN7M5c117sPwBxgYG4b9Eit2nzapJrkg/qiAkIqPH2UJ0O2vIfAqousy05RUzdJw3i705Lw9mCAjEVX7BWi0VHj8rL+/vj0V69sOzEcfx9xr1DK9WtXi3iMLpzS3h5eSHET4cOjaKg1/hg89GzmLH44t1UooP80b2pPNXqgu3yFH1V7TiZDKOlFHcM7IK9Z9KRnFOA+4b3QJBei6V7j4llGgT74/7hPbFq/4lLDg0TERHVNilcJVGG+IvAbv7CLUCV3e38BVvgEx+JmOdvhiqs+vcnaQrz/GU7xH0cRSWwnEoX4S1N02hEPjTWbVldu3h4a9XIX7QN2pZxUEeHIPf3DaIzr39/eT/PmmUQ1/n1ag2/7i1q++XTJdaGFLzLX+ReG1go10aD56TauPhYm7PUioKlO8R5v56ta6wNw19boW0VJ8LkeX9sFLXh1699ZW3k/b4B+l6toe/W8oq+VvpnSpMyK2tDCuwa/pJqw1UchkWbRdfUqGf+QW1I2xFp7K+H+/61rq1UGz4oWCxtNxpCFRWM/Hkb4Cw2wb+vvN2wZRmQ/8d66HuyNuoatxt0KUq27q12nSLAD8F33QBtO9dnvz0nH2WlcgjKejoZ+T8vrLxcoeD3ZQi9/xZoWrnG9tRxUVCEBKJk8x5o27eET5M4GDfugi01E9qOreClVMJpMsMwdzHU8bHQD+lVq6+XLg3H9uifCA70xcjBbcX5DdtOVLv9lvHd0KZFND75di3SM92bdNRk78FklJhKRUD34JE0pGYYcMfEXgj012H1Brk2osIDMOXmXli35Ti27GRt/H9xYPtplBgtmHBnPyTsSURaUi4mPTgEAUG+WLdY7uwc0SAItz00FJtWHMT2dXK9ENH/BgZ46arTt48aH38CHDxow6HDNrRr69658qfZcrBKUmyU98YNBvko2oICJ15+tUiEbZ96Qi867B47Zser04qwd58NkybnY+2aMASXd3CVuvm+/KIfnn+xCCOvlY+slTRrpsTTT8pHVD/3QhGk791vTncdRSsxmcug01761Oz070mh2m8+K8aRQzYcPWxFq7buU5H/Maek8ryxvDaqykx34K95rvqR9Ozrg1ffCURElY7LkqBgBR5/3h9vvVyISWNdR9w3bqrEg0/ItfDmywWiNp6f5j74YzY7odWyG68ndeylw9zP83HysAWnEixo2sY9bL/kF9cOU4lR3l6Yy/9qdOd/r7S+8m0moyscLgV0H5wWgekPpOHFO1Irrw8OV+D+l+Wp1L99LweFBgfe+TFWHHlZwWJ2QsPa8LjoxlpM+70VvnzmDA5tLsKeLFc9NGiqQaseftBV6YRrNMgHAJQUOvDTm8kibDvh4WjRYTflpBk/v5WM0wdK8N7dJ/Du4rbwC5K/TvkFq3DLM7H4floSXr3BtdMU3USD6x+RQ5rfT0uEQumF21+Oc1vHUrMDPlp24/W00Hg97vq5Hxa8tBdntubgeLb8o5AkrIkfGnYLhY/+33fQ1gX5YOjjrbDsrUP4bpIruBXaWI8BD8oDxcvePAhvlReued49MGwz26HS8iv71eLUYnmALrZfHDSB1Q/s8mvgh04PdEGD3g3gG+nqrHv4p0Oie+6W1zeJkHjja1zhXymgKwV71z+3FmseW1V5vTZUi25P9BDn93y2G5YCC4Z+Mlzcv4LdYodSw/rwpL4NG2JShw5YfOwYVp+WO7NcyPaUZDjLysRg/rAmTavd59YOHSrP69Vqt+n03t+0CW8MHYqFt95Wef3JvDx8vE2e0lG6ze5w4PV17p1CNEql6P5BdadJRAiu6y530K2wdM9R/GfhRhirTJ95oe670nfIw8mZOJHh6vBUoaDEghmLN+OVG4fg1ycnVV5/OjMPX67YJs6/fMMQ2J0OvLNgvdt9NSolLDV0GyK541IZ/lmHrqvBP+0qRkRUl6Sgk8RyNgOWk2kIHNkNwaN7QBGoF5ezvlkmOhemvvULGn1wb7Xpq225hShad8DtOl37xoi8/1qoQtzHbpX+OoRNHoqsr5ch6blvK69Xx4Qi9KaB4nzWV0vhpfBGxNRr3O7rLLW5dfOl2id1WHWrjWu6IahqbXxbXhtv/4JG/7nvolObZ329FLbsAtGZM+T6fm63Kf19EXrbMGR/sxTJz31Tc218vaS8NkZWC/h5+7iPSZNnthvS+196Kg0BI7ojcJRcG9Ll7G+Xii696e/MQdz791+0NqT33Z5tEN13gyf0d7tN4e+LkFuHIufbpUh54evK69UNwhA8cVD5/aXaUCDsrlFu92VteB63G3QhqtgoBN0yBj6tm4qOt2U2G6wpGShctAbWU0nI+eQnhD91FzQt5TE6p9H122He93/Cp2kcAieOhioqDPbsPBTMXwnLwePifpHTHoUqIlQsKwV0g24di9zPZyPnw1luIeGgm68V5wv+WA6nsQTBT02Fl7fr9yHWRt3g2B79EwpvL7zy5Gj46TU4nZiDRSvd90Xi40Jx1y19cOhoGuYt2XNJj1lYbMbMHzfiqQeG4Zv/Tq68PjElF7PmbhHnpdvsdic+/uZvt/v6qJUotbI2/lcVFZgw64PleGTaeHwy7+HK65NOZWH2Z2vE+UemjYPd7sCXby12u6+PRoVSCzs1/y+N+Uo47vv/C3/trcdSU13BsZpkZGSgPurbxwc9e6ixfYcVU+7MxztvB4jLUkj3h59M+GOeWYQmpQ67FfmFigOupe+yXbuo8M1Xrq6GXbqo8dvcYPTul4OsLCd++LEETz7umu7ojtt90baNCkuXWUQguE1rJSZO1Ilw7p/zzVi/oRTvvxuAiAiFCO2+8WaRuL64uAzBwd64Y7IOTz2ph0LBMG9t69HHB116qLFnhxWP3p2Pl94MQJfuPigscOLXn0qw+E8TlCppynppuorq9x88QouDSQ3gcJQhK8OB7ZtL8cWMIkwYlo03PwzC8NHuXXRvmqxHyzZqrFluFqHP5q1UuO5GnQjnLl1gwtYNpSL8GxahEKHdD98qwtKFJhiLyxAU7I2Jt/ni/sf9WBse0Km3L9p11+LQTjNevTcNj0yPQPtuWhQVOLB4dgHWzC+6YG38U72G6PHlkkZY91cRCvIdiIlXY8SNAfAPVODwLhOW/1qIm+4PRnxLH1Fvsz/Jw5I5BSjMd4huv0PG+eOeF8IY5vWQ43uK8dHDp8S/xYc+bIw2Pf2hVHnh+F4j5ryTjG9eTMSJvUbc+3a8WL4i/u+wl6FZJ1889onriPpmHfV44fsWeGr4QRRk27Dml2yMfyi68vahk8LRsLUOu1YaYDY6RIfe/hNCRDh3y195OLipCFOnN0RQuFqEdn95L1VcLy0rBYGl+0thYalDMNW+5H15+OOJXfBWemPCu53RqEcoFCpvpOzLx6oPErD4tf1I2Z+Psa93/NfP1fWmeES2DMDRNRkoLbEjork/Ol4XK8K5h5am4vTWHIx+tT38wjQitLv6wyPi+lKjHbogNbpMbIQB97dgbdQhq9GK5LVJ4nzTMc1qXObc7rqS8A4RGPzfCOz873Yc+/0odn+0Ew2HNBLB3QpSIHjM7OtwduUZWAwW+Mf5o+mY5vAJ8EHW/iycXHQCbW9vj6CmwXA6nDj47X4cn38MpQWlUPmqRCC4y6PdGOatZX5qNd6VptczmTBtrTxV88UkFxZi4dEjmNC6Dd4bMRy6dSpsOHtWDMRf16oVHujeA1aHA2qFQswSUdWcgweQkJONa5o1Ez8AHMvJwbyEBDGAf13LlhjQKB4vrl6FnJIS8Xgv9B+Aca1awc/HB3kmk7j/J9u2iR8ZyLNmb9wnTtLUiJFBfhjctgnuHdYDfZ5vhMdnLcaeM2nnva+XF3BdN7nb04IdCedd7vetB3EsLRtD2zeDXqPG8fQcLNp5RIRzpe6/fVs1wuu/r0FuUYkI7T41th9Gd2kFP60P8o0m/L7lIL5cuZ31QUR0FfpfHfN1H8R1wr9fW0Te4wrA+XZojNjXJuPMI5+hNDkbRZsPI2CgKxAh8evREi3nv4YyhxP2vCKUHDyD3F/X4+zjXyDq0fHw7+3eMTHomm7QxEehePsROE2l8GkUiYDBHUU4t3DDQZTsPy3Cv1JYSwrtZv+4CkUbD4llFf46BI7oitCJA0QgizzE7oRf37aIuGd05VW+HZog9tXJOPvoZ7Cepzaqyv1jA4rWH4CXWomop26snL68Wm00jkTxtqNwmqXaiEDAIKk21CjaeBCm/acRcd+1UAZJtWFFzk+rxfWVtTG8K0ImDmRteET5dsPhgL5PO4Tf7aoNXfsmaPDK7Uh67FNYU7JRvOUw/Aecvzby5q1H8Yb98FIpEfXkxBprI3BEd9HR1yhtN0RtRMJ/YHltbDoI04FTCL93TGVt5P68CsVSbZhLxeMFDO+G4BtZGx7F7QbVwH+4ewgbWh9o2zSDpnVT5H72M8z7jsAwdwmiXn9Mvr3KvrEiyB/hT04V2wqJOi4aYY/egczXPoYtLQtFS9cj5K4bKpfXdWyNyGmPwbR9PxzFJVBFhsK3b1co9DpYTiSKjrz+owZAHRMpgjhSiNi4bocI9XppfeDbsxMCJ45imNcDOLZH/9TTDw5H1w4NUVBkwivvLRKh2qrh3pceG4kyZxne+XR51c3IRS1csR8nzmRhYO/m0Gl9cCoxG8v/PizCucMGtEKPzvF4//OVyDOUiNDug3cOxPABraH39UFBoUnc//tft8LpZG38r1n66w6cPpqOvsPbQqfX4MyxDKxesEeEcwdd2xFd+7XAx6/OR35OsQjt3v3MKAwe2wm+fhoU5BuxdO4OzPl8DWuDqB7iL7z1WGysPKXm/6JvvgrEXfcYsGuXDXfcaXC77Z67fbFzlxUHDtgQGCjv6Or1rjDL5Nuq71jr9d64foIWM78qwaZNVjz5uPvtUshXOlUlBYZfe70IPXqocdutcrDz4UcMWLmqFA/c54vu3dVYscKCGR8bRbB32qvuXR6odnzwRTCevC8f+3Zb8ejUfLfbbpvqi327rEg4aIN/eW3URArxRccoMeFmpQgFjx+WjVefMaBzNzVCw92Pwu7QWS1OVUmB4fffKETn7mpcf4tcby8+ZsC61Rbcca8enbqpsW6lBV99UgyzqQxPv1LztCp0Zb38WTSmP5COhD1mvHaPeyhi/J1BSNhtxolDFvgFyu+xVi/XiMV0/iOXzCXybVW7s1Zo1NwHdz4td9ytYLOW4aOXshAVp8Jtj4aI6755JwfzZxlwzcQA9BqmFwHfed8YYMix49Uv5a6sVHtKiuz46KFTKDbYRRfeph3kjpiSzoMCEdNEg+fHJGDDvFz0GRsiwr0aX9f7Pfim8GqPqdUrxLLLZmXh8NYitwBvRchXOlVlLLBj9tvJaNFVj0E3yXXzxdNnsOfvAoyeGokWXfywe40BCz5Ph8XkwG0vuHfopSvPUmTD74/vgqnAKrrwxrR3HfzTfECk6MA7c8J67F+QjHajYxDfXe6q8G/EdAgWp6rMhVasfP8w4joHo/P1DcV1C17ci+PrMtHrjqaI7RQszm/66oQI9g5/Wp6qiTwvcfVZ0fFWF65DdM9/vv3ucHcnHP/zmAjo5h7OQUSnSLfbAxsHie69VTlsDmx/Z4vo7NthqvxD055Pd+Po3AQ0HdsMsf3jkL0/CwlzDsOcZ8bA9wb/y1dJF/LKwEGI9vPDw0sWiy4al3y/NWvgq1b/X3t3Ad/ktT5w/Km7CxSX4j5s2HDYxthgygz5b3d3CmNM7hRmd74x9zsm9w4mwPDBNmC4u0uBIqUtdbf8P+eEpE2btKW0SeX3/XzeT94kb5KT5vTN+z55znNkZGQree8ayypNiw4dEjcXZ31fUlZWicfuPHdOL0UFeHrKs4MGy+bTp2X2nj36NvW8w1q2lK+2bZUtZ87IiMhImXxlH/F2dZN//726wu8ZlyevoEBOX0iW71Zvlx1RZ+WHKePktbuultGvzZLs3MIZHoq6snUTaRDsL5k5ubJk+8FSn3/3yRi9FOXv7SFPjBko246dll82GPuHes3BHVvKtyu3yfaoszqh+P6RV4qXu5u8veDvSnzHAIDKUJtjvmpqepPAEZbHvopbWID4XtFKUjcekPTdUTaTrVTyk1t4oAQOu0JX4I2a8onEfPSbeLdrIq5BlufjXm0a6aV4Rc/Yb34Xr/ZNJGD4Ffq2szPnStqWQxJ8fR89PXra5oN6evSCrBypN2lkJf0FYIuzZ2H8VSW5FecWFig+V7SStI0HJGPPcZt9I2HBerkwe6U4ublIwydvE++2tuMrXq0b66V4Rc/Yb5bpPhAw3NhHz71v6ht9xavtxb7xy9866Tt8In2jqjl7Fu43Aobb6hutJW3TfsnYc8xmAm/iwvWSMEf1DVeJeGKc/iwvtW/Ez1omnu2aiv8wY9+I+WCupG85KEHX9xXPtk0lffMBSfh1tU7eDJtgWdkblY/9BirCyclJAm4YphN4c6PPSV6CqrocKE5F9jW+/bqbk3fNj3N2Ft9BvSXxvwsk60DJqq3uDeuJ+02Wn60hL08Svp0rrmHBEnD9UH1b0k9LJHX5WvEZ0EO8urWX7MMnJPX3NZKfkiphDxVW4kTVILaHSzH53iFy3fDOkpKaKY+98LNEn7XMWbn7lj7SJrK+fDprtUSfsbyvPPYfPqeXolSl30f+b7Ds3BctC5fv1repCsD9e0XK7PlbZPeBMzKgd6RMvK2veHq4ycffWM68hdrh4K5ovRTlG+Al/3z6OtmzJUqW/rRZ3/bkm7fJlUPby6//+Vv2bT8pfYe2lzsfGiqe3u7y5RuLHdR6ABVFAi+qpdBQF/ltboj8vSZH1q7L1sm0YWEuMnKEh3Tt4i5du5/X27Vra+zCTZoUJls1aWK9Wze9uE1srPUfSot78eUUSUsrkLfeCNAndEeP5cnSZdkydoynPPesMVl3xHBPOXQ4T76ZlS5PTPMVHx9Gzla1kFAXmfVLqK6eu3l9tiQlFujbBo/wlA6d3WVoT+OBbqs25ZvmrmFjV+nVx13+/itbNqzNltE3lkwAL+7tV5J1Rd7prwXqvhF1LFf+/D1Lrr3BS6Y+bUzWHTTMS44eyZUfv0uTBx/zE2/6RpULCnWVd39qLNvXZsjODRm6+q66re8wX2nd2VPGXWkMqjRvYwzE1G9o7CNpKQWSkVagK+MWF3fOOA1JvUbl+7qc/ekFOXU0R974oZG4ezjr51UVgNt395THXq9vrt4bezZPVi9KldPHc6RRC0ZVV6Wdq5IlJSFP6jXxsEjeNQlv4iktu/jI/o2psm99ik7gDW9cGKwrum7xuMae+jIpruxpsJX/vh6tq+ze+3Izvd84ezxTtq5Ikr6jg+X2J4xB3yuGBMrpI5my4odYuXlyQ4tEYlS+I2vOS0ZijgQ19rZI3jUJauQjDTsFyYkt8RK1Ma5SEnitUZV+VUXe66Z30X0jPipNDv4ZIx2vbSjDphqrR7UZVF/ijqbKlh9PyKAH24q7N4fwjnB04RF92XJUK3EyTQNxCVQ1Xc8gT8mMz5SM2MJp+Uqz99vdknwiWYZ/PFJcPFwlNz1XDv1yQMI6h0vfZ/ubq/emx6TLiT+iJOVUsvg3YeBQVVGB89z8fLmrS1e9FNUy2Jicf2vHTtKvSVNdOWPKEmOQLDMvTx5YsEC6RUToyhphPj6SnJUlf588IRujo+Xncbfr7Q7Fx5erHc9eNVBXDHlmxQp9vXlQkIxs1Up+O3BA3lizRt/21/Hj0iokRO7u2lVmblgvGWr6EjjUnlMxcuz8BWkVESodGteX7Taq8I7tZRyo8cfuo5KWVb7jjKKeuH6grsirqu8qzcKCdJXexdsOyHuL1urbVu87Li3rh8jtA7rIx8s26GRhAADswa1ekNV1i23qG2/PS0wt13O6hweKd8dmkr7tiKTvOlZqhUWT2FnLdfXE+veP1udh2WfiJW3TQfEf0EnCxw/X2/j1bCPZp+IkaekWCRs3WJy9iN84vG/UK71vJC7ZJHHfLhcnVxdp8MRt4tPN+swppVFVmFXfqHexb+Rc7Bt+AzpJ2N3GvuGr+kZ0rCQt3Syhtw2ySEyHY/tGfmKa1fuTlm6U+O9+130jYlrF+kbcd78b+8Y/C/uGStj1699JQu8aobfx7dFGck7HSfKyzRJyq9pv0DeqEvsNVJRbg8KiHfkJyTqB1zU0yDgljsGgE26tMd2en1S+YxRVqTfvXKyEP3GvOLm56X6S+tcGcY9sKiGTbjZX781PSJKMzbslNyZO3OpbFo1B5SK2h/J6aNIguWV0d0lNy5LHZvwsR6JiS2xz1ZXG74y+PVvKld2NM3ya1A83xuj7dG8hH7xym16f/NycMl/34f8bJN7eHvLWx8v19cYNg2Rgn9ayfPV++ew74yD89VuOSfMmoXLjqG7ynx/XSWYWfaMuuO+pUeLt66Gr7yqNmodKvxEd5a+FO+Q/7yzTt21aeUCaRNaT0Xf2ke8/XCFZGZceWwbgOPz6X4NFR1uOurA2nVqvXr2kplInugOv8tBLUSdO5Mn58wUSFOQknToZE/BatnDVVXjT0gySkGC9mqbpdm+fshMu1q3Lljk/Zcrjj/lKq0jjv8m+fcaDn549LIO1qhLv9h25cvhwnnTrRiDXXn2jzwBPvRQVfTJP4mILJDDIWdp3LF8Cr+LlbUzcTIgvO7lbJQ3/9nOGPDDVT5pHGl/j0H5j3+harIpztx4esmdHrhw7kiedutI37NU3ug/w0UtRZ0/mSEJsvvgHuUhkB2O/UYmzHl5Okp1p0JV5u/YpmbytbldMjylN9PEcmf1pgoy4yV+69TW+/smj2boqb/srjFW8TTr28NIJvMcOZJHAW8Xiz2abq+baYqqwnJZsTNiOaOYpnj7OkpVeoCv3WpOaaPy/9/QuO8l238YU+XtuvNz4SANp0NLYF04eMCbvtepmmVTcpruvHNuVLmeOZkpLKwnHqDzJ54wj7D18bH9fePi5mqvkVoWozfGy67doGfhAGwlt7qdvO38oWV827moZKFaVeM/sSZS4Y6k6sRj2lXQ8SeL3xYk4iUSOvvQfc5SC/ALJTTPuO9xK6XcmySeTZc+3e6TlqEiJ6GGs9J0UlSQFuQUS1smyOnh413CdwJtwOIEE3irm5uIiV5ZSFa9xQIBeTicb/5eL2nHunF6K8nFzk/ZhYfrHAxXwL4t67Zs7dpSZ69fL8UTjbBTtw4z9YfvZsxbbbj1zVrpFNJDIkBDZHWNZpRWOYUqUDfa1PDYsWj13SKeWen3uxr2X/Pw9IxvJmN4ddFJuVKyx8kebhsYf/3ZGWfa9HVFnpEuzCGlZP1j2njIOkK3z1FyHNXFayprYZgB1Nubr2SJCH1OLQSQ/JUPcQkseu6rbi1dWLItpyum85PQyt03fEyXJK3dK6G0DxaORcaBmdpTxWMmrrWWlXlXRN+vIGck+HSderZhFyeF9I9V230hculliv156MQnvVvHt3vqS25CxJ0pSVu6UkNsGiUcj4zFU1omLfaON5TmAl0XfsOw3qFwezSPMSXWqD5TWN5ys9I2kZZsk7j/GvlH/8dvEpyJ9Y2+UpK7aKcG3DhL3i8fX2Rf7hmexvuHZVvWN0zqR15O+UaXYb6CiCtIKB9abKu+qat+u9UMl71yc5KdZP57IT00v9zFK7rk4SV68Snz6dRfPdpHG286eF8nLF49I4yxsJh6tmukE3pxT50jgtQNieyjLAxMGyrgxPY3Ju9N/lkNHS4+bdelge58eEuyrl/Lo1qmxXDu0k3z9v3Vy6oyxb7Rqbuwbew9a9o3d+89IhzYNpFnjEDlwhL5R23Xu3UJG3NhDJ+WejorTt7Voa/zN6MCOkxbb7tt+Qtp1bSJNWobL4T2nHdLeaqemxnyVmtpuVAgJvDVYo0Z18wTv08+NJ0h33ekt7u7GZFxXVye5eqSn/PJrpqxZmy3XXlMy2W71GmMSV7cyEimzsw3y1NPJ0qqVqzzycOEBlYoRKRkZljtJ03XT/XCcWV8YR9jfdIe3uF3sG2XJyTbIji3GvtG0hWuZ2778bJK0iHSVex80JlpZ9I1My76RefE6fcPxfvnSeKJz7bgAc99Ql70H+8rfS1Jl5YKUEgm858/kyv7txgS/fiNLP7kyGAzy/rMx4uPnLPc9W5hUZfrss4rtN7IyCswJx6hawfWM+/yzx7MkIzVPvC8mZJrk5RZI1H5jwC6skTFY5+LqJD2GBcna3y7I3vUp0nNEyWTJvetS9GWLzpbJ4sXl5hTIN9NPSoOWnnLDPyPMt5s+++xMy0En5ut0jSrnF248Vog/kSZZqbni6WeZUJmfWyAxB4xBusCGZVdnv1R5Ofmy5OVdEtrCV/rfWyQh9OJnn5NhmTyem3nxOn3DIY4uPKwv63ePEL+GhccAl+L0mmjJy8rTn2FIu5Ayv1c2vr5e3H3cpMeUwuQM09eGfp4i8ugfdtH1k49t3vfmyJFyc4eO8s66tfLxpk3lfs67unYVLzc3WXDwgMRnlF6Z2d3FRV4ZOkyOXLggn24ufA2D+rVS/RjoZrkf8zZN90iQp1oI9PGUNg2MP8SdjLM+rd513duJh5urnIpLkq3HTl/yD1DP3zJUjsVckK/+ME6jVpSXh2X/8HI3Xqd7AED1U5tjvq5BvjqBKXP/KUnffdyYfFWEIS9fMvYZf4Asb8JsQW6eZB48pdfdG4SUue35zxeLe6NQCblxgBQ/0C4oVr2qIJuKRfbiGuSnp5nPPHBKMmz0jcyLfcMz0rJvJP2+RWK/WlKYhNejzSW/vuobMV8sMvaNsf1L3l+sL5j7CrE9u/QNnRR74KRk7j4mniqht3jf2H/Cet9YvkXivl5iTt717V6xvhH7xUKduBs8puh+4+L92Zb7DYNpFg36RpVjv4GKSt+8S186eXlYJMx69+gkKQv/kqz9R8V/RJH/94vU7Yp7c9vJn6a4XsJ3c8XZ21MCbxtVeMfFz95QrG+YrtM1qh6xPZTln+Ovkjtu7GVO3j141HZy7P9N/dbmfZPG9ZX/u72fLFqxW9746PcyX9fN1UUef2CEnIiOlx9+3Wi+3fTRl4jreRLXqyvc3Fxk8oyxcvLoeZnzxSqL7xrFo9hMMZ6m6/QNoMZhTndUS4cO50pqqmVSU16eQd7/ME2+/yFDmjdzkUcnWybUTX7EV9Rx7X//lyEr/jBWzTT55NM02bw5V1xcRCZNKD0J57330+R4VL68/WaAOUFY6XSxouvceZnmxMwLCQWyZGmWqAGarVuTD28Pxw7nSpqVvvHlR6nyy3/TpUkzF/nHw4WJNRfi82XO92klHqOcj8mXZ6YmSuz5AmnQyEX69C+9yurnH6TKqag8mf56oEWCcLuOxgOhJfMzJCvL2DcSE/Llz2WZ4uEh0qIVfcMeTh7JlvRUyyrK+XkG+fHjC7L4x2Rp0NRNbn/I8oec2+4P1kGR339Jli2rC0dVZ2UWyLtPxUhBvkj/q32lScvSp7Ra9lOy7N6UKfc/Fy7+gYUVWZtGeui+sn55qqQk5Zuf+8/5xuTPlu2ZKquqdRkYIB7ezpKTVSBfPXdCstIL+0heToH88O9ouXA2R1zcnKT3yMJE3Rvuj9C3rfw5TravTLJ4zkVfnZND29LE2UVk+J2WVTCLm/fxWYk5kSX3vtJMXN0LD7uadTB+F61fcEG3TUlNyJUtyxPFzcNJGkZar8yHyhPZP1zcvFwkLytfFr24yyJhViXvLn9rr67S6+zqJO1HGEeyVqa/Pz8sF06ly3XTu4iLW2HfiGhnrBayd8kZyc0y9teMxGw5+Oc5cfVwlrAWFUseRcUV5BXI8aXH9Hrk9bar76bFpOnt8rNLVu4+tfqkrH91nV5vMbKleIWUfjx6dMEROb89RnpM7SUeAYXfFQHNA8XZ3UWiV52U7ORsczLv8WXG9gW3Lj1hAY7RJCBAgr1K7tdv6dBRpvbtJ4mZmfLq6tVlPs/Dva+UZkFB8syK5ZJbUHhsuy/WOIXbDe3aioer8bgzyNNLRka2kqy8XP2jAKpei3rBMuqKtuLuWrI6f9OwQHlnwnU6OXfXibNy5Jz1z2RMrw76ct7mS6++e/+I3tI0NEhm/PSH5OUX9o/9p41VQlTbPNxczMnEwzpHSlZOnhw/T/8AANhX6K0D9eWFuWsl81DhgBVDfoHEzlouuecTxdnLXQKGGKc1zktKl8RlWyQ/w3j8W1TuhRQ59/48yUtIFbfwQPHpYqxkb8uFn/+WnHMXpP4Do8Xp4veiYkr6Svl7jzkZLy8lQ1I3HhQnd1fxaEw1PHsIuXWQvrwwb41kHi6sYGfIz5fYb38v0je6me9LWrFNzn+5+LKS8PRr/rxacs9dkHoPXC9OpmSZIn0j1aJvpEvapgPGvnGx4iaqVsgtxr6RMG9tib4R952pb3iI/+DCvpH8x1aJ+2rxZSXv6tf8ZbXkxiRI+P2WfUNXBlZ9Y81uc9/IV31j8wG9nTt9wy7Yb8CanFNnJWPHft0PijIUFEja31sk+VdjMp3f0H66H5j4Desnzj5ekrX7kKSuskzgTN+0SzI27ry4Xd9SXz99zRbJPhQlQeOuExffwhigW4NwVZFKMrbvk/yLVYBVonf6hh3G+5tUfgwalYPYXt1w75395a6bepcrebeyTbitjzSKCJI3P1oueXmFfePwMWNcb/jAduLubuwbAX5eclWfVpKdnSsnoukbtd0dDw6VBk1D5P3n50pebuH32tH9xqrMQ0Z3E3cPY9/wD/SWfsM7SHZWrpy82HcA1BxklaFa+uG/GfLDDxnSqbObRNR3kewcg2zfnitxcQU6eXfOj8Hi7W2Zf94q0lUn3U6dlizjJyZKly5u0riRixw8lCtHj+br5N3X/x0g7drZnrL40KFcnex7913e0qun5WiV5s1dZewNnjLvtywZNDROJ/Ru2Zoj8fEF8sjDPiXag6rxy4/pOlG3fSd3Ca/vIjk5Btm9I0cuxBXo5N3Pfwi1+CyyMg3y6nPJ8uZLydKmvZs0bOSqR6PFnM2TA/tyJTdHJLyes7z/ZYh4eNoe3nr0cK5883mq3Hynj3TraZl02aSZq1xzvZcsXZApY4edl3Yd3WTn1hxJiC+Qex7ypW/YyZIfk2Xxj0nSqqOnhNZ31X3j4I5MSYzP18m7r3/fWLyK7zc6esp9z4TJ56/GyXP/d1o69/aSwBBX2bMlQxJi86VRC3eZ8kq9Ul83MS5Pvno9TnoM9JEhN/hb3Ofl4yw33RMksz9NkPtGRkn77l5ydF+2xETnyuDRftKwWfmng0TF+Ae7yf+92FS+ePqEbFqaKAc2pUqLTj66yu7xvemSeD5XnJxFxj/XRMKbFCbxN2jpJfe+3Ey+eCZK3vnnEWnR0VtCG3nI6cOZupqvSt6dNKOZNGljOwnv9JFMWfRVjAwZFyZtulsmXdZv6il9rguWDYsS5Mlr9+qE3iPb0yTlQp5c/88I8fQumfyDyuUT7CGjnu8sC17YKfuXn5UTW+KlQcdAcXF1lrP7kiQ1Nkv3jav/1UmCGhVWWk6Ny5KfHt1ivp5y3lip+9CqGIm9c4359muf7SQR7QOtvnbs0RRZ/81R6X5zU2nSzTLhMriJr3S8pqHsXXpGPh27Uif0Ru9MkPSEHOl3Tytx9+bw3d5Or42WrMQscfdzl6aDLKe4KyonJVvWzvhbNr7pqhNpvcO8JT87X5KikiQ12jhwo373+tL7qT6lvl7mhUzZ9tEWadCnoU72LcrN203a395B9n67WxbcPk/COodLwqELknY2TZqNaCH+jS2/h1A9DG3RUv511VU6GH82NUWcxEk61asnjQICJD49XSbNmytx6aVP99wqJETu69lTfty9S7YVm07vZFKSrvJxfdt28vv4Cfp1ujdoIKE+PvLJpk2SmVcyqRyVL9jXW16/+xp5IXuoHDgTJ+eTUnVV3IggP2nXKFxcnJ11ddzHv11i9fFtG4bp7VTy7W+b91/Sa7esHyKThvSQnzfslp1Rlv0jOj5Zlmw7KNd2byvzn5og+0/HSrfmDSTEz0e+XLFZMnPoHwAA+/Lp3EJCbx8s8T+ulJPPfSNekQ3FJchXso+fk9zYJJ3c1GDqTeIaaCzeUJCTK+e/WCKx//ldPJrXF7cwdZ5lkNz4FP0YVWHRNdhPGj51mzhf/FHbmuxTsXJh/joJHNFdvNs1sbjPPSJY/Ad0lJQ1eyXq0U90hc+Mg9GSn5wuITf2L9dU2ajcvnHquW90xUzVD7KjCvtGxNSbzX0jK+qcnP98oa4u5VYvSFI37NeLNRGPjC21byT8tk4ChvcQ77bF+0aI+PXvKKlr98qJRz8WjxYRknmxbwTTN+zGu1MLCRk3RC7M/ktOv/Af3TdcVN84fk7y4lTfcJP6Uwr7huozsV8s0mXpXOsFSdqG/Xqxpv7DpfSN6FhJVH1jWHdd6bV43/Dt10nS1u2Rk499rPcbmYdO6b4RNHYAfcNO2G/Amrz4RIn/6HudjOvWpKG4BPhKQUam5J45L/kXjMU6vHt3kYAbhlo8zsXPR0Luv0PiP/hWEr+bJ2l/rhfXiHDJi70guaeM59r+o4eIV+e2Nl87PzlVkn5eKp4dW4vPlcbBSCbOnh7iP7K/pCxeJeeef088IptKzsmzkh+foNvjVi+0Sv4euHzE9mq/fr1ayoRbjXH70+cS5cZrCwd+FJWUkimfzCqsgloZmjUOkTvG9pIFv++SPQfPWNx3JiZJVqzeL8MHtpfvP5wkh4+fl05tG0pwoI98//NGySo2EwCqRmT7BvLQC2PM1yOaBOvLa2/rJb0GFX4nvPzI95IQl6rXg8P85PkP7zbfF1rfWLznyiHt5L1WD5pv//il+eZk3OKaRobLzfdcJUvmbJb9O4yzCpicO3VBVi7aKYOv6yqfL5qqn6NDt6YSFOonsz9fKdmZ9A2gpiEDANXS0CGeEn06X/bsyZXdu3N1JdyWLVzl/vt8ZNJEH/Hysp5oeest3tK6lat89Em6bNqcI/v350pQkLOMvs5THvinj3TrZvvEWJWZf+KpZAkJdpZnn7Ze3W7me4HSsGGqrsK7fEWWNGjgIs8/6ycP3F/6FOqoPAMGe8rZ0/lyYG+u7NuTo/tGsxauMv5eX7l9oq94FkvCDQ51lsef85dtm3Pk6KFciTqaJdlZBvHzd5bO3dxl4FBPufkOH/H1cy61b7z0ryQJDnaWR5+ynhjzyjtBEtHQRRbPz5RVf2RJ/QgXmfq0v0z8p2WlaFSdnoN9JOZMrhzdmyWH92TpyreNW7jLTfcGyw3jA8XD0/pnfNM9wdK8jYf88nWiHNqVKVkZWRLewFXGPRAg4x4IEW/f0hOwP305VnJzDTL5ZeuJvpMeDxXfABdZ8mOSbPgjTYJCXeW2fwbL+KkEY+yl/w2h0ri1tyz79rwc3JIq+zak6ET+wHA36Xd9sIy8u5607FLyf/WqG0OlYaSnLPwyRg5tTZWThzLFL9BVel8TJKP+r77VxxTdb3z1/AnxD3KVcY9bn/70/tebS2iEu6xbeEG2/5UkIfXd5fYnG8moe+pX6vuHbZ2vayzhrfxl0w/H5dS2CxK1KV4H8H3DPKTTqIbS644W0rBTYWVmJT+nQM7sKTn1eUZijl5MstPzbPaNRS/t0gnEQx9tb3WbG17pJv4RXrJ38WmdGBxQ30uGTW0vfSaWXk0KVePowiP6svmIFuJycSSzNd71fKTD+E5yYX+8pJ5O0Ym1BbkF4hHoIY36N9aPbza8uTg5lz4f3pb3NunHXfmk9UTfbg9coZOJj8w/JNF/nxKvYC/9ul3vsx5UhONtO3tGlh05Il3q15fWoaF6PxCdnCwfbNwgX2/bJqnZJavJFffqsOGSkJkhb64pHChQ1BPLlsnZlFS5vl07GdqypZxLTZXX/l4tX27dWgXvCNao5Nz3F6+V7i0aSrPwYGnXMExcXZwlOSNbNh2Jlj92H5X5m/ZJbrEKQCZjexur764/dELiUkr/0ae46bcOk4S0TJm5aK3V+5/98Xc5l5Sqq/AO7tBCYpJS5Z0Ff8usldsq8E5rMXWAWFAD55djvkQANVDoLVeJV6uGkrBoo2QePiMFx87o5KqAwV0leGw/8WhUGDNxDfCR8IkjJGP/SZ0wlXM6Tgpy8sTFx1M8WzcS3x6tdVKui7ftWY7U8VfMp4vE1d9Hwu4aZnWbiIfHiGtogK7Cm7r1kLiFBEjw+GESfEPpVfZQuUJuHqgT8BJV3zhyRrIu9g1/1TfG9LOoXFmQnmWeGjbnTLxebLGViKf7xmcLy+wbbqpvrNkjaaa+cfdwCaJv2FXwTQPFI7KhJC3eKFlHTkvB0bO6b/gNUn2jv7g3LOwb+Rmqbxg7R+6ZeL3YYiuBV/WN2M8XiIu/t4TcOdz6Yx8aIxdCAyR17W5j3wj1l6C7hkvg9f0u+/2i/NhvoDj3xhHiN7yf5Jw4I3kxsZJz9ITeJahEXq8encS3f3ebSbheHVpJ/RenSMrilZK1/6hk7tivK3x7dm6jK/R6dWxd6msn/rhIDy4KHl+Y6FVUwI0jxdnbS9JWb5bMnfvFxd9X/K8ZKAFjre9nUD0Q26v9/H0LC/y0axWhF2vOnU+u9ATeJx8aKUkpGfLZd9arOP/7g6VyPj5VV+Ht1zNSYuNTdRt+nFdYaAZVy9vXU9p1tRywo4RFBOrFxK3IgFK1bu0xgSG+ein63LZMfulGSU5Ml/+8s9Tq/e88/bPEnk2SIaO7ypWD20lcTLJ89eYS+eU/f1/S+6v1amrMVyHuW6c4GdQRBuzixIkT0rx5c70+YcIEmTVrVpW+3unTp6Vx48Z6fdvmcJ1sChQVl09lWFgXk0/iMayLy6O6I6w7lGU9oAGcyLSsMgyYrFlrTFgEivOJ5jwFlnJTk+TQ1y/p9ejoaGnUyPoAqcuJm1zlMVY8nWre4NwsQ7r8nT2v0v82AGpGzLflF1N1whhQlMFQ+qBB1F0FBfQNWOfszE/FsC4z2XZiEeo2l0TqxMG6hqsLHN0EVFM+hy44ugmohrJyU2T18U8rNbZZG2K+CnHfuoVfxQAAAAAAAAAAAAAAAAAAAAA7YmhUFVq7dq0cPXrUfD0+vnAqFnV78WoMEydOtGv7AAAAAAAAAADlR8wXAAAAAAAAQGUhgbcKffXVV/Ltt99avW/dunV6KYpgLgAAAAAAgAMY1LTBBTW03QDsiZgvAAAAAABADVBTY74Kcd86xdnRDQAAAAAAAAAAAAAAAAAAAADqEhJ4q5CaLs1gMJR7AQAAAAAAAABUX8R8AQAAAAAAAFQWEngBAAAAAAAAAAAAAAAAAAAAO3K154sBAAAAAAAA1Y2hwCAGp5pXKZPqngAAAAAAAABQe2K+CnHfuoUKvAAAAAAAAAAAAAAAAAAAAIAdkcALAAAAAAAAAAAAAAAAAAAA2JGrPV8MAAAAAAAAqHYMBSKilprYbgAAAAAAAABArYj5KsR96xQq8AIAAAAAAAAAAAAAAAAAAAB2RAIvAAAAAAAAgDKdPHlSpk2bJm3bthUfHx8JDg6Wnj17yltvvSUZGRmObh4AAAAAAAAA4BIQ83U8V0c3AAAAAAAAAED1tnDhQrnrrrskJSXFfJsK4G7dulUvX331lSxevFgiIyMd2k4AAAAAAAAAQNmI+VYPVOAFAAAAAABAnWYoMNTYxR527Nght912mw7k+vr6yquvvirr16+XP//8U/7xj3/obQ4fPiyjRo2S1NRUu7QJAAAAAAAAAGxxdNy2usd9iflWH1TgBQAAAAAAAGDTlClTJDMzU1xdXWX58uXSp08f831DhgyRVq1ayZNPPqkDuu+8847MmDHDoe0FAAAAAAAAANhGzLf6oAIvAAAAAAAAAKs2b94sa9as0ev33HOPRSDXZNq0adKuXTu9/v7770tubq7d2wkAAAAAAAAAKBsx3+qFBF4AAAAAAAAAVs2fP9+8PmnSJKvbODs7y/jx4/V6UlKSrFy50m7tAwAAAAAAAACUHzHf6oUEXgAAAAAAANRthoKau1SxtWvX6ksfHx/p3r27ze0GDhxoXl+3bl2VtwsAAAAAAAAAbHJ03LYax32J+VYvJPACAAAAAAAAsOrAgQP6MjIyUlxdXW1u17Zt2xKPAQAAAAAAAABUL8R8qxfbnwAAAAAAAABQB2RLlohBama7Lzp37lyZ2zdq1OiSnj8rK0vi4+PL9digoCBdsSE9PV2io6Mv6XUAAAAAAAAAoDLV1JhvVcd9iflWPyTwAgAAAAAAoE7bIn9JTderV68ytzEYLi1inZqaal739fUtc3tTMDctLe2SXgcAAAAAAAAAKlNtiPlWRdyXmG/14+zoBgAAAAAAAACoflQ1BhN3d/cyt/fw8NCXmZmZVdouAAAAAAAAAMClI+Zb/VCBFwAAAAAAAHVO/fr1a820X2oatbCwMHF1rdxQn6enp3k9JyenzO2zs7P1pZeXV6W2AwAAAAAAAADqUsy3quK+xHyrHxJ4AQAAAAAAUOeooGejRo2kNqiq9+Hn52deL88UaWoqtfJOvQYAAAAAAAAAlak2xXyVqngvxHyrH2dHNwAAAAAAAABA9aOqMYSEhOj106dPl7ptYmKiOZjbuHFju7QPAAAAAAAAAFB+xHyrHxJ4AQAAAAAAAFjVvn17fXn06FHJy8uzud3BgwfN6+3atbNL2wAAAAAAAAAAl4aYb/VCAi8AAAAAAAAAq/r3768vVaWFbdu22dxu9erV5vV+/frZpW0AAAAAAAAAgEtDzLd6IYEXAAAAAAAAgFVjxowxr3/zzTdWtykoKJDvvvtOrwcGBsrgwYPt1j4AAAAAAAAAQPkR861eSOAFAAAAAAAAYFWvXr1kwIABev3rr7+WDRs2lNjmnXfekQMHDuj1KVOmiJubm93bCQAAAAAAAAAoGzHf6sXV0Q0AAAAAAAAAUH29//77eoq0zMxMGTFihDzzzDO64oK6Pnv2bPniiy/0dq1bt5Zp06Y5urkAAAAAAAAAgFIQ860+SOAFAAAAAAAAYFO3bt1kzpw5ctddd0lKSooO5hanArmLFy8WPz8/h7QRAAAAAAAAAFA+xHyrD2dHNwAAAAAAAABA9TZ69GjZvXu3TJ06VQduvb29JTAwUHr06CFvvPGG7NixQyIjIx3dTAAAAAAAAABAORDzrR6owAsAAAAAAACgTE2bNpV3331XLwAAAAAAAACAmo2Yr+NRgRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADtyteeLwb7y8vLM6+fP5zu0LaieLhQYHN0EVFNx+bmObgKqqQv5OY5uAqqplKxMRzcB1VR6Vrqjm4BqKi8pydFNQDWVm8pYY1jKTU+xGusAgLqo6H4wLzHVoW1B9UTEF7YUFDg5ugmoppyd2XPAuryUbEc3AdWUIdnF0U1ANZWdWeDoJqCacsktjO8BJtl5aeZ14r6oy0jgrcXi4uLM69eOvuDQtgAAAAAAAFRGrKNZs2aObgYAVIuY78mnvnJoWwAAAACgqGhHNwBAjUXcF3UZZW0AAAAAAAAAAAAAAAAAAAAAO3IyGAzMi1JLZWVlyZ49e/R6WFiYuLrW3YLL586dk169eun1zZs3S0REhKObhGqCvgFb6Buwhb4BW+gbKA39A7bQN2ALfUMspk8zVZzs1KmTeHp6OrpJAOAwxHwt8X0JW+gbsIW+AVvoG7CFvgFb6Buwhb4BW+gbloj7AkZ1O7pXy6kdW8+ePR3djGpHfQE2atTI0c1ANUTfgC30DdhC34At9A2Uhv4BW+gbsIW+IUyfBgAXEfO1je9L2ELfgC30DdhC34At9A3YQt+ALfQN2ELfMCLuC4g4O7oBAAAAAAAAAAAAAAAAAAAAQF1CAi8AAAAAAAAAAAAAAAAAAABgRyTwAgAAAAAAAAAAAAAAAAAAAHZEAi8AAAAAAAAAAAAAAAAAAABgRyTwAgAAAAAAAAAAAAAAAAAAAHZEAi8AAAAAAAAAAAAAAAAAAABgRyTwAgAAAAAAAAAAAAAAAAAAAHbkZDAYDPZ8QQAAAAAAAAAAAAAAAAAAAKAuowIvAAAAAAAAAAAAAAAAAAAAYEck8AIAAAAAAAAAAAAAAAAAAAB2RAIvAAAAAAAAAAAAAAAAAAAAYEck8AIAAAAAAAAAAAAAAAAAAAB2RAIvAAAAAAAAAAAAAAAAAAAAYEck8AIAAAAAAAAAAAAAAAAAAAB2RAIvAAAAAAAAAAAAAAAAAAAAYEck8AIAAAAAAAAAAAAAAAAAAAB2RAIvAAAAAAAAAAAAAAAAAAAAYEck8AIAAAAAAAAAAAAAAAAAAAB2RAIvaqWtW7fKSy+9JCNGjJBGjRqJh4eH+Pr6SuvWrWXSpEmydu1aRzcR1dBTTz0lTk5O5mXVqlWObhIcICcnR7766isZOXKkREREmPcfbdq00fuP9evXO7qJqGSxsbGyaNEieeGFF+Saa66R0NBQ835g4sSJFXrOP/74Qz82MjJSfHx8JCAgQH8H3XzzzfLpp59KWlpapb8PVK6UlBSZPXu2TJs2TQYOHKg/S/U5uru7S3h4uAwaNEjefPNNuXDhgs3nyM3NlWXLlsnUqVOlb9++um+5ublJYGCgXHHFFfLEE0/I8ePH7fq+UDVOnTol06dPlx49ekhYWJh4enpK48aNZcCAAXrfsnfv3nI/V0ZGhrRo0cK8H2rWrFmVth32/b5Qn+/cuXPlgQcekJ49e0pQUJDeL4SEhEifPn1kxowZEhMTU+42qX3MuHHjdJ/x9vY2970bbrhB5syZIwUFBZfxjmHP889Zs2ZZnIuUtqhtyyM9PV0+/vhjGTp0qDRs2FC3q169evo76JFHHpHly5dXwrsHAMC+iPuiIoj7QiHuW7cQ84UtxH1RXsR86w7ivrCFuC8AuzEAtcyAAQMMqmuXtYwfP96QnZ3t6OaimtixY4fB1dXVoo+sXLnS0c2CnZ04ccLQoUOHMvcfjzzyiKGgoMDRzUUlKe2znjBhwiU9V0JCguGGG24osw+pfQ6qtxUrVpTreCI0NNSwbNmyEo+PjY01hISElPl4d3d3w8yZMx3yHlE5PvjgA4OPj0+pn/OUKVPK/XzTpk2zeGzTpk2rtP2w3/fFrl27DL6+vmXuF/z9/Q2zZ88u9bmysrIMN910U5nPpc6NEhMTK/GvgKo6//zmm2/K9TxqUduW5a+//tL7j9Kep0uXLpX81wAAoGoR90VFEPeFQty37iHmC1uI+6I8iPnWLcR9YQ1xXwD25Gq/VGHAPs6ePasvGzRoILfccoseBdekSRPJz8+XDRs2yDvvvCNnzpyR7777To+Q/N///ufoJsPB1Ai1++67T/Ly8vToWjXKDnWP2h+MGjVK9u3bp6937txZHnvsMV2BITU1VY+gU/sPNaLtww8/1PuYf/3rX45uNiqZ+r5o27ZthUYmJicny/Dhw2Xbtm36+tixY3X1hZYtW4qLi4tER0fL6tWr5ddff62ClqMqqNHMgwcPlu7du+t1VZ1FfWecPn1afvnlFz2aOj4+Xq6//nrZvHmzdOnSxfzY7Oxsc5WGrl276lHRvXv31iNgVV9ZunSp3pdkZWXJo48+Kl5eXvq7CDXLK6+8Is8//7xeVyOu//GPf+jR9apqh/r8d+zYIfPmzRNn5/JNfKK2nzlzph5Nr0bnq+8f1J7vC1XhxVSNp1+/fnLdddfpCh6qCkNcXJzep3z55Zd6uzvvvFP8/f11xQdrJk+ebP4+UcevTz75pB5dr/rNnj175I033pCTJ0/KmjVrdKUGVbEBNef88/fff9fPZ4uq9lBWVajRo0fr7xhV/ef+++/XFYRUX1HVQA4cOKCripw/f74C7xgAAMch7otLRdwXCnFfEPNFccR9URpivnUbcV+YEPcFYFd2TRcG7GDUqFGGOXPmGPLy8qzeHxcXZ2jdurV59Mnq1avt3kZUL++9957uC23btjU8/fTTVGKoo37++WfzZ9+nTx+r+5CtW7ca3Nzc9DaBgYGG3Nxch7QVleuFF14wLFy40BATE6OvR0VFVagaw913360f4+HhYfjtt99sbqeqeNB3qj9bxxFFzZs3z9xXxo4da3Hf6dOnDcOHDzds2LDB5uM3btxo8PLy0o8PCAgwpKSkVErbYR9//PGHxQjrnJwcm9uWp/qX6nPdu3fXz/fSSy+ZR1BTjaH2fF+sW7fOcOuttxr27dtnc5v58+cbnJyc9HO2bNnSauUn9frOzs56m6CgIEN0dHSJbZKTkw3NmjUzt2/Lli2X/H5h3/PPopUYVN+qqKKVgLp27Wrur9ZQmRAAUNMQ98WlIu4Lhbhv3UTMF7YQ90VpiPnWTcR9YQ1xXwD2VL5hQUANokaU3HrrrXrkqzWhoaF6NIyJGkmJuuvUqVPmUZSfffaZuLu7O7pJcJD169eb159++mmr+xA1GluNmlSSkpL0KDbUfC+++KL+XNUI+YpSlTq+//578+hsNTLfFicnJ3F1ZRKE6s7WcURRY8aM0dVaFDXauaiGDRvqEdpXXnmlzcerygwPPvigXlfVGVasWHHZ7YZ9qIocDzzwgF5XFTi+/vprPQLelvIcX7z//vu6movqU0899VSlthfV4/uib9++MmfOHGnfvr3NbVTVlhtvvFGvHzt2TFfoKG7Tpk26DyqTJk2yOipfVXGYOnWq+bqqCIC6cf6pjmNVNRhvb2+ZP39+qf2Vcx8AQE1T3b53Ub0R94UJcd+6iZgvbCHuC1uI+dZdxH1RE84/ifsCtRsJvKiT1LQoJuoACXXXQw89pKe0mDBhggwcONDRzYED5eTkmNdbtGhhczs1NZa1x6Bu++ijj/SlmkLp4YcfdnRzYEd+fn76Uk1XUxEck9RMKkh/5MgRva4Cr5f7A42a8uqFF17Q6/ywjLL2Cxyz1Dz22tcnJiaap2q76667pGnTplX2WgAAVFecY8GEuC9MOIdCRRHzrduI+9Y9xHxR1Yj71j7EfQFUFhJ4USdlZ2df0khL1E4//fSTHjkVHBwsb7/9tqObAwczjaZWjh8/bnM708G3GlHfqlUru7QN1Zs6Of7tt9/0+vDhw8XT01Ov5+fnS3R0tJw4caLCQT5Ub4cOHZKdO3fq9bZt21boOTgmqZl+/vln83eBqUKPkpCQoIO86vJSqIoc6enpcvfdd8ugQYMqvb2oWcraL1zqMUvxx8D+7LWvV+c2mZmZer1oZaiMjAw5evSoxMTEiMGgZlkDAKD24hwLCnFfFEXcFxVBzLduI+5bNxHzRVUj7lv7EPcFUFlI4EWdtHr1avN6u3btHNoWOIaaBmvKlCl6/Y033tBTHKBuu/322/W0I6Y+oQJxxanpTBYvXqzX77jjDvP2qNt27dplDtZ26tRJUlJS5NFHH9X7lSZNmkjz5s11lQYV6F21apWjm4vLpE6GVbDu3Xff1RV88vLy9O3qM68Ijklqpo0bN+rLZs2a6WocauSz+v8PCQmR1q1b60sVOFM/FBcN4Fgze/ZsWbJkiQQFBVlMt4S6q6z9gupralo2ZdasWXL27NkS26SmpsrMmTPN1RpGjBhRpW1G5e7r1RR5DRo00JVZ1PGEmpbzueeekzNnzpRr32TqJ1u2bNGfvdpPqQSEiIgIPbWaqhx1/vz5y3xXAABUT5xjgbgviiPui4og5lv3EPcFMV9UNeK+tQ9xXwCVxgDUMfn5+YZevXqp4Sd62bp1q6ObBAf4xz/+oT//fv36GQoKCsy3T58+3dw3Vq5c6dA2wv5+++03g7e3t/78u3XrZvj2228NGzZsMKxYscIwY8YMg5+fn77viiuuMMTExDi6uagiUVFR5v3AhAkTytx+1qxZ5u3VPqRVq1bm68UXJycnw+uvv26X94HK880339j8TNXyr3/9y+K7pLzOnj1r3q+EhYUZMjMzq6T9qPxjSWdnZ/259ezZ0zB58uRS+0ffvn0NiYmJVp8rISHBUK9ePb3d559/bnFf06ZN9e3qErXj+6I8du7caXBxcdHP2alTJ5vbHTp0yNC8eXO9nepD77zzjj52XbNmjeHTTz813xcaGqqPZVD9zz/L+q5Ri6enp+Gzzz6z+VqDBg0yb6uOT1xdXW0+V/369XV/AwCgNiHuC4W4L6wh7gtivrCGuC9MiPmiKOK+KA/ivgAqEwm8qHPefvtt85fXjTfe6OjmwAH+/vtvHVBRBzZ79uyxuI9ALg4cOGC49957dR8pfsCrTpRmzpxpSE9Pd3QzUY1OzN99912LEyx1efXVVxs2b95syMrKMsTGxuqT6oCAAPN28+fPt8t7QeWwdXLdtWtX/TlXhAr8jh492vxcH3zwQaW3G1VDBWCL/89HREQYfvjhB31fRkaGYfXq1YYrr7zSvN3YsWOtPtc999yj7+/Tp0+JHwMI5ta9QK76zujRo4f5ORcsWFDq9vHx8YaXX37Z4OvrW2L/5ObmZnj88ccN0dHRl90u2Of8U33XtGjRQn9uv/76q/5+Ucvs2bMNt9xyi8WxafEff0w6d+5ssX9S/eCVV14xnDp1ypCdnW3Yt2+fYeLEieZtmjVrZkhOTq7Cdw8AgH0R9wVxX5SGuG/dRswX1hD3hQkxXxRF3BflQdwXQGUigRd1yqpVq8yjUcLDww3nz593dJNgZ+oApm3btroPPPHEEyXuJ5Bbt6n+8fTTT+sR0bZGrakTLFWxAbXXpZ6Yq5Poon1k+PDhhry8vBLbqdGxphHc7dq1q9DIfTiGGkmvfvhTizqp/vHHH3VwTn2WLVu2NCxcuPCSn1OdWJv6zODBg/VIXdQMKjBW9H9eVfA5ePBgie1UULdLly7m7TZu3Ghxvwr4mn5Y3rVrV4nHE8yte4Fc9UPypTyfCvyZjmutLU2aNDG88cYbfN/UkPPPpKSkUj8r9V2jArOm/c65c+dKbKO+k4r2ge+++87qc913333mbagSBQCoLYj7grgvSkPcF8R8YQ1xX5gQ80VRxH1RFuK+ACqbswB1xL59+2Ts2LGSl5cnnp6e8vPPP0t4eLijmwU7+/e//y0HDx6UJk2ayPTp0x3dHFQj6enpMmzYMHnttdckISFBnnzySTlw4IBkZ2dLcnKyLF++XPr37y9bt26VMWPGyLvvvuvoJqOaUN8pRb3xxhvi4uJSYjvVf2688Ua9rvrWnj177NZGXJ7AwEDp2LGjXnr27Cnjxo2TuXPnynfffSfHjx+XG264QWbNmlXu5/vvf/8rzz//vF5v3ry5/O9//xNnZw7La+r//L333itt2rQpsZ2Xl5e8+uqr5utz5swxr6vvlvvuu08NppQpU6ZI586dq7jVqO7U8cdXX32l19V+5uOPPy51+2nTpsmkSZP0ca06Llm3bp2kpaVJZmambN++Xd936tQpeeqpp+Tmm2+W/Px8O70TVPT8MyAgQJycnGzef91118kLL7yg1zMyMuTrr78udf+k9it33323zXMiDw+PEvsmAABqKuK+UIj7whbivqgIYr51A3FfmBDzRVUh7lv7EPcFUBU4YkSdEBUVJSNGjJDExER9gj179my56qqrHN0s2Jk60FUHycqHH34oPj4+jm4SqpEZM2bImjVr9Lo6MFYBubZt24q7u7v4+/vL8OHDZeXKlTJ48GB98v3EE0/Irl27HN1sVAN+fn7m9bCwMOnWrZvNbUeOHGle37JlS5W3DVVLnSDfcsstUlBQIA8//LD+Eagsixcv1gEWtR+pX7++rFixQl+iZv7PK+oY05ahQ4eKq6trif95FeQ9dOiQNG7cWF588cUqbC1qgs8//1yeeeYZva6OPZYsWVLqcaraj5h+UJ44caLMmzdP+vbtqx+jAnnqe+g///mP+Qcj9cPTJ598Yqd3g6o8/1Q/ApmCvatXry51/1TavikkJER69Oih19XxbE5OzmW3DQAARyHuC4W4L0pD3BcVQcy3biPuW/cQ80VVIO5b+xD3BVBVjEcWQC129uxZPbpaXaovPXVQo0ZMou5577339EFKixYt9OgldUBV3N69e83rf/31l8TExOj10aNHE/itxVRARe0blNatW8uECROsbqdOyF9++WU9ql4FbtTIa9WvULepYIxJo0aNyr1tXFxclbYL9qGOKX766SddzWXZsmVyxx132Nx21apVekR0bm6uBAUFye+//y4tW7a0a3tx+dToZfXDjel/uOj/dXEqqBYaGqqPJ4r+z6sfCxV1jLpw4UKrj1V9ynRpOmZRo7iHDBlSqe8HjvXjjz/Kgw8+qNebNm2qf9xRfaY0pooN6tzmlVdesbmdCg6r4xRVoUEd5zzyyCOV3HrY+/xT7QNUEDY+Pl7OnDlT4n61P9q4caN5vTSm+9Uxrfohkh8VAQA1EXFfmBD3hS3EfVFRxHxB3LduIeaLykbct/Yh7gugKpHAi1pNfcGp0dNqmhPT6Pvx48c7ullwEDV1iaL6w+23317m9ipgV3Q0FYHc2uv8+fPmEdSljaRXunfvblHdA+jQoYN5vaypaorebxqhjZpNBfVMTp48aXO7zZs36x8Fs7KyxNfXV5YuXcoUWjX8/14F5i/l/77o/7xp1PM333yjl7KOZ03HLQMHDiSYW4ssWLBAn5uoQFpERIT8+eefZf4oaJqS0xTUa9iwYak/Jqi+umnTJo5ZatH5Z2nTranPW03ZpnBMAgCo7Yj7oijivrCFuC8qipgviPvWPcR8UVmI+9Y+xH0BVDXnKn8FwEGSk5P1tDX79+/X119//XV56KGHHN0sANVQ0YPXvLy8UrdVI6itPQ51lxo526RJE71+4sQJXdnDlmPHjpnXSzv5Rs1RdCSsCtBas3v3brn66qv1aGgVWFGj73v37m3HVqKyFZ0SyRSwsSYlJUUHdhT+51GUCtreeuut+rhDjaxXFRjKW5nFdPxR1jFL0eMWjllqx/mnqupi2qc0aNCgwvumosck6nspODi4UtsJAEBVI+4LoLyI+6KiiPmCuG/dQ8wXlYG4b+1D3BeAPZDAi1pJTZM1atQo2b59u77+7LPPylNPPeXoZsHB1LRXKshS2jJ9+nTz9itXrjTf3qxZM4e2HVVLHbz6+/vr9Q0bNpR6YrR69WrzevPmze3SPlR/N910kzlwo07ObZk7d655XU3Jh5rPNOJV6dSpU4n7Dx8+LCNGjJDExERxc3OTX3/9VQYNGmTnVqKq/ueVefPm2dxO3Wf6gWfAgAHm28s6HlGL+qFIUZem20wVIFCzrV+/Xk+tpaqEBQQE6GkVi1b2KYvp+OPChQvmqgzWqCpTpmmCOWapHeefX3zxhXmfoqqzWAvkmioEqR8NbVVjUFXmdu7cqdf79esnzs6EhgAANQdxX1hD3Be2EPfF5SDmW7cR9617iPnichH3rX2I+wKwF/5bUeuo6SnGjh0r69at09enTJkir7zyiqObBaAaUwev6uBbOXv2rLz66qtWt1OBmKIH5dddd53d2ojq7dFHH9UjGZXHHntMB3WL++GHH8yBGNXfGjdubPd24tJ+/FPTnpXmvffekyVLlpiDJEWDdcqpU6dk2LBherpGFxcX+d///ifXXnttlbYb9qGmwbvmmmv0+o8//mj1R5yYmBh57rnn9Lq7u7tMmjTJ7u1E9aOCZ+o7ID09XU/Tu3jxYotpWstDTctY9PvHND1fUWp6tsmTJ5vv45ilep9/qmpOO3bsKHWbRYsWyUsvvaTXvby8rO5T1HfN448/bp7es+jU0CYqYeHBBx/UfUS5//77L6mtAAA4EnFfAJeKuC8uBzHf2om4L2wh5ovLQdy39iHuC8CenAylzfkB1NDRcabRrkOGDJGZM2eKk5OTze3VwXXr1q3t2EJUZzNmzJAXX3zRXImB0bJ1x8GDB/WJlBpJZzpJmjBhgrRo0UIHczZu3Kj3JyowowwdOlT++OMPB7calWHt2rVy9OhR83U1RckTTzxhHp147733Wmw/ceJEq8/z1ltvyZNPPqnX27Rpo4P+KuCjArvqe+nTTz/VIyJV1Y+tW7dKq1atqvR94fKoCjypqan6uEJVzlBTHKmp0tRte/bskf/+97/mk3Z1LKGCMSpoa6JGSPfp00eOHDmir6u+cffdd5f6mkFBQUy5VYOoKhtqSrykpCT9Y44KqKlAvQqwbN68WV577TU5ffq03vaNN94w7x8upQ+qQIyqxqCCPKj53xdq6qq+fftKbGys+cegovsNa8LDw/VSPHDYtWtXcxUGVQXmkUcekS5duuhAnprKS33nqOpSSr169XRFhtDQ0Mt6/6i680/1Y+/gwYP194Y6BlWfpelzV1Oi/fLLL3oxhW8+/vhjHYy1Rh23qv5oqgoxbtw4fUyrnk/1QdXvTH1D7bNUgLi09gIAUJ0Q98XlIO5bdxH3rZuI+cIW4r4oDTHfuom4L6wh7gvArlQCL1CbqG59KUvTpk0d3WRUI9OnTzf3jZUrVzq6ObCzFStWGEJDQ8vcbwwZMsSQkJDg6OaikkyYMOGSvjdK869//cvg5ORk87Hh4eGG9evX2+29oeLU8UF5+kOjRo0My5cvL/F49R1yqcckqi+iZlmzZo2hXr16Nj9TtT947rnnLqsPcqxae74vvvnmm0veL6hjU2tOnDhh6NKlS5mPb968uWHHjh12+OvUXZVx/lne7wxvb2/D559/Xmabzp49a+jevXupz3XttdcaUlJSquivAgBA1SDui8tB3LduI+5b9xDzhS3EfVEWYr51D3FfWEPcF4A9udo3XRgAgOpLjYZUFRm+/vprWbp0qezbt0+PsnV1dZX69etLz5495Y477pDrr7+eEWuwSo2+Vv1DjYBds2aNnDt3To/SViMu1e1qpGxAQICjm4ly+P3333V1BVVtQY28VtOhqeoKaqS9Gs2qRkGrqYluvfVW8fb2dnRz4SCqSof6rvjwww9l/vz5EhUVpUfJR0RE6GpO6n++W7dujm4maiFVpWPLli0ye/ZsPUJfjbqPi4vTI/WDg4N1NaAxY8bI+PHj9ZRtqN5UNTA17aqqkKAqNqnjB1XpQ017pqr0dOjQQVcBU9U+ilfmsEbtg1QVMXVMq6Z8VNU51DFtSEiI9OrVS1cJUdO/AQAAAHUFcV9cDmK+tQtxX5SFmC8cibhv7ULcF0B5Oaks3nJvDQAAAAAAAAAAAAAAAAAAAOCyOF/ewwEAAAAAAAAAAAAAAAAAAABcChJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAgCKcnJz0MmPGDEc3BQAAAAAAAABwmYj5AgAAoLoigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAAAAAAAAAAAAAAAAAADsigRcAAAAAAAAAAAAAAAAAAACwIxJ4AQAAymnGjBni5OSkFyUrK0veeustueKKK8TPz08vvXr1ko8++kjy8vKsPofp8eq5SjNo0CC9nbosbtWqVebnUesGg0G+/vpr6d+/v4SEhIi/v79ux/fff2/xuJycHPnss8/kyiuvlODgYN3efv36yU8//SSVrXgbCwoK5Msvv5S+ffvq1/bx8ZEuXbrIa6+9pv+Opdm4caM899xz+m9Rv359cXd31++xffv28sADD8j+/ftLffzEiRN1O5o1a6avnzt3Tp566inp0KGD/huY2qjuN322yosvvmh+D6ZFPVdRqu0ffPCBbltYWJi4ubnp99emTRu55ppr5N1335UTJ05c1t8SAAAAAAAAQNUg5lt+xHyJ+QIAAKDyuVbBcwIAANR658+fl6uvvlp27txpcfuWLVv0snz5cpk/f744O1fteKnc3Fy54YYbZOHChSXaMX78eNm6dau8//77kpiYKGPGjJG///7bYrv169fr5ejRo/LMM89USRtVEHnUqFGybNkyi9t3796tlx9++EH+/PNPHagtbtasWTJp0iSr7/vAgQN6UUFiFVB98MEHy2yLCgyPHj1a4uPjL/NdGYPCw4YNKxFMVn9rtRw+fFi/57Nnz8rbb7992a8HAAAAAAAAoOoQ8y0/Yr7EfAEAAFA5SOAFAACogBtvvFEH8SZPnqyDg2oE/qFDh+Tll1/WAUYVXFVBxn/+859V2o7nn39eNm3aJHfeeafccccdOiCqgoiq2oNqjwpyqvZ9+OGHOmirqheMHTtWV21QgWj1eBVsfOGFF3RQWFUoqGyqkoIKLo8YMUK/fuPGjSU6Olo++eQTWbFihf47qjaqQKuLi4vFY1VVi6CgIN22q666Slq1aqUrOag2b9++Xb8/FZh9+OGHpW3btjJkyBCb7UhLS5ObbrpJV1B49tlnZfjw4eLt7S179uyRiIgIHYBXgedOnTrp7VVbiweIVVtMHnnkEXMg96677tJ9okGDBvo9qECvCqT/9ttvlfzXBAAAAAAAAFAViPmWHzFfAAAAoJIYAAAAUC7Tp083qMMntbi5uRlWrlxZYpsLFy4Y6tWrp7fp3LlziftNj1fPVZqBAwfq7dRlcep1Tc+jlpkzZ5bY5ty5cwY/Pz99f1hYmMHJyckwb968Etvt2rXL4OzsrLebPHmyobIUb+N9991ndbt77rnHvM3HH39c4v7Tp08b0tPTbb5OUlKS/jurx/fv39/qNhMmTDC/hq+vr2Hnzp2ltr08n1FmZqbuA2q7adOmlfp8qk8AAAAAAAAAqH6I+ZYfMd9CxHwBAABQWap2fg8AAIBaSo3EHzRoUInbVVUG0/RfapR/cnJylbajd+/eMmXKlBK3q6oMquqCEhcXJ7feequeTq24zp07S//+/fX6mjVrqqSN9erVk/fee8/qfTNnzpSwsDC9rqozFNewYUNdMcGWgIAAeemll/T62rVr5cKFC6W25cknn5QuXbrI5UpISNBTuimqSkRpVJ8AAAAAAAAAUL0R8y0/Yr7EfAEAAFA5SOAFAACoADV9mS3du3fXl2pgf1RUVJW2Y9y4cTbvKxq0LM92x48fl6qgAsm2ArK+vr76fmXfvn0SExNT6nOlp6fLiRMn9LZ79+7Vi5ubm/n+Xbt2VfhzuxRqOjp3d3e9/v333+tp3wAAAAAAAADUXMR8y4+YLwAAAFA5SOAFAACogLZt25Zr9H1qamqVtqN169Y27wsMDLyk7aqqrT179iz1/l69epnXVQWL4uLj4+WZZ56RNm3aiJ+fnzRv3lw6duwonTp10suoUaMstrVFBY5btGghlcHDw0Nuu+02vf7LL79IZGSkrvSwZMkSSUpKqpTXAAAAAAAAAGA/xHzLj5gvAAAAUDlcK+l5AAAA6pTSpvhydi4cI5Wfn18t2lGe7QoKCqQqhIeHlzndWtFpyoratm2bjBw5ssxp0kwyMzPLFdyuDB999JEO3C5cuFBOnjwpb731ll7U3/OKK67QVSbuu+8+PeUbAAAAAAAAgOqNmG/5EfMl5gsAAIDKQQVeAAAAVCknJ6cKPS4nJ0cHRFUgV02Z9thjj8nq1avl3LlzkpWVpaerU8uxY8fMj1HXbXFxcZHK5O/vLwsWLJBNmzbJtGnT9DR66jVUUHzr1q26OoOqgrFhw4ZKfV0AAAAAAAAAcCRivsR8AQAAUDmowAsAAGDnwKYKOJZV+SA9PV1qi/Pnz5f7/qJT0f31119y/Phxvf7JJ5/Ivffea/XxxSs42JuaDs40JZyakm7VqlUya9YsmTt3rsTGxspNN92kA85eXl4ObScAAAAAAACAykfMt/T7ifkCAAAAtlGBFwAAwI78/Pz0ZWJios1tVLD36NGjUlts2bKl3Pd37NjRvL5v3z7z+m233Wbz8aryQXX6fEePHi2//vqrTJ48Wd+mqkesXbvW0U0DAAAAAAAAUAWI+ZZ+PzFfAAAAwDYSeAEAAOyoefPmZQYgly5dKklJSVJb/Pzzz5KZmWmz6sRPP/2k19u3by8RERHm+/Ly8iy2s0ZVtfjyyy8rtb2enp76Mjs7+7KeZ+jQoeb1+Pj4y24XAAAAAAAAgOqHmK8lYr4AAABA+ZHACwAAYEcDBw7Ul5s2bZJ169aVuD8mJkYeeeQRqU3Ue5o2bZrV+x577DE95ZjywAMPWNzXqlUr87qansyap59+WrZv316p7TUFlNUUaLaoad5Wr15d6vMsX768RBAfAAAAAAAAQO1CzNcSMV8AAACg/FwvYVsAAABcpvvuu08++eQTXWlATbv1wgsvSP/+/SUnJ0cHd999913Jzc3VgcwjR45IbdCjRw/59NNPJSoqSu6//35p3LixREdH69t+//13vU23bt30fUWNHDlSwsPDdbD3ueeekxMnTsjYsWMlNDRUTzenqjD8+eef0q9fP6uB8Yrq27evbuuCBQvk888/189vqtDg7++v23Tq1CkZPHiwriCh2qTeY8OGDfU26r3NmTPHXGWia9eu0rt370prHwAAAAAAAIDqg5gvMV8AAACgokjgBQAAsKMOHTrIm2++qasQJCYmytSpUy3uDw4Olvnz58vzzz9fa4K5r776qrzzzjuybNkyvRTXtm1bWbRokbi6Wh6a+vj4yHfffSdjxoyRrKwsHVhVS1GDBg2Sjz76SDp27Fhp7X388cfll19+0dOpFQ8wT5gwwaIyxP79+/Vii3pvc+fOFScnp0prHwAAAAAAAIDqg5gvMV8AAACgopwr/EgAAABUiArgqqCmqjYQFBQkHh4eerqthx56SHbs2CEDBgyQ2sTd3V2WLFmiq1BceeWVEhgYKN7e3tKpUyd55ZVX9HRoDRo0sPpY9TfaunWr3HXXXXobNzc3CQsL09PSffHFF7oagwr6ViZVPWHDhg1y++23S5MmTfTnU5z6jFatWqWnc1NVGSIjI8XPz0+3r169ejJixAj57LPPZOfOnUylBgAAAAAAANRyxHyJ+QIAAAAV4WQwGAwVeiQAAABggwp0qiCnsnLlSl01AQAAAAAAAABQMxHzBQAAACofFXgBAAAAAAAAAAAAAAAAAAAAOyKBFwAAAAAAAAAAAAAAAAAAALAjEngBAAAAAAAAAAAAAAAAAAAAO3K154sBAACgZjh8+LDk5ORc8uPCw8P1AgAAAAAAAACoPoj5AgAAANUPCbwAAAAoYcSIEXLy5MlLftz06dNlxowZVdImAAAAAAAAAEDFEPMFAAAAqh8SeAEAAFDpBg0aJAaDwdHNAAAAAAAAAABUAmK+AAAAQOVzMnCUDQAAAAAAAAAAAAAAAAAAANiNs/1eCgAAAAAAAAAAAAAAAAAAAAAJvAAAAAAAAAAAAAAAAAAAAIAdkcALAAAAAAAAAAAAAAAAAAAA2BEJvAAAAAAAAAAAAAAAAAAAAIAdkcALAAAAAAAAAAAAAAAAAAAA2BEJvAAAAAAAAAAAAAAAAAAAAIAdkcALAAAAAAAAAAAAAAAAAAAAiP38PxBjGvFJwHaxAAAAAElFTkSuQmCC)" + ] + }, + { + "cell_type": "markdown", + "id": "AHY1ZP2wKaFe", + "metadata": { + "id": "AHY1ZP2wKaFe" + }, + "source": [ + "### Recall after 100 epochs for the Cora hypergraph\n", + "\n", + "![cora_hypergraph_epochs.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACWAAAAfQCAYAAABGuGRGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3QeYVNXZAOBvGyy9I1UEBFvsYOxi7y3FaJoaa2yx915ij/5q7BoTS9TE2HvvvXdFRQFBOksvu/M/96477MIu4LDA7PK+ee4zZ+499+6Zmbsb5vM73ynIZDKZAAAAAAAAAAAA4Ccr/OmnAAAAAAAAAAAAkJCABQAAAAAAAAAAkCMJWAAAAAAAAAAAADmSgAUAAAAAAAAAAJAjCVgAAAAAAAAAAAA5koAFAAAAAAAAAACQIwlYAAAAAAAAAAAAOZKABQBLyQorrBAFBQXpNmTIkFr77LPPPtk+t9xyyxIfIywM9ykAAAAsPmJINBbuUwCgMZOABUBOBg0alP2yXNvWqlWrWH755WO77baLv/71rzF8+PClPWR+lATqDjjggOjVq1c0bdo0OnfuHLvttlu89NJLC32NMWPGRIcOHdLP+pBDDlms44WFkclk4vPPP4/bbrst/vKXv8SGG24YzZs3z/5NSoLVAAAALHliSA2XGBKN0eKOIb355pvpvb7qqqtG69at0y1pJ/uSY7n47rvv4swzz4x11103OnXqFM2aNYu+ffvGr371q7j33nvT1wQALH3FS3sAADROkydPTrehQ4fG448/nn5BPOWUU+L0009Pv8iydLzwwgux0047xaRJk7L7Ro8eHffff3888MAD8be//S2OPPLIBV7n+OOPj3HjxqWBtyQ4CkvTW2+9FVtuuWWUlZUt7aEAAADwE4kh5ScxJBqjxRlDmjlzZhx33HFx5ZVXzpMQ9emnn6bbtddemyZ9XXTRRVFSUrJQ173pppvSc6ZMmVJj/9dff51u99xzT2y11VZx6623RpcuXer1NQEAP40ELAAW2cCBA2O99darsW/ixInx/vvvx4cffpg+nzVrVhpAmzBhQlx22WVLaaTLtrFjx8avf/3rbOBszTXXTD+7ZDbjU089lQYGjjnmmHQm1SabbFLndV555ZVsifCLL7442rZtu8ReA9QmCdRLvgIAAMh/YkgNgxgSjdXijCEl1eL+9a9/ZZ/36dMn1l9//bT92muvpclSye/O5Zdfno4hSaxakJtvvjn233//7PPkd2iLLbaINm3axEcffZStqJX8Xm677bbx8ssvR8uWLRfL6wMAFkwCFgCLbIcddkgDY3UFWvbaa6+0THIi+YL5u9/9LgYMGLCER0kyw2rUqFFp+9BDD01nY1XNJL399tvj97//fVRUVMQ555wTTzzxRK3XKC8vT8tlJ8GCJMD2xz/+cYm+Bpifdu3apX9bkqBwsiXl5E888cSlPSwAAAB+JIbUMIgh0djVdwwpSZSqSr4qLCyMSy+9NI444oi0nUh+X6644oo0cTFpJ/0322yz+f5eJGM6+OCDs8+Tv4fXXXddtGjRIrvvmWeeSZchHD9+fHzwwQfpz0yuDQAsHZX/zw8Ai8mGG26YliavXjL++uuvX6pjWlY99NBD6WPr1q3jvPPOq/GZJF/gN9poo7T97LPPxtSpU2u9RhJwS2alFhcXx9VXX72ERg7zl8zE/fLLL9MlDZLAb3J/77bbbrHccsst7aEBAACwkMSQ8ocYEo3V4oghzZgxo0ZiabLsZrI8Z1XyVSJpJ/uSJQqrJMusJssW1uW0005LKwImkt+5JMGrevJVIqmGlSRFVkn6JEsdAgBLhwQsABa7tdZaKwYNGpR9/sILLyzV8SyrPvvss/QxKQ+flKme25Zbbpk+zp49OwYPHjzP8REjRsQZZ5yRtv/yl7/Ez372s8U+ZljYWYsrrrji0h4GAAAAi0gMKT+IIdFYLY4Y0gMPPBBDhw5N28nvS5I4VZck6SpJbEx8++238fDDD9fa74cffoh77rkn+/yiiy6qkdBV3fbbbx9bbbVVtvJcUsEOAFg6JGABsMQCaFW+//77hTonma1z8sknx3rrrZfOQmrSpEl06tQpfv7zn6dfVhf2OlWSL6B33313Wtp5pZVWSr9wl5SURIcOHdJrJgGhp59+Oi2NXpukPPSLL76Y/uxtttkmll9++WjevHk0bdo0unbtms44SmZNjRkzJvLRpEmT0se6ZnQlr2HuvtUdffTRUVZWFt27d69zuYDGoD7uuyRYnMwOTbbnnnsu3ZcEYk499dR0pl379u3TGWsrr7xyHHXUUbUGK+dn8uTJadnybbfdNnr06BGlpaXp/ZwENA877LB4/fXXf/LrTj7bZHbqzjvvHCussEK0bNkyvbe7deuWBlbPOuus+Pjjjxf6eskM2GSG68Ybb5y+j8m1evbsmS4n8fLLL//k8QEAALBsEENa+sSQFo4YkhhS4r777su2f/Ob36S/63VJju2xxx7Z5/fee2+dSV3J35FE//790wqB87PPPvvUOh4AYAnLAEAONttssyTClG5nnHHGAvuffPLJ2f4lJSXz7Tt9+vTMQQcdlCkqKsqeU9vWrFmzzJVXXrlQ433hhRcy/fv3n+/1qrYTTjhhnvNnzpyZ6d69+0Kd36JFi8ytt966wDH16tUre84333xTa5+999472+cf//hHZlG0bds2vc7mm29e6/Ezzzwz+7M++OCDGseeeuqp7LG777470xjV531X/ffj2Wefzdx///2ZNm3azPea11133UKN88EHH8x06dJlgffhb3/728yUKVMW6prXXHNNpl27dgt1fz/66KMLvE8//vjjzCqrrDLf65x++umZxS0ZS9XPS37fAAAAWPLEkMSQGhsxJDGk6rp27Zo994477lhg/9tvvz3bP/lbUZu99tor2+fAAw9c4DWHDx9e4z378ssvf9JrAADqR/GSTvgCYNlUfcZXXbPnElOmTElnZFWf3dS3b9+05HkyO2vcuHHpseR606ZNi8MPPzyddZXMNqvLnXfemc5YnDVrVnZfMnNo7bXXTstCJ+cns7KSLZlZNH369FpnPg4fPjxtJ7O6VltttejTp09aMjq57rBhw+K1115Lr5W8hj/84Q/pzMhk1lO+WGWVVeLVV1+Nd955J52d2KpVqxrHn3322fSxuLg4fc+rzJw5Mw499NC0ncza/PWvfx2NzeK476q89dZbccopp6TvYzJTNpnZmFxzyJAh8fzzz6f3T3LNgw46KIqKimK//far81p33XVX/O53v0vvx0TSP5kdmJROT2Y0JrNrq37X7rjjjvjmm2/imWeeSWc31uWII45IZy1WSa45cODA6NevX3re6NGj47333kvHm6jt96O65OcnZc+T5Qbatm0bm2yySXTp0iWd1ZuMZeLEiWm/s88+O1ZdddW8+h0BAABg6RNDWvrEkOomhiSGVF0yxmT8VdZZZ50FnlO9T/K3Irk/qpYlrF5d7adcM6k+lvy9TJYurDq/vpdaBAAWQj0lcgGwjPkpsxdnzZqV6dmzZ7b/r371qzr7/vGPf8z2S2YbJjO/5jZ79uzM1VdfnWnatGnaL5lt9sorr9R6vXfeeSdTWlqavebaa6+dee2112rtO2LEiMzFF1+cufDCC+c5NmPGjMy+++6bjieZyVjX7LeLLrooU1xcnP6sZLbgpEmT8mb24jnnnJO91tFHH13j2D333JM9ts0229Q4dt5556X7k/f7iy++yDRG9X3fVf/9aNKkSfp47LHHpvdIdUOHDs1ssskm2b7NmzfPDB48uNZrJvtbtmyZ7bveeuvNM5utvLw8c+mll2YKCwuz/Q4//PD5zlqsPjtujz32yHz33Xe19v3www8zRxxxRObxxx+f731a9f4ks4Dnnj05duzYzBZbbJHt26dPn0xFRUVmcVEBCwAAYOkTQ5qXGFLDJYYkhlTd66+/XuN9mTp16gLPSV5r9XPeeOONefoklc7mV0msNgMHDsyek/x9AQCWPAlYACz24Fn1oE2yPfHEE3WWeK/q07dv38zo0aMX+ovxdtttV2ufjTbaKNtnwIAB8w1m1ZcLLrgg+zOTYEu+BM9GjRqV6dixY41A4gEHHJDZdtttMwUFBem+JOiSfA5VhgwZkgZ0kmOnnXZapjFaHPdd9d+PZDv44IPrvF5yT6688srZvn/4wx8WGOBbccUVMxMmTKjzmn/729+yfZPP9Ouvv56nz7hx4zKtWrVaqDEuSPX7NNlOOumkOvuOHDkyXWKhqm9dwez6IAELAABg6RNDqpsYUsMihiSGNLdHHnkke17r1q0X+rzq7+djjz1W41iSxFX9PUqSQxfGzjvvnD3nxBNPXOixAAD1p3BhqmQBwE+VlE5OSln/9re/jdNOOy27/6ijjoqtt9661nP+9re/ZduXXnppdOzYcb4/Y5999omVV145bT/++OMxduzYGsdff/31bDnwgoKC+Oc//5mWfl/c9t1332z7qaeeinzRqVOntJR+8+bN0+fvvvtu3HDDDel7lyRlJ+9R8r4n5b6rlxafOnVq9O7dO0466aR5rjljxoy0vHhVOfOGqL7vu7klZfovuOCCOo8n9+RFF12Uff6f//wnW2K9yoQJE9LS8VWS/snSB3X5y1/+ki5xkEiWRLj++uvn6ZPsS5YRSPTq1Ssuv/zyqK/77PTTT6/zeFIOfccdd8w+f+ONN+rl5wIAANAwiSFVEkPKf2JIYkhzS5ZzrNKsWbOFPq963+rXqO35wl53ftcEAJYMCVgALLKzzjorDbxU35Iv9ptuumn8+9//Tvt06NAhDSBUD1RUN3v27HjyySfTdrLm/U477bRQP3vzzTdPH5PgT1WgrMpjjz2WbW+55Zax6qqrRn1IghFvvvlmGng644wz0oDgYYcdlt3OPvvsbN/33nsv8knyPrz//vvxpz/9KXr06BElJSVpsGiXXXaJ559/Po488shs34ceeigeeOCBtH3llVfW+BKfBHIGDhyY7uvcuXMakNthhx3i7bffjoZkcdx3c0ve2/kFuhLJe5cEnRLTp0+PV199tcbxV155JQ1UJpLPa+edd57v9QoLC9PPuMqzzz47T5/qvx8HHHBANG3aNOpDMrbS0tL59ll77bWz7SFDhtTLzwUAACD/iSGJIYkh1U0MqeHFkJLPoEqTJk0W+rzq7+G0adPqvOZPue78rgkALBnFS+jnALAMKyoqigsvvDD222+/Ovt88MEHMWXKlLSdBHSS2VcLIwliVRk6dGiNY6+99to8wY5FDbRcccUVcdlll8WwYcMW6pwxY8ZEvllxxRXjpptumm+f5Et6MnMxseuuu9aYbXbcccfFJZdcUqP/zJkz49FHH42nn346nX2XBIwagsVx381tgw02WKjfkSQY+cgjj2Rnlm633XbZ48nzKuutt14UFy/4n3AbbbRRjfOrZqhWn91bn78fVVZfffUF9kmC6dVnOgMAAEBCDCm/iCHNIYZUSQyppuoJZMm9vbCqkuRqq3A1d1Lawl53ftcEAJYMCVgALLLkS3/yhb56iePvvvsuO+MqKS2+//77x9dffx3nnXderdf4/vvvs+2kHPff//73nzyO8ePH13j+ww8/ZNt9+vSJRZG8jiQg9MQTT/yk86rKczc0f/3rX+Obb75JZyX+3//9X40ZjVWBsy222CKuuuqq9L196aWX0rLqSVDxj3/8Y3z22WfRpUuXnH52MiN0QSXZa5v9l2w/1eK47+a2/PLLL9R1qvdLSvJXV/15Uup9Yaywwgo1AjXJvZjM0KwKWFWfCbeovx/VLWimZlWgssqsWbPq7WcDAACQ38SQ6iaG9NOJIYkhLW3Vlyr9KVWnqvede7nTuZ8v7HXnd00AYMmQgAXAIkuCFmeeeeY8+0eOHBlHH310toR8EpBZc801Y4899pin78SJE+tldmFdgatF/dKZlMivCpwlM8CS1/DLX/4ynanVrVu3dFZR9YBA1SyxZMZYQ/Pll1/GxRdfnLZPPfXUGsGaZBZqIgnC3HvvvdlgTFKW/uabb45tttkm/SyvvvrqGmX0f4p//vOf8e233/6kc5KS6rkEzxbHfTe3JAC5MFq0aFFn0DUJSNfWb2GvV3XNqs9r7uvXZ1Cm+gxJAAAAqE4MSQxJDKluYkgNz9wVupLlAxe0rOLUqVNrvK/t27evcTz5G5FsVQlV1RNE5yf5O1rXNQGAJUMCFgCLTTJ77bbbbotx48bF448/nu7785//HFtvvXW0a9euzi/6a6yxRrz//vuL/PNbtWpVa/Ahl5mLV155Zfb5Lbfcks7Qa2wzFqsceuih6WteeeWV45hjjqnxupIZqYk999wzG4ipknyuSWn6wYMHp593rsGzJWlx3He1BVUWRlUZ+7nv3bmDW9X7Lez15r7m3NdPfj/MjAMAAGBpEUNqmMSQ6pcYUsOz0kor1XieJATOvW9uSdW/+V2jat97772XvebCqH7d5HcSAFjyCpfCzwRgGVJYWBg33nhjNkiRBNKSWYxzW2655WqdrbMoql8zKYWeqzfeeCMbfFtttdXmGzhL/NSZd/nk7rvvjieffDJtJ6XUmzRpkj321VdfRUVFRdru379/redX7f/iiy9yHsOQIUPSWZ8/Zatt9uzCWBz33YKCKnUZOnRojdmY1XXq1OknXy95H6skn2P1gFkS+Exm0tXH7wcAAADUBzGkhkUMqf6JITU8yTKKXbt2zT5/9913F3jOO++8k2137959ngTFxCqrrPKTrpkskVm9Ulb18wGAJUcCFgCLXY8ePeLII4/MPr/qqqvmCVSstdZa0bRp07Q9atSodAbcolp//fWz7WeeeSbn6yRfYKsk5eIX5IUXXoiGKAkQJuX+E3vttVdsscUWdc6Gq6skelWQdFFmiy5Ji+O+m9trr722wD7l5eXx5ptvZp+vs846NY6vvfbaNYK5Sf8FqZppWnX+3GXdf/7zn9fL7wcAAADUFzGkhkEMSQyJOTbffPNs+7nnnltg/+effz7bnvt3pz6uufzyy6cV5gCAJU8CFgBLRFKGvGr21PTp0+Oiiy6qcTyZSVX9C+fVV1+9yD9z++23z7affvrp+PTTT3OegbmwpcCT2X3XX399NERnnHFGDB8+PJ11demll85zvPrst2HDhtV6jar9tc3cykeL476b2wMPPBBlZWXz7fPYY4+lwbtEaWlpbLDBBjWOb7jhhtkg3+jRo+Phhx9e4H34j3/8Y77BnOq/HzfccEO6ZAAAAAAsbWJI+U8MSQyJOXbbbbds+6677opp06bV2Tc5llSPq+3c6nbZZZfs35PPP/98gcl5yXKnVXbdddefNH4AoP5IwAJgiWjXrl0cfvjh2efXXXddGgSo7oQTTsi2r7zyynjqqacW+vq1lf5eb731YqONNkrbSYnxpOx7LrPq+vTpU2M20cSJE+vse/HFF8f7778fDc1HH30UV1xxRdo+++yza5TOrpLMnCouLk7btQVvRowYEW+//XbaXnXVVaOhqO/7bm5J4Ozkk0+u83gyK/T444/PPv/Vr36Vli+vrm3btvGb3/wm+/y4446LSZMm1XnNZIbwhx9+mLaTYM2BBx44T58DDjggWrZsmV3yoPoMYwAAAFhaxJDymxhSJTEkqidLJdX7EhMmTIjzzjuvzr7nnHNO2ifRq1ev2Gmnnepc8vIXv/hF9nnyuSd/m2rzxBNPpFuiqKgoDj744EV6PQBA7iRgAbDEJKXJq76sJ7MA554ht9lmm8Xee++dtmfPnh077rhjnH/++XUGvJJZkPfdd186qyf5olubJCBUNevrrbfeik033TRef/31OgMhl1xySRoAqy4pvd29e/e0nQTOfv3rX9coKZ9IZn6dfvrpceKJJ2ZLqDcUyZf3Qw45JH3P11xzzTjssMNq7ZeUjK+aBZcECG+++eYas+WSQMDMmTPT53UFD/LR4rjvqmvSpEn8/e9/T++NqvenSjJbNPl5n3zySXY2ZTKLtDbJ/VX1+/PFF1/EtttuG19//XWNPsnn8H//93/ZZQAShx56aKywwgq1BrQvvPDC7PNrr702DdDVNTP1448/jr/85S/ZgA4AAAAsLmJI+UkMSQwpIYZUU/J346yzzso+T+6J5O9J8h5XSdrJvurvY5LAmHzm80vWKikpSdsvvvhieu9VX94z8eyzz8Zvf/vb7PMkebQhJTUCQGNTOQUBAJaADh06pF/kq75oJgGFJODSvn37GrMak1lwyRf0JNCQzPo699xz4+c//3m6fn3yhTaZJfTVV1+lM+6qSl6vu+66tf7MddZZJ2666abYZ5990sDIu+++G+uvv36stNJKaVAsmSWWBMSS4EVyveTLcBIgqC6Z/ZV84f3Tn/6UPn/yySejf//+aUnvZKbS2LFj47nnnovx48enx5Py8b/73e+iofjXv/6VfokvKChIy6cnM6Xqcuqpp6avPwm47bfffnH77bdH375945VXXkmDK4lk5mNts+XyWX3fd9Ul1znllFPS+z65FwcNGpQGrpIZg8l9Uz2gdvnll6ezRGuTvM833nhjem+Vl5fHq6++mt7Hm2yySXosCfYln2MSkKuS3OtzL9VQXRI0TV7PNddckz5PSqDfc889MXDgwPQeT0rZJ7OMk9+bIUOGpH0233zzyEf7779/GiCvbty4cdl2EvBea6215jkveU8HDBiwRMYIAADAwhFDyk9iSGJIYki1x5CS3/nkM7r11luzfxuShKvkfU0kSwgm90SVfffdN02Wmp+VV145fb+T8SaSaz/00ENpcmOydGfyt6h6kugaa6yRJtUBAEtRBgBysNlmmyU1j9PtjDPOWOjzRo0alWnRokX23FNPPXWePrNnz86cdtppmebNm2f7zW8rKSnJHHroofP9uU8//XSmd+/eC3W9U045pdZrnHzyyfM9r7S0NHPttdemfavvr0uvXr2yfb755pta++y9997ZPv/4xz8y9W38+PGZzp07p9f/05/+tFDnXHrppXW+B61bt8689NJLmYaoPu+76r8fzz77bOa+++5L35v53TtXX331Qo3zwQcfzCy33HILHN9ee+2VmTJlykJd8/LLL5/v+Kq2goKCzOOPP77I92nSp6p/cm59qP6e/5Qt+XwAAABYfMSQxJDEkMSQloUY0owZMzKHHXZY+trn974cccQRmZkzZy70eG+44YYafwtr27bccsvM999/Xw/vDgCwKFTAAmCJ6tSpU/z5z39Oy7QnrrzyyjjmmGOibdu22T7J7LmkBPPhhx+ezqx76qmn0hk9Y8aMiVmzZqUzfJJZg6uvvno6k2qHHXZIrzs/ycygzz//PO688850plAyy2nUqFHpLLRkBmMyY2yDDTaI3XffPZ0NVpvzzjsvtt9++7jqqqvipZdeSmd1tWrVKnr06BHbbbddOpuvX79+0ZAks/SS9yGZQVq9BPb8JKXJk9leSfn/ZNZiMvuzS5cuaTnzZJZebaXKG4LFcd9VSUrNf/DBB2mJ9ocffji+++67dNZiz54903snKdm/sPdOUpp/8ODBafn+5F5OZo0mY0xKz3fr1i0dWzKDLpl5ubCSWXm///3v45ZbbonHH388+7oTHTt2jFVWWSUts5+Ul29o9zgAAAANkxhSfhFDmkMMSQypNslygsnfqT/84Q/pe55UxKqqMpYsTZpUNEt+95OqYT9FUgFrm222SauiPfjgg+k9kVQxSyrIJZX7ks9jt912SyvTAQBLV0GShbWUxwAA0KgkAZXnn38+bT/77LPpcwAAAACoTgwJAKDxKFzaAwAAAAAAAAAAAGioJGABAAAAAAAAAADkSAIWAAAAAAAAAABAjiRgAQAAAAAAAAAA5EgCFgAAAAAAAAAAQI4kYAEAAAAAAAAAAORIAhYAQD177rnnIpPJpNugQYOW9nAAAAAAyENiSADAoho1alQ89NBDcfrpp8f2228fHTt2jIKCgnTbZ599fvL1Hn300dh9992jR48e0bRp0/QxeZ7sX1izZ8+Oa6+9NjbZZJPo1KlTNGvWLPr27RsHHXRQfPzxx9FYFWSSf9UBAAAAAAAAAAANRpJoVZe99947brnlloW6TkVFRRx44IFx00031dln//33j+uuuy4KC+uu9TRmzJjYYYcd4s0336z1eJLUddVVV6XXamxUwAIAAAAAAAAAgAZs+eWXj2222Sanc0855ZRs8tXaa68d//73v+ONN95IH5PniRtvvDFOPfXUOq9RXl6eVsuqSr76xS9+kVbOev311+OKK66Izp07x4wZM9JKWD+lolZDoQIWAAAAAAAAAAA0MGeccUYMHDgw3ZZbbrkYMmRI9O7d+ydVwPriiy9itdVWS5cOHDBgQLzwwgvpsoFVpk6dGptttlm89dZbUVxcHJ9++mmsuOKK81zn5ptvjv322y9tH3LIIfH3v/+9xvHBgwfHuuuuG2VlZen5yXWS6zUWKmABAAAAAAAAAEADc9ZZZ8VOO+2UJl/l6vLLL0+TrxJXXnlljeSrRPPmzdP9iaTfZZddVut1LrnkkvSxffv2cfHFF89zPEm6Oumkk7LJWPfee280JhKwAAAAAAAAAABgGZMsmnf//fen7ZVXXjnWX3/9Wvsl+1daaaW0nfSfe7G9L774Iq1oldhjjz3SpK3a7LPPPtm2BCwAAAAAAAAAAKBB++abb+L7779P28kyg/NTdXz48OHpUofVvfTSS/P0q02XLl2if//+afvll1+OxkQCFgAAAAAAAAAALGM++eSTbDupgDU/1Y9XVbtalOsMHTo0pkyZEo1F8dIeAPOaPn16fPjhh2m7U6dOUVzsYwIAAFhWzJ49O0aPHp22V1999SgtLV3aQwKWMWJTAAAAy66GEJtKxjhy5MhoSEaMGLFQ37F79OgRS9KwYcMW+mf37Nkz206Spxb1OplMJj2vamnDhk70JA8lAa711ltvaQ8DAACApeyNN96IgQMHLu1hAMsYsSkAAADyOTaVJF9VTwZqTJKkpCVp0qRJ2XbLli3n27dFixbZ9uTJkxfLdRoySxACAAAAAAAAAMAyWAW7SpMmTebbt2nTptn2tGnTFst1GjIVsPJQUnauekZp165dl+p4AACAulWM2mRpD4FGZsQPs2P9HYbN8/0QYEkRmwIAgIZDbIplPTb12qM9o2vnoshXI0aVx/rbD83b79jVl5icOXPmfPvOmDEj227WrNl8r1M6n6Ur53edhkwCVh6qvuZn8su3pNf4BAAAFl5FtX+/w+L8fgiwpIhNAQBAwyE2xbIem0qSr3p0K4mGIB+/Y7dq1WqhlwOcMmVKncsMtprrOvNLwJrfdRqy/P9tAQAAAAAAAACAuVREJiqiIvJ5fPmsekLYsGGVlc/qMnRoZSWvRM+ePed7nY4dOy7wOgUFBXmXkLYoCpf2AAAAAAAAAAAAgCVr1VVXzbY/++yz+fatfnyVVVZZ5Ov07NkzWrRoEY2FBCwAAAAAAAAAAFjG9O7dO7p165a2n3/++fn2feGFF9LH7t27xworrFDj2MYbb5xtz+86I0eOjC+++CJtb7TRRtGYSMACAAAAAAAAAIBlTLIM4K677pqtTPXaa6/V2i/ZX1W5KumfnFdd//79s1Wx7r777pg6dWqt17nllluy7d133z0aEwlYAAAAAAAAAAA0OOWZirzf8t2RRx4ZRUVFafvwww+PadOm1TiePE/2J4qLi9P+tTn22GPTx3HjxsXxxx8/z/Gvvvoqzj///LS94oorNroErOKlPQAAAAAAAAAAAOCneemll2Lw4MHZ52PGjMm2k/3VK04l9tlnn3mukVSvOu644+KCCy6It956K10a8IQTToi+ffumSVMXXnhhvPvuu2nfpF+/fv1qHcvee+8dN998c7z88svx97//PV1u8IADDoh27drFG2+8Eeecc06UlZVFYWFhXHHFFWkyV2PSuF4NAAAAAAAAAAAsA2688cb45z//WeuxJBEq2RaUgJU477zzYtSoUWkCVZJsteeee87TZ7/99otzzz23zrEUFRXFfffdFzvssEO8+eabcc8996RbdU2bNo2rrroqtt9++2hsLEEIAAAAAAAAAECDUxGZvN8agqQq1U033RQPP/xw7LrrrtGtW7do0qRJ+pg8f+SRR9Jkr6Tf/HTs2DFeeeWVuPrqq2PjjTeODh06RGlpafTp0yethvX222/H/vvvH42RClgAAAAAAAAAANDAJEsMzr3M4KJIqlcl26IoLi6OP//5z+m2LFEBCwAAAAAAAAAAIEcqYAEAAAAAAAAA0OAki/wl/8vn8bFsUAELAAAAAAAAAAAgRxKwAAAAAAAAAAAAciQBCwAAAAAAAAAAIEfFuZ4IAAAAAAAAAABLS3kmk275Kp/HRv1SAQsAAAAAAAAAACBHErAAAAAAAAAAAAByZAlCAAAAAAAAAAAanIrIpFu+yuexUb9UwAIAAAAAAAAAAMiRBCwAAAAAAAAAAIAcWYIQAAAAAAAAAIAGpyIiyvN4mb9kfCwbVMACAAAAAAAAAADIkQQsAAAAAAAAAACAHEnAAgAAAAAAAAAAyFFxricCAAAAAAAAAMDSUhGZdMtX+Tw26pcKWAAAAAAAAAAAADmSgAUAAAAAAAAAAJAjSxACAAAAAAAAANDglGcy6Zav8nls1C8VsAAAAAAAAAAAAHIkAQsAAAAAAAAAACBHliAEAAAAAAAAAKDBqfhxy1f5PDbqlwpYAAAAAAAAAAAAOZKABQAAAAAAAAAAkCMJWAAAAAAAAAAAADkqzvVEAAAAAAAAAABYWioiE+WRiXweH8sGFbAAAAAAAAAAAAByJAELAAAAAAAAAAAgR5YgBAAAAAAAAACgwSlPtkx+j49lgwpYAAAAAAAAAAAAOZKABQAAAAAAAAAAkCNLEAIAAAAAAAAA0OBU/Ljlq3weG/VLBSwAAAAAAAAAAIAcScACAAAAAAAAAADIkQQsAAAAAAAAAACAHBXneiIAAAAAAAAAACwtFVEQ5VEQ+Tw+lg0qYAEAAAAAAAAAAORIAhYAAAAAAAAAAECOLEEIAAAAAAAAAECDU5Gp3PJVPo+N+tWoK2B99913ccYZZ8SAAQOiU6dOUVpaGj179oxNNtkkTj/99Pjoo48W+lpTp06NPn36REFBQbqtsMIKi3XsAAAAAAAAAABA/mu0CVhXXnllrLrqqnH22WfH22+/HWPGjIkZM2bEsGHD4qWXXopzzjknbrzxxoW+XpKw9c033yzWMQMAACwtt/13Uhx83KhYb9uh0azX4CjqOjhuuauszv5lkyrimDNGR+8BQ9L+fQYOiePPHhOTp1TU2r+iIhNX3TQh1tz8u2jR+6tYbrWv47d/Hhlffztrnr7l5Zk4///GxYo/HxLt+n8d2/xmeHzy+cxar3v9rROjZe+v4qsh814HAAAAgIZBbApo6BrlEoTnnntunHbaaWm7f//+ccABB8TAgQOjTZs2MXbs2Hj33Xfj3nvvjcLChcs/S/pffvnlaQWtkpKSmDRp0mJ+BQAAAEvW6ReOjW+HzY6O7Quja+fitF2XKVMrYvNfDIv3PpoZW2/WLPbcvWW8++GMuPSaCfHCq9PiuXu7R2lpze9bBx83Om66oyxWW6lJHL5fm/h+ZHn858FJ8eTzU+OVh3pEvz5Nsn0vv35CnHrBuNh+y+bRv09J3H7PpNhur+HxyYu9omWLOdcd8cPsOPHcsXHGse2j7woli+mdAQAAAGBxE5siV+VRkG75Kp/HRv1qdAlYTz/9dDb56o9//GNa5SpJmqpuyy23jGOPPTZmzqw9S7W68vLyNIEreUyWM7zpppskYAEAAI3O9Zd2jn69S6JXz5K48MrxcfJfx9bZ9+K/j08DXMcf1jbOP6Vjdv9J542Ji66akAapTjyifXb/sy9PTQNcm65fGo/f1T2aNKkMOuy1e8vY6fcj4vCTR8djd3bP9r/x9rLYctNm8dBt3dLnu+/QMgbtPjweenJK7Llbq2y/w04aHX2WL4mjDmpb7+8HAAAAAEuO2BTQ0DWqJQgrKiriz3/+c9pec80102SpuZOvqmvSZE4Wa13+7//+L13CcKWVVooTTjihXscLAACQL7batHka4FqQTCaTBqxatiiIU4+aE8hKJM+T/cnx6pKgVeKs4ztkA1yJ7bdsEYM2bBZPPj8tvhs2p0z70OGzY901mmafD1izaXZ/lf89PDkefGJKXH9ppyguNosMAAAAoCETmwIaukaVgPXEE0/El19+mbaTZKni4kUr8PXtt9/G6aefnravvfbahUrYAgAAaMy+/HpWWqJ9w4HNokXzml8pk+fJ/q+/nR1Dh88JWj3/yrRo0bwgNlqvdJ7rbTOoeWWfV6dl9/XsXpyWja/yzo/tZH9iYll5HHHK6DjywLaxzhrzXhMAAACAxklsCshXjSoB6z//+U/6WFBQEDvttFN2/7hx49LErOTxpzjkkENiypQp8Yc//CEGDRpU7+MFAABoaL78pjJ41a9P7TMSq/ZX9ZsytSJG/FAevZcviaKieWcDrti7sv/gH/sn9vtt63Tm4c5/+D6OOWN0/PJPI6Nbl6LYaesW6fHjzx4bzUoL4qzjas5yBAAAAKBxE5tibuVRkPcby4ZGlYD12muvpY8rrLBCtGrVKu64445YffXVo0OHDtG/f//0MVlK8JJLLokZM+ZkrNbmzjvvjEceeSTatWsXl1566RJ6BQAAAPltYllF+timVe1fJ1u3LKzRb4H9f9xf1S9x1EFt4+zj28cnn8+Mm/89KdZYtUk8fmf3aNmiMJ2xmJSRv+aizlFSUhDHnjkmOq7ydTRf4avYfZ8RMWrMnFLwAAAAADQuYlNAvlq0NfrySEVFRXz22Wdpu2PHjvGXv/wlrrjiinn6ffHFF3HcccfFvffeGw8//HC0bdt2nj7jx4+PI488Mm1fcMEF0alTp3od67Bhw+Z7fMSIEfX68wAAABqSZDbiKUe1T7fqpk+viIOPHxV/+HWr2GrT5nHBFePi6lsmxqVndYweXYvjiJNHx75/GRUP395tqY0doCEQmwIAAKib2BSwTCdgTZw4MU3CSnz44Yfx5ptvRteuXePiiy+OHXbYIUpLS9N9J5xwQlop65VXXok//elP8b///W+eayUJWj/88ENssMEGccABB9T7WHv27Fnv1wQAAFgS2rT+cVbgpDmzAqsrm1xRo98C+/+4v6rf/Jzzt/ExYWJFXHpmx/T5FTdOjD/8qlX8ee822Wv98bAf4vPBM2OlFZvk8OoAlg1iUwAAQEMlNsXcMpmIikxBXo+PZUOjWYJwypQp2fb06dOjefPm8eyzz8bvfve7dBnBZs2axaabbhrPPPNMrLnmmmm/pArW66+/XuM6L7zwQtx8881RXFwc1157bRQU5O8vKgAAwJLWr3dJ+vjl17NqPV61v6pfi+aF0XW5ovjmu1lRXj5vtGHwN5X9V/yxf10++GRGXHLN+LjsnI7Rvl1RTCwrjx9Gl8daP2ua7bP2j+3PBs/M+fUBAAAAkL/EpoB81WgqYCUVrqrbf//9Y6WVVpqnX5KIdd5558VOO+2UPr/rrrvi5z//edqeMWNGHHjggZHJZNIlDNdYY43FMtahQ4cusMz7euutt1h+NgAAwKLo16ckunUpilfenBZTplakQawqyfNkf+/li6Nn9zlBq003aBZ33Tc5Xn5jetqu7onnplb2Wb/m/uqS4NiBx4yKbQY1jz13a1Xj2IwZcwJnM2ZWtk2kAZg/sSkAAKChEpsC8lWjqYDVqlXNP3TbbLNNnX233HLLtMJVIlmWsEqSmPX555+nZdjPOuusxTbWHj16zHdLlk4EAADIR0kAab/fto7JUzJx7mXjahxLnif79/9d6xr7D/h95fMzLhobM38MRCUefXpKPPfKtNh6s2bRq2fdswyvuGFCfPrlzLj6gk7ZfW1aF6WzFx95ZkqN6yVW6Tf/GYsAyzqxKQAAoKESm2Ju5VGQ9xvLhkZTAatp06bRqVOnGD16dPo8SaKaX7Wsjh07xsiRI7P9ExdeeGH6uNVWW8WDDz4436UOk8c777wzbXfu3Dm22GKLen09AAAAS9KNt09MZwEmPvq0skz6zbeXxfOvTEvbG61XGvv/rk3aPu7QdvHA41PioqsmxLsfzoh1Vm8a73w4I558floMXKtp/OWAtjWuvflGzdPA2E13lMWAbYbGDls1jxE/lMfdD0yK9u0K44rz5gSv5jZk6Kw44+Jx8deTO9SYuZg4Yv+2cdJ5Y2On338fPboWxz/uLIsdt24e/fo0qff3BwAAAIDFR2wKaOgaTQJWYrXVVovnnnsubZeXl8+3b9XxqkpYiZkzK/+Q/+Mf/0i3+RkzZkzstddeaXuzzTaTgAUAADRoSYDrX3dPqrnvzenpVqUqyJWUdn/2f93jrEvGxf8erpwp2LVzcRx9cNs4/Zj20azZvMWWr724U6y+SpO44bayuOLGidGyeUHstn3LOPfEDtF3hbpnBR583Kj0vEP2rfzZ1R3z57Yxdnx53HJnWTz3ciZ23qZFXHtR50V8JwAAAABY0sSmgIauIJPJzKmx18CdccYZcfbZZ6ft//73v/HLX/6y1n5lZWXRtm3bSF56slTh448/vkhrsSYJWFWJX/Vh2LBh2QpeQ4cOTUu/AwAA+aliZL+lPQQamWHfz45e6w5J274TAkuD2BQAADQcYlMsi7Gp6t9bH3mtayzXNX9rD/0wYnbssP6IvH4/qR/zpn42YNUTru699946+yXHqvLONtlkk+z+ZN+Ctl69eqV9k8eqffWZfAUAAAAAAAAAwIKVR2HebywbGtUnvcYaa8T222+ftv/973/H008/PU+fkSNHxqmnnpq2mzRpEvvuu+8SHycAAAAAAAAAANA4NKoErMTll1+eLi9YUVERO+20U5x00knx4osvxltvvRVXX311DBw4MC1HlzjnnHOie/fuS3vIAAAAAAAAAABAA5W/C2HmqH///vHggw/Gr371q/jhhx/iggsuSLfqCgoK4pRTTonjjz9+qY0TAAAAAAAAAIDcZTIFUZEpiHweH8uGRpeAldh4443j448/jiuvvDLuu++++Oabb2LmzJnRtWvXGDRoUBx++OGx9tprL+1hAgAAAAAAAAAADVyjTMBKdOjQIc4888x0q09Dhgyp1+sBAAAAAAAAAAANV6NNwAIAAAAAAAAAoPEqj4J0y1f5PDbqV2E9Xw8AAAAAAAAAAGCZIQELAAAAAAAAAAAgRxKwAAAAAAAAAAAAclSc64kAAAAAAAAAALC0lGcK0y1f5fPYqF8+aQAAAAAAAAAAgBxJwAIAAAAAAAAAAMiRJQgBAAAAAAAAAGhwKqIgKvK49lAyPpYN+XsXAgAAAAAAAAAA5DkJWAAAAAAAAAAAADmyBCEAAAAAAAAAAA1OssRfeR4v82cJwmWHClgAAAAAAAAAAAA5koAFAAAAAAAAAACQIwlYAAAAAAAAAAAAOSrO9UQAAAAAAAAAAFhayjOF6Zav8nls1C+fNAAAAAAAAAAAQI4kYAEAAAAAAAAAAOTIEoQAAAAAAAAAADQ4FVGQbvkqn8dG/VIBCwAAAAAAAAAAIEcSsAAAAAAAAAAAAHJkCUIAAAAAAAAAABqciiiM8jyuPZSMj2WDTxoAAAAAAAAAACBHErAAAAAAAAAAAAByJAELAAAAAAAAAAAgR8W5nggAAAAAAAAAAEtLeaYw3fJVPo+N+uWTBgAAAAAAAAAAyJEELAAAAAAAAAAAgBxZghAAAAAAAAAAgAanIgqiIo9rDyXjY9mQv3chAAAAAAAAAABAnpOABQAAAAAAAAAAkCNLEAIAAAAAAAAA0OBUZAqiPFOQ1+Nj2aACFgAAAAAAAAAAQI4kYAEAAAAAAAAAAORIAhYAAAAAAAAAAECOinM9EQAAAAAAAAAAlpbyKEy3fJXPY6N++aQBAAAAAAAAAAByJAELAAAAAAAAAAAgR5YgBAAAAAAAAACgwanIFKZbvsrnsVG/fNIAAAAAAAAAAAA5koAFAAAAAAAAAACQI0sQAgAAAAAAAADQ4JRHYbrlq3weG/XLJw0AAAAAAAAAAJAjCVgAAAAAAAAAAAA5koAFAAAAAAAAAACQo+JcTwQAAAAAAAAAgKWlIiLKMwWRz+Nj2aACFgAAAAAAAAAAQI4kYAEAAAAAAAAAAOTIEoQAAAAAAAAAADQ4FVGYbvkqn8dG/ZKABQDAMqNiZL+lPQQaoZ2+2H5pD4FGZtqoyRHxj6U9DAAAAOqZ2BSLQ3mmYmkPgUbGPQW5kWoHAAAAAAAAAACQIxWwAAAAAAAAAABocMozhemWr/J5bNQvnzQAAAAAAAAAAECOJGABAAAAAAAAAADkSAIWAAAAAAAAAABAjopzPREAAAAAAAAAAJaWiihIt3yVz2OjfqmABQAAAAAAAAAAkCMJWAAAAAAAAAAAADmyBCEAAAAAAAAAAA1ORaYwyjOFeT0+lg0+aQAAAAAAAAAAgBxJwAIAAAAAAAAAAMiRJQgBAAAAAAAAAGhwyqMgyvO49lAyPpYN+XsXAgAAAAAAAAAA5DkJWAAAAAAAAAAAADmSgAUAAAAAAAAAAJCj4lxPBAAAAAAAAACApaUiU5Bu+Sqfx0b9UgELAAAAAAAAAAAgRxKwAAAAAAAAAAAAcmQJQgAAAAAAAAAAGpyKKIzyPK49lIyPZYNPGgAAAAAAAAAAIEcSsAAAAAAAAAAAAHJkCUIAAAAAAAAAABqcikxhuuWrfB4b9csnDQAAAAAAAAAAkCMJWAAAAAAAAAAAADmSgAUAAAAAAAAAAJCj4lxPBAAAAAAAAACApaU8CtItX+Xz2KhfKmABAAAAAAAAAADkSAIWAAAAAAAAAABAjixBCAAAAAAAAABAg1ORKUy3fJXPY6N++aQBAAAAAAAAAAByJAELAAAAAAAAAAAgR5YgBAAAAAAAAACgwamIiPIoiHweH8sGFbAAAAAAAAAAAAByJAELAAAAAAAAAAAgRxKwAAAAAAAAAAAAclSc64kAAAAAAAAAALC0VGQK0y1f5fPYqF8+aQAAAAAAAAAAgBxJwAIAAAAAAAAAAMiRBCwAAAAAAAAAABqc8kxh3m9LwsyZM+PGG2+MbbfdNrp27RpNmzaNli1bxkorrRT77rtvvPLKKwt1nUcffTR233336NGjR3qN5DF5nuxn/ooXcBwAAAAAAAAAAMhD3377bey4447x8ccfz5OU9cUXX6TbLbfcEocffnj83//9XxQUFMxzjYqKijjwwAPjpptuqrF/+PDh6XbffffF/vvvH9ddd10UFqr1VBvvCgAAAAAAAAAANDCzZs2qkXy1xhprpMlWr776ajzxxBNx+umnR4sWLdJjV155ZVx44YW1XueUU07JJl+tvfba8e9//zveeOON9DF5nkgqbJ166qlL7LU1NCpgAQAAAAAAAADQ4GSiICpi3opO+TS+xen+++/PJl9tsMEG8eKLL0ZRUVH2+NZbbx277LJLeixJ1koSsI499tgoLp6TLpRUyLrkkkvS9oABA+KFF16IZs2apc8HDhyYnr/ZZpvFW2+9FRdffHH86U9/ihVXXHGxvq6GSAUsAAAAAAAAAABoYF555ZVs+6STTqqRfFVl3XXXjZ122iltT5gwIT799NMaxy+//PKYPXt2tkpWVfJVlebNm6f7E0m/yy67bLG8loZOAhYAAAAAAAAAADQwM2fOzLb79OlTZ7++ffvWek4mk0mraCVWXnnlWH/99Ws9P9m/0korpe2kf3IeNUnAAgAAAAAAAACgwSnPFOb9tjhVJUUlvv766zr7ffXVV+ljQUFB9OvXL7v/m2++ie+//z5tJ8sMzk/V8eHDh8eQIUMWeeyNjQQsAAAAAAAAAABoYPbaa69o3bp12r7wwgujvLx8nj7vvvtuPPzww2n7t7/9bbZ/4pNPPsm2kwpY81P9+NzLGBJRvLQHAAAAAAAAAAAAjdmIESMW2KdHjx4/6ZodO3aMW2+9NU3Eevnll2PgwIFx5JFHRv/+/WPy5MnpvksvvTRddnCdddZJ29UNGzZsoX92z549s+2hQ4f+pHEuCyRgAQAAAAAAAADAYrTeeustsE8mk/nJ191ll13i7bffTpOrbrrppth7771rHF9uueXinHPOiQMOOCCaN29e49ikSZOy7ZYtW87357Ro0SLbTpK7qEkCFgAAAAAAAAAADU5FFERFpiDyeXyLW1Ld6l//+lfcf//9tSZw/fDDD3HbbbdF796902St6qZPn55tN2nSZL4/p2nTptn2tGnT6mXsjYkELAAAAAAAAAAAWIzeeOON6Nq1a71ec8qUKbH99tvHiy++GEVFRXH88cfHvvvuG3369EmTq15//fU4++yz46WXXorddtstLrnkkjj66KOz55eWltZI5JqfGTNmZNvNmjWr19fRGEjAAgAAAAAAAACAxShJvurRo0e9XvPMM89Mk68Scy8/mFS02nrrrWPzzTePbbbZJp599tk47rjjYsstt4w111wz7dOqVauFXlYwSfZa2OUKl0WF0YiUlZXFnXfeGcccc0xsttlmseKKK0abNm3Sm6pz584xaNCguOiii2Ls2LF1XmPWrFnx2GOPxVFHHRUbbrhhdOzYMUpKSqJt27axzjrrpDfj119/vURfFwAAAAAAAAAANZVHQZRHYR5vi28JwmS5wZtvvjlt9+/fv0byVXXFxcVxzjnnpO2Kioq45ZZbsseqJ4QNGzZsvj9v6NCh2XbPnj0XefyNTXFjK9e211571Xps9OjR8fzzz6fbxRdfnK5vue22287TZ5VVVqk1QWvixInx7rvvptsVV1yRJnL95S9/WWyvBQAA6nLbfyfFS69Pi3c+mBEffjYjkqrAN13eOfb5Teta+5dNqoizLhkb/3t4SowcPTu6di6OX+3cMk4/pn20bDHvnIyKikxc/Y+JccNtZTF4yKxo2bwgtty0eZx7Yofo06ukRt/y8kxcdNX4uOmOshg7viIGrt00Lj+7U6y60rxrxV9/68Q4+vQx8f6zy0ffFWpeh/w17NFP48MLnppvnw7r9Ij1Lts9bZd9OTpGPPtllH0xOiZ+MSpmTZwe7dfqHj//v1/Uem75jNnxxQ2vxsjnBqft9mt2i1WO2CyadZ53BtXn17+SjmfTf/0uSlrNKY0NAAAALDliUyxJyf1w7S1lccudk+LzwbOiuDhizdWaxlEHt4mdt20xT/833pkeF1wxIV59c3pMmlIRy3cvjj12bRknHN42mjWreb9Nn14Rp10wPu55cHJMnZ6JTdYvjcvO6Rg9us2bRnHq+ePin3dOig+e7xHt2hYt1tcMC+uHH36IcePGpe211157vn3XXXfdbPuzzz7LtlddddVa99em+vEkt4ZGnIBVlWWXlE9Lbp6knZRwSzL4kky9//73v/G///0vxowZE7vsskuasFVVVq1qvcqq5Ku11lordt111/j5z38eyy23XJqA9eijj8aVV16ZrpN55JFHpmtaHnjggUvx1QIAsCw6/cKx8e2w2dGxfWEasEradZkytSI2/8WweO+jmbH1Zs1iz91bxrsfzohLr5kQL7w6LZ67t3uUltYMPBx83Og0aLXaSk3i8P3axPcjy+M/D06KJ5+fGq881CP69ZkTwLr8+glx6gXjYvstm0f/PiVx+z2TYru9hscnL/aqEUAb8cPsOPHcsXHGse0FuBqY1it2jBX3Wa/WYyOfHxyTvxkXHQcun933w0tfx9e3vx0FJYXRoke7NAFrfj675qX47r4Po+vm/aKkTWkMf/TTeOfkh2LD6/aIgqI591DZV2PimzvfjTVP3UbyFQAAACxFYlMsKUl1n70OGhX3Pjwl+q5QHPvu1SpmzMzEg49PjV/u+0Ncfm6HOORPbbL9731kSvzu4B+iqKggdt+hRXTpXBSvvDk9/nr5hHju5Wnx+N3domnTOdWITjh7XFz7z7L41c4tomP7ovjnXZPiF/uMjFcf7Z5eo8oHn8yIv10zIf55VWfJV+SVpLJVldmz6/5bXLUaXG3n9e7dO7p16xbff/99WtBofl544YX0sXv37rHCCisswsgbp0aVgJUkXn333Xd1Ht9jjz3ivvvui9133z1mzpwZZ511VpqQVaWgoCBd//Lss8+O9ddfv9br//KXv0wfp02bFscff3xacav6mpgAALC4XX9p5+jXuyR69SyJC68cHyf/te4lti/++/g0wHX8YW3j/FM6ZvefdN6YuOiqCWmQ6sQj2mf3P/vy1DTAten6pfH4Xd2jSZPKQMNeu7eMnX4/Ig4/eXQ8dmf3bP8bby+LLTdtFg/d1i19vvsOLWPQ7sPjoSenxJ67zfl38mEnjY4+y5fEUQe1rff3g8Wrdb9O6Ta3ilnl8e29H6RJUt23mzPbqcugFaPzRr2jVZ8OafLVM7+oLIFdm0xFJoY9/En02GHVWP34LdN9bVfpEh/89cmY8NmoaLdal8p+5RXx0UVPR6ef94quW/RbLK8TAAAAWDhiUywpSdW0JPlqw4FN49E7u2YrWJ1zYnlssP3wOOGccbHD1s1jhZ4lMW1aRRx2wugoKIh4/v5usc4aTbNJXEeeMjauuaUs/u/6iXH84W2zlbX+ceekNKnr2ksqY18D12kafzpidLz13oz4+bql2SprBx87JrbdvHn8epd5K7az9GUyBVGRWXzL/NXH+BaX9u3bR+vWraOsrCxeffXVNAmrenJVddWTq5Kkq+p5MklxomuuuSatcPXaa6/Vmi+T7K+qgJX0T86jpnlrOjZgRUULzjbdbbfdYqWVVkrbL774Yo1jSZbeE088UevNVCWpiHXIIYek7aQq1pNPPrnI4wYAgJ9iq02bpwGuBUmCC0nAqmWLgjj1qDmBrETyPNmfHK8uCVolzjq+QzbAldh+yxYxaMNm8eTz0+K7YXNmygwdPjvW/TGYkRiwZtPs/ir/e3hyPPjElLj+0k5RXOxLWWPxw4tfpwlWnTdYIZq2b57d36p3h2jTv3MUFi/4+9nMidOiYmZ5tFmpc3ZfVXv6D5Oy+4b89/2Y/N34WPWoQfX+OgAAAICfRmyKJSWpdJU44Yh2NZYP7NihKI44sE3MmJFJlwVMvPrWjBg9tiJ22a5FNvkqkSSJnHVCu7R9w61l6X2ZGDOuIqZPz9Tou+6P98931e6fK2+cGJ8PnhlXnj8ngRDyRWFhYey4445pO6lgdd5559Xab/z48XHCCSdkn++00041jicrwFXl2xx++OFpQaLqkufJ/kSS4JX0p5EnYC2sqopVyVKCuUgqYFX56quv6m1cAABQn778elZaon3Dgc2iRfOa//RPnif7v/52dgwdPido9fwr06JF84LYaL15l3jbZlBlks3zr8758tWze3FaNr7KOz+2k/2JiWXlccQpo+PIA9vGOmtYNq4xGfrwx+ljj51WzfkaTdo0i8ImRVH25ejsvok/tkuXq/zeNnVEWXz5j9djpQM3jGadzTIEAACAhkJsikX1w6jy9HGF5eet6LNCz8p9z71c+d/8R46eXWN/dW3bFEW7toXpcpnJPZdIltAsLS2I9z6ac/9U3UvL/3j/DBk6K866eHyce1L76NGtUS0uRiNy+umnR/PmlX8fzzzzzNhll13innvuiXfffTetinXZZZfFWmutFZ988knaZ8stt4xtttmmxjX69+8fxx13XNp+6623YqONNoq77rorbSePyfOknUj69etnlYLaLHN/JT7//PN477330vbKK6+c0zVmzJjxk6puAQDA0vDlN5XBq359ap+RmOx/4rnKfj27l8SUqRUx4ofy+NnKTaKoaN7ZgCv2rrzO4B+vm9jvt63jhHPGxs5/+D769ymJ2++ZHN26FMVOW7dIjx9/9thoVloQZx1Xc5YjDdu0kWUx9p1hUdqpZXRar1fO1ykoLEiXH/zu/g9j9tRZ0aR1aQx77NN0ycO2K1dWwvr40mejVd+Osfxuq9fjKwAAAAAWN7EpFlWH9pWJe0O+mx2r9GtS49iQobOziX6Jju2LauyvbmJZRYyfUJHt33eFkigsLIh9ftMqrvtXWUyaXBEd2hXFv+6eFGv9rEkMWKuyEtahx4+JNVZtEgfv03oxv1LIXZL3cv/998dee+0VY8aMiQcffDDdarPFFlvEf/7zn1qPJdWzRo0aFTfffHOavLXnnnvO02e//faLc889t95fQ2OxTCRgTZ06NYYPH57eZBdddFG67mUi17Jo1dfGXGWVVeptnAAAUJ+SwEKiTavaC9+2bllYo98C+/+4v6pf4qiD2qalvm/+d1m89Pr0GLhW07j8nE7RskVhOmMxKSP/2J3doqSkII49c0zccldZTJ2WiW0HNY/rLukUnTsuE19JGp1hj34aUZGJ7tuvEgVFi1ZYeeVDNo6C4sIY+dzgqJgxOzoO6BmrHLFZet3hj30aY98bFhvduFeUT5sVn/zf8zHy+coqxF026xurHjkoipsteMkDAAAAYMkTm2JRbbtF87j7/ilx8VUTYvONSqO0tPIeGDuuPK68YWLanlBWWSVrw4Gl0bpVQTzw2JS0ktXaq89ZWvCsi8dl2xMmzrl/Ljy9fZSURNzz0JSYNj0TW27aLC47p2OaAHjrfyal1dbeeKJHTJmaib+cMjr+99CU9Lxf7NQirvhrx3kqu7F0VERhuuWrJTG2rbbaKj777LO46aab4tFHH42PP/44JkyYkC4X2KVLlxg4cGD89re/TatjJcty1rWcYXL+L3/5y7j++uvjzTffTBO6OnbsmJ5/0EEHxfbbb7/YX0tD1mj/H+WWW26Jfffdt87jJ554YnqD/VQjRoyIf/zjH2m7U6dONZYjXFjDhg1b4M8AAICGIAlGnHJU+3Srbvr0ijj4+FHxh1+3iq02bR4XXDEurr5lYlx6Vsfo0bU4jjh5dOz7l1Hx8O3dltrYyU2mIlOZgFUQ0WOHRZ+QUtS0OFY9fNN0q27GhGnx6dUvRd/fDYhWK7SPjy55Jn546Zv42TGbRxQUxMeXPRdFTUtitaMHLfIYAJY1YlMAADQWYlON2167t4xb756ULjO4zpbD0mUoZ83OxAOPTY3OnSorXiWVrBJJ0t3FZ3SIg44dE5vu8n38YscW0aVTUbz61vR0acqVViyJzwfPisJquTDNmhXGpWd3TLfqRo8tj+PPHBvHH9Y2Vu3fJA45fnQ8+PjUuPqiTklYKo44eUw0bzYurjy/5nmwNHXo0CGOP/74dFsUO+ywQ7rx0zXaBKy6JGtbJtl6SYbeT5XJZNKsvkmTJqXPTzvttCgt/elrBffs2fMnnwMAAD9Vm9Y/zgqcNGdWV3Vlkytq9Ftg/x/3V/Wbn3P+Nj6dTXbpmZVBiCtunBh/+FWr+PPebbLX+uNhP8Tng2fGSivWLB9Ofhvz9tCY/sOk6LBuj2jetfLzXBw+veKFaNquefT9/YCYPXVmDHvk0+i373rRbeuV0uNTR0yMwbe8ESsdvGEUN3cPAfwUYlMAACwJYlMsquLignjwtq5x0VUT4s57J8eNt5elFdJ23b5FHHVw21ht46HRuUNlIlZi39+2jq5diuPSqyfEg49PifLySJcTfPyubnHx3yekCVidO87pX5ejTxuTJnideES7dHnCW+6cFKcf2y72+kXL9Pg3382Kc/82Ps4/tX2a+AXQqBOwdttttxgwYEDanjZtWnz11Vdx9913x7333puufXn55ZfHTjvt9JOu+de//jW7VmZS+erQQw9dLGMHAID60K935dJsX349q9bjVfur+iUls7suV5QGEMrLM+kMwuoGf1PZf8Uf+9flg09mxCXXjI9/XrlctG9XFBPLyuOH0eWx1s/mlP1e+8f2Z4JcDc6whz5OH3vsuNpi+xmjXhsSI579Mta/8pdRWFIUk78dF5nyimjVr1O2T+t+nSIzuyKmfj8xWq84Zz8AAACQH8SmqA9NmxbEace0S7fqkiUmE+usWfPz226L5uk2t32PmJlWv6q+NGFtHn16avzngSnx7L3dokmTgvj0y5kxe3bEmqvNOS+5l2bNivhqyKwa+1k6yjMF6Zav8nls1K9Gm4DVtm3bdKuSVLzac88949Zbb4299947dt1113T9yn322Wehrnf77benFa8SvXv3jjvuuCNdAzMXQ4cOXWCZ9/XWWy+nawMAQJV+fUqiW5eieOXNaTFlakUaxKqSPE/2916+OHp2nxO02nSDZnHXfZPj5Temp+3qnnhuamWf9Wvury4Jjh14zKi0HPieu7WqcWzGjMyc9szKdl3rzZOfZk6cFj+8/HWUtC6N5Tbpu1h+RlLt6uO/PRfL7/qzaPezrjWOVcwsn7ftHgL4ycSmAABYEsSmWJz+/b/J6eMeu1ZWpZqfV96YHkOGzo7tt2w23wpqk6dUxOEnjomD/tg6NhhYcyWsqnumetvtA1S3zNXD+8Mf/hC//vWvo6KiIg477LAYN27cAs95+OGHY999902XIOzSpUs8+eST6WOuevToMd+ta9ea/5EBAABykQSQ9vtt65g8JRPnXlbz373J82T//r9rXWP/Ab+vfH7GRWNjZrWgwqNPT4nnXpkWW2/WLHr1rHuW4RU3TEhnhV19wZyKRG1aF6WzFx95ZkqN6yVW6Tf/GYvkl+FPfB6ZWRXpMoBFTRZcrj0XX9zwakRFJlY6cMPsvubd2kRBcWGMfm1Idl/SLigpTI8B8NOITQEAsCSITVEfqpaerO6ehyanywImywvuvkOL+fb9fuTsOOjY0VFcHHHmce3n+7NOO39cVFRk4tyT5/Tru0JJlJREPPZ0ZQJgImk3aVJ5DKDRV8Can6T6VbIc4ZQpU+Kxxx6L3/72t3X2fe655+JXv/pVzJo1K9q1axePP/549O27eGZ6AwDAwrjx9onpLMDER5/OTB9vvr0sW3Z7o/VKY//fVSalHHdou3jg8Slx0VUT4t0PZ8Q6qzeNdz6cEU8+Py0GrtU0/nLAnKqxic03ap4Gxm66oywGbDM0dtiqeYz4oTzufmBStG9XGFecV/dSb0OGzoozLh4Xfz25Q42Zi4kj9m8bJ503Nnb6/ffRo2tx/OPOsthx6+bRr48S7w3JsIc/SR977rhqnX2S5QK/vuPttF0+Y3blvu/GxwfnP5nts8ZJW9d67viPR8a3930Y65y7YxQ3n3NvJO0eO6waQx/4KHvNEU99Eb12XyOKmwl0AQAAwJIkNsWStNGOw6Nnt+JYuV9JuhzhW+/NiOdfmR59ehXHv6/vXGOpyqtumhh33DM5vQc7dSyKYd/PjgcfnxJTp2Xiuks7xdpr1L1c4OtvT49rbimL/968XLRqOaeOTcsWhbHvXq3i+n9NSq+TuPPeyXHIvq1rVHVj6anIFKRbvsrnsVG/lskErE6d5vwf87fffltnvzfeeCN23nnnmD59erRs2TIeffTRWGONNZbQKAEAoHZJgOtfd0+que/N6elWpSrIlQQBnv1f9zjrknHxv4crZwp27VwcRx/cNk4/pn00azZvkODaizvF6qs0iRtuK4srbpwYLZsXxG7bt4xzT+ww31ldBx83Kj3vkH3nrUh0zJ/bxtjx5XHLnWXx3MuZ2HmbFnHtRZ0X8Z1gSZrw6ciY/M3YaLPKctGqb8c6+80YNzWGP/ZZjX0z59pXWwJWxezy+OjiZ6LLZn1juY16z3N85UM2jszsihj5/OD0eY8dV42V/rzRIr4qAAAA4KcSm2JJ+vUuLeK+R6fG6+9Mj1mzI1boWRwnHdk2/Uxbt6p5/2wwoDRefHV6PPzk1Bg/sTw6tCuK7bZoHsce2jbWXr3u5KtZszJx8HGj4xc7toidtplTUavKhad3iJkzI/73cOWyh0lC1vmnzr+aFrDsKcgk6+otY2655ZZ0ScHEFVdcEYcffvg8fT744IMYNGhQjB8/PkpLS9Pkq+T5kjBs2LDo2bNn2h46dGha+h0AgEVXMbLf0h4CjdBOX2y/tIdAIzNt1OR47tf/SNu+EwJLg9gUAMDiITbF4lCemXfZPVgUSeWwPgO+y+vvhNW/t+776C7Rarnmka8m/TA1/rH9A3n9flI/lsmaeP/5z3+y7dVXX32e41988UVss802afJVSUlJ3HPPPUss+QoAAAAAAAAAAGg4ChtbZatkucD5ueyyy+KRRx5J2717945NNtmkxvHvvvsuttpqq/jhhx+iqKgo7rjjjthhhx0W67gBAAAAAAAAAPhpMpnCqMjjLRkfy4biaETOPPPMOOaYY+KXv/xlbLzxxtG3b99o2bJlTJo0KT788MO4/fbb4+WXX077NmnSJK6//vo0yarK2LFj0+SrpOxbIrnWyiuvHB999FGdP7Ndu3bRvXv3JfDqAAAAAAAAAACAfNOoErAS48aNixtuuCHd6pKsqXnzzTenyVbVJUlaX375Zfb5RRddlG7zs/fee6eVtwAAAAAAAAAAgGVPo0rAevzxx+Phhx9Oq1wNHjw4XUYwqWrVrFmz6Ny5c6y11lqx0047xR577BHNmzdf2sMFAAAAAAAAACBH5VGQbvkqn8dG/WpUCVgrrbRSuh199NE5nT9o0KDIZDL1Pi4AAAAAAAAAAKBxKlzaAwAAAAAAAAAAAGioGlUFLAAAAAAAAAAAlg0VmWQryOvxsWxQAQsAAAAAAAAAACBHErAAAAAAAAAAAAByJAELAAAAAAAAAAAgR8W5nggAAAAAAAAAAEtLRaYw3fJVPo+N+uWTBgAAAAAAAAAAyJEELAAAAAAAAAAAgBxZghAAAAAAAAAAgAYnEwVREQWRz+Nj2aACFgAAAAAAAAAAQI4kYAEAAAAAAAAAAOTIEoQAAAAAAAAAADQ45ZmCdMtX+Tw26pcKWAAAAAAAAAAAADmSgAUAAAAAAAAAAJAjCVgAAAAAAAAAAAA5Ks71RAAAAAAAAAAAWFoqMoXplq/yeWzUL580AAAAAAAAAABAjiRgAQAAAAAAAAAA5MgShAAAAAAAAAAANDgVURAVmYLI5/GxbFABCwAAAAAAAAAAIEcSsAAAAAAAAAAAAHJkCUIAAAAAAAAAABqcTLIEYR4v85eMj2WDClgAAAAAAAAAAAA5koAFAAAAAAAAAACQIwlYAAAAAAAAAAAAOSrO9UQAAAAAAAAAAFhaKjLJVhD5PD6WDSpgAQAAAAAAAAAA5EgCFgAAAAAAAAAAQI4sQQgAAAAAAAAAQINTkSlMt3yVz2OjfvmkAQAAAAAAAAAAciQBCwAAAAAAAAAAIEeWIAQAAAAAAAAAoMGpyBSkW77K57FRv1TAAgAAAAAAAAAAyJEELAAAAAAAAAAAgBxJwAIAAAAAAAAAAMhRca4nAgAAAAAAAADA0lIRBemWr/J5bNQvFbAAAAAAAAAAAAByJAELAAAAAAAAAAAgR5YgBAAAAAAAAACgwclkCqIiU5DX42PZoAIWAAAAAAAAAABAjiRgAQAAAAAAAAAA5MgShAAAAAAAAAAANDgVeb4EYT6PjfqlAhYAAAAAAAAAAECOJGABAAAAAAAAAADkSAIWAAAAAAAAAABAjopzPREAAAAAAAAAAJaWikxBuuWrfB4b9UsFLAAAAAAAAAAAgBxJwAIAAAAAAAAAAMiRJQgBgLxUMbLf0h4CjdCRIwYs7SHQCH0ztv3SHgKNzKzxvqoDAMDSJjbF4lCeqVjaQ6ARGlE+dWkPgUZmVEV5NCSWICRfqIAFAAAAAAAAAACQIwlYAAAAAAAAAAAAObKuAQAAAAAAAAAADU4mWeYvCvJ6fCwbVMACAAAAAAAAAADIkQQsAAAAAAAAAACAHEnAAgAAAAAAAAAAyFFxricCAAAAAAAAAMDSUpEpSLd8lc9jo36pgAUAAAAAAAAAAJAjCVgAAAAAAAAAAAA5sgQhAAAAAAAAAAANTkXk+RKEkb9jo36pgAUAAAAAAAAAAJAjCVgAAAAAAAAAAAA5sgQhAAAAAAAAAAANTrL8YF4vQZjHY6N+qYAFAAAAAAAAAACQIwlYAAAAAAAAAAAAOZKABQAAAAAAAAAAkKPiXE8EAAAAAAAAAIClpSJTkG75Kp/HRv1SAQsAAAAAAAAAACBHErAAAAAAAAAAAAByZAlCAAAAAAAAAAAankxBZPJ5mb98Hhv1SgUsAAAAAAAAAACAHEnAAgAAAAAAAAAAyJElCAEAAAAAAAAAaHAqoiDd8lU+j436pQIWAAAAAAAAAABAjiRgAQAAAAAAAAAA5EgCFgAAAAAAAAAAQI6Kcz0RAAAAAAAAAACWlopMQbrlq3weG/VLBSwAAAAAAAAAAIAcScACAAAAAAAAAADIkSUIAQAAAAAAAABocDKZgnTLV/k8NuqXClgAAAAAAAAAAAA5koAFAAAAAAAAAACQI0sQAgAAAAAAAADQ4FRkkq0gr8fHskEFLAAAAAAAAAAAgBxJwAIAAAAAAAAAAMiRBCwAAAAAAAAAAIAcFed6IgAAAAAAAAAALC2ZTEG65at8Hhv1SwUsAAAAAAAAAACAHEnAAgAAAAAAAAAAyJElCAEAAAAAAAAAaHCSJf4q8niZP0sQLjtUwAIAAAAAAAAAAMiRBCwAAAAAAAAAAIAcWYIQAAAAAAAAAIAGJ5Mu8xd5K4+HRj1TAQsAAAAAAAAAACBHErAAAAAAAAAAAAByJAELAAAAAAAAAAAgR8W5nggAAAAAAAAAAEtLRRSkW77K57FRv1TAAgAAAAAAAAAAyJEELAAAAAAAAAAAgBxZghAAAAAAAAAAgAYnkylIt3yVz2OjfjW6ClijRo2Khx56KE4//fTYfvvto2PHjlFQUJBu++yzT07XfOqpp9JzV1xxxWjRokW0adMm+vfvH7/61a/immuuicmTJ9f76wAAAAAAAAAAAPJfo6uAtdxyy9XbtcaPHx/77rtv3H///fMcKysriy+//DLuueee2GCDDWKttdaqt58LAAAAAAAAAAA0DI0uAau65ZdfPlZeeeV44oknfvK5EydOjK233jrefvvt9Pnuu++eVrzq27dvFBUVxdChQ+P5559PE7AAAOpy238nxUuvT4t3PpgRH342I2bOjLjp8s6xz29a19q/bFJFnHXJ2Pjfw1Ni5OjZ0bVzcfxq55Zx+jHto2WLeYuXVlRk4up/TIwbbiuLwUNmRcvmBbHlps3j3BM7RJ9eJTX6lpdn4qKrxsdNd5TF2PEVMXDtpnH52Z1i1ZWazHPd62+dGEefPibef3b56LtCzeuQvz594Ot46sw35tunx8DOsft1W2SfT/huUrx10yfx/XujY/KoaVHaukm079M61tizf/TZrHuNc2fPKI9Xr/ogBj/1XcyeXh7d1ukcmx2/TrRcrvk8P+eVK9+PTx/4Jn53zw7pNWkcJr32aYx/7K2Y/vWIyMyYGcXtWkVp/x7R+Y9bRUnHNmmfic9/EJNe/TRmfPtDlE+cEpnIREmnttFizT7RftcNo6RDzb9/FTNnx+jbn45Jr3wSFTNmRfPVesVy+20fJR3n/Ts5+ranY8Iz70afKw6NopbNltjrBgAAaKjEpliSkvvh2lvK4pY7J8Xng2dFcXHEmqs1jaMObhM7b9tinv5vvDM9LrhiQrz65vSYNKUilu9eHHvs2jJOOLxtNGtW836bPr0iTrtgfNzz4OSYOj0Tm6xfGped0zF6dJv3P3efev64+Oedk+KD53tEu7ZFi/U1s2Tuq3/9a2rcfde0+Grw7CguLohVVy2OAw9qEVtvU1rrOd99Nzv+ftWUePGFGTF6dEW0bl0YK/Yrjj/+sXnsuNOcc6ZPz8RFF06KRx6eHtOmZeLn6zeJs85uHV27znvfXHTBpLj77mnx9DMdo03bRrfQWINWkSlIt3yVz2OjfjW6BKxk6cGBAwemW1INa8iQIdG7d++ffJ3DDz88Tb5q2rRp3H333bHLLrvUOD5gwIA0Keuyyy6L8vLyenwFAEBjcvqFY+PbYbOjY/vCNGCVtOsyZWpFbP6LYfHeRzNj682axZ67t4x3P5wRl14zIV54dVo8d2/3KC2t+cXu4ONGp0Gr1VZqEofv1ya+H1ke/3lwUjz5/NR45aEe0a/PnADW5ddPiFMvGBfbb9k8+vcpidvvmRTb7TU8PnmxV40A2ogfZseJ546NM45tL8DVwHRcqV2sd+BqtR4b/PSwGPfVxFh+g67ZfSM/HBv3HvRMVMyuiN6bdo++W/aMaeOmx1fPDIuHj3ox1jvoZ/Hzg36W7f/SZe/Fh//5MvptvXyUtm2aJnw9dNSLscetW0dh0Zx7aMwXE+LdWz+Lbc7dQPJVI5HJZOKHax+KCU++EyVd2kXrjVeLwmZNY/a4STH1429j1uiJ2QSsspc/jlkjxkaz/j2iuF3L9NwZQ36I8Q+/HhOffT96nbdvNF2+c/bao/75REx47M1oteFqUdS6eUx85r0Ydv6/Y4WLDoiCavfV9CE/xNj7X4luR/5C8hUAAMBCEptiSUm+/+910Ki49+Ep0XeF4th3r1YxY2YmHnx8avxy3x/i8nM7xCF/qowdJO59ZEr87uAfoqioIHbfoUV06VwUr7w5Pf56+YR47uVp8fjd3aJp0zlJCyecPS6u/WdZ/GrnFtGxfVH8865J8Yt9Rsarj3ZPr1Hlg09mxN+umRD/vKqz5KtGcl8d8ucJ8egjM6JXr6L4zZ7NY+bMTDz5xIzYf78JcdY5rWKffWom9yVJVwfsPyFtb7VV01h++aKYOLEiPv1sdrz00owaCVjnnTspbv3X1Nhpp9Jo174w/nP3tNjvT+PjwYc61LivPv10Vlx33ZT4vyvaSL4Clp0ErLPOOmuRr/HSSy/FrbfemrbPPffceZKvqisoKIjiJH0bAKAW11/aOfr1LolePUviwivHx8l/HVtn34v/Pj4NcB1/WNs4/5SO2f0nnTcmLrpqQhqkOvGI9tn9z748NQ1wbbp+aTx+V/do0qTyC+Feu7eMnX4/Ig4/eXQ8duecCkY33l4WW27aLB66rVv6fPcdWsag3YfHQ09OiT13a5Xtd9hJo6PP8iVx1EFt6/39YPHqtFK7dJtb+azy+ODuL6OwuCBW2XnO5IQ3rv8orWS14982jj6DemT3r3fgz+KO3zwa7/zz0xiw7ypR1KQoMhWZ+OT+r2PV3frElqetl/br8rP28eTpr8eoj8dFlzUq79mK8op4+pw3oteGXaPfNssvkdfN4pckTyXJV223G5BWp6qeGJXIlFdk292P/XUUNpn3O9KEp96JkVc/GGPuej66H/fryvMqMjHx6XejzZZrR9dDKr93NevXPUZccV9MH/x9NFupR/b6I69+IFquvWK03qj2JEMAAADmJTbFkpJUTUuSrzYc2DQevbNrtoLVOSeWxwbbD48TzhkXO2zdPFboWRLTplXEYSeMjoKCiOfv7xbrrNE0m2xz5Clj45pbyuL/rp8Yxx/eNlsB6R93TkqTuq69pFO6b+A6TeNPR4yOt96bET9ftzRbZe3gY8fEtps3j1/v0nKpvRfUn0cemZEmXw0YWBK3394+SptV/p05/oSK2HnHMfHXcyfFlls2jZ49K2NRw4eXx58PnhBduhTG7f9uH92710zCmz07k20n99Vdd06N3+zZLC68qDI5cO21S+KoIyfG++/PinXWaZK9r044riwGDWoaO+1sUiBQN+mZtbjqqqvSxzZt2sRhhx22tIcDADRgW23aPA1wLUgSXEgCVi1bFMSpR80JZCWS58n+5Hh1SdAqcdbxHbIBrsT2W7aIQRs2iyefnxbfDZuV3T90+OxY98dgRmLAmk2z+6v87+HJ8eATU+L6SzulpZxpHL5+dnhMnzAzVtikWzTvMGeG18ThkyMKInptNKcqVqJ1txbRccW2aXLWzKmV98e0CTOifEZ5dF5lzv3ZedXK9qSRU7P73v/3FzF+SFkMOmnAEnhlLAnJsoBj7n4+SpZrV2vyVaL6vtqSrxJJhavEzJHjsvvKy6ZGZubsKO1bGXxPlK5Y2Z41ZmKNBLCZw8fEcgfuWE+vCgAAYNkgNsWSklS6SpxwRLsaywd27FAURxzYJmbMyKTLAiZefWtGjB5bEbts1yKbfFVV+OKsEyonF95wa1l6XybGjKtIl4qr3nfdH++f76rdP1feODE+Hzwzrjx/TgIhDduTT0xPHw89rGU2+SrRvn1h7Ld/i5gxI9KqVVX+ftXkmDQpE+ed33qe5KtE9b8r48ZVpOevvvqcv5Grr1HZ/n74nBWwbr5panz11ew496+1L90KUEUC1lxmzpwZ999/f9reeuuto7S0KmO6PIYOHZouaTh9euUfegCA+vLl17PSEu0bDmwWLZrX/Cda8jzZ//W3s2Po8DlBq+dfmRYtmhfERuvNu879NoOaV/Z5dc6Xz57di9Oy8VXe+bGd7E9MLCuPI04ZHUce2DbWWWPea9JwfXzfV+njqrv1rbG/Q982EZmIb18eUWP/pBFTYszgCdGxf9to1rYymJU8FjUtitGfjc/2q2q36lJ5v5V9Pzlev+aj2PCwNaPlcpX7aPimvP9VVEyeHi3XWykyFRUx6bVPY+z/Xorxj78VM0eMW/jrvP1F+lh9+cFkycGCJsUx4+s59+D0ryrbVUsazhw1IUbf+Wx0+v2WUdJRoAsAAGBxEJtiUf0wqjJhZYXl552YtcKP1Ymee7nyv7GOHD27xv7q2rYpinZtC9PlMpN7LpEsoVlaWhDvfTTn/qm6l5b/8f4ZMnRWnHXx+Dj3pPbRo5vVixqL0aMrq6737DlvMlXVvldenpk+Jgl7Dz80Pdq1K4iNNmoaH34wK264fkpcd+2UeOnFGWnFq+qSJK6mTSM+/njO37WPPqpsd/sxeWvo0Nnxt0snx/EntIyuXS1pma+SXM1831g2+H+fubz//vvZBKvVV189ysrK4vTTT49//vOfMWFC5VqxTZo0iU033TROOeWUGDRo0FIeMQDQGHz5TeUXu359ap+RmOx/4rnKfj27l8SUqRUx4ofy+NnKTWqsRV9lxd6V1xn843UT+/22dZxwztjY+Q/fR/8+JXH7PZOjW5ei2GnrFunx488eG81KC+Ks42rOcqRhK/t+Sgx7Y1S0XK5Z9NqwS41j6x+yRox4f0w8evzL0XvT7tG2V6uYNm56fPXMsGjTo2Vsd8GG2b4FhQWx6i6948P/Do5ZU2dFaZum8emD30SnldtF59Uq75lnz30rTdpafY8Vl/jrZPGpSohKqlwNOeramPl9teUqCgui/U7rR+d9tpnnvLKXP44ZQ0dHZuasmPHd6Jjy3uAoWa5tdNxzUI37qs0Wa8WEx9+Kiukzo7Blsyh79v1o2rtLthLWD9c+FKW9ukTb7QYuiZcLAACwTBKbYlF1aF+ZuDfku9mxSr/KpduqDBk6O5vol+jYvqjG/uomllXE+AkV2f59VyiJwsKC2Oc3reK6f5XFpMkV0aFdUfzr7kmx1s+axIC1KicPHnr8mFhj1SZx8D4mbzUm7dtV3ldDh5ZHv341UxuSfYlvvql8HPpdeUyYkIk11iiOk06cGHfcPicBNLHaz4rjppvbZROpkvtqj980j9tunRqTJ2eiXbvC+O9/pqX91lyz8m/YySeWxSqrFscf9zbZFFgwCVhz+eSTT7LtioqKGDBgQHz55ZfzVMl66qmn4umnn47zzz8/TjjhhJ/0M4YNGzbf4yNG1KxAAAA0fklgIdGmVe0FSlu3LKzRb4H9f9xf1S9x1EFt01LfN/+7LF56fXoMXKtpXH5Op2jZojCdsZiUkX/szm5RUlIQx545Jm65qyymTsvEtoOax3WXdIrOHf3TsSH69IGvI1ORiVV27h2Fcy0d17536/j1LVvHoye8nCZdVSlt2yRW3aVPmoRV3cZHrRWFxYUx+KmhMXtGefT8eZfY7Ph10ut++tA3MeztUbHXv7eNWdNmx/MXvh1fPVV5zb5b9YhBJw6IkmbuoYaofOKU9HHcA69GaZ+u0evC/aNpj04x/ZsRMfKah9L9JV3aRbu5EqQmvfxxWi2rSrLMYLdjfhlNlqtcSqBK5723iYKiopj06idRMXNWNF+zT3apw4nPvh9TPxoSK1x6UGSmz4oRNz6S9ku02mDV6HLADlFYWjOoC8CCiU0BAHMTm2JRbbtF87j7/ilx8VUTYvONSqO0tPIeGDuuPK68YWLanlBWmSiz4cDSaN2qIB54bEpayWrt1ecsLXjWxXOqbU+YOOf+ufD09lFSEnHPQ1Ni2vRMbLlps7jsnI5pAuCt/5mUVlt744keMWVqJv5yyuj430OV8Yxf7NQirvhrx3kqu9EwDNq8aTzwwPS45u+TY8MNm6SV0BLjx1fETTdVLntZ9uPfmTFjKx8//nh2fPVVeVxyaevYZpvSKJtUEX+/akr8+45p8eeDJsR9D3TIXv/UU1ul91VSOStZ5nLjTZrEWWe3Tu+re/47LV57bWY8/GjHmDo1E6efOjEeeaSy8toOOzSNc85rHc3dV0A1/qUyl3Hj5vyf+oUXXphWw9puu+3i7LPPjjXWWCOtiHXPPffEiSeeGBMnTkwfV1555dh1110X+mf07NlzMY0eAKBuyZfGU45qn27VTZ9eEQcfPyr+8OtWsdWmzeOCK8bF1bdMjEvP6hg9uhbHESePjn3/Mioevr2yGg0NR5J49ekD30QURKyya595jo/8aGw8cvSL0WHFtvGb27eJdiu0jqljp8cHd30ZL1z8Tnz/3ujY/sKNsv2LS4tj0+PWSbfqpo2fHi/97d0YsO8q0b5Pm3jm3Dfjm+eGx+anDoiCgoJ47vy3oqS0OAadNGCJvG7qV1K+PVFQXBTdT9wzStq3Sp83X7VXdD/21/HNMdemSVhzJ2B1P36P9LF8yvSY/vWIGHPHMzHk2Ouj+wm/iRar9872K2xaEsvtt126VTd74pQYdcvj0f4XG0fTnp1i5DUPxuQ3Po8uB+8cBQURI69/JEY1KYkuB+24BN4FgMZFbAoAWBrEphq3vXZvGbfePSldZnCdLYely1DOmp2JBx6bGp07zak4lEiS7i4+o0McdOyY2HSX7+MXO7aILp2K4tW3pqdLU660Ykl8PnhWFFbLbWnWrDAuPbtjulU3emx5HH/m2Dj+sLaxav8mccjxo+PBx6fG1Rd1SuMHR5w8Jpo3GxdXnl/zPBqGXXcrjf/8Z1q8+srM2HbrMbHZoKYxe3Ymnnh8RnTsWHmDJJ9zouLHfL3y8ohjjm0Zv96jsmpVm7aFccGFbeKzT2fHu+/OijffmBkD16uc0FfarCDOOLN1ulU3dmxFnHN2WRxyaIvo37+yotYTT86I8y9onf68U08ti9Jmk+K8v7ZZou8HdcgURCYzbzXGvJHPY6NeScmcy5QpldnQiST5auutt46HHnooBg4cGE2bNo1OnTrFwQcfnO4r/PH/9U866aTsf5QAAMhFm9Y/zgqcNGdWV3Vlkytq9Ftg/x/3V/Wbn3P+Nj6dTXbpmZVBiCtunBh/+FWr+PPebWLnbVrEuSd1iMeemRqfD56Z02tj6Rn6+siYNHJq9Bi4XLTpXrOaVfmsinj8pFfSJeR2uHTj6LxK+7RCVVL1apNj1o4+m3ePwU8OTZOwFiRJ1mrevjQG7LdqzJwyK626tfYfV46Vtl8h+m/XK9b+w8rx8b1fx8ypc5YdoOEoal45CzVZErAq+apK016do2S5djFr5Pg00arW81uUpglXPU77fRQ0KYkR/3dvZGZXznidn1E3PxZFbVtGx19uEuXTZsSEZ96L9rtuGG02XT1ab7J6tN91g5jw9DtRMc3fJgAAgEUlNsWiKi4uiAdv6xqnHdMunZB34+1lcd8jU2LnbZvHndcvl/bp3KEyESux729bxwO3dYn1120aDz4+Ja79Z1la/ezxu7qlyw6m/TvO6V+Xo08bkyZ4nXhEu3R5wlvunBRH/7lN7PWLlrHn7i3jqIPbxM13lMXkKbXfq+T/ffXPf7WLo45umSbk/fuOqfHYozNi622axjXXtU37VCViJVXVqmy99ZyqalW23Kpy3wcfLDhGeeYZZdGxU1EceljLmDy5Iu6+a1ocdFCL2G33ZrHrbs3iwANbxF13Tosp7iugGhWw5lJaWlrjeVIFq6ho3v9z33jjjeMXv/hF/Pe//41PP/00Pvzww7RC1sIYOnToAsu8r7feej9x5ABAQ9avd2VQ4cuva//yV7W/ql9SMrvrckXxzXezorw8k84grG7wN5X9V/yxf10++GRGXHLN+PjnlctF+3ZFMbGsPH4YXR5r/WzOF9S1f2x/NnhmrLSipb4ako/v+zp9XG33eatfjR9SFmXDp0TfLXrUujRgjwHLxdfPDo/Rn42Pbmt1qvNnDHnp+/jyiaHxy5u2jKKSohj3TVlUzM5Ep5XmLDPXaeV2UTG7IiYOmxyd+tdcfo7816RbZQC8qHnN70pVkv3JX5zMjFkRLWrvU9mvaTTr3yMmv/FZzBw5Ll3GsC6T3/4yyl7+OJY/d98oKCmKWcNGR5RXRGnvLtk+pb27RsyuSK9VfT8ACyY2BQDMTWyK+tC0aUGagJVs1SVLTCbWWbPm57fdFs3TbW77HjEzTbapvjRhbR59emr854Ep8ey93aJJk4L49MuZMXt2xJqrzTkvuZdmzYr4asisGvtpWPfVkUe1TLfqXn21cjnA1deo/DuzfK/iSP6zflIBq3UtyZ+tW1f+nUqWGpyfZ56ZEQ89OD3+c0/79L4aPHh2el+tutqcv2er/awkva++/bY8Vl1VzRugkgSsubRqNWdGd1Ltau21166z77bbbpsmYCXefPPNhU7A6tGjRz2MFABoTPr1KYluXYrilTenxZSpFWkQq0ryPNnfe/ni6Nl9zpe8TTdoFnfdNzlefmN62q7uieemVvZZv+b+6pLg2IHHjErLge+5W82qNjNmzPkSOmPmj8uPVdVypkGYNmFGfP3c8Cht0yT6bj7vvz8rZlXOzpo2fkbt54+vrGZU1KTumYZJRavn/vpW/OxXK0bXNWuWcS+fWTFPuyBZC5EGp/nqK6SPM4aPmedYUskqSYAqKC2JojYtFnit2eMnpY8FtUxyqZJUtBp53cPRdtsB0XzlmktkZWbNnrftbxPATyY2BQDMTWyKxenf/5ucPu6xa80Emtq88sb0GDJ0dmy/ZbP5VlBLKlodfuKYOOiPrWODgTUnhFXdM9Xbbp/G5757K+OXu+xS+XemtLQg1l23JN54Y1Z8+eXs7DKDVb78srIie48edcelkopWp548MX7/h+YxYEDN82dW+7tU1XZf5YdMni9BmM9jo35Jx5xLz549FzoYVb3v6NELXpoFAKAuSQBpv9+2jslTMnHuZeNqHEueJ/v3/13NdegP+H3l8zMuGhszqwUVHn16Sjz3yrTYerNm0atn3bMMr7hhQjor7OoL5lShadO6KJ29+MgzU2pcL7FKv/nPWCS/fP7wkDTJaqUdVqg1iarDim2iScuSGPH+mPju1RE1jk0aOSU+uuerJGMquq9bd5WiV6/6IF2Ke8PD50xESJYwLCwujCEvf5/dl7QLSwqjTc8FB9nIP026tI8Wa/WNWSPGxYQn36lxbOz/XoqKKdOj1c9XiYKiwnSpwNoStRITnn43pn85PEq6to8mXdvX+fNG3/50EpWITr/fssYYorgwJr/zZXZf0i4oLoomXVRVAwAAWFRiU9SHqqUnq7vnocnpsoAD1moau+/QYr59vx85Ow46dnQUF0eceVzdsYPEaeePi4qKTJx78px+ydKFJSURjz1dmQCYSNpNmlQeo2GaVMu98vDD09NlAddcsyS2235OZbMkcSpx2WWTayRyJlWs/vufadGyZUEMGlR3JbSLLpwcFRURJ5w4J47Zq1dRel89++yciaxJO7mvkmMAVVTAmstqq62WbZcn9Qnno/rx4uRfAgAAc7nx9onpLMDER5/OTB9vvr0sW3Z7o/VKY//ftUnbxx3aLh54fEpcdNWEePfDGbHO6k3jnQ9nxJPPT4uBazWNvxxQuaZ9lc03ap4Gxm66oywGbDM0dtiqeYz4oTzufmBStG9XGFecN59l44bOijMuHhd/PblDjZmLiSP2bxsnnTc2dvr999Gja3H8486y2HHr5tGvjxLvDckn91cuP7jqbvMuP5hIkrI2+sua8ex5b8UDh78QK2zSLdqt0Cqmjp0eXz0zLGZNnR1r/2GlaNerZnC1ysgPxsSHdw+OHS/dOJq0mHMPNWlekv7Mj/47OGZPr/z38hePfhtr/KZfrUsd0jAsd+AO8e1JN8fIax6MSW98Fk27d4zp34yMqR9+E8Wd2kTnP26d9iufNC2+OeLvUdq3WzTp3jGKO7SKisnTY9rg72PG1yOisHnT6HbEbnX+nGmfD4vxj70Z3U/4TRQ1mxMMK2zWJNpuuXZMePztyMyorHxV9uKH0Xb7gVFY6m8TAABAXcSmWJI22nF49OxWHCv3K0mXjXvrvRnx/CvTo0+v4vj39Z1rLFV51U0T4457Jqf3YKeORTHs+9nx4ONTYuq0TFx3aadYe426k2Ref3t6XHNLWfz35uWiVcs59UZatiiMffdqFdf/a1J6ncSd906OQ/ZtXaOqGw3LrruMjW5di2LFfsXpffXee7PitVdnxvLLF8XV17atcV/tsmtpPPbY9Hjk4Rmx/bZjYtPNmsaksop49NEZaULW3y5vE23a1n4vvPPOzPjXP6fGDTe2jZbV7qsWLQrjN79pFrfdNi2m/Xhf3X/f9Nh7n+bR3H0FVOO/gMylV69esfzyy8d3330XQ4YMSWf011XS9Kuvvsq2u3fvvgRHCQA0FEmA6193T6q5783p6ValKsiVBAGe/V/3OOuScfG/hytnCnbtXBxHH9w2Tj+mfTRrNu+XuWsv7hSrr9IkbritLK64cWK0bF4Qu23fMs49scN8Z3UdfNyo9LxD9q382dUd8+e2MXZ8edxyZ1k893Imdt6mRVx7UedFfCdYkkZ+NDbGDp4Yy/2sfXTsVzM4Wt3PfrlitO7eMt6/44u0EtaQl75Pk6Q6rdwufvaLvmn1rNqUz6qIZ859M/pu2SN6bzbvv4M3PmqtqJhVHoOfHpY+TxKykmQvGq6kAtUKFx8QY/79XEx+d3BMef+rKG7bMk2A6vjrzaK4beUM1uLWzaPDrzeNqR99G1Pe/zrKJ09Nq1SVdGob7XZeP9rvvEGUdKw9qS9ZzjBJ8Gq1/qrRauBK8xzvvPc2aZ9Jr36aPm+z5drZxC8AAABqJzbFkvTrXVrEfY9OjdffmR6zZkes0LM4TjqybfqZtm5V8/7ZYEBpvPjq9Hj4yakxfmJ5dGhXFNtt0TyOPbRtrL163clXs2Zl4uDjRscvdmwRO20zp6JWlQtP7xAzZ0b87+HKZQ+ThKzzT51/NS3y2847l8Zjj86Id9+dln7+PZcvisOPaBEHHdwiWs11XyX/Xf/Kq9rGuutOjbvunBZ33J5UQKtcmvDQw1rG+hvUnsiZXPfE48tihx1KY6utay5pmTjltFYxc1bEo49U/u38zZ7N4uSTay6dClCQSTKMGrEkiap3795pe++9945bbrllgeccffTRcdlll6XtJ598Mrbaaqta+22++ebx3HPPpe0kYav6koSLYtiwYdlrDR06dIFLIQJAY1Qxst/SHgKN0JEjBiztIdAIPTlk3mQhWBSzxpTFVwdWfif1nRBYGsSmAEBsisWjPDPvUmqwqEaUz1lyEerDiBHlsf56o/P6O2H17639bjyqzkmf+RLr+3J/sb5lgZp4tTjyyCOjtLQ0m4xVVlY2T5/bbrstm3y144471lvyFQAAAAAAAAAA0HA0uiUIX3rppRg8ePD/s3cf4FGUaxvH7/ReCaEGSKT3IkVBQEAUARUr2LH7WVBUEBsoWBBUjnBsB8UuoDSlK9JBAQWkdwglkJDe637XvEsaoZpACv/fdc2Z2dl3dib4nk0yufd58h4fP348b9vaf3IFrPvvv7/Ia1gtCN944w0NGTJEmzZtUrt27TR06FA1b97chLGmT5+ujz/+2Iz19fXNq5YFAAAAAAAAAAAAAAAA4NJS4QJYEydO1FdffXXK51auXGmWswWwLC+88IJiYmI0evRo7dixQw888ECRMcHBwZo5c6bq1aMMLQAAAAAAAAAAAAAAwMVks9mXsqosXxtKFi0Iz+Dtt982ga177rlHderUkZubm/z8/NS2bVuNHDlSO3fu1BVXXFHalwkAAAAAAAAAAAAAAACglFS4ClhWi8GT2wwWhxWwImQFAAAAAAAAAAAAAAAA4JIIYAEAAAAAAAAAAAAAAOBSaUHooLKKFoSXDloQAgAAAAAAAAAAAAAAAMC/RAALAAAAAAAAAAAAAAAAAP4lAlgAAAAAAAAAAAAAAAAA8C85/9sDAQAAAAAAAAAAAAAAgNJik4NsNgeV5evDpYEKWAAAAAAAAAAAAAAAAADwL1EBCwAAAAAAAAAAAAAAAEC5t3fvXv31119mffToUSUnJ8vFxUX+/v6qVauWmjRpotatW8vT07NEz0sACwAAAAAAAAAAAAAAAOWO7cRSVpXla6tIFi9erB9++EHz58/X4cOHzzreCmRdccUV6tevn/r376/g4OBiXwMtCAEAAAAAAAAAAAAAAACUG6mpqRo3bpzq1q2rHj166PPPP9ehQ4dks9nOumRkZGjp0qV69tlnFRISogEDBmjNmjXFuh4qYAEAAAAAAAAAAAAAAAAo87KzszV+/Hi98847ioqKMoEqS2hoqNq3b6927dqpTZs2pqpVYGCgAgICTFgrJiZGsbGx2rlzp9auXWsCV9Y6LS1NU6ZM0dSpU9WrVy+9++67aty48XlfFwEsAAAAAAAAAAAAAAAAlDs2m4NZyqqyfG3lVZMmTbRr1y4TvKpRo4buuOMO3XXXXWrVqtVpj/Hx8TFL7dq11bJlS91+++1mf1JSkqZPn67vv/9eixYt0ty5c7Vw4UJ98cUXuvvuu8/rumhBCAAAAAAAAAAAAAAAAKDM27lzpxo1aqTvvvtOBw4c0NixY88YvjoTb29v3XvvvZo/f7727Nmjhx9+WI6Ojtq7d+95vxYVsAAAAAAAAAAAAAAAAACUeVOnTtUtt9wiB4eSrS5Wq1Ytffrpp3r11Vd18ODB8z6eABYAAAAAAAAAAAAAAACAMu/WW2+9oK9fs2ZNs5wvAlgAAAAAAAAAAAAAAAAof2wnlrKqLF8bSpRjyb4cAAAAAAAAAAAAAAAAgIstPDxcw4cP1+WXX67KlSvL3d1dISEhuuqqq/Taa69p8+bNZzx+3rx56tevn6kA5ebmZtbWY2s/zowKWAAAAAAAAAAAAAAAAEA5Nn78eA0bNkzJycmF9h86dMgsK1asUEJCgsaNG1fk2JycHD3yyCP6/PPPC+0/fPiwWWbOnKmHHnpIn376qRwdy1+tpwMHDui7777Thg0bFB8fL19fX7Vs2VJ33nmnQkNDS+QcBLAAAAAAAAAAAAAAAABQ/tgcZLM5qMy6SNc2atQovfrqq2a7fv36evjhh9W2bVv5+fkpOjpa69ev14wZM04bnnr55ZfzwletWrXSkCFDdNlll2nPnj169913zfETJ040VbXeeustlSfvv/++XnrpJWVmZspmy+8JOX36dL3xxht688039fzzzxf7PASwAAAAAAAAAAAAAAAAgHJo0aJFeeGre++91wSlXFxcCo3p3r27CRllZGQUOX7nzp0aO3as2bZaFy5btkweHh7msRXiuuGGG9SlSxetW7dOY8aM0QMPPKC6deuqPJg6dar5uh0cHNS7d2917NhR/v7+OnjwoKZMmWICZkOHDlWtWrV0++23F+tc5a8uGAAAAAAAAAAAAAAAAHCJs1oHPv7442a7RYsWporVyeGrglxdXYvss1oSZmVl5bUxzA1f5fL09DT7Lda4Dz74QOXFe++9Z8JX06ZN088//2zCVo8++qipGLZjxw4TyrKqYllVsoqLABYAAAAAAAAAAAAAAADKHaujXFlfLqSFCxdq165dZtsKFzk7n18jPCt8NGvWLLPdsGFDdejQ4ZTjrP0NGjQw29b4gq38SsPixYvPadzmzZsVGhqqm266qchzVjvGwYMHm+1NmzYV+5oIYAEAAAAAAAAAAAAAAADlzI8//mjWVpWnPn365O2PiYkxwSxrfSb79u3TkSNHzLbVZvBMcp8/fPiw9u/fr9LUvXt33XnnnYqIiDjjOKviV0JCwmmfj4+PzxtXXASwAAAAAAAAAAAAAAAAgHLmjz/+MOs6derIx8dH33//vZo1a6ZKlSqpfv36Zm1Vrho7dqzS09OLHL9169a8basC1pkUfH7btm0qTbVr19bkyZPNNVltBrOzs085rmPHjoqOjjaVrjIzMws9Z4XIXnzxRRNe69SpU7GviQAWAAAAAAAAAAAAAAAAcAFZ1ZoOHTp0xuV85OTkaPv27WY7KChIgwYN0l133WXa7hW0c+dOvfDCC+rWrZvi4uIKPVfwnDVr1jzj+UJCQvK2Dx48qNK0bds2vfTSS8rIyNCQIUPUokULLVmypMi4119/3VS3+s9//mOuv3fv3qZyVufOnU1Azfq3cXNzM+OKiwAWAAAAAAAAAAAAAAAAyh2bzaHML7natWtnQkBnWs6H1T7PCmFZNm3apA8//FDVqlXTt99+a1oPpqSkaOnSperQoYMZs2rVKj3wwAOFXiMxMTFv29vb+4zn8/LyyttOSkpSaXJ3d9eoUaNM2Kxnz56mklduW8LcloqWNm3aaP78+QoNDVVkZKTmzZtnKmetWLFCWVlZCgsLM8+3bt262NfkXOxXAAAAAAAAAAAAAAAAAHDRJCcn522npaXJ09NTixcvNi0Hc1mVnn7//XddccUV2rhxo2bMmKE///xT7du3zzsul1Up6kysSlG5UlNTVRZcdtllJlQ1ffp0PfvssyZcNWfOHL322mt65pln5OTkpC5dumjXrl1auXKlNmzYYIJrfn5+pmqW1XrQakFYEghgAQAAAAAAAAAAAAAAABfQmjVrTIWqkqwCVdBDDz1UKHyVy8PDQ2+++ab69OljHk+ZMiUvgFXwNax2fmeSnp5e6DXLkptvvlm9evXSyJEj9f7775u2hJMmTdKECRPUtWtXE7KywlbWcqHQghAAAAAAAAAAAAAAAADlj9Xir6wvJ1jhq5o1a55xOR8+Pj6FHlut+E7Has/n7Gyv0bR27dpTvsbZ2goWrLh1tnaFpcEKhb311lv6559/1KNHj7y2hAMGDCjUlvBCIYAFAAAAAAAAAAAAAAAAlCNWS8DKlSvnPQ4JCTntWKvSVVBQkNmOiorK218w9HXo0KEznu/gwYPndK7SVr9+fS1YsEBTp05VjRo1TMWvhg0bauzYscrOzr5g5yWABQAAAAAAAAAAAAAAAJQzTZo0yds+W7go9/ncSliWxo0b521v3779jMcXfL5Ro0Yq62699VZzzS+88IJpnzh06FC1aNFCixcvviDnI4AFAAAAAAAAAAAAAACAcsdmK/vLhdS5c+e87b179552XEJCgo4fP262rapQuUJDQ1W9enWzvXTp0jOea9myZXnH16lTR2XB6tWr9cgjj6hdu3Zq0KCBWVuPV65caZ739PTU6NGjtXHjRl199dWmLaHVnvBCtCUkgAUAAAAAAAAAAAAAAACUM7fcckve9owZM047znrOdiINdtVVV+Xtd3Bw0I033mi2rWpRf/zxxymPt/bnVsCyxlvHlbbnnntOnTp10ueff65169Zp165dZm09toJpzz77bN5YqwXhb7/9ph9++EHVqlUr1JYwKyurRK6HABYAAAAAAAAAAAAAAABQzjRv3ly9evUy21a4aNGiRUXGHD16VK+88orZdnV11cCBAws9/8wzz8jJyclsP/XUU0pNTS30vPXY2p/bvtAaX9omTpyoDz74wITKrrnmGk2aNEnz5s0za+uxtf/DDz804wq64447tGPHDhPeKum2hASwAAAAAAAAAAAAAAAAgHJo3Lhx8vf3V05Ojvr06aNhw4Zp+fLlphrURx99pLZt2+rQoUNm7MiRIwu1ILTUr19fL7zwgtm2junYsaOpEGVtW2vrsbVtscbVq1dPpe3jjz82VbgeeOABzZ8/X/fdd5+uvfZas7YeP/jggyaEZX39J/Py8tKYMWO0fv16denSRdu2bTOhreJyLvYrAAAAAAAAAAAAAAAAABeb1VXP3lmvbLoI12YFqH755RfdeuutOnbsmN555x2zFGSFlV5++WUNGTLklK/x5ptvKjIyUl988YUJJvXv37/IGCvUNGrUKJUF27ZtM+v777//lM9bQSyrFWFu28RTady4sX7//XdTOSw3gFYcVMACAAAAAAAAAAAAAAAAyqlOnTppy5YtGj58uGmp5+vrK3d3d4WGhpqWg3/99ZepfnU6jo6OJrA0Z84c3XjjjapevbppV2itrcdz58417fyscWWBu7u7WUdHR5/y+dz9uePOZMCAAWcMap0rKmABAAAAAAAAAAAAAAAA5VilSpU0YsQIs/xb119/vVnKQ+Bs9uzZpt1imzZtVLNmzbznIiIi9Morr5iqX9a4c+Ht7V3sayKABQAAAAAAAAAAAAAAgHLHZnMwS1lVlq+tPHvjjTe0aNEi7dixQ3Xr1tWVV16patWq6ejRo1q1apXS09NN9avihNHOFwEsAAAAAAAAAAAAAAAAAOVCy5YttWDBAtNecc+ePVqyZEmh563Wi1ZLxdatW1+0ayKABQAAAAAAAAAAAAAAAKDc6NSpk3bu3KmVK1dqw4YNio+Pl5+fn1q0aGGes1oQXkwEsAAAAAAAAAAAAAAAAFA+2Ur7AlBarJCVFbayltLmWNoXAAAAAAAAAAAAAAAAAADlVYlWwLLKef30009avXq1jh49qpSUFE2aNEm1a9fOG3PkyBHFxcXJ3d1dYWFhJXl6AAAAAAAAAAAAAAAAACifAawJEybo5ZdfVlJSknlss9lMqa/k5ORC45YsWaK7777bBLAOHTqkwMDAkroEAAAAAAAAAAAAAAAAABXU008/rWHDhqlatWoX5PWtwlNZWVnq37//xW9BOHz4cA0aNEiJiYlydXVVmzZtTjvWusCqVasqPT1d06ZNK4nTAwAAAAAAAAAAAAAA4BJjszmU+QUlyyoQZXXce/LJJ7V3794Sec3MzEz98MMPatasme644w7t3LnzvF+j2AGsv/76S6NGjTLbVmUrq/XgmjVrTn9CR0fddtttpkLWr7/+WtzTAwAAAAAAAAAAAAAAALgE3H333crIyNDHH3+sevXq6corr9RHH31k8krnG7r6/fff9dBDD6lKlSrmdbds2aLQ0FB179794rcgtJJlVpjK+oK+/vrrczrmiiuu0Pjx47Vp06binh4AAAAAAAAAAAAAAADAJeDrr7821a9eeeUV/fbbb/rjjz/0559/6qmnnlJISIjatm2rVq1aKTg4WAEBAWZJTU1VTEyMYmNjTXWrtWvX6p9//jFBLouVe6pcubJeffVVPfbYY3J2dr74Aaxly5bJwcHBfHHnqk6dOmZ9+PDh4p4eAAAAAAAAAAAAAAAAlyLbiaWsKsvXVo61a9dOCxcuNEGqcePGafr06UpPT1d4eLgOHjxoHp+JFbjK1aZNGz3yyCO688475eXl9a+vqdgBrIiICLNu0KDBOR/j7u5u1tYXDwAAAAAAAAAAAAAAAADnw6p29d133ykhIUGzZs3S4sWLtXz5cu3Zs+e0x3h6eqpDhw666qqrdOONN6ply5YqCcUOYLm6upogVVxc3Dkfc+zYMbP29/cv7ukBAGVAztF6pX0JqIBeOta8tC8BFdC6qFqlfQmogNJSXUv7ElDBZKW5lPYlAAAAlCvcm8KFkG3LKe1LQAWUkJNW2peACmh3pm9pXwIqmKjMTOt/S/sygPPi6+ure+65xyyWqKgoHTp0yKyt1oNWoSirxaC1hIWF/asWg2dT7FesVauWtmzZol27dunqq68+p2N+//33866aBQAAAAAAAAAAAAAAAORzOLGUVWX52iquyifCVheTY3FfoHv37qY34ieffHJO4w8fPqzPPvtMDg4O6tmzZ3FPDwAAAAAAAAAAAAAAAAClptgBrCeffFIuLi7auHGjRo4cecaxO3bs0HXXXaf4+HjTU/HRRx8t7ukBAAAAAAAAAAAAAAAAoNQUuwXhZZddpjfffFNDhgzRiBEjNGfOHN188815z//4448moLVy5UotXLhQOTk5pvrVuHHjLnq5LwAAAAAAAAAAAAAAAAAoUwEsy/PPP2/aEL7yyitas2aN1q5da0JWljfeeCNvnDXGyclJY8eO1YMPPlgSpwYAAAAAAAAAAAAAAMClyHZiKavK8rWhbLUgzPXCCy9ow4YNGjhwoIKCgkzYquDi6+urAQMGaP369Ro0aFBJnRYAAAAAAAAAAAAAAAAAyncFrFyNGjXS559/brbDw8MVGRmp7OxsVapUSWFhYXJ0LLG8FwAAAAAAAAAAAAAAAABUrABWQbVq1TILAAAAAAAAAAAAAAAAUOJoQYgygpJUAAAAAAAAAAAAAAAAAFBaASwnJyezWC0GN23adE7HbNmyxbQjdHa+YAW4AAAAAAAAAAAAAAAAAKDsB7BsNptZ9u/fr44dO2rWrFnndSwAAAAAAAAAAAAAAADw71oQOpThpbT/gVCuWhA6ODjIxcVFSUlJuuWWW/TWW2+VxMsCAAAAAAAAAAAAAAAAQMUPYFkmT56sevXqKScnR6+++qruuusupaenl9TLAwAAAAAAAAAAAAAAAECZ41xSL9SgQQOtWbNGt956qxYtWmQCWXv27NGMGTNUrVq1kjoNAAAAAAAAAAAAAAAAgEtQt27dSvw1rc5/VtapTASwLH5+fpo/f74GDRqkjz76SGvXrlW7du00a9YstW7duiRPBQAAAAAAAAAAAAAAgEuYzWZfyqqyfG3l1ZIlS0xgylYC/7i5r2Oti6tEA1gWJycnTZgwQU2bNtXTTz+tw4cP66qrrtKkSZN0++23l/TpAAAAAAAAAAAAAAAAAFwCOnfuXCKBqZJW4gGsXI899phpS3jbbbcpJiZGAwYM0ObNm/XGG29cqFMCAAAAAAAAAAAAAAAAqMAVsMoixwv54ldffbX++OMPE8SySna9+eabuvXWW5WcnHwhTwsAAAAAAAAAAAAAAICKzlYOFlwSLmgAy1K3bl39+eefuvbaa00Ia8aMGbr55psv9GkBAAAAAAAAAAAAAAAAoPwHsCy+vr6aM2eOnn76aRPCioiIuBinBQAAAAAAAAAAAAAAAIALyrm4L1CrVi05ODjI1dX1jOMcHR01btw4NWnSRE8++aQyMzOLe2oAAAAAAAAAAAAAAABcqmwO9qWsKsvXhrIVwNq/f/95jX/44YfVpUsXqmABAAAAAAAAAAAAAAAAOGdOTk4qaVbhqaysrNINYP0b9evXNwsAAAAAAAAAAAAAAAAAnAubzaayqFQCWAAAAAAAAAAAAAAAAABwPoYPH66yiAAWAAAAAAAAAAAAAAAAyh0HaymbBZHyrg8lq9wHsMLCwvL6Hu7Zs6fI/n/j5NcCAAAAAAAAAAAAAAAAgPLknANY+/fvzwtNnWr/v3HyawEAAAAAAAAAAAAAAABAhQxg3Xfffee1HwAAAAAAAAAAAAAAALhgrPaDZbgFYZm+NpROAGvSpEnntR8AAAAAAAAAAAAAAAAALrbY2Fht3LhRx48fV2pqqmy2M6fh7r333osTwAIAAAAAAAAAAAAAAACAsmrJkiUaPny4VqxYcc7HODg4EMACAAAAAAAAAAAAAADAJcjmYF/KqrJ8bRXQxx9/rKeeespUuzpbxauS5ngxTpKenq5FixZpypQpWrNmzcU4JQAAAAAAAAAAAAAAAIBLwLZt2/T000+b4FWzZs00c+ZMzZkzJ6/C1Z49e7R27VoT0mrdurXZ36lTJ23ZskV79+4t9vmLXQHrwIED+u9//2u2X3rpJfn7+xd6/o8//tCtt96qiIiIvH2tWrXStGnTVLt27eKeHgAAAAAAAAAAAAAAAMAlbPz48crOzlblypW1fPly+fj4mHBVrtDQULO0adNGjzzyiF588UWNGTPGVMz67bffSr8C1vTp0zV27FhzMSeHrxISEnTTTTeZ8FVueS9r+fvvv9W7d29lZmYW9/QAAAAAAAAAAAAAAAAALmFLly41la6sKlhW+OpMrHGjR49Wt27dtHjxYn3xxRelH8D69ddfzYXdeOONRZ777LPPFBkZabatL3DWrFn6v//7v7zSX1999VVxTw8AAAAAAAAAAAAAAIBLka0cLLgoDh06ZNa57QUtVp4p16mKRFmVsKxCUt9++23pB7By+yBefvnlRZ6bOnWq+WJuvvlmjRs3Tn379tWECRN02223mS/AakMIAAAAAAAAAAAAAAAAAP9WWlqaWVevXj1vn5eXV952bGxskWPq1q1r1lu3blWpB7CioqLMulq1aoX2x8fHm1aDlvvvv7/Qc/379zfrjRs3Fvf0AAAAAAAAAAAAAAAAAC5hgYGBZp2cnJy3r3LlynlVsHbu3FnkmOPHj5t1XFxc6QewEhMTzTo7O7vQ/lWrViknJ0dOTk7q2rVroedCQkLMOiYmprinBwAAAAAAAAAAAAAAwKWotNsL0oKwzGjYsKFZ79q1K2+fp6en6tWrZ7Z//vnnIsfMmDEjL6hV6gEsf39/sz5y5Eih/UuWLDHrli1bFirpVZC7u3txTw8AAAAAAAAAAAAAAADgEtapUyfZbDYtX7680P6bb77Z7P/www81adIkUyErMjJS7777riZOnGgqZHXr1q30A1hNmjQplArLrYY1depUc5EnV7+yHD582KyrVKlS3NMDAAAAAAAAAAAAAAAAuIT16dPHrGfOnKm0tLS8/c8995xpT5iZmamHHnpIvr6+qlatmoYNG2byTVbxqBdffLHY53cu7gv069dPS5cu1TfffGMCVVdddZXZPnDggAlg3X777UWOWbduXaFWhAAAAAAAAAAAAAAAAMB5Kett/srytVUw7du3NxWusrKyFBsba0JWlkqVKmnBggUmv7Rv375CxwQHB+vrr79Wo0aNSj+A9eijj+rTTz/Vtm3bNHbsWLPk6tu3ry6//PIix1jVsqxwVocOHYp7egAAAAAAAAAAAAAAAACXuPvuu++U+9u0aaPt27fr999/15YtW0xIq169err22mvl6elZIucudgDLzc1NixYt0pNPPqlffvnFlOxydXXVHXfcoQkTJhQZv2zZMm3dutUEsKwvBAAAAAAAAAAAAAAAAAAuFBcXF5NTulBZpWIHsCxVq1bVTz/9pPT0dMXExJjyXVYI61SstoOLFy822506dSqJ0wMAAAAAAAAAAAAAAABAqSiRAFbBali5PRRPJzQ01CynExUVpY8//thsv/baayV5eQAAAAAAAAAAAAAAAKgobA72pawqy9dWAYWHh5t1lSpVTIbpTNLS0hQZGWm2a9WqVexzO6qMsb64ESNG6PXXXy/tSwEAAAAAAAAAAAAAAABQxi1cuNAUhGrWrJlSUlLOOt4a06RJE4WFhWnJkiUVL4AFAAAAAAAAAAAAAAAAAOfqxx9/lM1m00033aSAgICzjg8MDNQtt9yinJwcTZkyRcVFAAsAAAAAAAAAAAAAAADljoOt7C+4OFavXi0HBwf17NnznI+59tpr844tLgJYAAAAAAAAAAAAAAAAAMqt/fv3m3X9+vXP+Zi6deua9b59+4p9fgJYAAAAAAAAAAAAAAAAAMqtrKwss3ZycjrnY3LHpqWlFfv8BLDOICMjQxMnTjQlx6pVqyY3Nzd5e3urQYMGGjhwoFatWlXalwgAAAAAAAAAAAAAAHBpspWDBRdFUFCQWe/du/ecj8kdGxgYWOzzE8A6jQMHDqh169Z6+OGHtXDhQh09etQEspKTk7Vz5059+eWX6tixo55++mnZbPw/BgAAAAAAAAAAAAAAACgNLVu2NOspU6ac8zGTJ08266ZNmxb7/M7FfoUKKDMzU71799aWLVvM4+bNm2vw4MGm8lViYqJWrFih9957z4Sxxo8fr+rVq+vFF18s7csGABTTtz8lasWfqfr7n3Rt2p6ujAzp83HBuv8O31OOT0jM0etjozV9TrKORmWpWrCzbu3rrdeeC5S3V9GMc06OTR9Nitf/vk3Q7v2Z8vZ0UPfOnhr1YiWF1XYpNDY726Z3J8Tq8+8TFB2bo7at3DTujcpq3MC1yOt+9k28Br92XBsX19JldQq/DsquTbMOaO7wv844pna7yur/2VV5j49sitHqz3fo8IZoZSRnybeqhxr1ClGHBxrIxb1wOdWs9GwtHb9FO349rMy0bNVqE6TuQ5vLt4pnkfMs/XCzuZ6HZlwjd9+icwzlT/TKnTr2y3ol7z6m7LRMuQZ6y7tRNdV+sKvcgvPf01IPx+jwD38occshpR9PkrOPuzxrVVLVG1sr8Ip6hV4zJyNL4ZOWKXrZDuWkZ8q3eYjqPN5DbpV9ipw//Itlily4SS3/96B5TZR/BweNUfbxuFM+59YoVNVeeajQvozDkYqfuUSpW/YoJzlVTn4+8ry8kfxv7iYn78LvQ7acHMX/skxJi9cpOylFbpfVVOA9feRaM7jIuRJ/X6OYb+aq+jtPyaVKpRL+KgEAAIDSxb0pXAjfTUvUyj/TzLzavD3DzKuJH1TWvXcU/X0+d16NfC9WMwrMq1v6eOmV5wJOO68+npSgid8laM/+LDOvul3loTdeDDzlvBrz3zhN+j5R0bHZatvSXe+NrKTG9YvOq4nfJui516L19+81mVfliDUfvvgqRd9NSdHu3VlycpaaNnHRE496q1fPwveIgmoeOevrbVxTRTWq57aGsmnU6AT9PDtVqak2XdnBTW+/4afqJ54vaNQ7Cfp+SopWLQ6Wvz/1SCrCvPr52zjN+zFBB/dkyMnZQZc1ctPtDwfoyh7eRcYnJ2brq/9Ea/n8JMUez1ZgZSd1ud5H9z5dSR4nvY8lxmfr41FR+nNJshwcpPZdvfTYy5Xl41d0Xr05KEJ7d6Tr019qy9nF4YJ+zQD+nRtvvFFz587V9OnT9eOPP+q222474/ipU6easQ4ODrrppptUXASwTmHWrFl54asrrrhCy5cvL9Qj8pprrtENN9xgnrPCWqNHj9bzzz8vZ2f+OQGgPHttdLQOHMpSUKCjubFgbZ9OckqOrr75kDZsztA1XTzUv5+31m9K13sfx2nZ6lQtmVFD7u6Ff5B/7IUoc9OqSQNXPfWgn44czdaPvyTq16UpWjW7puqF5d9oGPdZnF55J0a9unuqfpiLuVFy3YDD2rq8dqEbHRHHsvTiqGgNfz6QGxHlTHADP3V8tOEpn9vx2xEd35Og0Cuq5O9bdFg/D10jB0cHNeheQ15Bbjq0IVqrPtuuA2ui1P+zTnJ2zf95ZfH7m/T31L1q2LOmPP1dTcBq+qDVuve7bnJ0yv/lMHJnvNZ8vUt93mxL+KoCsCqz7v1woSLnbpRbNX9V6tpITh6uyohOUsKmg0qPTMgLYCVuP6KtQybLlpWjgA51FdipgTLjUhSzcqd2jJihmvd0VMjdHfNee/9ni3Vs9npV6txQzr4eilq4WTtGTFOzD++Vg1P++1Ly3kgd+WmN6g7tQ/iqgnHwdJfvdVcW2e8cFFDocdqucB17e5JsGZnybNNIzlUClXEgQokLViv1n12qNvxROfnkh7AS5q1U3NRf5dGyvjyrBilp5QYde2eSaox9Ro7ubnnjsmITFPPDAhPiInwFAACAioh7U7gQRoyOPa951f3mI9q4xT6vbr/JSxs3Z+j9T+K17I80/T69WpF59X9DjuuL7xPVuIGLnnjAVxHHsvXTL0n6bVmqlv9SQ/XC8ufFfz6L12vvxKpXdw/VC/PU99OS1HtAhDYtCykyr4aNitGrzwUwr8rZfakHH4vVL3PTFFrbSXf191R6hk3zF6bpngdi9M5IPz000Ctv/AvPFg3OWPbtz9ZPM1LVoL5zXvjKMnxkvL74OkU39nVXpQBH/TA1VXc9EKPf5gTJqcD9zi1bMzXhkyR9Mj6A8FUFmVdvPBlhwlTVa7uo1+1+ysywaeWvSXr1kSN6akRl3XRv/r2p1JQcDR5wSLu3puvyqzzVra+b2Z76v1ht/DNF46aEyNUtf168Pfio/lqRrGv6+cpqevXrjATFx2Zr1P9qFLqOPxcnacmcRP3nxxDCV0AZdt999+ntt9/W/v37deedd+rPP//UoEGDFBISUmjcwYMH9cEHH5iCS1b4ynr+oYcKf8j43yAxdAqrVq3K2x42bFih8FWuNm3aqE+fPpoxY4bi4uK0bds2NWvW7CJfKQCgJH32XrDqhbqodoiLRo+P1UtvRZ927Jj/xpobXEOe9NfbL9v7CVuGvXlc706IMzepXnw6v1fw4pUp5gZX5w7uWjClhlxd7T+gD+jnrT53R+ipl6I0f3L+D/TWJ8a6d/bQ7G+rm8f9rvdW136HNfvXZPW/Kf/TaU8Oi1JYLRc9+6h/if974MKq0tDfLCfLzszR31P2ytHZQU1vqGX2WRWsFo7aYLbv/rKLqjYOyPvl87d3Nprx677dbSphmf05Nv0zc7+a31RHvYa3NvuqNQvUnFfWKWJLrGo0t8/NnGyb5r/+t8I6VlGja2tetK8dF87RmX+Z8FWVvq0U+nj3QsEoiy07J2/70LerlJOepQbD+ynwyvxqV+l3X6mNj03Skal/qsbt7eXo6mzmVOSCTQq+trkue/Y6M86nYXXtHjNHSTuPyqdR9bzX3/PBfPm3DVVQl1MHDFF+OXq6K+CW7mcdFz1xpmzpGQoefLcJYOWKn71csT/MV+zUhQp6MP/TRImL18m96WWq8sJ95rFn2yY6OvJ/Slm/Q95XNM8bF/PlL3IJDpDv9fnBQAAAAKAi4d4ULoRPxgapbpiLatd00bvj4/TK2zGnHTv2v3EmfPX8E3566+X8D7689Ga0xv43Xv/5X7yGPpUfdFiyMtWEr67q4K55k6vlzSsrEHjD3Uf1zMvHNeeHannjP/8uUd2v8tCsb+z7brreS936RWjOrym646b8MM7TLx1XaC1nPfOoX4n/e+DC+WVOmglftW/rqp++ryQPD/t8eOXFbPW4/riGj4pXzx5uqhVi//P00OdOXd3vxVfizdoKcBWsgPTd5BSzb9wY+/tNm1au+r9n4rR+Q6Yub+OaV2XtmRfi1P1qN93U1+OCf8248JbNSzLhq6Zt3PXuNzXldiIE+uDzQXr8xgP65K3j6tDNW1Vr2sOaUz6NMYGr/o8G6OGhlfNe53+jozT501j99Hmc7vw/+/fH6Mgs/bk4WQ88V0l3PWF/z7Ne58sPohUTlaXAyva5mpqco3GvRurGe/zVuBXzCijLXF1dTUWrzp07KykpyYSsrKVWrVqqVs3+80dERITCw8Pz/s7m7e1tcj9ubvkfBv63iP2eQoZVf/WEsLCw04677LLLTnkMAKB86tHZ09zgOhvrm7F1w8rby0GvPJt/I8tiPbb2W88XZN20srw+pFLejQhLr+5e6nqlh35dmqrwQ5l5+w8ezlKb5vnf6C9v4Za3P9f0OUn6ZWGyPnuvspyd+cRFRbHz9yNKjcvQZVdVlVcle/WgwxujlRKbrnpXV88LX1msVP5VTzQ22+t/3GfmpiUlLl1Z6Tmq2jj/5mfudkJESt6+dd/vVvT+RF3zkr0nNsq37PRMHfx2lal8darwlaXgvrSIOMlB8m9b+Oddtyp+8qxT2YSzrPaFlqyEFNkysuRVL78qm1f9qmZtVdXKFTHzL6UdilHokz0vyNeIsi/zWLQyDx2Ta1iNQuErixWccvT2VPLKDcpJy//9KTs6Xq6h+X/osY41+wu0PExeu0Upf29XpYf6yeEUH5ABAAAAKgLuTeFCsNpMWuGrc5lXk35INPPn5WcLVzq2Hlv7rdaBBX1+Yl6NGBJQaF5d181TXa50PzGv8ufMoSNZatU8v9Ja7hwrOK9mzE3W7IUp+nQs86q8mbcwzayfedI7L3xlqRTopMce8lJ6ukxbwDOx2gz+NCNFrq7S7bfkB12iY3KUli61aJ4/l1u2sG8fOpKdt+/Tz5O1a0+WxrxJKLSiWPVbkllboanc8JXFL9BJtzwQYKphzf8xPu99bO7UeHl4OejupwpXT7ceW/ut53NFRdi/79Vrml/Fv34z+3bkkfzviZ+PPS7Z7KEvAGVfy5YtTeWrVq1amfcFazlw4IDZZy3Wdu5+q/DSmjVrzNiSQADrFBo0sFePsOzdu/e04/bs2ZP3x8969fKrBgAAKrZdezNNifYr23rIy7Pwt1LrsbV/74EsHTyc/wP60lWp8vJ0UMd2Rdtx9exq/yTP0tWpeftCajibsvG5/j6xbe23xCdk6+mXo/TMI/5q3ZwWXxXJPzP2m3WLfnXy9iUft9+88K+RX6I7l9U20N3XxQSr4g4lm32e/m5ydnPUse354YVj2+zbvtXs8y3+cLJWfLRVXZ5qIt8q+Z8mQ/kV/9d+ZSelKfCKuqYSVfSKnTo85Q8dnb1eqYdji4z3rBNkbhzErS38864VqErZHyXPsGC5+NpvdDn7esrB1VnJeyLzxiXvPmrWuS0N047G6+DXK1RrYGe5Vc7/NDQqkKwsJS79W3Gzlihh4Wql7z5YZEh2nP2mmHPlwn8Esjg4Oso5yE+29MxCxzpV8lPG/iN5jzP22bedguw3S3NS0kz1K99eV8qtQFALAAAAuFRxbwoXdl65n2ZeuZ+YV/lhqWWr08y8sp472TVd7PNq2R/586pmdWfT0jDX+k0ZJ82rHFM1a9DDfmpVIACI8iEyyh6Eql2r6AenatWy/zdeserMBS1mz0tVXLxN113jrqBK+a9TKdBR7m7Sps3572sbN9m3a55oUxh+MEujxybq1Rd9Vb1A60KUbzEn5lXVUwSUq53Yt/7E969D+zIVfSxbTdt4yOOk9zHrsbU/IjwzL1xVuZr9+N1b8r/f7d5ivxcfXN3+3Nb1qZr1TZwGjQyWR4FWqQDKtkaNGumvv/7SggUL9NRTT6lTp04mB2Qt1vbTTz+tX3/9VWvXrlXDhiXXzYMWhKcwYMAAvfLKK0pISNDo0aN1/fXXF2lDuH79es2ZM8dsW70jfX1PXSYTAFDx7Np34lMRYaf+5Ji1f+ES+7iQGi5KTslRhPVDf0PXQr3oc9UNPfFD/onXtTx4p6+GjoxW33uOqH6Yi76blqTqVZ3U5xp7AGfIG9HycHfQ6y8U/QM3yq/4Iyk6sCZSPlU8FNrRXl3I4hFgv+EUd9gesCooPTFTaQn2uRNzIEkBId5ycHRQsxvraP2Pe5WRnCUPf1dt/jlcVRr6qVoT+ycY549ar+D6fmp1x+mrfaJ8Sdp1NK/K1cbHJyntUIHQlaODqvW7XHUeuTpvV637rlLi1sPaOWqWAjrUlXvNAGXGpShm5U5TRav+SzfkjbXmVPC1zXRs9nplp2SYYFbkr5vkVTdY3icqYe39cIG8woJN+0NUTFa4KvqzaYX2WdWqKj95h1yq2D9V6ORjv8GeFVW0pYUtJ0dZx+2fMsw8elweTe0VhX26Xm5aEx4b87VcqgUpaeUGOQX4yLOV/YMxMd/Pk4Ori/xv7XHBv0YAAACgPODeFC6E3fuyCs2Hk1n7Fy5JNfPECkzlzqsmDV1OPa/C7H+C3L03f149cKePho2K0U33HjXz9PtpiWZe9b7G/rvkiyPt82r4C4UrcKF8CAy0/y31QHi26tcrPI/Cw+3za8/e/ADfqVhtBi13Dyj8gVFHRwfd2d9Tk75OUVKSTYEBjvrhxxQ1a+qiVi3t53ruxXg1aeysB+7jw6YViV+AfV4dPZip2nULBzMjDtrfXw7tswf7Du+3r2vUya+0V5C1f+2yFB3en2kCVpWCndW+q5e++s9xRRzMkNVg4tcZCbqiu5dpP5iVadP7w46py/U+ps0hyi7ru5CDvUFImUQ9x9JzzTXXmOVicS6LPRmt/ouOjqWXIA0KCtI333xjglgrV65U27Zt9cwzz6h+/fqmT6S177333jNtB1u3bm22z8ehQ4fO+LzVcxIAUHZZn8Sy+Pmc+nuVr7djoXFnHX9if+44y7OP+is93aYvfkjQij/T1Lalm8aNrCxvL0fziUWrjPz8ydXl4uKg50cc15dTEpSSatO1XT1Nee7goDL3LR7nYNOs/bLlSE1vqCXHAjeuarasJFdvZ+1afMRUtarSML+E9vKPthYKY+W6enAzOTo7aMevh5WVnq06HYLVfWhz87qbfzmgg+uO6/7J3ZSZmq1f396gHb8dNsc16FHDtCR09WAOlTdZcfYbVEemrZVX3Spq9uE98qhVScm7j2nvfxYoYtpauVfzV9UTASnruWbj7taOUbNM6CqXs6+Hgns2M2MLqv1wVxPuil6+w7Qn9G9dR3Ue72H2Rf26WQn/HFTz/96nnLRM7fvvb2acpdJVDRT6ZA85uZ/6xgfKB5/OreXWsI5ca1aRg7urMiOOK2HeSiWv2KCjb32hGu88LUcPNzlXC5JzcKAy9h5Wyvrt8myV/+mhhPmrlJNkn6c5yfZPE+a2JrRlZilp6V9K27FfbmE1FXhvHzm6uylt2z4lLflLVV6838y1mG/nKmnZ38rJyJRH83oKevAmOflxAwwAzhf3pgCgfOPeFC6E3P/+vr6nnic+ufMkMee85mHCifGWZx71U3qGTV/+kKgVf6bq8hbuen9UJTOvlq1O1RffJ2ruD1XNvBryerS+mpJo5lXPrh76eIw1r6hqVJb1uNpNM2al6j8fJemqjm5yd7ff34yJzTGtAU9+nznZgfAsUyGrZg0nde1ctALa66/4ycXZQbNmp5pWhV2vctPbb/iZAOCUn1K0cnW6Fs+vrOQUm158JU6/zLHfe+jb212j3/QrUtkN5UO7rl5aPDtRP3wSq1ZXesrV7cR7UWy2pk+yfwA1+cT7TO7a6zTvS54n3peSE/PbVr74flV9NCpKq36zz9HuN/jq8Vcqm+3vP47R8cgsjfm2pmKisvTBK8e0dmmK3NwddN1tfnrkxaBTBlABXLrK3E/AViu//fvtrXdK0w033GBKklnhqs8//1z33XdfoeerVKmikSNH6uGHH5an5/klqUNCQkr4agEAFY31Q/vLzwaapaC0tBw9NiRS99zmox6dPfXOhzH66Mt4vfd6kGpWc9bTL0Vp4KBIzfmueqldO/4dW45Nm34+YD4K0fym/PaDFldPZ3V7rrnmv/63vrl3iQlJeQW56/CGaNNaMDDURzH7Ek2Volwu7k7qMaSFWQpKiUnX7+9tUocH6ivoMl/NH/m3di2J0HWvtjbnXvjWBnNsz5epYlTeWP3KLY4uTmo4op9cK9nbAPo2C1H9V27Uxse/NOGs3ABW4vYI7Xh9ujxDK6vZhHvlEVJJmbHJOvrz39r/8SIlbj5kjsvl5Oai0Me7m6Ugq2rW/s8Wq8Yd7eVZO0h7/rNAMat3KWzQtXJwkPZO+FWObs4Ke6rnRf33QMnyv6Xwf3e3OtVV+fHbzLYVwkpcvFZ+13cy7dkrDbxBx8Z+o8j3vpXn5Y3tgazwCKVt2i2XkCrKPHis0PuV1ZrQv9/VZinIClkd/3ymvDq1lEfTuoqbtVQJv/2pwLuvl3Ogr6K/nK3jn05TlSGFf1cDAJwd96YAAGfDvSlcqHn10jMBZjl5Xj3+wnHdfZu3unf21Ojxsfr4ywSNHVFJNao56ZmXo/XQM5H6+dtqpXbtOLtbbvLQD1NTTIjqqh6R6t7VXZlZNs1bkKbKQfbgS4HbAUV8PyXFVCAacLuHqXh1Mg8PB735up9ZCjoena1XX0/QoCe81aC+iwYPjdO8hWl6b7SfuTc15OV4c+yYtwp/2BDlQ/cbfLRgWrw2rE7VQ9cdUNsuXqYy1cpfkxRwIpRp/Xf+t3z9nfTi2PxuFLkO7E7X9x/F6JlRwQoIctbQ+w4pfE+GXptQTdHHsvTfkVHm/P0fpRIkUNbl5OQoJiZGKSkpqlGjRpHudxU6gFVWWNWtvv76a82aNSvvj1kFHTt2TN9++61CQ0NNWAsAcOnw8y38aa+TJSTlFBp31vEn9ueOO5OR78cqLj5H740IMo8/nBive2710eP3+eW91r1PHtOO3RlqUJdqM+XJ/j8ilRCRqtrtK8u/hr2cf0Et+tWRd2V3rflyp3YviVBOjs20E+z/WSf9MWmnCWB5Bhb9ZNjJfnt3oxl3xUMNlZ6cqU2zDqjTY43U+Hr7H+HiDiVr5afb1PXZZib4hfLDycv+39+rXtW88FUuzzqV5V7VT2lH4pSVlCZHdxftevtnE4Jp8Fo/ObnbS7U7VfNXnUe7Ke1ovKlglbDlkHyb1Dzjefd9vEgu/p6q0f8KZaekK2rBJtW8p6Mqd2tsnk+LiNeh71aq9kNd5eTB+1JF49OtnQlgpe8Ml66377MqU1V77WHFzVistC17lLNhh1xrBqvys3eZx1YAy9G36PvcyeJnLFZOcqoJXFkSFqySd6eW8u3R3jzOSU3X8Y9+VOaRKLlUt38yEQAAALgUcG8KF0Luf/+E01QoSsydJycqy5zrPMytsHYmoz6IM5WRxgy3t7efMDFBd9/qrUfv8817rfufjGJelXHOzg6a8k0l/ee/SZo2M0Vff59s/vtff527nnjUW+07RyroNFXMrHudVnjLapB0V//zK3zx0msJqlzZUc8+5aPEpBwT5Br6nI9u7eeZ1xJxzAeJGv6yr6m2hvLFydlBb39RQ5M/idWinxM0Z3K8qXDVsae3bn8oQPd13y//Sk6FKl/lVsI6WcqJ9yUvnzOHL6xsgNV6sFlbD113q58JXq1bnqKXPqiqK3vYK7Hv3JymaV/EEsAqK2wO9qWsKsvXVkFlZ2fryy+/NMvatWuVmZlpPjz8zz//qHFj+98uLLNnz9ayZcvk5+enl19+udjnLbG/qm3btk2fffaZli9frr179yoxMdEkyc7E+gKzss7c67c0JCcnq1evXuZrsdJvQ4YM0cCBAxUWFqa0tDT9+eefeuONN7RixQrddNNNGjt2rAYPHnzOr3/w4MGzlnlv165dCXwlAIALoV6oPaiwa29+u7eCcvfnjrNKG1er4qR94ZnKzrYVKUm7e599fN0T40/nn63pGvtxrL4aX0WBAU6KT8jWsahstWyaH7ppdWJ7Ozcjyp2NM+wVQJv3K1z9qqDLOlU1y8mOv7xODo5S1QKtCU9lz/Kj2r7wkO78ooucXBwVvTdBOVk2BTfIP85qb2jtizuYVGg/yj6PmvZf9p29Tx3Ec/J2N2urfWB6VKLSj8YrsGP9vPBVQX4tail21S4l7448YwArds0eRS/brqZj7zSVt5LDo2XLzpHXZcF5Y7zqBsuWlWPCXwX3o2Jw8rHfzMxJzyi0361uiKq8cG+R8VYbQvN8aI0zvm5G+FHFz1muoMdvk5O3p3JS0pQTnyTX2vmfdnatbf9EPQEsADh/3JsCgPKNe1O4EOqGOheaDyc7eZ7kzqv94Vmnnld77X//qxt29nn1/sdxmvRh8Il5lWPmVYsm+fMnd47t2J3JvCrj3NwcNGSwj1kKWrEq3axbNj/1fFi0OF1HInLUrYubatY49z9f/7ooTTN/SdXs6UFydXXQzt1Zsv703LRx/nmaNXFRZqa0/0C2mjYmgFUeWW0H7x1UySwFbfgjxawbNLPf96xRx/7+cHh/4ftUuXL316hz5veln7+N1+6t6frfvNrm8cG99uMua5z//a5uY3fNnZKgpIRsefvSHhUoSyIjI02Ox8r1nKrYUkF16tQxBZes7FLv3r3VsmXL0g9gvf/++xo2bJgJU53tCygPRowYYcJXlpPbD7q6uuqaa67R1VdfrZ49e2rx4sV64YUX1L17d7VoUbjFz+nUrHnmKgIAgLKtXpiLqld10qq1qUpOySnUO956bO0PreWskBr5P8R3vsJDU2YmaeWaNLNd0MIl9l8SOncovL8g6ybGI89FqmdXT/W/qfAvr+np+d970zPs29YPCig/UuPSTVUrdz9X1e92fiX6D62PVvyRFIV1qiI3n9P/4piRkqWFb61Xq9vCVLNl4V9UszOzi24zh8odKzRlSQ2PLvJcTla20o7EmspXVrWqjJgksz8z3v7+c7Lc/Vao6nSyUzO0d/yvqtK7pXyaFA7T5BSYU3nbTKkKKX3PIbN2Djp7YDMrKlbpOw7IpUawXGsVDZPmsuXk6Pj/psujWT15X9G88HNZ+XPLlvthHt6vAOC8cW8KAMo37k3hws6rtNPMq7QT8yr/T4tXdXDX1FnJ5rmrTpo/vy5NyRtzpnn12PPHzby64yZ7VZmT51LBOca0Kr9+mpFq1v1uPPX7zHeT7fPl7gHnXv0qKTlHL7wUr4H3eKrd5YWDeRkF5k/uNtOn4lk0K8Gsr+5r/75UM9RFlao4afNfqUpNyZFHgfcx67G1v1qIi4Krn/4+etTRTH0+5rjue6aSqtcqPK8yC8yr3G3el4CyV/mqb9++puqVo6OjbrvtNnXu3FlPPvnkKcc3bdpU7du315o1azRjxoxiB7CKHfOdP3++nn/+eVOyy9KhQwc98cQTevXVVzV8+PAzLq+99prKGitA9sUXX5jt+vXrFwpfFeTs7KyRI0eabavSl1W6DABwabBuID14p6+Skm0a9UFMoeesx9b+h+6yl8fO9fDd9sfD340u9MvfvEXJWrIqVdd08VDtkNP/0P/h/+K0bVeGPnonv8KHn6+T+ZTZ3N+TC72epVG9M3+CA2XL5tkHlZ2ZoybXh8jZ9dSBl/Skop8+TIxM1bw3/pajs4OueiK/ZOqpLBu/RbYcqfPTTfL2+Yd4m2P3LD+Wt8/atqpj+YecvT0Yyhb36gHya1PHVJo6Nm9joeeOTPlT2UnpCuxYTw5OjvKsHSQnT1clbj2suL/2FRqbHpmgY3M2mrtSvs3trSlPJXzSMinHptoPdC5wDf5ycHZU3Jq9efusbQcXJ/McyqeMI1FFKlzl7o+dPN9se1+Z/2GUnLT0Ih/MsSpYRX38k/XLkwLu6HnG81lVsqyqVpUeyG/17ujpLid/H6Vu2JG3L3fbpQbVrwAAAHBp4d4ULtS8GjjAx8yfNz+ILfSc9dja/8BdhcN3D52YVyPejS00r+b/nqKlq9Ls86rm6efC+Inx2r4rQ+Pftre0zG1taM2r+YtSC72epWE9ql+VdbmtKgv6eXaqaQvYqoWL+vQqGsg7Hp2tBb+lKaiSo67refrA3snefMfqxmTTK8Py3+/q1HaSi4v06+/2ilsWa9vV1apyQpWi8io5Mf8DebmWzk3U/B8T1KC5mzpd6533Pnb97X5KTbbp2/GFP6RqPbb2X3+HvWXu6Xz4WqSq13HRLQ8E5O2rdZn9vWfNkvzvd38uSTZhr7O1MwRwcX311VcmfOXi4qI5c+Zo8uTJ+r//+78zHmNVwLLuZ1sd8Iqr2BWwxo0bZ9YBAQH6+eef1bFjR5Vnx44dU0yM/ReWVq1anXFsmzZt8ra3b99+wa8NAHBhTfwu3nwK0LJ5m/0PzV98l6Clq+y/7Hds566H7rL/cP7CEwH6eUGy3p0Qp/Wb0tW6mZv+3pSuX5emqm1LNw16uHDQ4OqOnubG2OffJ+jyngd1fQ9PRRzL1tSfExUY4KgP3zz9H4/3H8zU8DExeuulSoU+uWh5+iF/DXszWn3uPqKa1Zw1aXKCel/jqXph3IwoT/6ZaW8/2OLm07cf/OuHPdoyJ1w1W1WSZ4CbEo+lateSCGWmZavX8Naq2ij/F8KTHf4nRn9P2aObP7hCbl75c8jV09m0PNzw4z5lpdl/id0676Ba9w+Tq0eJdarGRRT25DXa/Ox32jtugWJW7ZJHSCUl7zmmhA3hcqviq9oPdTXjHF2dVfvhrtr7n4Xa9spPCmh3mTxCApUZm6zolTuVk5qpare0zWtreLLEbUd09Jf1ajC8n5w880tvO3m4Kvja5jo2Z4Ny0u2hweOLt6nqDa3l5M77UnmVvPofJcxdKfeGdUylKwc3V2UePa7UDTutjxTJ74Yucm8Umjc+Zd02xU5dKPfGYXIO8FV2QpJS/t6unIRk+d/aQ55tGp32XJlRsYr7aZEJaTlXKvy91Pe6KxU7eYGOjflKToF+Slr6lzxaNZBL1fwb9QAAAEB5xr0pXAjWHFq59qR59X2Clq4+Ma/auuuBE4G955/w1y8LUjT2v/HauDlDLZu5acOJeXV5Szc9/VDh4ELXjh564E4fffF9otpde0i9unvqaGS2fvw5ycyrD0YVrsJ+8rx6fUysRg0LLFRVy/Lkg356+a0Y3XhPhGpUc9aXkxPNnLWqdKFs69n3uGpUd1L9us6mHeHfGzK0cnWGCUZ98WlAkVaVlik/pZoWgbfd4mHaCJ6LdX9l6POvkvX154Hy8c6vN+Lt5ai7+nvqy29SlJpqDwVOm5mqh+73KlTVDeXLkzcfVOVqzqpV19XMke3/pGnjH6mqVstFw/9bvdC8uuPRQK36LVmTP401bQTrNXHTri3pWrc8xYS1bnng9B8SXTIn0QSr/jujVqHXDAlzVdsunvrqP9E6djhL0ZFZ+ntlih59iXtSZYb1f/ey3KitLF9bBfPDDz+YMOajjz6qa6+99pyOyc0F7diR/+Hff6vYf1lbt26d+QKsalblPXyVW9kql9VS8Uxyq36dfBwAoHyybnB9PTWx8L61aXk3KCy5N7msX9YWT6+h18fGaPoc+ycFqwU7a/Bj/nrtuUB5eBT9Ze6TMZXVrJGr/vdtgj6cGC9vTwfd1Mtbo16spMvO0HP8sRcizXH/N7DoJzOee9xf0bHZ+nJygpastKlvTy998m5wMf8lcDEd2RSj47sTVK1pgCrXO/2nb2q0CFT4uuPavfSo0hIy5OHvqrBOVdVhYH1VaXj6Xxqtylrz3/hbDXrUUN0u1Yo8f/XgZmbMjt8Om8fN+9VW12ealdBXh9KogtVs/L06+PUKU9kq/u/9cgnwUpW+rRRy95Vy8c+vbFbl+pZyq+KviJnrlLjtsGLX7DEBKq+6VVTl+haq3C2/WtrJ7Qz3jJuvSp3qK7BD3SLP136kqxkTs9z+y0rwdc1U66EuF/CrxoXm0ThMmYejlHHgiNJ27JctI1NOPp7yaFlfvj3ay6N5vULjXUOqmBaDaZt2KzsxRY6ebnKrGyLfXp3k0STsjOeK/nymOd7nmvZFnvPt3cm8XtKyv2Tbuk+erRup0oM3lvjXCwAAAJQW7k3hQrDmzzdTkwrtW7U23Sy5cgNY1rxaNL26Rr4XoxkF5tWzj/rplecCTjmvPno3SE0bumridwma8HmCmVc3XuelN14MPOO8emLIcTVt5KrHBxau1mYZ/LifmVdfT0nUkpVp6tPTUx+NpvpxeXBTX3fNmZemdX9nKCvTplq1nPXcIG89+Zi3fHwcz9h+8J5zbD+YmWnTs0Pi1Le3u667pmjFrNdf9VVmhvTzXHvI0ApkDX+56DxD+dG1t7eWL0jStg1pZl5VDXHR3U8G6vaHA4pUoLLaDr7/Q019/Z9oLZ+fpA1/pCiwsrNueyhA9z5dSW7up56HifHZmvB6pG59IED1mhSdV0PHVNV/Xo00bQ9d3R10xyMBZiyAsuWff/7Jq2p1roKD7T+7RkcXrpz3bzjYTu4NcZ48PT2Vnp5ueiIWrAhVXlntBK1qXgkJCapevboOHDhw2nDV7NmzTf9Iy1NPPaUPP/ywRK7h0KFDCgmxt3s5ePCgatasWSKvCwAXSs7Rwn94BUrCS8eal/YloAJadqxoYAgorojjZy5dDpyvrOh4HXr6XbPN74QASgP3pgCUN9ybwoWQbSvaSg0oroSc/EAlUFI2Zthb8AElJSoiU/077ivTvxMW/L01ZPircvY//QfVS1tWXJwOvj6yTP97VhRubm6m0JJVSKpgxztHR0dTWGrTpk1q3LhxoWOsloXt27c32aekpMKh9fNV7FqLNWrUMOuMDHvZ0vLO+ofv3bu32T5y5IjefPPNU46LjY3V0KFD8x736dPnol0jAAAAAAAAAAAAAADAJc9WDhZcFIGBgXlBt3O1a9cus65cufjVNosdwMqtALVy5UpVFFY7RSvdZhkxYoQpTzZt2jStX79eq1ev1gcffKCWLVtq69atZkz37t3Vs2fPUr5qAAAAAAAAAAAAAAAA4NLTpEmTvKpW52rKlCmmOlbbtm1LP4D1/PPPmxTZe++9p6NHj6oiaNiwoWbNmqWgoCDz+JdfftGtt96q1q1b68orr9TgwYMVHh5unuvWrZt+/PHHUr5iAAAAAAAAAAAAAAAA4NJ00003yWazacKECaar3dn89NNPJg9kueWWW0o/gFW9enUTVsrOzjbhpLlz56oi6NGjh7Zv367Ro0era9euptyYi4uLPDw8FBoaqttvv10zZ87Ub7/9poCAgNK+XAAAAAAAAAAAAAAAgEuKg63sL7g4Hn74YdWqVUsJCQmmi11uV7uTRUZG6uWXX9add95pql81bdrUZICKy/lcB1qVns7EqoK1c+dO05LQ399f9erVy2vjdzrWF7Jo0SKVVZUqVdKQIUPMAgAAAAAAAAAAAAAAAKDscXNzMwWkrCJLf/31l5o1a6YGDRrkPX/33XcrKSlJe/fuNZWyrMXKBU2bNs3kly5aAGvJkiXmhNYFnEruxVjPW6W81qxZc9rXyn2dkvgCAAAAAAAAAAAAAAAAAFzaWrRoobVr1+q+++7T6tWrTee7XBs3biyUeWrXrp2+//57hYWFlci5zzmA1blzZwJTAAAAAAAAAAAAAAAAAMqkunXrauXKlVqxYoV+/vlnrVu3zrQdzM7ONhWvWrVqpRtuuEHXXHNNiZ73vCpgAQAAAAAAAAAAAAAAAGWCVdDo1I3cyoayfG0VTHh4uFl7e3srMDBQnTp1MsvF4njRzgQAAAAAAAAAAAAAAAAAJaxOnToKDQ3V5MmTVRoIYAEAAAAAAAAAAAAAAAAotzw8PMy6bdu2pXJ+AlgAAAAAAAAAAAAAAAAovy0Iy/KCi6JGjRpmnZ2drXIZwFq1apWcnJxMkuzw4cNnHW+NcXd3l7Ozs/7666/inh4AAAAAAAAAAAAAAADAJaxnz55mvWLFivIZwLJ6J9psNvXp0ycvTXYm1pi+ffsqJydH33//fXFPDwAAAAAAAAAAAAAAAOASNmjQIFM8auzYsedUQKrMBbCs5JiDg4N69ep1zsf07t3brJctW1bc0wMAAAAAAAAAAAAAAOAS5GAr+wsujnr16plCUCkpKerQoYPZzsjIuEhnl5yL+wJ79uwx68aNG5/zMQ0bNjTr3bt3F/f0AAAAAAAAAAAAAAAAAC5h3bp1M+vKlStr3759uueee/Tggw+aYFZAQICcnJxOe6xVeGrRokWlG8BKS0sza3d393M+xs3NzayTk5OLe3oAAAAAAAAAAAAAAAAAl7AlS5aYIFUum82m9PR0bd68+bTHWOOtcQWPK7UAVmBgoCIjIxUeHq6WLVue0zGHDh0ya39//+KeHgAAAAAAAAAAAAAAAMAlrHPnziUSpCq1AJbVetAKYP3888+64YYbzumYmTNnmnWDBg2Ke3oAAAAAAAAAAAAAAABcimwO9qWsKsvXVgErYJUmx+K+wPXXX2/KcX399ddavnz5WccvW7ZM33zzjUmd9enTp7inBwAAAAAAAAAAAAAAAIDyG8B69NFHFRQUpOzsbBPGmjBhgtLS0oqMs/Z9+OGH6t27t7KyshQQEKDHH3+8uKcHAAAAAAAAAAAAAAAAgPLbgtDb21vff/+9CV+lpKRo0KBBeumll9SmTRtVq1bNjImIiNC6devM81a1LGdnZ/3www/y9fUtia8BAAAAAAAAAAAAAAAAlyJbaV8AUAIBLEuPHj20YMEC3XPPPTpy5IiSkpJMq8GCrOCVpUaNGqYFYdeuXUvi1AAAAAAAAAAAAAAAAABQvgNYlquvvlp79uzR119/rdmzZ2v9+vU6fvy4ec5qUdi6dWv17dtXd999t9zc3ErqtAAAAAAAAAAAAAAAAABQ/gNYFitY9fDDD5sFAAAAAAAAAAAAAAAAuFAcbPalrCrL14aS5VjCrwcAAAAAAAAAAAAAAAAAl4xiB7BCQ0N12WWXaffu3ed8THh4uMLCwsxxAAAAAAAAAAAAAAAAAHDJtiA8cOCAHBwclJGRcc7HZGZmav/+/eY4AAAAAAAAAAAAAAAAALhkA1gAAAAAAAAAAAAAAADARWc7sZRVZfnaUP4DWPHx8Wbt6elZGqcHAAAAAAAAAAAAAAAAUEEsW7bMrNu2bSsPD49zOiYtLU1r1qwx2507dy5/Aaxvv/3WrGvXrl0apwcAAAAAAAAAAAAAAABQQXTt2lWOjo76559/1Lhx43M65vDhw3nHZWVlXdwAVrdu3U65f+DAgfLy8jrjsenp6dq7d68iIyPl4OCgnj17nu/pAQAAAAAAAAAAAAAAANPiz6Est/kry9dWAdlstot6XLECWEuWLDHhqYInt7bXrl17Xq8TFhamYcOGne/pAQAAAAAAAAAAAAAAAKBYcnJyzNrJyeniB7CsnodWACvX0qVLzeM2bdqcsQKWNcbd3V3VqlXTlVdeqf79+5+1YhYAAAAAAAAAAAAAAAAAlLQDBw6YtZ+fX+lUwCrI6oNo+fLLL8+5hyIAAAAAAAAAAAAAAABQLLYy3uavLF9bORceHn7K/REREfL29j7jsenp6dqzZ49effVVU1CqSZMmFz+AdbJ7773XXExAQECxLwYAAAAAAAAAAAAAAAAAziQ0NLTIPpvNpp49e+rfZJ9KPYBlVb4CAAAAAAAAAAAAAAAAgIvBCludz/5TcXd319NPP60HHnig9ANYAAAAAAAAAAAAAAAAAHCxTJo0qdDjgQMHmg5+I0eOVI0aNU57nDXGCl5Vq1ZNrVq1Omu7wlINYGVnZys2NlapqalnTZbVqlXrQlwCAAAAAAAAAAAAAAAAKjIrknLuBY8uvrJ8beXcfffdVySAZbnpppvUuHHji349JRbAOn78uMaPH6+ZM2dq69atysnJOesxVqosKyurpC4BAAAAAAAAAAAAAAAAwCVm8eLFZh0aGloq5y+RANaqVat08803Kyoq6rx6KQIAAAAAAAAAAAAAAABAcXTp0kWlqdgBrOjoaN14441mbfVFfOihh+Tv768RI0aYClcTJ05UTEyM1q1bp59//llpaWnq2LGjHnzwwZL5CgAAAAAAAAAAAAAAAHDJcbDZl7KqLF9bRZOdna2VK1ea7RYtWsjPz++M4+Pi4vTPP/+Y7auuuspknEo1gDVhwgQTvnJzc9Pq1avVpEkTbdmyxQSwCvZYtEREROjOO+/UsmXLdMUVV2j06NHFPT0AAAAAAAAAAAAAAACAS9jMmTN12223qVKlSjpw4MBZx7u6uppuf7GxsZo1a5b69OlTrPM7FutoSfPmzTMpsAceeMCEr86kWrVqmjt3ri677DKNHTtWv//+e3FPDwAAAAAAAAAAAAAAAOASNmPGDLO2Qlienp5nHW+NueOOO2Sz2TRt2rRin7/YAazdu3ebdY8ePfL2FSzLZZX4KsjDw0PPPvus+QI++eST4p4eAAAAAAAAAAAAAAAAwCVs7dq1Jq/UrVu3cz4md+wff/xR+gGshIQEs65du3bePnd397ztxMTEIsdcfvnlZv3nn38W9/QAAAAAAAAAAAAAAAAALmEHDx4069DQ0HM+pk6dOoWOLdUAlre3t1lnZWXl7QsMDMzb3r9/f5Fj0tLSzDoyMrK4pwcAAAAAAAAAAAAAAAAAWR35zndswcxTqQWw6tata9bh4eF5+/z9/VW1alWzvXjx4iLHrFixwqy9vLyKe3oAAAAAAAAAAAAAAAAAl7DKlSub9fbt28/5mNyxQUFBpR/Aat++fV4vxYKuu+46kxR79913tWvXrrz9Vt/EMWPGmL6Lbdu2Le7pAQAAAAAAAAAAAAAAcCmylYMFF4WVQbJySl9//fU5H/Pll1+a/FLr1q1LP4B17bXXmi9g+vTphfYPHjxYzs7Ops1gkyZNzBfauHFjXXXVVYqLizNjBg0aVNzTAwAAAAAAAAAAAAAAALiE3XrrrWa9aNEivffee2cdb435/fffzfZtt91WNgJY9957rzp06KB9+/bl7W/atKk+/vhjOTk5mV6Jf/31lyndlZ2dbZ4fMWKEqZIFAAAAAAAAAAAAAAAAAP/WHXfcoRYtWpgiUkOGDDGBrBUrVpjMUi5re/ny5brlllvMGKv6lZVvuvvuu1VczsV9ARcXF1OS61QefPBBderUyTy/ZcsW84XUq1dP99xzjy6//PLinhoAAAAAAAAAAAAAAACXKAebfSmryvK1VTQODg6aMWOGOnbsqIiICLNtLVauKTAw0IyJiYlRZmam2baCWtWrV9esWbPMsaUewDqbBg0a6O23377QpwEAAAAAAAAAAAAAAABwiapTp47Wr1+vxx57zASrrJBVRkaGjh49WmicFbi6+eab9dFHHyk4OLhEzn3BAlhWtavY2FizHRAQIGfnC571AgAAAAAAAAAAAAAAAHCJCg4O1vTp07Vz507NmTPHBLKOHz9ungsKClLr1q3Vu3dv08GvJJVoKmrr1q365JNP9Ntvv5kvxEqS5SbHrAvv0aOHHn30UdM/EQAAAAAAAAAAAAAAACgW2vzhFOrXr2+Wi6VEAlg5OTl64YUX9OGHH5rt3OBVLuvxjh07TCjLCmg9+eSTeu+99+To6FgSpwdwHnKOlmyKE7BMTgwo7UtABbQ9sUppXwIqoPhU99K+BFRAOZn8XoOSlZPFnAIAVFzcm8KFkG3LKe1LQAWUZEsv7UtABbQry6W0LwEV0Ka0kNK+BFQwcelpkvaV9mUA5U6JBLDuvPNO/fjjj3nBqyZNmqhdu3aqUsX+h9Njx45p7dq12rx5s7Kzs01Q68iRI5oyZUpJnB4AAAAAAAAAAAAAAAAAymcAa/LkyZo6dappM9iiRQt99tlnatu27SnHWiGsxx57zPRX/Omnn8yx/fv3L+4lAAAAAAAAAAAAAAAA4FJjK+MtCMvytZVT4eHhedu1atU65f5/o+BrlUoAywpcWay+iStWrJCXl9dpx1rBrGXLlunyyy83LQk//fRTAlgAAAAAAAAAAAAAAAAAzio0NNSsrUJRWVlZRfb/Gye/1r/hWKyjJW3cuNFcyNChQ88YvspljbHG5h4LAAAAAAAAAAAAAAAAAGdjs9nyltPt/zdLcRW7AlZGRoZZN2/e/JyPyR2bmZlZ3NMDAAAAAAAAAAAAAAAAuARMmjTpvPZfLMUOYNWuXVvbtm1TfHz8OR+TkJCQdywAAAAAAAAAAAAAAABwvhxs9qWsKsvXVl7dd99957X/Yil2C8JbbrnFlOKaNm3aOR/z008/mbaF/fr1K+7pAQAAAAAAAAAAAAAAAKD8BrAGDx6ssLAwffrpp5o6deo5ha+ssaGhoXr++eeLe3oAAAAAAAAAAAAAAAAAl7CwsDCzTJgwoXwGsPz8/PTbb7+pdevWGjBggG666SbNnDlThw8fVmZmprKyssy2tc+qeHXHHXeYsYsWLTLHAgAAAAAAAAAAAAAAAOfNVg4WXBSHDh3SgQMH1LJlS5UG53Md6OTkdNYxVivCX375xSxnGrNu3TqTOrPaEFoBLQAAAAAAAAAAAAAAAAD4N6pWrWoKRHl4eKhMV8CyglNnW85l3MljAAAAAAAAAAAAAAAAAODfat++vVlv2bJFZboC1vDhwy/slQAAAAAAAAAAAAAAAADnyMFmX8qqsnxtFc3jjz+uadOm6YMPPtCAAQPk4uJyUc9PAAsAAAAAAAAAAAAAAABAudWtWzcNGzZMb7/9tvr06aOJEycqJCSk7AWwAAAAAAAAAAAAAAAAAJR9Q4cO1bvvvpv3ePHixeratesZj5k3b54+++wzrV27VlFRUapcubLatm2rRx55RL169VJZ9sYbb8jNzU3NmjXTr7/+qrCwMHXs2FHNmzdXQECAnJycznj8a6+9VqzzE8ACAAAAAAAAAAAAAAAAKogNGzbo/fffP+fxOTk5JmT1+eefF9p/+PBhs8ycOVMPPfSQPv30Uzk6OqosGjFihBwcHMy2tc7Oztby5cvNci6KG8Aqm/8qAAAAAAAAAAAAAAAAwJnYysFykeWGqbKyshQcHHxOx7z88st54atWrVrphx9+0Jo1a8zaemyxWvq98sorKstsNlvecvLjsy3FRQALAAAAAAAAAAAAAAAAqAA+/PBD00KwYcOGevDBB886fufOnRo7dqzZvvzyy7Vy5Ur179/ftB601itWrDD7LWPGjNHu3btVFuXk5BRrKS4CWAAAAAAAAAAAAAAAAEA5Fx4erldffdVsf/LJJ3J1dT3rMePGjTPVsizjx4+Xh4dHoec9PT3Nfos17oMPPrgg117eEcACAAAAAAAAAAAAAABA+VPa7QXLWAvCJ554QklJSbrvvvvUpUuXs463Wu/NmjXLbFsVszp06HDKcdb+Bg0amG1rfEm07KtoCGABAAAAAAAAAAAAAAAA5djUqVM1e/ZsBQYG5rUUPJt9+/bpyJEjZvtsga3c5w8fPqz9+/errAkNDdVll112Xi0SrYphYWFh5rjici72KwAAAAAAAAAAAAAAAAAoFXFxcRo0aJDZHj16tIKCgs7puK1bt+ZtWxWwzqTg89u2bTOBp7LkwIEDcnBwUEZGxjkfk5mZacJk1nHFRQALAAAAAAAAAAAAAAAA5Y6Dzb6UVQWvLSIi4qzja9as+a/OM2TIEB09elQdO3bUgw8+eM7HHTp06JzPHRISkrd98ODBf3WdFRkBLAAAAAAAAAAAAAAAAOACateu3VnH2GznnyZbvny5Jk6cKGdnZ33yySfnVc0pMTExb9vb2/uMY728vPK2k5KSVBHEx8ebtaenZ7Ffy7EErgcAAAAAAAAAAAAAAADARWS123vkkUdMcOvZZ59V06ZNz+v4tLS0vG1XV9czjnVzc8vbTk1NVUXw7bffmnXt2rWL/VpUwAIAAAAAAAAAAAAAAAAuoDVr1qhatWol+ppvvfWWtm/frlq1amn48OHnfby7u3uhMNeZpKen5217eHiotHXr1u2U+wcOHFioWtfpvpa9e/cqMjLSVAzr2bNnsa+HABYAAAAAAAAAAAAAAADKH6tj3/l37bt4ClybFb6qWbNmib20Fbx6++23zfb48ePPGjo6FR8fn3NuK5icnHzO7QovhiVLlpjwVMG2jdb22rVrz+t1wsLCNGzYsGJfDwEsAAAAAAAAAAAAAAAAoBz54IMPTNUqK0CUkpKiyZMnFxmzefPmvO3ff/9dR48eNdt9+/Y1ga2CgbBDhw6d8XwHDx7M2w4JCVFp69y5swlg5Vq6dKl53KZNmzOG0awxVuUvKxB35ZVXqn///v8qvHYyAlgAAAAAAAAAAAAAAABAOZLbEtBqpTdgwICzjh85cmTe9r59+0zoqHHjxoUqap1JwecbNWqkslABqyBHR0ez/vLLLwt9XRcLASwAAAAAAAAAAAAAAACUT2W5BWEZFxoaqurVq+vIkSOmgtSZLFu2zKxr1KihOnXqqKy59957TXWrgICAUjm/Pf4FAAAAAAAAAAAAAAAAoFywKj3ZbLYzLsOHD88bv3jx4rz9uQEqK7B044035lW4+uOPP055Lmt/bgUsa3zB1n9l6d9j0qRJprVgaSCABQAAAAAAAAAAAAAAAFyCnnnmGTk5OZntp556SqmpqYWetx5b+y3Ozs5mfHkVHR2tmJiYC/LaBLAAAAAAAAAAAAAAAABQ7jjYyv5S1tWvX18vvPCC2V63bp06duyoKVOmmG1rbT22ti3WuHr16qk8OXbsmB555BEFBQUpODhYlStXNm0K77//foWHh5fYeZxL7JUAAAAAAAAAAAAAAAAAlCtvvvmmIiMj9cUXX2j9+vXq379/kTEPPvigRo0apbLg0KFDateundl+9dVX9fjjj59y3N69e9W5c2dFRESY1ou54uPj9c033+iXX37RokWL1LJly2JfExWwAAAAAAAAAAAAAAAAgEuUo6OjPv/8c82ZM0c33nijqlevLldXV7O2Hs+dO1cTJ04048qC+fPn6+jRo6ad4O23337acVaQ7MiRI3nhq5CQELVv314+Pj5mX2xsrAYMGKCsrKxiX1PZ+JcBAAAAAAAAAAAAAAAAUGJGjBhhgkbW0rVr17OOv/766zVz5kwdPnxY6enpZm097tWrl8qS1atXm/XVV1+tSpUqnXLM7NmzTetEBwcHBQYGmtDWgQMHzLFWeGvgwIFm3M6dOzVt2rRiXxMBLAAAAAAAAAAAAAAAAJQ/tnKwoMRt2rTJBKuuueaa04757rvv8rbfe+899ezZM++xh4eHqejVrFkz83jWrFnFviYCWAAAAAAAAAAAAAAAAADKhf3795t1ixYtTjtmyZIlZu3n56c777yzyPNWgOuBBx4w1cE2btxY7GsigAUAAAAAAAAAAAAAAACgXEhISDDroKCg0wa0jh07ZkJWnTt3louLyynHtWrVyqyPHDlS7GtyLvYrAAAAAAAAAAAAAAAAABeZg82+lFVl+drKMwcHB7POyMg45fNr1qzJ27788stP+zr+/v5mnZycXOxrogIWAAAAAAAAAAAAAAAAgHKhUqVKZr1z585TPr9q1aq87bZt2572dRITE83a3d292NdEAAsAAAAAAAAAAAAAAABAudCiRQuznjZtWpHnbDabfv75Z7Pt7Oysjh07nvZ1Dhw4YNZVqlQp9jURwAIAAAAAAAAAAAAAAED5YysHC0rcDTfcYIJWs2bN0jfffFPoubFjx2r//v2mTWGPHj3k7e192tdZvXq1WTdo0KDY10QACwAAAAAAAAAAAAAAAEC5cM899ygkJMRs33///Wrfvr3uuusutW7dWi+++GLeuMGDB5/2NawA18yZM01Qq0OHDsW+JudivwIAAAAAAAAAAAAAAAAAXASenp6aPHmyrrvuOiUmJmrdunVmyQ1WWR544AF17979tK8xd+5cHT58OK9SVnFRAQsAAAAAAAAAAAAAAABAuXHFFVeY0NUtt9wid3d3E7yyltq1a5s2hJ999tkZjx85cqRZV61alQpYAAAAAAAAAAAAAAAAuERZxY7sBY/KprJ8bRVAvXr19OOPPyonJ0dRUVFydXVVQEDAOR27aNEis3Z2LpnoFAEsAAAAAAAAAAAAAAAAAOWSo6OjqlSpcl7HeHl5lew1lOirAQAAAAAAAAAAAAAAAMAlhApYAAAAAAAAAAAAAAAAKHccTixlVVm+NpQsKmABAAAAAAAAAAAAAAAAwL9EAOs8DR06VA4ODnnLkiVLSvuSAAAAAAAAAAAAAAAAAJQSWhCehw0bNuj9998v7csAAAAAAAAAAAAAAACA7cRSVpXla0OJIoB1jnJycvTII48oKytLwcHBioyMLO1LAi5p3/6UqBV/purvf9K1aXu6MjKkz8cF6/47fE85PiExR6+Pjdb0Ock6GpWlasHOurWvt157LlDeXkWLAebk2PTRpHj979sE7d6fKW9PB3Xv7KlRL1ZSWG2XQmOzs216d0KsPv8+QdGxOWrbyk3j3qisxg1ci7zuZ9/Ea/Brx7VxcS1dVqfw66DsstlsWrcwVgu+jVTE3jSlJGarUjVXNWrno74PV1VwLfcix0QeTNesT45o08oExUdlytPXSTXqeuiaO4PVvldg3riM9BxNfe+Q/pwfo4y0HDVs66N7X62tSlWLzp8p7x3S0mlRGjOvmbz8+BZe3oXP3a71by8+45ig1jXU8T83mO2DC3fqyJK9StgTrfTYVPMTu2cVH1VuG6K6A1rIo7J3oWOz07O07bM/dXjJHmWnZSmoZXU1G9RJHsGFx1m2fvqHuZ5u3w6Qq49bCX+lKA0Jf2xX7Ly1Stt7VDlpGXIO8JFHgxqqcm8PuVT2M2Pil25SwqqtStsfqez4ZNlkk2tlf3m1DFOlm66QS6XC31NzMrIU+e0iJazcJltGpjyb1FbVh66TS1DR773HvlmkuEUbVHfC/8nJ2+Oifd24cA4/N1rZ0XGnfM6tQaiqDHvknMbmCh72iNwbhJptW06OEuYsVdKytcpJSpFbWIgC7uwjlxpVihyXtGSNYr+fraqjBskluFKxvy4AAIB/g/tSuNisOfHJlwn6cnKiduzOlLOz1KKJm559zE99r/UqMn7N32l658M4rV6bpsTkHNWq4azbb/TW0Kf85eFReM6lpeXo1XdiNe2XJKWk2XRVB3d9MDJINasXvff0ytsx+mpyov5ZWlMB/k4X9GvGxZlXn3+VrO8mp2jX7iw5OUvNmrjoyce81atn0d/l9+zN0vvjE/XnmnQdOZqtAH9H1a/nokce8CoyPi3NppHvxGvW7DSlpuao4xVuevsNf9WoXnTejHw7Xt9NSdEfS6rI35/GPRVhXk37JlGzpybrwJ5MM6/qN3bVnQ/76qprPPPGZWXatPy3FC3/NVVbN6YrMiJbDg5Snbou6n2rt26801tOTg6FXjs9zaZPxsTq97kpSku1qVV7Nw0eEajgakXfrz5+N1azpybph0XV5evH+1VF+BvNP79Fafl3BxW5N0WpSVnyr+quum391f2hOgoKyX8PWvfLUW1cGKkjO5OUFJ0hm00KrO6uBh0DdfXAWvKvUvjvOZnp2Zo9bo82LohURmq26rYN0M0v1Tevf7LZH+zWn9MjNGx2B3n68bMUgKL46+05+vDDD7V27Vo1bNhQ/fr109tvv13alwRc0l4bHa0Dh7IUFOhoblpZ26eTnJKjq28+pA2bM3RNFw/17+et9ZvS9d7HcVq2OlVLZtSQu3vhX+weeyHK3Lhq0sBVTz3oZ36h/PGXRP26NEWrZtdUvbD8m1jjPovTK+/EqFd3T9UPc9F30xJ13YDD2rq8dqGbaBHHsvTiqGgNfz6Qm1zlzHfvHNS8ScfkH+yiNj385eHtpPDtKVo8NUqrZkdrxJRGCqmf/8vjppXx+uD/dpvtVlf7KzjETckJWQrfkarNqxIKBbC+f+egfvs+0uzzCXDWsunH9f5juzRyWmM5FvgF0zrfnM+P6v/GhhG+qiD86gWpwcDLT/nckSV7lLgvVsHtQvL2HV60W8mH4hXYpIrcKnmaT0zE7zquvT/9o4PztqvTR/3kG5o/t7Z8tFr7ZmxWjavrytXf3QSs/nxxnrr87xY5OOW/N8XvjtbuHzaqzWvdCV9VkJsRER/PUdzCv+VSNUC+nZrI0cNVWTFJStlyQJlR8fkBrOWblRERY4JZzgHeZk6l7TuqmNl/Ku73jarz9v1yrxWc99rHvvzVhLp8OzaRk6+nCVgdfGuyQsc8VGhOpe0/puiZq1Xj2X6EryoYBw93+fTsWGS/c1BAocfWmJyUtCLjcpKSlbToDzl6ecgttGbe/sQFKxQ/baHcmzeQS9UgJa/eoMixX6ja24Pl6J7/vpQdl6DYKfPkd1N3wlcAAKBUcV8KF/v3vAGPRmrGnGRdVsdZAwf4KD3Dpl8WpOiWgcc0blQl/d8D9t/zLDPmJuuux46Z4EK/671UNdhJq9am6a1xcVqyMlULplaXm1v+Paehb8Tok68SdGtfLwUFOumrKYm6+f6jWj2vRqHwwz9b0/X+x3H6akIw4asKMq8GPhqjX+amKbSOk+4e4Gnm1bwFabprYIxGj/LTwwPzP8S37u8M3XjbcWVm2XRdT3f17e2hqOM5mj0vVXcNTNfQ53w0dHB+CPW1kfEm3HVTXw9VCnTU91NSdNfAaC2aW7nQvNqyNVPjP0nSp+MDCF9VkHn1yhPHtXheimrUdlbfO7yVmWHTsl9TNOThKA1+PUC33WefJ4cOZOmlx4/L08tBl1/prqt6eCopMUcrFqVqzKsxWrUkVWMmVpaDlco6YfxbsZr+TaK69/aUX6CT5vyYpBceitIXP1ctNK92b8vQd58laMS4IMJXFcSsd3dryVfh8q3sqqbdK8vd21lHdiTqj5+O6O+5x/TM95erWj37e9b6eccUdSBFdZr7yreymwlgHd6eqGXfHNSamRF6+ps2eWPNa4/ZrZU/HFLL64LlFeCqNTOOaOIT/2jw1LaF/kZjne/3SeG6Z3QTwlcATou/4J6D8PBwvfrqq2b7k08+0eLFZ65WAeDC++y9YNULdVHtEBeNHh+rl96KPu3YMf+NNTe5hjzpr7dfDsrbP+zN43p3Qpy5UfXi0/mhhcUrU8xNrs4d3LVgSg25utp/wBrQz1t97o7QUy9Faf7kGnnjJ36XoO6dPTT72+rmcb/rvdW132HN/jVZ/W/yyRv35LAohdVy0bOP+pf4vwcunLioTM3/6piCarjq7Z+byNMn/1vnvElH9e3b9nDWI2/bq3gcP5Ku/zy1RwFVXDTsywYKql440JKdZSv0aaAlP0Wpy61BevhN+/GXtfDSJ0P2ac+mZNVraf8lICfbpv+9vF8tOvupw/X5cxXlP4BlLSfLyczWvumbTaAlpFeDvP1t3+gpJ7eiP7odmL1NG0Yv0Y4v1qrtyGvNPluOzeyv3buRWg7tavYFNArW32/+rtjtkQpsUtU+LjtHG95doiodQlSjW90L+NXiYomZvcaErwJ6XW6qUxUMRuX+N89Vc8htcnQtOqdif12viP/+oqjJSxUy5Db7cTk2xf22Xv49Wqn6E33NPo96NXTkPzOVuvuIPBvUzHv9I//9Rd6t68qvU5ML/NXiYnP0dJd/vx5nHed7badT7k+Yt9ysPa9oKQfX/BtVSUvXyr1JXQUPvt889mjTRJFvf6bUDdvl1aFF3riYb36Wc3CgfE7z+gAAABcL96VwMVmV06zw1ZVt3TRvcrW8ClYjX8zWFb0Oa+jIGF1/jafqhLiYSkNPDo0yVWSWzqqu1s3d8kIRz7wcrY+/TNB/PovXkKf88+5NTZqcaEJdn4ytbPa1be2mB56O0roN6Wrfxj2v0tpjzx/XtVd76rYbilbWRvnz85w0E75q39ZV038IkoeH/b3m1Rez1a1XlAlQXdvDXbVC7PcN3v0gQalpNn37RaCuvzb/w1ZDB/uoY/dIffjfJD3zhI8J91nz6tvJySbU9Z8x9g/stGnlqscHxervDZlq28Y1b14NeiFWPa52V78b8j/civLLCl5ZS/PL3fSfb4PzAsaPveCvgX0jNOHNWHXq5qlqIc7y9HbQ8yMDdf0tXvLwzL9/9XRKjp7of0wrF6WaSlfde9ur/Fnz6pcpSSbUNewd+4eymrR01RuDo7VtY4aatnbLm1dvvRitK7p6qEefohUCUf4kRKVr6TfhCqjuriEz2sujwN9orFDWzNG7tPjLcN35ZmOz7/4PmsrFrWjw7o9pRzT51W2a/999GjiuWd68+nPaEbW/pbr6v9HI7Kvd3FffvbhV4ZsTVKeFX97faCa/tl2NrqqkVr2KVmwHgFzEyc/BE088oaSkJN13333q0qVLaV8OAEk9Onuam1xnY91csG5aeXs56JVnCwdXrMfWfuv5gqwbV5bXh1TKu8ll6dXdS12v9NCvS1MVfigzb//Bw1lqc+JmhuXyFm55+3NNn5OkXxYm67P3KsvZuXDZXJRtUYfTZcuR6rf2LhS+yq1uZUmIyZ8Psz6JUGpSth54vU6R8JXFqcB//8TYLGWm2xTaNP8XwbAT29FHMvL2WQGwI3tTdf+I2iX81aEsili+TxnxaapyZW25B+bffDpV+MpS/erLzDr5cP57WUZ8qnIysuXXwH7z1OLf0F7JKPVYUt6+PT9uUtKBWDUf3PmCfC24uHLSMxU1ZalcqgScMnxlKbjvVOEri29H+82KzIjYvH3ZCSmyZWTJ/bJqefs86tq3rapauazqWRmHjqvao9eX0FeFiiRp+Tqz9u7cttD+7Jh4udbO/yOi64nqWNkx+W0MU9ZtVur6bao08GY5OPHpVQAAULq4L4WLyap0ZRn6dECh9oFBlZz09CN+Sk+3mbaAltXr0hUVnaMbrvPKC19ZrAoyrw+1B2H+902CmZuW4zE5plVcwbFtTsyh8AJzaPzEeO3YnaHxbxf9IBnKp3kLUs168FM+eeErS6VAJz3+sLfS02XaAuY6cMDeHs4KSxUUUtNZjRu6mHBWcrL9Q1/RZl5JLZvlV+tr2cL+nnmowLz6ZGKSdu7O0pi3CIZWFFY7Qct9T/gVqu7oH+ik/g/6mpa9s3+035sMruqsW+7xKRS+sliPrbGW9X+m5+2Pi8lRRrpNDZrmz6tGJ967jh7Jn1dTJyWa1ocvjOSDzBVFzJE08zeasFZ+hcJXliZd7N+XkmPzfzY6VfjK0vJa+/3x4+H5723WcZnpOQppnB9aD2lin3+xR/Kruy/95qCO7U3Wba/mf2AaZYxNcijDi3V9uDQQwDqLqVOnavbs2QoMDNTYsWNL+3IAnKddezNNmfYr23rI66Qf5K3H1v69B7J08HD+D2dLV6XKy9NBHdsV7e/cs6s9DLF0tf0XCUtIDWdTOj7X3ye2rf2W+IRsPf1ylJ55xF+tmxd9TZRtVWu7y9nFQTv/TlJKUnah59Yvtv9huMkV9h/IrZtXa+bHyNvf2ezbtzlZc784qjmfR2jzynjzaYqCrJaDLm4OOrA1/wf+/Se2K1W3/yIZdShdP314WHc8V1OVqub/comKy6pcZandx/6Jm7M5tvqAWfsUaD/o6uchR1cn06IwV9zOKLP2qGL/pGpKRIK2f7FGjR7tII9gPr1aESRv2KucpDT5tG8gW06OElZv0/FpKxQzf51pNXiuktbtMmu3WvkBPqvloIOrs9L2Hs3bl7ud29Iw41icIn9YouB7usslKL/tACoOW1a2kpb/pfhfFivxt1VK3xN+zsem7zqgrCORcg2tIdda+UE+i1OgnzLCj+Q9zjxw+MT+E5/KT0lT7Lc/m9aGrnXyg1oAAABlHfelUBKORdrvR9WpVfRDNHVOVCdastL+R+KjUVmF9hfk7+ekAH9H0zLTmncWq42mu7uDNmzOn0O586nWiTm0/2CmXh8Tq1HDAlWzOk1VKopjUfawVK1aRYMKtU/sW74yf140bOBs2nj9trhwu3krULV1e6aaNnZRYKD9OKvloLu79M/m/A+Y/rPJ/j5X88S8Cj+YpXfGJuq1Yb6qUZ0P2VQU0VH296vqp3gPyt331+rCc+hUnE9knAt+/so/0FGubg7auSV/Xu048d5V9cR7U8TBLP3v/Tg9PiRAwdV4v6ooKtf2lJOLg/auj1daUuG2z1uW2u9/1+tgDxmfSe7Ygu0HvQJc5OLmqEPb7EFmy6Gt9m2r4pYl+nCq5o3fqz7PXib/qvwsBeDM+O5zBnFxcRo0aJDZHj16tIKC+HQHUN7s2mf/xa5e2Kk/lWjtX7jEPi6khouSU3IUcSxbTRu6FuoZnqtuqP11dp94XcuDd/pq6Mho9b3niOqHuei7aUmqXtVJfa6xVzIa8ka0PNwd9PoLfOKiPLJCUv2fr6nv3jmoF67bpDbd/eXh7aTw7Sna8keietwZrJ5320vORh1MV1JctsKaeurzV/fr9yn2wEuuOo09NfiTenlBKkdHB3W5pbIW/RCp1ORs+fg7a9mM42bcZc3s8+fz1/arVkNPXXOX/dMZqNhSjiYq6q/Dcg/2UpX2Iaccc/j33UrcH6vstCwl7otR5NqD8qzmo4YP5leUcXB0UK3eDbV/5hZlpWTI1ddd4fN2mJaHAScqYW0Ys0x+lwUptB9t4iqK1D1H8v777x30qTKOFGiD4uigwL7tVXVgzyLHxa/YovSDUbKlZ5p10vo9cqnir8p32ttX5r6mf/eWip2/TjmpGXLy8VD87xvlHlZVHnXtrU4iPp4t9zpVTPtDVEw58YmK+fynQvusalWVHu8vl2B7+f/TSVpmr37ldVL1q9yKWHFT5ynygy/lUjVIyas2yMnfVx4tG5rnY6fMlYOLi/xuvqZEvx4AAIALjftSKAlWmMWyPzxLjeoV/nDe/oNZeWE/S9CJAEzu/oLiE3IUG5eTN/6yOi7m3tT9d/jo068TlJiUo0oBTvp6aqJaNnXV5S3tlWWeGHJczRu76rH7+aBNRZxX4eHZalCv8HvUgXB7iGbP3vx59PJQX61Zl6H7H4nRdT3dVTfMWVHHczR7XqpCazvr84/zww/WvLrrDi998XWykpJtCgxw1A9TU9S8qYtat7Sf69mhcWrS2EUP3keLuIrEP8A+r44czFKduoXnlbXPEl7ge9jpzJ5qr5LVvrNHoXnV53Yvzfg2SSnJOfILcNLcn5JUv4mrGrWwvzeOfiladRu56pZ7+LBpReLl76K+g+tq1ru79Fbv1WrarbLcvZ11ZEeidv0Rq04DauiqO+3V1AtaP++Yju5JVmZato7uTtb2lTGqVNNdvZ4KKzSv2t9cTSsnH1Z6Sra8/Fy0ZmaEajbyUa2m9u97U0dsV42G3uo0oOg5AOBkBLDOYMiQITp69Kg6duyoBx98sMRe99ChQ2d8PiIiosTOBVzqrBsLFj+fUxf88/V2LDTurONP7M8dZ3n2UX9T6vuLHxK04s80tW3ppnEjK8vby9F8atEqJT9/cnW5uDjo+RHH9eWUBKWk2nRtV099OraygoN4Ky7reg2sqoAqrvrfy/u06If8UFWDNt66sm9gXlvB+Bj7L5H7t6XoyL40PfJOqC7v7q+UxGzTmnDx1Cj956ndeuNHe3svy10vhpgKW3/Oi1FGeo6aXumre1+tLUcnBy2fcVzb/kzUm7OaKD0lR1++cUBrFthbgrW7NkD3D68td08+IVaRhM/dLuXYVKtXw1O2j7Mc/n2PIpbuzXvs37CyLh9xjbyqF74R2vSJK+Xo7Kgji/cqOz1LwW1rqtmgTuZ1w+fvUPSGw+ry+W3KTs3SPx8s15Gle8xx1btcpuaDr5Kzx9nbaaBsyY63V9CL/vkP0yowdMyDcqtZWal7IxTx8RzFzPpDrlUDFXhSQCph5VYlrrZXXrO4162ums/dLNcqhT85VuX+a0zrt4RVW5WTkSmvlmF5rQ7jFm9UyuYDCvvgEdnSMnXks3lKWL3VHOd7RWNVe7SXHN2p4leeeV/VRm71Q+VSs4oc3FyVdfS4EhasUMqq9YocPVHVRj0jR4+irXctOWnpSln7jxxcXeTVoUWR532u6yRbVpYJaaXv3G9CXYF39ZWju5vStu9V8rJ1Cn7+ATPXYn+Yo+QVf5mWmx7N6itwYD85+XJjFQDOF/emgIuD+1IoCdd289TUWckaMyFOV3d0z2vrFR2TrfH/s7eEj0uwB2aubOsuXx8H/Tw/2VSyatUs/2f018fkV0aOi8+fQ6NfC5SLizRtdrJpI9e9s4c+GBlkQoDf/JhoKq6tWVhTySk2DXo5StNnJ5vjbu7jpQ/fCipS3Q3lg9VKcPqsVI37b6Ku6uhmKqFZYmKyTWvAk99r6td10cJfKmvgozGaPTe/gpEVrrrzDk+F1in8XvLGq35ydpZ+npNq5lXXzm56+w1/M68m/5iilavTtWRBsJlXQ1+OM+MsN/T20Ltv+TGvyqkOXT306y8p+ubjeLW5wl1uJ+ZVfGy2pnxhb7GbVGBencrM7xO1ekma2lzpriuvzg9gWZ56OcC00v19borS02xq28ldg0cEmnk1d1qS/v4zTV/NqabUFJveey1ai+fZ75Vd3ctTz48MLNLuEOVH1/tqyS/YTZNf26ZVU+yV0y1hrf3UundVOTkX/W+7YcExbVyY//eckKY+um9sU1WqWXhe3fBCPXMffeOCSBPWanBloG5+qb75G82aWRHavSZWL0xrp4yUbP305k4zztLi2mDd+koDufE3mrKhrLf5K8vXhhLFb1ensXz5ck2cOFHOzs765JNPTI/0khIScuqKFgDKJ+uH+5efDTRLQWlpOXpsSKTuuc1HPTp76p0PY/TRl/F67/Ug1azmrKdfitLAQZGa8529cgjKrukTDmvmxxG69eka6nhjJXn5OOnAthR9+1a43rxnhwaNv0xtugfIdqLFYE62dOugGupys71yopefsx4aVUfhO1K0Z2OydqxLVIPL7T3FXd0ddc/LtcxSUEJMpr59+6BueLSaatb1MBW1/loUpwdH1pH1LWnSiANy83DUwBF1SuFfBBeCNX9MAMtBqnW9verLqbQbda1ZZyamK27XcW37359a8tBPZn/lNvmfwnFyc1azpzuZpaD02FRtmbBK9e5uLd/QQG0Ys1RHV+xTyxe6yJpc/7y3TE7uzmrxXOcL+NXiQsh9D3JwdlLIsDvkEmh/n/FqUls1X7hVe5/9VNGzVhcJYIUMvc2ss5PSlLYvQpHfLtbe5/6nkBdvl1fz0Lxxjm4uqvrQtWYpKCs+Wce+WKhKt3SUW0hlHflothLX7FD1x/uYORXx6VxzbLXHrr8I/wq4UPxu6lHosWvt6gp65HZZxdutEFbS0jXyve6qUx6b8uc/sqVlyKtjazl6FC3V7uDoKL8bupmlIFtGpmK+nCGvK1vJvUldxc9eosRFfyjgzt5yCvAzbQmjJ/6o4MEDS/irBYCKj3tTQMXBfamKb0A/b30zNdG0GWzd/ZBpRZmZZdPP81MUXNkpr4KHxQrejRleSY8+f1ydbziim3t7qWplJ61el2baUzao66IduzPlWODv1B4ejnrvjSCzFBQVna0hI6I15El/Na7vqv8bEqVfFqToo3crm3tTT790XJ4eMRr/Np1DyqNb+3noh6nJWr4qQ526H1P3q92VmWnT3AVpqhxknyAF58lf6zN0z4PRatTQRYvnV1a9us6KjMzR/yYladhr8fpjTYYmfZr/PuTh4WACV9ZS0PHobL3yeryeedJHDeu76NkhsZq7MFUfvOtv5tXzL8WZY8e+Xfg4lA89b/QyVan+Wp2uu687og5dPJSVadOyhSkKDLLer7LP+PfWFYtS9N7wGFWt4aQR44pW2rYCqM8ODzRLQbHR2fpwVKzufdxPofVc9c6waC3/NVVD365k3WrV2Fdj5O4RqxdGnbl6N8qu+R/t1a+f7DfVqy7vW1UePs46vD1JM0bv1IT7/9YD45qZylgFDRzX3KxTEjJ1eFui5vxnr8betlYP/KeZ6nfIn0Ou7k66eVh9sxSUFJOhWaN3qcfDdVS1rremDN+mzb9H6Y7XG5p7+D+N3GH+vnPba6e/lw/g0kPU9xQyMjL0yCOPyGaz6dlnn1XTpk1L+5IA/Et+vic+GZh46k9VJCTlFBp31vEn9ueOO5OR78eaT5O9N8J+E+LDifG651YfPX6fn/r29NKoYZU0//cU7did37McZc/mlfGa9uER9bwr2IShrPaB7l5OJkD13Kf1TfUrqz2hxdMnP9fcplvRmwStT+zbu9n+ScEz+XpUuPyCnHXjY9WUmpStpdOOq8+DVdWxbyVd2aeSej9YVYt/PK60ZPsnHFH+Ra07pNRjSQpqXaNINatTcfFxU+XWNXTF2D5ycnXW32/+rpyss8+HTR+ukFuAh+rf01qZKRkKn7NddQe0VM1r6qtmj3q6bEBLHZi9TVkpZy8HjrLFycv+yWarJWBu+CqXe+1gU9Eq82isCVqd8nhvd3k1C1Wt4XeZwNTh/8yU7Rzm1NGJC+Ts763Kt16l7NR0xS3aoEo3XSG/Ls3k17mp2Y797W/TuhAVj8/V7cw6fdeB045JWn6i/WCXou0HzyT+59+Vk5Im/wG9zePEhSvl1bGVfLp1kGerRvK/pafS/tmpzIjCLX8BAADKCu5LoSRY1V5++baaXn0uwAQXJn6XoJlzk9X3Wk9N/qyKGRNcKb/6xsA7ffXzt1XVoY2bflmQrE++SjAV0BZMqW7aDprxJghxZoNfPW4CXi8+HWDaE345OVGDH/fTgJu91b+ft559zE9ffJ+gpOQzV7NB2Z1XU78N0tDnfEyA76vvkjV7Xpp69XTXl5/ZQypBJ+aVFcx66P9iTEDqm88D1aKZqzw9HFWntrPeHOGv3te5a9bsVP2xNv2s57XCWpUrO2rwUz5mXn03JUVPPeajW/t56pabPPXkoz765gerdSHzqrzOq/e/rKKHnvEzAb5ZPyRq6YIUXXWNp9762B6OCTwR8DvZqsWpevnxKBPUmvBDFQUFn3sNkQ9ejzHH3feEn5KTcjT7xyTd+aivrr3Ry4TC7nzEVz9PsbcuRPmzY1WM5k/Yp0531TRhKP+q7nLzclZYG389/N8W5m80M9/dddrjPX1dVK99oB77rKVc3Rz13bCtys48+1yY/vZO+VRy1TWP1FFacpb+nBGhbgNrq02fqmrTu6quvr+W/vjpiNKTi7b9BXDpogLWKbz11lvavn27atWqpeHDh5f46x88aP9D/ZnKvLdrZ/9DBoDiqRdqv6mwa++pgwS5+3PHWaWNq1Vx0r7wTGVn28ynCAvafaI/ed0T40/nn63pGvtxrL4aX0WBAU6KT8jWsahstWyaX/a71Ynt7bsz1KAubZnKqg3L7KXcG3coGojxr+yi6mHu2r81xQShgmu5ydHJXgHL07fot1hPH/tNi4y0M/9wv2FJnP6YG6PXvm8oZ1dHHd6Touwsm2o38swbU6eRp7IzbToWnl5oP8ovK/Rkqd2n0Xkd5+LlqoAmVXR0+T4lH0qQT53CbeMKOrb6gGlheNWEm+To4qTEA//P3n3AR1Gnfxz/JtlNNr2HVDqh9yJFUBARBMTe69nvTj31bKdn7+Wvd569YUexIoqgdOlNlN4hEEJ629TN7v81sySbJQG9XIAkft6v19zOzs7uzsrvJrvPPL/nyZOryqnwTp7ZqhGdYuRyOGVPL1B4R2axNif+Se4AqW9w3QpDtbcb7QP9VP8+Br+gAAWmJqlo2WZV7M81q1odTtHKrSpctF5tH79SPlY/Ve7NkqqcsrWLr9nHXHc4VZGR67UdLYNvSLB56yqv/8Jd5b4Dqti2R5aEWNlSf3/Vxoq0/SqcsUDR154vv5AgMxHLWVgs/9YJXlW4zPfYnyVrwuHHKQCgLmJTwLFBXAqNJSDAx0zAMpbajDaThn69vf8Nx44KMpdDXXVzhZkUUbs1YX1mzC7R1Gl2zf0yUf7+Ptq4tUIOh9S7u+d5xniqrJS276r02o7mNa7uui3MXGr7abE7kapP74PnsG0O7d5TpQmn28zEq0OdODRA335fpl/XVWrwwMOPhR9ml+nLaaX69osYc1xt2eowx1XP7p5zWq8eVnNc7dpVpR7dqSHRHPkH+Ojqv0WYS22rl7gnBHap5/yzaE6J/nFDlsKj3MlXSa2P/Hfu0MSt2dNL9MrUVrL6+2jXtkpVOaTUbp7zYmp3fzkqpX27HepUazuah40Lc8zbToPqxr3DYgPUql2w9m4sMhOhjMSsw7GFWNSmd7h+nZ2lrD2liu/gjmnVZ8P8bK2ZcUA3v9/fvEZzYIddTodLSV1CavZJ7hpqXrfJTitVUhfvybA4TmjzhyaABKxDGIlXTzzxhLn+4osvKjj48CffhkpO9rQHAnB0dWpvVWK8nxavKJW9xOnVO964b2xv19qilCTPF/oRQwL1yVfFWrS8zFyvbdY8d8/wEYO9t9dmBMiuuz3TLAd+4ZneX7rKyz1//csrDvTvO+MAAQAASURBVLaKasQWp2h8RpJTdUvA+hjbfXwlP6uPrP6+6tQ3RJtXFmvfttKaNoPV9m1z/8iMTT58IMJI5Hr7wd0afVGcUvt5P7/y4Jipvc7waRkqCsrMNoDWsAAljGj/Xz+/LNtdVc2nnl731YyKVmufW6B2Z3ZXVE/vJJiqyqp61hlczU1wD3dyS8VeoymcN6OSlZFM5WOzyhL+299vK3OLatoZHo5R0Srjte8UOXaAgrp4tzGqXTmrZp0TVotUvsN9Ad8SU3/yZ/ECd/WrkBHerS+PxOV0KvftL2Tr0UnBg3v/jrHVkCMHgD82YlPAsUFcCkfbx18Um7fnT/JcED6cxcvLtCvNoXGnBB6xippReeimu7N1/eVhGjLQe/JO9bipvc4Qanmmfuk+15x9hjuJr+JgfDQnp/5JpdkHtxtJVUcaV7ffk68/XR6sEw5J0mJc/THM/Nodvxw9Maje5KuwCD+99HErpRys1Pd7GBWtnrkvR2ddGqpe/b3PVxW1/uZVrzOumqfqalXFh7lGU5xXcfAazW8nbRZkuhNMjapZh2Mkck19eLOGXZisdn29EwkdtSpnVa8zrgDURvr4IZ5//nmzBWH79u1VUlKiKVOm1FnWrVtXs/+cOXNqttvtv91SCsCxZQSRrr44TMV2lx59PtfrMeO+sf2aS7xn+Fx7qfv+A0/nqKLWj78Zs+2at7hUp54UqDYph/8R8O838s1ZYS8/6anEEB7mZ85g/G6O3ev1DF07/f4fFDj2Uvu5A1gz3jmgkiLvUrI/fpyp3IxKdeoTYiZfGUZfHGfefv5iuiorPF/G07eXauGX2bIF+6r38PDDvt8n/7dXLqdLF9zuuSDSqnWAmeD18/z8mm3GusXqY1bdQvOXNnOznJVOpYxJlZ9/3YQXo1Vg0Z68ep+7+9uNyt+YqeDkcIUkH35sbXh9mdleuev1J9RsC04MN5O2MpfsqdlmrPtafRWc9NttENG0+CdEKbhPezPRKu+H1V6PZX++SE57mcJO6CIfP1+zVWD5vrqJWoa8H9eobGu6/BOjzNc8nMwP5pjnq7jLRnmOIT5KsviqeJWn7LexbiRy+ccfvjobmrbK9Ew566lwZWzP//R7cz1oSJ86jxsJUvbFayQ/PwUP6/e7389oNVi5P1NRl59Zs803yCa/iFCV/bK5ZlvpWve6NcH9txcAAKCpIS6FxlLdfrK2z6cXm20BB/QJ0FmnBx9x3/QMh67/e5YsFunBOw7/O8/wzydy5XS69Og/PPsZrQutVun72e7EHIOx7u/vfgzNU31jxWgl+OGUEvXrY9XE090JLV07WxUa6qNlKyo0Z757gmm1vfscevcDu5mAMGzw4SsLPfpkoZxO6Z/3eM55bdv6mePqhzme1zTWjXFlPIbmyV7PuJrznV3TPy1W197+OnmsJwFrydxSM/kqNNxd+SrlNyo8HurVZ/LNcXXjnZ4kmaQ2Flms0pJ5pZ73mVcqq7/7MTQ/7fq5Y97z3t2j0kOu0Syaslf5GeVq2yfcrFRltAo8sLP+6/VLP0/Xnl8LFdsmULFtDt9VZPoL2804+oRbO9Rsi0kJNJO2NixwV+MyGOvGdZvoFDqUAPDgL80hysvdma87duzQRRdd9Jv7P/LIIzXrO3fuPCoVswDU9eaHBeZMQMO6je4Lgm9/WFhTdnvYIJuuucT9peyOv0Rq2ky7nv5Pvtb8Wq5+PQO0+tdy/TC/VAP7BOiWa70z2EcOCzKDY299VKgBY9J0+ugg7T9QpU+nFSkq0lf/fuzwLW52pVXqgWdy9fg/or1mLxpuviZC9zyWowmXpis5waJ3phRq/KlB6tSekrdN2QnjovTjx1natKJIt4/5Vf1GRSg4zKJd6+1av7RI/jZfXXqPp/LLkPFRWjErT8u/z9M9E9er1/AwlRRVmdsqyp268en2Cg6v/8/v1p+L9cOHmbrt5U4KDPEEGWzBfjr53BjN/jirpn3h4m9yNebSONmCCEa0BLu/3XTE9oOVBWWac+kURXSJU0jrCAXGBKuyuFx5GzNVsCVblmB/9bvXkwRzqNz1Gdr55Tqd8PhYWYM85xxLkFVtxnfRrq83qKrc/eN17w9b1e7sHrIEEkBtjhKuP107735H+1+abrYQNNoSlu3IUMmvu2SNDVerK08196sqLNX2v74sW8dEBSTFyBIdKmdxmUq3pqtsx375BgUo8eZJh32fks17lTtjhVLuPl9+gZ5EUN9Af0WO7qu871fJWe6elVa4YJ0iTx8oXxt/75or+7JfVDTzJwV0bitLdKR8AvzlyMhWqZEMVVWlsAkny9a5XZ3nla7ZKGeRXYH9u8sv7Ldn5BscWXkq+PJHRZx7mizR3t/RQk8dpvyp3yvz/ybLEhWu4oUrZevdRdZ42qUCAIBji7gUjrVh4/cpJdGiLp2sZtu4lT+Xa/7iMrVvY9HHr8d5tav8z1sF+ujzYnMcxsb4aW+6Q9/MtKuk1KXXnotV316Hn8y3bFWZXplcqM/ebqXQEM/8/ZBgX111Uahef6/IfB3DlC+L9eerwrwqu6F5OXVClpIS/ZTaySJbgI9Wr6nQT0sq1LaNn955LapmXBlj7qH7wnXbXfk6/9IcnTbapk4dLcrMrNL0GWVmMulfrg9Rxw71x5JWrKrQm5Pt+uCtqDrj6tILg/XO+3aVHhxXn31ZqmuvCmZcNWNXn7lfrRItatvBarYj3LC2XKuXliuptUWPvRRbM66MVoF3X5+pigqp3+AA/TCtbtJMQrJF48+rP56wbnW5Pn+vSE++HqvgWuMqKNhXE88P0ZcfFqus1B1Ln/V1ic69IlSBjKtmqc9prbRoyj5tX5mvx05frB4jYxUYatHeDUXauixPVpuvzryzk7mvPb9ST05YqpQeYYprF6TwuACVFjq0Z12hub8txE8XP9H9sO+1a22Bfvp4r65+sZdstdoZGq0NTzgnUYs/2afKUndF9lXfHtDwi5MVwDUaALWQgAWgWTKCXO99WuS9bUWZuVSrDnQZP9bmfpGkh57N1RffumcLJsRZdNsNEbr/9igF1tO3/tVnYtWzq7/e+KBQ/36zQCFBPjpzXIgevTv6iLO6brgj03zen6+qW4Xm9hsjlJNXpclTCjVvkUsTxwTr1aep2NDU+fr56O53Us0KWMtm5GrJ9Fw5Kl0Ki7Zo2BnRmnRDgpI6BnrNbv3r/3XQrL4HNO+zbM2ZkmXOvDBaExr7dh1Uf1Uho1ztm/ft0qDTIs0kr0NdfFeK+b5GYpfBSMi66E7vll9onvI2HFDRjlxFdI1TWIfoevfxjwhU5yv6K3tNurJW7FVFYZlZpSooPlQdzu+lDhf0VmBc/cEIp6NKPz89X4knt1f8MHeLutq6/2WonA6n0uftMO+3Ht9F3f88pJE/JY4Vo2JV+2evUebH82Rfs13FP2+XJSLETICKPX+ELBHuyQKW8CDFnD9CJet2yb52hxxFJe4qVXERijrjBEWfMUTWmPrPV0ZVIyPBK2xIV4UO6lzncSPJy1VZpcIlG837EaP7qtUVo4/yJ8fRZOvaXo79marYna7yLbvkqqiUb0iwAnt1VsgpJyiwR2q9zyteuMK8DTlp4O9+r9x3v5Q1uZVCThlc57HQccNVVVwi+0+rVL5phwL7dFXUlWf9D58MAACgYYhL4Vg774xgfTWjRMtWl6nSIbVNseiev0WY/65hod5jaMgAmxYuKdO3P5Qor6BK0ZF+GjsqSH//S4T69jx88lVlpUs33JGls8cHa8KYuhPNn7o/2kyU+OJbd9tDIyHrifuOXE0LTdtZZwRq+oxSrVxdIYfDpdYpFt1+S6huujGkzri68tJgtWntp9feLNbylRWaNbtMwcE+6tXTqisuCdZ5Zwcddlz97c48nTE+UGPH1G2f+vD9YWaLw2nfuhNYL70oSA/ee/gK72j6Rk8I1ryZJVq3plyOSikxxaIrbwrXpdeFKbjWuMrNqjLPKYYfvvFU16ut7wkB9SZgGXHyJ+7J0chxQRo+uu7Yu+neSHPszZ3hft2JF4ToL/fUjbmj+VyjufHNvmYFrJ+/z9TqbzPMMRAa7a8BE+M1+rq2iu/g/rsVEumvMTe007YVedqyONdMyDJaE0Yl2XTSFSkaeUVrRcR7t6us3erwk/s3qveYODPJ61CT7uhk7rN2VqZ5f/A5iZr4945H+dPj9/JxuZemqikfGxqXj8uooYf/yoMPPqiHHnrIXJ87d65OPvnkRn39vXv3KiXFfVE9LS1NycmeNlTA/8qZ4c4CBxrTlCLaSqHxfXpgwPE+BLRAW3MOP1scaKji/LpBZOB/4cgtUPptT5rr/CYEcDwQm8LRRGwKR0OVq27LK+B/Vexyd0wBGtPmSmpjoPEtKyERCI0rP6NMD45a1KR/E9b+3dr1yvvlH9J0Ey0rivO1cfLDTfq/JxoHtRYBAAAAAAAAAAAAAAAAoIFIswYAAAAAAAAAAAAAAEDzY/R8a8p935rysaFRUQELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCASsBrgwQcflMvlMpeTTz75eB8OAAAAAAAAAAAAAADAH46Pq+kv+GMgAQsAAAAAAAAAAAAAAAAAGogELAAAAAAAAAAAAAAAAABoIBKwAAAAAAAAAAAAAAAAAKCBLA19IgAAAAAAAAAAAAAAAHDcuA4uTVVTPjY0KipgAQAAAAAAAAAAAAAAAEADkYAFAAAAAAAAAAAAAAAAAA1EC0IAAAAAAAAAAAAAAAA0Oz4u99JUNeVjQ+OiAhYAAAAAAAAAAAAAAAAANBAJWAAAAAAAAAAAAAAAAADQQLQgBAAAAAAAAAAAAAAAQPNjtPhrym3+mvKxoVFRAQsAAAAAAAAAAAAAAAAAGogELAAAAAAAAAAAAAAAAABoIBKwAAAAAAAAAAAAAAAAAKCBLA19IgAAAAAAAAAAAAAAAHDcuA4uTVVTPjY0KipgAQAAAAAAAAAAAAAAAEADkYAFAAAAAAAAAAAAAAAAAA1EC0IAAAAAAAAAAAAAAAA0Oz4u99JUNeVjQ+OiAhYAAAAAAAAAAAAAAAAANBAJWAAAAAAAAAAAAAAAAADQQLQgBAAAAAAAAAAAAAAAQPNEmz80AVTAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBLQ58IAAAAAAAAAAAAAAAAHC8+Lpe5NFVN+djQuKiABQAAAAAAAAAAAAAAAAANRAIWAAAAAAAAAAAAAAAAADQQLQgBAAAAAAAAAAAAAADQ/Bgd/ppyl7+mfGxoVFTAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABqIFoQAAAAAAAAAAAAAAABodnxc7qWpasrHhsZFBSwAAAAAAAAAAAAAAAAAaCASsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGsjT0iQAAAAAAAAAAAAAAAMBx4zq4NFVN+djQqKiABQAAAAAAAAAAAAAAAAANRAIWAAAAAAAAAAAAAAAAADQQLQgBAAAAAAAAAAAAAADQ7Pi43EtT1ZSPDY2LClgAAAAAAAAAAAAAAAAA0EAkYAEAAAAAAAAAAAAAAABAA9GCEAAAAAAAAAAAAAAAAM2P0eKvKbf5a8rHhkZFBSwAAAAAAAAAAAAAAAAAaCASsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGsjT0iQAAAAAAAAAAAAAAAMDx4uNyL01VUz42NC4qYAEAAAAAAAAAAAAAAABAA5GABQAAAAAAAAAAAAAAAAANRAtCAAAAAAAAAAAAAAAAND9Gi7+m3OavKR8bGhUVsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGogVhE+fMHC6nhX8mNJ6v7CHH+xDQAi0u6ni8DwEtUFGl7XgfAlqgqirmH+AocPoc7yNAS8OYAtCEEJtCYyt2lh3vQ0ALlOt0HO9DQAuUW2U93oeAFmhTecLxPgS0QL8UJx/vQ0ALY7fb1dz40OYPTQBXoAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABrI0tAnAgAAAAAAAAAAAAAAAMeNy+VemqqmfGxoVFTAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABqIFoQAAAAAAAAAAAAAAABodnxc7qWpasrHhsZFBSwAAAAAAAAAAAAAAAAAaCASsAAAAAAAAAAAAAAAAACggWhBCAAAAAAAAAAAAAAAgObHaPHXlNv8NeVjQ6OiAhYAAAAAAAAAAAAAAAAANBAJWAAAAAAAAAAAAAAAAADQQCRgAQAAAAAAAAAAAAAAAEADWRr6RAAAAAAAAAAAAAAAAOB48XG6l6aqKR8bGhcVsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGogUhAAAAAAAAAAAAAAAAmh/XwaWpasrHhkZFBSwAAAAAAAAAAAAAAAAAaCASsAAAAAAAAAAAAAAAAACggWhBCAAAAAAAAAAAAAAAgGbHx+VemqqmfGxoXFTAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBLQ58IAAAAAAAAAAAAAAAAHDcul3tpqprysaFRUQELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBaEAIAAAAAAAAAAAAAAKDZ8XG5l6aqKR8bGhcVsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGogUhAAAAAAAAAAAAAAAAmifa/KEJoAIWAAAAAAAAAAAAAAAAADQQCVgAAAAAAAAAAAAAAAAA0EAkYAEAAAAAAAAAAAAAAABAA1ka+kQAAAAAAAAAAAAAAADgePFxuZemqikfGxoXFbAAAAAAAAAAAAAAAAAAoIFIwAIAAAAAAAAAAAAAAACABqIFIQAAAAAAAAAAAAAAAJofl8u9NFVN+djQqKiABQAAAAAAAAAAAAAAAAANRAIWAAAAAAAAAAAAAAAAADQQLQgBAAAAAAAAAAAAAADQ7Pi43EtT1ZSPDY2LClgAAAAAAAAAAAAAAAAA0EAkYAEAAAAAAAAAAAAAAABAA5GABQAAAAAAAAAAAAAAAAANZGnoEwEAAAAAAAAAAAAAAIDjxnVwaaqa8rGhUVEBCwAAAAAAAAAAAAAAAAAaiAQsAAAAAAAAAAAAAAAAAGggWhACAAAAAAAAAAAAAACg2fFxuZemqikfGxoXFbAAAAAAAAAAAAAAAAAAoIFIwAIAAAAAAAAAAAAAAACABqIFIQAAAAAAAAAAAAAAAJofp8u9NFVN+djQqKiAVY+VK1fq4Ycf1pgxY5ScnKyAgACFhIQoNTVVV111lX766afjfYgAAAAAAAAAAAAAAAAAmgAqYB1ixIgRWrhwYZ3tFRUV2rp1q7lMnjxZl19+ud544w35+/sfl+NsTj74rEg/LSvV6l/K9eumclVUSG+9EKcrLwird//CIqceejZHX3xrV0aWQwlxFp07MUT33x6lkOC6OYNOp0svv1OgNz4o1LZdlQoJ8tEpI4L06N3Rat/G6rVvVZVLT/8nT299VKicPKcG9g3QCw/Hqlvnuv+Or79foNvuz9baua3Voa3366DpcrlcWjarQN+9l619O8pUUlSlmAR/dT8hRGdeF6f41gFe+6fvKtcXrxzQxpXFys2oVEiERckdA3T6ZbEaODrca9+Kcqc+fHa/lszIV3mZU90HhejqfyYpOqHu+Pnw2XTN+SxX/5rZRSHhnGqbs43TdmjOQ8uOuE/SwFY689VRNffz9xRp1dvrtf/nLBVnlsoW5q/I9mHqdUGq2p2U7PVcR3mVlr60Vtt/TFNlmUNJ/eI0/I7+CmkVVOd9lvxnrXk8F3823nxNNG/7v1+vjU/POuI+kX1T1Pe5c2vuO+zl2vnuUmUu2KqKvBIFRAUr7qROanvFYFkCvcdEZVGZtr48XznLd8lHUvQJ7dTxxhGyhtrqvM/6R79T8Y5sDXz9Evla/BrxU+J4KVq2Ufnfr1DZjv1ylVfIEhkqW6dkxV5+qqwx4XI5qlS8YrOKV25W2dZ9qswpkOSjgJRYhZ3cRxGn9pePn/f3LmdFpbI/nK2iJRvkLK9UUPc2irt6nKzR3n8vDVkf/qiCOWvU7l9/lV9I4DH85Dha9t3xpKpy8ut9LKBzO7W66/o626sKi1X47VyVrt0kR26BfAP8ZYmPUfDQfgodObhmP5fTqcLv5qt4wQo57XYFtEtR5EUTZU1qVec1i+ctU96U6Yp/+G+yxkU38qcEALRExKVwrBlj4s137Xp/il1btzlksUg9u1t10w2hOn1M3e/G23dU6rkXi7RkeYXSMxyKjPBV505WXf+nkDr7l5W59PCTBfpqeqlKSl0aNsRfTz8coaTEurGnh54o0Aef2LV8Xrz5mmj+4+r990o09ZNSbTfHlY+6drPo2uuDdeoY79/5L/xfkf71vP2wr7VwcYySUyxe56ZXX7brkymlys9zqlcfqx54MEydUuuOq48+LNEjDxbq+x9i1KYtMc+WMK6mvl+srz+1a9d29/kqtZu/Lrs2VCed6jn/VFa6tODHUs3/oVTr11bowP4q+fhI7TpaNfHcYJ19cbD8/Izok0d5mUsvPZOvH78rVVmpS/1OCNAdD0aoVULdcfOfp/M17VO7PpudoLBwzlct4RrNqh/yNPv9DO3fWarSoipFxfur8wlhOv3aRMWl1I1NZqWVafpr6Vq/KF8FWZUKCrMosUOgRl3cSgPHeX77V5Y79dn/7dGK73NVUeZU54GhuuS+toqK977uYzD2W/h5lh7/rreCuUbTrG2dvk0LH150xH0SBsRr3MuneW0r2lektZN/1b5l6SrNKZV/qL8i2kWo6zmd1W50W69rNKteXq1ds3fJUVal+H6tNPj2QQpuFVznfVa+vFpbp23V2Z+eqYCwuuMOAPiLc4j09HTzNjExUeedd56GDx+u1q1bq6qqSkuWLNFzzz2nffv26b333lNlZaU++uij433ITd79T+Vo916HYqJ8zaCVsX449hKnRp69Vz+vq9CpJwXqwrNCtObXcj33Sr4WLCnVvC+TZLN5fwG/4Y4sM3DVvbO/bro6XOkZVZr6TZF+mF+ixdOT1am9J4j1wuv5uu/JXI07JUip7a368PMijb1onzYsbOMVRNt/wKG7H83RA3+PIsjVzLz7RLq+eTtLkXEWDTo1XEEhftq1sVQ/fpKjn77J0+NTO6l1qvvH45af7Xrg0m2qcrg04JRwDT4tQoW5Di2dma8nb9ipC26O1/k3x3u99swPszX09AiFRlo09/NcPXH9Tj31ZarXD8xdm0r19ZuZuuW5NiRftQAxnSM18Loe9T62fXaacrcXqPUQzzjJ+DVbX18/R06HU21PSlKHUSkqySvTjjl79d1tCzXw+h4adF3Pmv0Xv7BGv07dqo6ntlZgRICZYPXtrQt03vtj5Fsr+SF7a55+fm+jRj86lOSrFiKkY6zaXu5JQKgta8FW2XflKGpgm5ptVaWVWn3rVBVvy1LUgDZqNaqzub7n01XKW7tX/f51vvz8PeecDU98r9yVuxU/ppsR+VDGrI2qLChVr8cmeb1X9tKdOjBvi/r/+wKSr1pIkOvAa9NV8MMqWeMjFXZiD/na/OXIK1LJ+t2qzMo3E7AqMnKV/uyn8rH5K7hnO4UM7KyqkjLZV25R5hvfyr56q5LuuUg+RkT1oKx3Zyl/5gqFDu0uv9AgFcz9Wfue+FhtnrrOK1mrbFeGcr9erIRbzib5qoXxCbQp9NRhdbZbYiLrbKvYk67M596Ss6RUgb26KGhATznLy1WZnqXSnzd6JWAVzfpJBV/MlK1XZ1lbdZV9yc/K/L+3lPDY7fK1eYJZVfmFyps6Q+GTRpN8BQD43YhL4Vh/H7/i+lxN+65U7dr66bKLglReIX03s1QXXZWjZx6N0HVXhdTsv3J1uSacl61Kh0vjxgTqjPGBys6u0jcz3Pvfc3uY7r7Nkyx43yP5ZnLXWRMDFR3lqw8/KdGFV+Vo3ndxXrGpdRsq9O9Xi/TGi1EkX7WQcfWXG/P1/XflatPGT+dfGKSKCpd+mFWu667O14OPhOqKK+teJD7nXJuSU+r+zg8L8x4Tb71RomefLtbIUQFq185PX31ZqssvydWP82IUXOvclHmgSk8+XqRbbgsh+aqFjKu7/5Kj2TNKldzGojMvCDbHlZFkddu12brzoQhdcEWoue/e3Q7deWOOgoJ9NHCoTSeNDlRxkVMLZpfpyX/madG8Uj3/ZoxXDOGFx/PN5K5TxwcqIspP06bades12Xp/Wiuv89XWjRV67/UiPfpCNMlXLcQnT+3RzHf2KyLWqn6nRMoW4qe0TSVa8Gmmlk3P0b1Tuis51TP52Ei6+vdftpjrfUZGKjYlQCUFDqVtLtH6JQVeCVhTntqtuR8dMLeFRFr00xdZ+teNm/XAZz3lW2tcpW2y6/u39uu6ZzqSfNUCRKVGqc81vet9bNec3crfka+kwUle242kq9l3zDXXU4YnKzQpVBWF5crdlqf0Ffu9ErBW/HuFNn622dxmiwjQ1m+268e/z9HEyeO9rtHkbs3Vr++v00kPjyD5CsBh8VfnEF26dNHjjz+uc845R35+3j9OBg8erMsuu0zDhg3Tli1b9PHHH+uGG24wq2bh8F5/Lk6d2lnVJsWqp17M0z8ezznsvs+8lGcGue78a4SeuDemZvs9j2Xr6f/km4Gqu2+Oqtk+d1GJGeQaMdimmZ8kyd/f/QXrorNCNOHS/brpH1n6fornj+6bHxbqlBGBmv5Bonn/rNNDdPJZ+zT9B7suPNP9Y8Lw13uy1L61VbdeH9Ho/z1w9ORlVerbyVmKTbLqueldFBzq+f/wN29navLj7uSsvzzZ2tz26YsZqihz6a5X2pnJWtXOuylet52+SV++fkBnXR8na4CvORtoztQcnXJelG583P38Tr2D9OIde7T9lxKl9g2umTH2yj/S1HdEmIaNr3sxEs1PbOdIczlUVWWVfv1ki/nDrsuEdjXbV7yxzpwxMe654Wp/sqfa1cDr7JpywXdaM3mj+l/ZTX7+fnI5Xdrw9Q51m9RBI/85yNyvVY9o/Xj/UmVuyFV8T/d50Fnl1NxHlqv1sER1GuMef2j+QjvGmcuhnJVV2vfVz2ZCS4KRPHXQ7k9WmAlXrS8coI7XDa/Zvu31hdozZaXSPlutthe7x1F5TrFylu5U+z8NVdtLTzC32eLDtPOdJSrPtZuVswyO0gptfmG2kif1Vni3hGPwqXG05X+7zEy+ihg7UHF/GlenipWrqsq89Q0MUNy1pyv85D5mglY15xUVSrt/suyrtqh4yQYz2cp8ntNpVrQKP6Wf4m88w9xmVNTKePFLlW3fp8DUlIOv79SBV6YpuG9HhQ2rP3kVzZdvkE0RZ576m/s5S8uU9eJ75nr8/TfJPyWh3nFYrXj+ctm6dVTc364y7wf276HMJ18zK2cFn+AJsOV+8LUssVEKHXNiI30iAMAfAXEpHEtff1tqJl8NHuivrz6OVWCge0w8cHeYTh6XaSZQnTbapjYHqw89+XyRSstc+ujtaI0/zTN54a7bHBp6ygG98FKRbv1LqAICfNwVkKbYddlFwXrxGXecYkBff11/S55W/1yhgf0DamJTN92Rp1NH2nT2GXWra6P5mfFduZl8NWCgVe9/GCXbwXF1x11OnTE+W48/WqRTTgnwqmplOPf8QA0e8tsXiKd8XKJhw/319rvucXXaOJsuODdXc34s18RJnnF5/32Fat3aT9dcWzfZC82PkXhlLL0H+OvlD2JrEoz/ckeVLpt4QC88lq/howKVmGJRcIiP7nokQhPPCVZgkCfOcGuJU9ddmKmFs8vMSlenjnefc4zz1def2DXpgmD980n3380effx1/2252rC2Qj37ec5Xj9ydp2En2zRmAuerlqAgq0Kz3t2v6CR/Pfx1LwWFes5LMyfv15QndpvJWVc/0cHclpNerpdu3qrIVv66452uik70PmcZk+erGeNq4WeZGn5unK56tL25rUOvEL1x13bt/LVYHfq4v0s5q1x6574d6jk8QoNOZ/JWSxCdGmUu9V2j2Th1k3z8fNRpvHtMGYozijXn7nkKig3S2JdOVUi8J/ndYEyer2Zco9kybZtSz+ikE+8dam6L7R6rBQ/+pOwNOYrrGet+TpVTPz22WMlDk9T+VE/yFpoQ43ThOWU0PU352NCoSCc/xPTp03X++efXSb6qFhMTY1bBqvbZZ58dw6NrnkaPCDKDXL9nxoURtAoJ9tF9t3r/ITXuG9uNx2szAleGh+6MrglyGcadEqyThwbqh/ml2rO3smZ72j6H+vfyfIEb0DugZnu1L74t1jez7Hr9uVizlDOaj6y9FXI6pS79Q7ySrwz9R7kTrApyPP/WB9IqzFLJfU/yBDkNcUn+at050EzOKitxfxErynOootyl9j08PwQ79nSvZ6VX1GwzEsD2bS/TdQ95t5lDy7Nj7j6VFVSozfAkBUV7glGFe4uNLl5qM8z7YnNYQrCiO0aYyVmVJe5xWJpfrqryKsV29SR4xXZzn/+K9pfUbPvl4y3K21Wok+4ecAw+GY63rEXbVFlYpujB7eR/MFHK+BuZ/u06+QVa1e4y76pZxn1ju/F4tfLMYvM2NNXTvivs4Hr5gaKabTvedJdubn9N3Yo2aH6MtoDZU+fJ2ipScX8aWyf5yuBz8DuuNTpMkWMHeSVfGYz7kROHmOsl63fVbK8qKpGrwiFbe8+5zdbRfeGwMstoX+iW9+1SVezLVqvrxh+FT4jmomjOUrNdYcS5Y+skX9Ueh9Wq8grk38Zzcdq/rft7VFWup+Vhyap1ZuWs6KvOqfN8AACOhLgUjqXvZpaZt7ffFFqTfGWIjvLTn68NUXm59OEnntZwu3Y7zNiUkSxVW+tki7p1sZrJWXa7OzaVk+tUWZnUp6dnPPft7f4+n7bPk+D+ypvFZuvD5x4nga+l+GGWe1z9+a8hNclXhqgoX119TbAqyqWpn5Y2+PX3p1epZ61x1auXe31fumdcfT+jTD/+UK4nnw7n3NRCGJWuDH/6S5hXdcfIKD9dfHWo2bLXqFpliIu36PzLQr2SrwzG/UuudsfWVy8rr9men+tUeblLXXt4Yg7devnXjLdqH79TrF3bK3X3I0xkbimy95XL5ZQ69Q31Sr4y9D7Z/XepKM/z3Wj6q/tUWlylyx9sVyf5yuBX63xTnOdQZblLbbt7kkDb9nQn1uTUukbzw3sZ2r+jTJc9SJJMS7d7XprKC8qVcmKyAmtdo1n7zq+qtFdq6N2D6yRfGXwttSr555eZ12hiuniS9WK6uteLMzzf2TZM2aiC3YUaemf9HS0AoBoJWA0wcuTImvXt27cf12NpSbbuqDTLtA8dGKjgQ77IG/eN7Tt2O5S2z/PlbP7iUgUH+WjYoLo9o8ec7E6Omb/E8+MzJclilo6vtvrgurHdUFBYpZvvzdLfrotQv151XxNNW0LbAFmsPtq0qlglRd6VFVbNcV8c7jXU82WrdSeb0ZVLa+Z7khGqE6r2bC5V2642s9Wgwbj1D/DRzg2e8bRjvTtBJjbR/eMxc2+5PvlXhi75e4KiE2gR19Jt/Mp9/u92pnu2TTUjycrIZN+9aL/X9qL9duVsy1d0aoRZxtZgtBz0C/BT1ua8mv2yNrrXQxPc57DC9GIte/VXDflrb4W0YibYH0F1IlXieE/1oNK9+arIsSu8R6KZbFWbcd/YXra/QGWZ7vNZQJz7XFe0LbNmv6Kt7vWAVu7AWMGG/dr79Vp1/tsoWQI5Z7UE9rXb5SwuU8igLubsraKlG5TzxUKzbWDF/sNXejiUz8EgRO0ELqPloI+/RWU7M2q2le9wn+esse4k58rMPGV/Mlcxl4yWNdpTWRIth8tRpeKfVqpg+lwVzV6s8u176t2vZMVaGVcSg/r3VOX+LBX9uEiFM+arZM0GuRx12z75RYabLQurVe7e594e5Q7OOkvKlPfB12blq9qJWgAANCbiUmgMB7Lc8ag2res2nqjetmCRZwx07Ww1Y1M/zHUn2FQzkvI2bKpUz25WRUW5k8+NloM2m/TLOs8YXPurez0lyb3P7jSHHn+2UA/cE66kRJpftBRZWe4kvJR62glWtxhcvMiTfFBt+bJKvfpysV571a5Z35fVJPMdKiHRT+trjat1B9eTEt2vXVjo1AP3FepP1wSpR61ELTRvOQfPV0mHVE6rvW3FEu9zU32MeLyh9jyZiChfs3Lf5vWecblxXUXNeDOkpzn06v8V6K93hqtVAuerlqJVG5s5JrauKVJpsffv/7Xz3JOsug0Or0l+XzEzVyERFnUbEq5d64rN6lgz3krX+sUFZsWr2oyWg9YAH+3e6EmK2b3evR598BpN9t4yffnvNJ17e4qi4mkR19JtmeZuXdl5UmrNNmNc7Zq9WwHhAUocmKDsjTla9+F6/frBOu1bnm7GTGuzRdjMazQ5W3JrtuVsdq+HxLuT/YrSi7X69Z/V/8/9FNyKKpAAjoxvNQ1QbkxVOuhwlbLw39u60/3DrlP7+n/EGdtnzXPvl5Jklb3Eqf0HqtSji79Xz/BqHdu5X2fbwdc1XH1xmO56JEcTL0tXanurPvy8WInxfppwqvsP5p0P5yjQ5qOH7qhbyhJNn5EkdekdCXr3iXTdfNpGDRwdrqAQP+3aWKp1S4s19pIYjbvMXS7UcNFtCdq02q5nb9qpAaeEK7FtgFkha9msAsW3DtBt/25Ts6+vr49GnRutmR9lq9RepdAIi+Z+kat23QLVoZc7qPrqfXvVpkugxl7qaVOAlqlwv117VxwwE6JaD/Wu7HHCjb20/+cszbzzJ7U9KUkRrUNVmleuHXPSFJ4cotOe8FQa8vH1Udcz2mvdZ1tVaXfIFuGvTd/sVEznSMUdrIQ177EVikmNUI/zOh3zz4ljrzSjUHlr0hQQG6LogZ5ZWiX73Il5QUn1zwg0tueu2K2SvXmyxYUqIDpE0Se0087JS1Sa7k5AzZi1QTFD2pvtB52OKm167gfFnZSqmMHeSYRovsq3H0xg8fXRrtteUWV6raQrXx9FThisuCtO+83XKZi9xrwN6u0p3e3j66vwUX3NZC5nabmZkFUw92cFtIuXrYM7ISbj1ekKaBNvtj9Ey+QsKFLu294VgP3bJSv6+otkjXPPDjQSrCr3HpBvaLCKZi9SwVc/GtGvmv2NFoIxN10u/+T4mm0hIwYqf+oMZb4wWdb4GNmXrJFfRJgCe3cxH8/79Dv5+FsV/jvaHwIA0FDEpdAYjCQpw+49DnXu5D2WjG2GbTs8F6T/eVeYlq0s1+XX5WjcmEB1bG9RVnaVvplRqrZtLJr8SpRXbOrSC4L11nt2Fdudior01UeflqhXD6v69XFfeP7bXXnq0c2qa67g4mBLYvxbG9LSqtSxk/clnb1p7iSanTu9J6Mann/OXR27Wli4j+5/MEznnOupEmK44KIgPflYka6+Mk/t2vnpqy/L1KqVr0aNdicvPPFYkWw2H912u3cXATRvEZHua1v70hxq19H7fGVsM+zZWXcCzaGmfepOgBk8wuZ1vjrj/GB99kGx7HaXIiJ99c1ndnXublW3g5X7HvtHnlK7WnXeZXWr06D5Com06ty/t9YnT+7WP8auVd9TImUL8VPaphJtXFaoURe30imXuuMBWXvLZc93qG2PYE2+f4fmf+KZSGpo3S1It7zSuSaRyhhXw8+J09yPD6jMXmUmbi36Isvcr93BSliTH9iplM5B5vugZSveX6z9KzIUHBekpCHuKv3VyVLlheVmFatFTyzR5i/dSVrVojtHafSzo2oSqYxrNJ0mdtSmzzebVbOMxK2t324z94vp5o51LX5iiaI6RarruZ2P8afEf8P4RebThNv8UT/0j4MErAaYP39+zXrXrl2P67G0JAWF7hk44aH1F2YLC/H12u839z+4vXo/w63XR5ilb9/+uFA/LSvTwD4BeuGRWIUE+5qzFo1S8t9PSZTV6qO/P5ityZ8UqqTUpdNODtJrz8YqLob/yzR1E/8Up6hWVr3yjzTN+shz4bnrgGANPyPCq2RtcgebnvgsVc/dtEvLZnraJ4VG+mnkuVFq1dp7hsTl9yTKzyotmVGgijKneg8L1dX/TDIDrfO+zNX6ZcV6dlpns23hmw/t1dLv3a85eGy4rn0wWbYgEjZbik3TdpgzJbpMaCffQ1p8RbYL0znvjtHMu37Sjjl7a7bbwv3VZWJ7hSV7BxWG/a2PfC0+2v5jmtmeMOWEeA2/o7/5upum79S+VZm64KOxqix1aOFTq7Rtdpr5vI6npGjE3QNkDeS81JLs/3695HQp4bTuXtWHHHb3LEG/4PorVVVvrzq4n6HbPWO19eV5yl683axE0+qULur055PMx3Z/tELlOXb1ffZcVeTaten52cpdvku+ARYljOuujtcNr7d9HZo2R6E76Jn3zRKzVWDCU9cqICnGrFp14NVvlDdtiaytohR5hASp/FkrZV+zTUE92ymkv2f2mCH28jHmuChaskHOikoF926vuKvHmdsK5v2s0vW71ObZ6+Uqq1DGm9+ZFbgMoYO7qdW14+u0O0TzEnLiAAWktpU1KV4+Af5yHMhW4cyFKlmyRpnPvKGEh2+Vb2CAnPZSGT2hncUlKpg2RxHnjVPw0H5yVVWpeN4yFU6fq6x/TVbi47fLx+oO8oeeNtxM3CpeuFLlW3fKv22Koi6eKF9bgMo275B94QrF3fYnc6zlTZku+6JVZsvNwJ6pirribPmFEbAHAPzviEuhMRitBD//ulTPv1SkEcNsZtKKITe3Si+/WVxnTKR2tOrHb+J0xfU5+ua7Uq+Em0svCFK7tt7/5o/+M0JWi4+++rbEbE948ogAPf1whBmb+niqXT8tKdfCma1kL3Hpjnvz9PW37tecND5Qzz4eUae6G5qHk0YG6JtpZXrlpWINHeqvgIPjKi/PqbffclfoL6o1rrp2terpZ8M0eIi/4uL8lJVVpdmzy/X8s8W647YChYX56NQxnmSZa64NUkW5S59+UqoVyyvUq7dVDzwUpuBgXy1dUqFPPi7Vex9GymKVHn24UJ99WmqOv5NOCtDjT4UpJoaYZ3M09GSbZn5TosmvFGngEFvNuMrPq9LHbxfVGVf1+eKjYi2aV6aBQwN04kjvxL6/3Wu0q5R+/K5U5WUunXCiTXc86D5fTf/crlXLyvTRt/EqLXHpqftzNXuG+3x1yrhAsyXhoe0O0XycdmWCIuP89c59OzR3iiepqlP/UA2eEFNzjaYox52kvmejXRk7SnX1E+3V95QolRY5NP21dM3/NFMv3bxV//zU0yXggrvamM9f8X2OKsud6jYsXJfc11a+fj5a9FWWNi8r1INf9VR5iVMfPLJTK2e6KxkNOC1Kl93fTgFco2kxtnyzzbxG03FCR69rNGW57sp9RkWr/N0FGn7/MLUekaKK4kqtnfyLtny1VXPumaeJb4+vec6gmweYbQl3zd5lXqNJGpSowbcPMl9367fbtX91hia9P1GOUoeWPLNMu+bsNp/XdlQbDbnzBFkP6VgB4I+NX+3/JafTqSeffLLm/vnnn/9fv8bevZ4L8vXZv9+7bRUaj/Hl/t5bo8yltrIyp264M1OXnReq0SOC9OS/c/Xy5AI991CMkhMsuvkfWbrqlkx9+6EnixpN06cvZujzlw/oglviddKkSAWFuStgvfPYPt1/yTbd8Z92ZmUsw9a1dj114061Tg3UM1+lKqmDTXlZlZrxfrbefmSfNq606+8veirQBNh89af7ks2lNqNq1uTH9+nsG+KU0smmV+9L04ofC3XDoylmSvMbD+xVgC1d1z2ccsz/e6DxGV/qN07bYf7bdp1Ut3LQgXU5+u72hYruGK7zPzhNEW3DVJJTpl8/3aKfnl1tVsca+9SJNftbbBYN/3t/c6mtNK9Mi/5vtfpf1U1R7cM197Hl2jl/r0beO9B87wVPrpTF5qeT7qHSTEsaW2YClo/MJKj/lTXMpm53j62z3b47R7s/XK7Ot54i/8gg/XznF7LvyVX3+8erIqdYW1+ab25vcyFjq9k5WELbx+KnpLsulCUqzLwf1K2NEv9+nnbd/qryvll82ASs4pWbdeCt72SJDVfCLWfXedw3wKq4P40zl9ocBXZlTZ6pqLNPVEBKnDJe/UbFKzYr/oaJ5tyeA298az631XUTjsrHxrERPmm0133/1omKufYCZRtV+pasUfGC5QozEqmqS7k7nQodPUxhY0fUPCfirDFyZGSrZMUvKlm5TsFD+noqrE08xVxqc1VWKnfyFwoe2le27p1U8O1cFc1ZqsiLJsgvMkx5H05TzltTFXfrVcfiPwEAtCjEpo4P4lIt33lnBenDT0u0cHG5hpxyQKNHBqiyUvp2ZqnizCSVKvnWyilYtaZCF1+drW5drJr/fZxSO1p0INOpN94p1l33F2jJ8gq9+5q7+oIhMNBHTz4cYS61ZedU6R8PFei2v4aqS6pVt9yZp29nlepfT0ca83F02z/yzOf+3xP1V1VG0zbpTJs+n1qqJYsrNPbUbI04OUAOh0uzZpYrJuZgC/laZRVOG+fdwjQ5xaIrrrSoY0eLLrs4T889U+yVgGWcm266JcRcajOSZv5xd4HOPsemE4cH6OX/FOv990r0z/vDFJ/gqwf+WWgmdL3zHlX7mqOxk4LMqlQrl5TrgrEZGnqSTY5Kl+bNKlVU9fmq9sA6xILZpXrqgTwlJPnpkRc856lqNpuv/v5ApLnUlpdTpf97NF9X3Rim9p2seuyeXM3/oVT3PhFpVgd58p95sgX66J5HGVfN1df/2atvXt2ns25O1pAzYhQUajGTrD5+YreeunyD/vLvTmailfNgfp+zSjrrlhSdeHaceT843KIrH2mvtM0l2rG2WFtWFip1gDvG5W/z1cX3tjWX2gpzKzXlid0af32ikjoGmRW11szO0xUPtzfPj+8/tFP+Nj9d/mC7Y/8fBI3OiD1tnb7NjKOnTuzo/djBKuyuKpf6X99XnSa4Hw8IC9CJ/xiqvG15ylqXrYyfDyi+T6uaazSDbxtkLodeo1n+wgr1uqKnIttHmBW19ixI07B7hpjvveTpZeZzh941+Jh9dgBNHwlY/6Xnn39ey5cvN9fPPvts9e/vfcH890hJIQmjPuFhB2cGFtU/q6Kw2Om132/uf3B79X5H8sj/5Sm/wKnnHnS3jvv3mwW67NxQ3XhFeM1rXf7XA9q8rUKdO1K9oalau6hIn/wrQxOuitXZN3hKzHYdEKJ7Xm+vP4/coMlP7DMTsIwfk//3t93y8fHRXa+0U0Cge5wYrQevujdJmXsrtGRGvjatKlaX/keuqvD2o3sVHm3V2Te2UmlxleZ8lqMLbk7Q8DPcPy4PpJVr6osHdNldiQoMZoZFc5e2LEPFGSVKHtRKYUneY6Oq0qlZ/1gkH19p3LPDa6pTGa0HT7ytnwr32c1KV0YSVkIfTzvM+ix8ZrUCo23q/6duqrBXatPXOzTwhp5KHef+cWm81orX12nILX3kH8QMi5Ygd9UelWcWKbJfigIT3H9/qlnqqXBVW9VvVMiq/QN003M/KrxXkhLGdjcTr3JX7la3e8cpdpi73VzhlkylfbaaBKxmyDfIHUC3dUisSb6qFtC6laxxkarMyFWVvVR+wd4zU4tXbVH6s5/KEh6ilAevkCXy97eWyHx7hvzCQxR99nCzPWHBnDWKueBkhQ3vZT5eeSBP2VPnKfayU80KSWhZQk8+wUzAKt+2SzpteM04NAT2rVstOLBPVzMBq2Ln3poErMMpmDZbztIyRVzgTt4r+mGRWU0rdKQ7sOUqLVfOG5+ocn+WrAlH/rsKAPBGbKou4lJoDBaLjz7/IMasgDX1yxJN/tBuVkObMDZQN98Qon7DDyg22h0bqqx06ao/55gJDh++Fa2gg7Gpdm189fiDEdqd5tBX00u1dEW5Bg888vfou+7PV1ysr26/KUxFxU598Ild99weZiaEGXbuduip5wv18H3hZsU1NL9x9c57kXr1Zbu+/qpUUz4qUWior8aMDdC11wdr1IhsRR9MxDqSYScGqE0bP23e5FBRkdN8jSP59wvFKix06b773b8v33m7RGefE6hLL3ePq+Jil269uUDbtzvUoQOXmprjuHpxcqwmv1Ko76eV6IuPixUS6quRYwJ12XWhOmtkhiIPM65+mluqu240xp2fXv04TrFxvz/m/cxD+eZ4/dNfwmQvdurrqXbdcGu4xk1ytwPbl1al1/9VoFvuiVAQ56tmZ/3iAn314l6NuTJe469LqtluJFD97dXOunP0z5ry1B4zASso1DNu+pxSN0G4z8hIMwFr1zp7TQLW4Xz02C6FxVg14fok8xrNT59n6cybkjVkovu7VVZaub5+aa/Ov6O1bFyjafbSl6fLnmFXwsAEhSZ5xzD9gz3XSlJG1P3Nk3JiipmAlbMxpyYB63CWPbdcgVE29b6qp9mecMu0rep3XR91GOuemF+0r1g/v7lWA2/qLyvXaI4/I/fuYAJek9SEDw2Ni28v/2Xrwbvvvttcj4uL0yuvvHK8D6lF6dTO/cdp6w532dFDVW+v3s8omZ3Qyk8791SqqqruWWvbTvf+HQ/ufzi/bCjXs6/k6flHYhQV6aeCwiodyKpSnx6ewEbfg+ubttV/4RtNw5r5heZtj8F1E6YiY61Kam9Txu4KldqrtG9HmTLTKtSpT1BN8lVt1a+xY72n/Ht9Vs0r1OJv83Xj4ymy+vvqQFqFqhxS226eC9vtugWZCV8H9jB+WoINX203b7ud6U5WqS1/V6GZGNWqR3S9rQGTBrhn8WRtzjvie+z6KV3bftijkfcNkp/VT4X7iuWscikm1fNDNKZzpJwOpwr3ulsYoPnb/92v5m3i6T3rPBaU5P63L9lX/9ip3h6UfOTZzPum/aKibZnqcqu7ykxJmvt5oR08iQuhneJUkVsiR3F5gz8Ljg//JPeMU99g79nO1fwObndVOOomXz3zifxCg5Ty0BXyj//9s0yN5xYtXq/4GyfKx2pRxYE8qcqpgLbxNfsEtIuXHE73Y2hxfEPcQXJXufu7t2+Av1mdylwP8k70q73NqG51JBVp+1X4/QJFXjRRfiFBcpaUyVlYLP/WCV5VuAyVGZ6WBgAANBRxKTSWgAAf3X1bmFYtjFfWzmRt/yXRrESVnlFlPt6ntzuJbss2h3bvqVL/fv41yVe1DR/q/nf/Zd2RvzfNml2qL6aV6t9PR8rf30e7djvkcEi9unvGXu8eVrMS185d3r8F0LzG1S23hmjO/Fht3h6vlT/H6fEnw3Xg4Ljq1ev3XfiNjHKPtbLSI18F3LixUq+/ZtcDD4YqItJXhYVOZWc51a2b5326Hxxj27cxrpor/wAfXfe3cH0xJ0FLt6Tox1VJuveJKGUeHFfdetZN+l04p1R3XJ+tiCg/vfZxrJJb//7kOyNx64fpJbrvyShZ/X20b4/DjKWn1hpXnbtb5aiU9u5mXDVHvy7IN2+7nuA9udQQHuuv+PY2Ze4uU5m9SnGtbfI9mAtlVMk6lNHdxFBRfuRWmGvn52n5dzlm1SyLv6+y9papyuFSSld3sqihdbcgVVW6lJnmbk+H5m3z11vN286TOtV5LDQ5TD5+7up9ASF1z2H+oe5tRqvBI0lbtFc7f9ylYfcOPXiNpsisqhWV6ombRneOOniNxt22FQAMJGD9TuvXr9dZZ50lh8Mhm82mqVOnmklYDZGWlnbEpbrC1h9Np/ZWJcb7afGKUtlLvL9QGfeN7e1aW5SS5PkyPmJIoOwlLi1aXvdL06x5Je59Bte98FPNCJBdd3umxpwcpAvP9M6SLi/3/AgtrzjY0ucIJXdx/BlJTobC3Pp/nBnbjTLvxuye37OvwUiqOhwjkev1+9M05uIYdekX7H0sFc666wyfZq8sv1w75+9TQLi/2o/0bkVpqHK4/61L8+pPXCk7uN3PevhxVVFSqflPrFCPczsqobd3NQ9nRVXddcZVi1BZUKqsxTtkCbMp9sS6yX2ByRHyjw5Wwbp0VZV6B9+N+8Z2W0KYbHGHr1pUnlWs7W/+pPZXDFFgone7CmclY6slCOrhLqNesddoCufN5ahSRUaufGxW+YUF1Um+8g0JVMpDV8o/oW7bgMMxql0deP1bRYwZoMAureu8X33raHnKd+wxby0xngTQgC7u81hlet3EqMr0A+atX639D+VyOpU7+XPZuqcq+ITe3o8ZVxPrrHPCAoD/FrGpuohL4Wj79Ev3JL9zznCPiYqDsamcnPq/L2fnuMeh/xGKnhXbnbrtnnxdfXmwTjikSlZ5Rd11hlDL89WX7vPPhIPj6khKSpzausWhoCCfmkSsw52b7r6jUCNOCtDESd6vW3HwfFR7nXHV8sz42v03bMxET/ygOvnqzhuyFRbhayZfpbT9/RVfSuxOPXFfns69NES9+3ufrypq/c2rXmdcNU+OSmdNS8D6FOU6zO4RflYfWQN81bGv+/tP+jb3mKstfZv772ZM0uGrQBqJXO8/uFMjL2qlTv28v0s5ap2vqtcZVs1fWX6Z2QbQaCnY5mTveKTBEuCnuJ7u6yp5O90JgbXlH9wWkuB9Ta+2ypJKLX5qqbqck6pWvbxzAapqXaOpXud8BaA2ErB+h507d2rMmDHKy8uTn5+fpkyZohEjRjT49ZKTk4+4JCR4ZnX/kRhBpKsvDlOx3aVHn8/1esy4b2y/5hLvMqPXXuq+/8DTOV4//mbMtmve4lKdelKg2qQc/kfAv9/I18atFXr5SU+SQ3iYnzmD8bs5dq/XM3TtRAnJpqxLf/cXpm/ezpK9yDt4NfOjbOVkVCq1b7D5xb51J5uCQny1eZVdPy90V86qlp1eoVkf55hfmrqfcPgvYR89t18up3Tp3z3/n23V2l8Wq49Wz/O8prFubItvTZuA5m7zdzvlrHSq87i28vOvW6o4ukO4WeI2Y2229izZ7/VYUYZd679w9yVP6n/4BN6l//nFLEU6+K+eC85hySHytfhq9yLPaxrrvlZfhSf//jZhaLoyftgoV2WV4kd3ka+/pd6/kYnje5jJVjvfX+r1mHHf2J44vm7lrNo2/2u2ghIjlHJuv5ptQSnuBIicZTtrtuUs32kme1mCaRXX3BiVq4J6dzDbDOb/uMrrsZwvf5LTXqbQQV3l4+c+fxWv3upOvgoOVGsj+Srx9ydfGbI+mm2WdY69dLTnGFpFShZf2Ve7Z6IZjHUfi99/VVkLTUvl/kw5a1/Bq7U9/7PvzfWgWolS1S0CC7+bJ2eJp5poVUGRin5cZEamgvr3OOz7Ga0GjeStqMvPrNlmtDb0Cw9V2S+ba7aVHly3JjZsYgwA/JERm6qLuBQaS3X7ydq+ml6iD6bY1a+PVWec7k5o6dbZqrBQHy1dUaHZ872T+Pbuc+idD+xmbOrEwYf/bfbwk4VyOqUH7vFUGmnX1iKrVZo1x/OaxrqRyGU8hubJaBl4qO++LdPUT0rVq7dVY8e5x0lxsVM7dtSdcGpUvLrnzkKzbeD4CTZzgurhvPNWiVnV6pHHPee8sDBfxcX5au5cz6TDuXPc6x07Ma6aq+J6xtWP35Vo2qd2de/tr1FjPQl4i+a6k69Cw43kqzi1/o0Kj4f6zzMFZiz9r3d6zlfJbSyyWKVF8zznK2Pd6u9+DM1PdRLUrMn7VVLkfS6a+/EB5WVUqGOf0JqJ70bilOHr/+xVZa1J7fu3l+qnL7PMdoE9h3tPJK3t8+fTzL+D597mScSJS7GZCV6/zPck3xjrxjUao+oWmrftM3aY12g6jGtf7zUaQ5dzOpu3a95Y65Uwlb+rQNumb5c12KrkIZ4WmYda9fJqyenSgD/3r9kWlhxqXqPZu3hfzTZj3bhGE8o1GjQBK1eu1MMPP2zmtBi/6QMCAhQSEqLU1FRdddVV+umnn/6r15sxY4ZZnKj6tYxb476xHUfGN5jfkJ6ertGjR5u3RiDm7bff1qRJk473YTUrb35YUDMTcN1G94Wbtz8s1PzF7osxwwbZdM0l7i/dd/wlUtNm2vX0f/K15tdy9esZoNW/luuH+aUa2CdAt1zr/UVr5LAgMzj21keFGjAmTaePDtL+A1X6dFqRoiJ99e/HvKvH1LYrrVIPPJOrx/8R7TV70XDzNRG657EcTbg0XckJFr0zpVDjTw1Sp/Yk0DRlQ8ZFaOaH2dqwwq6bRm/UwFPCzDK1O9eX6tclxfK3+ejKf7hb1RhJWJfdnajX7turx67eof4jw5TUwab8rEotnVWgMrtTZ1wdq8R29X8h37LGru8/yNadr7RTYIjnS15gsJ9GnRelWR/lqLzMHXxdOC1P4y6LkS2I3uLN3Yavdhy2/aDB+MI/9G99NO+xFZp+83y1GZ6oyLZhKsku1Y65e1VZ4lCfS7sook39Peszfs3WuqlbNe654V69yv2DrOo6qb3Wf75NlWXuH65bv9+tnhd0qrfVIZqf9BnrDtt+sFqbCwYqe9EO7ZmyUsXbssxWgUVbM5W7crdCO7dSyjmexKpDHZi3WTnLdmnAyxfJx8+Tfx/cOkpRg9pq57tLVXagUOU5duWt2qOONzQ80RzHV6vrxmvPP97SgVe+UfHyTfJPilH5zgyV/LpTlthwxV5+qrlf+d4spT89xUz8C+reVoU/uVtg1maNjVD4qL71vk/pljTlf79CSXdeKN9AzwUhYz18VD8VzFop58GWdEULf1XEuEHytfE9qrmyL1urolk/KSC1nSzREfIJ8JfjQLY7AaqqSmHjT5atc/ua/QM6tlHomBPN5+y//wUF9u4qV5VTpT9vMNsIhp9zmqzx9X9Pd2TnquCrHxRxzmmyRHl/9w89dZiZ8JX5wjuyRIar+KeVsvXuImurmKP+3wAA0HwRl8KxdsqETCUl+qlzJ6sCAqTVayq1cEm52rbx07uvRcuvui1OgI8evi9cf7srX+demq2xo23q1NGizEynvplRaib9/fX6EHXsUH+Sw4pV5XpjcrE+eitaoSGe33khwb667MJgvf2+XaWl7ovZU78s1XVXBZutM9E8nXVGjhIS/MxkJ2PsrP25UkuXVKh1az+99GpEzbjKz3Nq9MnZZlJWx45+io3zM1sHLvqpXPv3O9W5i0X33Hf4C8V70xx6/rli3XF3iBITvWOZV10dpKeeKNafrshTfIKvmfw1anSA2rUjNtVcXXHmAbVK9FO7Dsb5ykfr1lZo1dJyJbX201Mvec5XO7dV6u/XZ6uiQhow2KaZ0+pWK0pItuiM8+qfzPzr6nJNfa9Yz70eo+Ba56ugYF9NOj9Yn39or2mL+f3XJbrgihAFcr5qlgaOjTYTrTavKNI9p61Vn1GRCgr10+4Ndm1cWih/m68uvKdNzf4njI/Wqlm5WjkzV/ef8Yt6nBih0mKHVs3MVWW5U9c+1VHB4fWfY7b/XKTZH2bo5pc6e12jMZK2RpwTq7lTMlVR6k6+WTo9R6dc2koBXKNp9rZMc0/6TK2n/WC19mPaaffcPdo1Z7e+umSakgYnqaK4Qrvm7jYTskY8eKJZQas+mb9maeNnm3XKMyPNRK1q1iCrUs/oqE1fbJHj4DWaHTN3qut5XWQNZJJEk+CSfI7cYfn4OorHZhQOWrhwYZ3tFRUV2rp1q7lMnjxZl19+ud544w35H6HErtPp1HXXXae33nrLa/u+ffvM5auvvtI111yj1157Tb5G2ynUwTfjI8jOztapp56qHTvcF9xffPFFc2Div2MEud771Lv/7aIVZeZSrTrQZQQB5n6RpIeezdUX37pnCybEWXTbDRG6//YoBQbW/T/yq8/EqmdXf73xQaH+/WaBQoJ8dOa4ED16d7Q6HKEE7g13ZJrP+/NVdXtR335jhHLyqjR5SqHmLXJp4phgvfo0M+ubOuMH4f2TO+ibd7K0+Lt8Lfwm3yx5Gx5t1YhJkTrnxlZK7uhJqBpzYYxaJQfo23eztHm1XavmFcoW5Kv23QJ16oXRGjGp/kodRvvCV+5N0+CxERp4St3xc8XdiWZJ26Xfu2dYnHJelC67y534hebrwLoc5W4vUFz3aEV3Ovysm+5nd1RYYrDWfrzFrIS1+6d0M0kqtkukup3VUZ1Pb1vv86oqnZr7yHJ1OCVF7UbUnX0x7Na+Zj/x7T+mmfeNhKyhN/dpxE+I46VwY4bsO3MU1iVeIe0Pn0TgF2hVv+fP0853lyhz4Tbl/Zwm/6hgpZzXX+2uGCy/gPq/1lUWlWnri/OUcl4/M2nrUN3uOk2bX5itjNmb5OdvUesLB3hVyULzYlSZavP0dcqeMlf2NdtkX7tdlogQRYwdqOjzT5IlPMTcryq/2Ey+MhQtcicAHiqwe5t6E7CMloIZr3yj0MHdFDLQPaOstrgrxkiOKhUt3WDeDz+lr2Ivcyd+oXmyde0gx/4sVexJV/nWnXJVVMo3JFiBvTorZORgBfZIrfOcyAsnyJocr+I5S2VftMqseuXfOlGhl515xOpXue9+aT4vZNSQOo+Fjh2hquIS2X9apfKKHQrs01VRl5/d6J8XANCyEJfCsXb2GYH6ZkaZVq62q9LhUpsUi+64JVQ33xiqsFDvMXTVpSFq09qiV98s1rKVFZo5u0whwT7q3dOqKy8J0flne7f/qlZZ6dLNd+Zp0vhAjRtTt/Xco/eHmy0Op33rTjS87KIgPXzv4WMZaPomTLTp+xnl+nlNqfnvn9LaT3+9OVjX3RCs0FrjKjzCV5deHmQmaM2bW6GCAqdsNh916GjRFX8K1hVXBMkWePjqV/+4u9BM0rr8irpj79rrg5WX59Jnn5ZoyWKXRp8aoMeerHsOQ/MxZkKQ5sws1bo1djkqpcQUP119U5guvy5UIbXGVU5WlZl8ZZj5Td3kK0P/EwLqTcAyxusj9+TplHGBGjG67vnq1nsjzPf+cYb7dSddEKyba1X1Q/Pi6+ej29/ualbAWj4jR0unZ6uq0qWwaKuGnBGjCTckKbGDZxwYhS9u+L9O+vGDDC38LFPzPjlgVsfq0C9UE65PUpdB9U9kNq77vPPPHRpwWpSZ5HWoC+5qY17HMRK7DMPPjdX5d3gSv9A8Za3PUt72fMV0j1FUx7r/7rXH1cmPjtCGTzdqy7Rt2vzlZvla/dSqZ5x6XdVTCf3i632ecf1l0eOL1XZUG7UenlLn8YG3DDCv4xiJXYbUMzpp4E2eKlnA8WIUEjIkJibqvPPO0/Dhw9W6dWtVVVVpyZIleu6558zkqffee0+VlZX66KOPDvta9957b03yVd++fXXnnXeqQ4cO2r59u55++mmtWbNGb775pmJjY/X4448fs8/YnPi4XK6mnAt43BQUFGjUqFFavXq1ef/JJ5/UXXfddUzee+/evUpJcZ/Yd69qq+RE8uTQeL6yuy+8Ao1pTkHX430IaIE2FtT/Qwj4X+zLI4iHxldaQAl7NC5HboHS//6EuZ6WlmaW+QaAY4nYFI6mYqd3uz2gMeQ667bdA/5XuVVUNUHj+6X88K3PgIZaWFB3kiTwv7AfsOuTiZ816dhU7d+tg0fcI5ut6cb+y8oKtHTB0Yn1TZgwwSwidM4558jPz6/eokPDhg3Tli1bzPvz5883q2Ydyni8e/fucjgcGjBggBYsWKDAQE/SbElJiU466SSz3aHFYtHGjRvVsWPHRvscLQV1wephDJ7x48fXJF8ZmX7HKvkKAAAAAAAAAAAAAAAAv4OrGSxHyfTp03X++efXm3xliImJMatgVfvsM3di3aFeeOEFM/mqujNc7eQrQ1BQkLndYOz3/PPPN+KnaDlIwKqnF+ZZZ52lRYsWmfdvueUWPfroo8f7sAAAAAAAAAAAAAAAAIDfbeTIkTXrRjvBQxlN877++mtzvUuXLho8eHC9r2Ns79zZXXHP2J9me3VRP/wQF110kWbNmmWuGy0Ir776aq1bt+6w+/v7+ys1NfUYHiEAAAAAAAAAAAAAAABwZOXl5TXr9VXK2rlzp9LT0811o83gkRiPb968Wfv27dOuXbvUrl27o3DEzRcJWIf44osvatbnzJmjXr16HXH/Nm3amAMLAAAAAAAAAAAAAAAAx46Py2UuTdXxPrb58+fXrHft2rXO4xs2bKhZNypgHUntxzdu3EgC1iFIwAIAAAAAAAAAAAAAAACOov379//mPsnJyY32fk6nU08++WTN/fPPP7/OPnv37v3d752SklKznpaW1mjH2VKQgHUI+lQCAAAAAAAAAAAAAACgMQ0aNOiY5qw8//zzWr58ubl+9tlnq3///nX2KSoqqlkPCQk54usFBwfXrBcXFzfacbYUvsf7AAAAAAAAAAAAAAAAAAA0XuvBu+++21yPi4vTK6+8Uu9+ZWVlNev+/v5HfM2AgICa9dLS0kY71paCClgAAAAAAAAAAAAAAABofpwHl6aq1rEZ1agSEhKO+luuX79eZ511lhwOh2w2m6ZOnWomYdXHeLxaRUXFEV+3vLy8Zj0wMLARj7hlIAELAAAAAAAAAAAAAAAAOIqM5Kvk5OSj+h47d+7UmDFjlJeXJz8/P02ZMkUjRow47P6hoaG/u62g3W7/3e0K/4hoQQgAAAAAAAAAAAAAAAA0Y+np6Ro9erR56+Pjo7fffluTJk064nNqJ4Tt3bv3iPumpaXVrKekpDTCEbcsVMACAAAAAAAAAAAAAABAs+PjcplLU3Wsji07O1unnnqqduzYYd5/8cUXdfnll//m87p161azvmnTpiPuW/vxrl27/k/H2xJRAQsAAAAAAAAAAAAAAABohgoKCnTaaadpw4YN5v0nn3xSf/nLX37Xc9u1a6fExERzff78+Ufcd8GCBeZtUlKS2rZt+z8fd0tDAhYAAAAAAAAAAAAAAADQzJSUlGj8+PFavXq1ef/ee+/VXXfd9bufb7QqrG5TaFS4Wrp0ab37GdurK2AZ+xvPgzcSsAAAAAAAAAAAAAAAAND8uJrBcpRUVFTorLPO0qJFi8z7t9xyix599NH/+nX+9re/yc/Pz1y/6aabVFpa6vW4cd/YbrBYLOb+qMtSzzYAAAAAAAAAAAAAAAAATdRFF12kWbNmmeujRo3S1VdfrXXr1h12f39/f6WmptbZbmy74447zNaFK1eu1LBhw8wqWh06dND27dv11FNPac2aNea+xn6dOnU6ip+q+SIBCwAAAAAAAAAAAAAAAGhGvvjii5r1OXPmqFevXkfcv02bNtq1a1e9jz322GPKzMzU22+/bSZbXXjhhXX2MRK8GlJh64+CFoQAAAAAAAAAAAAAAADAH5Svr6/eeustffvtt5o0aZISExPNilnGrXH/u+++05tvvmnuh/pRAQsAAAAAAAAAAAAAAADNkEtyudR0Hb1jcx2Fz3366aebC/57pKYBAAAAAAAAAAAAAAAAQAORgAUAAAAAAAAAAAAAAAAADUQLQgAAAAAAAAAAAAAAADQ7Pi730lQ15WND46ICFgAAAAAAAAAAAAAAAAA0EAlYAAAAAAAAAAAAAAAAANBAtCAEAAAAAAAAAAAAAABA8+NyuZemqikfGxoVFbAAAAAAAAAAAAAAAAAAoIFIwAIAAAAAAAAAAAAAAACABiIBCwAAAAAAAAAAAAAAAAAayNLQJwIAAAAAAAAAAAAAAADHi4/TvTRVTfnY0LiogAUAAAAAAAAAAAAAAAAADUQCFgAAAAAAAAAAAAAAAAA0EC0IAQAAAAAAAAAAAAAA0Py4XO6lqWrKx4ZGRQUsAAAAAAAAAAAAAAAAAGggErAAAAAAAAAAAAAAAAAAoIFoQQgAAAAAAAAAAAAAAIDmx+jw15S7/DXlY0OjogIWAAAAAAAAAAAAAAAAADQQCVgAAAAAAAAAAAAAAAAA0EAkYAEAAAAAAAAAAAAAAABAA1ka+kQAAAAAAAAAAAAAAADgePFxucylqWrKx4bGRQUsAAAAAAAAAAAAAAAAAGggErAAAAAAAAAAAAAAAAAAoIFoQQgAAAAAAAAAAAAAAIDmx2jx15Tb/DXlY0OjogIWAAAAAAAAAAAAAAAAADQQCVgAAAAAAAAAAAAAAAAA0EC0IAQAAAAAAAAAAAAAAEDzY3T4c6rpogPhHwYVsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABrI0tAnAgAAAAAAAAAAAAAAAMeLj8tlLk1VUz42NC4qYAEAAAAAAAAAAAAAAABAA5GABQAAAAAAAAAAAAAAAAANRAtCAAAAAAAAAAAAAAAAND9Gh7+m3OavCR8aGhcVsAAAAAAAAAAAAAAAAACggUjAAgAAAAAAAAAAAAAAAIAGogUhAAAAAAAAAAAAAAAAmh+j/WCTbkHYhI8NjYoErCZuWbm0o+x4HwVakh3lccf7ENAClVb5H+9DQAvkcFKoE43P6fQ53oeAlohxhcbmPN4HAAAexKbQ2FaWdDveh4AWaKM94XgfAlqgbYUxx/sQ0ALtzws73oeAFqi8wHa8DwEtjCM3/3gfAtAscWUTAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBaEAIAAAAAAAAAAAAAAKD5cR5cmqqmfGxoVFTAAgAAAAAAAAAAAAAAAIAGIgELAAAAAAAAAAAAAAAAABqIFoQAAAAAAAAAAAAAAABodnxcLnNpqprysaFxUQELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBaEAIAAAAAAAAAAAAAAKD5MVr8NeU2f0352NCoqIAFAAAAAAAAAAAAAAAAAA1EAhYAAAAAAAAAAAAAAAAANBAJWAAAAAAAAAAAAAAAAADQQJaGPhEAAAAAAAAAAAAAAAA4flySy6WmqykfGxoTFbAAAAAAAAAAAAAAAAAAoIFIwAIAAAAAAAAAAAAAAACABqIFIQAAAAAAAAAAAAAAAJofVxNvQdiUjw2NigpYAAAAAAAAAAAAAAAAANBAJGABAAAAAAAAAAAAAAAAQAPRghAAAAAAAAAAAAAAAADNj/Pg0lQ15WNDo6ICFgAAAAAAAAAAAAAAAAA0EAlYAAAAAAAAAAAAAAAAANBAJGABAAAAAAAAAAAAAAAAQANZGvpEAAAAAAAAAAAAAAAA4HjxcbnMpalqyseGxkUFLAAAAAAAAAAAAAAAAABoIBKwAAAAAAAAAAAAAAAAAKCBaEEIAAAAAAAAAAAAAACA5sdo8deU2/w15WNDo6ICFgAAAAAAAAAAAAAAAAA0EAlYAAAAAAAAAAAAAAAAANBAtCAEAAAAAAAAAAAAAABA8+N0uZemqikfGxoVFbAAAAAAAAAAAAAAAAAAoIFIwAIAAAAAAAAAAAAAAACABiIBCwAAAAAAAAAAAAAAAAAayNLQJwIAAAAAAAAAAAAAAADHjctYjP9poprwoaFxUQELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCBaEAIAAAAAAAAAAAAAAKAZcjXtFoT0IPzDoAIWAAAAAAAAAAAAAAAAADQQCVgAAAAAAAAAAAAAAAAA0EC0IAQAAAAAAAAAAAAAAEDz42riLQib8rGhUVEBCwAAAAAAAAAAAAAAAAAaiAQsAAAAAAAAAAAAAAAAAGggErAAAAAAAAAAAAAAAAAAoIEsDX0iAAAAAAAAAAAAAAAAcNw4Xe6lqWrKx4ZGRQUsAAAAAAAAAAAAAAAAAGggErAAAAAAAAAAAAAAAAAAoIFoQQgAAAAAAAAAAAAAAIDmx+V0L01VUz42NCoqYAEAAAAAAAAAAAAAAABAA5GABQAAAAAAAAAAAAAAAAANRAtCAAAAAAAAAAAAAAAAND8ul3tpqprysaFRUQELAAAAAAAAAAAAAAAAABqIBCwAAAAAAAAAAAAAAAAAaCASsOqRmZmp6dOn6/7779e4ceMUExMjHx8fc7nyyiuP9+EBAAAAAAAAAAAAAAAAaCIsx/sAmqJWrVod70P4Q3A6Xfr6/QLNmFqkPdsr5GeROnYN0PnXRmrYqcF19rcXOTX5XzlaOMOu3GyHomItOvn0EF1xS5QCg71zCYsKqvTyo9laNrdE8pFOGBmkP98bo9Bwvzqv+8gtGdqxqUJvTE+RxepzVD8zjj6Xy6V1P2Zq0Yd7lLnTrrJihyLibWo/MEojr26r6JSgmn1XT9+vX2Yd0P4tRbLnVJjtdyMTbUodGq2Trmqr8FY2r9euLK/SjBe26ZdZGaosdar9wEhNuqeL+fqHmvHCVi3/Yp/u+GaYgsKtx+Sz4+jYOn2bFj686Ij7JAyI17iXT/PaVrSvSGsn/6p9y9JVmlMq/1B/RbSLUNdzOqvd6LY1+znKq7Tq5dXaNXuXHGVViu/XSoNvH6TgVnXPgytfXq2t07bq7E/PVEBYQCN+ShxP2T9tVfq0n1W8NVNVZZXyjw5WWNcEtbt2hGxxYTX7FW7cr7SPlqlg/T5VlVYqIC5UcSO7KOWiQfIL8D7POCsc2vnWT8pasFnOMofCeyer419GKSA2tM7773xroTK+X6cBb18la2jd8xmap+JlG5U/c7nKd+6Xq7xSfhEhsqUmK+bSMbLGhMvlqFLxys2yr9yksm375MguNL8z+SfHKuzkPgofPUA+ft7fr5wVlcr5aLaKl66Xs7xSgd3aKvZP42SNDq/z/tkf/ajCOWvU5oW/yi8k8Bh+chwt++56UlU5efU+FpDaXq3uvL7mfvGilcp9Z+phXyvu79fJ1qWD17biBctUOGuhqvIKZE2KV+R54xXQyfP3slrp+i3KeuFttbrzhnofBwDgv0FsCkcDsSk0NmJTONqITeFoIDaFxkRcCr/J6XIvTVVTPjY0KhKwfkPr1q3VpUsXzZo163gfSosLRDz0lwwt+N6uxDZWnX5+mCoqXFr8g133XbdfNz8Yo7OuiKjZv7TEqb9duFfbNlRowPBAjTojRFvXl+uTN/K1dlmp/vVpkvwDPF/EHr/tgFYuLNGYs8LkkkuzvihSYW6VHnsz0es4ls61a970Yr34WTIBrhZi+jNbtODd3QqLDVD3U+JkC7YofXORln+2Vz9/t19//XCQ4ju5f+QZ97P3lKhNr3CFxgZILil9U5F++mCPVn6drj+/P0jxHUO8XnvJlDT1Ghuv4AirVny1T5P/ukY3fzJYvn6e8WO837x3dunip3oS4GoBolKj1Oea3vU+tmvObuXvyFfS4CSv7UZga/Ydc831lOHJCk0KVUVhuXK35Sl9xX6vINeKf6/Qxs82m9tsEQHa+s12/fj3OZo4ebx8a/3AzN2aq1/fX6eTHh5BgKsF/S3c+sKPyvj2F9kSIxQ7srMsgf4qz7Gr4Jc0lR8orAlyZS/cqo2PTpd8fRQzvJP8o4JVuC5dez5Yqvw1e9TrmfPk6+/5Wrfjtflm4Cz2pM6yhgcqY+Y6rf/nV+r70iVegYviHVna++lKdbnndAJcLWhcZb7+jQp/XCVrqyiFDushX1uAHHlFKt2wS46sfDPIVXkgVxnPfSIfm7+CerZXyIDOqiopl33lZmW9+a1K1mxVwl0XmxVgq2W/N0sFs1YoZEh3+YUGqXDeGu1/6mOlPHGd17gq352hvGmLFH/zOQS4WhifQJtCR59YZ7slJrLe/QP7dJM1JfE39y9Z+Yty3/tCAR3bKrBnF5WsWafMF95SwiO3yxLl+U3gLK9Q7vtfKuSkEwhyAQD+Z8SmcLQQm0JjIzaFo4XYFI4GYlM4WohLAWgOSMCqh9F6cODAgeZiVMPatWuX2rVrd7wPq0VZMMNuBrh6DLDp2fcTFWBzfzEquKNK15+Rplcez9GQU4IVn+wOEEx5Lc8McF10Q4Suuyum5nVefypbH7+ar6lv5euSP0eZ23IyHVo6p0RX3x6lS//q3hafZNU7z+cqN8s9O9FQanfqhfuyNOmycHXryxf7lqAwq1wL399tzhS89YshCgz1BJiMwNc3T282b89/tIe57bLne8saUHfm6fLP92rq/Rv0w0vbzX2qZ8UaswYHnp2k8x7ubm5r3StcU+5Zp7R1BWrT2/0lzFnl0mf3r1eXE2PUe2z8MfrkOJqiU6PM5VBVlVXaOHWTfPx81Gm8Z7ZEcUax5tw9T0GxQRr70qkKifcESg1Oh7Nm3eV0acu0bUo9o5NOvHeouS22e6wWPPiTsjfkKK5nrPs5VU799NhiJQ9NUvtT+WLfUqR/ucYMcCWc0ducAXjojC5XlXusVJVXauu/fjBngPX510UKTW1VE8zY/p85Sv/6Z+39fJVaX3SCe7vTpYwZ6xQ/tqdSbx9jbgvtkqDNT81Q0eYMhXVLrHn9rc/NUuSgtoo9ufMx/vQ4WvK/W2oGuMJPG6jYq06vZ1xVmbdG4Cv2mvEKO6mPfG3+NY87Lz9Nex98R/ZVW1S8dINCh7j/5rmcThXOWa2wUX3V6oZJ5jZbp2Qd+M8XKtu+T4GpKQdf36kDr0xTcJ9OCh3q/nuLlsM3KFARk0793fsH9u2ukGEDfnO/4oXLZYmPVdyd18vH11eho4cp/e6nZF+6RuGnj6zZr+CrmVKVQxHnjGvwZwAAoBqxKRwNxKZwNBCbwtFCbApHA7EpHC3EpQA0B95/9WB66KGHNGHCBFoRHkWLfrCbt5f8ObImwGUIj/LTuVdHqLLCpRlTC2u+xH/3SaECg3102U3ePzSN+8Z24/FqmekO8za1p2cWTude7vUD+9yPGd54JseYVKZr74g+ap8Tx1ZeeqlcTqlt3wivAJeh68nu4GhxbkXNtvoCXIZep7mDU8YMxGoleRVylDuV3N1Tcrl6PX9/Wc02I8hmlJc/659dG+1zoWnaPS9N5QXlSjkxWYHRnlk0a9/5VZX2Sg29e3CdAJfB1+I555Xll6mqvEoxXTznoZiu7vXiDPd50rBhykYV7C7U0DsHH8VPhGPJCFztfn+JbAnh9Qa4DNXbCtenqzK/VNFDO9YEuMzHfXzU9qph5vr+6b+Yfy8NlQWlZpn3kFr7Vj+vPLOoZtu+L1erJC1XnW4efRQ/KY4lo/R67tT5sraKVOxV4w4zrtx/+yzRYYo4bZBXgMtg3I+c4A66l67fVbO9qqhErkqHAtp7Zo3ZOrjXHdkFXkG2yvRsxV47/ih8QrRUjtwC+ackmEEugyU6Ur4hwarKza/Zp3xnmopmL1bkJWfJN5AL1ACA/x2xKRwNxKZwLBGbwv+C2BSOBmJTaI6IS7UQxt+gpr7gD4EKWDgujNl+hoSUuiWwEw7OLFyzuFRX3Srt3Vmp7ANVGjgiSIFB3l/WjPs9+gdqxYISZaZXKi7RqrhE97A2ysAPOsndp37runLztlWS+7ENa8r09fsFevSNBAUGk4fYUsS0CZKf1Ue71uSrrNghW4jnFLdxXrZ522nwbwc1N87PMm/jO3kCFEGR/rIE+Grfxlo/EA+uRyS4v2zl7ivVrP9s1+m3dVJEPF/AWrot07aYt50npdZsM4IMu2bvVkB4gBIHJih7Y44yVmeY241y8YkDjC/xnpLJtgib/AL8lLMlt2Zbzmb3eki8+/xVlF6s1a//rAF/7a/gVu5taP7yVu6Wo6hMrU7rbs7Kylm8XSV7c2UJsSmyX2sFJnnKIFfkuQPuRkDsUMb+llCbWRK+bH+BAhMjzLLuRsn34m2ZNfsVHVwPiHO3uSjLKNCuyYvV/trhCoh1b0PzV/LLdjntpQob2cecbWpfuUEV6TnyDbaZpdz9E37nhb2DwbHaQTKjrLuP1aLynftrtpUdXLfEuMdmZWaecj6Zq5hLR8saXXe8ovlzORwqXrRSVfmFZrDJv22yAtq3Puz+FXvSVVi8wCjXIL/oSNm6dZRfSN2/ZZaocFWk7TdnsxrBLkdOnpzFdvkdLPNuzI7Nffdzc+ZiUJ9uR/UzAgD+OIhN4WggNoVjidgU/hfEpnA0EJvC0URcCkBzQAIWjgtjNqFhf1ql2nT0zm7fv7fSvDWCW+btLvdtctu6AbHq7SsWuPczglzRcRadMDJIk1/I1f49DjOhdNaXhRp6SpBZ4t1R6dKz92Tq5PEhGjKKH4wtSXCEv06/NVXTn9msZyYsUrdRsbIFW5S+uUjbl+VqyIUpGnqxuwxtbWu/z9CB7cWqKHWat1sW5SgqOVCn/dVTutvX10cDz0rS0k/SVG53KDjCqpVfpSupa6hSeri/yH/+4AYldA7V0IvqvgdaluL9xdq/IkPBcUFKGuKZcWMEpMoLy82ZgoueWKLNX7oDYdWiO0dp9LOjaoJVRsCr08SO2vT5ZnNmohEc2/rtNnO/mG7uH6OLn1iiqE6R6nouZbhbkuKtB2rGwKrr3lPp3jzPg74+Sj6nn9pff7J51xrmnsVqBLEO5SguN4NlBuM1jCCX8ZqtxnbX/m/WqqqkQtYwmw7MWq+QjnEK7eyeRb31+R8U0iFWCWf0ORYfF8dI+fZ089YIFOy5/WVV7s/xPOjjo4gJQxR7+Wm/+TqFc9eYt0G9PX8Hjdc0SrwXzFopZ2mF/EIDVTjvZwW0S5CtQ5K5T+br3yigbSuFnzao8T8cmgRnQZFy35nqtc0IdkVfd7GscXWDqMWzF3nd9/G3KnziaIWNc5/fqoUMH6TsVz9U5jOvy79dskpWrzf3DR7c13y88Pv55qzDuFuvPiqfCwDwx0RsCkcDsSkcK8Sm8L8iNoWjgdgUjibiUgCaAxKwcFwMOilIc74p1sev5Knf0ED5B7iz2AvyqvT52+6SjsVF7j7Q9iJ3n/Hg0PpnAwaF+HrtZ/jH/7XSS49ka9GPdqMtuUZPCtWf73OX+f7wlTzlHHDouQ8SzdmO/3dvlpbPL1GAzUfjzgvT9fdEy8/PMwsIzcuIK9oovFWApt6/Xks/2VuzvV2/CPUdHy+/WiW2awe5fv0h06t8+yXP9lJUcpDXfhPvSJWfxUe/zDqgyrIqdRoarUn3dJGvn49Wfp2u7StydetnQ1RRUqUvH9ukX2e5f8T2HNNKZ9/XRf5BnHJbii3fbDNn8HSc0FG+tWbhlOW6gw3GrMH83QUafv8wtR6RooriSq2d/Iu2fLVVc+6Zp4lve8ofD7p5gFn6fdfsXXKUVylpUKIG3z7IfN2t327X/tUZmvT+RDlKHVryzDLtmrPbfF7bUW005M4TZA2s/wIAmrbKfPfMwb2frVJop1bq+59LFNQmypwZuOX5H7R36irZEiKUeEYfhfdIlF+Qv3IWbzODYyGdPOXbd73r+RHpKPa0nGh//Unytfgpa/4Ws+R7RP82NeXkjYBX/i971e/Vy+Qsq9S2F+coa4E7IBs7IlUdbzpFfoyrZslR6G4PkTd9iRl8SnniOvknxah8V4YOvDZN+d8sNkvAG+XdD6fgh5UqWbNVgT3aKbifZxa1Ieay08wy8UVL1stV4VBQrw6K/ZO7nHzh/J/NsvApT98gV1mFDrz1nYqXbjCfFzK4m+KuGV+npDyal5Bh/RXQqZ2sSfHyCfCX40C2Cn9YqJIlq5X53BtKeOhW+drcrZUsMVGKvHiSbN1T5RcZLqe9ROWbtiv/ixnK/3yGGcQKPcXdpsIQNKCXIi8tUdEPC1U8f5n5HjFXXyBLVIQqM7JUOH22+Xp+4aEq+G6uin78yXzNgI5tFXX5ObK2cn/PBwDgv0FsCkcLsSkcC8Sm8L8iNoWjgdgUjhbiUvhdaPOHJoBfXMfB3r2eH9712b/fUz6zpTKCTjM/L9KaJaX609g0DRoRJIfDpZ9m2RUZ41fTP7yhwiL8dM9znh8B1XZvq9CHL+XptsdiFRlj0R2X71Pa9ko98J945WQ69J+Hs833v+gGT3ldNC8/vLxds1/boTF/7ah+ExMUGGpR+qYiTXtqs169aqUuf763uo+K83rO5S+4Z9mUFlaapdu///dW/ev8pbrihd7qWKssvNXmZwa1jKW24twKffP0Zo26tp1adQzRZw9u0Ia5mTr3wW4yoqxfPrpR/jZfnX0/pUlbAiO4tXX6NvPfNnViR+/HDn65c1W51P/6vuo0wf14QFiATvzHUOVty1PWumxl/HxA8X3c5yiLzaLBtw0yl9pK88q0/IUV6nVFT0W2jzBnLe5ZkKZh9wwx33vJ08vM5w69a/Ax++xo3HFk8LX6qdtDkxQQ424rEd4zWd3+OVGrrn/PDIAZQS6/QH+1v/FkbX1ultbc/LEZiPKPClLh+nQVbc1UYOsole7JNWeRVfMLsKrDn0eaS20V+SXa/uo8pVw4SMFtos2AmhE8S731VHNcbfv3bPkGWNTpltHH+L8IGsXBceVj8VPinRfKEhVm3g/s2kYJt52vPX9/RfnfLDlskKt41WZlvvWdLLERir/5nDqP+wZYFXvVOHOpzVFgV9a7MxV51nAFpMSZATX7yk2Ku36i+X0u883pyg6wKu7aCUflY+PYCD/jVK/7/q0TzWCU0UjHCHYVL1imsDEjzMdsndubSzVf/3BZhvSTtXWiDjz6ogqm/aiQkwebQdNqoScPNpdD/67mvveF/Nu3VvCJA2Vf9rMKvpyp8EmnmjMcjaBZ9kvvKf7Bv5kzYQEAvx+xKWJTOHqITeFoIzaFxkBsCkcFsSkcJcSlADQXnA2Og5SUlCMugwa1/NKYxkytJ99J1JV/izKq2Wr6lAItnGnXsFOD9dDL7hK0kdF+XrMLa88irK2k+MizEGv/oTTKu/caaNPYc8O0Z3uFVi4s1TV3Rpvve8Yl4RpzVqg+OzjLEc3PliU5mvXSdg29uLUZcIqItykg2KJ2/SN11Ut9zXE3/Rnvstu1BYZZ1fGEKF3zWn9ZA3w15R/rVFVZ/7ir7esnNik02l+jrm2vMrtDK77cp5Ouaqu+ExLUd3yCTrqyrZZ/vs8sD4/mL315uuwZdiUMSFBoUqjXY/7BnplZKSPqlvtPOdG9LWdjrdLLh7HsueUKjLKp91U9zRLwW6ZtVc9Lu6vD2PbqcFp79biku7Z8vVWVJe5WGGheLMHu2Tghqa1qAlzVgtvFyJYQrrL0/JqZgwnjeqrH42crrFuiGZRKn7bWDGT0evpcs7S7wT/Se2Z0fba/NFf+kcFqffEJcpRU6MD365R8/kDFndJVcaO6Kvm8AcqY8auqSiuOyufG0eUb5B5XAR0SawJc1QJatzJnGFYeyFWVvbTOc+2rtyjjuU9liQhW8gNXyBLpfX47kqx3ZsgSHqyos4bLWVpulomPPGOYwob3UuiJPRU5cagKZq82H0PLEzriBPO2fJt7FvyR+CfFm7MDjVmClfs9FR4Ox75guSp27jFnExoB06LZP8nWtaPCJ5yiwB6dFXXxmapMP6CyDVsb5bMAwB8JsSliUzg6iE3hWCA2hcZAbApHA7EpHGvEpQA0NVTAwnHjH+CjK26JMpfafl7qLn2b2sv9RS25rftH495d9f+Qq95evd/hfP1BobatL9db37c27xtBLkPHbu73Mde7B+jbTwpVXFilkDBP5jOah80LjVx3qeOgurNEw2IDFNcu2JxFaASbjODX4dhCLGrdO0LrZ2cqe0+JWnXw/gFa28YFWWaZ+D+/N0gWf19l7rDL6XApsYvnx0Fi11BVOVzKSSv12o7mafPX7i/TnSd1qvNYaHKYfPx8zFmGASF1yxn7h7q3GeXcjyRt0V7t/HGXTn99rPysfsrfWWC+ZlSq53wZ3TlKTodThXuLFF1rO5qHwBT3ecoS4vkbVF8QrKrcIcvBU1DUoHbmcqhNT82QccUopGPd2fW15S7boaz5m9X7+QvM2Y0le3LkqnIqpENszT4hHePkcjhVmp6vkA7eM7LR9Bkl3Q1+QbZ6H/cNdm83SrQr2LPdvmqL9j/3ifxCg5T0wJWytvr95xQjOFa8eJ2SH/mTfKwWVezLlqqcCmjrvmhpMErOq6pKlQfyvLajZfANdQ8mV3lFo+5flV+ovM++U9jE0TWl3CszshUy3JMQYMxcdG/PMgNfAAD8t4hNobERm8KxQGwKjYHYFI4GYlM41ohLAWhqSMA6DtLS0n6zzPsfYabh4fz4VbF5O2qCOxiQ3M6qmFZ+WreqVKUlTgUGeWYTGveN7QkpFsUlHj7IlZXh0JvP5JizGhNbe+9XWeGqs/6/lJjH8VM9I7A4r/6AaHFehXx8JT/rbxf/K8x0z+zxsxx+XyNY9sXDGzXkghS17eue5VPNUeGsu86wavbK8svMUutG2fY2J7sD5rVZAvwU1zNWB37OVN7O/JpS7tXyd7pnMYck1Pp1eQhj1uDip5aqyzmpatXLO8hQVVFVZ53TVfMU0cc9fkqM8uyHcDqqzBmGvjar/COOPHOwYN0+lWcUmsGvwwXMDMaswa3/+lGJE3srvHuS9/tVVtVdZ2A1S4Hd3UHQin1ZdR5zOapUmZErnwB/+YUF1Qlw+YYEKunBK+Wf4Glv8luMWYOZb0xX+JiBCuzsfU501RpXNesMqxapfMce89YS89ttklxOpyp2uVteWaKPvH/uh1+Zrxl22gjv13DUqtpwcN2HwQUA/zViU0dGbAoNRWwKRxuxKTQWYlM4GohN4VgjLoUaRhvmg62Ym6SmfGxoVLQgPA6Sk5OPuCQkJOiPoL6y7fO/K9aMqYXq0itAw8cG1wScTr8gTKV2l95/0fvHgHHf2D7+Qu9Spod64Z9ZSmxj1blXewIRrTu4Z/ssm2uv2WasGwG13yoZj6apOtC04N1dKi3yDnQt+SRNBRnlatM7wpwNaJRjz9zp+bevbfkX+5T2a6Fi2gSZy+HM+Nc2s33AuFs9s82iUwLNcvKbFrhnPBqMdT+rj2JSAhvhU+J42j5jh5yVTnUY115+/vXPRO5yjnumw5o31noFpfJ3FWjb9O2yBluVPMQ7yFDbqpdXS06XBvy5f822sORQ+Vp8tXfxvpptxrqv1VehycxcbY6M0uyR/duobF++9n/3i9djaVOWy1FcrpgTO8rHz/33yGGvWx67PLtYW/5vlrlPm6uGHfH9dr71k3m+anv1cK9j8LH4KnfZzpptxrqP1U+BCd6BezQP/vFRCurdwQxmFcxe5fVY7lcL5bSXKWRQF/n4uc9f9jVb3QGuYJuSH/jvAlyG7I9nmz8cYy4ZXbPNKCUvPz/Z13jaqhjrRluC/2b2IpoWoyy7s56Zgcb2/M9nmOtBJ/Sp2V4dzDo0yGXs68jMUUCXDvKLOPz395JV61S6dqOirji3ZrwarAmxKlu/Ra4q99/X0l83m7eWBM9saQDA70Nsyo3YFBobsSkcbcSm0FiITeFoIDaFo4G4FIDmhApYOG7+fFaa4hIsat3R3yz5vmltuX5eWqrE1hY98FK8/Pw8GcMXXh+pRT/Y9fGr+dq6vlypPQK0ZV25Vi4sNQNi5/7p8F/G504v0rJ5dr3yVYrXaxpBrkEnBWnyv3KVsc+h3EyHVi0q1Y3/+O++4KHp6HVavJZ8slc7Vubp6fGL1O3kWAWGWbRvQ5G2LcuV1eariXe6AxAl+ZV6duIiJXcPU2z7YIXH2VRaWKm0dQXm/kap9wse73HY99q9Nl+LP96jK//dR7ZaJeON8vEDz0nS0k/2qrLM/SVszbcZGnZxivyDOOU2d1umuUu8p9ZT4r1a+zHttHvuHu2as1tfXTJNSYOTVFFcoV1zd5tBrxEPnmjOUqxP5q9Z2vjZZp3yzEgzGFbNGmRV6hkdtemLLXKUuWdV7Ji5U13P6yJr4JFbXKDp6njLaP1888fa+n8/KGfRdgW1jlTxtizlr9mjgFZhan/dSTX77vtyjTJnb1B4jyRZI4JUnlWknMXbVVVWqdS/n6bQTocv8V64IV3p035W94cmyRLkaT/gF+iv+LE9tX/6WlWVuy8MZM3ZpMRJfeTHuGq2Yq+ZoL33vanMV6epePkms/R7+c79Kl23U5bYCMVcNqZmJuL+Z6bIVelQYPe2Klr0a53XssZGKGxk33rfp3RLmgq+X66EOy+Sb6DnnGash4/qq4IfVsp1cFwV/fSrwscOkq+tbvsLNA/25WtV9MNCBaS2M2cI+vj7y3Egyx1oqqpS2OkjZUttX7N/xqMvypqcIGtyvCwR4aoqKVH55h1yHMiWX2S4oq8457Dv5SwpVd5HXyn0lGEKaJvs9VjoKScq5/WPlPns67KmJMq+aKWsSfGyde14VD8/AKDlIjaFxkZsCkcbsSk0JmJTOBqITaGxEZcC0JzwiwvHzcgJIVr4vV0bfi6Uo1JmqfbL/hqpC66LrDPLzyjt/sKUJL37r1wt+N5uBsOiYy06/5oIXXFLlAJs9c8KLCqo0osPZeu8qyPUqXvdH5V3Pxun5/+ZpdlfF8nf5qMLr4/wmomI5sXXz0fXvtFfC97drV9mZmjNd/tVVelSaLS/+k1M0Khr26lVB3fD+pBIq065ob12rMjT1sU5ZtDLKP8emWTT8MvbaMQVbRQRbztsOfnPHtigXmNaqdvIun3oJ/491XzfX2cdMO8POidJ429PPcqfHkdb1vos5W3PV0z3GEV1PHx5WmNm9MmPjtCGTzdqy7Rt2vzlZvla/dSqZ5x6XdVTCf3q7zHvdDi16PHFajuqjVoPT6nz+MBbBphjzwieGVLP6KSBN3lmIqL5MWb59X35Eu1+d7HyVuxS3qpd8o8MNoNMrS8dIv9IzyznsO6JKvglTTlLdshRXCZrWKBZ2j3lgoEKOUKAyygZv+X/flDs8E6KHtKhzuPtrz/J3Cd7gXtGWPy4Hmp3nXdZZTS/mYYpT16vnE/mqOTnbSr5f/buA0yuqmwA8NkkpIcSEpJAQu9VOkgH6SBFRVGqNFEpgoJIbyIiUhVBOii9iXSQ3vtPb4FAgAQSSEI6SfZ/voszTjZbZ2dnZnffl2fInZ07d87M3Lkz57vf+c7L76Vu8/ZN82y5Vur/g41St3m++R6cMW5iFuAKEx9/td5t9Vp+0XqDXFEyPoJofddZPvVd45uTR4UG7LFlts7Ep17Prs+96WppwG7fBNdon3ouu0Sa8elnafpHn6Rp77yfaqd/nbr07ZN6rbRM6rvJuqnXCrP/zum3xQZp+vCP0tTX30mzJk3JRpl2W2D+NPd2m6a5N98gdenTcBWHL2+8M6W55krz7DjnPtNnrVXSzC/Gpa/ufyxNe39k6rnUoqn/Hjunmi4qhABQHLEpSk1sirYkNkWpiU3RFsSmKDVxKZpl1qyUauascFxV7aNTqKmNmp806oMPPkiLLfbNvMV77rlnuvzyy9v08UaOHJmGDfumg3P9E4umgUPkyVE6z03+XxY4lMobkzrH9BSU17sTBlS6CXRAn37Z+NQwUIxp4+s/MQbFmvHFuPTJEadlyx999FE2HRhAOYlN0ZbEpmgLYlO0BbEp2oLYFG1BbIrOGJsq7LduPHCP1LPrNwme1WjqzInpoc+vrOrXk9KQkgkAAAAAAAAAAFAkw9cAAAAAAAAAAGh/YtK3ap74rZrbRklJwKrHY489lt5999389TFjxuSX4+91pyDca6+9yto+AAAAAAAAAACgOkjAqsfFF1+crrjiinpve/zxx7NLIQlYAAAAAAAAAADQOUnAAgAAAAAAAACg/TEFIVWiS6UbUI1iisHa2tpmXwAAAAAAAAAAgM5JAhYAAAAAAAAAAECRJGABAAAAAAAAAAAUqVuxdwQAAAAAAAAAgIqZVZtSTW2q6vbRKaiABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEUyBSEAAAAAAAAAAO1Obe2s7FKtqrltlJYKWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkUxACAAAAAAAAAND+1KaUZsX/qlQVN43SUgELAAAAAAAAAACgSBKwAAAAAAAAAAAAiiQBCwAAAAAAAAAAoEjdir0jAAAAAAAAAABUTG3tN5dqVc1to6RUwAIAAAAAAAAAACiSBCwAAAAAAAAAAIAimYIQAAAAAAAAAID2Z9as+F+q7vbRGaiABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEUyBSEAAAAAAAAAAO1Pbe03l2pVzW2jpFTAAgAAAAAAAAAAKJIELAAAAAAAAAAAgCJJwAIAAAAAAAAAAChSt2LvCAAAAAAAAAAAlVI7a1aqTbNSNbePzkEFLAAAAAAAAAAAgCJJwAIAAAAAAAAAACiSKQgBAAAAAAAAAGh/amu/uVSram4bJaUCFgAAAAAAAAAAQJEkYAEAAAAAAAAAABTJFIQAAAAAAAAAALQ/McXfrCqe5s8UhJ2GClgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARepW7B0BAAAAAAAAAKBiamtTSrNSdbePzkAFLAAAAAAAAAAAgCJJwAIAAAAAAAAAACiSKQgBAAAAAAAAAGh3amfVptqa6p3mr9YUhJ2GClgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAC0P7Wzqv9SJiNGjEiHH354WnbZZVOfPn1S//7905prrpnOOOOMNHny5LK1o7PqVukGAAAAAAAAAAAAxbn99tvTbrvtliZMmJD/WyRdPffcc9nl4osvTnfccUdacsklK9rOjkwFLAAAAAAAAAAAaIdefPHF9MMf/jBLvurbt2869dRT0xNPPJEeeOCBtN9++2XrvP3222nbbbdNX331VaWb22GpgAUAAAAAAAAAAO3QIYcckqZMmZK6deuW7r333rTuuuvmb9t0003TUkstlY444ogsCevMM89MJ5xwQkXb21GpgAUAAAAAAAAAQLtTO6u26i9t6ZlnnkmPPvpotrzPPvvMlnyVc/jhh6flllsuWz7nnHPS119/3aZt6qwkYAEAAAAAAAAAQDtz66235pf33nvvetfp0qVL2mOPPbLlcePGpQcffLBs7etMJGABAAAAAAAAAEA789hjj2X/9unTJ62++uoNrrfRRhvllx9//PGytK2z6VbpBgAAAAAAAAAAQIvVzkopxaWa29d23njjjezfJZdcMnXr1nAK0LLLLjvHfSgtCVhVaMaMGfnlsZ/9bxlKYdyUqZVuAh3QpMmTKt0EOqBpE3tUugl0QF+Pb9u51umcZkzw+4rSmjluQr39Q4ByEZuiLYlN0RbEpmgLYlO0BbEp2oLYFJ09NjUtTU2ptsrb91+ffvppk+sPHTq02dueOnVqGjNmTLPuN99882VVsiZNmpQ++uijZj8GzScBqwp9/vnn+eUDdxxZ0bbQEX1Q6QYAAAAt6B8uuuiilW4G0MmITdG2xKYAAKC9aA+xqWfTf1J7sdZaazW5Tm1t87PJvvrqq/xy3759m1w/l4A1ceLEZj8GzdelBesCAAAAAAAAAAAVFhWwcrp3797k+j16fFPhc8qUKW3ars5KBawqtNJKK6VnnnkmWx44cGCj83R2dlGiL5clGq/ZkCFDKt0kOgD7FW3FvkVbsF/RFuxXtAX7VfNFafdc9ZnoHwKUm9hU8/l+oy3Yr2gL9ivagv2KtmC/oi3YrzpebGrw4MHtbhq92A9L3cfu2bNnfnn69OlNrj9t2rTs3169epWsDfyP6EkVig/JmmuuWelmtDvxRdmS+VChOexXtBX7Fm3BfkVbsF/RFuxXTav20u5AxyY2VRzfb7QF+xVtwX5FW7Bf0RbsV7QF+1XHiE1FElN7ex/bor39+vXLLzdnWsGYfrC50xXScqYgBAAAAAAAAACAdjaAav7558+WR44c2ei6X375ZT4Ba9iwYWVpX2cjAQsAAAAAAAAAANqZ5ZdfPvv33XffzaaPbMibb76ZX15uueXK0rbORgIWAAAAAAAAAAC0M+uvv372b1S3ev755xtc7+GHH84vr7feemVpW2cjAQsAAAAAAAAAANqZHXfcMb982WWX1bvOrFmz0pVXXpktzzvvvGmTTTYpW/s6EwlYAAAAAAAAAADQzqy11lppgw02yJYvueSS9OSTT86xzplnnpneeOONbPmQQw5Jc801V9nb2Rl0q3QDAAAAAAAAAACAljvnnHOyaQWnTJmStthii/S73/0uq3IV16+99tp00UUXZestvfTS6fDDD690czssCVgAAAAAAAAAANAOrbrqqum6665Lu+22W5owYUKWgFVXJF/dcccdqV+/fhVpY2dQU1tbW1vpRgAAAAAAAAAAAMUZMWJEVg0rEq1GjhyZunfvnpZccsn0gx/8IP3yl79MvXv3rnQTOzQJWAAAAAAAAAAAAEXqUuwdAQAAAAAAAAAAOjsJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVi0O88991w66aST0hZbbJGGDh2aevTokfr27ZuWXnrptPfee6fHHnus0k2kAznyyCNTTU1N/vLQQw9Vukm0Q9OnT08XX3xx2nLLLdOQIUPyx61lllkmO2498cQTlW4iVeKzzz5L//73v9Nxxx2Xtt566zRgwID88WevvfYqapv3339/dt8ll1wy9enTJ80zzzzZd+b3v//9dMEFF6SJEyeW/HlQPSZMmJCuvfbadPjhh6eNNtoo2w9iH+jevXtaYIEF0sYbb5z++Mc/prFjxza4ja+//jrdfffd6Ve/+lX69re/ne2Xc801V5p33nnTaqutln7zm9+k4cOHl/V5UX0+/PDDdPzxx6c11lgjDRw4MPXs2TMNGzYsbbDBBtkx7dVXX232tiZPnpwWX3zx/PFv0UUXbdO2A0BLiEtRbmJTtJa4FC0hNkWpiU1RLmJTQDWoqa2tra10I6C5Ntxww/Too482ud4ee+yR/v73v2c/4KBYL730UlpzzTXTjBkz8n978MEHsw4BNNeIESPStttum1577bVG1zvooIPSOeeck/2Yp/Nq7P3fc8890+WXX97sbX355ZdZIPW2225rdL0XX3wxfetb32pRO2k/Isi5+eabN7leBK6uvvrqLCBf6PPPP0/LLbdco0GwEL+5Ilh2yCGHtLrNtD/nnXdeOuqoo9KkSZMaXCf2jbPPPrtZ2/v1r3+dzjzzzPz1RRZZJH3wwQclaSsAtIa4FOUmNkVriUvRUmJTlJrYFOUgNgVUi26VbgC0xCeffJL9u+CCC6Yf/OAHWdbywgsvnGbOnJmefPLJ7Mvw448/TldeeWWWEf/Pf/6z0k2mnZo1a1baf//9swBXjMKIkT/QUnEcKgxyrbzyyumwww7LRhh+9dVX2cjoOG5FpyA6CHFs++1vf1vpZlMl4vtt2WWXTffee2+L7zt+/PgssPH8889n13faaadsVOESSyyRunbtmj766KP08MMPp5tuuqkNWk61iZFem2yySVp99dWz5RjxHN9zI0eOTDfeeGO6+eab05gxY9J3v/vd9Mwzz6RVVlklf99p06blA1wRDN1hhx3S2muvnQYNGpTtZ3fddVd2/Jo6dWo69NBDU69evbLvTzqPU045JR177LHZcoxg3m+//bKThDGaNfadCKTfcsstqUuX5hVfjvUjGBajFGM0a3xfAkC1EJeinMSmaC1xKVpLbIpSEZuiLYlNAVUlKmBBe7HtttvWXnfddbUzZsyo9/bPP/+8dumll46qbtnl4YcfLnsb6RjOOuusbB9adtlla4866qj8PvXggw9Wumm0IzfccEN+31l33XXrPXY999xztXPNNVe2zrzzzlv79ddfV6StVIfjjjuu9vbbb68dNWpUdv3999/P70N77rlns7ez++67Z/fp0aNH7W233dbgerNmzbLPdXAN/WYqdMstt+T3s5122mm220aOHFm7+eab1z755JMN3v+pp56q7dWrV3b/eeaZp3bChAklaTvV7/7778/vO3vssUft9OnTG1x32rRpzdpfV1999Wx7J510Uu0iiyySLce/AFANxKUoJ7EpWktcimKITVFqYlO0JbEpoNo0L9UTqkTMPb7LLrtkIyQaKlFaWBIyMuehmHmic9nyf/vb30wZQNGeeOKJ/HKUv63v2BWjfrbbbrtsedy4cemNN94oaxupLieeeGK2P8QIrmLFCNarrroqP/onRo41Vla+WzcFUTuyhn4zFdpxxx2zEdCh7pQ6Cy20UDbSdZ111mnw/jHq8Oc//3m2HCMP77vvvla3m+oXI1UPPPDAbDlGpl5yySXZqMCGNOf3VEx5EqOjY3888sgjS9peACgFcSnKRWyKUhCXohhiU5Sa2BRtRWwKqEYSsOhwooxpznvvvVfRttA+/eIXv0gTJ07M5rTfaKONKt0c2rHp06fnlxdffPEG14vS2/XdB4px/vnnZ/9GieVf/vKXlW4O7US/fv2yf6NcezH8/up8Ivj5zjvvZMsRkGptwHzEiBHpuOOOy5adZASgPfO7iFIQm6IUxKWoFLEpiiE2RUuJTQHVSAIWHU7MB92SzHoodP3112cjWvv375/+9Kc/Vbo5tHO5UTth+PDhDa6X6xDGiK+lllqqLG2jY4pA6W233ZYtb7755tk89WHmzJnpo48+Sh988EHRQQw6rrfeeiu99NJL2fKyyy5b1Db8/up8brjhhvx3V27EfPjiiy+y4Ff82xIxUnXSpElp9913TxtvvHHJ2wsA5eJ3Ea0lNkWpiEtRCWJTFENsimKITQHVSAIWHc7DDz+cX15uueUq2hbalyizfcghh2TLp59+ejZ1ALTGrrvumuaee+78PhWBhrpefPHFdMcdd2TLP/7xj/PrQzFefvnlfBBrpZVWShMmTEiHHnpodjxbeOGF02KLLZaNPowA2EMPPVTp5lJBkydPzgIRf/7zn7MR9TNmzMj+HvtLMfz+6nyeeuqp7N9FF100G6X6z3/+MzvuzD///GnppZfO/o0TPnHSsDAIWp9rr7023XnnnWm++eabbdomAGiP/C6iNcSmKCVxKSpBbIrmEpuitcSmgGokAYsON9/vH/7wh/z1XXbZpaLtoX054ogj0qhRo9J6662X9tlnn0o3hw4gAgtXXXVV6t27d3r88cfTmmuuma688sqsY3D//fenE088Metcxsiw1VZbzQ97Wu3111+f7TtxjTXWyOatjyB+Tuxvsf9tuummWQCWzuPyyy/PRoTFpU+fPlkg4vDDD0+jR4/Obv/tb3+bBdxb6tNPP02XXXZZtjxw4MDZSr7TMcXx5c0338x/18VJwp/85Cfp1VdfnW29t99+O/3mN7/JjjeFx6FCX375ZT64Gr/jYx8CgPZKXIrWEpuilMSlqASxKRojNkWpiE0B1UoCFh3KWWedlZ555plseeedd06rr756pZtEO/Hoo4+miy++OJsjOuZ2jg4AlMJ3v/vd9Pzzz6d99903K6O85557pnXXXTcb5XXCCSdkQbCzzz472wcHDRpU6ebSzhWWVY4AVowi22qrrbLvxhh9+Nlnn6ULLrggG2lYW1ubBTVyZeHpvL71rW9l+8hpp53W4u+/2I8OOOCA9NVXX2XXjz322Pz0AnRc48ePzwJd4ZVXXknnnntuGjJkSLr66quz41CMYo2Rp+uss062zhNPPJF++tOf1rutCIJFoDW+G/fbb7+yPg8AKDVxKVpDbIq2IC5FuYlNUQyxKVpKbAqoVhKw6DDiizR+rIcFFlgg+xEPzREjbvbff//sh/qvfvWrtOKKK1a6SXSw/StGF0YgIfaxuuKHfXQKYtQXtFbMUZ8TQa0IqP773//ORrn26NEjG73zs5/9LPtbly7f/Aw86qij6t036Xh23HHHLCARlwhqXXPNNWmnnXbKgvAxNUXsFy31+9//Pt1+++3Zcowu/MUvftEGLafajzVx0ubBBx/MRhpGqfZevXqlDTfcMP3nP/9Jq6yySrbeLbfckp5++unZtvPII4+kSy+91ElGADoEcSlaQ2yKtiIuRbmJTdEYsSlKRWwKqFYSsOgQXnvttexHWswRHZntN9xwQxbsgub+QI9SpTEH/fHHH1/p5tDBOgHf+c53spE7MeoiphJ44403svnGY4TGvffem9Zff/303HPPZZ3PmO8eWqPu6K4Yadi1a9c51ov9Lkbkh9gnI+hBxzfvvPNmJ3LiEoHPH/3oR+nmm2/OgvHDhw9PO+ywQ1YKvrn+8Y9/ZKMKw2KLLZb++c9/5oOndK5jTYymX2aZZeZYL4Jdp556av76ddddl1+O78LcScYoE7/yyiu3casBoO2IS9FaYlO0BXEpKkFsisaITVEqYlNAtfItRLv3/vvvpy222CKbozd+yF977bVZVjM0RwS3IggRzjvvvGzecSiVKOUeJdzDJZdckgUcll122dS9e/c099xzZyPAYlRGjMyJH/lR6vbll1+udLNpx/r165dfjhGFq666aoPrbrnllvnlZ599ts3bRvXafffd0w9+8IOsbPcvf/nL2aYLaMgdd9yR9t577+zYNXjw4HTfffdl/9L5jjUhfos3ZLPNNstGEdY91kTw66233krDhg1LJ554Yhu2FgDalrgUrSU2RVsRl6ISxKYohtgULSU2BVSrb4420E598skn2Sie+DfKQkaZyMiQh+Y666yzslLciy++eDYndARK63r11Vfzy1GudNSoUdny9ttvLyhGg6LjF8eksPTSS6c999yz3vXih//JJ5+cjfqKDmaM8In9EooRncWcoUOHNnvdzz//vE3bRfWL30/XX399NkL67rvvTj/+8Y8bXPehhx5K3//+99PXX3+dlfS+55570hJLLFHW9lJZuWkjcseOwuNJfSMSBwwYkP1+KjzWxMmfEL/lc1MFNFROPv7N/UaLaiKbbrppSZ8PABRLXIpSEJuiLYhLUSliUxRLbIqWEJsCqpUELNqtMWPGZKN0oixpboTYHnvsUelm0c5EidEQ+1HMMd6UCEgUjnIV5KIho0ePzo/UaWykV1h99dVnG/kKxVphhRXyyzNnzmx03cLbcyOA6LwiYJEzYsSIBtd75plnspM8U6dOTX379k133XWX8tyd+HgTAc+WHG8KjzVxkjFcdtll2aWp3/2532kbbbSRIBcAVUFcilIRm6ItiEtRKWJTFEtsipYSmwKqkSkIaZdijvooT/v6669n1//whz+kX/ziF5VuFkBe4Q/5GTNmNLpujNSp737QUossskhaeOGFs+UPPvggG/HakPfeey+/vNBCC5WlfVSvjz/+OL8cwav6/N///V/aaqut0sSJE7ORYzEybO211y5jK6kmhVMr5U4812fChAlZkCo41gDQUYhLAdVOXIpKEZuiWGJTtJTYFFCNJGDR7kQp7m233Ta98MIL2fWjjz46HXnkkZVuFu1UlNWOTmBjl+OPPz6//oMPPpj/+6KLLlrRtlPd+vfvn+aee+5s+cknn2w02PXwww/nlxdbbLGytI+O63vf+16+Y/nAAw80uN7NN9+cX46pBujcbrjhhvzySiutNMftb7/9dtpiiy3Sl19+meaaa6500003pY033rjMraQajzXhlltuaXC9uC0XcN9ggw3yf2/q91dcInAf4t/c33IjGwGgUsSlKDWxKdqCuBSVJDZFMcSmaCmxKaAaScCiXYlykDvttFN6/PHHs+uHHHJIOuWUUyrdLIA5dOnSJQvKh08++SSdeuqp9a4XHcbCYP12221XtjbSMR166KHZCLBw2GGHZcGuuq6++up8RzH202HDhpW9nZTvZE6UZG/MWWedle688858sL0wEBE+/PDD9J3vfCebwqJr167pn//8Z9pmm23atN1Uvyjvv/XWW2fL11xzTb1B9VGjRqVjjjkmW+7evXvae++9y95OACglcSmgvRCXopLEpigkNkVbEZsCqpF6srQrMb/uvffemy3H/Lr77LNPevXVVxtcP75Ml1566TK2EOB/jjvuuHTbbbdlI6RPOOGE9Pzzz6c999wzLb744lmn86mnnkpnn3121oEMm222WTaKh87rscceS++++27+eq40coi/R8Ci0F577TXHNqLM+0knnZSOOOKI9Morr6S11lorC6ZGhzQCXjG68IILLsjWjdGwEeCg44pjz+GHH56NCIvRpEsssURWxv2rr77K9o9//OMf+ROI8bvpoosuygJZOWPHjs0CXB999FF2Pba17LLLNvr7a7755lPOu5OI77AYTT9u3LjsRE0E2SMA2qtXr/TMM8+k0047LY0cOTJb9+STT7ZfANDuiUsB7Ym4FMUQm6LUxKZoS2JTQLWpqW1sAmaoMjU1NS1aP0pCxjzj0NoOwoknnpgv866sLS1x//33Z0H6wmBFfSJ4f+ONN2adQzqvCFpdccUVzV6/sZ9xRx11VDr99NMbXGeBBRZIt956a1p33XWLaivtQ0xJMmLEiCbXGzp0aLr00kvT5ptvPtvfYzTqJpts0qLHjIB+3YAsHTs4//3vfz8bhdrQ7/eYmimCXMXuv37TA1AtxKWoFLEpiiUuRUuJTVFqYlO0NbEpoJqogAUAbShG57z55pvpkksuSXfddVd67bXXstEY3bp1S4MHD05rrrlm+vGPf5y++93vtjiYD42J0T2xX8WIwkcffTR9+umnWfn3GIEffz/ooIPSPPPMU+lm0sbuueeedMcdd2QjCWOkagQiYuRgjAKLQOe3vvWtbHTYLrvsknr37l3p5tIOxejV+G4777zzssD5+++/n03PNGTIkOzEYBxrVl111Uo3EwAAOiVxKSpJbIogNkVbE5sCqokKWAAAAAAAAAAAAEXqUuwdAQAAAAAAAAAAOjsJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAABtrKamJruccMIJlW4KAAAAAJ2M2BQAQNuTgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAFBBJ5xwQqqpqckuYerUqemMM85Iq622WurXr192WWuttdL555+fZsyYUe82cvePbTVm4403ztaLf+t66KGH8tuJ5dra2nTJJZek9ddfP80///xp7rnnztpx1VVXzXa/6dOnp7/97W9pnXXWSf3798/au95666Xrr78+lVrdNs6aNSv9/e9/T9/+9rezx+7Tp09aZZVV0mmnnZa9jo156qmn0jHHHJO9FoMHD07du3fPnuPyyy+fDjzwwPT66683ev+99tora8eiiy6aXf/000/TkUcemVZYYYXsNci1MW7PvbfhxBNPzD+H3CW2VSjafu6552ZtGzhwYJprrrmy57fMMsukrbfeOv35z39OH3zwQateSwAAAIAgNtV8YlNiUwAAjenW6K0AQNmMHj06bbXVVumll16a7e/PPvtsdrn33nvTrbfemrp0adv86a+//jrtsMMO6fbbb5+jHXvssUd67rnn0jnnnJO+/PLLtOOOO6ZHHnlktvWeeOKJ7PLuu++m3/3ud23Sxgiubbvttunuu++e7e//93//l12uvvrq9MADD2QBrLouv/zytPfee9f7vN94443sEsGzCDT9/Oc/b7ItETDbfvvt05gxY1r5rL4Jln3nO9+ZI8gWr3Vc3n777ew5f/LJJ+lPf/pTqx8PAAAAIEdsqvnEpsSmAADqkoAFAFVi5513zoIbBx98cBY0iZFlb731Vjr55JOzwEsEnSL4csABB7RpO4499tj09NNPp5/85Cfpxz/+cRYoiuBKjGKM9kTwJ9p33nnnZcGsGJW30047ZaMRI0AX948gzHHHHZcFy2LkXanFCMEIum2xxRbZ4w8bNix99NFH6a9//Wu67777stcx2hgBqK5du8523xitOd9882Vt23DDDdNSSy2VjVCMNr/wwgvZ84uA1S9/+cu07LLLpk033bTBdkycODF973vfy0YGHn300WnzzTdPvXv3Tq+88koaMmRIFpiMgNxKK62UrR9trRs4i7bkHHTQQfkA12677ZbtEwsuuGD2HCIAFgHG2267rcSvJgAAAIDYVEuITQEAMIdaAKBijj/++Nr4Oo7LXHPNVfvggw/Osc7YsWNrBw0alK2z8sorz3F77v6xrcZstNFG2Xrxb13xuLntxOXss8+eY51PP/20tl+/ftntAwcOrK2pqam95ZZb5ljv5Zdfru3SpUu23sEHH1xbKnXbuP/++9e73j777JNf5y9/+csct48cObJ20qRJDT7OuHHjstc57r/++uvXu86ee+6Zf4y+ffvWvvTSS422vTnv0ZQpU7J9INY7/PDDG91e7BMAAAAArSU21XxiU/8jNgUAMKe2rRMLADRbjDDbeOON5/h7jDbMlSWP0Wvjx49v03asvfba6ZBDDpnj7zHaMEYThs8//zztsssuWZn3ulZeeeW0/vrrZ8uPPvpom7Rx0KBB6ayzzqr3trPPPjsNHDgwW45Rh3UttNBC2UjAhswzzzzppJNOypYfe+yxNHbs2EbbcsQRR6RVVlkltdYXX3yRlZoPMfqxMbFPAAAAAJSS2FTziU2JTQEA1CUBCwCqRJRVb8jqq6+e/RsD1t5///02bcePfvSjBm8rDOY0Z73hw4enthABtoYCVX379s1uD6+99loaNWpUo9uaNGlS+uCDD7J1X3311ewy11xz5W9/+eWXi37fWiLK5Hfv3j1bvuqqq7Jy9AAAAADlIjbVfGJTAADUJQELAKrEsssu26xRZV999VWbtmPppZdu8LZ55523Reu1VVvXXHPNRm9fa6218ssxMrOuMWPGpN/97ndpmWWWSf369UuLLbZYWnHFFdNKK62UXbbddtvZ1m1IBNQWX3zxVAo9evRIP/zhD7PlG2+8MS255JLZCMY777wzjRs3riSPAQAAANAQsanmE5sCAKCubnP8BQCoiMZKj3fp8r+c6ZkzZ1ZFO5qz3qxZs1JbWGCBBZosA19YPr3Q888/n7bccssmy7fnTJkypVlBv1I4//zzs4DW7bffnkaMGJHOOOOM7BKv52qrrZaNntx///2zUvQAAAAApSQ21XxiU2JTAAB1qYAFALQ7NTU1Rd1v+vTpWaAoAlxRyv2www5LDz/8cPr000/T1KlTszL6cXnvvffy94nrDenatWsqpbnnnjv961//Sk8//XQ6/PDDs/L+8RgRLHzuueeyUYcxuvPJJ58s6eMCAAAA0HxiU2JTAAB1qYAFAB0g4BOBmKZG9E2aNCl1FKNHj2727YUl8v/zn/+k4cOHZ8t//etf07777lvv/euOTCy3KFOfK1UfpfIfeuihdPnll6ebb745ffbZZ+l73/teFojr1atXRdsJAAAAIDbV+O1iUwAAnYMKWADQzvXr1y/798svv2xwnQiCvfvuu6mjePbZZ5t9+4orrphffu211/LLP/zhDxu8f4zoq6b3d/vtt0833XRTOvjgg7O/xajIxx57rNJNAwAAABCbauJ2sSkAgM5BAhYAtHOLLbZYk4GZu+66K40bNy51FDfccEOaMmVKg6Mpr7/++mx5+eWXT0OGDMnfNmPGjNnWq0+M1vz73/9e0vb27Nkz+3fatGmt2s5mm22WXx4zZkyr2wUAAADQWmJTsxObAgDonCRgAUA7t9FGG2X/Pv300+nxxx+f4/ZRo0algw46KHUk8ZwOP/zwem877LDDslLo4cADD5zttqWWWiq/HGXT63PUUUelF154oaTtzQXaojR7Q6L8/MMPP9zodu699945gpsAAAAAlSQ2NTuxKQCAzqlbpRsAALTO/vvvn/76179mI+iiHPhxxx2X1l9//TR9+vQs6PXnP/85ff3111mA55133kkdwRprrJEuuOCC9P7776ef/exnadiwYemjjz7K/nbPPfdk66y66qrZbYW23HLLtMACC2RBsGOOOSZ98MEHaaeddkoDBgzIyuDH6MIHHnggrbfeevUGDIv17W9/O2vrv/71r3ThhRdm28+NPJx77rmzNn344Ydpk002yUZGRpviOS600ELZOvHcrrvuuvzoyW9961tp7bXXLln7AAAAAIolNiU2BQCABCwAaPdWWGGF9Mc//jEbXffll1+mX/3qV7Pd3r9//3TrrbemY489tsMEuU499dR05plnprvvvju71LXsssumf//736lbt9l/6vTp0yddeeWVaccdd0xTp07NAk5xKbTxxhun888/P6244oola++vf/3rdOONN2Zl3usG3vbcc8/ZRjy+/vrr2aUh8dxuvvnmVFNTU7L2AQAAABRLbEpsCgAAUxACQIcQga0I9sQouvnmmy/16NEjKwP+i1/8Ir344otpgw02SB1J9+7d05133pmNrlxnnXXSvPPOm3r37p1WWmmldMopp2Rl2hdccMF67xuv0XPPPZd22223bJ255porDRw4MCuXf9FFF2WjDCMYVkoxKvDJJ59Mu+66a1p44YWz96eueI8eeuihrMx8jDZccsklU79+/bL2DRo0KG2xxRbpb3/7W3rppZeUeAcAAACqitiU2BQAQGdXU1tbW1vpRgAANCUCQBH8CQ8++GA2GhAAAAAAykFsCgCAxqiABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFCkbsXeEQCgJd5+++00ffr0Ft9vgQUWyC4AAAAAUCyxKQAA2pIELACgLLbYYos0YsSIFt/v+OOPTyeccEKbtAkAAACAzkFsCgCAtiQBCwBoFzbeeONUW1tb6WYAAAAA0AmJTQEA0JiaWr8WAQAAAAAAAAAAitKluLsBAAAAAAAAAAAgAQsAAAAAAAAAAKBIErAAAAAAAAAAAACKJAELAAAAAAAAAACgSBKwAAAAAAAAAAAAiiQBCwAAAAAAAAAAoEgSsAAAAAAAAAAAAIokAQsAAAAAAAAAAKBIErAAAAAAAAAAAACKJAELAAAAAAAAAACgSBKwAAAAAAAAAAAAiiQBCwAAAAAAAAAAoEgSsAAAAAAAAAAAAIokAQsAAAAAAAAAAKBIErAAAAAAAAAAAACKJAELAAAAAAAAAACgSBKwAAAAAAAAAAAAiiQBCwAAAAAAAAAAoEgSsAAAAAAAAAAAAIokAQuA2dTU1OQv7dlDDz2Ufx4bb7xxqlYnnHBCvp2xXC4ffPBB/nEXXXTRkm47tpfbdjxOObSX97ujaO7+09b7wo477phte8iQIWnSpEmp0l577bXUtWvXrE2nnnpqpZsDAAC0keb0dfbaa6/8OpdffnnZ20jHUqn4UVuaOHFiGjp0aPacvvvd79a7Tnx2cs87PlMAVM5vf/vb7Hjcs2fP9N5771W6OQBVSQIWQAcSiSeFCVTNvUTyCi338ssv51/DAw44oNLNgU7l7rvvTrfddlu2HMHnPn36VLpJaYUVVkh77LFHtvz73/8+ffTRR5VuEgAAtDh20K9fv7TwwgunrbbaKvtd+/HHH1e6yUAHdMopp2THlxjIdNppp1W6Oe3KK6+8kg4//PC0zjrrpAEDBqS55por9e3bN0sO3WGHHdJFF12Uvvrqq0o3E2imTz75JF1//fXpiCOOSFtvvXVadtll0zzzzJO6deuWfbYXWWSRtP3226dzzz03jR07ttnbHTVqVLrqqqvSPvvsk9ZYY400//zzZ8eLeeedN3uMPffcM91+++1p1qxZzU7Amm+++dK0adPSr371q1Y8Y4COSwIWABQpOic5DY3Ua+8qUc0KmhJBgV//+tfZ8rBhw9JPf/rTVC2OPvroLHg8efLkdNxxx1W6OQAAUFRVmhhMcM8992S/bxdbbLF04oknptra2ko3Degg4hhz9tlnZ8s/+MEPsgFNNG3q1Klp3333TSuvvHL685//nJ5++uksGWPGjBlZZfARI0akf/3rX9lA0aWWWipbhvaqM814sMUWW6Qf/vCH6YwzzsgGnb711ltpwoQJaebMmdln+8MPP0z//ve/0yGHHJIWX3zxdMEFFzS6vVh/0003TQsttFA2WPTSSy9Nzz//fPriiy+y48X48eOzx7jyyiuz8xqrrbZaltjZlEjcOuigg/LnRh5++OGSvQYAHUW3SjcAgLax5pprprXWWqtZ68YPcVouF8To3bt32myzzSrdHOg0rrnmmmy6vxAjPmPkVrVYcskl0/e+971s1FqMMIuRYcsss0ylmwUAAM2OHcRJuaj4nDsR9/XXX2dVZ8eNG5fOOuusCrUU6EhOOumkrIJKOPLIIyvdnHYhkmB32mmnLDkjZ+65586q2kR1nDh2v/nmm+n111/Pbhs9enTaeeed0w033JDdD2gfhgwZkpZbbrlsitY47xDV7OKz/cILL2THgUjM+vnPf55Vt4oE+YYqaj344IOz/S2OE9/61rfSAgsskCV1Pfvss+mdd97Jbovffeutt1564IEHst+GjTn44IPTn/70p2zwaSTqP/bYYyV89gDtnwQsgA5qm222yQKkLWVEa/NEB+e5557LljfffPNs3vNixHtUzPtUispWbfVeq5RFWzv99NOzfyMIsffee6dqc+CBB2YJWDFKLQISf//73yvdJAAAaHHs4Iknnki77rprVkUhRLWan/zkJ9nJfoBiffrpp1nVlRAn/CMhgKZdccUVsyVfRRJEHL9jOrBCUb0wqmSNHDkyi0v87Gc/y6Y0KzZ2CbS9mDo0klGj0ldU+6/P8OHDs+p2999/f34a12233bbRQfgLLrhgNnNATDUYg0bruu2227LjxZgxY7JEr6hI+MYbb6RevXo1uM2YxjDWi2PS448/nl3iWA7AN0xBCABFiBK7uQSmjjr9IFSjGImVG4kfnf0Y7dlcMbqrNdOwNFcES3JBjauvvjoLYgAAQHvz7W9/OzsxF1P/5Fx00UUVbRPQ/v31r39N06dPz5bjxD/Nc/nll8+WrHHOOefMkXwVttxyy3TzzTfnr3/22WfpvvvuK1s7gZY79dRT0+67795g8lWIqQfvuOOOtOyyy2bXZ82a1eCgz4iXxjSl7733Xjr55JPrTb7KHUvuvPPO1LVr1+x6TGOaS5BtTOGxOzedLADfkIAFAEUmYIUuXbpkI02A8rjkkkvyyz/84Q+bfb8bb7wxLbXUUvlS/C0RI7qi9Pe7777b7PtEcliYOnVqNmUiAAC0R1GZJgYY5DzyyCMVbQ/QvkXCwGWXXZYtd+/e3dR4LfB///d/+eWoTtiYmEJs6aWXzl9/++2327RtQHnEcTOqkea8+OKL9a63/PLLp1/96lfNqnwXx4vvfe97+euR5NWUqHgV1bVCJOuPHTu2mc8AoOOTgAXAbGJka+7S2PR1uXVy081FWetjjz02rbLKKmneeedNffr0yUZjHHTQQdnIieYYP358lqgQpXTXXnvtNGDAgKxTESM2llhiiSy4ENN6RbCmkqZMmZIv9RslfgcNGlT0tqJUeO61bGjahxjhlltnr732yv/9lltuSdtvv31aeOGFU48ePbL527fYYous4k5T0wvG+5bbZryfDd1W+N4ttthis+0fuctDDz3U5P7R3t7v+t6XeN8j+Sde43jNo61x+0svvdRgpaYo877CCiuk/v37Z+9RdExjJOL555+fba8lJkyYkM4777zsPY/XuG/fvvltbrbZZunEE09Mr732WoP3j8e79dZbsxL166+/frbfxnOI7cT2IugZzy83CrUaRQWreA6hX79+2fNujthHf/zjH2fTHGy66abpzTffbPZjxucpSnXHMS4er7nVrAqDyLENAABorwqnB/vkk0+adZ+YvuZ3v/tdvs8cfY+BAwdmfb/jjjuu2dvJiWm0on+4xx57pGWWWSar+jLXXHNl0+DENg855JCsD9ZQXzj6lY8++mj22Lk+XUxpHn2qIUOGZP2EqD5RjdVro+p2rn962mmnNft+v//97/P3a2jgWPSNjjjiiLTOOuvk++RxsjbiC6uvvno25XsMSPnyyy9L+IxS+uijj7KKHBtssEHWp433IfrNq666avr1r3/drGSRiI/knl+uMlCcAI4p62O/i/0tplCK+ML+++/f4Enqhnz99ddZotCOO+6YFllkkWxbEa+I/W+fffYpqqJQDNC59NJL0y677JK1K7YXr3m83vFa/Pa3v01PP/10s7c3Y8aMrFLJd77znbTQQgvl9+do87///e9mb+c///lP9pxWWmmlLKbXrVu37PMxdOjQrF2HHnpotr1SxAsefvjh9PHHH2fLkdw5zzzztHgb8d7Efrn55ptnbYznHf/G845EgOaq1P5fisrc9VW+qis+UznljK3VF1Nr7b7anPhp3ThQbv3CJOLmrBPt2XnnnbNYWewP8T0TUzhGlaC64nWNfW677bbL4qaxfjyvGJT31FNPpXKItteN0cYx9phjjsni9LEf5OL0kZDT3MGF8TmL6SzjM7LJJptkx+p4fnEsjM9bvCZR+ag5FeMbikM/9thjWSWlaFscC+L2ON7k3u943MJjR31x6bpx7Uoc18otvt9yYtrAUiicQrCxeH5OvPbx+c3tK/EbDYD/qgWgw9hoo40i0phdjj/++KK2kbt/Y18RiyyySH6d999/v/aWW26pnWeeeWa7b+GlV69etf/+978bfdybbrqptkePHg1uo/Cyyiqr1A4fPrzR7T344IP59eN1KaV//etf+W2feuqprdpWvE9NvWeXXXZZfp0999yzdty4cbXf/e53G32Nttpqq9rJkyc3+LjxvuXWjfezoduac4nXurH9oz2+33Xfl9dff712hRVWqLd9L7744mz3/fDDD2s33njjJp/XggsuWPvII480qz0XXHBB7Xzzzdes1+uuu+6a4/5PPfVUbd++fZt1/0UXXbT2hRdeaLQ9je0/Ld0XWuK2226bbR9vrvHjx9euueaa+fsOGTKk9q233mryfv/85z9ru3btmr/fL3/5y2Y/5syZM/PHxZqamtrRo0c3+74AAFBNsYPf/e53+fXnmmuuRtedOnVq7QEHHDDb7+iG4gTnnXdes9ob/aall166Wf2ZI488co77T58+vXahhRZq1v379OlTe9VVVzXZpub0daL/nlsn+vXFuu666/LbiX5pcy2//PL5+0Xfpq5475t6n3KXn/zkJ7WlEP2kY489trZnz56NPl63bt2y/W7WrFkNbqvu6/vEE09k/eyGthnPtbmxsuhDL7HEEk2+Lptvvnnt559/3qxtRhykufthxACailOMHDmy9tvf/naj29l7772z17whEydObDK+VHj5+9//Xttav/rVr/Lb+8Mf/tDk+nVjYp988kmTz3v77bfPnltjKrH/t1bhPvnnP/+50XW//vrr2eJI99xzT9na2Rb7anPipy2NE9ZdZ9KkSbU/+tGPGm1n4WN/9tlnjT6viAU193uuVN/p8ZwidtZUnP7CCy9sdJsR25x//vmb9fmI9e69994WxRGnTZuW/Vaob3uHHHLIbO93U5e6cclKHNfK7eCDD863f4sttijJNs8999z8NuP3Q3PceOON+ftss802JWkHQEfQLZeIBQDFiEpQUeUnRqPGCNJ11103G8H3/vvvZ6NuYoRTVN6J0X2vvvpqNhqoPp999lmaNm1athwjUaJM7uDBg7ORKTGSJkbPvvDCC9lo1pdffjltuOGGWeWhGIVUqekHcyNRyylezygJHCN7Y2Tet7/97WzUZIyijNG8H374Ybbe3XffnQ477LB0wQUXtPgx4v37xS9+kS3H6LTcSJoYaRxVh+qKkWst1Z7e7xhBu9VWW2WvbYz0iupRMfo12ll3NFu0O6okRaWl3Gig1VZbLXt+MUIsRnnGlB3xmsaI7xitedddd802oquuqFgVla9yunbtmpWGjun0oj2ff/559trkRifFvlBXjNbMjUiLkZxRlSte9xgBN3ny5Gz02zPPPJPtX7GdjTbaKHv9l1xyyVRNCkcYx2i1luzT9957b/bexPOK9yde8xg919BzjJFbu+++e3ZsC3GcK3wfmhLTk8bnM97f2I/jWBlVuAAAoL0prFbVWAXoqFgbFX8ff/zx/N+ivxqVZKJayxdffJHdFtuLOEFUzI5Kv1EpqyHXXntt1heN6go5Ma1WVEqKahlx/6gEHJeoRFJffyh+0+cq7kQF4OgPLb744lk/IbYb1W6jbxfbiucQ/YCortWSKc/bUsQdoq255xr9v8KqZPWJak+56dejH5+rUpFzzjnnZFWUc6L6T1QBisot0Y+N9yqqA0UfN9cnaq3YTrymN91002zxhFy1quizRvWn9957L+ubRgWv6O9edNFFTW47qndHDCT6vvEeR0Wz2FdjX3vwwQezfm88fjzn2E9OOumkBrcVffao7BL3CfF6RBujXx+VUmJfiTbm+qhRNSSquBRWJKnrzDPPTL/5zW/yFdpimyuvvHK2L0Z74/V+5ZVX0ltvvZXdXt9+XCheq4hTRJwt4ijRPx42bFgWa4jnGzGXEBW8omLXkUceWe92dtttt/Svf/0rfz36x/HZioo58dmI1z/a1ZxqKG3drw/Rpqg2HftJxEbi/nGMiecd/fvRo0fn43ZRPTziAFH1pq5K7P+lOhacddZZ2XL8G+9fQ/tdfH5ylbtiH2huBfFSK9W+Wg5RLSm+c2Kfic91fB7iOBCVlHL7Vuw30c44pkY1xTgeR2wu4pYRFx83blwWs43XPj7vEdOL78CIl5fDc889l44++ujsWBUx1KiOFd+/8RmOz0h8huL7N2YjiM9QPOf6xHdhbkq5uH8cqyIWGser2HbE/eNYGMeqWG+bbbbJth9xsOaISlwXXnhhthwVqqJSV3zvRvXDiKfFMTdi0/HdnauEHxW46puytG6suBLHtXKK3wExg0HO97///ZJsN16TnPiMNkfhMTx3Hqi+Yy5Ap1PpDDAA2ncFrKhilBshWndk4quvvjrb6L4YzdRYVanTTjut9p133mlwnaiCtOWWW+a3t88++5S9AlY8x6ieE9tdbLHFWr29llbAylWN2nrrrbMRZHVHt/3617+ebaRVQyNx27KCUXPuU+3vd+H7EiNv49/vf//72ei2QjE6L0ZT50ZYLbfccvn7xXv07rvv1luN6cADD8yvF/tTVDWrT4x6LfxM7rLLLtkotPq88sor2Qio+kY1xujdGD0c6zQkKjTtvvvu+cfabLPNqq4CVmEVq9tvv73F9x87dmztyiuvnN/G0KFDa9977716R3Dl3vfcvtfYyOuGHHXUUbON4AMAgPYWO4h+5rBhw/LrR7+oIXvssUd+vahYVbdacpgxY0btX//613zfNirQROWi+kRl3sJKSauuumrWt6nPp59+WnvGGWfUnn766XPcFpU2Ih4R7cn13+qr3PXHP/4x3w+Yd955a7/66quqqIAVov25bR1++OFNrn/YYYfl14921H1PBwwYkL89+uYNvS7Rh7r00kvrfV1bKipf5R5z8ODBWUWo+vpZ119//WzVW6ICWFOvb/fu3fOViqLPXeiLL76o3XnnnfPrdunSpfbxxx+vd5uxbmEca6mllqp97rnn5ljv6quvzqrIFFZcasgdd9yRxWdy62666aZZle2G4iDxOl1++eWNxilyn594DeI9KhRVfHbdddf8ulENu75qUC+99NJs69x5550NPofoN59yyilZLKc14jMVr38uZjVhwoQm71MYE8u9z6uttlrt22+/Pcex5eSTT54thvL73/9+ju2Vcv+PNvziF78o6aWxCnwRk8rFJHOfo3POOaf2jTfeyN73OA7+5z//yfbH3DqxP7/88su15VTqfbUcFbBy7YyKVnXjRDHDwA9+8IPZjgsHHXRQtrzTTjvNUfE8jiMbbrhhfv1NNtmktlzf6bnPSMSH43ut0EcffVS7wQYb5Nft3bt3vXHL8MEHH2TP8emnn26wMlkca+P7qPB7v6F1C+OIucpz8duivpkBCtvd0nhvKY9rcewu9ee7od8wzTl2xm+i4447rrZfv36zvSZxTGut2H5hxbz4PdVchcekurNEAHRWErAAOpDCDlckKjTnh3/dJJ7CQEVzAo0RMKlvyrOcmHqwsOPT2k5BBEVyCRQRiI1ObTkTsJ555pn8diPZpdwJWHGJznJDr2MELwuTVBoq517pBKxqf7/rlrqOcs6NlUIPJ510Un79CMA0tX5hsLi+9ymea2Gn+mc/+1ltOUTiWO4xGwoKVyIBK/btwpMvjSXvNSYCloXTSS688MKztS2mVI1pVXK3x0mkpt7Lhlx55ZX57cS0lAAA0N4SsOomNDQ0zVCcRM2tE9NkNTUtW2E/t6Hpxddbb738OmussUajCVGlEn2z3GNGoli1JGBFUkVuWzHNXmN9lLitcCq++++/f7bbY2BO7rZ4jcshXqPcSff+/fs3eNK/vucbA53qS9QqfH1z0x819LpEDCX6ZIVxlfrEye3cOnEyuqEBUOHmm2+e7fEffvjheh930UUXza+z3XbbFR0XqxuniMSVhkyZMmW2xMlrr712jnViarTc7UcffXRtOTz55JOzJQY1R92YWNxvzJgxDa5/zDHH5NeNAaN1E/JKuf8XxqJKdambMFnXiBEjZhtY1tAlkmsinhFTNpZbqffVciRgxWWZZZZpMAEskgXj2FW4fiRTNnTMiQSm3DEvYueRHFeO7/Sm4ofxPbrsssvm142BmK0Vj5fbXkMJT4VxxNz++dZbbzW57ZbGe0t5XGvJNIjNvTT3t0AkYja2ndin9tprrzmS7IpVmEgX52/qDkBuTHwOcvetL3kYoDPqUukKXAC0jWeffTb95S9/afISZXdbY7vttstKSTckShDH1HIhN7Vca0Q54p/85CfZcpQ5jjLv5VRYwrjc0w/mnH322Q2W841S6XvvvXf+ekwr155V+v0ufM2jBHZDooT1+eefny336NEj/e1vf2t0/Vw5+Hi/wj/+8Y85bo9pFnLTP0aZ72hDOey111755Zg2r1qMGjVqtmkYYgrFYkR5/igHHyXjQ0wtGdMRxr8xTUFMl5qb3iSmDIwy+E29lw0pnJ6zvZY2BwCg84mp7mKK+/g9fOyxx842ZVBMo16fP//5z7NNtxZTejXV71h22WWz5XvuuSc/1VFOTDGWm8ow+k1XXHFFNvVRWyvsT1dTfyimkcr1gXLT6jUkpsvKTRsZfZK6U97H+5vT2LR5pRRTvuWmcjvuuOOyaeMaE22O6SxDxJFiSsXGxD5y7rnnNth3ixhK3J4T+3duur+cGJNYON1h7PuNTcMUU2HFVIU5F1xwwRzrxHSLub5gnz59sv5lKaZn6t69+2yfubpiSrRdd9210dhQJfaDmLastX36mD6y7pRjhY455phsKsHcNGrXXHNNxZ93KcU0dy+88EL65z//2ehxNqYGi30g91pUSin21XL5wx/+kH1O6xNTuW677baz/S2eV0PHnIjj5abji2NLTA1YDtHOeB4Nie/RP/7xj/nrN9xwQxo/fnzZvzd/+ctfZtMJl1p7/3w3R3wvxVSu8X0SMejWihhpYcz5qKOOatFrJ/YJMCeTsQLQKj/4wQ+aDILFPO6RPJH7IR5zuzdm3Lhx2TzyMad5BGEjcWvWrFn5299888388ksvvZS23377VC6RoBHmmWeetOGGG6ZyW3zxxdNqq63W6Doxr3176vhU8/sdVl555bTccss1uk4EUj777LNsebPNNksLLLBAk9tdcMEFsxMOEUx+9dVXs4BH7Fc5d999d355v/32K0mnOkyePDl7vV955ZUsATOSvHKB8PDxxx/P9npXi9GjR+eXe/funQXpijVo0KDspMRGG22U3n333exzst5662XvYS75KhKxrrzyyqKTr0JhMDR3DAQAgGpy4oknZpfGRLLDb37zm3TkkUfWe/uMGTOyk4Fh7rnnzgZqNUck2UR/L05OR7JV4SCnwv5Q9LGWX375VArR13z++eezvs7IkSOzk7W5PkBd1dQfithKJMTlTpzHIJ54XepTOMAnEhvq9mkKk4oikevtt99ukxPhhe688878cjyP5th0002z5LwQg7Eai4VEokNTSV0Ri4p4SS6ZK557bmBOiL55rt/WtWvXtMceezTZxn333Tfddddd2fJDDz00x+2F+3G8F00lJjbX+uuvnx/sWGxsqHA/iL5vxB2ir12ufn1jSVQNibhI9NWbWudHP/pROuuss/Lv8wEHHNAm+38kRn4zmUD5RFJZJDHGwL+I78w333zZ/hCJVhFPi+SsOK7GZycucVyNZK2GEovaWin21XLo1avXHAlWdRXGs5dccsks3t2YFVdcMUv2rJt82Jbi/S6MLTY0WDoSbCImGAMdn3zyyUYHV8d3ZCRFv/zyy9kxMuKI8b2fkxs82pLvzfiMtoVSHtdOOOGE7FIJ8d30i1/8Iv+7JWLGr7/+evYefPTRR1kyfCQBx+D6pj5fjRkxYkT2XuTiwvF5bei3XkPEPgHmJAELoIM6/vjjy9JJaCqZqm5QpXAkSl0R/Pztb3+bbrzxxjRt2rRmPf6YMWNSuUSFnOjohOiYRnWmcivl611p1f5+56y++upNrhPBisLnFSO5mpt8FiJgF/crDJJEcCOn7ojlYnzxxRdZkC4CEIXBkWp7vRsLMuaUIigcCXARbI1EygiExeufs/POO2cnLSLo3hqF7YygVgRNWpPQBQAA5Ra/iU8//fS0zz77NLjO//3f/+V/r0c/+ZBDDml25e6cOKFYKAaNlLI/FCeLowJSJGUU/vZvL/2hsNtuu+UTsKKy0l//+tc5BqZMmTIl3Xzzzfnru+++e70nqNdZZ53sNY6TutHnjfXiZG4MTCl1Ek4MtIokl1w1nKYS/nLiZHND+0dd6667brO2GevlErDqVtUqvB4nv5uTIBSvV+GJ56g8Fn3NttqPSxkbiiSMSMqJz24k7cQAsficRxJKJMS0tj/cFv36eN7NqYQX73MuAavu+1zu/b+UImEmEhNjEF8kZUaMJ+JqkTxUKBJi99xzz/Tpp59mlfwjae2OO+6oSJvbSxwzkvCaivNGslvOCius0OQ2+/fvX/bn1ZxjYXy211xzzXxibHxG6kvAiu+TqN4fyX7N/T5sznrxOjdnvyhGJY5rbSHen7jU9c4776RDDz00e+/iuz4SyiNBuZiKgvHdHFUcc+9ZbCMqBrb0NSo8ZhYe4wE6MwlYALRKU6NqQmEHtqGRpdHZi9GbX375ZYsev7mJJKWsfhXKXYWp1K93pbWH9zunOWWXc9M75E4+xKWlCl+LCMxEoKOw8llrxIimSDSKJMJqf72bo1QjTCO4EImqEZgsHC3b2DSfLVHukbAAANBScYJvrbXWyl+PCirRb3jiiSeygTJRFSGq/AwfPjydeuqpTfaH4oReVGRoqbp9w8JKOa3tD8XziKog9957b7vuD8UJ66jQHP3N6DNGjKJuVfL4W+5Ef279+lxyySVZIke8zvGex/R5cYl+0Le+9a2s/xhTAEa/vbUnrCMJJGf69Okl2T/qm5atOQrXi2SWQoXXY/qw5lZXjiS4GHAT4kR2YQJWKffjUseGIunl4osvzip9xe2R5Jar+BJJTmuvvXZWNTriX7FPlFox/eVSvM/l3v9LKRLFIvkqRPJVQwNvozpOHO/WWGON7PgXyRrXX399k9XDOnMcszntLIwTtXT9cj2vUn1G4pgbn5GWVoJszvdmJLKVIuZWn0of19raUkstlX3Pf+9730u33nprFu+NBLNctcjmiuNeJKtF5cfc6xbbKCaRS+wTYE6G4APQKjHiqrUiGBAdh1xALRJejjnmmKw6TXSUYvREVI6JH/RxiTnOcwqnqitXAlZ0EqOT0l5f70prL+93Tt2RhPWJUZOt1VD57tCcEZ6NiSkecslX/fr1S7/61a+yqRDiJEp0uuOkSu71jvehkq93QwrL5Rcmp7XGI488kg488MA59s8Y+ZebUrI1CtsZQXnVrwAAqDbRtz3//PPzl8svvzybrjumgYop03KiCkacwC9Hf6hun6i1/aGouJRLvoo+9Q9/+MPsucSJx2h7JAXl+kOFJxKr8aRiYUWrq6++eo7bC/9WX/WrnJjSMSp8H3TQQbMlEsT78Nxzz6U///nPWQJKJCLFyezWaIv9o67mVi0q7FfW7XdH37i+9VqzzVLux20RG4qpp5555pms+lNhEky8Fg888ECW5BNVYyKRJzeVWiX79aV4n8u9/5dKVEnPJVlEm5uaJiymvys8BhTG1sqpvcQxW9rOan1epfqMxPR3ueSrqFwYidi33XZbVs0wNwVh7juzcHrF5sQRmxNnbU/HtXKL2OI555yT3wfj900uMbM5ImE4ktLjNcrFiWMq3WKnei48lldqqlOAaqMCFgAVF6Xzc521hRZaKJuGYMiQIVU1CjU6aQ899FB+PvTCstN0vPe7pQo7mAcffHDWEW6N6PzW3f+KDdbGyPW4hNhGlNlvrFNdra/34MGD88uTJ0/OOvitCdo8/vjjWQny2FaIpKs4AROjx2KqixjpGsloAwYMKPoxCkcRFrYfAACqXfx+jWSemMo8d9I/Bi9EZZW6/eHC/lBUXIrEhtYq7BMVJsa0VAywOO+88/LXI8EsKmO0t/5Q4eCaSLyIk9xxwjTen9w0V1F9LAba5E7QxrpNVW+KaRnPOOOMrJ8YJ6Kj7xh9pVwVrY8//jjtt99+WdWtWLcYhfvH3HPPXZKErLpy/bqmFE6PVLffXdjnbsk0So1tM67nBp+1Zj9uS1EFJqayGjduXDZIKaazikskIuWq9sQ0VzGFYkxPVbfqWksU9ouLmeKzFO9zKff/mA6stfGfumJ6xJhutK7cZzs3zVxz4iFRwSiXQBbvZ2dSTQMKy6kUn5HY76+99tr8d0nse41NoVqN35ulOK5F5bjcNI2lEkmRUYWrtaKCWUyV++abb2bX47gVSZdNieceg6Jzg2/jOBIDzuub7rC5xD4B5iQBC4CKi9EnOTGPeWPJOCESJMotAs4RuK3k9IMdRXt4v1sqAnc5o0aNavX2IigdneDcKKJIWCu2E1v4esdUe02NaKrW1zte48LXZOTIkVnp7WJEcHXrrbfOB8Bj1P8tt9ySbTNKkce/MXrsO9/5Tjb6P3dCo6UiaJWz6KKLFrUNAAColDjxGifvl1122exkbST7RCWsSFhoy/5Q3W0WVtdoqajwkPvdv8IKKzSafFXN/aGcmN4uThhHPy9OpEYlr5/97GfZbbGcO7Ec68SAp+aIadijHxSXENuI7ceUk3HCOkQSW5w4LuYkbeF7GYktkSDQ3CotzZWr+NyUqLqdU3ewTVTnbun2onJybvrB+rYZzz2XgBX7cSTXVKt55503q4oSl9x7FQkMxx9/fPZ6ROXsn//852m77bYrejDUYostll+Ofncl3udS7v/R5y9mSs3GxPGqvgSswvhCTBfWHIXPvS0SH8upsJJRUxXxOsLzLVYpPiMRB8tVgIzYWWPJV9X+vdma41r8fij15zuqbpUiASsUJsNHAnZT4rlGYnYuqSw+UzfeeGP+2FcssU+AOZkHBYCK++STT/LLK620UpPrx8iVcvvXv/6VX8512jqDtiip3R7e75Yq7DzHiMlSTFVRuM0IfnT21zv2xcL2v/XWW0VtJyquRbWr3Ai9mFYggi9RUn3xxRfPRoHlTlTEyP1IwsoFzFsqKmrlrLLKKkVtAwAAKmno0KHZwJmcmKawbpJVVJqIJIZcQsq7777b6sctTFTRH5pdYXLGP/7xj3qX60vgaK44KRt9pvvvv3+2ihpRJaMYMehq2LBh+eu5Cs2lFINsmuPJJ5/ML6+22mqz3RZTUuVEVZFIOGxKVB3JiUFTkSDXFvtxJcTAsL322itrd+7zHVWrCl/DlookyEjsDJ9++mmLK+fEQKnmVCdr7H0u9/5fKoXJIc3ZN+smZUQiSnsW+2NLkk1eeeWV1Bk151gYiTgRG2voM1JN35uljku3xXGtUuIYmtPUwNGoCBfPOxKuQteuXdM///nPbEBqa4l9AsxJAhYAFZcLvjSnVHKUBy7sJJZDdFJyo0Ni5O+SSy6ZOouePXvml3MjaTv6+12M9dZbLx/MilGcpQjMxSiznL///e/5Cmxt+XpHkOW2225L1WqttdbKLxczrUnsT1tssUV+JGRMn3Lrrbfmgy4hPt8RiMlVZnvxxRez9aJseUsVtrGw7QAA0J4cfvjh+SmKotrPH//4xzkSA2Kqq5y//vWvJe0PRTWawhN8bdUfir7/RRddlKpdTB+US8aIBKAPPvggq66US2yK22Kd1op+UvSfckaPHl30tqK6SCn3j7ridWiqUtprr72WXnjhhfz1jTfeeLbbl1tuuXzl6UhQiCk4m3LJJZfkl+urElO4H8eUXsVMu1dpSyyxRJY4VYr9IKZ5zFXljoFrMbVfS8Tx54Ybbmh0nenTp6frrrsuf72p6j2t2f9jH4rnUcpLTJPa0JRjOZEsUlh5rSGFSX/tPZZZWFnnpZdeanL9qAjYGcUA4twUmg2JKQUjWToX940pLYv93ozbr7zyytSe4tLNPa6dcMIJJf98RxJUKcT3WXz3F35/NSYqZea+0yKp7dJLL03f//73W92O2I9ySflR2bI50yACdAYSsACouKg6U1+lqfo6dfvvv38qtwhs5IJknan6Vd2y5oUlhTvy+11sYK5wVHiUr27J61VfR3+//fbLgpO5ct6F22+L1zsCzPF6R7CyWkUiVE5uKoDmigBdYSJVnCCKZLPCYE7O0ksvnQUqc1NlROJWVMpqKohV9+RN7gRIBDeikhYAALRHMc3NQQcdlL9+4YUXps8//3y2dY488sj8ckzXFdVjmqu+aQtjAEMMdAlx0jKmDsxNJVhsf+jhhx9udFqqmFqxmIEe5RbJcDvssEP+tYkqFnHJVWKO23IJc/WJCr/RX2npNFULLLBAq5L4ouJGiOnfG0oyqU9zprWM537IIYc0WI06+rsHH3xw/vr666+fDbArFP22whjESSed1Gi/PvrXd9xxR/56birIQjvvvHNaZJFFsuXYf/fee+9mTZ9WDs1NBovXrrDSSmv2g9b268Nxxx3XaJXqmCY197716dMn7brrrhXf/0uhMKYQcY26U8HW9frrr6errroqfz1iGu1ZTP+Yq4b09NNPN5qUG0mekaDSGUXc6ne/+12Dt0cFuSOOOCJ/PZJw5plnnga/N2NAchwDGju2tyYps9Rx6Uod11qrOVXdciL5MuLOhW2P77SGHHbYYdnA3pyYVrGp6Zib69FHH50tIbVbt24l2S5AeycBC4CK23777fPLV1xxRTrzzDPn6NzFFAYx8ixGK0YApZwKk1YK29oZFI5caWqUYUd5v4sVQYfc6KkICqyxxhrZa9ZQYC+CAjG6Okp91xc4i5Mcp59+ev763/72t/TDH/4wq7BVnwguRcD53nvvne3v2267bT5I9dBDD6Vf//rXacqUKXMEtGOEdASPq/n13myzzWYb6d3cZLEoPV84leBGG22UVSkrLOFfVwTjIwkrF4R55plnsoBlc6dIiKSt3MmdCBRWOpgDAACtESfwcgNEYrBM9OMKxW/sPffcM1uOBJPoh5x22mkNJk3FCcSoRhvJQg0NdDr33HPz1Wqfe+65tOGGG2Yn3usTfZo//elPc/StYlq53BTj8fv8Bz/4wWzTK4WoNhxJHb/97W+ruj9UqHCKwahq0ZLpB2MgSgw6idersIJG3dckppvMTVdUt5pTMdVGjjnmmPz1n/70p1nftKGT5bEPRd929913n21qwIbElPLRx4vqInX7bNEPjCScXDWg6B/HvlmfGPiU21/ihHj0QeurthPVrAoTeyLOEftnXXEyOl7HXJ/83//+d9avjCkO6xPvR+yLbVlRJuc3v/lN1uZ4rIYqPsdrEIPDcokKMX3Xt7/97ZLFhFo6LWO8z5EUFfGi9957b7bbIq4U72skzuUcddRRs01dV6n9vxRiaq/CSoNRnefkk0+utxJWVA2M1yh3Wxy7CxM26qsuFftoXEpVoafUojpd7vlHomV8/urGx+K4Ed9NkWxZWOm8M4nPSCTYxPdZ3ZhZxCrjuzmS80LExI4//vg5thGvc1QzysVn47u97jEiEr0iYTVilW35vbnYYovl2xKDU5uaJaFSx7XWOuWUU7Lk1JtuuqnR6nYRC43fW4XTPkbSaS7Bua54f88666z89ahgeuCBB5as3YXH8MJKlwCdnXRUACouggLROYrOQ3SiIwgXncVITIlROO+8805WSSaCKREIiySTwtE6bS03ndyAAQMq3iErt0jKidHNuRFkkVQS70uu8xui4xbB1I7yfhcrAlqRrBeJPjH1QZwA2GWXXbL9Zp111smCRfF8v/jiiyzYEc8zl5xVGEQrFAGyV199NV1wwQX5EurRGY+EnggYRvWmGHke0+TlAod1y+tHIlEErXMB3AhGxejoXFJQ3C/eiwjMxCjpOGFR38jdahBBnR133DFdc801WVA9gorNCYLG/XKVrjbYYIMs0axwH25ITI0QjxGvaZwYiP0zglnNEaO6c37yk5806z4AAFCtogrFL37xi/wgkejDRT+tf//++XWi7xgnNCNxJvoXUYUjTiquvfba2fRZcUI8TohG4kT0c3LTrK+++ur1Pmb0EWOKt0gIiBPr0e+JvtUyyyyTJeXE7/NIqor+VWwv+lfRf6w7lVIkKUTCT7jvvvuyvlT07aMyUZyIjYEqucEaMUimPfx+jySegQMHZv3Bwkow8bfmVLqJ9yBOVMcl3puVV145P2gk+rJPPfVU1nfNidektfGQOBEc/c8YiBV94+ibRrW0GLwUMYXoo8VJ/VgnpqaLSi11K6A0JBJtzjnnnKzfG32x6GPH84nnEieIc9vKrdtQtZAYCBX95ehnRqLhW2+9le2HsQ9H/zD263htIikhZ6mllpptKsK64qR0JAZFQkSI9sS2IqEmBnFFLCFe63jO8Xih8IR5W4n3IKqXxCVO3kfsIKaxitcgBm1FskbdgU+RtNTYQKbmiOSBiPXE9uOzF5/huhV4GhLVeuK1jwFS0d7o38e+E/GBiGsUVrSJuFNhZb5K7/+lEMenaEdM+xXHu0jWO/vss7P9eciQIdl+HnG7wmNCJFXF/hnHhvbu1FNPTQ8++GD23KNaYRzL47Me+1O8X7EPxGsTn6n4zBVWbuws4jv36KOPzr6r432PqkTxmY7kpfi8FX6eY9+pb2rKWD9itblkxkjwveuuu7LjYLzW8TmLbcX+FkmmES/OJWCXWhybIg4Yx+UQz2errbbKPre5pKP4HZKr+lWp41prRbujcmhc4rdSfDfEezPvvPNm8fH4ro9BynWTDuM3zz777FPvNqN6WWFCalT5j/3gl7/8ZbPaFPct/I1XX5sjoTXMNddcWQwcgG9IwAKgKkRiyTbbbJN1JkIksMSlUASooqJQBFrKJQI7ucBFjBKK4G1nEqNvYlRZJLyEGG1cd8RxBBNbkoBVze93a0WZ7hiZHQlMMVIyOqORuBOjXBsSnemVVlqpwdsjkBEnGCKwFsHo6HhHMDAudUVgrb7EokjgiiBirjpWBEvqTkc4dOjQbBTv119/napZBBZy++N1113XrASseF8ikSoC7RGQb8novKgCF/eNkzZx3+aOosyNlI3Erx//+MfNfjwAAKjmqr9RFSZOukZlq0gSid/JOfFbOU74nXjiiVlyTSSwxCVOmDckTtpFUlVDIvEhEgv23XfffJ8xklRyiSp15ap0FYpp36JvH1UiQrQ/ErEKxe/2OBkdv93bQwJWnPSOCsnxfhT60Y9+1OQUQPEaRd8xN13fhx9+mF3qEzGQ6N/Ga9Na8Zgx9WAk3EUyViS9xUnwGICVm769vvvkpqJsTFTwiYE2kaAT/d3cSeFCcTI+kqAiQaExkbgTfcDYD4YPH569Tg31wWMAViQGNJXcEolA0cY4WR7TdcU2o7JWfdW1QjkqsRVOUxlxhqiq3dC0bbFufKajakxrxT4Vn8l4H+L9j4S55lZdiuNFrB+DBeP9iGNLfceXiN9FfKO+z0Kl9v9SiNhbJJbEILtcrCwSj+rGd3Jiv4ypx3JTljakcOrOhirpVINIAIrnE5WXYp+NhJrCaUBDfF9ErKixafM6shhsGbHUmGIu4pGFVdwKv+/+/Oc/zzblal0Rg4xk2NxgztjPIgmrbjzzsssuS9/61rdSW4rv7khcjbhm/Ka4+eabZ7s9kqlzCViVOq61VmGsMZLTI16ei5nXJxJGYwBtY1MJRjJiofjuieT55ookvMYSsOJ7OzctZFQybU6yNEBnIQELgKoQozDih/vFF1+cBUli9Gp0qqJDEcknEViM4Fckl5QzISdX/aozTj+YEyOdIskqkl4iOBgd+MbKIbfn97sUonMaCWbxnOI1i1FhcaIgRlZH8C4CFDGKKUbRRrA2ktxy1ZkaEkHamEYigtX33HNPNsI7N1VDVNiK0VwxijRetxh9W1e8jhEoicBwjDaOkeORzBX3jeSkCF5GwDNGhEV7q1lMAREJazGtYASVYpRzc0bLxn5VN0jTXDEatiVTcD788MNZhbMQ+3G8zgAA0N7FyfyogBzVIkJUL4qkrOjjFJ68j6oJUXkkTtxGNYdc/yUGe8RUP3GyNH7TR6XZGJjTVPJKVDiJhKvoO8bglhj0EicW4yRl9AWif7XuuuumnXbaKauI01DllBi8EQlLjz32WFZNIk6+xkCUqKYRAz3q60tVs0jCqJuA1dT0gyGXpBQDdKISSFSSiUSj3HRN8ZpGZZmoqhMnd2NwVCnFvhH9z6uuuipLhIvHj/cj4gy59ySqf0Slk9g/hg0b1qztRmWg2FZUCYoknUgeiETBBRdcMNuHosJ09MObI5ICYzBeTO8YU2VGLCT2uUgAiurW8drEYLWo8N1c0V+P2Ep8LqJ/nnvekSQQffHos8Z24/1pzrSLrRWf33hN4jMayUyRpBCJSFFNKhKX4mR6vA/xHGNfy1WIKoV43JgKKxKwIqGmJdPexfsZfe7c1JsxnWMcX6K9kXwSyV1RMada9//WirbF+xXvW8SeImYW0zLG+xaxpYg/xP4Tx7tcXK0xkQhZWFWnOceQSopqhvH5jASiSMqJ9zKed0xVF7GtAw44IHsNqj221ZYi4S4q6sX0gJGgFp/r+KzFsTS+76ICUlPfd/FdHvHDmLY3jqkxGDf2lThWRfWpeIx4L+Lz2NBUnqUSvxnicxrfd/G5ffvtt7P9PSpjVtNxrTWiYlkkgMc+HZ/p+P7Jfa4jlhy/neL9i892vIdxjqLS02xGTL9w+l4A/qemtjC9HQCYTQSEo9MenZoI6NQ3mhYor0gky41Kj1H31dbRj8B6BEIjYBWJeFHyHAAAgNKJpJ1IEAhRhaUlSTxUXlTfieSrEJVeypF0xpwiWXHnnXfOD3iLxBXal0hWjaTEEBXh4jq0pRhkHIl4MZg6kp8jmRWA/+lc8ygBQAvE6LcYGRui8yr5CqpDTKsRI9ZCjHqspmkT33vvvXTTTTflR45KvgIAAIDZHXvssfkKLlH9hcqIijs5uWlaARoTlcYi+SpXYRSA2UnAAoAGREn4XDnjmMscqA5Rfjs37UmU5L700ktTtYjAQ0whEWX+Y+oVAAAAYHYxnVaumvWNN96YTVVK5RKwYkq5tdZaq9LNAdrBgPVIwAoxra6KawBzkoAFAA3YddddU8zUG5eYPx6oHltttVUWIAwnnHBCmjRpUqWblAWMr7zyymz5d7/7XVaOGwAAAJjTMccckxZaaKFsENNvf/vbSjen0xk9enQWx4hBbqecckqlmwO0A1Gx8IsvvsgqGJ599tmVbg5AVepW6QYAAEAxbr311lRNll9++XzVPAAAAKBhffv2TSNHjqx0MzqtQYMGZYNOAZrrtNNOyy4ANEwCFgAAAAAAAEAbOv7449PYsWNbtY1tttkmuwAA1UcCFgAAAAAAAEAbuuKKK9KIESNatY0BAwZIwAKAKiUBCwAAAAAAaDcuv/zy7ALQmT300EOVbgIAUKCm1iTPAAAAAAAAAAAARelS3N0AAAAAAAAAAACQgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUKRuxd6RtjN16tT0yiuvZMsDBw5M3bp5mwAAADqLGTNmpM8//zxbXmmllVLPnj0r3SSgkxGbAgAA6LzEpqA4oidVKAJca621VqWbAQAAQIU988wzac0116x0M4BORmwKAACAIDYFzWcKQgAAAAAAAAAAgCKpgFWForR7YUbpkCFDKtoeAACgEVMmVLoFdDCfjhqV1tpwszn6hwCdKTY1c+bMNHbs2Gx5/vnnT127di17G6CQfZJqY5+kGtkvqTb2SapRe9gvP/3003xVZLEpaD4JWFWoW7f/vS0R4Bo6dGhF2wMAADRi8vhKt4BO0j8E6EyxqTgp0aNHj3zAvxpPStC52CepNvZJqpH9kmpjn6Qatbf9UmwKms8UhAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAAAAAAABQJAlYAAAAAAAAAAAARZKABQAAAAAAAAAAUCQJWAAAAAAAAAAAAEWSgAUAAAAAAAAAAFAkCVgAAAAAAAAAAABFkoAFAAAAQKf22WefpX//+9/puOOOS1tvvXUaMGBAqqmpyS577bVXi7d31113pZ122ikNHTo09ejRI/s3rsffm2vGjBnpb3/7W9pggw3SwIEDU69evdISSyyRDjjggPTaa6+1uE0AAAAAtJ1ubbhtAAAAAKh6gwYNKsl2Zs2alfbff/90ySWXzPb3jz/+OLvceuutad99900XXnhh6tKl4XGRY8aMSdtss0169tlnZ/v78OHD00UXXZSuuOKKdP7552fbAgAAAKDyVMACAAAAgP9aeOGF0xZbbFHUfY8++uh88tWqq66arrnmmvTMM89k/8b1cPHFF6djjjmmwW3MnDkzq5aVS77aeeeds8pZTz/9dDr33HPTAgsskKZNm5ZVwmpJRS0AAAAA2o4KWAAAAAB0ajH14JprrpldohrWBx98kBZbbLEWbePtt99Of/rTn7LlNdZYIz3yyCPZtIEhtvvd7343bbTRRum5555LZ5xxRvrpT3+allxyyTm2E9WtHnvssWz55z//efrLX/6Sv22ttdbKpkhcffXV04QJE9LBBx+c3njjjdStmxAfAAAAQCWpgAUAAABAp3biiSem7bbbrlVTEZ599tlpxowZ2fJ5552XT77K6d27d/b3EOudddZZ9W4nl8TVv3//LFGrrkjaOuqoo7Lld999N91yyy1FtxkAAACA0pCABQAAAACtUFtbm2677bZsedlll03rrLNOvevF35dZZplsOdaP+9WtohUVrcIuu+ySJW3VZ6+99sovS8ACAAAAqDwJWAAAAADQCu+//3765JNPsuWYZrAxuds//vjjbKrDQrmpB5vazuDBg9PSSy+dLT/++OOtajsAAAAArScBCwAAAABa4fXXX88vRwWsxhTenqt21ZrtfPTRR2nSpEktbjMAAAAApdOthNsCAAAAgE5n5MiR+eWhQ4c2uu6wYcPyy5E81drtxDSGcb/c1IYtbW99Pv300/zyzJkzs0u5xWPOmjUrvwyVZp+k2tgnqUb2S6qNfZJq1B72y2ptF1Q7CVgAAAAA0ApfffVVfrlv376NrtunT5/88sSJE9tkO00pTAJrytixY1OPHj1SucUJifHjx+evd+mikD+VZZ+k2tgnqUb2S6qNfZJq1B72y+gHAi1XfZ9mAAAAAGhHpk6dml/u3r17o+sWJjNNmTKlTbYDAAAAQHmpgAUAAAAArdCzZ8/88vTp0xtdd9q0afnlXr16Nbqdwust2U5T6k59WN8UhGuttVa2PP/886eBAwemSk55MWDAgNS1a9eytwEK2SepNvZJqpH9kmpjn6QatYf9srC/CTSfBCwAAAAAaIV+/fo1ezrASZMmNTjNYN3tNJaA1dh2mjJ06NBmrxsnAyp1QiA3FUcl2wCF7JNUG/sk1ch+SbWxT1KNqn2/rMY2QXtgCkIAAAAAaIXChKaRI0c2u/rUsGHDWr2dmpqaFiVUAQAAAFB6ErAAAAAAoBWWX375/PKbb77Z6LqFty+33HKt3k4kcfXp06fFbQYAAACgdCRgAQAAAEArLLbYYmnBBRfMlh9++OFG133kkUeyfxdaaKG06KKLznbb+uuvn19ubDujRo1Kb7/9dra83nrrtartAAAAALSeBCwAAAAAaIWYBnCHHXbIV6Z66qmn6l0v/p6rXBXrx/0KLb300vmqWNdff32aPHlyvdu5/PLL88s77bRTyZ4HAAAAAMWRgAUAAAAArXTooYemrl27ZssHHXRQmjJlymy3x/X4e+jWrVu2fn1+/etfZ/9+8cUX6Ygjjpjj9vfeey+ddtpp2fKSSy4pAQsAAACgCnSrdAMAAAAAoJIee+yx9O677+avjxkzJr8cfy+sOBX22muvObYR1at+85vfpD/84Q/pueeey6YGPPLII9MSSyyRJU2dfvrp6cUXX8zWjfWWWmqpetuy5557pksvvTQ9/vjj6S9/+Us23eB+++2X5ptvvvTMM8+kk08+OU2YMCF16dIlnXvuuVkyFwAAAACVJUIDAAAAQKd28cUXpyuuuKLe2yIRKi5NJWCFU089NX322WdZAlUkW/3oRz+aY5199tknnXLKKQ22Japo3XrrrWmbbbZJzz77bLrpppuyS6EePXqk888/P2299dbNfIYAAAAAtCVTEAIAAABACURVqksuuSTdcccdaYcddkgLLrhg6t69e/ZvXL/zzjuzZK9YrzEDBgxITzzxRPrrX/+a1l9//TT//POnnj17psUXXzyrhvX888+nfffdt2zPCwAAAIBOXAHrww8/zAe9RowYkb766qs0cODAtOiii6ZNNtkk7bLLLmnFFVds1rYmT56crfv+++9n1xdZZJH0wQcftPEzAAAAAKCtxRSDdacZbI2oXhWX1oipBQ888MDsAgAAAEB167AVsM4777y0/PLLp5NOOikbFThmzJg0bdq0NHLkyPTYY4+lk08+ORtx2FzHHXdcPvkKAACgI7r6muvSAQcdmtZYf+PUY74FUk2fedPlV/2jxduZNWtWOu+CC9NKa3479Zp/cBq4yBJp1z33ScPfb3gQyz33PZA22nKb1G/Q0DT34GFpk623Sw88+HArnxEAAAAAALS9DlkB65RTTknHHntstrz00ktnpdnXXHPNNM8886SxY8emF198Md1yyy1NlnvPifXPPvvsrNT7XHPNlVXSAgAA6GiOOemUNOLDj9KAAfOnIYMHZcvFiCSuiy+/Mq2w3HLp4AMPSJ98+mm6/uZb073/+U966sH701JLLjFH4tfu+x6QBg4YkPbabdfsb9fdeEvafPsd0/VXXZ6+v9MOJXl+AAAAAADQFjpcAtYDDzyQT77aY489sipXkTRVaLPNNku//vWv0/Tp05vc3syZM7MErvj3+OOPz6Y0lIAFAAB0RBf/5by01JKLp0UWXjj94U9npaOOP7HF23jw4Uey5KsN1/92uu/2W1P37t2zv/94lx+kbXb+QfrlYb9J9/zr5vz6X345Lh306yOypK8Xnng4DV1ooezvRx52aFr12xumAw89LG35nU1Tv379SvhMAQAAAKD8vpo6I70/dkqa/PWstFBtr7TQfL1Tv56z5zMA7VOHmoIwprk48MADs+VVVlklS5aqm3xVKHcioDHnnHNONoXhMsssk4488siSthcAAKCafGfTjbPkq9b4+2VXZv+efOzRs/W5tt5y87Txhuunex/4T/rwo/9V1rrhllvTuHHj00E/2z+ffBVi+ZcH7JfGjBmbbvnXv/N//9nBv8qmRowEsbpyt51+5tmteg4AAAAANN9XU79O74z+Kr300bjs37jekttLsY1qeIyGbq+trU1PvDcmHXj182n1Ux9Iu171etrn2jfTVuc8lr510n3p5/94Prs91gParw5VAevee+9N77zzTrYcyVLdurXu6Y0YMSIdd9xx2fLf/va3ZiVsAQAAdGYPPfpY6tOnT1pv3XXmuG3LzTZLDz3yWHr40cfT7j/+0TfrP/JY9u8Wm2065/rf2SydcOof0sOPPZ72+Mk3UxOedfrv0yOPP5GOO+X3abNNNkprrr5a9vdb/nV7uvCSy9KmG22YfvOrg9v4WQIAAEDnFoklo8ZPTZOmz0x9undNg+fpOVsVn9beXprHaLzSUHnaUPnHaKs29O3RLT05fGy66skR6d7XR6eZs/6XPNS1S03aYvkF0mqLzJeeHzEu3VfP7VuuMCj9ZO2FU02qSVc9Vdw2quExmrp9ncX7pxFjJ6eRX05J9Yn173xlVHZZelDf9OddvpVWXGieetcFqluHSsC64YYbsn9ramrSdtttl//7F198kcaOHZvmn3/+1L9//2Zv7+c//3maNGlS2n333dPGG2/cJm0GAADoKKL/9OmoUWnF5ZdPXbt2neP2mN4wvPPee/m/5ZaXWmKJOdf/798K1+/Vq1e65rKL09obfyftutc+6aUnH03jxo9P+/7i4DT//P3TVZdcmLp06VDFngEAAGhHqjVZphSP0dqEm/aQLNNZkoJa24YuNSn17t4tTZw2I9Un1r3r1dHZpamko4Y0ZxvV8BhN3f74u2NTc709emLa5cIn04W7r542WGpgs+8HVIcOlYD11FNPZf8uuuiiqV+/fumf//xnOu2009Krr76aX2fppZdO++23XzrooINSjx49GtzWtddem+68884033zzpTPPPLMs7QcAAGjPxk+YkP07zzxz13v73P2++fv48ROadZ+55+43x/phlZVXSqeffEI69Iij0oGHHJZGfvJJ+uKLL9Nt1/8zLThkSAmfEQAAQOVVc0JOKasNVcPz7MyJSU09RikSbtpDskxnSQpqbRti12hoX6B1Jk+fmQ646vl0/QHrqoQF7UyHScCaNWtWevPNN7PlAQMGpEMOOSSde+65c6z39ttvp9/85jfplltuSXfccUead95551jnyy+/TIceemi2/Ic//CENHFja7NKRI0c2evunn35a0scDAADoaA7++c/SPff/J1197fXZ9QP32yd9d9ttKt0sAACAkqitrW00oacaEnLaQ5UeiUmlewwJN1DeJKzDr3853X3oBtnsX0D70GESsMaPH58lYYVXXnklPfvss2nIkCHpjDPOSNtss03q2bNn9rcjjzwyq5T1xBNPpJ/+9Kfp5ptvnmNbkaA1evTotO6662bVskpt2LBhJd8mAABApc0z95wVrgpN+GrOaleF94kpBGdbf8JXc6yfE8GnHbffNt11733Z9YN+tn/JngcAAEAlqzJ9MWl6Ova2V7OpqKo5Iac9VOmRmAS0V2+N/io9NfyLtO4S81e6KUBnS8CaNGlSfnnq1Kmpd+/e6cEHH0zLLLNM/u8bbrhh+s9//pMlVr388stZFaynn346rb322vl1HnnkkXTppZembt26pb/97W8ySgEAAJqpT58+acjgwen9ESPSzJkzU9euXWe7/Z13h2f/LrXEEvm/xfJzL7yY3nnvvTkSsOJvddfPef+DD9Jvjj4u9e8/X/ryy3Fp318cnB659845HhMAAKAxxUwn19ZVmQAgXP3UCAlY0I50mASsqHBVaN99950t+SqnV69e6dRTT03bbbdddv26667LJ2BNmzYt7b///llZ15jCcOWVV26Ttn700UdNTkG41lprtcljAwAAtKWN1l8vXXvjTenxJ59KG66/3my33fPAA9m/G67/7f+tv8F66Zobbkz3PvCftM5aa86+/v0P5LdZaMaMGeknP90/ffXVV+nef92S7r7v/nTmueenE3//h3TSsUe34bMDAAA6eoJVc6aTa+uqTAAQ7n5tVPY9VrfyIlCdOkwCVr9+/Wa7vsUWWzS47mabbZZVuIqgfUxLmBOJWW+99VY2ReCJJ57YZm0dOnRom20bAACgHMaMGZvGjB2bBsw/fxow4H8j8fb/6Z5ZAtaxJ5+a7rv91tS9e/fs73fdc1966JHH0habbZoWWXjh/Pq77LxTOvLY49N5f7so/XSP3dLQhRbK/j7y44/T+Rf+Pdv2Tt/9ZgBNTiRaPfn0M+nXhxyUvrPpxllC14OPPJp+f8af0+abbpI2WO9/CV4AAEDnm/6vNQlWppMDoFrE99foCVMlYEE70WESsHr06JEGDhyYPv/88+x6JFE1Vi1rwIABadSoUfn1w+mnn579+53vfCfdfvvtjU51GP9ee+212fICCyyQNt1005I+HwAAgHK7+PIr02NPPJktv/La69/87Yqr0kOPPpYtr//tddO+e+2RLZ9/4UXpxN+fno7/3ZHphKOPym9jk402zNaJba327Y3StlttkT4dNSpdd9Mt2XSB5535x9kec7755k3nn3lG2n3fA7L1f/j9nbK/X3fjLWns2C/SdVdeNtuAm0ceezxLtFrtW6ukU084NvtbJHn987KL0+rrb5x222f/9PJTj6V55523zV8vAACg+qb/k2AFQEcycdrMSjcB6GwJWGGFFVZIDz30ULY8c2bjB6Lc7VEJK2f69OnZv5dddll2acyYMWPSrrvumi1vtNFGErAAAIB2L5KvrvjHNbP9LaYSjEtOLgGrMReed3ZaaYXl00WXXpHO+evfUt++fbIqVqcef2xaYvHF5lh/t11/mFXS+v2fzkyXXfXPVFNTk1ZfdZV0zBG/ySpc5Xz55bi02z4HZFPLX3P5JfnqWmGZpZdKZ//xtLTfLw5O+/3ykHTD1Ve04pUAAADa6/R/EqwA6Ej69uha6SYAnTEBa8MNN8wnYA0fPjytuuqq9a43YcKELIEqLPTf6S0AAAA6u8svuiC7NEdUvSqsfFWoS5cu6eCf/yy7NNdWW3wnuzQmqmV9+NarDd4eyWHNSRADAADabnrA2tpa0/8BQAl061KTBs3ds9LNADpjAtb3vve9dNJJJ2XLt9xyS3a9PnFbdADCBhtskP977m+NWXTRRdOIESPSIosskj744IOStR0AAAAAAKCtE6Rac3tT0wOus3j/NGLs5DTyyyn1tkmCFQA035YrDJ7tuxmobh0qAWvllVdOW2+9dbrrrrvSNddck/bee++02WabzbbOqFGj0jHHHJMtx3QVsQ4AAAAAAEB78dXUGen9sVPS5K9npYVqe6WF5uvdZPWpSJDaYvkF0mqLzJeeHzEu3dfC25szPeDj745t42cOAJ3HbussUukmAJ01ASucffbZ6cknn0zjxo1L2223XTr00EPTNttsk3r16pWeeeaZdNppp6WRI0dm65588smmIAQAAAAAAMqqEtWnYv27Xh2dXYq5XfUqACifZQb1y77bgfajwyVgLb300un2229P3//+99Po0aPTH/7wh+xSqKamJh199NHpiCOOqFg7AQAAAACAzqM11alUnwKAzqN3967pzF1WyfIagPajwyVghfXXXz+99tpr6bzzzku33nprev/999P06dPTkCFD0sYbb5wOOuigtOqqq1a6mQAAAAAAQAdUt4LVF5Omp2NvezW9PXpiveurPgUA5JKvLtx99bTiQvNUuilAC3XIBKww//zzpxNOOCG7lNIHH3xQ0u0BAAAAAADtf/rAxipcAQA0Z9rBqHwl+Qrapw6bgAUAAAAAAFCKBKu+Pbo1On3gOov3TyPGTk4jv5xS0bYDANVp2Hy90sLz905PDf9itt8R3brUpC1XGJx2W2eR7PeEaQeh/ZKABQAAAAAAdBotTbDqUhPTAXVrcArAWPfxd8eW8RkAQPWI79DJ02dk0+UWJhVtsfygtPoi86XnRnw5x3drLunoJ2svnCLf6KqnRqR7Xptznaa2UQ2P0Zw2FCZXjZs0Lb0x4pM0efqsNHTQgLTgfL2zSppA+ycBCwAAAAAA6LTTAzaVYBWrNnQbQGdUbMJNe0mW6SxJQa1tQ2FiUXxPjp4wNU2cNjP17dE1DZr7m+/fsM8G33w/N3R7WHeJAY2u09Q2quExmtOG0K9nt7RY/17Z8sCBfVPXrl1nux1ov2pqo9dBVRk5cmQaNmxYtvzRRx+loUOHVrpJAABAQyaPr3QL6GBGfvxxGrb0CtmyPiHQWWNTM2fOTJ9//nm2PHDgQCclqDj7ZHVrLLnK9IBAObXnxKTmPEZzE25CU4kozUlUae02mqo0VI42VMNjlKMNdKzfldXQJ4T2SAUsAAAAAACgXXr14/HpsOtfSm+Pnljv7aYHpCOqpoSc9lClp5oSk9pDFZ/mPEaI5cYScFp7e2keo/FKQ+VpQ+UfoxxtAEAFrKokoxQAANoRFbAoMRWwgEqrhthUexgVTudin6zOKQbf/HRCOvH219OUr2dWulnQZpYZ1C+dvOMKqX+f7lVfpae11YY6SqUgqofvb6pRe9gvq6FPCO2RClgAAAAAAEDZE6j6dO+aBs8zZ/JD3dtjSq+GphiESkwnV67qU7mKSjXxQE2ojgo5ras21FEqBQEAnZMELAAAAAAAoM2Sq2IijoYSqLpmiSgLpNUWmS89P2Jcuq/O7V1qUurdvVs2pReUM8GqOdPJlWs6OAAAqp8ELAAAAAAAoEktrU4VyVWRwDJi7OQ08ssp9W4z1r/r1dHZpT6xOclXVDLBqhqqMgEAUP0kYAEAAAAAAPVqrHpVU9WpYt3H3x1bxtbSkbRm+r9SJ1gBAEBTJGABAAAAAABzVLj6YtL0dOxtr6a3R0+sd33Vqaj26f+CBCsAAMpBAhYAAAAAAHQCLZ1CEIo1bL5eaeH5e6enhn/R5tWpJFgBAFANJGABAAAAAEAH1ZopBKE11atqampUpwIAoNOQgAUAAAAAAO2welVh4kp9t48YOzkddv1LphDsZBqrPrXF8oPS6ovMl54b8eUcCXnNub0l1auCBCsAADoLCVgAAAAAANDOqld1zZJlFkirLTJfen7EuHRfPdWtogKRKQU7nlJUn9png9Sq24PkKgAA+B8JWAAAAAAAUGF1K1h9MWl6Ova2VxusXhWJVXe9Ojq71CdLzqmVfNVetLT61PjJ09MbIz5Jk6fPSkMHDUgLzte7xdWnWns7AADwPxKwAAAAAACgyipc0XEtM6hfOnnHFVL/Pt1bUX2qW1qsf69seeDAvqlr164Vez4AAIAELAAAAAAAqLoKV7RPw+brlRaev3d6avgXjVawiikCG6P6FAAAtC8SsAAAAAAAoITJVYPn+aZakQpXHU/fHt3S5OkzvpnisZHkqqYqWAEAAB2LBCwAAAAAAGjEV1NnpPfHTkmTv56VFqrtlRaar3eWiNNQclXXLjVZIs6IsZPTyC+nVLTtlD7BauK0GU0mV6lgBQAAnYsELAAAAAAAqKOx6lVdalLq3b1blohTn1j38XfHlrG1lHJ6wKYSrCRXAQAAdUnAAgAAAACAAq9+PD4ddv1L6e3RE+u9PXJ3Gkq+oroUMz2gBCsAAKClJGABAAAAANCpRULOqPFT06TpM9Obn05IJ97+epry9cxKN4si9JqrSzr+uyukZQfPbXpAAACgbCRgAQAAAADQKZKr+nTvmgbP801CTmNTDNI+LTOoXzpzl1XSigvNU+mmAAAAnYwELAAAAAAAOpTGkqu6dqnJpqIbMXZyGvnllIq2k5bp26Nbmjx9RjYFZGNTDAIAAJSbBCwAAAAAADpMhasvJk1Px972anp79MR6149krMffHVv2dnZ2w+brlRaev3d6avgXsyXERQLVFssPSqsvMl96bsSXcyTM1U2wmjhtRho9YWqaOG1mg1MMAgAAlJsELAAAAAAA2hXTB7bf6lSRMNdQAtU+G3yTUNdYglUsS7gCAACqjQQsAAAAAADajVc/Hp8Ou/6lBitcUT7FVKdqKoFKghUAANAeScACAAAAAKBdePSdz9MBVz2fJk+fWemmdDrLDOqXTt5xhdS/T3fVqQAAAOqQgAUAAAAAQLuofCX5qvJTCAIAADAnCVgAAAAAAFS12trabNpByVfF61qTUuRWNZZg1ZwpBAEAAJiTBCwAAAAAAKrWV1O/Tne/Oiq9PXpipZvSrqcPPHOXVdIi8/duNMHKFIIAAADFkYAFAAAAAEDVVbx6cvjYdNWTI9K9r49OMwvLNpGvXrXF8oPS6ovMl54b8eUcr1ND0wdKsAIAACg9CVgAAAAAAFSNVz8en003qOLV7BWsTt5xhdS/T/d6q1fts8E3lcJMHwgAAFAZErAAAAAAAKiYSBwaNX5qmjR9Znrz0wnpxNtfT1O+npk6u4YqWDXE9IEAAACVIwELAAAAAICyMsVgyypcAQAAUN0kYAEAAEAHNGPGjDRq1KhKNyMNHjw4desm/ADQWRVWt+rTvWsaPE/PNGLs5E41xeCw+XqlhefvnZ4a/sVsiWYtrXAFAABA9RIBBQAAgA4okq+GDRtW6Wakjz76KA0dOrTSzQCgjAlWfXt0a7C6VZealCUadaSKV/F8J0+fkQqfUn3JVfFajZ4wVYUrAACADkgCFgAAAAAAJZk+MBKsenfvliZOm1HvfbNVa9t/8lXdBKt4vk0lV8V1CVcAAAAdkwQsAAAA6OB2Sr1T71S+aY0mp9p0S5pctscDoHwVrr6YND0de9urDU4fGAlWDSVftWe95uqSDt1wWFpyYK80dNCAtOB8vWdLppJcBQAA0LlJwAIAAIAOrm+qSX1Tl7I9Xpc0q2yPBUB5K1x1RssM6pf++L0V06Du07PrAwf2TV27dq10swAAAKgiErAAAAAAAMi8+vH4dNj1LzVY4aqjGTZfr7Tw/L3TU8O/mC3RrO4Ug7NmzUqff/55RdsKAABA9ZKABQAAAABAevSdz9MBVz2fJk+fmTqyuslVNTU12VSLoydMTROnzUx9e3RNg+buaUpBAAAAmk0CFgAAAHRwXVJN6lJTU77Hqy3fYwFQuspXHTH5KqYPPHnHFVL/Pt0bTa6K6xKuAAAAKJYELAAAAACATioqP306bkr6+T9e6DDJV/W+XKeJAAEAAElEQVRVuAIAAIC2JAELAAAAOrgu/72U8/EAqI7kqlHjp6ZJ02emPt27psHzfFP5qba2Nj05fGy66skR6d7XR6eZs2pTR/Gn76+StlxxkGpWAAAAlJUELAAAAACADqKx5KquXWqyilAjxk5OI7+ckjqamG7we6svpOIVAAAAZScBCwAAAACgA3j14/HpsOtfSm+Pnljv7ZGM9fi7Y1NH1Lt713TmLqtIvgIAAKAiJGABANB5TB5f6RbQAb249MqVbgIdzOiZM0q+zTgX3aWM56Ozh+o4s1kBtAuPvvN5OuCq59Pk6TNTZxPJVxfuvnpacaF5Kt0UAAAAOikJWAAAAAAA7bzyVWdNvoppB6PyleQrAAAAKkkCFgAAAHRwXf57KefjAVAetbW12bSDnSn5qluXmrTlCoPTbussktZZvL9pBwEAAKg4CVgAAAAAAO3Uk8PHprdHT0wdWa+5uqTjv7tCWnbw3Klvj65p0Nw9U7+ec1W6WQAAAJAnAQsAAAA6uC41NdmlbI+XalKqLdvDAXRqVz81InVkphgEAACgPZCABQAAAADQDn019et0z2ujU3vW9b85u7MKEndNMQgAAEB7IwELAAAAAKAdGjV+appZmLnUTqtbLTJ/7zR6wtQ0cdpMUwwCAADQLknAAgAAgA6uy38v5Xw8ANrepOkzUzXr26Nbmjx9RrOqW0m4AgAAoD2TgAUAAAAA0A716d41VZu6CVYTp81Q3QoAAIAOTwIWAAAAdHBRXKRLTRkfr3wPBdCpDZ6nZ+rapaZi0xDGFIIn77hC6t+ne4MJVrEs4QoAAICOTgIWAAAAAEA7FIlNW64wKN35yqiyPWZDUwgCAABAZyYBCwAAAACgnYpEqHIkYC3cv3e6ZM81sqpbKloBAADA7CRgAQAAQAfX5b+Xcj4eAG3vq6lfpwF9umfJUR9+MbnNHqd3967prz9ZLS01qF+bPQYAAAC0ZxKwAAAAAADaidra2vTk8LHpqidHpHtfH51mzqpt08eL5KsLd189rbjQPG36OAAAANCeScACAACADq6mpia7lO3xUvkeC6AzefXj8emw619Kb4+eWJbHW2ZQv3TmLqtIvgIAAIAmSMACAAAAAKjSKQZHjZ+aJk2fmd78dEI68fbX05SvZ5Zk28Pm65UWnr93emr4F7NV0erWpSZtucLgtNs6i6R1Fu9f1gReAAAAaK8kYAEAAAAAdIIpButLrookr9ETpqaJ02amvj26pkFz90z9es5VsscEAACAzkACFgAAAHRwXf57KefjtbXPPvssPfPMM9nl2WefzS5jx47Nbttzzz3T5ZdfXpLHOeGEE9KJJ57YrHUffPDBtPHGG5fkcYHOqa2mGFy4f+90yZ5rpMHzzJlcFdclXAEAAEDrSMACAAAA2p1BgwZVugkAJfXoO5+nA656Pk2eXpopBgt9+MXkNGbi9LTUoH4l3zYAAAAgAQsAAAA6vC4131zK9nipvBZeeOG07LLLpnvvvbdNH+eVV15p9PbFFlusTR8f6NiVr9oq+Srn6qdGpHWXmL/Ntg8AAACdmQQsAAAAoN057rjj0pprrpldohrWBx980OYJUCuuuGKbbh/onGpra7NpB9sy+Src/dqo9NXUr003CAAAAG1AAhYAAADQ7px44omVbgJASTw5fGx6e/TENn+cmbNq0+gJUyVgAQAAQBuQgAUAAAAdXE2ZpwUs42yHAO1eTA1YLhOntW2VLQAAAOisyhl/BQAAAADgv2JKwHteG122x+vbo2vZHgsAAAA6EwlYAAAA0MF1qakp+6Uj2mKLLdICCyyQunfvnv278cYbpz/84Q/pyy+/rHTTgHZq1Pip2dSA5dCtS00aNHfPsjwWAAAAdDamIAQAAADazKefftrkOkOHDk3twX333Zdf/vzzz9PDDz+cXU4//fR0+eWXpx122KGi7QPaX/WrN0dNKNvjbbnC4NSv51xlezwAAADoTCRgAQAAAG1mrbXWanKd2tryVH8p1korrZR23HHH7LksuOCC6euvv05vvfVW+sc//pHuvffeNG7cuPS9730v3X777WnrrbeudHOBKhbHuyeHj01XPTki3fv66LJVvwq7rbNI2R4LAAAAOhsJWAAAANDBdfnvpZyP11Eceuih6YQTTpjj72uvvXbaY4890oUXXph+9rOfpZkzZ6Z99903vffee6lnT1N8AXN69ePx6bDrX0pvj55Y9sdeZlC/tM7i/cv+uAAAANBZSMACAAAA2swzzzyThgwZktqreeedt9HbDzjggPTss8+mSy65JH3yySfppptuSj/5yU/K1j6gfXj0nc/TAVc9nyZPn1n2x+7dvWs6c5dVUk1NTdkfGwAAADoLCVgAAADQwXWp+eZStscrWI7kq6FDh6aOLJKwIgErPPzwwxKwgDkqX1Uy+erC3VdPKy40T9kfGwAAADoTCVgAAAAArbD88svnlz/++OOKtgWoLrW1tdm0g5VIvoppB6PyleQrAAAAaHsSsAAAAABawbReQEOeHD42vT16Ytker1uXmrTlCoPTbussktZZvL/jEwAAAJSJBCwAAADo4LrUmRawHI/Xmbz++uv55QUXXLCibQGqy9VPjWjT7feaq0s6/rsrpGUHz5369uiaBs3dM/XrOVebPiYAAAAwJwlYAAAAAK1w4YUX5pc32mijirYFqB5fTf063fPa6DbbvikGAQAAoHp0tkGpAAAA0OnUpJrUpYyX+K89uPzyy7PpueJywgknzHH7K6+8kt59991Gt3HRRReliy++OFsePHhw2mmnndqsvUD7Mmr81DRzVm3JpxjcdqUh6Zr91kl3H7qB5CsAAACoEipgAQAAAO3OY489Nlty1JgxY/LL8fdIriq01157tfgxnn/++bTvvvumTTbZJG299dZppZVWSvPPP3+aMWNGevPNN9M//vGPdO+992brdu3aNUvG6tOnT6ueF9BxTJo+s6TbO2/XVdPGyww0xSAAAABUIQlYAAAA0MF1qfnmUrbHK8NjRNWpK664ot7bHn/88ezS2gSsMHPmzHT//fdnl4ZEUtYll1yStt9++6IeA+iY+nTvWtLtLTekn+QrAAAAqFISsAAAAADqsc0222SJVU8++WR68cUX0+jRo9PYsWNTbW1t6t+/f1pllVXSVlttlSV3zT333JVuLlBlBs/TM3XtUlOSaQhj6sFBc/csSbsAAACA0pOABQAAALQ7McVg3WkGWyoSpxqrjLXAAgukn/70p9kFoKWiWtWWKwxKd74yqtXb2nKFwapfAQAAQBUrx6wAAAAAQIU7/+W+AJDSbussUlXbAQAAANqGmCgAAAAAQIl9NfXrNKBP97Rw/96t2s4yg/qldRbvX7J2AQAAAKVnCkIAAADo4LKqVDVlfLza8j0WQDWpra1NTw4fm656ckS69/XRaeas1h0Qe3fvms7cZZVUU1PGgzgAAADQYhKwAAAAAABa6dWPx6fDrn8pvT16Ykm2F8lXF+6+elpxoXlKsj0AAACg7UjAAgAAAABohUff+TwdcNXzafL0mSXZXkw7GJWvJF8BAABA+yABCwAAADq4mLiqS/b/8j0eQGeqfFWK5KtuXWrSlisMTruts0haZ/H+ph0EAACAdkQCFgAAAABAEWpra7NpB1uTfLVw/97pkj3XSIPn6Zn69ZyrpO0DAAAAykMCFgAAAHRwXWq+uZTz8QA6gyeHj01vj57Yqm18+MXkNGbi9LTUoH4laxcAAABQXl3K/HgAAAAAAB3C1U+NqKrtAAAAAJUhAQsAAAAAoIW+mvp1uue10SXZ1t2vjcq2BwAAALRPpiAEAACATjD6qpwjsIz2AjqDUeOnppmzakuyrdjO6AlTU7+ec5VkewAAAEB5iYkCAAAAALTQpOkzS7q9idNKuz0AAACgfDpUBawJEyakO++8Mz377LPpueeeSx9//HH6/PPP05QpU9K8886bll9++bTNNtukffbZJ80///z1buPrr79ODzzwQLrnnnvS008/nd5+++00fvz41KdPn7T44ounzTbbLB144IHZMgAAALQHXWq+uZTz8QA6uj7du5Z0e317lHZ7AAAAQPl0qASsZ555Ju2666713haJWA8//HB2OeOMM9LVV1+dttxyyznWWW655dLYsWPnuH8kYb344ovZ5dxzz01//OMf0yGHHNJmzwUAAAAAqF6D5+mZunapKck0hN261KRBc/csSbsAAACA8utQCVhh2LBhaZNNNkmrr756tjxkyJA0a9asNHLkyHTjjTemm2++OY0ZMyZ997vfzRK2Vllllfx9p02blk+++ta3vpV22GGHtPbaa6dBgwZlCVh33XVXOu+889LUqVPToYcemnr16pX233//Cj5bAAA6q6uvuS49+sST6fkXX0qvvPZ6mj59errsb39Je+3+kxZtJ34r/+XCv6eLLr0ivTt8eOrbt0/6zsYbp1NPODYtvtii9d7nnvseSL//05nphZf+L9XU1KTVV10lHXPEb9Jmm2xUomdHpdwxeVJ6cdq09MbX0/+fvfsAj6pM2zh+z6STQid0pKMoVRRQAakqzbYoCoIFsaLLJ7CuDcGyrGBZKwjSrNhARAWlV5EqTWmC9BZKEkif73pfSEhIgEAmM5PJ/7fX+c6Zc95TJsyHzMl9nkebk5OULGlwsRLqEh6R62OsSUrUl3Fx9hgHUlOV4EpTmYBAXRocrF4RkbosOCTbPmkulybFx+m743HalpIiU/+jVlCw7omIVMuwIm5+lwAAuEdkaJA61I3WD2v25vlYHeqWtccDAAAAAAAFk18FsEzw6u+//z7r9m7dumny5Mm65ZZb7C+oXnzxRRvISmd+edSuXTsNGTJETZs2zfH4t912m52btoYDBw60FbciIyPz7T0BAAAAOXl2yEva/vcOlSpVUuXKRtvli9H38Sc1etwE1b30UvV7uK9279mjSd9M1oxZs7Rk9i+qWaN6tuBXzwf6qnSpUurd42T12S+++lbtOt+sSRPH6fZburrl/cE73jt2RHtSU1XM6VSpgAC7fKFMgGtJYoKuCA5Wk5AQhTqc2pWaonknTuiXE8f1YvGS6lQkPGO8y+XSoJiDmplwQhUDAtW1SLiSXC7NTTihf8Yc1MCixXVnBN+58soph508eT4AKAx6NK3ilgCWOQ4AAAAAACi4nPIjAQHmOelzu/nmm1W7dm27PH/+/CzbKlSooBkzZuQYvkpnKmI98sgjdtlUxfr555/zfN0AAADAhRr97tvatuF3Hdi+RQ/df99FHWP23Hk2fNXi2uZasWiuhr30oiaOGaXJn3+imJjDeqz/gCzjDx8+osefGmhDX2b82yNes5NZLlmyhB5+sr9iY2Pd9A7hDc8XK6nvo8trVrmKuv0Cql5ldkdEpGaUq6ARJUtrYLES6le0mIaVKKWJZaIVLIfePHrYhq7SmeCVmRoEh2hSdFkNKlZCzxUvqS/LlFO5gAA7fndKihvfJQAA7tOsWknVir64/2amqx0dqabVSrjtmgAAAAAAgOf5VQArt9IrVplWghfDVMBKt2XLFrddFwAAAJBbbVu3UpXKlfN0jA/HTrDzoc89o+Dg4Iz1N3Zop1YtrtWMmbP0947TlbW+/Hayjhw5qscfelAVK1TIWG+WH+vbRwcPHtK3332fsf6hfv+UI7yY/jP8jWznTt82bMSbeXoPcK+rQ0NVPjBvhZJDHDlXPqoRFKyqQYGKSUtTXKYA1pwTx+38vsgoWy0rXfGAAN0dEakkSVOOx2Wsn348Xo12/a3HD+7PEuQ637bCzvyxOD04neVjAAB+x1TUf71bAxUJPv+DoTkx+43oVt8eBwAAAAAAFFyFLoD1559/atWqVXa5Tp06F3WMxMTEC6q6BQAAAPiiOfMXKDw8XNc0y14BtkObNnY+d/7C0+PnLbDz9m1aZx/f9tT4BafHvzHsFV1ap7aef+kV/bZ8Rcb6b7+bqpFjxqp1yxYa8M9+bn5X8FU7UpK1LSVFZQMCFOk8/VX0UFqanZcPyB78qnBq3W+ZvoN1KBKuzkXCtTAxQZ/Gn664ZqpkvXwkRiWdTtvmkF9kAwA85fIKRTWyZ+MLDmGZ8WY/sz8AAAAAACjYCkUA6/jx49q0aZNef/11tWzZUimn2lc8+eSTF3W8uXPnZixfeumlbrtOAAAAwFPi4+O1Z+9eVa1SJceHCmrWqGbnmzJVfE1frlm9evbxp9ZlHh8WFqbPxo6W0+lU9973Ky4uTjt37dIDj/azLQsnjhlpt8E/rU1K1AfHjuido0f0TMxB3bV/r13/72JZWywVO/UZ2J2avc3grlPr/k5JzrJ+UNHiqhQQqLePHtGfSUlKdbn0zOGDine5bPiqBA/KAAA87LqapTWpbzOVjQrNddtBM97sBwAAAAAACr689ZbwYePGjdO999571u3/+te/dNddd13wcffs2aOxY8fa5dKlS2dpR5hbO3fuPO85AAAAgPx09NgxOy9aNCrH7VGRJ9cfPXosV/tERUVmG2/Ur3eFhg0drCcHPq2Hn+ivnbt3KybmsKZM+lTly5Vz4zuCr1mblKRRsac/D6Yy1ZDiJdUsNCzLuGtCQzX9xHGNjT2mJiGhGS0Mj6Sm6tO4kxWuYk9VyUpXxOnUqyVKqveBfXr68EFdFxqm1UlJujs8Us3POD5OMj9VT9YEo/4YgMLIVLK68pLi+v73nO/tBTod6lC3rHo0raKm1UpQrREAAAAAAD/itwGss2nQoIFGjRqlJk2aXPC+LpdLffv2VWzsyV8CPPfccwoNzd1TbZlVqlTpgvcBAAAACqp+jzyk6b/M0sefT7KvH+5zv7p0vMnbl4V8dmdEpJ0SXGn6OyVFn8TF6vFDB9QvqpjuORXwM24IC9d38fFalpSobvv2qHloqFJc0pyE4yrhNJWsUuXMIc5zWXCIHokqpv8dO6JtcbGqHRSkfkWLefhdAgBwWkpqmuZvOphl3ZNtaqpVnTKKCAlQdFSoIkODvHZ9AAAAAAAg//htv4+bb75Za9assdPSpUv12Wef6ZZbbtGqVavUvXt3ff/99xd8zFdeeUVTp061y6by1aOPPpoPVw4AAADkv6JR2StcZXYsNnu1q3Ptc+xY7FmrY5nqDjd37pjx+vGHHszz9aPgCHU4VSso2LYGbB4SagNTm5OTMrYHOhx6p1QZ9Y0sKqdD+iY+TrMSjqtlaBG9VrKUHVM8IOevri1DwzK+1N5aJEJBVBI5K/Oz9fQEAIXNqh1HdPRE1ra5d1xVSQ0qFVONMpGErwAAAAAA8GN+WwGrWLFidkpnKl7deeedmjhxonr16qWuXbtqzJgx6t27d66O98knn9iKV0bVqlX16aefyum8uPzajh07ztuC8KqrrrqoYwMAAAC5ER4ernJly+qv7duVmpqqgABTaei0TZu32nnN6tUz1pnlZStWatOWLSpZskTW8Vu2ZBuf7q9t2zTgmedVokRxHT58RA882k/zZvyQ7Zzwf01DQ7UgMUErExNVIyg4Y32ww6G+UUXtlNmyxAQ7vyzT2HTJLpeePXzILkc6HHrv2FG1CAtTdIDffs0FAPi42X/uz/K6TtlIlStKa1wAAAAAAAoDv62AdTY9e/bUP/7xD6Wlpemxxx5TTEzMefeZNm2a7r33XtuCsGzZsvr555/t/GJVrFjxnFO5cuUu+tgAAABAbrW89hrFx8dr4eIl2bZNnznTzltc2/z0+OuusfMZM2dlH//LzIxjZpaSkqK773vQtvH+YvxY9X/8US1a8qtefOU/bn8/8H0HUlMzql7lxo/H4+28Q5HwbNveOXZEG5KTdF9klIYWL6WjrjQ9F3NIaS6Xm68aAIDcmfXHgSyvr69TxmvXAgAAAAAAPKvQBbAMU/3KML9s+umnn845ds6cObr99tuVnJys4sWLa/r06aqew1P9AAAAgK86ePCQ/vhzo51n9uB9vez8uaEvKynpdEu4H6f/rDnzFqh9m9aqUrlyxvput95iWwy+/cEo7dy1K2O9WX5n5IcqVaqkbunSKcs5TNBq8a9L9X/9HlPb1q30yovPq1GD+nrltdc1f+GifHzXyG+HU1P1V3KynWe2Pikxx/F/JiXp6/g4W4b56pDQLNvi0tKyjf/lxHFNOR6vukHBah2atXrIkoQT+jguVlcEBevByKK28lW38AgtS0rU2Lic22oWdk45PD4BQGGy92iCNuzJ+t+g62sTwAIAAAAAoLAolL0ZSpcunbG8ffv2s45bunSpOnfurISEBEVEROjHH39UvXr1PHSVAAAAwNmNHjdBCxYttstr1q0/uW78RM2Zv8AuX9u8mR7ofY9dfmfkKL34yjC98O9BGvzM0xnHuL5lCzvGHKtR85bqeEN77dm7V198/a1tF/j2iP9mOWfx4sX0zojX1POBvnb8HbffYtd/8dW3OnQoRl9MGKvIyMiM8fMWLLRBKxO4ennwyXbewcHB+nTsaDW+tpV63P+gVi9ZkKV1OLzr2/g4rToVoNqUfDKUN/l4vJafWtcgOES3hEfY5S/iYzUq9pgejIzSQ1Gn/wwHxBxUgBy6NDhYZQMClOJyaVtKin5NTJCpTTWgaHGVD8z6VfSeA3tVNiBQVQMDbTvCdUlJNkxVMSBQw0qUUkCmilkm8PX84RiFOxx6pUSpjGpa/yxaXCsSEzXy2FFdFRKqK4JDPPATAwDgpDlntB+MCg1Uo8r8GwcAAAAAgMKiUAawdmV6Wt8Eq3Ly+++/64YbblBcXJxCQ0M1depUXX311R68SgAAAODsTPhq/CefZVlnWglmbieYHsA6l5Fvv6kr6l6mUR+N11vvfaCIiHBbxerlF55T9WpVs43v0f0OlSpZUq8MH6GxEz+Vw+FQ44b19ezAAbbCVbrDh4+ox/19FRYWps/GjbHBq3S1a9XUm/99VX0e7ac+jz2hLz8en4efBNzJhK+mnmr7l3ldeijLSA9gnc19kUU1P+GE1iQlan5amm0JWCogQDeEFdEdEZE5BqPahxXRrBMn90lxSeUDA/RAZJTuiYhShDNr4ebBRw7pYFqqXipeUhUyBblCbCCrpHru36dnYg7pszJlFX7GvoWZ03Fy8uT5AKAwmX1GAKtFrdIKDOC/QwAAAAAAFBYOl8tlHkIuVDp27KgffvjBLs+ePVutWp3+RZGxceNGtWjRQvv27VNQUJAmT56sm266yWPXt3PnTlWqVMku79ixQxUrVvTYuQEAAPza8aPevgL4oZW1qJIL99qXmqIb9+7O83fCzN8t34osoRLOAHlKTFqqnoiNsct8rwUKHl+4N5WamqoDBw5kVLMPCPDc32EXKjElVY2G/Kz4pNNteUf8o75ua8zfff6kIH0mUTjwmYQv4nMJX8NnEr6oIHwufeE7IVAQ+dVjWOPGjbPtAs/ljTfeyAhfVa1aVdddd12W7X///bfatm1rw1fmL7tPP/3Uo+ErAAAAAADczXHqBoCnJgpgAShMlm07nCV8ZbSsXdpr1wMAAAAAADzPr1oQDh48WP/3f/+n2267Tddee62qV69uWwzGxsZqzZo1+uSTT7Rw4UI71rRAGTVqVJZE6aFDh2z4yqQ4DXOsOnXqaO3atWc9Z/HixVWhQgUPvDsAAAAAAAAAviI2IVl7jyboi99O3ktMV79iUZWKyN5yFwAAAAAA+C+/CmAZMTEx+vDDD+10NqZE3kcffWTDVpmZkNamTZsyXv/3v/+107n06tXLVt4CAAAAAAAA4N9cLpcWbz2kiYu3a8b6fUpNc2UbU6NMhB3ncFAPEAAAAACAwsKvAljTp0/XtGnTbJWrzZs32zaCpqpVWFiYypQpowYNGqhTp07q1q2bihQp4u3LBQAAAADAI0wEwJMxACIHAPzR2l1H1X/SKm3cF3fOcV+v2KU1u47q9W4NdHmFoh67PgAAAAAA4D1+FcCqXbu2nfr3739R+7dq1co+nQYAAAAAAABcrKSkJE2YMEFffvmlfv/9d1uxPSgoSBUqVFDz5s3Vp08fOz+fH3/8UaNGjdJvv/2mAwcOqHTp0mrSpIkefPBB3XjjjR55Lzhp/qYD6jtxuY4npeZqvAlpdRu5WCN7NtZ1NUvn+/UBAAAAAADv8qsAFgAAAAAAyM7pcNjJk+cDCqvt27erY8eOWrduXbZQ1saNG+00btw4Pf7443rrrbdybFOXlpZmQ1ZjxozJsn7Xrl12mjx5sh544AGNHDlSTqcz399TYWcqX11I+CqdGW/2m9S3GZWwAAAAAADwc9yhAQAAAAAAANwgOTk5S/iqXr16Nmy1ePFizZgxQ88//7zCw8PttrffflvDhg3L8TjPPPNMRviqYcOG+uyzz7R06VI7N6+N0aNH69lnn/XYeyusTLV803bwQsNX6cx+/zdpNVX3AQAAAADwc1TAAgAAAAAAANxgypQpGeGrZs2aaf78+QoICMjY3q5dO3Xp0sVuM2EtE8B66qmnFBh4+hadqZA1fPhwu3zllVdq3rx5CgsLs69N+0Gzf8uWLbVs2TK99tpruu+++1SjRg2Pv9fCYvHWQ7adYF78uS9WS7bGqFn1km67LgAAAAAA4FuogAUAAAAAgJ9zeGECCqNFixZlLD/99NNZwlfpGjdurE6dOtnlI0eOaMOGDVm2v/nmm0pJScmokpUevkpXpEgRu94w49544418eS846eMl233qOAAAAAAAwDcRwAIAAAAAAADcICkpKWO5WrVqZx1XvXr1HPcxbepMFS2jTp06atq0aY77m/W1a9e2y2Y87e3yR2xCsqav2+eWY/20bq89HgAAAAAA8E8EsAAAAAAA8HNUwAI8Iz0UZWzduvWs47Zs2WLnDodDNWvWzFj/119/affu3XbZtBk8l/Ttu3bt0rZt2/J87chu79EEpaa5J9xmjrPvWIJbjgUAAAAAAHwPASwAAAAAAADADbp3766oqCi7PGzYMKWmpmYbs3LlSk2bNs0u33XXXRnjjfXr12csmwpY55J5+5ltDOEe8UnZ//zyIi7RvccDAAAAAAC+I9DbFwAAAAAAAAD4g1KlSmnixIk2iLVw4UI1adJETz75pGrVqqW4uDi7bsSIEbbtYKNGjexyZjt37sxYrlix4jnPValSpYzlHTt2XNB1Zj5PTvbs2ZOxbEJkOQXJ8ps5Z1paWsayN4QGureeX1igw2vvBf7xmQQy4zMJX8TnEr6GzyR8UUH4XPrqdQG+jgAWAAAAAAB+ztNtAWlBiMKsS5cuWr58uQ1XjRkzRr169cqyPTo6WkOHDlWfPn1UpEiRLNtiY2MzliMiIs55nvDw8IxlE+66EJnDW+dz6NAhhYSEyNPMLySOHj2a8drp9Hwh/6CkVAU4pFQ3dCEMcEqBSXE6cOCEOy4NXuALn0kgMz6T8EV8LuFr+EzCFxWEz6X5Hgjgwvne/zcDAAAAAAAABZSpbjVhwgRNmTJFLlf25M6+ffv08ccf65dffsm2LSEhIWM5ODj4nOfJHIo6cYJQT34IDwlQyxrF3HKsVtWL2+MBAAAAAAD/RAUsAAAAAAD8nMPhsJMnzwcURvHx8brxxhs1f/58BQQEaODAgbr33ntVrVo1G6769ddfNWTIEC1YsEA333yzhg8frv79+2fsHxoamiXIdS6JiYkZy2FhYRd0nedrWWhaEF511VV2uWTJkipdurS82fLCtHY0P09vuK+FU7M2/eaG49RQ6dIl3XJN8A5f+UwC6fhMwhfxuYSv4TMJX1QQPpeZv28CyD0CWAAAAAAAAIAbDB482IavjDPbD5qKVu3atdP111+v9u3ba/bs2RowYIDatGmj+vXr2zGRkZG5bitowl65bVd4pooVK+Z6rPllgLd+IZDeisOb13BNjdKqFR2hjfsurM1jZrWjI9W8RmnCqX7AFz6TQGZ8JuGL+FzC1/CZhC/y9c+lL14TUBDQghAAAAAAAADII9Nu8KOPPrLLtWrVyhK+yiwwMFBDhw61y2lpaRo3blyOwaidO3fmuopVpUqV8nz9yJkJTb3erYGKBF/cLyDMfiO61Sd8BQAAAACAnyOABQAAAACAn3N4YQIKm3379ikmJsYuN2zY8JxjGzdunLH8xx9/ZCxfdtllOa7PSebtl1566UVdM3Ln8gpF9UGPRnI6Ljx8NbJnY7s/AAAAAADwb7QgBAAAAAAAAPLIVLZKl5KScs6xycnJOe5XtWpVlS9fXrt379bcuXPPeYx58+bZeYUKFXTJJZfk4cpxNrEJydp7NEHxSanadyxRaa4LaztoKl8RvgIAAAAAoHAggAUAAAAAgJ9zeLgENhWwUBiVKFFCUVFROnbsmBYvXmxDWJnDVZllDleZ0FU606aua9euev/9922FqyVLlqhp06bZ9jfr0ytgmfG0t3NvK8nFWw9p4uLtmrF+n1LPkroKC3IqKdWVZXug06EOdcuqR9MqalqtBH8uAAAAAAAUIgSwAAAAAAAAgDxyOp3q2LGjPvvsM1vB6uWXX9YLL7yQbdzhw4c1aNCgjNedOnXKsv3JJ5/UqFGjlJqaqscff9xWugoLC8vYfuLECbveMAEvMx7usXbXUfWftEob98Wdd2xkaJDeuauhSoQHKy4xVREhAYqOCrXrAQAAAABA4ePJB2ABAAAAAAAAv/X888+rSJEidnnw4MHq0qWLvv76a61cudJWxXrjjTfUoEEDrV+/3o5p06aN2rdvn+UYtWrV0oABA+zysmXLdM011+iLL76wy2ZuXptlw4yrWbOmx9+nP5q/6YC6jVycq/CVsT82Ub3H/qY9RxPUoFIx1SgTSfgKAAAAAIBCjApYAAAAAAD4OdMFy5OdsOi6hcKqTp06mjJlirp3766DBw9q6tSpdspJ69at9eWXX+a4zVTP2r9/vz766CMb3rrzzjuzjbn//vv10ksvuf09FNbKV30nLtfxpNQL2s+MN/tN6ttMl1comm/XBwAAAAAAfB8VsAAAAAAAAAA3adu2rf744w8NGzZMrVq1UunSpRUUFGTbCFatWlXdunXT5MmT9csvv6h48eJnbWc4ZswYTZs2TV27dlX58uUVHBxs5+b1Dz/8oNGjR9txyBuXy2XbDl5o+Cqd2e//Jq22xwEAAAAAAIUXFbAAAAAAAPBzjlP/8+T5gMKsZMmSGjhwoJ3y4qabbrIT8s/irYdy3XbwbP7cF6slW2PUrHpJt10XAAAAAAAoWHhMDgAAAAAAAECh9PGS7T51HAAAAAAAUDARwAIAAAAAAABQ6MQmJGv6un1uOdZP6/ba4wEAAAAAgMKJABYAAAAAAH7O4YUJAHzd3qMJSk1zueVY5jj7jiW45VgAAAAAAKDgIYAFAAAAAAAAoNCJT0p16/HiEt17PAAAAAAAUHAEevsCAAAAAABA/vJ0VSoqYAEoCMKDA9x6vIgQ9x4PAAAAAAAUHFTAAgAAAAAAAFDolC0aqgCneyKjgU6HoqNC3XIsAAAAAABQ8BDAAgAAAACgEHz5NxkDj03efsMAkAuRoUHqUDfaLcfqULesPR4AAAAAACicuCcKAAAAAAAAoFCJTUjWpn2xalatpFuO16NpFbccBwAAAAAAFEyB3r4AAAAAAAAAAMhvLpdLi7ce0sTF2zVj/T6lprncctza0ZFqWq2EW44FAAAAAAAKJgJYAAAAAAD4Ocep/3nyfADgS9buOqr+k1Zp4744tx63SHCARnSrL4eDv/cAAAAAACjMCGABAAAAAAAA8FvzNx1Q34nLdTwp1e3hq5E9G+vyCkXdelwAAAAAAFDwEMACAAAAAKAQoDYLgMJa+So/wlem7aCpfEX4CgAAAAAAGASwAAAAAAAAAPgdl8tl2w66K3wV6HSoQ92y6tG0ippWK0HbQQAAAAAAkIEAFgAAAAAAAAC/s3jrIW3cF5fn4wztermaVS+h6KhQRYYGueXaAAAAAACAf3F6+wIAAAAAAED+MkVaPD0BgLd9vGS7W46zZOsh1SgTSfgKAAAAAACcFQEsAAAAAAAAAH4lNiFZ09ftc8uxflq31x4PAAAAAADgbAhgAQAAAADg5xxemADAm/YeTVBqmsstxzLH2XcswS3HAgAAAAAA/okAFgAAAAAAAAC/Ep+U6tbjxSW693gAAAAAAMC/EMACAAAAAAAA4FfCgwPceryIEPceDwAAAAAA+JdAb18AAAAAAADIX0457OTJ8wGAN5UtGqoAp8MtbQgDnQ5FR4W65boAAAAAAIB/ogIWAAAAAAAAAL8SGRqkDnWj3XKsDnXL2uMBAAAAAACcDQEsAAAAAAD8nMMLEwB4W4+mVXzqOAAAAAAAwH8RwAIAAAAAAADgd5pVK6la0RF5Okbt6Eg1rVbCbdcEAAAAAAD8EwEsAAAAAAAAAH7H4XDo9W4NVCQ44KL2N/uN6FbfHgcAAAAAAOBcCGABAAAAAODnTHbA0xMA+ILLKxTVyJ6NLziEZcab/cz+AAAAAAAA50MACwAAAAAAAIDfuq5maU3q20yXlCyS67aDZrzZDwAAAAAAIDcCczUKAAAAAAAUWKYglSeLUlEAC4CvMZWsejWrohe/35Dj9kCnQx3qllWPplXUtFoJ2g4CAAAAAIALQgALAAAAAAAAgN+bt+lgltftLo3Wo61rKCIkQNFRoYoMDfLatQEAAAAAgIKNABYAAPBNx496+wrgh5L6/cPblwA/NG73EW9fAvxMrCvN25cAAH4nITlVS7bGZFnXuUF5NahUzGvXBAAAAAAA/AcBLAAAAAAA/Jzj1P88eT4A8CXLth3WieTUjNemw+B1NUp59ZoAAAAAAID/cHr7AgAAAAAAAAAgP83duD/L6/oVi6l4eLDXrgcAAAAAAPgXKmABAAAAAODnTKUXp8Oz5wMAXzJ344Esr1vWKu21awEAAAAAAP6HClgAAAAAAAAA/NbuIye0cV9clnUtaxPAAgAAAAAA7kMACwAAAAAAAIDfmndG9auiYUG2BSEAAAAAAIC70IIQAAAAAAA/ZzoCerIrIB0IAfhy+8Fra5ZSgCf7sgIAAAAAAL9HBSwAAAAAAAAAfiklNU0LNh/Msq5lLdoPAgAAAAAA96ICFgAAAAAAfo4KWAAKq1U7jig2ISXLOgJYAAAAAADA3QhgAQAAAAAAAPArsQnJ2ns0QV8s25FlfZ2ykYqOCvXadQEAAAAAAP9EAAsAAAAAAABAgedyubR46yFNXLxdM9bvU2qaK9uYGmUi7DiHg1p9AAAAAADAfQhgAQAAAABQKFoQei5sQKwBgKet3XVU/Set0sZ9cecc9/3ve7RxX6xe79ZAl1co6rHrAwAAAAAA/s3p7QsAAAAAAAAAgIs1f9MBdRu5+Lzhq3RmnBlv9gMAAAAAAHAHAlgAAAAAAPg502nL0xMAeKryVd+Jy3U8KfWC9jPjzX5mfwAAAAAAgLwigAUAAAAAAAqc/fv36/vvv9fzzz+vG2+8UaVKlZLD4bBT79698/38e/bsUfHixTPO2apVq3w/J4CsXC6XbTt4oeGrdGa//5u02h4HAAAAAAAgLwLztDcAAAAAACgQT1958gksT5wrOjpa3vT444/ryJEjXr0GoLBbvPVQrtsOns2f+2K1ZGuMmlUv6bbrAgAAAAAAhQ8VsAAAAAAAQIFWuXJltW/f3mPnmzp1qr7++muVKVPGY+cEkN3HS7b71HEAAAAAAEDhRQALAAAAAAAUOKb1oAlC7d27V9u3b9fIkSM9ct64uDg9+uijdnn48OEeOSeA7GITkjV93T63HOundXvt8QAAAAAAAC4WLQgBAAAAAPBzjlOTJ8+X31588UV5w7///W/t2LFD119/vXr27Kl77rnHK9cBFHZ7jyYoNc3llmOZ4+w7lqDI0CC3HA8AAAAAABQ+VMACAAAAAADIhaVLl+rdd99VcHCw3n//fW9fDlCoxSeluvV4cYnuPR4AAAAAAChcqIAFAAAAAIC/czjkcHiwBpYnz+UhKSkp6tOnj9LS0jRo0CDVrl3b25cEFGrhwQFuPV5EiHuPBwAAAAAAChcqYAEAAAAAAJzH8OHD9fvvv6tGjRq2DSEA7ypbNFQBTveEPQOdDkVHhbrlWAAAAAAAoHCiAhYAAAAAAMg3e/bsOe+YihUrypdt2bJFQ4YMscumBWFoKEENwNsiQ4PUoW60flizN8/H6lC3rD0eAAAAAADAxSKABQAAAACAnzM1YjzZFDDzua666qrzjne5XPJlDz30kE6cOKE77rhD7du39/blADilR9MqbglgmeMAAAAAAADkBS0IAQAAAAAAzmLChAn65ZdfFBUVpTfeeMPblwMgk2bVSqpWdESejlE7OlJNq5Vw2zUBAAAAAIDCiQpYAAAAAAD4OW9WwFq6dKnKlSungujgwYP6v//7P7v88ssvF9j3Afgrh8Oh17s1ULeRi3U8KfWC9y8SHKAR3erb4wAAAAAAAOQFASwAAAAAAJBvTGipYsWKKoj69+9vQ1hXXnmlHnnkEW9fDoAcXF6hqEb2bKy+E5dfUAjLhK/MfmZ/AAAAAACAvCKABQAAAAAAcIbdu3dr4sSJdrl169aaNGnSOcfv379fn3/+uV2uWrWqrr76ao9cJwDpupqlNalvM/WftEob98Xlqu2gqXxF+AoAAAAAALgLASwAAAAAAPycaa/lyRZb/tDOKykpKWP5v//973nHb9iwQd27d7fLvXr1IoAFeJgJU33ywNVq8vLMHLcHOh3qULesejStoqbVSvjF31MAAAAAAMB3EMACAAAAAAAAUOCt2XU0y+vQIKc+faCposICFR0VqsjQIK9dGwAAAAAA8G8EsAAAAAAA8HNOx8nJk+cr6C655BK5XK7zjkuvotOyZUvNmTPHA1cG4GxW78gawKpXoZgaVSnutesBAAAAAACFh9PbFwAAAAAAAOAN48aNy2jPOHjwYG9fDoA8Wr3zSJbX9SoW9dq1AAAAAACAwoUKWAAAAAAAoMBZsGCBNm/enPH64MGDGctmvQlXZda7d2+PXh8AzzIV637feUYFrErFvHY9AAAAAACgcCGABQAAAACAn7NVnjzYF9CRlv/nGj16tMaPH5/jtoULF9opMwJYgH/befiEYuKTsqyrTwUsAAAAAADgIbQgBAAAAAAAAFCgnVn9qliRIFUuUcRr1wMAAAAAAAoXKmABAAAAAODnHI6TkyfPl99Mi8Ez2wxeKFMVK6+VsUzbMwDe9/vOI1le16tYzFb/AwAAAAAA8AQqYAEAAAAAAAAo0FbtyBrAov0gAAAAAADwJAJYAAAAAAAAAAqs1DSX1u46mq0CFgAAAAAAgKfQghAAAAAAAD/njy0IASDd1gNxik9KzbKOClgAAAAAAMCTqIAFAAAAAAAAoMBavTNr9atyRUNVJirUa9cDAAAAAAAKHypgAQAAAADg7xwOOSiBBcBP/b7zSJbX9ah+BQAAAAAAPIwKWAAAAAAAAAAKrNU7zgxgFfPatQAAAAAAgMKJABYAAAAAAACAAikpJU0b9sRmWVefABYAAAAAAPAwWhACAAAAAODnTEdAOhAC8Ed/7D2mpNS0LOuuoAUhAAAAAADwMCpgAQAAAAAAACiQVu88muV11VLhKhoW5LXrAQAAAAAAhRMVsAAAAAAA8HMOh8NOnjwfAHjC7zuOZHldn+pXAAAAAADAC6iABQAAAAAAAKBAWr0zawCrXsViXrsWAAAAAABQeFEBCwAAAAAAP2cKUnmyKBUFsAB4Qnxiijbvj8uyrn4lKmABAAAAAADPI4AFAAAAAAAAoECJTUjWjHV7leY6vS7A6dBl5QhgAQAAAAAAzyOABQAAAAAAAMDnuVwuLd56SBMXb9eM9fuUmjl9JalIcIBW7jisZtVKykEpPgAAAAAA4EEEsAAAAAAA8HNOh8NOnjwfALjT2l1H1X/SKm3cl7XlYGaxCSm668NfVSs6Qq93a6DLK1ANCwAAAAAAeIZTfmb//v36/vvv9fzzz+vGG29UqVKl7BNvZurdu/dFHfOXX36x+9aoUUPh4eEqWrSoatWqpdtvv13vv/++4uLOfuMHAAAAAAAAwMVbsPmguo1cfM7wVWZmnBk/f9OBfL82AAAAAAAAv6yAFR0d7bZjHT58WPfee6+mTJmSbduxY8e0adMmff3112rWrJkaNGjgtvMCAAAAAOBOpiCVJ4tSUQALgLv8sf+4Hvlqo44npV7QfmZ834nLNalvMyphAQAAAACAfOd3AazMKleurDp16mjGjBkXvO/Ro0fVrl07LV++3L6+5ZZbbMWr6tWrKyAgQDt27NDcuXNtAAsAAOBsPv7sC81ftFjLV67SmnXrlZSUpLEfvKvePe++oOOkpaXp3ZEfatRH47V561ZFRISrbatWennwc6pW9ZIc95n+80y9MnyEVqz63VYDbdywvp4dOEBtrm/ppncHb/l08x4t2HtYKw8d09qYOCWlufThdXV1T63yuT7Gwr2HNWX7fs3bc1jb4xIUn5KqKhGh6ly5jAbWv0TFQoKy7eNyuew+763foT+PxOtoUooqRoSqRdnieqreJaoWVcTN7xSe9IcrSbuVqv1K1UGlKU1SW4XqMkdwro+x05Wib3T8rNvPPN4JV5q2KEV/KUWHlKo4uRQsh6LlVAOFqIrDr7+yAgDOw/zbY8j0vy44fJXO7Pd/k1brpyevs/8eBgAAAAAAyC9+dzfbtB5s0qSJnUw1rG3btqlq1aoXfJzHH3/chq9CQkI0adIkdenSJcv2K6+80oay3njjDaWmXtxNIAAA4P+eHfKStv+9Q6VKlVS5stF2+WL0ffxJjR43QXUvvVT9Hu6r3Xv2aNI3kzVj1iwtmf2Lataoni341fOBvipdqpR69+hu133x1bdq1/lmTZo4Trff0tUt7w/eMXj5ZhuaKhUapHJFQuzyheo+63cdTEjWNdHFdHeNcjK/kpy397BGrNmmb7bt09zOTRQdFpJln0FLN+qttX+rXJFgda5SRlFBgfo9JlYf/blLk7bu1dxOV6luiQg3vlN40mIlKlYuhcqhcDns8sWqoAA7nan0Ges2K0WzlWDPV0mBdm5CWFuUrO06rmtcIWrsyPo5BAAUHit2xmnroQv/d05mf+6L1ZKtMWpWvaTbrgsAAAAAAMDvA1gvvvhino+xYMECTZw40S6/9NJL2cJXmZmn5wID/e7HCAAA3GT0u2+rZo1qqlK5sv4z/A09/cKF/1tl9tx5NnzV4trm+nnqZAUHn6wec1e3f+imW/+hx/oP0PTvvskYf/jwET3+1EAb+lqxaK4qVqhg1w/q/6QaNm+hh5/srw5tWysyMtKN7xSe9P61l6lGVBFViQzTa6v/0rPLNl/wMfrVray7apRT+fDQLFUm+i36Q6P+2KmXV27V/5pfmrFt7/FEvb3ub1sl67dbmqpo8OkKWW+t3a6Bv5pw1naNalHXDe8Q3tBGYSomp6IcTi1zJWqREi/6WCZ81dRx+rN1NuZ8nRSmqgrMUpnksCtYXyjehsJqu4IU4XBe9LXgJIf5nwerv5jzAUBeff37frcc5+Ml2wlgAQAAAACAfMVd7By88847dl60aFE99thj3r4cAABQgLVt3cqGr/Liw7ET7Hzoc89khK+MGzu0U6sW12rGzFn6e8fpylpffjtZR44c1eMPPZgRvjLM8mN9++jgwUP69rvvM9Y/1O+fcoQXswGxM6VvGzbizTy9B7hXmwolbfgqL56qXzVL+Mow4Yx/N6xml+fvOZxl2/a4E0pzSc2ii2UJXxk3VSpl5wcSkjLWTdqyVyFjflaX6StssCuzc22D91R2BNrwlSdVcgSqmiMoWzCouCNAtRRk2yDu0emKw7tdKXrbdUyfuuKUcsZn51zbAAAFT2xCiuZuPuKWY/20bq9iE5LdciwAAAAAAICcEMA6Q1JSkqZMmWKX27Vrp9DQk7+UMm0Gd+zYYVsaJiTkrfQ5AADAhZgzf4HCw8N1TbOm2bZ1aNPGzufOX3h6/LwFdt6+Tevs49ueGr/g9Pg3hr2iS+vU1vMvvaLflq/IWP/td1M1csxYtW7ZQgP+2c/N7wq+Ksh5MggTeGqezlTcCnY6tHjfER1LSsmy7YcdB+38+vIlMtZ1q15WPWuW0/Sdh2zlrHTbYk/osUUbFB0WrNEtLvdoRR54zlGlaaUrUb+5ErXBlaQ4l4lSXdyX1cxfWss7AtVEwTqotCwVuhJdLk3XCdvg8AaFKZDPVTYmW+fpCQDyYu+xBKW6KU+bmubSvmPczwMAAAAAAPmHW6JnWL16dUbA6oorrtCxY8f05JNPqlSpUqpcubKqVq1qK2OZcNacOXO8fbkAAMDPxcfHa8/evapapYoCAky0ICvT3tDYtGVLxrr05ZrVq2cff2pd5vFhYWH6bOxoOZ1Ode99v+Li4rRz1y498Gg/lSxZQhPHjLTbUDiM27jbzttWyNqmp2RosF5qUlN/xyWo3tcL9djCDfr30k3q9NMKPfPbJvW9tKIeuaxSln3ebFZH1aPCbIvE1Ydi7S8/e89ZYwNco1vUVZmw0xXd4F/+VIrmK9G2EPxZCRqnOM1zJSgtl5WpTKBqs1JsoKq8/b+nXaUQlVOAVilJ21wnq5nM0gnFyqUWClUJR/a/KwEABc/xxKyB77yKSzxdUREAAAAAAMDdAt1+xAJu/fr1GctpaWm68sortWnTpmxVsn755RfNnDlTr776qgYNGnRB59i5c+c5t+/Zs+cCrxoAAPiro8eO2XnRolE5bo+KPLn+6NFjudonKioy23ijfr0rNGzoYD058Gk9/ER/7dy9WzExhzVl0qcqX66cG98RfJkJSb28covKhAbr/+pdkm37E5dXUYUiIXpowXp9+Mfpf9NeE11Md1Yvp8AzgnoRQYGa2OoKtfz+N/WcvUY3VS6lxfuPql/dympf8WTbQviXMDnUXCGqqkBFyalkuWwLQVOtygSmTF2q65S19WVOZuuEjsulpgpR2BmllJwOhzq4wvSZ4my4q4ErTZuUouoK1OUOQn0A4C+KhLj3tmVECAFdAAAAAACQfwhgnSEmJiZjediwYbYa1g033KAhQ4aoXr16tiLW119/rX/96186evSondepU0ddu3bN9TkqVcpaGQAAAMAX9HvkIU3/ZZY+/nySff1wn/vVpeNN3r4seMjWY8d184yVttXPxOuvUKnQ7EEWE856ddVfeqFRdXWvUU7FggNtaGvArxvVbtoyfd6mnjpXKZNln8ali2pwo+p6Ztlm/bkmXvVLROrlJjU9+M7gSSUdASqZqWJVkByqLqfKugL0qeK1Wklq7ApWkXP0p1voStBGpaiKAnSlcg5URTmcut4Vpp90wlbZipBDbRSWL+/Jbzgcnm35SRtIAHlUNipUAQ65pQ2haa0cHXX+ADAAAAAAAMDFopdMDm1+0pnwlWk1+P3336tJkyYKCQlR6dKl9dBDD9l16a14nn76ably2UoDAADgQhSNyl7hKrNjsdmrXZ1rn2PHYrONT2d+MX9z544Zrx9/6ME8Xz8Khr9iT6jDD8t1MCFJn7Wup1blS2QbM3PXIQ1ZsVUPX1pJA+pXVcXwUFvh6pqyxfVNuwYKcjo0aOnGHI/fqUoZOU9lMe6vU0HBAXwNKWzCHU5VU6DSJO3V2VtALXYlaLmSVFEB6qgittrV2VRSQEY8q7aCFErgBwD8SmRooFrWKOaWY3WoW1aRoUFuORYAAAAAAEBO+M3HGUJDsz4NZ6pgBQRkL1F+7bXX6tZbb7XLGzZs0Jo1a3J9jh07dpxzWrp0qRveCQAA8Afh4eEqV7as/tq+Xamp2UMLmzZvtfOa1atnrEtf3rRlS/bxp9ZlHp/ur23bNOCZ51WiRHEbxnrg0X45nhP+V/mq/bRl2nMiUZ+0rqeOlUvnOG76zoN23jKHcFbZIiGqXSxcW46dUFxySpZtyWlpunfuyX8rm4pZg5dv0c74hHx5L/BtobYBoZT1E5I1fPWbklRBAeqsIgo8T6DqFyUo6dRxVypJB1z8fXUu5sfp6QkA8uq2elkra16sHk2ruOU4AAAAAAAAZ0MA6wyRkZEZy6baVcOGDc86tkOHDhnLv/32W67PUbFixXNO5cqVy8M7AAAA/qbltdfYKp0LFy/Jtm36zJl23uLa5qfHX3eNnc+YOSv7+F9mZhwzs5SUFN1934OKjY3VF+PHqv/jj2rRkl/14iv/cfv7gW+Fr0zlKxu+ur6eupzRPjCzpLSTFV9NlaycmPWmylXQqSqx6Z5btlkrDsZqUP2q+qjl5YpJTNZ9c9cqjQqyhc6+U5WvIk8Fsc4WvuqiIgo6T3pntStJfynFVr66WUXsOtOOMJnPFQD4lUYVI1StZN5aB9aOjlTTatkD5AAAAAAAAO5EAOsMlSpVylg2Yajcjj1w4EC+XhcAAPB/Bw8e0h9/brTzzB68r5edPzf0ZSUlnQ6//Dj9Z82Zt0Dt27RWlcqVM9Z3u/UW22Lw7Q9GaeeuXRnrzfI7Iz9UqVIldUuXTlnOYYJWi39dqv/r95jatm6lV158Xo0a1Ncrr72u+QsX5eO7Rn4zwag/jsRnC06ltx3cfTxRH19/hbpecu4KE83LnGwB9Naa7TqalJxl26gNO7QzPlFNyxRTSKb2gr/sOqQ312zX1aWL6tmG1Wx1rYcuraS5ew7rtdXb3Po+4VknXGmKcaXaeWb7z1KFapUrUTuVqmJyKlpZKwwvORW+Kp/L8NUhV6oWKEFRcuh6haqMI0DNFaLDStM8UV0NAPyJqcr6fIeqKhKcvTp9bpj9RnSrb48DAAAAAACQnwLz9egFUN26dTOWz9dyJ/P2wEB+lAAAILvR4yZowaLFdnnNuvUn142fqDnzF9jla5s30wO977HL74wcpRdfGaYX/j1Ig595OuMY17dsYceYYzVq3lIdb2ivPXv36ouvv7XtAt8e8d8s5yxevJjeGfGaej7Q146/4/Zb7PovvvpWhw7F6IsJY7NU/Zy3YKENWpnA1cuDn7PrgoOD9enY0Wp8bSv1uP9BrV6yQMWKnQzgwPs++nOnFu07YpfXxsTZ+diNuzRvb4xdbh5dTPfVPvkwwfvrd+illVttAOq5RqdbT3b4YZn+jk+w4ag1MXF2OlPm8bdVjdaoP3Zo/t4juvzLRepUubSKhgRq5cFYzdkTo7AAp/57da2M8Sbw9cC8tYoMCtT4669Q4KnKWMOuqqn5ew9ryIotur58CV1Vpmi+/ZxwYda6krTnVJWqg6fm65SsXadCVeUUoMsdwXZ5tZK0VEm6SsFqqtOVSabpuJwuh6LlVIScSpZLe5WqA0pTiKT2CpMz0y/B17tOHsd8Okwwa7kSpTOKWFVUoCo6Tn7fSnG5bKUrM+QGhSn41LEaKljblWKvt4orUDUcQfn94ypwTrYF9FwAgawDAHepU6aI3r+7oR7+ZKWOJ6VeUPhqZM/GurwC/9YAAAAAAAD5j9TQGapUqaLKlSvr77//1rZt2+Ryuc56k3rLli0ZyxUqVPDgVQIAgILChK/Gf/JZlnWmlWDmdoLpAaxzGfn2m7qi7mUa9dF4vfXeB4qICLdVrF5+4TlVr1Y12/ge3e9QqZIl9crwERo78VP775nGDevr2YEDbIWrdIcPH1GP+/sqLCxMn40bY4NX6WrXqqk3//uq+jzaT30ee0Jffjw+Dz8JuJMJX03ctCfbuvRQlpEewDqb7XEnKwX9euConXKSOYAV4HRo2g2N9b+12/XVX/v0+dY9Skp1KTosWHdVL6eBDS7RpcUiMsb3mbdOe44naVzLy1U1MixjfWhggCa2ukLNv/tV98xZo99ubqrIYL6W+AITvtqg5Gzr0kNZxuXnOcYVCtbfStEupSpBKbbZYKScaqBgG5KKdGQtwnxMJytomf+7Ujm3t0wPYRmm8tUhpamZQlT2VCjLMH/HtXeF6RPFa6ZOKNoVkO1cAICC69oapTSpbzP1n7RKG/dlD43n1HbQVL4ifAUAAAAAADzF4TIJIz9mQlRVq578pWSvXr00bty48+7Tv39/vfHGG3b5559/Vtu2bXMcd/3112vOnDl22QS2MrckzIudO3dmHGvHjh3nbYUIAIBfOp5zIATIi6R+//D2JcAPDfjoV29fAvxMrCtNYxWX5++Emb9bLqx1icoFea4y2J7kZF2z8WSrUb7XAgWPL9ybMpXnDxw4YJdLly6tgIAA+6Dkkq0xmrhkm6av26fUtNO3NQOdDnWoW1Y9mlZR02olaDsIj3wmAW/iMwlfxOcSvobPJHxRQfhc+sJ3QqAg4lHzHDz55JN6//33lZCQYMNYCxYsUFRUVJYxH3/8cUb4qmPHjm4LXwEAAAAAAADIzoSqmlUvaafYhGTtO5aguMRURYQEKDoqVJGhtKAFAAAAAADe4XcBLBOW2rx5c8brgwcPZiyb9WdWwOrdu3e2Y5gWhEOGDNHAgQO1Zs0aXXXVVRo0aJDq1aunY8eO6ZtvvrEBLcMEs9KrZQEAAAAAAADIfyZsReAKAAAAAAD4Cr8LYI0ePVrjx4/PcdvChQvtdL4AljFgwADFxMRo2LBh+vPPP3XfffdlG1OmTBlNnjxZNWvWdNPVAwAAAADgfk6Hw06ePB8AAAAAAAAAFBZOb1+AL3v11VdtYKtnz5665JJLFBISoqJFi6pJkyYaOnSoNm7cqGbNmnn7MgEAAAAAAAAAAAAAAAB4id9VwDItBs9sM5gXJmBFyAoAAAAAUJCZglSeLEpFASwAAAAAAAAAhQkVsAAAAAAAAAAAAAAAAADgIhHAAgAAAAAAAAAAAAAAAICL5HctCAEAAAAAQFYO8z8P9gU05wMAAAAAAACAwoIKWAAAAAAAAAAAAAAAAABwkaiABQAAAACAnzPFrzxYAMuj5wIAAAAAAAAAb6MCFgAAAAAAAAAAAAAAAABcJCpgAQAAAADg7zxcAcucDwAAAAAAAAAKCypgAQAAAAAAAAAAAAAAAMBFIoAFAAAAAAAAAAAAAAAAABeJFoQAAAAAAPg5h9NhJ0+eDwAAAAAAAAAKCypgAQAAAAAAAAAAAAAAAMBFogIWAAAAAAB+zuE4OXnyfAAAAAAAAABQWFABCwAAAAAAAAAAAAAAAAAuEgEsAAAAAAAAAAAAAAAAALhItCAEAAAAAMDPOR0OO3nyfAAAAAAAAABQWFABCwAAAAAAAAAAAAAAAAAuEhWwAAAAAADwc6YglSeLUlEACwAAAAAAAEBhQgUsAAAAAAAAAAAAAAAAALhIBLAAAAAAAAAAAAAAAAAA4CLRghAAAAAAAD/ncDjs5MnzAQAAAAAAAEBhQQUsAAAAAAAAAAAAAAAAALhIVMACAAAAAMDPmXpUnixKRf0rAAAAAAAAAIUJFbAAAAAAAAAAAAAAAAAA4CIRwAIAAAAAAAAAAAAAAACAi0QLQgAAAAAA/JzD4bCTJ88HAAAAAAAAAIUFFbAAAAAAAAAAAAAAAAAA4CJRAQsAAAAAAH/nMFWpPHs+AAAAAAAAACgsqIAFAAAAAAAAAAAAAAAAABeJABYAAAAAAAAAAAAAAAAAXCRaEAIAAAAA4OccDoedPHk+XJi///47X45buXLlfDkuAAAAAAAAgNMIYAEAAAAAAHhZ1apV8yUIl5KS4vbjAgAAAAAAAMiKABYAAAAAAH7O4Tw5efJ8uDAul8vblwAAAAAAAADgIhHAAgAAAAAA8LKxY8d6+xIAAAAAAAAAXCQCWAAAAAAAAF7Wq1cvb18CAAAAAAAAgItEAAsAAAAAAD/ncDjs5MnzAQAAAAAAAEBh4fT2BQAAAAAAAAAAAAAAAABAQUUFLAAAAAAACsPjV04PVqXicS8AAAAAAAAAhQgBLAAAAAAAgALA5XJp1apVWr16tQ4ePKgTJ07Ydefy/PPPe+z6AAAAAAAAgMKKABYAAAAAAH7PITkcnj0f3Gr8+PF68cUXtX379gvajwAWAAAAAAAAkP9oCgAAAAAAAODDnnnmGd13333atm2brXh1rsk48zW85++//9YLL7ygK6+8UqVLl1ZoaKgqVaqk6667zobj1q5de879f/zxR91yyy2qWLGiQkJC7Ny8NusBAAAAAADgOwhgAQAAAAAA+Khff/1Vr776ql1u166dbUG4YsUK+9rhcCg1NVUHDhywgZwuXbrY0NW1116rPXv2KC0tzctXX7i9/fbbuuyyyzRkyBAtX77cto1MTEzUzp07tWDBAg0dOlSjR4/OcV/zZ/fAAw/opptu0uTJk7Vr1y4lJSXZuXlt1vfp04c/YwAAAAAAAB9BAAsAAAAAAD9ngjqenuAe77//vp1XqVJF06ZNU7169RQUFJSx3fysS5YsqQ4dOthgzrvvvmvDPTfccIMN7MA7XnrpJfXr10/x8fGqVauWXnvtNc2ZM0crV67UL7/8Yl83b95cTqfzrFXPxowZY5cbNmyozz77TEuXLrVz89ow4a1nn33Wo+8LAAAAAAAAOQuUGx09elRfffWVFi9erL179+r48eMaO3asvUmYbvfu3Tpy5IgtuV6tWjV3nh4AAAAAAMCvLFq0yIasTJgnMPD8t3EefvhhzZo1S998843ee+89Pfnkkx65Tpw2c+ZMPffcc3b5nnvusUGpzKE5o02bNnrqqadyDMlt3LhRw4cPt8umdeG8efMUFhZmXzdp0sRWOmvZsqWWLVtmg1ymPWWNGjU88t4AAAAAAACQzxWw3nnnHVWuXFkPPvigDV398MMPmjt3rn3SLzPztN/ll19up5iYGHedHgAAAAAAnI3T4fkJbmFaCRp169bNWJe5alJycnK2fXr27GlbEX7xxRceukqkMy0BTQjOqF+/vq1idWb4KrPg4OBs6958802lpKRktDFMD1+lK1KkiF1vmHFvvPGGm98FAAAAAAAAvBLAeuGFF/TEE08oNjbW3jhq3LjxWcfeeeedKlu2rBITE/X111+74/QAAAAAAAB+KT1gVaZMmYx1ERERGcsHDhzItk/FihXtfPPmzR65Rpw2Y8YMbdq0yS4PGjQoV1XLMjPBuSlTptjlOnXqqGnTpjmOM+tr165tl814sx8AAAAAAAAKcABr+fLleumll+xyjx49bOvBpUuXnv2ETqf+8Y9/2BtDP//8c15PDwAAAAAA4LdKly5t58eOHctYFx0drYCAALu8YcOGs1bNMg/KwbO+/PJLOzdtIzt16pSx3lSBN8Gs81WD/+uvv7R79267bNoMnkv69l27dmnbtm1uuHoAAAAAAAB4LYBlWg+aMFWzZs00YcIEFS1a9Lz7mLHGmjVr8np6AAAAAABwPg6H5ye4RXrrwT/++CNjnak+nr4+pzaDEydOtPPy5ct77Dpx0pIlS+z8kksuUWRkpD799FNdccUVKlmypGrVqmXnpnLV8OHDbXX4M61fvz5j2VTAOpfM23MK4gEAAAAAAMBzLqwOeg7mzZtnn+p77LHHcr2PuQmV/oQeAAAAAAAAcnbdddfZtnazZ89Wnz59Mtbfcccd+v333/XRRx+pXLly6tatm+Lj4zVu3DhNmjTJ3qu58cYb5cu2bNmiuXPn2urqW7dutVXVzXsICgpSsWLFVLlyZRs0u/rqq9WiRQuFhITIl6WlpWUE5UqVKqUnnnhC//vf/7KN27hxowYMGKBvv/1W06ZNs+813c6dO7O1kjybSpUqZSzv2LHjgq4183lykl5FzUhNTbWTp5lzmp9p+jLgbXwm4Wv4TMIX8bmEr+EzCV9UED6XvnpdgN8HsNJvyJin93IrNDTUznN60g8AAAAAALiXw+mwkyfPB/e4+eab9dxzz+n777+3bQijoqLsehPu+fDDD23ruZdeeslOmRUvXlxPP/20fI253rFjx+rzzz/X5s2bs2wzFdbTmQBZejWp9HtJHTp0UI8ePdS1a9eMFoy+5OjRoxk30U3V999++82G41577TXddNNN9j2YdYMGDbLvbdGiRbrvvvv0zTffZBwjc9vIiIiIc54vPDw8YzkuLu6CrjVzeOt8Dh065JXwm/lZmp9pOqczz4X8gTzhMwlfw2cSvojPJXwNn0n4ooLwuTTfAwF4IYBlyt6bINWRI0dyvc++ffvsPPMTfgCAAuz46X8oAu6S8kxvb18C/NDsyWu9fQnwQ4muk79sB9wlSXymcJqpAGWqX6WkpNgpXZEiRex6E0hauHBhln0uv/xy24bwfBWUPGnZsmU2JGYqPpmbzZnDVqbiVYkSJexkgmMnTpxQTEyMDh8+bENnhlk3ZcoUO5nWiv369dOjjz5qfw6+wlTvSpeQkJDxZ5T5oUVTyWvWrFlq1qyZVq9ebatg/frrr7bKV/p+me+5nUvmUJT5+QAAAAAAAKAAB7BMOfh169Zp06ZNuv7663O1j7nRdKFVswAAAAAAAAqjli1b5ri+SpUqmj9/vv788097b8YEtGrWrKmGDRvKV5gqV0899ZSmTp2aEboqWbKkOnfurKZNm+qqq67SFVdccdaKVvv377dVo5YuXaqZM2dq8eLF2rVrl/71r39p+PDhGjJkiB588EFbMcvb0iu+p3vggQdyvPcVFhaml19+WZ06dbKvv/jii4wAVuZjJCUlnfN8mSvLm2NeiPO1LDQV782fTfqfV+nSpeXNlhempaMvVj1D4cJnEr6GzyR8EZ9L+Bo+k/BFBeFzSSczwEsBrDZt2mjt2rX64IMP7A2v8zE3yUaNGmVvjLVv3z6vpwcAAAAAAOdjwimeDKj4QBimMDEhH199yM1U4zJBIlPl6rbbbtNdd92lG264QYGBubslVaZMGXXs2NFOL774orZv365PP/1U48eP18aNG/XII4/YSlkmkOVtkZGRWV6f676XuZ9mfgYmNGcCZjkd43xtBTNX3Dpfu8IzXUh1NPPLAG/9QiC9FYc3rwHIjM8kfA2fSfgiPpfwNXwm4Yt8/XPpi9cEFAR5bij62GOP2Ztopmz60KFDzznWPJFpbrKZnqamDHvfvn3zenoAAAAAAAD4KFP1ytz/MZXTTXDKVH3KbfjqbFW/nn76aW3YsEGffPKJLrvssvNWivIU0xIwc6WoSpUqnXWsqXRlnnQ2Dhw4kGMwaufOnbmuYnWucwEAAAAAAKAAVMCqXr26LZs+cOBADR48WNOmTdOtt96asf3LL7+0Aa2FCxdqxowZSktLs9Wv3nzzTa+ULwcAAAAAoLAx38MdTs9VpfKFdnDwDVu3blWFChXy5TPWvXt3O5l2eb6ibt26mjNnTra2EjlJ3545kGYCZen++OOPc+6fefull1560dcMAAAAAAAAHwhgGU899ZR9ovHZZ5/V0qVLben09JutQ4YMyRhnxphydcOHD9f999/vjlMDAAAAAAAUeBMmTMhYvueee3JcfzEyH8sb8iN8daZy5crJV7Ro0SIjgGXCZw0bNsxx3LFjx3Tw4MFsP6OqVauqfPny2r17t+bOnXvOc82bNy9j/0suucSN7wIAAAAAAABeCWAZAwYMsGXkTbjq+++/z1I+3ShatKhuuukmWyb+8ssvd9dpAQAAAAAACrzevXufrFTmcGQJTaWvvxhnHgv577bbbst4GPHbb7+1r3NitpkHFY3rrrsuy59Z165d9f7779sKV0uWLFHTpk2z7W/Wp1fAMuOpOgcAAAAAAOBdTncezJQ7HzNmjPbt26dt27bZaliLFy/Wxo0bdejQIX3yySeErwAAAAAA8DQTzvD0hAtmAjnpoZyc1l/MBM+qV6+ebrzxRrv82WefaebMmdnG7N2711aRN4KDg3Xvvfdm2f7kk0/aCvLG448/rhMnTmTZbl6b9entC814AAAAAAAA+EkFrDNVrlzZTgAAAAAAADi3v/7664LW+7NPP/1U48aN06pVq3T06FFFRUWpQYMG6tWrl3r06CFf9+abb9oHEo8cOWKrxZuAlKkKHxYWZh9WfPXVV7Vz5047dujQodnaNNaqVctWmv/Pf/6jZcuW6ZprrtGgQYNUvXp1bdmyRcOGDdPKlSvtWDOuZs2aXnmfAAAAAAAA8EAACwAAAAAA+FD9a6ejgNbbLhyqVKlyQev9UXJysv7xj39o6tSpWap3marqppLUrFmzNGnSJH399dcKCgqSrzIBKvMebr/9dlsl3gSpzJSZaRn4zDPPaODAgTke4+WXX9b+/fv10Ucf2bDVnXfemW3M/fffr5deeinf3gcAAAAAAAA8eEvUlEQ3U7Vq1bRmzZpc7bNu3To5nU5bJh0AAAAAAOBCmXDK999/r+eff962fCtVqpQNtZipd+/ebjuPqUA0YsQIG4Ax7eXKlSunkJAQRUZGqnbt2rYq0+zZs912vsLstdde03fffacyZcpo+PDhtorUhg0bNGPGDPtzNqGsadOm6b///a983bXXXmvvf73wwguqX7++reIVGhqqqlWr2paDy5cvt9WvzsbcNxszZox9v127dlX58uVtu0IzN69/+OEHjR492o4DAAAAAACA9+U5AZX+ROK2bdtsSfSJEyfaG0EXsi8AAAAAAMCFiI6O9sh5TPu4hQsXZluflJSkjRs32mnChAm2cpOZm5CNO9133302VGYqHZnwV24cOHDAtqwz+5kQT0Exfvx4+7DenDlzbLgtnVlu27atDWaZkJb5OZvqUb6uZMmSGjx4sJ0ulmldaCYAAAAAAAD4Nrc8Jmdu6JnS73Fxcbrtttv0yiuvuOOwAAAAAADADdIrQ3ly8qTKlSurffv2+XJsU+2qZcuWevrpp23w5+eff7bVi3766ScNGzbMVjQyvvzyS7dW3ko3btw4Ox0+fDjX+xw7dixjP19gqkAlJiaed9z27dtVs2bNLOGrzG6++eaMcQAAAAAAAIAvcVud8s8//9zeJEtLS9Nzzz2nu+++O1c31wAAAAAAAC6UaT04depU7d271wZyRo4cmS/nmT59uq3IZB4269mzp63E1KhRI3Xo0EEDBw60beaaNm1qx37xxRf6/fff8+U6CjLTaq9u3bq2ZeT5KkaZP8v4+Pgct6f/bEuUKJEv1wkAAAAAAAB4PYBlnk5cunSp2rRpY1sLmkCWeUJ0z5497joFAAAAAAC4GE6H56d89uKLL6pTp0753orQtMQ7l7CwMD3xxBMZr+fPny9vS0hIyKje5QtMe8atW7eqa9eu6tKli13OiWm1d/z4cXXs2FGrV6/OWJ+cnKyJEydqwIABtrpa586dPXj1AAAAAAAAgAcDWEbRokVtCf5HHnnEhrB+++03XXXVVVqxYoU7TwMAAAAAAOAzIiMjs4WfvGnhwoV2nt/htNwylcFmzJihWrVq2SpYl19+uQYPHpytcvpLL71k20nOmzfPVhmLiIhQ+fLlVaRIEdveMS4uTlWqVNGQIUO89l4AAAAAAACAnJz7Mc6LEBAQoHfeecfeTOvXr5927dql6667TmPHjlW3bt3cfToAAAAAAACvMlXA09WpUydPxzpbuOi9995TmTJlzrmvCTRt2bJF3333na0Udc0118hXmNaNa9as0fDhw/Xyyy/btoSmqtWbb76ZUdHKBMZMdfVBgwbZ0JaphmUmIzQ0VHfeeaf+85//nPfnAAAAAAAAABT4AFa6hx56yLYlNGXmY2Ji1L17d61du5anFAEAAAAA8DSH4+TkyfP5sbS0NB04cEDr1q3T22+/rcmTJ2eErzp06JCnY5vKUCY8lZmpMv7+++/n+hhmvAksmZZ9vsS0c/zXv/6lHj166Mknn9Q333yjm2++2bYefOutt1StWjUbrjIP8Y0aNUp//vmnjh49aiuum3tMQUFB3n4LAAAAAAAAgGcDWMb111+vJUuW2CcZzU0z84Tj+vXrNXDgwPw8LQAAAAAA8BF79uw575iKFSuqILjkkku0ffv2HLeZ8JAJFJmQUV6ZAFW69DBW5nVnY0JX5cqVU/PmzfXUU0+pfv368kXmz/urr76ybQkff/xxTZs2TTNnzrT3i55++mmFhITYsJWprg4AAAAAAACosAewjBo1aujXX3/VHXfcoenTp+vbb7+1oSwAAAAAAODBAlhOz54v3VVXXXXe8bkJF/kqE7gyVav69eunyMhIt1TXyszpdNoQlqkqftlll8mftG/f3r6v1157Ta+88kqObQkBAAAAAACAgsAjt1+joqLs04zmZqS5qZqbp18BAAAAAAB8ianYtGbNGq1evVqzZs2ygSHTMm/IkCF69NFHFRcX5/ZzVq5c2U7BwcHyR6bS1b///W9t2LBBXbt21V9//WXbEnbq1Elbt2719uUBAAAAAAAAnqmAZW4Cmicxz3cj0DyxaZ5grFu3rh577DElJyfn9dQAAAAAACDXJbAcnj3fKUuXLrVt8fxBrVq1sry+/vrrbfCqQ4cOtnKTCWYtXLhQERERbjvntm3b5G/i4+N17Ngx+8BeeHi4XVepUiXbwvGnn36ybQl/+OEHG3IbMGCADWiZtoQAAAAAAACA31bAMjcCzdOJptVgbvTp08c+LTp79mx7Iw0AAAAAAPgvE76qWLHiOaeCrHjx4ho/frxd/v33320rPWRnHsR79dVXbYjNBK/Mn7uZm9fmZ5aUlGTH3XDDDVq3bp1efPFF+8DfSy+9ZFsvfvfdd95+CwAAAAAAAIB3WxCeydxca9mypZ0AAAAAAAAKsksvvVQ1a9a0y1999ZW3L8fnHD9+XK1atdKzzz6rzZs3y+VyZUzm9XPPPWfvEZlxhqmybtatX7/etiI0D/7dcssttCUEAAAAAACA/7YgBAAAAAAAPs7pkMPpwRaEnjyXjyhdurQ2bdqk7du3X9T+rVu3tnNT9WnmzJnZ1l+MM4/lLS+//LIWL16soKAgW9mqe/fuKlu2rPbu3avPPvtMgwcPtq0qzTgzpatSpYqmTJli2xH269cvS1tCcxwAAAAAAADAVxDAAgAAAAAAyKNdu3bZeURExEXtP2fOnIzQ1JnrzTpTLSq30sefeSxv+eKLL+y1DBkyRIMGDcoSsPrXv/4lp9Np559//nmWAFa6m266SW3atNF//vMfO5m2hASwAAAAAAAAUCADWNWqVbNzc8Nsy5Yt2dZfjDOPBQAAAAAA8oEJ4ngyjOMjwR9P+e233zIqX11xxRUXdYwWLVrkGJg62/qCZOfOnXZu2hDmxLQfzBxiy0lISIheeOEF3XPPPXriiSfy6UoBAAAAAACAfA5gbdu2zc7PvOmXvv5iFPQbiAAAAAAAoOAaN26c7r33Xrtswj2mFV5mpi1eYGCgGjVqdNZjmNBQr169Ml6bgFBeKmDldn1BUqpUKe3Zs0erV6/W1VdfnW3777//buclS5Y877GqVq2q7777Ll+uEwAAAAAAAMj3AFbmm4m5WQ8AAAAAAJBfFixYoM2bN2e8PnjwYMayWW/CVZn17t37gs+xfv16G9Bq3ry5OnfurAYNGqh06dIZwavZs2dr7NixOnr0qF3Xtm3bizqPv+vUqZNGjRqlgQMHqlixYrr99ttt20HTJvHbb7+1bQnNQ3rmZwwAAAAAAAD4dQDL3FC8kPUAAAAAAMBHOB0nJ0+eL5+NHj1a48ePz3HbwoUL7ZRZXoJRixYtstO5mOO/++67NliErIYOHaoZM2bYKurdu3dXz549bVUsE5pLSUmxQazKlSvrxRdf9PalAgAAAAAAAPkbwAIAAAAAAChM7rjjDhUvXlyzZs3SihUrtHv3bu3bt0/JyckqWrSoatSooWuuucYGiurVq+fty/VZpmqYaedoKl19/vnnOnHihG1JaISGhqpbt24aNmyYoqOjvX2pAAAAAAAAwEUhgAUAAAAAgJ8z7d3M5Mnz5TfTYvDMNoMXylStOldlrLCwMHXt2tVOviI2NlZ//fWXnaempp53fIsWLeQLTMWrMWPG6IMPPtCff/5p2zaaEFutWrUUHBzs7csDAAAAAAAAfD+AlZiYqAULFtjS8lWrVtVVV13lidMCAAAAAAD4hQ8//FDvvfee1qxZY1v25TYIZ1r8+ZKgoCBdfvnl3r4MAAAAAAAAwLcCWNu3b9e7775rl//973+rWLFiWbYvWbJEt99+e0ZpeaNhw4b6+uuvVaVKlbyeHgAAAAAAwG+ZKle33Xabpk6dal/nNnwFAAAAAAAAoAAFsL755hsNHz5cDRo00H//+98s244dO6abb75ZBw4cyHKDcMWKFerYsaNWrlxpn3wEAAAAAAD5yGkmh2fPB7cwLfu+++47uxwdHa17771XjRs3VokSJeR08oMGAAAAAAAA/CKA9fPPP9uS9l27ds22bdSoUdq/f7/d3q9fP7Vp00bTp0+3JfM3bNig8ePH64EHHsjrJQAAAAAAAPilCRMm2Plll12m+fPnq3jx4ipI6tevrxdeeEG33nqr24+9a9cuvfrqq6pcubIGDhzo9uMDAAAAAAAAuZXnRyW3bt1q51deeWW2bZMmTbLhK3OT7c0331Tnzp31zjvv6B//+IetiGXaEAIAAAAAgPzmkBwenMz54BbmATZzb+W5554rcOErY82aNfY+UL169TR27FhbLT2vli5dqr59+6pGjRp6//33lZCQ4JZrBQAAAAAAALwWwDLtBY1y5cplWX/06FHbatDo3bt3lm133nmnna9evTqvpwcAAAAAAPB7tWvXVkE0evRolS5dWmvXrrVV0MuWLatu3brp888/17Zt23J1jPj4eM2dO1fPP/+8atasqWbNmtnjJicn6+6779b999+f7+8DAAAAAAAAyNcWhLGxsXaempqaZf2iRYuUlpamwMBAtWrVKsu2SpUq2XlMTExeTw8AAAAAAOC3TOBo1apVBfYeyn333ac77rhDb731lt544w0dOnTIVkRPr4pesmRJNWjQQGXKlLEVvsx04sQJ+34PHz6sjRs36s8//7T3mAxTUd248cYbbftBU1kLAAAAAAAAKPABrGLFitmbZ7t3786yfs6cOXZubqKFh4fnuG9oaGheTw8AAAAAAM7DtLAzkyfPB/cwVcRXrlyp77//Xq1bt1ZBZO4L/fvf/1b//v01ceJEffTRR/r111/ttoMHD2rmzJln3Tc9cGWYSlr33HOP+vTpo1q1annk2gEAAAAAAACPtCCsW7eunX/77bcZ60w1rEmTJtkbrmdWvzJ27dpl59HR0Xk9PQAAAAAAgN/q16+f6tevr/fff1/z589XQWYexDPhqcWLF9v2g+PGjbPtA+vUqaOIiAgbtkqfAgIC7H2jdu3aaciQIZo9e7Z27typ1157jfAVAAAAAAAA/K8C1i233KK5c+faJxjNjbHrrrvOLm/fvt0GsLp165Ztn2XLlmVpRQgAAAAAAPKR03Fy8uT54BYhISGaPn26br31VhtGMoGsu+66y4aWCnJl8cqVK9tqVmZKl5SUZFsPmvdlKq4DAAAAAAAAhSaA1bdvX40cOVIbNmzQ8OHD7ZSuc+fOuvLKK7PtY6plmXBW06ZN83p6AAAAAAAAv2UqQaUzlaFGjBhhp9ww915SUlJUUAQHB6ts2bLevgwAAAAAAADA8y0IzZOYM2fOtE9iBgYG2puBQUFB6tmzp62EdaZ58+Zp/fr1drlDhw55PT0AAAAAAIDfytyW78zXuZkAAAAAAAAAFIAKWIZ5OvGrr75SYmKiLRVfsmRJ+9RiTkzbwdmzZ9vla6+91h2nBwAAAAAA56mEZCZPng/u8cILL3j7EgAAAAAAAAB4IoCVuRpWuXLlzjmmatWqdjqbAwcO6P3337fLzz//vDsvDwAAAAAAoEAhgAUAAAAAAAAUsgCWO+zfv1+DBw+2T8sSwAIAAAAAwA2cjpOTJ88HAAAAAAAAAIWE09sXAAAAAAAAAAAAAAAAAAAFFQEsAAAAAAAAAAAAAAAAAPCXFoQAAAAAAMDNHI6TkyfPhwsyYcKEjOV77rknx/UXI/OxAAAAAAAAAOQPAlgAAAAAAABe1rt3bzkcDjtlDk2lr78YZx4LAAAAAAAAQP6gBeE5JCUlafTo0erQoYPKlSunkJAQRUREqHbt2rr33nu1aNEib18iAAAAAADnZYM9Tg9OVMC6KC6Xy05nW38xEwAAAAAAAID8RwWss9i+fbs6duyodevWZQtlbdy40U7jxo3T448/rrfeeoubywDgBz7+7AvNX7RYy1eu0pp16+3f+WM/eFe9e959QcdJS0vTuyM/1KiPxmvz1q2KiAhX21at9PLg51St6iU57jP955l6ZfgIrVj1u/1vSuOG9fXswAFqc31LN707eMsnG3Zowa5DWrH/iNYeOqak1DSNbtdQvepWyfUxzP5TtuzW3J0Htf3YccUnp+qSqCLqXK2cBjWpqWKhwdn2qTFmurbHnsjxeC0qlNTMf1yXp/cF75qZeFxrk5O1OSVZ21KTlSypf3hRtQ8tctHHTHa59MTRg9qamqKKzgCNLl4my/Ykl0tjj8dqU0qydqemKNaVpgiHU+UCAnRDSBG1DglTIP8mLtA2Kll7laoDSlOM0pQmqZVCVFtBuT7GbqVoqhLOuj2n4/2mRO1Tmo4oTQly2a0RcqqmAnWpghQkPlcoHP76668LWg8AAAAAAADAdxDAykFycnKW8FW9evXUv39/W/kqNjZWCxYs0IgRIxQfH6+3335b5cuX17/+9S9vXzYAII+eHfKStv+9Q6VKlVS5stF2+WL0ffxJjR43QXUvvVT9Hu6r3Xv2aNI3kzVj1iwtmf2Lataoni341fOBvipdqpR69+hu133x1bdq1/lmTZo4Trff0tUt7w/e8cKi9TYIVSosWOWKhJw1FHUud05bqoMnknRN+RLqcWllG0UwYazhyzfpm827NK9bC0WHh2bbr2hwoPo1zPp5M6pEXXxIB75h/PE47U9LVVGHU8WdAXY5rz45EavdqWc/zgmXS9MS4lU7MFhXBYeoqNOpuDSXfktO1OvxRzUn6YReiiwhJyGsAus3JSlOLpm/TYrIYZcvVjk5VV4B2daXzKEI8zolq6icqqgAhclhA4W7larFStJGpairwghhoVCoUqXKBa0HAAAAAAAA4DsIYOVgypQpGeGrZs2aaf78+QoIOP3Lg3bt2qlLly52mwlrDRs2TE899ZQCA/lxAkBBNvrdt1WzRjVVqVxZ/xn+hp5+4cULPsbsufNs+KrFtc3189TJCg4+WZnorm7/0E23/kOP9R+g6d99kzH+8OEjevypgTb0tWLRXFWsUMGuH9T/STVs3kIPP9lfHdq2VmRkpBvfKTxpZLuGqlEswoae/vvbRj2zcP0FH+OJhtV196WVVD4iLGOdaSn0+OzfNfL3v/TSr3/q7db1s+1XLCRIzze7NM/vAb7nyfCiqhAQoOiAQH1xIs5WpsqLP5OTNOlEvB4Kj9J78cdyHBPpcOjrEmUVdEbAKtXl0tPHYrQiOcmGsa4Ozh4GRMHQUiE2CBUpp1YqSUuVdNHHMuGrKxWSq7E9FK7AHAJWs5SgTUrRn0rW5cpe6Q8XyPz/ricDkoQxAQAAAAAAABQi2R8/hhYtWpSx/PTTT2cJX6Vr3LixOnXqZJePHDmiDRs2ePQaAQDu17Z1Kxu+yosPx06w86HPPZMRvjJu7NBOrVpcqxkzZ+nvHacra3357WQdOXJUjz/0YEb4yjDLj/Xto4MHD+nb777PWP9Qv3/KEV7MBsTOlL5t2Ig38/Qe4F5tKpfJc8WpAU1qZQlfGaZV5TNX17bL83cdzNPxF+4+pNC3pqjxx7OUmJKa623wnkbBITZ85Q6mteDw+COqGxisziFn/6yaylZnhq+MAIdDzU+FrvZkqqA1J/GEbji0R88di7GBwczOtQ3eU1GBNnzlaTmFr4xqp54XOpapEpdpkThKcfpKx5V6RoWuc20D4D3mnoq7Jx6AAwAAAAAAgK8hgJWDpKTTT3pXq1btrOOqV6+e4z4AgMJrzvwFCg8P1zXNmmbb1qFNGzufO3/h6fHzFth5+zats49ve2r8gtPj3xj2ii6tU1vPv/SKflu+ImP9t99N1cgxY9W6ZQsN+Gc/N78r+KogpyMjAJOTxNQ0jV+3Xf9Z+qfeXbVVv+6JyXHcNeVL6t9X1dLvB4/p6QUnq4AaRxKS1OvHZQoJcOrjm5ooJDB7KB0Fn6metT81Tf+MKGqDfRcqzeXS8uREu1wl0y/EW4WEqW1ImK2KNTnheMb6vakpejv+qIo7nPq/izwnfN9RufS7kmwlrY1KVrzSLvgYfyvFzktk+tpaVgFqpCAdUpqWZKrQlSiXZirBNj1so1AF0LIwO/NjNP/d8Njk7TcMX2GCtvkxAQAAAAAAAL6ERwZzULv2yWoSxtatW1W3bt0cx23ZssXOzS+Natas6bHrAwD4pvj4eO3Zu1eXX3ZZjtUTTXtDY9Op/35kXq6ZKdSbMf7Uuszjw8LC9NnY0bq6VVt1732/Vi2eryNHj+qBR/upZMkSmjhmpJxOfuNZWIxb97edt6tSJsfte48n6oGfV2ZZd2V0MX18YxNVLxaeZf0zV9fRzB0H9M6qrWpfJVo3VI3WIzNXa3vsCb3XpoEuLUEbTH+0JjlRUxLi9WCRKJXPZUWtZJdLn5+Is8vH0tK0KiVRO1JT1T4kTA2DsracezQ8SuuTk/TR8WOqFxSsSwIC9d+4Izpu2hZGFlcxJ6E+f7VZKdqc6bX5L1NdBampguU8SzhqlZKUIpdMnG+fUnVAaaqoANU842trIwVrl1K1VsmqpABVVqDmKVFxcuk6hag4yR/Ap7zwwgvevgQAAAAAAAAg3xHAykH37t317LPP6tixYxo2bJhuuummbL9IX7lypaZNm2aX77rrLkVFRXnpagEAvuLosWN2XrRozv9NiIo8uf7o0WO52icqKjLbeKN+vSs0bOhgPTnwaT38RH/t3L1bMTGHNWXSpypfrpwb3xF82ar9RzR0yR8qUyRET12ZPQjeq24VXVuhpOqWjFJEUIA2Ho7Tmyu36JMNO9Th6wVa2bO1IoODMsYHOB2acMOVuvKT2br/5xXq16C6vty0S7fUKKc+V1zi4XcHT0hwpen1uKOqExikLqG5b5NpAjKfnApgGSZKc1touO4rkj2kF+Zw6l+RxdT/6CH9J+6wrgoK1fqUZN0SGq4rg7OGteAfQuXQ1QpWZQXYdobm87JPafpViVqjZPt5aaac/+xXK0kJmV6b4JUJVJ1ZzcoEuFor1LYanKNEXaE0bVWKqipAl+n032vIyjw45MmKc1S3QzoCWAAAAAAAACgMfC6AFRwcrMqVK3u1ekepUqU0ceJEG8RauHChmjRpoieffFK1atVSXFycXTdixAjbdrBRo0Z2+ULs3LnznNv37NmTx3cAAPB3/R55SNN/maWPP59kXz/c53516XiTty8LHrL1aLy6TlmiVJdLn9x4pUqFZQ8zPNe0TpbXDcoU07gOje2yCWGNXrtd/2xUI8uYKlFF9G7r+rr7x2V6dtF6VYwI0wdtG+bzu4G3fBgfq0NpqRoaVULOCwhKmFDVTyXL2daDh9LS9GtygsYdj9WGlCQNjSyh8DP+HV8rMFj3FInUR8djtSM1XtUDAnMMa8E/lFCAndIFyaFL5FQZOfWlTtiqVQ0UpLAcqlT1UoSdH1earXD1q5L0rU7oJoUq4ozxJtxlwlkzlailSlK4HGqhUA+8QwAAAAAAAAAACkAAy7Ty27Ztm7cvQ126dNHy5cttuGrMmDHq1atXlu3R0dEaOnSo+vTpoyJFcl8xwKhUqZKbrxYA4AuKnqqGeGbFqnTHYrNXu8q8j2khmGX8sdhs4zNXlbi5c0f9OONn+/rxhx502/uAb/vraLzafbVABxOSNKnjVWpVqfQF7W+qWZkA1uLdh7IFsIzWlUsrKjhQx5JSdGftiioRGuzGq4evWJ2cqGmJx/VAkUhVzGXrwTOZ0FbpgAB1CghXlMOpV+KO2NaE94dn/zurWXCoDWmlSboxtIiCqIxT6BSRU5coQH8oxVbEMqGsc42tKaeKymkDWIuVpHY5hKsqKFDBSlSSpBoKtNW3AAAAAAAAAADwBu+VmfJxprrVhAkTNGXKFLlcrmzb9+3bp48//li//PKLV64PAOB7wsPDVa5sWf21fbtSU1Ozbd+0eaud16xePWNd+vKmLVuyjz+1LvP4dH9t26YBzzyvEiWK2zDWA4/2y/Gc8L/KV22/WqA98Qn67KYm6lit7AUfo9SpQFV8cs6flz4/r7Thq5Khwfrfqi221SH8z9aUFDsffTxWNxzak2Uydqal2uXbYvbm6niNg05WYfs9xURhskpxufTf2JOfowiHQ+OPx+oAf18VSukBKdOWMDfKKMA2K9yjnD8vc5Vgw1cmmmXaGx48yzic4nR4fgIAAAAAAACAQsJtFbA2bNigUaNGaf78+dq6datiY2OVlmaecT878wvjlFO//PEl8fHxuvHGG+17CQgI0MCBA3XvvfeqWrVqSkhI0K+//qohQ4ZowYIFuvnmmzV8+HD1798/18ffsWPHeVsQXnXVVW54JwAAT2t57TX6/KuvtXDxErW49pos26bPnGnnLa5tfnr8ddfosy+/0oyZs9T0qiZZx/8yM+OYmZn/dt5934P2v7UzvvtWP/38i0b87x29+Mp/NOS5Z/Lx3cHb4at2p8JXn97URF2ql7uo4yzdezij3eCZ3lu9Vd9v3au76lTUE41q6Lov5qnnj8v0612tVCTI5wqnIg+qBASqQ0hYjtumJ55QuMOha4NDFZLLSlWmlaFxuvHcaWOPx2pTarK6h0WoTmCQXog9rNfijug/F9j6EAXfflsD7WT7wNxIlssGrHKqN7xWSdquVNVUoK5QkCbrhGYqQbeqiG17CMB3zJs3L1+O26JFi3w5LgAAAAAAAHAx3PKbtNdff11PP/20/YVwTtWiCprBgwfb8JVxZvvB4OBgtWvXTtdff73at2+v2bNna8CAAWrTpo3q16+fq+NXrFgx364dAOAZBw8e0sFDh1SqZEmVKlUyY/2D9/WyAaznhr6sn6dOtv/dMH6c/rPmzFug9m1aq0rlyhnju916iwY994Le/mCU7runhypWqGDX79y1S++M/NAe+5YunbKc2wStFv+6VE898bjatm5lA12z583XK6+9rnatr9d115wOeKFgOXgiUQdPJKlUWLBKhZ2sKJS57eDuU+Grm2uUP+dx/oiJVeXIsGyhKbP+3wvW2eXutbP+e2TtwWMaNG+tqhUtonda11dkcJCGNr9Ug+avU/+5a/RB24Zufa/wnKNpaTrmSrNtAos6TwZfGgWH2OlsAaziDqf+GVEsy/rtKcmKDghU6BmhqQSXS6OOn2yZelVQ1jZxK5IS9U1CvA1e9QiLUIDDoc4hRTQ18bgmnYjXnUUi3Pxu4Skn5FKCXLaqVVimwNMBpap0DlG8NUrSbqWqqBwqnSmAdUxpCpYjW/vAVLm0SIm2VlalM44Xo1QtUZKi5NC1CrH7X6Vgu87s0zKHdoWwT0CdnDx5Plyw1atX5/reQkHRqlUr+wCeO/nqA30AAAAAAAAovPIcwPrpp5/01FNPZdwAa9q0qRo3bqwSJUrIeeoXPAWJCZB99NFHdrlWrVpZwleZBQYGaujQobr22mttpa9x48bpjTfe8PDVAgDcafS4CVqwaLFdXrNu/cl14ydqzvwFdvna5s30QO977PI7I0fpxVeG6YV/D9LgZ57OOMb1LVvYMeZYjZq3VMcb2mvP3r364utvbbvAt0f8N8s5ixcvpndGvKaeD/S14++4/Ra7/ouvvtWhQzH6YsJYRUZGZoyft2ChDVo1alBfLw9+zq4zIa9Px45W42tbqcf9D2r1kgUqVixrcALeM2btNi3cdcgurz10zM4/Wrddc3cetMvXVCip+y+/xC6/t2qrhv76p567uraeb3ZpxjFM+Orv2BO6umxxrTlw1E5nyjx+0p879ebKLbquQklVjiyi8KAAbTocpx+37VNymkuDmtTSdRVLZYxPSElVjx+X2VZxE2640oavjH82qqGft+/XmLXb1b5KGd1a82RAEN73Y8JxrTvV7m9bSrKd/5R4PKMFYN3AYN0YerJu0HcJ8frkRJzuDotQzyKn/z65UPOSEvRtQrw9drQzQEUcDh1MS9Oy5AQdc7l0eWCwbgkLzxL8Gh53RGEOh/4VUcyGr4w+4VFak5KkiSdi1SAoWHWCTgZV4X0blKy9p9r4xZyqVvWHkm1wyiirAF2qk38/rFOSlitZjRWkK22jwJNmKMHGq0wIK1wO227QVL46aINWUmuFypkpbGXaC85Xoj125Kkg1nG5tEupipdLxWy46vTxzfFmngpmmWOZ8JVRT0HaqVT9oRRVUoqqua/YM+BRjRo1UqVKldSxY0d17txZrVu3zgj0F2T+8LAeAAAAAAAAcC55viv95ptv2nnx4sX13Xff6ZprsrZJKmj27dunmJgYu9yw4bkrPZigWbo//vgj368NAJC/TPhq/CefZVlnWgmaKV16AOtcRr79pq6oe5lGfTReb733gSIiwm0Vq5dfeE7Vq1XNNr5H9ztsJa1Xho/Q2Imf2kBz44b19ezAAbbCVbrDh4+ox/19FRYWps/Gjcnyy7jatWrqzf++qj6P9lOfx57Qlx+Pz8NPAu5kwlcTN2RtP7xod4yd0qUHsM5me+wJO/9172E75SRzAKtVpdL6IyZOqw4c0YJdh3Q8JVWlQoN14yXReqh+NbWrUibLvgPnr9W6Q8c0pPmlurpciYz15rP4UYfGavTxLD30yyo1KVtclSJzagYGTzPhq18ST34u0q1PSbZTuhtzbNx28a4ODlFMWqo9x4aUJJ1wuWyrwqoBQWoZEmZbGqaHrIzX444oxpWmgRHFVDbg9NeO4FOBrH5HD2pY3BG9W6yUijgK3oMb/siErzYqa0WZvUqzU7r0ANbZ1FWQdijVBqtMTMp8IiLksG0CTUgq4oz2g+mhLjP+kN1H9gzF5dTlCrLHy9xS0FS5MuGwJgpWdKbKWA451Eoh+krHNU8JKqMi2c4FFJSg0t9//60PPvjATkWKFFHbtm1tGMuEsqKjo1XQmMrhAAAAAAAAgL9zuPL4GGKpUqV0+PBh24bwiSeeUEF38OBBlS5d2i7fdttt+uqrr846NjY2VlFRUXa5U6dOmjp1qluuYefOnfaJV2PHjh20LATg+45nr8YD5FXKM729fQnwQzMn/urtS4Af+vbQyRaMgLvEKU2f6HievxNm/m75171tVTEizK3Xec5zx51Q1bG/2GW+1+be7t279f3339v7CzNnzlRCQkJGKNqG9Bs3tmEsM/lbq0L4Fl+4N5WamqoDBw7YZXOvLiAge4tbwJP4TMLX8JmEL+JzCV/DZxK+qCB8Ln3hOyFQEOX5keDjx0/eFDat+PyBaZ2YHqpavHixUlKyPgGe2dy5czOWq1bNXtEEAAAAAAAgt8qXL68HH3zQBrAOHTqkKVOmqE+fPipbtqzS0tL022+/6YUXXrCtCqtUqaJHHnlEP/74o5KSTragBQAAAAAAAFBAA1gVKlSwc3+52ed0Om1Z//QnT19++eUcx5mqX4MGDcp4bSpgAQAAAADgmxymjJLnpkytI3FxTNtpU+lq5MiR2rVrlw1fPf/882rYsKFtVWieQDXbzP2IkiVL6pZbbtFHH32kffv2efvSAQAAAAAAgEInzwEsczPQWLhwofyFuaFZpEgRuzx48GB16dJFX3/9tVauXGmrYr3xxhtq0KCB1q9fb8e0adNG7du39/JVAwAAAAAAf2XaD5p7FMuWLbOtAD744APddNNNCg0NVXx8fEa1LPOg3NVXX62XXnpJq1ev9vZlAwAAAAAAAIVCYF4P8NRTT2nixIkaMWKEevToYcviF3R16tSxNy67d++ugwcP2tL/ZspJ69at9eWXX3r8GgEAAAAAQOFuVWimhIQE/fLLL/a+xffff689e/bYalkmqGXaFZpAlnl47qGHHtIVV1whXxQbG2vfgwmMmfswJ06csFW+zsbhcGjMmDEevUYAAAAAAAAgXwNY5qafCSvdfPPNat68ud555x37BGZB17ZtW/3xxx/2ht6PP/6odevW6ciRIwoMDLQhsyZNmuiuu+6y1bHMjT8AAAAAAHyW03ly8uT54BGmApZpQ2gmY/ny5TaIZQJZK1asyKiWFR0d7XMBrLS0NA0dOtQ+1GeqeOWGCWYRwAIAAAAAAECBDWCZSk/nUqJECW3cuNE+VVmsWDHVrFkzo43f2ZgbZjNnzpSvKlmypAYOHGgnAAAAAACAgtCq0Eym+tXu3bttEGvatGnnvUfjDb1799Ynn3xiQ1UBAQH2Psz+/fvt/aKKFSvq8OHDiouLs2PNulKlSvnk+wAAAAAAAAByHcCaM2eOvdl1thLw6VWgzHZzg2zp0qVnPVb6cagcBQAAAACAB5jv3578Ds73fZ9gqpb37dvXTr5m+vTp+vjjj+29IRPEMlWwdu3apXr16tnt27dvt/M///xT77//vt59910VL15ckydPVp06dbx89QAAAAAAAMBFBrBatGhBYAoAAAAAAAB5NnbsWDuvW7euPvroI7tsKnadqXbt2nrzzTfVpk0b3Xrrrbrpppu0cuVKFS1a1OPXDAAAAAAAALilAhYAAAAAAACQV0uWLLEP+j366KO5Gt+5c2f16tXLBrf+97//6bnnnsv3awQAAAAAAAByy5nrkQAAAAAAoGByZGpD6JHJ228Yvm7//v12XqtWrYx1AQEBGcuJiYnZ9rn99tvlcrn07bffeugqAQAAAAAAgNwhgAUAAAAAAACvKFGiRMZyZGRktoBWZmXKlLHzbdu2eejqAAAAAAAAgNwhgAUAAAAAgL/zaPWrUxNwDtHR0XYeExOTZV1wcLBd/v3337Pts337djtPSEjw2HUCAAAAAAAAHglgLVq0yJaIDwsL065du8473owJDQ1VYGCgli9fntfTAwAAAAAAoIC54oor7Hz9+vUZ68y9ooYNG9rlsWPHZtvn/ffft/MqVap47DoBAAAAAAAAjwSwPv/8c7lcLnXq1EkVKlQ473gzpnPnzkpLS9Onn36a19MDAAAAAACggGnVqpW9n/TLL79kWd+jRw+7/ttvv1WvXr00bdo0TZo0SR07drRjHQ6Hunbt6rXrBgAAAAAAAPIlgLVgwQJ78+vGG2/M9T7mppkxb968vJ4eAAAAAACcj9Pp+Qk4h1tuucXOf/rpJ+3bty9jfd++fdWoUSMbwvr444/VpUsXde/e3Y4zKleurEGDBnntugEAAAAAAICc5PmO6JYtW+z8sssuy/U+derUsfPNmzfn9fQAAAAAAAAoYKpWraqtW7dq7dq1ioqKytKG8Oeff9bdd99tl00Qy0zpD/TNnz9fxYsX9+KVAwAAAAAAANkFKo8SEhLsPDQ0NNf7hISE2Hl8fHxeTw8AAAAAAM7H4Tg5efJ8wHlccsklOa43AauJEyfqvffe06ZNm5SSkqIaNWqoRIkSHr9GAAAAAAAAwCMBLHPza//+/fr777/VoEGDXO2zc+dOOy9WrFheTw8AAAAAAFDgDRkyJF+O+/zzz6ugioyMtO0IAQAAAAAAAL8PYJnWgyaA9d1336lLly652mfy5Ml2Xrt27byeHgAAAAAAoMAbPHiwHPlQOawgB7AAAAAAAACAgsKZ1wPcdNNNcrlcmjBhgubPn3/e8fPmzbNl5M1NxU6dOuX19AAAAAAA4LxOtSD01GTOhwtm7q+4e/JVJ06csPeSzHTgwIHzjjdj0scnJyd75BoBAAAAAAAAjwWw+vbtq1KlSik1NdWGsd555x0lJCRkG2fW/e9//1PHjh2VkpKi4sWL6+GHH87r6QEAAAAAAAq8tLS0fJl81aRJk9S7d28988wz9h7R+ZgxZuy9996rr7/+2iPXCAAAAAAAAHgsgBUREaFPP/1UAQEBOn78uJ544gmVKVNG119/ve666y47meXSpUvrn//8p+Lj4xUYGKjPPvtMUVFReT09AAAAAAA4H09Wv8qoggWc3dSpU+38jjvusPeJzseMufPOO21Vr8mTJ3vgCgEAAAAAAIDcO/8drlxo27atpk+frp49e2r37t2Ki4uzrQYzSy97X6FCBduCsFWrVu44NQAAAAAAAAqYFStWyOFwqEWLFrnex4wdMWKEli9fnq/XBgAAAAAAAHglgGWYKldbtmzRhAkT9P3332vlypU6ePCg3WZaFDZq1EidO3dWjx49FBIS4q7TAgAAAACA83E6T06ePB9wDnv27LHzSpUq5XqfihUr2rl5+A8AAAAAAADwywCWYYJVffr0sRMAAAAAAACQk4CAADtPTEzM9T5JSUlZqqwDAAAAAAAAfhnAAgAAAAAAQP6YPXu2Jk+erNWrV9uq4ydOnDhnGMm0+DPVyn1RdHS0tm3bprVr16pp06a52mfNmjV2Xrp06Xy+OgAAAAAAAMDDAayqVavK6XRq+vTpqlGjRq72+fvvv9WqVSufvhEIAAAAAIDfcDhOTp48H9xm//79uvPOOzV37lz7+myhK3OfJfM289pXNW/eXH/99Zc+/PBDPfDAA7naZ+TIkfY95TawBQAAAAAAAHiKM68H2L59u31iMb0MfG4kJyfbfcwEAAAAAACAs99DufHGG234yoSr6tevr44dO9ptJozUs2dP+7pcuXJ2u1nXuHFj9erVS/fcc4981V133WXny5Yt0xNPPHHOSl5mmxmzfPnyLPsCAAAAAAAAfhPAAgAAAAAAPs6RqQqWRyZvv2H/MW7cOK1cudIujx07VitWrNB//vOfjO3jx4/X1KlTtWvXLn3zzTc2iLV+/Xp16tTJjvdVJlTWunVrG6565513dPXVV+vjjz+2D/qZh/zMZJYnTpxot5kxJlzWokULde3a1duXDwAAAAAAALi3BeHFOHr0qJ0XKVLEG6cHAAAAAAAoEL7++ms7v+GGG2xVq3O5+eabdcUVV+jKK69U7969Va9ePdWsWVO+atKkSWrVqpXWrl1rq1ud6/2ZoJZ5b+k/DwAAAAAAAECFvQKWeaLRqFKlijdODwAAAAAAUCCsXr3aVn7q0aNHjtvPbN1XvXp1264vPj5eb731lnxZiRIl9Ouvv+rJJ59UWFiYfS85TeYBvv79+2vJkiV2HwAAAAAAAKDAV8Ay5eFzcu+99yo8PPyc+yYmJmrr1q3av3+/vXnYvn37Cz09AAAAAAC4UOmtAT15PrhFTEyMnVetWjVjXXBwcMby8ePHs92PadOmjYYMGaKff/5Zvs4Er15//XW98MILmjVrlm23ePDgQbutVKlSatSoka6//noVLVrU25cKAAAAAAAAuC+ANWfOHBueyvyEpVn+7bffLug41apV09NPP32hpwcAAAAAACg0TNgqJSUlS+gqKioqY3nXrl2qVatWln1CQ0MzthUUJmB1yy232AkAAAAAAADw+wBWixYtbAAr3dy5c+3rxo0bn7MClhljbgCWK1dOzZs315133nneilkAAAAAACDvHE6nnTx5PrhH5cqV9ccff2jfvn0Z66KjoxUZGam4uDjbwu/MANbatWvtPPP9GwAAAAAAAAA+VgErM+epm6rjxo3TZZdd5r4rAwAAAAAAKORMCz4TwDKt+W688cYsD8hNmzZNb731lrp166aQkBC7/siRIxo2bJgNXxWk+zQnTpzQ8uXLtXfvXttW8eabb85S6QsAAAAAAADwZXl+JPWee+6xU/Hixd1zRQAAAAAAALDatGkjl8tlw1aZPfTQQ3Zugln16tXTgAED9Mgjj+iKK67Qxo0b7TZzv8bX7dixQz179rT3lVq2bKk77rhD9957r3bu3Jll3JgxY3TVVVepXbt29ucBAAAAAAAAFOgKWGcyla8AAAAAAIAvc5h+dJ49H9zCVIIaPHiwDSRt2bJF1atXt+s7duyo++67Tx999JE2bdqk119/3a5PDye1b99eDz/8sHyZaZ9o3sfhw4ezhKpyap3YuXNnPfroo0pOTtaMGTPUoUMHD18tAAAAAAAAkI8VsAAAAAAAAJA/ihUrpm3btmn79u0Z4at0o0eP1ocffqirr75a4eHhtg2hqYD12muvaerUqXI6ffe2j2mV2LVrV8XExKhs2bJ67733tGbNmrOOL1OmTEYLxjOrgQEAAAAAAAAFvgJWTlJTU+3TiydOnDhvWfjKlSvnxyUAAAAAAIB0Dg9XwPJota3C7f7777dTQfO///1P+/fvV6lSpbR48eJc3R9q27atpkyZoqVLl3rkGgEAAAAAAACPB7AOHjyot99+W5MnT9b69euVlpZ23n1MSfmUlBR3XQIAAAAAAAAKAFOhy9wX6t+/f64fzqtbt66dm1aMAAAAAAAAgN8FsBYtWqRbb71VBw4cOG/FKwAAAAAAABRumzdvtvMWLVrkep/ixYvb+bFjx/LtugAAAAAAAACvBLAOHTqkrl272nlERIQeeOABFStWTIMHD7ZPMo4ePVoxMTFatmyZvvvuOyUkJOiaa64pkOXxAQAAAAAokGhBCB9j7g8ZQUFBud4nPj7ezsPCwvLtugAAAAAAAACvBLDeeecdG74KCQnR4sWLbTn4devW2QCWce+992aM3bNnj+666y7NmzdPzZo107Bhw/J6egAAAAAAAL+3YcMGjRo1SvPnz9fWrVsVGxurtLS0c+5jHoxLSUmRLypTpox27typv/76S02aNMnVPqtWrbLz8uXL5/PVAQAAAAAAABfGqTz68ccf7Q29++67z4avzqVcuXL64YcfVL16dQ0fPlyzZs3K6+kBAAAAAMD5OJ2en+A2r7/+uho0aKD//e9/WrFihY4cOaLU1FS5XK7zTr7q6quvzrivlBvmvXz44Yf2HtR1112Xz1cHAAAAAAAAeLgC1ubNm+28bdu2GevMzbB05oZgQEBAxmtTJv6f//ynHn30UX3wwQdq3bp1Xi8BAAAAAADAL/3000966qmnMu63NG3aVI0bN1aJEiXkLMBBt7vvvltfffWVPvnkEz3xxBM2YHYu//d//6fVq1fbn0GvXr3+n737ALOiOv8A/G1hl2UB6U2KvddY/lbsmBiNYtRoYkGxxq5RY+xdE41Gk9hQsdeoMZpiR0EN1sQaC72JdNhdtv+fGWClLG3Zxu77Ps88c+7MuTPn4vHC3v3d79TbOAEAAACgXgJYs2bNSvd9+vSpOtayZcuqdlISv127dos8Z9ttt033//73v1f19gAAAABN1i233JLu27dvH88991zsvPPO0RQceOCBsccee8Rrr70We+21V1x99dXx05/+tOp8snTihAkTYtiwYWnlr7feeisNXx188MGx0047NejYAQAAAGBxq/xVydatW1d9MLZA8i3MBUaNGrXEc+bOnZvuJ0+evKq3BwAAAJYnKVSdVKuut62hX3DT8d5776XBo0svvbTJhK8W+Mtf/hJbb711TJ8+PU477bTo3r17VVX15HivXr3i8MMPT8NXyRKEybKFgwcPbuhhAwAAAEDtB7DWW2+9dD9mzJiqY0nFq27duqXt5JuMixs6dGi6z8/PX9XbAwAAADRZhYWF6X6XXXaJpib5/Ojtt9+OCy+8MNq2bZuGrKrb8vLy4vzzz4/XX3/dZ0kAAAAANM0lCJNvH77//vvx7rvvxiGHHFJ1/Ic//GH6rcTf/va3sf/++8f666+fHn/nnXfid7/7XfqNxu22225Vbw8AAAAsz4LKVPV5P2rFmmuuGSNGjIiSkpJoinJycuKaa66J3/zmNzFkyJC04ldSMb28vDw6duyYVsLae++9Y4011mjooQIAAABA3QWw9t133/jTn/4UTz/9dNxwww1Vx88555x46KGH0g/NNt1009hyyy2joKAgvvrqq/RDtCSAdeaZZ67q7QEAAACarAMOOCD+8Ic/xLBhw2LHHXeMpuKBBx5I9xtuuGH65b6kstV+++2XbgAAAADQ7JYgTAJYRx99dOywww4xcuTIquObbbZZ3H777ZGVlRVlZWVplawvvvgiDV8lLr/88rRKFgAAAADV+9WvfhUdOnSIm266KSZNmhRNxYABA+LYY4+N0aNHN/RQAAAAAKDhK2C1aNEiXWqwOgMHDoxddtklPf/pp5+mQaxkKcKjjjoqtt1221W9NQAAALAiLEG42urRo0f89a9/jYMOOih22mmn+OMf/9gkqkQlSwrOmjUr/ZwIAAAAAKK5B7CWJyklf91119X1bQAAAACanD333DPdJ1Wwvvzyy3RJwnbt2qXBpVatWi3zuRkZGfHKK69EY7T22mvHf/7zn5g+fXpDDwUAAAAAGm8AK6l2teBDtPbt20d2dp1nvQAAAIDqZGRGZGbW7/2oFa+//noapFqgsrIy/bxl+PDhS31O0j/pt/DzGpv+/fvHRx99FH/729+qQmYAAAAAsLqq1VTUZ599FnfccUe8/PLL6bcykw/7EskHfsk3M/fee+846aSTYrPNNqvN2wIAAAA0SX379m3UQaqaOvPMM+Pee++N22+/Pfbff//Ya6+9GnpIAAAAANCwAayKioo477zz4tZbb03bC4JXCySP//e//6WhrCSgddppp8VNN90UmfX57VtgnsKZDT0CmqDylx9p6CHQBE1584uGHgJNUGFFRUMPgSZop7YtG3oINDHTKsrj4TmFtXvRJMBTnyGeJhgYasgKWE1R27Zt46WXXopDDjkkfvjDH8axxx4bP//5z2OLLbZIK6k3xdAZAAAAAE1XrQSwkg/Innzyyarg1aabbhrbb799dO3aNX387bffxrvvvhuffPJJlJeXp0GtCRMmxOOPP14btwcAAABgNZKVlVXVTj5Puueee9JtRSThrLKysjocHQAAAADUcwDrscceiyeeeCL98GvLLbeMu+66K7bbbrtq+yYhrJNPPjk+/PDDeOqpp9LnHn744as6BAAAAABWI9VVTwcAAACAZhvASgJXiQ022CCGDh0a+fn5S+2bBLPeeOON2HbbbdMlCe+8804BLAAAAKhrliCkkbnssssaeggAAAAA0HgCWP/5z3/S6lcXXHDBMsNXCyR9kr7HHXdc+lwAAACA5m7MmDFV7d69e1d7vCYWvlZjIoAFAAAAQFOyygGskpKSdL/FFlus8HMW9C0tLV3V2wMAAADLk5k5b6vP+7FS1l577XSffMmtrKxsieM1sfi1AAAAAIC6scqfiPbp0yfdz5w5c4WfM2vWrEWeCwAAANCcVVZWVm1LO16TDQAAAABYDSpg/fSnP42rrroq/vKXv8Qee+yxQs956qmn0m9h9u/ff1VvDwAAADRDkydPjuHDh6fbu+++m25Tp05Nzx1zzDExePDgWrlP8oWz559/Pl5++eX44IMPYtSoUVFYWBjt2rWLzTbbLPbff/8YOHBg+nhV3HfffSt1HAAAAABoQgGsc845Jx5++OG48847o2/fvnHYYYctN3yV9E1K6P/qV79a1dsDAAAAy5ORrkdXv/erY127dq3ze/zjH/9IvzxWXFy8xLkpU6bE66+/nm433nhjPPLIIyv8xbTqJKGxlTkOAAAAADShJQjXWGON9FugP/jBD+KII46Igw46KJ599tkYP358lJaWRllZWdpOjiUfWv7sZz9L+77yyivpcwEAAABWRe/evaNfv361ft2kolYSvsrMzIx99903br755nj11VfTSljPPfdc+hlHYtKkSWklrI8++miV7vfAAw+k26xZs2rpFQAAAAAAjaoCVlZW1nL7VFZWxt/+9rd0W1af9957L9ZZZ510GcIkoAUAAADUoaT6Vb1WwKr7e1166aWx3XbbpVtSDStZGjCptl2bWrRoESeddFL85je/SUNeC9t6663jgAMOiJ133jnOOOOMdFnCpEp4EtCqqQEDBqSflWy77baxySabLHH+u+++i9tvv73q9QMAAAAAq1kAKwlO1Va/Fb0WAAAAQHWuuOKKOr9HUuFqQZWrpTn99NPTqlXJl82GDBmSLk3YqVOnOhnP5MmT4/LLL09DWgJYAAAAALAaBrAuu+yyuh0JAAAAwGpo9913TwNYFRUVMXLkyDoLYAEAAAAAjZMAFgAAADR1TXAJwsakuLi4qp2VldWgYwEAAAAA6l9mA9wTAAAAoMlIlh5MtGjRItZbb72GHg4AAAAA0FgrYAEAAACrqYzMiMzM+r3ffBMnTlxu9549e8bq6oUXXoj//ve/aXvfffeNtm3bNvSQAAAAAIB6JoAFAAAA1Jntt99+uX0qKytjdTRt2rQ49dRTq5YevPLKKxt6SAAAAABAA7AEIQAAAMBKKi8vj1/84hcxevTo9PHFF18cW2+9dUMPCwAAAABoACpgAQAAQFOXkTFvq8/7zTd8+PDo3r17NDW//OUv45///Gfa3n///eOSSy6ptWv/+c9/ji5duixxfPLkyVXtFa22demll9bauAAAAACA6glgAQAAAHUmCV/17NkzmpILL7ww7rrrrrS96667xhNPPJEuQVhbbr/99qWey5gfbrviiitW6FoCWAAAAABQ9wSwAAAAoKlrwApYTc0NN9wQ119/fdr+wQ9+EM8//3zk5eXV2vUrKytr7VoLwloAAAAAQN0SwAIAAABYwaUBf/3rX6ftjTfeOP71r39F27Zta+36r732Wq1dCwAAAACoPwJYAAAAAMvx4IMPxmmnnZa211lnnXj55ZejU6dOtXqP3XbbrVavBwAAAADUDwEsAAAAaOoyMudt9Xm/JuTpp5+OY489Nl0esGfPnvHKK69Ejx49GnpYAAAAAEAj0bQ+EQUAAABYQYMHD46MjIx0u/zyy6vt8+KLL8YRRxwR5eXl0aVLl7Ty1VprrVXvYwUAAAAAGi8VsAAAAKA5fP0qM6N+71fHhg4dGl9//XXV4ylTplS1k+NJuGphAwYMWOl7vPPOO9G/f/8oKSmJFi1axM033xylpaXxySefLPU5SYWsdu3arfS9AAAAAIDVlwAWAAAAsNoZNGhQ3H///dWeGzZsWLqtagDrn//8ZxQWFqbtJHj1i1/8YrnPue+++2p0LwAAAABg9WUJQgAAAAAAAAAAgBoSwAIAAICmLiOz/rc6liwxWFlZucJbdZJKVQvOX3755UucT46tzD2STfUrAAAAAGh+BLAAAAAAAAAAAABqSAALAAAAmrqMjPrfgCoXXHBBZGRkVG2vv/76cp/zj3/8I/r37x89e/aM3NzcdJ88To4DAAAA0LhkN/QAAAAAAKCp+uijj+L3v//9CvevqKiIE088Me65555Fjo8fPz7dnn322Tj++OPjzjvvjMxM360EAAAAaAx8SgMAAABNXUZmRGY9bsn9gKowVVlZWXTp0mWFnnPRRRdVha+23nrrePTRR2P48OHpPnmcGDRoUFx88cV1OnYAAAAAVpxPRAEAAACgDtx6663x7rvvxkYbbRQDBw5cbv8vv/wybrzxxrS97bbbxrBhw+Lwww+P7bbbLt0PHTo0PZ743e9+F19//XWdvwYAAAAAlk8ACwAAAABq2ZgxY+KSSy5J23fccUfk5OQs9zm33HJLWi0rcdttt0VeXt4i51u1apUeTyT9br755joZOwAAAAArRwALAAAAmrqMjPrfoJk79dRTY86cOXHMMcfEbrvtttz+lZWV8de//jVtJxWzdthhh2r7Jcc33HDDtJ30T54HAAAAQMMSwAIAAACAWvTEE0/E888/Hx06dKhaUnB5Ro4cGRMmTEjbywtsLTg/fvz4GDVqVC2MGAAAAIBVIYAFAAAATV1GZv1v0EzNmDEjzjzzzLR9ww03RKdOnVboeZ999llVO6mAtSwLn//8889rPFYAAAAAakd2LV0HAAAAAJq9888/PyZNmhQ777xzDBw4cIWfN27cuKp2z549l9m3V69eVe2xY8eu9BgXvld1Jk6cWNUuLy9Pt/qW3LOioqKqDQ3NnKSxMSdpjMxLGhtzksZodZiXjXVc0NgJYAEAAABALXjzzTdj0KBBkZ2dHXfccUdkZGSs8HNnz55d1W7duvUy++bn51e158yZs9LjXDjAtTxTp06N3NzcqG/JLyRmzpxZ9TgzU2U9GpY5SWNjTtIYmZc0NuYkjdHqMC+TnwOBlSeABQAAAE1dkgFZiSBIrdwPmpmSkpI48cQTo7KyMs4+++zYbLPNVur5c+fOrWrn5OQss+/CgaiioqIajBYAAACA2iSABQAAAACr6Nprr40vvvgievfuHZdddtlKP79ly5aLhLmWpbi4uKqdl5e30vda3rKFyRKE22+/fdru2LFjdO7cORpyyYtOnTpFVlZWvY8BFmZO0tiYkzRG5iWNjTlJY7Q6zMuFf+YEVpwAFgAAADR1STn7+ixp3wjL50NdSoJX1113Xdq+7bbbFlkicEW1adNmhZcVLCgoWOHlCqvTs2fPFe6b/DKgoX4hsGApjoYcAyzMnKSxMSdpjMxLGhtzksaosc/LxjgmWB0IYAEAAADAKrj55pvTqlXrrLNOFBYWxmOPPbZEn08++aSq/eqrr8akSZPS9gEHHJAGthYORY0bN26FK1j16tWrll4FAAAAADUlgAUAAAAAtbA8w4gRI+KII45Ybv+rrrqqqj1y5Mg0gLXJJpssUlFrWRY+v/HGG9dw1AAAAADUFmsCAAAAQFOXkVH/G7BS1l577ejRo0faHjJkyDL7vvHGG+l+zTXXjLXWWqtexgcAAADA0glgAQAAAMAqGDx4cFRWVi5zu+yyy6r6v/baa1XHFwSoMjIy4sADD6yqcPXOO+9Ue6/k+IIKWEn/5HkAAAAANCwBLAAAAGjqMjLrfwNW2llnnRVZWVlp+/TTT4+ioqJFziePk+OJ7OzstD8AAAAADc8nogAAAADQCGywwQZx3nnnpe333nsvdt5553j88cfTdrJPHiftRNJv/fXXb+ARAwAAAJDI9scAAAAAAI3DNddcE5MnT4577703Pvzwwzj88MOX6DNw4MC4+uqrG2R8AAAAACxJBSwAAABo6jIyIjLrcUvuB9RIZmZm3HPPPfHCCy/EgQceGD169IicnJx0nzz++9//HoMGDUr7AQAAANA4+KRmJV1wwQWRkZFRtb3++usNPSQAAAAAGrnLL788Kisr02333Xdfbv/99tsvnn322Rg/fnwUFxen++Txj370o3oZLwAAAAArzhKEK+Gjjz6K3//+9w09DCAiHnr08Xjzrbfj/Q8/io8//SxKSkrivjv+FAOO+sVKXaeioiL+dOfdcde998fXI0ZE69b5sffuu8c1l18S66y9VrXP+ddLr8S1N94UH3z03zSIuc3WW8bF558Xe+2xWy29OhrKw6//O4Z+9k188PWY+Hj0hCgpK4t7zjgqjtlrxxW+xuQZs+Pel4fFB1+PjQ++GROjJk9Nj5f99c9Lfc66J1wcoydPq/Zc383Wj1evObsGr4bG4qmpM+Pfc4riv4Vz44ui4iiprIxb+nSLn3Vqt8LX+KCgKAZPnp5e49vSsiiqqIzuOdmxRauWcUrXDrFVft4Sz9nu469jXElZtdfbsXVePL1hn1V6XTSsIcVF8VlZaYwoL43R5WWR/Jc+rVXb2DN3ybmwokorK+OC2dNiVHlZrJmZFbet0WmJPifN/C6+q6io9vmbZreIq9p0qPH9aRyGlcyNL8vL0nkwrmLe3Dq+ZevYNadlja9ZVlkZVxTMiDEV5dE9Myuub91+kfNvlsyNQXPnLPMam2S1iAvy16jxGEgqYGXO2+rzfgAAAAAAzYQA1kqENE488cQoKyuLLl26xOTJkxt6SNCsXXzl1TF6zNjo1KljdO/WNW3XxEmnnxWDBj8Qm268cZxxykkxYeLEeOLpZ+PFV1+Nd157OdZfb90lgl9HHX9SdO7UKQYceUR67PGnnol9DjgonnhwcBzS/8BaeX00jEsf/lsahOrUtnV079B2qaGoZfls7MS4+MHn0nDe+t07R6vcnCgsLlnu89bIz4szDthjieNrdem40mOgcblhwndpEKpDdlZ0aZG11FDUsvx7dmG8MbswfpDfMnZpkx95mRkxuqQ0XpwxJ/42fXb8Ya3ucWjHJYMJbbMy44QuiwYdEr1yWtT49dA4PDJ3ThqEapuREe0zM5cailoZT8wtiEnl5cvt1yojI/bPbbXE8S6ZWas8Bhre08WFMaWyItpkZES7jMy0vaqeLS6MbyuWPrd6Z2XHQTnVhwffLSuJ8RXlsVm29y0AAAAAABovAawVdOutt8a7774bG220UfTv3z+uu+66hh4SNGuD/nRbrL/eOtGnd++4/sab48LLrljpa7w25I00fNV3l53ipb89Gzk5Oenxnx92aOx38KFx2jnnxb+ee7qq//TpM+L0X52fhr4+eGtI9FxzzfT4BeecFVvv1DdOOeuc2HfvPaNNmza1+EqpT3eeemSs36Nz9OnSMW546l9x0YN/XelrbNyrW7x67dmx9dq9ok2rlrHpL6+I/43/drnPa5efF5cdsX8NR05jdlOf7rF2bk70ym0Rt02aGteO/26lr3Fsl/ZxSrclw3hJRa0ffT4qrhw3OQ7p0DYN/i0ewPpVj86rNH4ap1+2ahvdM7OjS1ZWPD23IB4qWnb1oOX5qqw0nplbEAPz2sTdRbOX2Tc/IyMOz2u9Svej8Tour3V0zcyKTplZ8XxxYTxZXLhK1/umvDReKCmKX7TMjwfnFlTbp09WdrpVVznr5dK5kUT7dmlR8wpcAAAAAABQ16wJsALGjBkTl1xySdq+4447qkIaQMPZe8/d0/DVqrj7vgfS/VWXXLTI/9c/2nef2L3vLvHiK6/GmLHfV9Z68plnY8aMmXH6ySdWha8SSfu0k06IKVOmxjPPPV91/OQzzo6M/HZpQGxxC87dcNMtq/QaqF17b7VRGr5aFV3btY2+m66fhq/qwrDPv4nc/qfFNmddG8WlpSt8jobTt21+Gr5aFS0zq/8n20Z5ubFey5yYUlYes1ehAtLwOYXR8/0vYu/PRkbxYtdZ1jkazpYtctPwVW1IlsW8tWBmbJzdIn64CksYLu7zspI4ZPq3cc6sqenyhit6joa1aXZOGr6qrbl1d9Gc2CArO/aqQYDq/bKSmFNZGVtm58QaC70PvlNaHMfMmhI3Fc6MysXmz7LONXtJRjcJ6tbb1tAvGAAAAACg/ghgrYBTTz015syZE8ccc0zstttuDT0coJa8/ubQyM/Pj5133GGJc/vutVe6H/LmsO/7vzE03ffba88l++89v//Q7/vffMO1sfFGG8alV18b777/QdXxZ577W9x5z32x525947yzz6jlV8Xqqri0LO5/5e247sl/xp9eeD3+/b+R1fbbeeN14zeH/TD+M3JcXHj/s1XHZ8wpjKN/f1/ktsiOh849NnJbWKqpORhVXBLfFJdEjxbZ0baaME5JRWU8PmVG/GHilLh38vT4oKCo2uts37pVnNW9Y3xaVBxXL1Sha2ZZeZw6ckLkZGbEn9fuEblLCYKxenu4aE5MqSiPU1stWUWtOqWVEa8WF8VTRQXx97mF8WVZ9YHPjbNz4pCW+TGqvCweWKhCV0FFRdxSMDOSd6lz8teIFitwT1ZPTxUXxNSK8jgur80Kza3FDSmZm+53Wyy8tUOL3NilRW78t6w0XpzfJ/FdRXncXzQn1sjIiBNa1uyeAAAAAABQE5YgXI4nnnginn/++ejQoUPceOONDT0coJYUFBTExEmTYrNNNomsakILyfKGia+++abq2IL2+uuuu2T/+ccW7p+XlxeP3jco/m/3veOIAQPjo7ffjBkzZ8bxp54RHTt2iAfvuTMyhRmYb9L0WTHw1gcXObbt+n3i4XOPi3W7L7qE3MWH7Rev/Od/cdvzr8c+W28SP9pm0zjlz4/E6MnT4vZf/jw27tW9nkdPffmwoChemTknDcCMKymNF2fMC7X8tk+3avtPLiuPs0ZPWuTYVq1axu3r9Ii1chet6Hl2907xxqzCuGfy9Ni9bX7stUbrOH/MpBhXUha/7d0tNsjLrcNXRkP5tLQkXigujAF5baJbNUvAVWdGZUX8sXDWIsfWy8pOw1SLX+PQlvnx39KS+HtxYWzdIid+0CI3bi+cFd9VVMTJrdpEzxW8J6ufL+aHo36em58uabiyklDgZ+Wl0SEjM7bIXjJUfFTL1vFVeWk8WVwQG2W3iF6ZWXFH0ewoisr4ZV7baOvfWEvKyJy31ef9AAAAAACaCb/xWIYZM2bEmWeembZvuOGG6NSpU0MPCaglM2fN+8XxGmu0rfZ82zbzjs+cOWuFntO2bZsl+ie23GLzuOGqy+Os8y+MU848J8ZNmBDTpk2Pvz7xSPToLiTDPMfstWPsssl6sVnvHtE6Lze+HP9t3PLXV+Kh14dHv0v/EB/94eJFljTMysqMB88ZkC41OPAPD8QZP9kjnhz2QfTfcas4Yd9dGvS1ULc+LJgbN02cWvW4c3ZW3Lr2mmlganGHd2wX/9c6L12msFVWZoyYWxJ3fjstnpo2Kw79cky8tsna0XqhAGpWRkb8ae0esc/nI+OsURPjhC4d4rnps2O/dq3jqM7t6u01Un/mVlamQaoNslrEfiu49OCeOXmxSXZO9MrKjryMjJhQXhbPFRemlYoumzM9bmnbMfIWCl0k8+qs/DXi3NlT47aCWbF/bqt4q7Q4rWDUL7dVHb46GlJxZWUMKpqdBvP2zqnZkrxvlsyNZAHBpNJVZjWVrFpmZMQpeW3iqoKZcXvR7NgqOye+Li+LfXNaxubZlowHAAAAAKB+CWAtw/nnnx+TJk2KnXfeOQYOHFhr1x03btwyz0+cOLHW7gU0vDN+eXL86+VX46HHnkgfn3LCwPjJj/dr6GHRiFx6+I8XebzVOr1i8NkD0nYSwhr00rA4+8B5y1wu0KdLx/jzKUfEz2+8Ny5+8Lno2bFd3HnqL+p13NS/47q0T7eiiooYmQSqJk+LX3w1Ni5es3Oc0q3jIn3P7bFocHyzVi3jtrV7pO0khPXQlJlxctcOi/TpldsibujdLU4eOSGum/BdurThjX2ERZuq+wtnx/SK8rikbbtqAy7V+Vle60Uer53dIs7MXiNtJyGsl4qL4ictFw0EdsnKipNatY3fF8yMh+fOiY4ZmXFKq+oD0DQNj84tSCul/arlGis8txZWUVkZb5YWR/LMvssIcK2d1SJ+mtsqnigujIklRdE7MysOy10ykAoAAAAAAHXNmgBL8eabb8agQYMiOzs77rjjjsiowS8OlqZXr17L3LbffvtauxdQvTXaLlnhamGzZi9Z7WpZz5k1a/YS/RdI3j8OOuD7gM3pJ5+4yuOneTjhh7um+7c+/35py4XtueVG0XZ+ZazDd9suOrTxS+fmIi8zMzZp1TL+sFaP2KNtflw9/rv4oqh4hZ67oJrVu3MKqz2/S9tW0Wb+0l39O7SN9tkrv3QYjd8npSXxr5KiODyvdfSohWUA+82voJUsO1edLbJzolUap4nYNadl1Ryj6fm8rCReK50bB+e2im7VLPO8Ij4tL42plRWxcVaL6Lyc5Qu3zs6ZP7Mids9pGdm1+HNbk5OZUf8bAAAAAEAz4Tcf1SgpKYkTTzwxKisr4+yzz47NNtusoYcE1LL8/Pzo3q1bjBw9OsrLy5c4/9XXI9L9+uuuW3VsQfurb5YMwyw4tnD/BUaOGhXnXXRpdOjQPg1jHX/qGdXeExbXqc28SjMFc0uqPX/8rQ/GrMK50bFNftz63Gvx0Yix9TxCGoPd2uZHRUT8eymBqsV1mB+oKqxIFvda0jmjJsXsiopon5UVd0+eHp8Uzq3V8dI4jCyfF5R6oGhOHDz920W2xPiK8rR95IzJK3S9tvOXHUyWNazOHwtnRmFURpuMjHi+uDBGLiWoxepvzPx/4zxeXBjHzJqyyJaYWFGetk+Z9f1yqotLqqkldlvO8oVllZVxZ9GctJ0E/P5SXBjTKvwbCwAAAACA+ieAVY1rr702vvjii+jdu3dcdtlltX79sWPHLnMbPnx4rd8TWNJuu+wcBQUFMeztd5Y4969XXkn3fXfZ6fv+u+6c7l985dUl+7/8StU1F1ZWVha/OO7EmD17djx+/31xzumnxlvv/DuuuPb6Wn89ND3DvxyZ7tfqsugycYk/vzAknn/34/jF7tvHP644PT125E33RmFx9WEtmq5vS8vS/YpWffmgYF6woVdOiyXO3Td5erw4c078tEPbeGyDXumxU0ZOiMKKJOJFU9I7Kzv2ymlZ7ZZolZGRtpOKQiviy/mBqi7VVCv6x9zCeK+0JA3TXNq6fXosWY6weClhLVZvPbOyom+L3Gq3BUGppL1zzrzHi5tTUREflpVEfkZGbJOds8x7PVVcGKMqyuKAnLw4Ka9NFMwPZCVLGFKN5O+J+t4AAAAAAJoJAazFJMGr6667Lm3fdtttaZWc2tazZ89lbt27d6/1e0JzNmXK1Pjif1+m+4WdeNwx6f6Sq65JK98t8I9/vRSvvzE0+u21Z/Tp3bvq+GEH90+XGLztjrti3PjxVceT9h/vvDs6deoY/X+y/yL3SIJWb/97eJx7xmmx9567x7VXXBo/2GrLuPZ3v483h71Vh6+aujZl1pz4YtykdL8qkmtUF5pKjl/4wLNVywsu7JPRE+L8wU/HOt06xR9POjx+sG7vuOrIA+KLcd/GOYOeXKXx0LCmlpXFV3OL0/3CPiooqrZ/Up3qge9mRIuMiL5tWlUdT65RXWgqOX7NuMlVywsuLFnC8Mpxk6NPTou4vnfX2KJVy/h1j07x9dySuHTsvKpIrJ5mVVTEuPKydL/Ali1y49T8NardEu0zMtP28a2+nyfJNaoLTSXHH5xfhShZXnBho8vL4v6i2dE1MytObNUm1s1uET/Pa51W2Lq3cN7yvay+kmp5E8rL0v0Cm2bnxMC8NtVuiTUyM9P2kS3nVXlc3LDS4kjeAXdqkRstlhHg+aSsJP5ZUhTrZmXHQbmtYqsWObFXi5bxRXlpvFBS/XsmAAAAAADUlew6u/Jq6uabb06DGOuss04UFhbGY489tkSfTz75pKr96quvxqRJk9L2AQccUCeBLWBJgwY/EEPfejttf/zpZ/OO3f9gvP7m0LS9y047xvEDjk7bf7zzrrji2hvist9cEJdfdGHVNfbYrW/aJ7nWD3baLX78w34xcdKkePwvz6TLBd52028XuWf79u3ijzf9Lo46/qS0/88O6Z8ef/ypZ2Lq1Gnx+AP3RZs28365mHhj6LA0aJUErq65/JL0WE5OTjxy36DYZpfd48iBJ8Z/3hka7dq1q/M/L1bMPS8Oi2Gfz1tO8pPR80J297z0Vgz55Ku0vfPG68bAfvOqnP3phdfjqsf+Hpccvl9cdsSiwbvj/vBAVXvi9JlLHDv/p/1io57d0vbjb74Xt/z11dh10/WiT+cO0aplTnw1YXL84/1Po7SsPC44ZN/ou+n6Vc+dW1KaVroqKy+PB885Ntq0mhd2OOegveOljz6PQS8Oi35bbxIH77R1nf05sXIenjIjhs9fHvDzouL5x2bGW/OPbd+6VfyiU7uqClQ3TZwa53bvGL/q0bnqGieMGJ9WuEpCUWvmtIiSysr4Zm5JvDGrIJI4zFW9ukSv3O8rxfx12qy489vpsUObvOiZ0yJaZWam/V+dNSdKKyNO79YxdlwosDW3oiJOGTEhXc7rz+v0iNZZ86oYndy1Q7w+qyAd7+5t82P/9ouGtmg4LxUXxhfzq04lIafEy8VF8WnZvEDnRtktYp/cef+N/15cGE/MLYjDWubH4XnVh15WxNCSufG3uYWxSYsW0TkzK1pGRkyoKI8P5gdmDm7ZKjZt8f08TObpzXNmRrIg3Nn5a0Te/GUKD8xtFf8pLYmXSorS0MyOK1hli/rxesnc+Gr+EpVj58+tIaVz02BTYv2sFlWV0V4uKYpnS4rioJy86N+ydn4OeqN0/vKDLZY+L5LA191Fc9I5eEpem8iaH9Q6vGV+/K+8NJ4pLoxNslqkgT8Wkvw/OP//w3q7HwAAAABAMyGAtZji4nm/GB0xYkQcccQRy+1/1VVXVbVHjhwpgAX1JAlf3f/wo4scS5YSXHg5wQUBrGW587ZbYvNNN4m77r0//vDnO6J16/y0itU1l10S666z9hL9jzziZ9GpY8e49sab4r4HH4mMZHmcrbeMi88/L61wtcD06TPiyIEnRV5eXjw6+J40eLXAhhusH7f89ro44dQz4oTTzownH7p/Ff4kqE1J+OqBVxddkvKtz79JtwUWBLCWZfFrLH7s6D13qApg7b75BvHF2Enx0chxMfSzr9NqWJ3ato4fbbNpnPyjvmmYamHn3/d0WgHryl8cEP+34fdzNJmL9515TGx95jVx0p8eju3W7xO9Oi+5dCH1LwlfPTF11iLH3i0oSrcFFgSwluaMbp3i5Zlz4v2Conhxxpw0dNWlRXZaxeq4Lu3jB/l5i/TfqU1+fDW3JK2Q9e/ZRVFUUREdsrNiz7atY0CX9mmYamFJ5asv5hbHBT06LXKtZF7dunaP2POzkXHe6EmxdX5eGgCj4SXhq9dK5i56rLy0KiST2Kf6Fd5qbPPsnBjXoixGlpfF56WlURyV0SYjM37QIjd+mJsXW81fYm6BpPLVmIqy+HnL/NhgoSBMMq9Oz28b58yaGrcXzor1s1tEp2qWLqRhJOGroaXFix0rS7cFdo+6Cc19U14a4yrKY53M7OiVtfQfVQfNnR0zKivipLzWaRhwgZyMeYGsywtmxO1Fs+Oq1u2qgn8AAAAAAFCXMiorq1lHpBkbMGBA3H9/zcIQSQBrrbXWWuUxjBs3Lnr16pW2x44dmy5LCLWmcF41HqhN5S8/0tBDoAn67spbG3oINEFvj5je0EOgCZpdntT5gtozraI8zp4zfZV/Jlz4Z8tRd1wWPTvWX+XVcVNnxFonX5G2/VwLq5/G8NlUeXl5fPfdd2m7c+fOkTW/Sis0FHOSxsacpDEyL2lszEkao9VhXjaGnwlhdeTrwIsZPHhwJJm0ZW2XXXZZVf/XXnut6nhthK8AAACg1mVm1P8GAAAAANBMCGABAAAAAAAAAADUUHZNnwgAAACsLjIiMurzO1gqYAEAAAAAzYcKWAAAAAAAAAAAADUkgAUAAAAAAAAAAFBDAlg1cPnll0dlZWW67b777g09HAAAAFi2jIz63wAAAAAAmgkBLAAAAAAAAAAAgBrKrukTAQAAgNVERua8rT7vBwAAAADQTPhEFAAAAAAAAAAAoIYEsAAAAAAAAAAAAGrIEoQAAADQ1GVmzNvq834AAAAAAM2EClgAAAAAAAAAAAA1pAIWAAAANHUZmfO2+rwfAAAAAEAz4RNRAAAAAAAAAACAGhLAAgAAAAAAAAAAqCFLEAIAAEBTl5Exb6vP+wEAAAAANBMqYAEAAAAAAAAAANSQClgAAADQ1GVmRGRm1u/9AAAAAACaCRWwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYsQQgAAABNXkZERn0uC2gJQgAAAACg+VABCwAAAAAAAAAAoIZUwAIAAICmLiNz3laf9wMAAAAAaCZ8IgoAAAAAAAAAAFBDAlgAAAAAAAAAAAA1ZAlCAAAAaOoyMuZt9Xk/AAAAAIBmQgUsAAAAAAAAAACAGlIBCwAAAJq6zMx5W33eDwAAAACgmfCJKAAAAAAAAAAAQA2pgAUAAABNXUbGvK0+7wcAAAAA0EyogAUAAAAAAAAAAFBDAlgAAAAAAAAAAAA1ZAlCAAAAaBZLENbjd7AsQQgAAAAANCMqYAEAAAAAAAAAANSQClgAAADQLCpg1WNVKhWwAAAAAIBmRAUsAAAAAAAAAACAGhLAAgAAAAAAAAAAqCFLEAIAAEBTl5E5b6vP+wEAAAAANBM+EQUAAAAAAAAAAKghFbAAAACgqcvIiMjMqN/7AQAAAAA0EypgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA1ZghAAAACauozMeVt93g8AAAAAoJnwiSgAAAAAAAAAAEANqYAFAAAATV1GxrytPu8HAAAAANBMqIAFAAAAAAAAAABQQwJYAAAAAAAAAAAANWQJQgAAAGjqMjLnbfV5PwAAAACAZsInogAAAAAAAAAAADWkAhYAAAA0cRkZyZZRr/cDAAAAAGguVMACAAAAAAAAAACoIQEsAAAAAAAAAACAGrIEIQAAADR1GZnztvq8HwAAAABAM+ETUQAAAAAAAAAAgBpSAQsAAACaOhWwAAAAAADqjABWY1c0K6JwZkOPgiak/IOXG3oINEGV/32/oYdAE5TXOrehh0ATtEmn/IYeAk1Qy5Z+rKJ2TSwtjfhiekMPAwAAAACAFeQrqQAAAAAAAAAAADXkq9oAAADQ1GVkRGRm1O/9AAAAAACaCRWwAAAAAAAAAAAAakgFLAAAAGjqMjLnbfV5vzo2efLkGD58eLq9++676TZ16tT03DHHHBODBw+ulfuUlZXFxx9/XHWfZP/ZZ59FeXl5en7kyJGx1lpr1cq9AAAAAIDVkwAWAAAAsNrp2rVrvdznmmuuicsvv7xe7gUAAAAArJ4sQQgAAACs1nr37h39+vWrk2tXVlZWtVu2bBk77LBDrLvuunVyLwAAAABg9aQCFgAAADR1GRnztvq8Xx279NJLY7vttku3pBrWqFGjYu211671++y4445xxx13xPbbbx+bb755ZGdnx4ABA+Kbb76p9XsBAAAAAKsnASwAAABgtXPFFVfUy3323XfferkPAAAAALD6EsACAACAZlEBK7N+7wcAAAAA0EzU46evAAAAAAAAAAAATYsKWAAAANAsKmDVY1UqFbAAAAAAgGZEAAsAAACoMxMnTlxun549e9bLWAAAAAAA6oIAFgAAAFBntt9+++X2qaysrJexAAAAAADUBQEsAAAAaOoyMudt9Xk/AAAAAIBmQgALAAAAqDPDhw+P7t27N/QwAAAAAADqjAAWAAAANHWZGfO2+rzffEn4qmfPnvV3bwAAAACAemZNAAAAAAAAAAAAgBoSwAIAAAAAAAAAAKghSxACAABAU5eROW+rz/sBAAAAADQTPhEFAAAAAAAAAACoIQEsAAAAaPIyIjLqcUvutxoYPHhwZGRkpNvll1/e0MMBAAAAAFZTliAEAAAAVjtDhw6Nr7/+uurxlClTqtrJ8SRctbABAwbU6D5z5syJp556apFjC983OdepU6eqx1tttVW6AQAAAADNhwAWAAAAsNoZNGhQ3H///dWeGzZsWLrVRgArCXYde+yxSz1/3nnnLfL4sssuE8ACAAAAgGZGAAsAAACaunRpwMz6vR8AAAAAQDMhgAUAAACsdpIlBhdfZnBlJVWxllcZa6211orKyspVug8AAAAA0LQJYAEAAECzqIBVj1WpVMACAAAAAJqRelx/AAAAAAAAAAAAoGkRwAIAAAAAAAAAAKghSxACAABAU5eROW+rz/sBAAAAADQTPhEFAAAAAAAAAACoIRWwAAAAoKnLzJy31ef9AAAAAACaCZ+IAgAAAAAAAAAA1JAAFgAAAAAAAAAAQA1ZghAAAACauIyMjHSrz/sBAAAAADQXKmABAAAAAAAAAADUkApYAAAA0NQlFaky6vE7WCpgAQAAAADNiApYAAAAAAAAAAAANSSABQAAAAAAAAAAUEOWIAQAAIBmsQRhPS4LaAlCAAAAAKAZUQELAAAAAAAAAACghlTAAgAAgCYvMyKjPr+D5fteAAAAAEDz4RNRAAAAAAAAAACAGlIBCwAAAJq6jIx5W33eDwAAAACgmVABCwAAAAAAAAAAoIYEsAAAAAAAAAAAAGrIEoQAAADQ1GVmztvq834AAAAAAM2ET0QBAAAAAAAAAABqSAUsAAAAaOoyMuZt9Xk/AAAAAIBmQgUsAAAAAAAAAACAGhLAqsZ7770XV155ZfTr1y969uwZubm50bp169hggw3i2GOPjaFDhzb0EAEAAAAAAAAAgEbAEoSL6du3b7z55ptLHC8pKYmvvvoq3QYPHhxHH3103H333ZGTk9Mg4wQAAICVW4KwHr+DZQlCAAAAAKAZEcBazIQJE9J9jx494tBDD41dd901evfuHeXl5fH222/HTTfdFOPHj48HHnggSktL45FHHmnoITd6Dz36eLz51tvx/ocfxceffpaG2e67408x4KhfrNR1Kioq4k933h133Xt/fD1iRLRunR977757XHP5JbHO2mtV+5x/vfRKXHvjTfHBR/+NjIyM2GbrLePi88+LvfbYrZZeHQ3l4X+9EUP/+3l88L9v4uMRY6KktCzuufDUOGa/PVb4GpOnz4x7n38lPvjfiPjgyxExauLk9HjZm09V23/8d1Pjqdfejn+880H8b/SEmDRtRnRo2zp22nzD+NURB8b/bbpBrb0+GsbDH30dQ0dPig8mTI1Pvp0WJeUVMaj/rnHMD1b8v23y/L9+NjqGjJoYo6fPiYLSslirXes4YKPecUHfLaNdXu4i/cfPKoinPhkZ//xybPxvysyYNKcoOuTlxk69u8a5u2we/9erSx28UurT499Oj7dnzomPZhfFZwVzo6SyMv60Ya/4RbcOK3yN92YVxKAJU+M/s4tiYklpFJVXRI/cFrFVm7w4o1eX2LpNq0X6z62oiCtHTIwP5xTFyKLimF5aHmtkZ8XaeTlxVPeO8bMu7aNFpl+Mr86emzU73iuaG58WF8eXJSVRWhlxbdfOcXDbNit8jf/MnRuPzJgVnxUXx+Sy8iiqrIxu2VmxaW5uHNe+XWzectH3q6dnzY7ffPvdMq+5Q17LGNyzR41fFw3vmemzYnhhUXxSNDf+N7ckfc/6Xc+ucWj7NVb4Gh8WFsWDU2em1/i2rCyKKiqje4vs2CwvN07q1CG2aNVyqc/958zZ8dC0ec8trKiMLtlZsXWrvLiwW6fokdOill4lAAAAAADULgGsxWy00UZx7bXXxk9/+tPIyspa5NwOO+wQRx11VOy8887x5ZdfxqOPPhonn3xyWjWLpbv4yqtj9Jix0alTx+jerWvaromTTj8rBg1+IDbdeOM445STYsLEifHE08/Gi6++Gu+89nKsv966SwS/jjr+pOjcqVMMOPKI9NjjTz0T+xxwUDzx4OA4pP+BtfL6aBiXDno0Rk/6Ljqt0Ta6d2yftlfWZ6PGxsV3PZKG89bv2T1atcyNwrnFS+3/x7/8I3738LOx7prdYp/ttoxO7drG1+Mmxl+HDo+/vvluPHTpmXHYXjuv4iujIV32yvsxesac6NSqZXRv0yptr6zDH3s1phTOjZ17d40jt1ovLf4wZOSkuHHox/H0p6PijRMPiK6t86r6/+mdz+J3b/431u3QJvZeb83o3KplfD11Vvz1i9Hx189Hx4OH7h6Hbb5OLb9S6tPVIyfG2OLS6NgiK7rmZKftlfX2zIJ4ffrs2LZtfuzavnW0ysyIUXNL4h9TZ8Wz382M2zfqFYd3/T7QVVBeEfdOnBo/aNMq+nVoG51aZMeMsvJ4adqsOO1/Y+PpydPjqc3XiUzVSVZbt0ydHhPKyqJ9VmZ0zspO2ysrCXC9VVgUW7XMjf/Ly4u8zIwYW1oWrxYUxj/nFMT1XTvHgQsFujbOzYlTO7Sr9lovzimIr0pKY5dWi4YBWf3c+O2UGF9aFh2ysqJzdlbaXlnvFhTF0DkFaXBqp9atomUyt0pK4+VZBfH3mXPipp7d4uD2bRd5TmVlZfxmwuR4dNrM6JPTIg5Yo03kZ2XG5NKy+HdBUToOAazaqIBVj+/7/o4BAAAAAJoRAazFPP/888s836lTp7QK1gEHHJA+fuqppwSwlmPQn26L9ddbJ/r07h3X33hzXHjZFSt9jdeGvJGGr/ruslO89Ldnq5Z+/Plhh8Z+Bx8ap51zXvzruaer+k+fPiNO/9X5aejrg7eGRM8110yPX3DOWbH1Tn3jlLPOiX333jPatFnxKhE0LndecEoamurTrXPc8NAzcdGdD6/0NTbu0zNeve3K2HqDtaNNq7zY9BdnxP/GzKuCV53tN14vXrn1itht600XOf7mfz6LfmddGafedHccuOv2keuXg6utOw/aJdbr2Db6tGsTv33jP3HRS++t9DXO3HHT+MVW60WPtvmL/FL59OffijuHfxFXv/Zh3HbATlXntluzc7xy3H7Rd+3ui1xn6KhJ0W/wP+K0vw2LAzfuE7nZi4aCWX3ctmGvWCcvN3q3zImbx3wbV4yctNLXOGHNTnF6NdXQPisoij0/+Cou+WZiWtUqCZQm2mdnxZidN4uczEWXmiqrrIyD/vNNvDp9Trw0bXbs23HRAASrj6u7doo+LVrEmi1axF3TZsTvp05b6WscuUbbGNh+yUDVl8UlcejY8fHbKdPiJ21aV82rjXNz021xSYWkh2fMSn+wOKht6xq+IhqLG3p2jbVycqJnTov48+Rp8dtvp6z0NY7u2C5O7Lxklb//zS2On3w9Jq6d9F30b9emam4l7ps6Iw1fHdVhjbi8R5fIWiy8k7x/AQAAAABAY7Xob+VYIXvs8f0SZ998802DjmV1sPeeu6fhq1Vx930PpPurLrmoKnyV+NG++8TufXeJF195NcaM/b6y1pPPPBszZsyM008+sSp8lUjap510QkyZMjWeee77sN3JZ5wdGfnt0oDY4hacu+GmW1bpNVC79t52izR8tSq6dmgXfbfaJA1frYj+u+2wRPgqseuWm8TuW28a02fPiY9HjK46/vjLQyN710Ni//OuSQM4C1vWORrOXuuumYavVsV5fbdcJHyVSH7BfNHuW6ftN0dNXORc/03XWiJ8ldhlrW6x+9rdY3pRSXz87ffBisf/+020uOSeOOCBfy05r5Zxjoaze/s2afhqVbRcLEi1wCb5ebFBq5bxXWlZzCqvqDqeVLZaPHyVyM7IiP07zVtGbETR9xX//jJ5erQb8p849OMRS8ydZZ2j4ezUqlUavloVuUuZVxvk5sS6OS1ianl5zKlY/n/zV+YUxIyKitg9v1V0yv7++x0vzJ4TG301Ik4cP3GJubOsczSsXVrnp+GrunjP2rBlbqyXmxNTyspjdkXFIsum/mHy1Oid0yIuqyZ8teD9a4HnZsyKtT7+MgaMHLfE/FnWOQAAAAAAqCsCWDVQXPz9LywXX6aQuvH6m0MjPz8/dt5xhyXO7bvXXul+yJvDvu//xtB032+vPZfsv/f8/kO/73/zDdfGxhttGJdefW28+/4HVcefee5vcec998Weu/WN884+o5ZfFU1Ji/nVibIXek/42d67xNE/3D3++c6HceuTL1QdHzVxcvzyprvSANi9vzltkeoPNF0t5v8yOmspv5Re1nOyF3rOz7ZYN47aev3451fj4ta3P606Pmr67Dj1b2+lyxvec3Bf86qZGFlUHF8XFkfP3BaxxgpUSauorIxXps9O25vkt6w6/tMu7eOIru3Tqli3j/++2s3ouSVx9pfjokuL7Pjzhr3Mq2ZiTElpjCwpje7ZWdEma/nvWU/OmjenDllj0YpqP27TOg5q0zreKCyKB2bMqjo+rrQ0Lp88JTplZcV1XbuYV83I6OKSGFFcEj1aZEfbhf7N9MacwphZXhH92raO8srK+OfM2Wn1rYemzohRxSVLXOcn7drGT9u1jdfnFMa9U2dUHU+WObxo/OTolJ0VN/bqZm4tIaMBNgAAAACA5sEShDUwZMiQqvbGG2/coGNpDgoKCmLipEmx2SabVBt4S5Y3THy1UDWyBe311113yf7zjy3cPy8vLx69b1D83+57xxEDBsZHb78ZM2bOjONPPSM6duwQD95zZ2SuRGiC5mXMt9/FK+9/HN07to/N11m02tutZw+Mtz75In5z58Np9azk/FFX/iFmFRTFI5efE13az6tEQ9M3+IMv0/0+631flW9ZxsyYE6+MmBDd27SKzbu2X+TcrT/eMd4e/W26ROJua3dPzx/91Osxq7gkHjls3+jSesWqurH6eX9WYbw4bVa6FNfYuSXxj6nzQi2/X79ntf1LKiripjGTI6kBM720LIbMmBNfFhbHL7q1j93aL1rt7Xfrrxn/nlUQV4yYGLu0ax2b5reMEz8fHbPLK+K+TfpEZ8urNln/nTs3hhQURlllxISysni1oCA9fnmX5VeaHF9aGu8UFkW37KzYtZqKkpd06RQfzp0bN02dFtu3ahkb5OTEeZMmx5yKivh9j27R0fKqTdpHhUXx2uyCdG4lc+XlWfPm1jU9Fl1S9ZOiuek+mQ0/+mp0jCgprTqX/At8YKf2cVH3RefjlT26xPuFRXHDpCmxQ35ebNQyN84aOzGdW3/sveYi1dgAAAAAAKCu+VR6JVVUVMT1119f9fiwww5b6WuMGzdumecnTlx0earmbuaseb9cXmOxqgoLtG0z7/jMmbNW6Dlt27ZZon9iyy02jxuuujzOOv/COOXMc2LchAkxbdr0+OsTj0SP7ksuDwaJ0rKyOOaq26K4pDSuO/nIJUKCrVvlxUOXnRW7nnJxHHnFLbHfjtvE25/8L848bP/Y9/+2arBxU78+mjg1rnrtw+iS3zJ+tcsWy+1fWl4RA/4yJIrLyuPaftsuUTWrdW6LePCw3aPv3c/HUU+8Fvtt2DveHjM5ztxp0+i3lCAOTcP7swvjhtHfVj1OKlPdsVHv2LND9UtnllRWLtI/qUVyes/Ocdk6S/691jorK+7ZuE/0+/DrOP7z0bFvh7bx71mF8cs1O8VeHar/O5im4b9zi+NP076vIpRUprq+W+fYJb/Vcp/79KzZkSwk179tm2qXjcvPzIwbu3WNn48dH+dOnJwuU/jh3OI4pt0asesKXJ/V238K58YfJn+/jG5Smer3PbtH3zaLLtWbLEmYGDRlemyWlxt/Xbd3ulThp3PnxoXjJ8fdU6anyxMe1bFd1XPyszLj1l7d46cjxsQZYyfFXm3y4/3CuTGwY7vYbbHrM1/y/2h9VgVTgQwAAAAAaEYEsFbSzTffHMOHD0/bBx98cGyzzTYrfY1evXrVwcioDWf88uT418uvxkOPPZE+PuWEgfGTH+/X0MOiEQcyj7v2j/Hmfz6L4w/YO4784W7V9tt2o/XiiuN/Fr+54+H4YvT42Gr9teK6k39R7+OlYYyYNisOfPDFdEmlhw/bIzottOxbdSoqKuO4p9+IN0dNioHbbhhHbrV+tf22XbNzXLHnD+I3L70XX0z5OLbs1iGu3We7OnoVNBYnrtkp3YrKK+KbouL407jv4pCPR8QV63SP03stWlFmQahqxm5bpksPTiwpjX9OnRVXjpwU784qiCc2XyfaLlZ9aOs2reKitbrF5SMnxpeF38XmrVvG5dWEtWhajmy3RrrNraiI0aWlcd/0mXHihElxbqcOMbD994GXxSXz6plZc9Jg30/nB9yrs3nL3DijY4e0CtaIGTNj49yc9No0fcd0ap9uydwaWVyaBqwGjBofv+7WKU7s/P0cqKycv/RuRkbc1WfN6Npi3o+p2+e3ij/37p5WxUqeu3AAK7FFq5ZxTtdOaRWsb4pLYpOWuXFBt+VXbgMAAAAAgNpmTbWVXHrw17/+ddru0qVL3H777Q09pGZhjbZLVrha2KzZS1a7WtZzZs2avUT/BTIyMuKgA35c9fj0k09c5fHTdMNXx1/353j0paHxi35948+/WvZc+cku21ctY3n8AftETgtLeTUHI6fPjn3u/XtMKZwbjx++Z+y+To/lhq+Of/bNeOy/38TPt1w3/nzAzsvsf8DGfSJzfnWJ47fbKHIs5dVs5GVlxmat8+L2jXrH3h3axGUjJsZnBUVL7Z/MkzVzc2Jgj07xhw16xjuzCuOmMd9XxlrYfp3aVv0DcUD3jpFjCd5mo2VmZmyYmxvXd+uSLid405Rp8WVxyVL7v1VYlC5ZuENeXvRczt9re7VuVTWvDmvbNnJUxml2c2vjvNy4qVe3tDrV9ZOmxP/mFledb5M1b3ZskdeyKny1wIYtc9PqV6NLSmNm+bxKWQvbp03rqrl1RIc1IifT3AIAAAAAoP75jdoK+vTTT6N///5RVlYWLVu2jCeffDINYdXE2LFjl7ktqLDFPPn5+dG9W7cYOXp0lFfzS5evvh6R7tdfd92qYwvaX33zzZL95x9buP8CI0eNivMuujQ6dGifhrGOP/WMau9J85aErwZe96d44J+vx+F77xL3/ubUqnDV0pcp/EPabtc6Py4d9GiMmzy1HkdMQ1W+2vueF2LinKJ49Gd7xo837L3c8NXAZ96IBz/8Kg7ffJ249+C+kbmMXyInyxQe89SQtN2uZU5c9vL7MW5mQa2/Dhq/Pdq3SZeAe3sF//sn/RNDZyzZv7SiMk78fEzaXiM7K64eOSnGLyOAQ9O1c6tW6bx6v2juUvs8NT/UfsgaS69+lSitrIzzJk1O220zM+OWqdNiUmlZLY+Y1cWurefNreELhUbXyc1J923nB7EWt+B4ccX8UlkLza2zx02smls3fTslJpaW1uHom8gShPW5AQAAAAA0EwJYK2DkyJHRr1+/mD59emRlZcVjjz0Wffv2rfH1evbsucyte3dL/Sxut112joKCghj29jtLnPvXK6+k+7677PR9/13nVY158ZVXl+z/8itV11xYEq77xXEnxuzZs+Px+++Lc04/Nd56599xxbXX1/rrYfUPXz34zyFx2J47xf0Xn56+LyzLRXc+Eu//b0T8+qj+Mfji02ParDlxzNW3ptei6YavkspXSfjqkcP2iJ9s3GeFwlcPffR1HLbZ2jH4kN0iazlVhy5+6b34YMKU+HXfLdP+04qKY8BfhqTXonmZVFJatXTXCvUvXtB/yXNXjpwYH80pinN6d4k7N+od08vK46TPx6RLzdG8TC6fF5DKXsq0ml5eHq8UFMQamZmxT37+Mq9185Rp8WlxSZzUoV3c0LVzzKyoiPO/nWxeNVPfzg/fLfyetWN+Xrr/uprAZxKyGlVcGq0yM6LDYpUefzdpSnxcVByndu4QN/fqFjPKK+LssZPMLQAAAAAA6p0A1nJMmDAh9t5773SfVES6995748ADD2zoYTVZU6ZMjS/+92W6X9iJxx2T7i+56pooKfn+FzP/+NdL8fobQ6PfXntGn97fV5c57OD+6RKDt91xV4wbP77qeNL+4513R6dOHaP/T/Zf5B5J0Ortfw+Pc884Lfbec/e49opL4wdbbRnX/u738eawt+rwVVPXpsyYFV+MHp/ua2PZwSR8dcgeO8YDl5y53PDVS+/+J25+/G/xf5tuEJcOOCz233nb+OXBP4whH34aNzz0zCqNh4Y1pWBufPHdjHRf3bKDE2YXxsOH7hEHbbLWCi07mISvDtl07bj/kN2XG756+evxcfNbH8f/9eocl+yxdVpd65T/2ziGjJwYv33zP7Xy+mgYU0vL4svCuel+YR/OLqy2/3/nFMV9E6amQYbd5le2SnxRMDcKy5cMeSbHLvpmQtrep8OiS/G+Nm12/HHcd7Fdm1bx67W6xQ87to0TenSMoTML4uYx86oXsXpKwlIjSkrS/cI+XmgJuIV9Xlwcj82cFcmigju2mheMWdxzs+ZEaWXET9q2XuaSb8MKCuO+GTNjy5a5cWqH9rFH6/z4+RptY3jR3Lhr+oxVfGU0tGll5fH13JJ0v7D/FlZfOe3TornxyLSZaQB059atqo73yc1JK2ONKimNx6bNXOQ5t0+eFrMqKmLftq0je6HQ1puzC+LuKdNj67yWcWbXjrFX29ZxdIc14p2Corj9u2m1/lqbhowG2AAAAAAAmofshh5AYzZlypTYZ599YsSIeUvc3XbbbXH00Uc39LBWO4MGPxBD33o7bX/86Wfzjt3/YLz+5tC0vctOO8bxA+b9uf7xzrviimtviMt+c0FcftGFVdfYY7e+aZ/kWj/Yabf48Q/7xcRJk+LxvzyTLhd4202/XeSe7du3iz/e9Ls46viT0v4/O6R/evzxp56JqVOnxeMP3Bdt2nz/i+o3hg5Lg1ZJ4Oqayy9Jj+Xk5MQj9w2KbXbZPY4ceGL8552h0a5duzr/82LF3PO3l2PYf79I25+MmLdc1j3Pv5IGmxI7b7FRDDxg77T9p6f/EVfd92RccuyhcdlxP1vkOsdd88eq9sSpM5Y4dv6R/WOjPmum7asGP5kuO9g6r2Ws36tHXPPAU0uM68Bdt4+t1l87bSeBr+RabVrlxUOXnhnZ86s2/PaXR8cbH30WV9z7ROy5zeZpOIvG4Z73/hfDxnybtj/5dt4vb+99/8sYMmpS2t65d9cYuO2GafvP//4srnrtwzQAdemeP6i6RhK+GjOzIA1HffzttHRb3ML9r379w3TZwdY5LWL9Tm3j2iEfLdE/qaC1VfeOaTsJfB339BvRJqdFPHjoHpE9f1mm3+67fbwxclJc8eoHscc6PeL/etVsmVxq3wMTp1YtD/jZ/MDegxOnxtAZc9L2jmvkx9Hz//veNX5K3DD627igT9e4cK1uVdc4+tNRafBgqzZ50TM3J0oqK+PrwuJ4bfrsSOq8XL9ej+jTct4SXolnvpsRfx73XeywRn70bpkTbbIyY0JxWbw8bVYalEju+cuenav6J4GvU/43Ju1398a9q0IOV63bI4bNLIjrRk+K3dq3jm3bLrvSEfXnyZmzqpYH/HJ+OP2pmbNieOG8Zd22yWsZh64xL2T30IyZ8adpM+LUDu3i9I4dqq5x5sRv0wpXm+bmRvfs7CiNyhhZUhpvFRal8+o3nTtGzxZJDGtJT82aF2o+pO2iQb6FJYGvX3/7XeRnZsRN3bpUzasLOnWId4uK4o9Tp6cBry1btqy1PxdWXRKAenf+8oD/mx/Se3zazHhnzrxj2+XnxeEd1kjb90+dHn+YPC3O7NIhzu7aqeoap4yZkP733iwvN9Zs0SJ9zxpRXBJD5xSmc+uy7p2jV86ic+vqHl3ipyPGxq/HfxsvzpoT6+bmpIGttwqKYs0W2XFht+/fs5L3sXPHTYrWmZlxa+/uVXPrN907x78LiuLmb6fGTq1bxdZLCRACAAAAAEBtE8BaipkzZ8a+++4bn302LzB0/fXXx6mnntrQw1otJeGr+x9+dJFjyVKCCy8nuCCAtSx33nZLbL7pJnHXvffHH/58R7RunZ9Wsbrmskti3XXmBV4WduQRP4tOHTvGtTfeFPc9+EhawWybrbeMi88/L61wtcD06TPiyIEnRV5eXjw6+J40eLXAhhusH7f89ro44dQz4oTTzownH7p/Ff4kqE1J+CoJQy3srY+/SLcFFgSwlmXxayx+7Oj9dq8KYI2e+F26n1M0N6574C/VXm+tbl2qAljJUoUTp06PBy45I9bu0bWqT8vcnHjosrNihxN+HUdd+Yd4/74b05AWDS8JXyVhqIW9NebbdFtgQQBraUbPD9X8e+x36VadhQNYo+b3n1NSGtcNqb56VZ92rasCWMc/80ZMnF0Y9x+yW6y9UMWjli2y46HDdo8d73gujn7y9Xjv1IOiTe7372c0nCR89ei30xc59s6swnRbYEEAa2nO7d01/jltVrw7qzD+WTorkpUmu+a2iEO6tI8T1+y4RDAqqV6VLE04fGZhDJ9VGAXl5dE2Kys2bZ0XP+3cLo7s3mGRSjK//GJsTCopi7s26h1r5eVWHW+ZmRmDNu4de37wVRz/+Zh4c5sNos1iS4DRMJLw1bOz571/LPDB3OJ0W2BBAGtpkiUBXy8ojP/MLY7XygsjqZnWOSsr9m/TOn7Rru1Sg1H/nTs3viopjS1yc2PDZbzPXPjtd/FdeXn8rmvnRYJcuZmZcVO3rnHo2PHxq0mT45nePdMgDY1DEr76y2JVQ98rnJtuCywIYC3NqV06xKuzCuKjwrnxSllBOre6ZGfFge3axNEd21UbjEqqYD23bu/4/eSpMWR2Qbw5pyA6Z2enVa3O6NoxOmV//6PreeMmxeSy8rilZ7dFglwt5weyfvL1mDhz7KT4+3p9ovX8oDIAAAAAANSljMrKyuRLyCyksLAw+vXrF8OGDUsfX3TRRXH11VfX2/3HjRsXvXr1Sttjv/w0eq45L/wBtaH8g5cbegg0QZWv/6Ohh0ATVPDyew09BJqgSRNmN/QQaIJatvS9FmrXxNLS2PGLkWl77Nix0bNnz1X+2XLM8NejZ4/vqyvWtXETJkXv7Xdf5dcANIxFPptqoP+Hy8vL47vv5n2ppXPnzpGV5YsANCxzksbGnKQxMi9pbMxJGqPVYV42hp8JYXXk68CLKSkpif79+1eFr84888x6DV8BAAAAAAAAAACrD1/VXswRRxwRL774Ytrec889Y+DAgfHJJ58stX+yXN0GG2xQjyMEAACAlZSsPJtRz/cDAAAAAGgmBLAW8/TTT1e1X3311dhiiy2W2b9Pnz4xatSoehgZAAAAAAAAAADQ2FiCEAAAAAAAAAAAoIYEsBZTWVm5UpvqVwAAAKw+axDW5wbNz3vvvRdXXnll9OvXL3r27Bm5ubnRunXr2GCDDeLYY4+NoUOHrtT1/vGPf0T//v2rrpXsk8fJcQAAAAAaD0sQAgAAAMAq6tu3b7z55ptLHC8pKYmvvvoq3QYPHhxHH3103H333ZGTk7PUa1VUVMSJJ54Y99xzzyLHx48fn27PPvtsHH/88XHnnXdGZqbvVwIAAAA0NJ/QAAAAQFOXkVH/GzQzEyZMSPc9evSIM888M5566qkYPnx4vP322/H73/8+1lxzzfT8Aw88EAMGDFjmtS666KKq8NXWW28djz76aHqtZJ88TgwaNCguvvjiOn9dAAAAACyfClgAAAAAsIo22mijuPbaa+OnP/1pZGVlLXJuhx12iKOOOip23nnn+PLLL9Mg1cknn5xWzVpccv7GG29M29tuu2288cYbkZeXlz7ebrvt4ic/+Unstttu6XKHv/vd7+K4446L9dZbr55eJQAAAADVUQELAAAAmrqkIFW9VsBq6BcM9e/555+Pww47bInw1QKdOnWKm266qepxUiGrOrfcckuUlZWl7dtuu60qfLVAq1at0uOJpN/NN99ci68CAAAAgJoQwAIAAACAerDHHntUtb/55pslzldWVsZf//rXqopaSeWs6iTHN9xww7Sd9E+eBwAAAEDDEcACAAAAgHpQXFxc1a6uUtbIkSNjwoQJaTtZZnBZFpwfP358jBo1qtbHCgAAAMCKE8ACAACA5rEGYT1vwOKGDBlS1d54442XOP/ZZ59VtZMKWMuy8PnPP/+81sYIAAAAwMrLrsFzAAAAAICVUFFREddff33V48MOO2yJPuPGjatq9+zZc5nX69WrV1V77NixKzWWhe9TnYkTJ1a1y8vL062+JfdM/swWtKGhmZM0NuYkjZF5SWNjTtIYrQ7zsrGOCxo7ASwAAABo6jIy5m31eT9gETfffHMMHz48bR988MGxzTbbLNFn9uzZVe3WrVsv83r5+flV7Tlz5qzUWBYOby3P1KlTIzc3N+pb8guJmTNnVj3OzFTIn4ZlTtLYmJM0RuYljY05SWO0OszL5OdAYOU1vv+bAQAAAKCJLT3461//Om136dIlbr/99mr7zZ07t6qdk5OzzGsuHIoqKiqqtbECAAAAsPJUwAIAAACAOvLpp59G//79o6ysLFq2bBlPPvlkGsKqTnJ+gZKSkmVet7i4uKqdl5e3UmNa3pKFyRKE22+/fdru2LFjdO7cORpyyYtOnTpFVlZWvY8BFmZO0tiYkzRG5iWNjTlJY7Q6zMuFf94EVpwAFgAAADR5yZKA9bksoCUIITFy5Mjo169fTJ8+Pf1Q/bHHHou+ffsutX+bNm1WeFnBgoKCFV6ucHE9e/Zc4b7JuBvqFwILluJoyDHAwsxJGhtzksbIvKSxMSdpjBr7vGyMY4LVgSUIAQAAAKCWTZgwIfbee+90n5GREffee28ceOCBKxyMGjdu3ApXserVq1ctjBgAAACAmlIBCwAAAJq6jIx5W33eD5qxKVOmxD777BMjRoxIH992221x9NFHL/d5m2yySVX7iy++WGbfhc9vvPHGqzReAAAAAFaNClgAAAAAUEtmzpwZ++67b3z22Wfp4+uvvz5OPfXUFXru2muvHT169EjbQ4YMWWbfN954I92vueaasdZaa63yuAEAAACoOQEsAAAAAKgFhYWF8eMf/zg++OCD9PFFF10UF1xwwQo/P1mqcMEyhUmFq3feeafafsnxBRWwkv7J8wAAAABoOAJYAAAA0FyWIKzPDZqZkpKS6N+/fwwbNix9fOaZZ8bVV1+90tc566yzIisrK22ffvrpUVRUtMj55HFyPJGdnZ32BwAAAKBhZTfw/QEAAABgtXfEEUfEiy++mLb33HPPGDhwYHzyySdL7Z+TkxMbbLDBEseTY+edd166dOF7770XO++8c1pFa911141vvvkmbrjhhvjwww/Tvkm/9ddfvw5fFQAAAAArQgALAAAAmrykIlV9VqVSAYvm5+mnn65qv/rqq7HFFlsss3+fPn1i1KhR1Z675pprYvLkyXHvvfemYavDDz98iT5JwKsmFbYAAAAAqH2WIAQAAACARiQzMzPuueeeeOGFF+LAAw+MHj16pBWzkn3y+O9//3sMGjQo7QcAAABAw1MBCwAAAABWUWVlZa1fc7/99ks3AAAAABo3ASwAAABo4jIyMtKtPu8HAAAAANBcqFMOAAAAAAAAAABQQypgAQAAQFOXVKSqz6pUKmABAAAAAM2IClgAAAAAAAAAAAA1JIAFAAAAAAAAAABQQ5YgBAAAgGbBsoAAAAAAAHVBBSwAAAAAAAAAAIAaUgELAAAAmryMiIz6rICl2hYAAAAA0HyogAUAAAAAAAAAAFBDAlgAAAAAAAAAAAA1ZAlCAAAAaOoy6nkJwnpd7hAAAAAAoGGpgAUAAAAAAAAAAFBDKmABAABAk5dUpKrPqlQqYAEAAAAAzYcKWAAAAAAAAAAAADWkAhYAAAA0dRkZ87b6vB8AAAAAQDOhAhYAAAAAAAAAAEANCWABAAAAAAAAAADUkCUIAQAAoKlLVgSsz1UBrUAIAAAAADQjKmABAAAAAAAAAADUkApYAAAA0OQpgQUAAAAAUFdUwAIAAAAAAAAAAKghASwAAAAAAAAAAIAasgQhAAAANHUZGfO2+rwfAAAAAEAzoQIWAAAAAAAAAABADamABQAAAE2dClgAAAAAAHVGBSwAAAAAAAAAAIAaEsACAAAAAAAAAACoIUsQAgAAQJOXLAlYn8sCWoIQAAAAAGg+BLCgmcn6wd4NPQSaIvOKOrDGOQ09ApqiNRp6AAArIGv8+IgNNm3oYQAAAAAAsIIsQQgAAADNogBWRj1udf+SJk+eHM8//3xceuml8aMf/Sg6deoUGRkZ6TZgwIA6ueejjz4a/fr1i27dukXLli2jT58+ceSRR8bbb79dJ/cDAAAAAFYPKmABAAAAq52uXbvW272KiorikEMOib///e+LHB8zZkw8/PDDaTArCYJddtll9TYmAAAAAKDxUAELAAAAWK317t07rUxVV4477riq8NUee+wRzz77bAwfPjzuueeeWHfddaOioiIuv/zyuOuuu+psDAAAAABA46UCFgAAADR1C5YGrM/71bGk4tR2222Xbkk1rFGjRsXaa69d6/d59dVX47HHHkvbBxxwQDzzzDORlZWVPk7u/ZOf/CS22WabtBrWBRdcEIceemi0b9++1scBAAAAADReKmABAAAAq50rrrgi9t9//zpfivDGG29M99nZ2fHnP/+5Kny1QKdOneKGG25I2zNmzIhBgwbV6XgAAAAAgMZHAAsAAACavIwG2FZ/s2fPjldeeSVt77333tGzZ89q+x188MHRtm3btJ1UyAIAAAAAmhcBLAAAAIBqvPvuu1FSUpK2d9ttt6X2y8nJiR122KHqOaWlpfU2RgAAAACg4QlgAQAAAFTjs88+q2pvtNFGy+y74HxZWVl89dVXdT42AAAAAKDxyG7oAQAAAAB1a+K3kyMyMur3fgvaEycut//SlvZraOPGjVvhMfbq1auqPXbs2Nhkk03qdGwAAAAAQOMhgAUAAABN3PZ992y4e2+//XL7VFZWRmM0e/bsqnbr1q2X2Tc/P7+qPWfOnDodFwAAAADQuFiCEAAAAKAac+fOrWrn5OQss29ubm5Vu6ioqE7HBQAAAAA0LipgAQAAQBPUrVu3dCm8hpQsP9i5c+fIzl49P35o2bJlVbukpGSZfYuLi6vaeXl5dTouAAAAAKBxWT0/AQUAAACWKQk99ezZs0HH0ND3X1Vt2rRZ4WUFCwoKVni5QgAAAACgabEEIQAAAMByAmTjxo1bZt+Fq4316tWrTscFAAAAADQuAlgAAAAA1dhkk02q2l988cUy+y44n1QeW3/99et8bAAAAABA4yGABQAAAFCN7bbbLnJyctL2kCFDltqvpKQk3nnnnarntGjRot7GCAAAAAA0PAEsAAAAgGq0adMm9tprr7T98ssvL3UZwqeffjpmzZqVtvv371+vYwQAAAAAGp4AFgAAANAsDR48ODIyMtLt8ssvr7bPr371q3RfVlYWp556apSXly9yfsqUKXHBBRek7Xbt2sXxxx9fDyMHAAAAABqT7IYeAAAAAMDKGjp0aHz99deLBKEWSI4n4aqFDRgwoEb32XPPPePwww+Pxx57LJ577rnYZ5994qyzzooePXrExx9/HNdcc02MGTMm7XvDDTdE+/bta/yaAAAAAIDVkwAWAAAAsNoZNGhQ3H///dWeGzZsWLrVRgArce+996ZLDP7973+P1157Ld0WlpmZGZdcckmceOKJNb4HAAAAALD6sgQhAAAAwDLk5eXFCy+8EA8//HBaAatLly6Rk5MTvXr1ip///OdpNa6lLWEIAAAAADR9KmABAAAAq51kicHFlxlcWUlVrJWpjJWErZINAAAAAGBhKmABAAAAAAAAAADUkAAWAAAAAAAAAABADQlgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA0JYAEAAAAAAAAAANSQABYAAAAAAAAAAEANCWABAAAAAAAAAADUkAAWAAAAAAAAAABADQlgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA0JYAEAAAAAAAAAANSQABYAAAAAAAAAAEANCWABAAAAAAAAAADUkAAWAAAAAAAAAABADQlgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA0JYAEAAAAAAAAAANSQABYAAAAAAAAAAEANCWABAAAAAAAAAADUkAAWAAAAAAAAAABADQlgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA0JYAEAAAAAAAAAANSQABYAAAAAAAAAAEANCWABAAAAAAAAAADUkAAWAAAAAAAAAABADQlgAQAAAAAAAAAA1JAAFgAAAAAAAAAAQA0JYFVj8uTJ8fzzz8ell14aP/rRj6JTp06RkZGRbgMGDGjo4QEAAAAAAAAAAI1EdkMPoDHq2rVrQw8BAAAAAAAAAABYDaiAtRy9e/eOfv36NfQwVmsPPfp4nHT6WbHtLrtHbvsukZHfLgY/+PBKX6eioiJuu/3O2Hy7nSKvY7fo3GfdOOKYgTFi5KilPudfL70Su+27X7Tp2jPadusVe/xo/3jltSGr+IpoDMwr6oJ5RV0wr6gr5hZ1wbwCAAAAAICVJ4BVjWTpwb/97W8xadKkGD16dNx5550NPaTV2sVXXh133Ts4Ro8dG9271by6WPKLoDN+dUFUVlbGGaecFD/ce694+rm/xXZ994ivvv6m2l8e/fCgn8bnX3wZA448Io75xeHx6WdfxD4HHBRPPfPXVXxVNDTzirpgXlEXzCvqirlFXTCvAAAAAABg5WVUJp+Is0yjRo2KtddeO20fc8wxMXjw4Dq937hx46JXr15pe+yXn0bPNdeM1dnLr74e66+3TvTp3Tuuv/HmuPCyK+K+O/4UA476xQpf47Uhb8Se+/0k+u6yU7z0t2cjJycnPf6Pf70U+x18aPTba8/413NPV/WfPn1GrLPZlpGdnR0fvvVG1Z/huPHjY+ud+qbtEZ98FG3atKn110v9MK+oC+YVdcG8oq6YW9QF86pxSF57rw02Tdtjx46Nnj17NvSQgGZmkc+mGuh9qLy8PL777ru03blz58jKyqr3McDCzEkaG3OSxsi8pLExJ2mMVod52Rh+JoTVkQpY1Lm999w9/QXOqrj7vgfS/VWXXFT1C5zEj/bdJ3bvu0u8+MqrMWbs2KrjTz7zbMyYMTNOP/nERQJsSfu0k06IKVOmxjPPPV91/OQzzk6XV0l+ybS4BeduuOmWVXoN1C7zirpgXlEXzCvqirlFXTCvAAAAAABg5QlgsVp4/c2hkZ+fHzvvuMMS5/bda690P+TNYd/3f2Nouk++Xb9E/73n9x/6ff+bb7g2Nt5ow7j06mvj3fc/qDr+zHN/izvvuS/23K1vnHf2GbX8qmho5hV1wbyiLphX1BVzi7pgXgEAAAAA0NwIYNHoFRQUxMRJk2LtPn2qLcGYLJGS+Oqbb6qOLWivv+66S/aff2zh/nl5efHofYMiMzMzjhgwMObMmZMu+3H8qWdEx44d4sF77kzP0XSYV9QF84q6YF5RV8wt6oJ5BQAAAABAc5Td0ANojpI1U5dl4sSJ9TaW1cHMWbPS/RprtK32fNs2847PnDlrhZ7Ttm2bJfonttxi87jhqsvjrPMvjFPOPCfGTZgQ06ZNj78+8Uj06N69Fl8RjYF5RV0wr6gL5hV1xdyiLphXAAAAAAA0RwJYDaBXr14NPQSW4oxfnhz/evnVeOixJ9LHp5wwMH7y4/0aelis5swr6oJ5RV0wr6gr5hZ1wbwCAAAAAKCxsC4Djd4abZf8lvzCZs1e8hvzy3rOrFmzl+i/QEZGRhx0wI+rHp9+8omrPH4aJ/OKumBeURfMK+qKuUVdMK8AAAAAAGiOBLAawNixY5e5DR8+vKGH2Kjk5+dH927dYuTo0VFeXr7E+a++HpHu11933apjC9pfffPNkv3nH1u4/wIjR42K8y66NDp0aJ/+Quf4U8+o9p6s/swr6oJ5RV0wr6gr5hZ1wbwCAAAAAKA5EsBqAD179lzm1r1794YeYqOz2y47R0FBQQx7+50lzv3rlVfSfd9ddvq+/647p/sXX3l1yf4vv1J1zYWVlZXFL447MWbPnh2P339fnHP6qfHWO/+OK669vtZfD42DeUVdMK+oC+YVdcXcoi6YVwAAAAAANDcCWDQqU6ZMjS/+92W6X9iJxx2T7i+56pooKSmpOv6Pf70Ur78xNPrttWf06d276vhhB/dPlym57Y67Ytz48VXHk/Yf77w7OnXqGP1/sv8i90h+WfP2v4fHuWecFnvvuXtce8Wl8YOttoxrf/f7eHPYW3X4qqlr5hV1wbyiLphX1BVzi7pgXgEAAAAAwDwZlZWVlfPbLMWoUaNi7bXXTtvHHHNMDB48uE7vN27cuOjVq1faHvvlp9FzzTVjdTZo8AMx9K230/bHn34WH3z0n9h5xx1ivXXm/ZnustOOcfyAo9P25ddcF1dce0Nc9psL4vKLLlzkOiecekZ6rU033jh+/MN+MXHSpHj8L89E69b58farL8UG66+3SP+HHn08jjr+pOjcqVP87JD+6bHHn3ompkydGo8/cF8cevBBVX3fGDos9vjRAbHVFpvH26+9FDk5Oenx/335VWyzy+7RsUP7+M87Q6Ndu3Z1/KfFijKvqAvmFXXBvKKumFvUBfOqcUjCZ7022DRtJ8vUJ5WSAerTIp9NNdD7ULKs7HfffZe2O3fuHFlZWfU+BliYOUljY07SGJmXNDbmJI3R6jAvG8PPhLA6ym7oAdD0Jb/Auf/hRxc5lixHsvCSJAt+ibMsd952S2y+6SZx1733xx/+fEf6y5vkm/DXXHZJrDv/F0ILO/KIn0Wnjh3j2htvivsefCQyMjJim623jIvPPy/9lvwC06fPiCMHnhR5eXnx6OB7qn6Bk9hwg/Xjlt9el/4C6YTTzownH7p/Ff4kqE3mFXXBvKIumFfUFXOLumBeAQAAAADAylMBawWogAUAAEB9UQELaGiN4dvOq8O3wmlezEkaG3OSxsi8pLExJ2mMVod52Rh+JoTVUWZDDwAAAAAAAAAAAGB1ZQnCagwdOjS+/vrrqsdTpkypaifHF6+ANWDAgHodHwAAAAAAAAAA0DgIYFVj0KBBcf/991d7btiwYem2MAEsAAAAAAAAAABonixBCAAAAAAAAAAAUEMCWNVIlhisrKxc4Q0AAAAAAAAAAGieBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAAAAAAoIYEsAAAAAAAAAAAAGpIAAsAAAAAAAAAAKCGBLAAAAAAAAAAAABqSAALAAAAAAAAAACghgSwAAAAAAAAAAAAakgACwAAAAAaqdGjR8e5554bG220UeTn50eHDh1iu+22i9/97ndRWFjY0MMDAAAAICKyG3oAAAAAAMCS/va3v8WRRx4Zs2bNqjqWhK7ee++9dBs0aFC88MILsd566zXoOAEAAACaOxWwAAAAAKCR+fDDD+NnP/tZGr5q3bp1XHPNNfHWW2/FK6+8EieccELa58svv4wf//jHMXv27IYeLgAAAECzpgIWAAAAADQyZ555ZhQVFUV2dna8+OKLseOOO1ad23PPPWP99deP888/Pw1h3XTTTXH55Zc36HgBAAAAmjMVsAAAAACgERk+fHi8+eabaXvgwIGLhK8WOPfcc2PjjTdO23/4wx+itLS03scJAAAAwDwCWAAAAADQiDz77LNV7WOPPbbaPpmZmXH00Uen7RkzZsRrr71Wb+MDAAAAYFECWAAAAADQiAwdOjTd5+fnxzbbbLPUfrvttltVe9iwYfUyNgAAAACWJIAFAAAAAI3I559/nu7XW2+9yM7OXmq/jTbaaInnAAAAAFD/lv4JDg2mrKysqj1x0qQGHQsAAAD1a+GfAxf++RBoHubOnRtTpkxJ2z179lxm3/bt26dVsgoKCmLs2LErfI9x48Yt8/zC10r6lpeXR31L7jlt2rS0XVhYGFlZWfU+BliYOUljY07SGJmXNDbmJI3R6jAvJ06cWNX22RSsOAGsRui7776ram/fd68GHQsAAAANJ/n5cK211mroYQD1aPbs2VXt1q1bL7f/ggDWnDlzVvgevXr1WuG+O+644wr3BQAAoGnx2RSsOEsQAgAAAEAjqoC1QE5OznL75+bmpvuioqI6HRcAAAAAS6cCViO0+eabx/Dhw9N2586dIzvbf6ZllT/cfvvt03byZ9a9e/eGHhJNgHlFXTG3qAvmFXXBvKIumFcrLintvqAycvLzIdC8tGzZsqpdUlKy3P7FxcXpPi8vb4XvsbzlCpMQ2BdffBFdu3ZtsM+m/L1BY2NO0tiYkzRG5iWNjTlJY7Q6zEufTUHNSPY00g/atttuu4Yexmon+cupZ8+eDT0MmhjzirpiblEXzCvqgnlFXTCvlk9pd2i+2rRpU9VekWUFk+UHV3S5wgVW5D14vfXWi8bC3xs0NuYkjY05SWNkXtLYmJM0Ro15XvpsClaeJQgBAAAAoBF9Ma9jx45pe9y4ccvsO3369KoAVq9eveplfAAAAAAsSQALAAAAABqRTTbZJN1//fXX6dIPS5MsE7jAxhtvXC9jAwAAAGBJAlgAAAAA0Ijssssu6T6pbvX+++8vtd+QIUOq2jvvvHO9jA0AAACAJQlgAQAAAEAjctBBB1W177vvvmr7VFRUxAMPPJC227VrF3vssUe9jQ8AAACARQlgAQAAAEAjsv3228euu+6atu+55554++23l+hz0003xeeff562zzzzzGjRokW9jxMAAACAebLn7wEAAACARuIPf/hDuqxgUVFR9OvXL37zm9+kVa6Sx4899ljcddddab8NNtggzj333IYeLgAAAECzJoAFAAAAAI3M1ltvHY8//ngceeSRMWvWrDSAtbgkfPXCCy9EmzZtGmSMAAAAAMyTUVlZWTm/DQAAAAA0IqNHj06rYSVBq3HjxkVOTk6st956ceihh8Zpp50WrVq1aughAgAAADR7AlgAAAAAAAAAAAA1lFnTJwIAAAAAAAAAADR3AlgAAAAAAAAAAAA1JIAFAAAAAAAAAABQQwJYAAAAAAAAAAAANSSABQAAAAAAAAAAUEMCWAAAAAAAAAAAADUkgAUAAAAAAAAAAFBDAlgAAAAAAAAAAAA1JIAFAAAAAAAAAABQQwJYrHbee++9uPLKK6Nfv37Rs2fPyM3NjdatW8cGG2wQxx57bAwdOrShh0gTcsEFF0RGRkbV9vrrrzf0kFgNlZSUxKBBg2LfffeN7t27V71vbbjhhun71ltvvdXQQ6SRmDx5cjz//PNx6aWXxo9+9KPo1KlT1fvPgAEDanTNl19+OX3ueuutF/n5+bHGGmukf2cecsghcfvtt8ecOXNq/XXQeMyaNSsee+yxOPfcc2O33XZL50EyB3JycqJLly6x++67x29/+9uYOnXqUq9RWloa//znP+Pss8+OnXbaKZ2XLVq0iHbt2sUPfvCDOO+882LEiBH1+rpofMaMGROXXXZZbLvtttG5c+do2bJl9OrVK3bdddf0Pe2TTz5Z4WsVFhbGOuusU/X+t9Zaa9Xp2AFofEaPHp3++2WjjTZK/w3boUOH2G677eJ3v/td+vcENLbPF//xj39E//79q66V7JPHyXFoiM8nzUka48995iWN7fN2c5L6/ry+NuZcWVlZ3HHHHel7b/JenJeXF+uuu26cdNJJ8emnn670mIBaVgmrkV133bUymbbL244++ujK4uLihh4uq7kPP/ywMjs7e5G59dprrzX0sFjNjBo1qnLTTTdd7vvW6aefXllRUdHQw6WBLWuOHHPMMSt1rWnTplUeeOCBy517yXsdTddLL720Qv926tSpU+U///nPJZ4/efLkyo4dOy73+Tk5OZW33HJLg7xGGt6tt95amZ+fv8w5cuaZZ67w9c4999xFntunT586HT8Ajctzzz1X2bZt26X+nbLBBhtUfvXVVw09TFZjtfn5Ynl5eeXAgQOXeZ3jjz8+7Qf18fmkOUlj/LnPvKSxfd5uTlLfn9fX1pz77rvvKrfbbrulXiM3N7fy7rvvroVXDtRUdm0HuqAuTZgwId336NEjDj300DTd27t3uSwEgQAAJ0dJREFU7ygvL4+33347brrpphg/fnw88MADabWGRx55pKGHzGqqoqIiTjzxxDRJnlQISVLusLKS96Ef//jHVd862GKLLeKcc85Jv4kze/bs9Bu1yftWQUFB3Hbbbel7269//euGHjaNRPL3W/KN/xdffHGlnztz5szYZ5994v33308fJ9+iSSpeJd+EycrKirFjx8aQIUPiL3/5Sx2MnMYm+TbqHnvsEdtss03aTr4ZmPw9N27cuHjqqafi6aefjilTpsRPfvKTGD58eGy55ZZVzy0uLq6qjrXVVlvFgQceGP/3f/8XXbt2TedZ8u2s5P1r7ty5cdZZZ6XfuEr+/qT5uPrqq+OSSy5J20nFiBNOOCGtUJJUWkvmzocffhjPPPNMZGauWPHlpP8tt9ySfpM6qbSW/H0JQPOR/D3ws5/9LIqKitIqBhdeeGH675jkcVLV8+67744vv/wy/TkrqWDUpk2bhh4yzfzzxYsuuijuueeetL311lvH+eefn/7c9c0336SVZpM5nVToSKoTXHvttfX2Gmm+n0+akzTGn/vMSxrb5+3mJPX9eX1tzLnk36rJ5/zvvvtu+vjggw9O34+TasH//ve/0/fq5N8KSSWsNddcM63YBTSAGke3oAH8+Mc/rnz88ccry8rKlpr8Tb4JuSDpO2TIkHofI03DzTffnM6hjTbaqPLCCy9coW+YweKefPLJqrmz4/+3dydwNtb9/8e/9qUwsib7npJdpCJbhDtLG2WLlPATikiG3CUpVELJrVCJslOhkKyRspUoJhJJZMmWe/6P9/d+XOd/ZuacMzNnzjZnXs/H4zzmOnOu68z36Ns51/U5n8/nW7++x/eurVu3xmfLls3uExMTE3/58uWwjBWRYcSIEfFLliyJP3r0qL1/4MABvypqOnfu7Kp4WbRokdf9VAXGnItu3s6Z3C1YsMA1z9q1a5fgscOHD8c3a9YsfuPGjV6P37RpU3yuXLns8fny5Ys/ffp0QMaOyLdq1aoEHSIuXbrkdd+UdKfVfK1Vq5Z9vueee852vqIDFgBkzM5E6vayYcOGJI+/9NJLrs+e2NjYsIwR6V+g4ot79+51dSaqXbt2/N9//53g8XPnztnfO3Oazm0IdnySOYlIvO5jXiLS4u3MSYQ6Xh+oOTd9+nTX33788ceTPK7jnE7C5cuXJ+4PhEnKypCBCKF1du+77z7bvcMTrb2r7HaHujoA/qxl71T0aB3l7Nmzh3tISKfc15pX5ban9y51pGndurXdPnXqlPn+++9DOkZEllGjRtn5oO5C/lKl16xZs+y2ql7U1cgbrVWfNSsNUaOZt3Mmd23btrWVgrJu3boEj6laSlVd9erV83q8OmI9/vjjdltdsVauXJnmcSN9VOP37t3bbqtrmqr41LHKm5ScT7366qu2c5/m45AhQwI6XgBA5FMnTudcpEePHqZ+/fpJ9hk0aJC5/vrrXZ8b6oIAhCu+qK6d6kwk6rKhbrDucufObX8v2m/ChAkBfBWIdv7EJ5mTiMTrPuYlIi3ezpxEqOP1gZpzL7/8sv2pjlfjxo1L8nj58uXt/xeyf/9+25kQQOiRgIWoo9b0DrVuBFKrT58+5uzZs6Zr166mYcOG4R4O0rFLly65tsuWLet1P7Wa9XQM4I9JkybZn2oD37dv33APB+mEs3yPlhL0B+dfGY8S8/bt22e3lSyV1mTOuLg4M2LECLtNAjwAZEwLFy50bXfv3t3jPlraqEuXLq4v1FavXh2y8SFjSe78Nj4+3ixatMhuaykabwUL+r1T7KD9dRwQjPgkcxKReN3HvESkxduZkwi1QM05LcPuJBOqkEBJW55069bNtU0CFhAeJGAh6ly8eDFVXR8Ad3PnzrWVkMogd7LJAX85J8zy888/e93PCeaqG1GFChVCMjZEJwUUnAu6Zs2amZw5c7rWhz906JA5ePCg3wk2iF579+413377rSsQ4A/OvzKeefPmuT67nMpS+fPPP22AXj9TQ13Uzp07Zzp37mwaNWoU8PECACKfOrnKVVddZTsXeOOeiLB+/fqQjA0ZT3LntwcOHDBHjhyx28klxziP//rrr/aaDAhGfJI5iUi87mNeItLi7cxJhFqg5pxzrZTc8xQtWtRUrFjRbnOtBIQHCViIOmvXrnVtO23pgZRQ9Wz//v3t9tixY23LeSAtOnbsaPLmzeuaU0qCSWz79u1m2bJldrtTp06u/QF/fPfdd64Eq6pVq5rTp0+bJ554wr6flSxZ0pQpU8Z2xlJy1po1a8I9XITR33//bYOl48ePtxftThtszRd/cP6V8WzatMn+LF26tO2g9v7779v3nQIFCthAj34qMKovjNy/wPRkzpw5Zvny5SZ//vwJlvsBAGQsTkW3ls7w1WHDPWGcJdwRLMmd3+7Zs8e1nVwRA3MWoYhPMicRidd9zEtEWrydOYlQC9Sc8+d5VJCtYkcAoUUCFqJuTfIXX3zRdV9tGIGUGjx4sDl69Khp0KCB6dGjR7iHgyigINmsWbNsO1hVG9SpU8fMnDnTBi9WrVpl1w9X4oO6FtWsWZMvnZFm7hdi+kysXbu2efXVV20A16H5pvnXuHFjG6hAxvHOO+/Yyj/d1FlCwdJBgwaZY8eO2ceffvppG5hKrd9++83MmDHDbhcqVCjBci2ITnp/+eGHH1yfdfqC6MEHHzS7du1K0h79qaeesu837u9D7k6ePOlK/NN5vOYQACDjURHBH3/8YbeLFy/uc18l7OpcxvlSAQhHfPHw4cOu7eTmbIkSJVzbzFkEKz7JnEQkXvcxLxFp8XbmJEItUHPOn+fRMobuxwEIDRKwEFUmTJhgtmzZYrfbt2/vs2U94G7dunXm7bfftlW2U6dOtV9OA4Hwr3/9y2zbts307NnTLvHVtWtXU79+fduBaOTIkfZiceLEiXYOFilSJNzDRTrn3vpdyVXqcNSiRQv72agvtX7//XczZcoU2wVLF2BKuHGWLETGVb16dTtHxowZk+rPP82jRx991Jw5c8bef/bZZ11LXyJ6/fXXXzYYLzt37jSvvfaaufbaa83s2bPt+5A6rKlrRL169ew+GzZsMA8//LDH51KgXkmA+mx85JFHQvo6AACRwzmXkKuvvjrZ/Z0ErLNnzwZ1XMiYUhJfTM2cdearMGcRrPgkcxKReN3HvESkxduZkwi1QM055i6QfpCAhaihk319kSyFCxe2XzADKaFqiF69etkvkQcMGGBuvPHGcA8JUTa/VIWjJBfNscT0pbMCF6rQAdLKvaWwEq4UeFi6dKmtBsuRI4ftLPPYY4/Z32XO/L/TwKFDh3qcm4g+bdu2tUFT3fSF0gcffGDatWtng1Vq4a55kVovvPCCWbJkid1W56s+ffoEYeSI9PcaBTdXr15tq6HVlSRXrlzm9ttvN1988YWpVq2a3W/BggVm8+bNCZ7nyy+/NP/5z39IgAcAuJbRluzZsye7v85t5fz580EdFzKelMYXUzNnnfkqzFkEKz7JnEQkXvcxLxFp8XbmJEItUHOOuQukHyRgISrs3r3bfoH4zz//2K4L8+bNs0ESIKVfHqudcsmSJU1sbGy4h4MoC1Q0bdrUdpVRZZjayGvt7osXL9oqshUrVphbb73VbN261SZGjB8/PtxDRjqXuPOQumBlyZIlyX6ad6rkFs1JJeQg+sXExNggvm5KynvggQfM/PnzbdDq559/NnfffbddpjCl3nvvPdvxSsqUKWPef/99V2IfMtZ7japOK1WqlGQ/BeSff/551/0PP/zQta3PQucLJi1lcdNNNwV51ACA9PLZoi/VkqPPEeezBghHfDE1c9aZr8KcRbDik8xJROJ1H/MSkRZvZ04i1AI155i7QPrBNyRI9w4cOGCaN29uTp48ab9knjNnjq28AFJCgQ2drMvrr7+eoDUnkFZqeaxWxzJ9+nSbDFO5cmVboZA3b17bnUiVY+oaoy+gtQzTd999F+5hIx3LkyePa1vdrmrUqOF13zvvvNO1/fXXXwd9bIhcnTt3Nvfee69dWqBv374JlrL0ZtmyZaZ79+72vato0aJm5cqV9icy3nuN6FzcmyZNmtgOV4nfaxSg37t3rylRooQZNWpUEEcLAEgP3D9bUrJMhtOVIyXLFQLBiC+mZs66d5FhziJY8UnmJCLxuo95iUiLtzMnEWqBmnPMXSD9+N8ZEZBOHTlyxGa766eWLNESJureAKTUhAkTbLZ42bJl7br1CrAltmvXLte2WiofPXrUbrdp04aELXilCzy9J0nFihXtWvSeKDgxevRoW5mj5Ad1n9G8BPyhRAZH8eLFU7zv8ePHgzouRD6dP82dO9deoH/66aemU6dOXvdds2aNueeee8zly5ftsgOfffaZKVeuXEjHi/ByljR13jvc308SU4VewYIF7fmT+3uNgqSic3lnGUtvASP9dM7R1IWicePGAX09AIDw0+dFgQIFzIkTJ8zhw4d97qsEGeczwtdnEBDM+KL79VZyc/bQoUOubeYsghWfZE4iEq/7mJeItHg7cxKhFqg5l/h59J6b3PPovDa57wgABB4JWEi3/vjjD5vNriVznOqgLl26hHtYSGecVpyaRx07dkx2f524u1dHkoAFb7TWvNNFxlcXIqlVq1aCqkfAXzfccINr+8qVKz73dX/cqVJExqWgqiMuLs7rflu2bLEB/gsXLtgKqk8++YSl4zLw+42S8VLzfuP+XuO0S58xY4a9JXfe75ynNWzYkAQsAIhSVapUsR0N9u/fb5eA83aO6n7NdP3114dwhIhG/sYXNV9Teh3PnEUo4pPMSUTidR/zEpEWb2dOItQCNecSP0/16tWTfR4lcfEdJhB6LEGIdElrOWvppD179tj7L774ounTp0+4hwUALu7BBn154Iu6yHg6DkitUqVKmZIlS9rtgwcP2sowb3766SfX9nXXXReS8SFy/frrr8m2pt6xY4dp0aKFbXOt6lZ1Lbr55ptDOEpEEvcleZwvLD05ffq0/WJTeK8BAPiiLgWi7lbbtm3zut/atWtd2w0aNAjJ2BCd0hJfLFOmjClWrFiSOenJl19+6ToXKl26dJrHDXjCnEQkXvcxLxFp8XbmJEItUHPOuVZK7nnUifDHH3+021wrAeFBAhbSHbVhbtWqlfnmm2/s/WeeecYMGTIk3MNCOqX2s0pQ8HWLjY117a/1w53fc9INX6655hq77rxs3LjR50Wh+wmzTsiBtOjQoYMr+PX555973W/+/PkeL+CQMc2bN8+1XbVq1SSP68K9efPmdsmfbNmymY8//tg0atQoxKNEJL7XyIIFC7zup8ecZNDbbrvN9fvkzr90U1Kp6KfzO6f6GgAQfdq2beva9tYdUcvIzJw5027HxMSYO+64I2TjQ3RJa3xRS7o4yxSqy8CmTZs87qffO10ItL+OA4IRn2ROIhKv+5iXiLR4O3MSoRaoOadlN52uWHPnzrXnst7OKRzt2rUL2OsAkHIkYCFd0VIl+sBYv369vd+/f3/z73//O9zDAoAkMmfObIO5cuTIEfP888973E/JDO5B3tatW4dsjIhOTzzxhO1OJAMHDrSJWInNnj3blcSgeZp4TXlED110a7lAXyZMmGCWL1/uCkq5B0vll19+MU2bNrWt3rNkyWLef/99c9dddwV13Ih8WnqyZcuWdvuDDz7wmPCpqrvhw4fb7ezZs5vu3buHfJwAgPSjbt26rvOQ6dOn2y/WEnvllVfM999/74oJKTEcCFd8UddeOj+Wfv36mfPnzyd4XPf1e6f7hvYHgok5iUi87mNeItLi7cxJhFqg5tyTTz5pf2opzsGDB3tc8WLMmDF2u3z58iRgAWGSKd7X2jRABFZcOB07GjdubCZOnOgz81wn/MoKBtJi5MiRZtSoUa4KMzp+IKVUsaD15p1qhDZt2piuXbuasmXL2oQIVTXofUzJDdKkSROzatWqMI8a4fTVV1+Z/fv3u+6rfftTTz3lahncs2fPBPt369bN4/OMGzfOdRFWqVIlG3RQ0EzJWPocnTJlirly5YqtGtu6daupUKFCUF8XwkfV0GfOnLHnUOp0Vq5cObvEoH63c+dO895777m+eNJ507Jly2yylePEiROmfv36Zt++ffa+5lXnzp19/s38+fOz1FwGoc5oWoby1KlTNvFTASIl5+XKlcts2bLFBn0OHz5s9x07dqzH4FBy8zcuLs52wNKyqgCA6Ld9+3Z73qsvIXTOMmzYMNvlSvfnzJlj3nrrLbufYj06j82TJ0+4h4wMHl8cOnSoXbpQatSoYa+9dM6tL8B0/qM57ez3wgsvBOX1IGNIaXySOYlIvO5jXiLS4u3MSYQ6Xh+IOad4fsOGDV2xXJ3TPvLIIzYWq/fj0aNHm99//90mKy5dutSVQAsgxJSABaQXmrKpuZUqVSrcQ0YUiI2Ndc2p1atXh3s4SGdWrlwZX7BgwWTfrxo3bhz/559/hnu4CLOuXbum6nPOl6effjo+U6ZMXo8tXLhw/IYNG0L22hAeOhdKyVwqXrx4/IoVK5Icr8+91J5/aR4j41i3bl18kSJFvM4HvQ8NHz48TfOXc3oAyFgWL14cnzdvXq+fLRUrVozft29fuIeJdCyQ8cUrV67EP/zwwz6P79Gjh90PCEV8kjmJSLzuY14i0uLtzEmEOl4fqDl3/Pjx+Dp16nh9jhw5csRPmzYtCP8SAFKKJQgBAAgidZJRZY6qGFSdWKhQIbtMhqrEtNTXfffdZxYuXGgrcVSpAASKKhBVDaNuReoikyNHDpMvXz5Tp04dWw2jCkZ1NkJ0++yzz+xSPe3bt7dd0IoUKWJbWatbhKqsVCk1Y8YMs3fvXtOsWbNwDxfpkDqr7d6928TGxppq1arZznqqitZnnJae2LZtm33PAQAgpdTJYMeOHWbAgAG261Du3LlNTEyMqV27tqs6XEtqAJFAHQa0ZKY6yd59992mWLFitmOWfuq+lvp+++237X5AKDAnEYnXfcxLRFq8nTmJUAvUnCtYsKDZsGGDmTx5sn1vLlCggH0/Vhc4dcPS+3HirlwAQoslCAEAAAAAAAAAAAAAAADAT6TuAgAAAAAAAAAAAAAAAICfSMACAAAAAAAAAAAAAAAAAD+RgAUAAAAAAAAAAAAAAAAAfiIBCwAAAAAAAAAAAAAAAAD8RAIWAAAAAAAAAAAAAAAAAPiJBCwAAAAAAAAAAAAAAAAA8BMJWAAAAAAAAAAAAAAAAADgJxKwAAAAAAAAAAAAAAAAAMBPJGABAAAAAAAAAAAAAAAAgJ9IwAIAAAAAAAAAAAAAAAAAP5GABQAAAAAAAAAAAAAAAAB+IgELAAAAAAAAAAAAAAAAAPxEAhYAAAAAAAAAAAAAAAAA+IkELAAAAAAAAAAAAAAAAADwEwlYAAAAAAAAAAAAAAAAAOAnErAAAAAAAAAAAAAAAAAAwE8kYAEAAAAAAAAAAABh0qhRI5MpUyb7EwAAAOkTCVgAAABBpgCabiNHjgz3UAAAAAAAAAAAAAAEGAlYAAAAAAAAAAAAAAAAAOAnErAAAAAAAAAAAAAAAAAAwE8kYAEAAAAAAAAAAAAAAACAn0jAAgAgjEaOHGkyZcpkb3LhwgUzbtw4U7NmTZMnTx57q1u3rpk0aZL5559/PD6Hc7yey5dGjRrZ/fQzsTVr1rieR9vx8fFm+vTp5tZbbzUFChQwefPmteOYNWtWguMuXbpkpk6daurVq2euueYaO94GDRqYuXPnmkBLPMb//ve/Ztq0aeaWW26xf/uqq64y1apVM2PGjLH/jr5s2rTJDB8+3P5bFC1a1GTPnt2+xipVqpjevXubPXv2+Dy+W7dudhylS5e293/77TczZMgQc8MNN9h/A2eMetz5byujRo1yvQbnpudyp7G/9tprdmyFChUy2bJls6+vUqVKpmXLlmb8+PHm4MGDafq3BAAAAAAAAAAAABA4WQP4XAAAIA2OHTtmWrRoYb799tsEv//666/tbcWKFWbhwoUmc+bg5k9fvnzZ3H333WbJkiVJxtGlSxezdetW8+qrr5qTJ0+atm3bmi+//DLBfhs2bLC3/fv3m2HDhgVljEr8atWqlfn0008T/H7Hjh32Nnv2bPP555/b5KrE3nnnHdO9e3ePr/v777+3NyV2KQnq8ccfT3YsSuZq06aN+eOPP9L4qv6XyNW0adMkCWD6t9btxx9/tK/5yJEj5uWXX07z3wMAAAAAAIgUq1evtnGbdevWmaNHj5qsWbOaUqVK2XjZgAEDTLFixZIco4JEFbyJCgpPnTplJkyYYD766CMTFxdni+5UsNerVy/TsWPHZMegojfFvRSH++WXX8yVK1fMddddZxo3bmz69u1rqlatmuxznDlzxrz11ltm2bJlNsbz559/mpw5c5py5crZYscHHnjAFjD68uuvv5pXXnnFLF682G7nzp3b1K5d2zzxxBO2QA8AAACRhwQsAAAiRPv27W1Q5v/+7/9sQo+6Hu3du9eMHj3aJgUpIUqJQY8++mhQx/Hss8+azZs3mwcffNB06tTJJjEp8UcBLY1HiUka3+uvv24TrdQxql27drZTlpLHdLwShEaMGGETudQVKtDUvUoJYc2bN7d/v0SJEubQoUNm8uTJZuXKlfbfUWNUclSWLFkSHKtOYvnz57dju/32202FChVs9yyN+ZtvvrGvT8lUCqpVrlzZBti8OXv2rOnQoYPtWvXMM8+YZs2a2YDYzp07zbXXXmuDdUoWc4JzGmvipC6NxdGvXz9X8tVDDz1k54SCi3oNSs5S8tuiRYsC/K8JAAAAAAAQPoqrqFhuzpw5SR7btWuXvU2ZMsV88MEHNt7jzYEDB2xs5qeffnL97ty5c7ZLuW4qbHzvvfdsYpcnM2fOtIlaFy9eTPB7FRnqpm7xitMNHTrU6xhWrVplE70SF+qp8E9xM93U6V7JYt6sX7/eFj26P4f+jRRn0k3d85988kmvxwMAACA8MsX7OssDAABB5V6lp6XmFERJvESgquS0NJ46ZN10003mu+++S/C4s8RdbGysz2UI9bxr1641DRs2tEEnd7p/xx13uO5PnDjR9O/fP8E+qjysWLGireLT0ngKAs2fP98GhNypA1WNGjXsEoFKJlPVYCAkHqMCYm+++WaS/Xr27GkDYvLGG28kSXhS1aCSnpQo5clff/1lE7P0OlSVqKrLxLRs4Lvvvmu3r776avPVV1/ZakpvUvLfSIE0LYOogNygQYN8drjSnFCCHgAAAAAAQHqmr6iUVKVuUaLt++67z5QtW9Z2gd+yZYvtBKVuVOpmpeQkdYLyFFurU6eO2bZtm40Z3XPPPSZfvnw2vjN27FhbXCjqIKUOWYnp7+tvazyK9Sg2oy7lStZSAeKYMWNcCVEqAFSRnacOXioWVPGfiuk6d+5sCwBLlixp4z4quvvkk09skaUK9jzF7RR7U9xHr33gwIE2NqXXrdjTc889Zzt8aUxK5ApG0SMAAAD8F9w1jAAAQIqp+1Hi5CtRoo2zZJ46KylBKJhuvvnmJMlXok5Y6nQlx48ft8GwxMlXoiQxBYfEU/JSIBQpUsRjsMxJHlOCmBMQS0xt470lX4mCcwpoiYJbJ06c8DmWwYMH+0y+SikF15R8JUoA84XkKwAAAAAAEA3efvttm/ykwkQlJ2nJPXUFv+WWW0y9evVscZ+TbKSkJSVQeaNu6bNnz7bdspo0aWITtR5++GHbUdyJ3ajzuTpquVM8RklbTvKV4llK7FJ8S2NQIpSeQ93ORd2nEne4UoKVxq3kK8Wd1AlrxowZNnZWs2ZN+3pUNPjxxx8n6NCVmBLF1KldXdqHDBlilypUYpmWYFTilor89De0xCEAAAAiCwlYAABECC35502tWrXsTwWC1E49mB544AGvj7knGqVkv59//tkEg5K/vCVRKVCmx2X37t22c5cvakV/8OBBu6/T1l5BP0fijmOp+e+WGlrCURWNMmvWLBtMAwAAAAAAiFaKc6k7lSjRqkWLFh73UydzLbsn6oC1b98+j/u1bt3aLv+XWJ48eVwJS+rYPnXq1ASPL1iwwBw5csRuDx8+3FSvXj3Jc5QqVco1hr///tsmVyVevtB5jhdeeMFjkaWjRIkSxpfXX3/dFhAmpoQwFU4Gs+gRAAAA/iMBCwCACFG5cuUUdTzSEoDBpFbn3sTExKRqv2CNVZV/vtStW9e1ra5hialKcdiwYaZSpUo2CFemTBlz4403mqpVq9pbq1atEuzrjZK91BI/EHLkyGHuv/9+u/3RRx+Z8uXL2+5ay5cvt+3lAQAAAAAAoomW5HO6QWnJQF/cu4Vv3LjR4z5OB3lvsSJnyT51p3Ln3Fd3KXXM8ubee++1ndM9PcfSpUvtT3WveuSRR4y/FFNzj0t5K9IMVtEjAAAA/EcCFgAAEcLXsniZM///j+wrV65ExDhSsp+qCoOhcOHCyS5R6L60n7tt27bZZLcxY8bYtu6qtvTl/PnzKUpIC4RJkyaZNm3a2O24uDhbWamgm7pjKelM94O9BCUAAAAAAEAoaFk/R/369W0ClLebiuAc3rqdp7RgT/EgLWfocJYkVIFeoUKFvB6vzuU1atRIcIxj+/btrgQpXzGz5FSoUCFB/M1bkWawCzQBAACQeiRgAQCAdEeBN38ouKblCU+cOGGXGRw4cKBZu3at+e2338yFCxdsMpZuTvWl+ErQypIliwmkvHnzmsWLF5vNmzebQYMG2aCd/oYS2RSUVEcsdR7zVukJAAAAAACQXvz+++9+HaclANNSsKdYz8mTJ5MU7yV3vBQtWjTBMYk7qF977bUmLZJL3gp20SMAAAD8lzUNxwIAgAhJRlLgKLnAy7lz50y0OHbsWIofd1++8YsvvnC1aJ88ebLp2bOnx+MTB9FCTRWZTlWmKhrXrFlj3nnnHTN//nwbnOzQoYNNEsuVK1dYxwkAAAAAAOAv9y7vS5YsMaVLl07Rcd4Spfwt2AvU8QAAAMjYSMACACCdy5Mnjzl9+nSCyr3ElKC1f/9+Ey2+/vpr07lzZ5+PO2688UbX9u7du13b999/f4pa4EfCf18tS6hb//79zWuvvWY7dn311VemWbNm4R4eAAAAAACAXwoUKODajomJSRDD8YcK8kqUKOHzcSfRKn/+/EmK95Ir+HNf/tC94E8KFixoDh8+bGM2AAAAyJhYghAAgHSuTJkyySYNffLJJ+bUqVMmWsybN8+cP3/ea6evuXPn2u0qVaokaP3+zz//JNjPE3USmzZtWkDHmzNnTvvz4sWLaXqeJk2aJGltDwAAAAAAkB7VqFHDtb1+/fo0P597QZ6vxytUqGCyZ8/u+r2T+HXgwAFz/Phxr8dfvnzZbN++PcExjpo1a7ric96WSAQAAEB0IwELAIB0rmHDhvbn5s2bPQarVJnXr18/E030mgYNGuTxsYEDB9pl+qR3794JHlOAzaEl/TwZOnSo+eabbwI6XicJTMsGeqOlEdeuXevzeVasWJEk8Q4AAAAAACA9UtJS8eLF7fZbb71lLly4kKbne/fdd30mX+3atctuN23aNMFjzn11kJ8xY4bX5/joo4/MX3/95fE51LlclHyl1wIAAICMhwQsAADSuV69epmsWbPaIJGCPRMnTrTVdhs2bDDjxo2z1YQKDrknH6V3tWvXNlOmTDEtW7Y0ixYtsglT+tmiRQtXkEuv+7HHHktw3J133mkKFy5st4cPH24f/+yzz8y2bdvMhx9+aINnL730kmnQoEFAx3vLLbfYn4sXLzZvvvmmDfhpSUjdnGSxX375xTRq1MjccMMNdmwLFy60wUHd5s+fb5dMfOONN+y+1atXNzfffHNAxwgAAAAAABBKmTNnNsOGDXMVpnXp0sVn9/DTp0+bSZMmeX1ccRenK7q7s2fPmkcffdT1N51tR9u2bU2xYsXs9vPPP2927tyZ5DkOHTpknnzySbudO3du07179wSPP/TQQ+a6666z288884zPIjstVQgAAIDokzXcAwAAAGmjhB0lDanz08mTJ82AAQMSPH7NNdfYZJ5nn33W7Nu3z0QDBcNeeeUV8+mnn9pbYpUrVzZLly61iWnurrrqKjNz5kwbWFNVpZKhdHOnJCgF8xK3kk8LBehUJakgYuKksK5duyboxrVnzx5780avTQlZmTJlCtj4AAAAAAAAwkFxkpUrV5oFCxaYefPm2SI7JUjVrVvX5MuXzyZd/fDDD2bNmjU2wSpnzpymb9++Xgv2OnXqZJOf7rnnHpM3b16zY8cOM3bsWLN37167T58+fcxNN92U4DgtR6iCPhU26u+pMO+pp54yTZo0MVmyZLFFji+++KKriO7ll182BQsWTPAcGtesWbNM8+bNbRcsFfl17tzZxqDU5UsxIb2O5cuX29fhK9EMAAAA6RMJWAAARAElXVWpUsVMmDDBbNmyxQZ6VLl31113mcGDB5uSJUuaaKLAmAJWCo4poUoBrEuXLply5crZTlFKRsuVK5fHY9UFSx3CFDj74osvzPHjx01MTIz993vwwQdNjx49bDeqQFLHqo0bN9qOZFom8tixY0kCbbfddpsNJqoj16ZNm2xlpfZTopiS6KpVq2bat29vunXrZnLkyBHQ8QEAAAAAAISDCszUlbx///5m6tSp5qeffrKxLG+czuaeqPuVkqYmT55sb4l16NDBjB8/3uOxrVq1sssPKvnrzJkzZsSIEfbmTslYo0ePNr179/b4HHfccYctCOzYsaMtktTz+VrSEAAAANElU7zWKwIAAIhwSk5SIEtWr15tO1UBAAAAAAAgOmjpv2nTptkYkIrjtHTg1VdfbcqUKWNq1aplWrZsaVq3bp2gMG3kyJFm1KhRdltfdynxSR2q1FErLi7OZMuWzRa19erVyxbeJefgwYNm4sSJZsWKFXYM//3vf22RY+PGjU2/fv1M1apVk32OU6dOmSlTpthkLHXe0n11ZS9fvry5/fbbbZeuOnXqJDhGcS517mrYsKF9/d4kfr0AAACIHCRgAQCAdIEELAAAAAAAALgjIQkAAACRInO4BwAAAAAAAAAAAAAAAAAA6RUJWAAAAAAAAAAAAAAAAADgp6z+HggAAJAaP/74o7l06VKqjytcuLC9AQAAAAAAAAAAAEAkIgELAACERPPmzU1cXFyqj4uNjTUjR44MypgAAAAAAAAAAAAAIK1IwAIAAOlCo0aNTHx8fLiHAQAAAAAAAAAAAAAJZIrnm0wAAAAAAAAAAAAAAAAA8Etm/w4DAAAAAAAAAAAAAAAAAJCABQAAAAAAAAAAAAAAAAB+IgELAAAAAAAAAAAAAAAAAPxEAhYAAAAAAAAAAAAAAAAA+IkELAAAAAAAAAAAAAAAAADwEwlYAAAAAAAAAAAAAAAAAOAnErAAAAAAAAAAAAAAAAAAwE//D0DtC+eVJdsIAAAAAElFTkSuQmCC)" + ] + }, + { + "cell_type": "markdown", + "id": "lvNwJVjyKaPD", + "metadata": { + "id": "lvNwJVjyKaPD" + }, + "source": [ + "### Recall after 100 epochs for the Cora cell complex\n", + "\n", + "![cells_dim2.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACWAAAAfQCAYAAABGuGRGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3Qd0HNXVAOArW+69AW6ATe8QMJDQTGiBUAMhQH4ChBpCDb2ETkINNRBqIAFC7733TiChhg7GGNx7l/Y/b8SuJVuSZVm2V9L3ceZodvbt7Nvd2VnP5b77SnK5XC4AAAAAAAAAAACYZy3m/SEAAAAAAAAAAAAkErAAAAAAAAAAAADqSQIWAAAAAAAAAABAPUnAAgAAAAAAAAAAqCcJWAAAAAAAAAAAAPUkAQsAAAAAAAAAAKCeJGABAAAAAAAAAADUkwQsYKH68ssvo6SkJFuWXnrpRd2dJunee+8tvMd33333ou5Oo3TDDTcU3sO99957kR/Lu+22W/Y8iy22WIwdO3aBPhfFLx2T+WMvHav1PYabg/Ly8lh77bWz92HNNdfMbrNojsnGxnkXAGDRE0Na8MSQ5p8YEsVMDKnuxJAWjqYYQ2os3n///WjZsmX23p999tmLujsATZYELKBg8ODBhX/8zr60bds2Fl988VhuueViww03jEMPPTT7B/LXX3+9qLtdFMaMGRN33HFHHHzwwfGTn/wkC3K0bt06OnfuHMsss0wW/Lj55ptjxowZC7QfU6ZMiSOPPDJbX3/99eMXv/hF0feZuTvrrLOitLQ0RowYEaeccko0ZqeddlqN55m0tGvXLpZYYonsPHPUUUfF22+/vai7zA8mTpyYfX6rrrpqtG/fPrp27RobbbRR3HjjjZHL5eq8n0022ST7rFdfffWYOXPmAu3z1VdfHf/+97+z9XPPPTdatPBP36YqHYP/+9//4qabborDDz88+11Lx2l9/ydHUzrvAgAsCGJI9Vcs8RgxpKapKV3LiCE1XmJINKcY0uzeeOON7Pdy5ZVXzn4n05LW07Z0X32kf0Ol71RKEuzVq1d2/ku/v7vsskvcc889dfperbLKKvGb3/wmW//Tn/4UQ4YMqVdfAJiLHMAPNtlkk/SvtHlaWrRokdtmm21yjz76aJ2e44svvig8dqmllso1dhMmTMhtu+22udatW9fp/Vp66aVzzz333ALrz7nnnlt4rpo+k2LrczH6+9//Xnj9e+21V1Ecy7/5zW+y5yotLc19+umnC/z5FpRTTz11ns8zv/zlL3OjR49e1F0vGumYzL836Vit7zE8L7799tvciiuuWONntMsuu+Rmzpw51/3ceOONWfuSkpLciy++mFuQ0rmuV69e2fOtv/76C/S5mru6HJML0htvvJHr3LlzreeR+pynm8p5FwBgQRBDmnfFFo8RQ2oYYkgLjhjS/BNDqhsxpIWnqcaQkmnTpuUOO+yw7Jitad/pviOOOCI3ffr0Ou/32muvzXXo0KHWPm+++ea5YcOGzXVfn3zySa5ly5bZY/bee+96vU4Aalc6twQtoHkaNGhQrLvuuoXbqeTuuHHjstLVqVTpV199Vdj+8MMPZ0sqH3vppZdGp06dojmN5nnwwQerbEujPNdZZ51sBFYa+ffOO+/Ef//730LJ8c022ywblbDttts2aF/Gjx+fjc5JUpnkrbbaquj7TN0dd9xx8Y9//CMb7XXqqadmI3Qauz59+sROO+1UZdvkyZPjs88+i1deeaUwcjaNsv3mm2/i6aefzkZSs/Dtueee8dFHHxU+ty233DI7l6Rzf/rM7rzzzjjnnHPipJNOqnEf6ffjmGOOydbT78UGG2ywQPt8ySWXZCN+k+OPP36BPheLVjoW029gQ2uK510AgAVBDKluiikeI4bUtDXFaxkxpMZDDInmGENK9t9//+zcmzdw4MCswmTy6quvxueff55Vqrr44ouzPlx33XVz3ef1118f++23X+F2qib305/+NLp06RLvvfdeoaLWk08+mf2Wv/TSS9GxY8ca97fsssvGzjvvHLfffnv885//zI73FVZYYT5fOQBVzCVBC2imoxfTCKPapGz68847L9evX78qmfaDBg3KTZ48OddcpPchve5u3brlDj/88Nw777xTbbsXXnghN2DAgML7lEZZfPfddw3alwsuuKCw/2uuuaZR9LlYFePoxcrf0TRK5csvv8w19tGL6fXU5Ouvv84NHjy4yvklHeMs/NGLaZRhfl/rrrtuNiow7/333y+MGuvatWtu0qRJNe7n4IMPztp17949N3z48NyCNGXKlMLIxSWXXDJXVla2QJ+vuVvUoxefeeaZwu/aFltskTvxxBNz99xzT+6cc86Z7/N0UzjvAgAsCGJI866Y4jFiSA1HDGnBEUOaf2JIcyeGtHA11RjSddddV6Xi50UXXVTlWErraVu6L98uVXmrzUcffZRr1apVof2vf/3r3MSJE6u0eeqpp7LXkm+zzz771Pk9SMt+++03z68VgNqZxBiolzTKLY1C+fDDD+OXv/xlYXvKuE+jUpqL1q1bxymnnJKN8EsjF9ZYY41q22244YbZyKs033eSRjik9g2lrKwsLrvssmy9Q4cOsdtuuxV9n5l3+dEu6fO+/PLLoynr379/PPDAA9nfvKuuumqR9qm5qjzaOY2QrjyKauWVV45DDz20MDoxjbKqzltvvRV/+9vfsvU//elP0atXrwXa55tvvrkwcnGfffaJFi38k7cpS79jn3zySYwePToef/zxOPvss2PHHXfMRubPr+Z03gUAWFDEkIorHiOG1Dw0p2sZMaTiIYZEc4whTZs2LU477bTC7WOPPTaOOOKIKsdSWk/b8pXdkvT7On369Br3+8c//rFQ3S9VgUvVtdLvdmWpGlY6hvNSm/TvrdoMHjw4q4SVpAqJI0eOnKfXC0Dt/EsCmC/pIuq2226Ln//854VtqXzp888/H81B9+7d4/TTTy8EmGqz9NJLx0EHHVS4/dBDDzVYP5566qlCSf/0WdRWZrZY+sy822GHHaJNmzbZer6UfFOWjuPKJZbTxfF33323SPvUHOXLxpeWlsZGG200x/1peom86i7w0zQjBx98cPY3TUuSynEvaJVLeP/qV79a4M/HotWtW7dC4KihNbfzLgDAgiSGVBzxGDGk5qG5XcuIIRUHMSSaYwzp/vvvjyFDhmTraWrAlDhVk5R0lf9NTb/FNf1Wfv/993HXXXcVbp933nk1JgduvfXWsfnmmxeSbvMJjLXJJ8RPnTo1/vWvf821PQB1JwELmG8lJSXZhXynTp0K29LIgeqkEXOpfVpSYKa2feaXvHfeeSd+97vfZXNSp4vqtKy33npxxRVXVBtEePPNN7ORlCuttFI2MqBHjx6x6aabVhkRsLBVnq8+vRcNpfJrSiM2GkOfZ/ff//43m3M8faZpdGwaZZk+4/R5p4vfdDE8bty4ue5n1KhRceGFF8YWW2yRjXxr27ZtNjd6GmX1+9//PjsuFrZ0AZYClhtvvHE2miYFwNLrS8dkGnWzxx57xJVXXjnXwFD6juUDFcOHD48nnngimro111yzyu1vv/12kRwDL774Yhx++OGx1lprxWKLLRatWrXKLpZXW2212GuvvbIL1SlTptT4+BRUuuiii+IXv/hFdkynzzLtI43iW2eddeLII4+MDz74IIrRhAkTsr89e/aMli1bznF/796952hb2TXXXBOvv/56FiRI5+sFPZLw888/j1deeSVbX3755bPfgHmRPqsTTzwxC/Sl72v6rqbPKZ2bUpCkLsdgGkmW/w179tlnC+eBk08+OfvOp/+JkX6XVlxxxeyz//TTT+epjxMnToxLL700ttpqq+jXr192jKcA0qqrrhqHHHJIvPbaazGv0gj1NAp+u+22y36f0/k3nav69OmTnXfSOez999+v8/4mT56cfd5pJHz+vJe+j7vvvnuNo1yLUXM87wIALEhiSHUnhlQzMSQxpOqIIS16YkhiSM0xhnTvvfcW1tNvUPv27Wtsm+7bddddC7fvueeeGpO6UiJi/tj8yU9+UmsfKlcUrdyfmuy0006F9VQFC4AGNJcpCoFmZJNNNinM/XzqqafO8+MPPfTQwuNLSkpyo0aNmqPNF198Uae5tPNt8qepc889N9eyZcsq2ysvW221VW7q1KlZ25kzZ+Z+97vf1dg2LbvttlvWbmG7//77C31o3759g+wzzR/es2fPwn6/++67XLH3ubIxY8bkfvWrX2XHTG2fWVoWX3zxWvd1+eWX57p06VLrPtLz/Pa3v81Nmzatxv2k+efz7dO89NWp67F81VVX5dq1azfX15aWDTbYYK7v1wUXXFBof/DBB+cam3Ruyfc/nXPm5vHHH6/yHr300ksL5RjIGzJkSG6LLbao0+e33nrrVbuPX/7yl3V6fOrXEUccMddzUzom849Jx2p9j+G62nHHHbP9lJaWZueb2T377LOF57r00kur3DdixIhc9+7dF+rxeskllxT6c9BBB9X5cek35MADD6z1tyYt6ft82WWX1fn39Jlnnsndd999tR6XaZ/pXFEXDzzwQG6JJZaY6/G0xx575CZNmlSnfV555ZW5bt261ek4feSRR+Z6TL7//vu5lVZaqdb9nHLKKbkFrfL3oLbzdFM/7wIALAhiSAueGNKcxJDEkGojhjQnMaTaiSGJITVEDKl3796Fx95yyy1zbX/zzTcX2vft27faNrvvvnuhzQEHHDDXfQ4dOrTKe/bJJ5/U2j59P/PHWTqffP/993N9DgDqprQhk7mA5i2VLU0jH5IU/0qjfbbffvv53u9VV10Vxx13XLa++uqrZ6OZ0giaNDojP9rnsccei8MOOyxrm8oUX3311dkImUGDBmUjV9JogRdeeCG++OKLrP2tt96ajSBJo+UWpnfffbewnkZxNIS33367ME/3csstN1/zlS+sPuelUUBpnvL//e9/hW1plFkaMZlGRKU5zr/++ut46623spE1qSRuTdIc6pdccknhdhpp9eMf/zgbCZkel96n9957Lzs2r7/++uy5U4nfBTmSKo02OfDAAwu302i31Kc02iiV4k6jMT/++OOsX7XN915Z5fLdzWH04uwjxWo7vhv6GEgjtdIIyGHDhhW2pZGLacRRGs2W9vnZZ59l+00jF2s6PtMxnKTPPI2gTN/TdJyn81gahfrGG2/E0KFDs35dfPHFMW3atGzUV7FI59B0LKdR4mnU2ewl5J955pnCehqNV9mxxx4bo0ePzt63mka1N7TK34vqyt1XZ9KkSdlIwMqj6pZZZplYe+21s1GB6TWk+9Ixkz7rQw89NDsnpVGOc5NGy5500knZdzyNWE4jG9M+02jw5557LjvPpX2mc0U6Jvbdd98a95Wma/n1r3+dlRNPUvs0OjCVTk8jGtPvXP47c8stt2S/eU8//XQ2urEm6bcz/9ud32f67UzHaXrciBEjsuoB+dHrtZ2Hk/T8qex5+t6k4zx9Buk7mH6nUl/yo9DPOOOM7PvQGMr7N7fzLgDAwiCGNHdiSFWJIYkhzY0Y0qInhiSG1NxiSKmPlb/3P/rRj+b6mMpt0vc5HR+zT/VbeYrOuuwzVR9L57w0dWH+8bVNtZjOZen89Mgjj2TnkyeffDKrsAhAA6hjohbQDMzv6MU0SqLyqI8TTjihQUYvtmnTJhupkUaA1DaSK42s+ctf/pKtp1ET77zzTpW2aURQGhmUb9+xY8fcxIkTcwtLGlWw4oorFp7/97//fYPs969//WthnzvvvHOuMfQ5mTFjRjZar/LonTTybPr06XO0TaPM0ijKNIqqOtddd11hP507d85dc8011e7n6aefzkaV5NumUbELcvTimmuuWWhzyCGH1DiSaMKECbnbb789d9xxx+XmZvLkyVW+Z6NHj8415dGLlUf79OrVK1deXr5QjoFx48bllltuuUK7NEI4jWCq7vnTeSSNXNpnn32q3dfxxx+ffb5pn9VJ+0zHd3p9+ed74YUXimb0YupLfl/pO5uOwbw0mio/6q1r165VjvEXX3yxMCr5xhtvzC0siy22WKG/7777bp0e85vf/KbwmOWXX77a35v0G3LFFVdkv0mpXfoevvzyy3P9PW3dunX29+ijjy6Msq88OnajjTaqMkL8008/rXafaXv63cq3XXfddecYzZbO2RdeeGGuRYsWhXapskBtoxYr/97uuuuuua+//rratum9POyww3KPPfZYrcdk/v1J57PZz3mpqsFPf/rTQtuBAwfW+J0upgpYjf28CwCwIIghLVhiSFWJIc0ihlQzMaQ5iSHVTgxJDGl+Y0ivvfZalfel8jFfk/RaKz/m9ddfn6NN5WqI1VUSq86gQYMKjznvvPPm2j792yvf/vDDD6/TcwAwdxKwgAYLniVLL710YR+pPHNDBM/atm2be++992psu/nmm1dpny6caiqZmi5+VlhhhULb2267LbewpHLD+edNFza1vaZ5kcod5/d70kkn5RpDn5MU3Mjvu1WrVrnnn3++XvsZP358dtGev0h99dVXa23/wQcfZMdUat+jR49qA1oNETxLAbH8/f3792/QC8R0wZnfdyrd3VSDZ+m1paB4vv2JJ5640I6B9F3KP28qx/zRRx/lFrTU78pBjGIJns3++9CvX78sUJj62KFDh8L2s846q8q5dvXVV8+2b7zxxrmFZdiwYYX+pMBdXaYISOee/GOWWWaZrOR9bSq/tz/72c/m+n7NrYx9OldU/p8Ue+6551wDfMsuu2xu7NixNe4z/z+S8ufuzz//fI42KfDeqVOnOvVxbiofkzX9z7O8NMVJ5eNmbt/XYkjAauznXQCABUEMacESQ6pKDKl5XsuIIdVMDGn+iSFVEEOavxjSww8/XCWhs64qv5+PPvpolftSElfl9+jf//53nfa53XbbFR6Tkjnn5h//+Eeh/eDBg+vcdwBqt+Bq5gLNUpcuXQrrY8aMaZB9ppK6q6yySo3377777lVup3K+qVRxdVJZ3F133bVw+/XXX4+FIZWhPuGEEwq3U3ng2l7TvMiXxE9SWfLG0OfkwgsvLKz/4Q9/qHOZ59mlMuBjx47N1tPUAeutt95cS2Hvtdde2fqoUaPi0UcfjQUhlQ7OSyWjS0pKGmzfffv2LaznSzo3FamMdpqy4I9//GNWzjuVLE9SieyaSnU39DGQyrf/9a9/Ldw+55xzYoUVVogFLfU79S156qmnopj885//LJSt/uabb+Lvf/973H777VnZ9WSXXXapMh3HpZdeGv/973+zkvnVlcJP5c9TWfL0XjekyufD9DvQunXruT7mL3/5S5XzUpp2oDZ77713oUx+mrokHUO16dSpU3YM1aRjx45x3nnnFW7fcccdhRLreen4TqXj81L7yr+3szv88MML5+s0fUqaUmV2aduECROy9aWWWiqbuqAhpKkVTjnllBrvT+XQf/7zny/03+H51ZTPuwAAi4oYUvXEkOYkhlR/TflaRgxJDGl+iCFVEEOaP2k6x7x27drV+XGV21beR3W367rf2vbZ3H4fABYlCVhAg0oXAXn5f5TPr3RRVpvVVlttntqvuuqq1V5oLSjpomfHHXcs/KM3zYle+WJtfuXn9c4HaRpDn7/66qv46KOPCrcPOeSQeu/r4YcfLqzXdZ7yn/70p4X1F198MRaEdAHetm3bbP29996Ll156qUH3nffdd99FY/Xcc89lQcXKS/v27WP11VePs846KwuspODHb3/722w++g4dOiyUY+DVV18tBONS4CMfaGsIH3/8cdxyyy1x5plnxtFHHx2HHnpodvznl3zQJAVkhgwZEsWif//+8eabb8bJJ5+cBfjSsd25c+fYYIMNskBaCuyk/zmRfPvtt3Hqqadm60cccUSVoHvaRwqcpM85BbfSftZee+0qgaGFeT5MwdknnngiW0+vZ9ttt63T82y66abZ3zTYfm7f7e23377WQFeyzTbbZEGnZOrUqfHKK69Uuf/ll18uBBrT93+77bardX8tWrTIvjd5zzzzzBxtKgeN999//2jTpk00hNS3/LmvJmuttVajC/A0lfMuAEAxEUOakxjSnMSQ5n/fTeFaRgxJDEkMqYIYUnFJn0FeXZL48iq/hymZtKZ9zst+a9tnU/59ACg2pYu6A0DTUjlgli5EGkLlYFd1unXrVlhPFyiVM/er071792pHmC0I6R/LO+ywQ3z66aeF9+TOO++sEmScX/nRQ0m6IG0MfU7BibwUmJufUZeVLzLTaJwbb7xxro9Jo6/yFlSAIl0YpQDkrbfeml2gp2DNr371qyy4u/HGG0fXrl3rve/Kn3Plz78pSgGAiy66qNaL8YY+Biofn+uvv/48jV6qyUMPPZSNyHz77bfr/JiRI0dmQatikc6vKeiXltqk0cjptyB9r/NBtOTee+/NRo/PmDGjSvt///vfsdtuu8U777wTf/7znxfq+TCNsMw/plWrVtmov7p444036nwO+fGPfzzX/aXA46BBgwqB4HSc/OxnPyvcX/m4WXfddbNRoXOTApuVH58CfZVHUb/22mtzBAMbwuz/Q6s6lQObC/p3uKE0p/MuAMDCIoZUlRhS9cSQxJDqSgxJDGleiCHNIoZUf5XPN9OnT6/z4ypXdJv9vDH7Oayu+61tn9WpfNyn3/NUAS0l5AEwfyRgAQ2qcsnbykGq+TG3UR+VLyLm1nb29rNfxDWkFDBJwZLnn3++8A/n+++/PxuZtaCki6NF0edLLrkkPvnkk1rbXH755dWOMBo4cGC9+5tGV1YO2F577bXzvI+GmuagOino89Zbb2XvTbpQSiW405IuZNKIrlQyf4sttoitt956nkYOze/nXPniOfVnXlX+LOdHnz59YqeddircTu9RCmqlwEQKHCV/+9vfsvfvgQceqPbCcUEcAw11fOaddtppcfrpp8/z4xpqBPjClMre50cipuM/H3RPIxrTKNB0zk2lylPJ/xTc+fzzz+Oggw7KzjmpxHoKLKfvQ0Ooy/ck9SsvjRitPG1AQ51DllxyyTrtp3K7VFq/ssq30/tXF0svvXSV71Y6nvL/UysFrCqPhGuI43xefodToHJh/A43pIY67wIAMIsY0ixiSFWJIYkhzU4MqXZiSPNHDEkMqb4qJxzXpepUdW1nT1qe/XZd91vbPqsj1gWwYEjAAhpMGgFSeUTQEkss0SD7rTzaoiHbLkhptECa4z0FnvIBuzQn+yabbNLgz1W5pPa8/CO/Ift8zz33ZKXA6xpwqRwUmJ9RkbPPcV/fgOGCkr4DqVz2+eefH9dcc00hKJPe63fffTdbrrjiimwE7rHHHhvHHHNMoQR3bSp/zjWVVK+LDz/8sF7BgoYKnqWRq9XtK72+Sy+9NE488cTsvUoBmTQi7sorr1wox0BDHZ9JKk1eOXCWRrLts88+2Ui1NDIx7b9y4HTw4MGF71J67Y1JCtD8/ve/z9a32mqrKlN5pM8uP0otjS7Nn1dSKfo0qjEFjlIgNI1enJ/g2byeDxfGOaSuo8or9332wGl+Ko/Z29V1f/l95oNns++/IUenF8vvcENrqPMuAAAVxJBmEUOakxiSGNLsxJDEkMSQZhFDKh6zV+hKlaTmNq3i5MmTq7yvsyehpwTStOSPy8qJnrWpPI1gXRLbKx/3qc+qXwE0DGdToMGkIEFZWVmVssvNVRqNc/PNN2fr6R+u//jHP+o8L/y8qhykzI/4KvY+d+rUqdqLwnk1+8Xh6NGjs5Eb87I8++yzsSCli9VUbnvo0KFZWfIUSEtl5SvPsZ5GP51wwgmx884712nkSeWRTA0VpC4m6QLzuOOOizPOOKOwLY1irO6zWhDHQEMdn0n6vCuXwn/ppZdi//33jzXXXDO7QJ991GpjHLGYd8EFF8T//ve/7DXNHhR97LHHsr/LL7/8HAH5FDxO5eOTl19+eb7e83k9H1Y+ftIo7Xk9dtKSRqfOLagyr6XvKx+Dswe36jplxOztKu9z9v3P73HeHDT18y4AwMImhjSLGFLtxJDEkGojhtQ4iSFVTwyp8VlhhRWq3P7qq6/m+pivv/661n3Mvq0u+5x9vyuuuGI0998HgEVFAhbQYNJIt7wUfNlwww2jOTryyCOzkWp5V111Vey+++4L7PkGDBhQWK88enRh9jkFH+Z2gVnZ4osvXlj/4osvor66du1aJfhQeZRHsUmjEtdbb704+uijs9GeaeTKCy+8ENtvv32hzX333Rd33XXXXPeVAnHVlYieV2m0an2CBQvL8ccfHz/60Y8Kt1NAbWEcAw11fKb/mZAfiZjOiWlk3txGds1+Ad5YfPnll3H22Wdn62kk7rLLLlvl/o8//rgQPKtOfnt6zz777LMGOR+mIEIaUVnXz3pBnT/q+pkOGTKksF45uJ706tVrnveXPpO81q1bVwmYpaB+5ekY5uc4by4a6rwLAEAFMaQKYkhiSNURQ5p3YkiNhxhSzcSQGp80jWLv3r0Lt99+++25Pubf//53Yb1v376FamOVpYpv87LPNEVm5UpZlR9fE7EugAVDAhbQINK856kkcN7PfvazOs3h3dScdNJJcfHFFxdup/nr99tvvwX6nGnETV4aOdQY+lx5ZGu6qK5v0C9Zd911C+tpZFhjkQ8wp9LZW2yxRWF7vnx/bSOhKo96WWONNaKpSgHHc889t3D79ddfz96vBX0MVD4+X3nllXpPy5BGz+WDN4sttli21OaDDz6YrxHIi9Lhhx+eHZsDBw7Myv7XNJKuplLqlUcRzs9IuhQMy7/PKdCbD9rVJI0izQdfhw8fHp9++mk0tDRqeW5S0PCNN94o3K4cNE7WWmutKt+DypUCapJGglZ+/OyB2xTMz3v66afnur/mrDmddwEAFgYxpApiSHUjhiSGVBdiSI2HGFLNxJAap0033bSwXpdKiZWn4f3pT3/a4PtM03TOnthY09SyzeH3AWBhk4AFzLd0gbLXXntVueA5+eSTo7lJI3f+9Kc/FW6n0tdHHHHEAn/eyoGD//znP42iz0sttVSVURh//etf672vyiXur7zyyoU6uq4hpAva7bbbrnB7bnO6v/fee1FeXp6tL7fcctnovaZs8803jw022KBwO5XiX9DHQAqepZLm+XLuaSqF+gZI8+oSgEt9b4wefPDBQtD30ksvjbZt287RJj9yrqZAeeXt1Y36WlDnxDSCr3Kg44orroiGlt6b8ePH19rm0UcfzYJ3SXr/fvzjH1e5/yc/+UkhyJdGZT700EO17i+dI/7+97/XGszZeuutC+tp9Pq0adPq+Iqan+Z23gUAWJDEkCqIIdWdGNIsYki1E0MqfmJItRNDapzSVLF5t912W63f4XTf7bffXu1jK0sVD/PnhZQwPbfkvBtuuKGwvsMOO9Sp35WP+crfBQDmjwQsYL6kgFmad73yP+T33HPPOf7h39RdcsklVQKGqXzyH//4x4Xy3GlUSr7UcBp5M7fgSzH0OfnDH/5QWL/wwguzUur1ceCBBxYCSKl87+mnn17nx6aRYnUZBVQfKegyt9LV1ZWNntsIt8rvU+VRj03ZqaeeWlhPn/HsgYOGPgZSkOLggw+uUra+PiODe/ToURjFPW7cuCojkWaXRl02xuBZChoceuihhYDBz3/+82rb5YPlb731VrXnqBSAS1q1apUFhedH5e/Fiy++ONf2lacluOyyy+LJJ5+s83PVpeR8CpxVN6Kz8sjOdP7N22WXXeYY/Z+O71/96leF28ccc0x2jqnJ5ZdfHu+++262noI1BxxwwBxt9t9//+jYsWO2nkZEL4z/cdJYNcfzLgDAgiCGVEEMad6JIc0ihlQ7MaTiJYYkhtRUpWSpfv36Zetjx44tTLFZnZQYmtrkE4wrJ4XOXqHtF7/4ReF2+txrShh9/PHHsyVfDfCggw6aa59T4l2+8llK7k0JrAA0DAlYQL2kC4YLLrggVl555SoZ+2mERRoF0Zxcf/31ceSRRxZu//73v69S8npBSxdG22yzzTyVAV7UfU723nvv7HhJZsyYkU05kEYOpfXZpSDUAw88EDvttNMc96WLzFTyPi8FTtJo2prmuE8XKilQkYIjqRxvfUuDz00KEqS500877bSsLHh1UtAmjYpJF+zVjSiqTuXPt6YLtKYmBUMql3SffQTjgjgG0kXtMsssUwh8pVL/t956a7UXuqls+r/+9a/47W9/W+t3Mx3zqfT37NI5NLVLx0PlMuqNQQoofPnll1lZ+BSQr0n+WE0j5FKwKj8CN7n66qsLgZ7NNtus2tGP86Ly96Iu58NNNtkkO16SmTNnZgHAP//5zzWWsZ86dWo2jUEaTZYCLHPTunXrbIT28ccfP0dAfejQodnz5c8RaTRl5WBxZaecckoh2JXK4m+11Vbx+eefV2mT3tf0OVT+nxPp/J7ORbNLI3Qrn/f/9re/ZQG6mkaYvv/++9k0AfmATnPSHM+7AAANSQypeOIxYkhiSE2dGFLxEkMSQ2qqUiJm5WTOdEykCm+Vj920nrZVfh9TJcn0mdcknb9SomE+oTYde/kpOvOeeeaZ2GOPPQq3f/Ob32T/3qrL7046XyWDBg2aa0IvAHVXOg9tgWbk4YcfrjKPfPoHYhqBkbLz0z/yv/jii2pHQqQL2HyJ2+YgXfCl152/oE4Xvmn9kEMOqdPj04XI/I7USX79618XSlyni7rdd9+96PtcWlqaBY5SWeNPPvkkC0Cki7yTTjopKxfeu3fv7EI2japJFwTp+Jt9RE/loES6iMwHVdJ7cfPNN8eaa64ZK664YnbBmS6E00XhO++8U7i4WNCGDRuWXXylZYkllsj6k/6m155GcKXX9e233xbab7TRRtlo4Jqk0UpPPfVUtp4uiprL6MUkBRTygcXXXnstu4DfcsstF9gxkEqY33333dl7nMp6p/Nh+l6lEV4p6NurV68siPLZZ59lIyZTAG6NNdaYYz9phHD6Tqb7U5ApBQHT6O7ll18+C6S88sorhfNp+l6moEhtoxyLSerr+eefn62nkc8pEFmTNML04osvzt7LG2+8Md58883sfUivPX9Mp2BjQ4ygHjhwYLbv9N6mPn744YdVpquozlVXXZV9X9NxlT6XNNrwrLPOivXWWy97Xel3Lf3+pc87TeGQL7W+9tprz7U/aT/pvJYCLNddd10MHjw4C1ylc9uzzz5bJaCW3qNll1222v2kYO61116bne9ToDW9vhVWWCE7b6T70vGdgjEpIJeXjrfzzjuvxr6lAHJ6PfmRsymQe9ddd2WBl3SMpkBmKlf/9ttvZ8dvsummm0Yx2m+//bLjqrLRo0cX1tO5Np0PZpfe03XWWafG/Tbn8y4AQF2JIdVNscRjxJDEkJo6MaTiI4YkhtTUY0gpqTJ9Rv/85z+zfwel37+UcJVPCE1TCKZjIm+fffbJkqVqk85H6f1O/U3SvlMFuPRbmM476d9Y6RyXt/rqq9ea3FjZPffcU1hPxwkADSgH8INNNtkkRVPmaWnZsmVu2223zT355JN1eo4vvvii8NilllqqxnaVn6Oh9pn3zDPPFNqn1zw/Ku+rPkt6fEOYOXNm9trTPjt06JCbMGFC0fc5b9SoUbmddtqpTs/dt2/fWvd122235fr06VPn17Luuuvmpk6dOsd+/v73vxfa7LXXXvU67l599dVcaWlpnfuyyy675MaPH1/r67vpppsK7Y866qhcY3TqqafW+/uXPq/8YzfccMMFegzkffnll7mNN964TvvaYIMNqt3Hvffem2vfvn2tjz3ggAOyflQ+D9f0XUvHZL5NOlarU5djeH5tscUW2f5XXHHF3PTp0+fa/rnnnst17Nix2tdfUlKSu+SSSxqsb9dee21h3+mYq+t59I9//ONcP6v80qpVq9zvf//7avc1++eYjoHOnTvXuK+2bdvmrrjiijr184EHHsgtvvjic+3f7rvvnps0aVKd9nnxxRfX2r/Kn9Njjz1Wr2NyQR+f9fk3TG3fs6Z03gUAWBDEkOZdscRjxJAqiCEVPzGk6hcxJDEkMaTijCFNmzYtd8ghh2Svvbb35bDDDqvT9yDvmmuuyX6va+vbZpttlvv222/rvM/llluucDyNGDGizo8DYO5UwALqJJVCTVn1afRYGn211lprZaM20tzQ+fmtWXTS3N6HHnpoHH300VkZ2lTKOo2Eagy6d++ejRJ744034pZbbslGiqQRZmPGjMlKKafjK404SeXl07z2tdl1112zks6pzPdjjz2W7TONvEmjetIozb59+2ajmNJon1SuO43OWVDSqKc0UuvJJ5+MF198MRv9k0a5jBo1Kht5lL5PacRRGgXzf//3f7HuuuvOdZ9plE3+867raNOmJJXPzpcGT+9pKrE8+0iqhj4GllpqqWw0YRphd8cdd2Sjw9IotzSaNu0v3Z/OhakEeE2lxFN/0gixv/zlL9nouFTWPo1g7dOnTzZSN4283HjjjaMxSaPcnnjiiWw9lUbPl8OuTXqN//3vf+NPf/pT9j6k9zH9pqTRoOnclT6ThpJGbp1wwgnZZ5+my0jHThodWZv0vUqlv9O5NI1+Td/dNJIsjVxN01qk72z6vFdbbbXsuEvHTxrFWhfpGEivPZVof+ihh7JjII1a7N+/f3ZuS9/nuo4KT9+BTz/9NHtdadRbKuue+pjOl+mYSn1LI+jSOaiu0qi8dB664YYbsu9N/nUnPXv2zL4zqcx+Ki/fEKPXG5Pmft4FAKgPMaTiJoZUQQypaRNDKh5iSGJIzenfP2ma2D333DN7z9NvVL7KWDqfpIpm++67b1Y1bF6kClipil+qipam2E3HRDpPpeqPP/rRj7LPY8cdd4ySkpI67S+dp1I1yfzxnz43ABpOScrCasD9AbCIpNLiAwYMyIIzqYx1KpFN05EuZlddddWs1H+a1z2VRgdqloJ0qWx7vqx2CkQsLCmgkp8GIAV5020aH+ddAACaKjGkps21DMwbMSSak5QclxIjUyJhSvhMUx0C0HBqT+MGoNHo1KlTHHvssdn6f/7zn3j00UcXdZdoQOedd14WOEuj3k4//fRF3R0oeocddlhhdOG55567qLtDI+S8CwBAUyWG1LS5loF5I4ZEc5GqK951113ZeqqcJfkKoOFJwAJoQlLZ46WXXjpbT2WQaToXRqm0fnLQQQfFsssuu6i7BEWvY8eOhfPgq6++mpVFh7py3gUAoKkTQ2qaXMvAvBNDork4++yzs6lt27dv77cfYAGRgAXQhKT52y+66KJs/ZVXXom77757UXeJBnDyySfHjBkzspFYZ5555qLuDjQaBxxwQPzoRz/K1o877rgoLy9f1F2ikXDeBQCgqRNDappcy0D9iCHRHKan/cc//pGtn3jiibHkkksu6i4BNEkluVSLFgAAaBCDBw+O5557Llt/5plnstsAAAAAUJkYEgA0LSpgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHqSgAUAAA3o2WefjTTLd1qUjgcAAACgOmJIADSE4cOHx4MPPhinnHJKbL311tGzZ88oKSnJlr333nue9/fII4/ETjvtFP369Ys2bdpkf9PttL2uZs6cGX/7299io402il69ekW7du1imWWWiQMPPDDef//9aKpKculXHQAAAAAAAAAAaDRSolVN9tprr7jhhhvqtJ/y8vI44IAD4rrrrquxzX777RdXXXVVtGhRc62nkSNHxjbbbBNvvPFGtfenpK7LL78821dTowIWAAAAAAAAAAA0YksuuWRsueWW9XrsSSedVEi+WmutteJf//pXvP7669nfdDu59tpr4+STT65xH2VlZVm1rHzy1S9+8YusctZrr70Wl156aSy22GIxbdq0rBLWvFTUaixUwAIAAAAAAAAAgEbm1FNPjUGDBmXL4osvHl9++WUMGDBgnipgffzxx7HKKqtkUweus8468fzzz2fTBuZNnjw5Ntlkk3jzzTejtLQ0Pvzww1h22WXn2M/1118f++67b7Z+8MEHx1//+tcq93/66aex9tprx/jx47PHp/2k/TUVKmABAAAAAAAAAEAjc/rpp8e2226bJV/V18UXX5wlXyWXXXZZleSrpH379tn2JLW76KKLqt3PBRdckP3t3r17nH/++XPcn5KuTjjhhEIy1j333BNNiQQsAAAAAAAAAABoZtKkeffdd1+2vuKKK8b6669fbbu0fYUVVsjWU/vZJ9v7+OOPs4pWya677polbVVn7733LqxLwAIAAAAAAAAAABq1L774Ir799ttsPU0zWJv8/UOHDs2mOqzsxRdfnKNddZZYYolYfvnls/WXXnopmhIJWAAAAAAAAAAA0Mx88MEHhfVUAas2le/PV7uan/0MGTIkJk2aFE1F6aLuAHOaOnVqvPvuu9l6r169orTUxwQAANBczJw5M0aMGJGtr7baatG2bdtF3SWgmRGbAgAAaL4aS2wq9fO7776LxmLYsGF1usbu169fLEzffPNNnZ+7f//+hfWUPDW/+8nlctnj8lMbNnaiJ0UoBbjWXXfdRd0NAAAAFrHXX389Bg0atKi7ATQzYlMAAAAUe2wqJV9VTghqKlJS0sI0YcKEwnrHjh1rbduhQ4fC+sSJExfIfhozUxACAAAAAAAAAEAzrIKd17p161rbtmnTprA+ZcqUBbKfxkwFrCKUys5Vzijt3bv3Iu0PAABQu/LhGy3qLtCEDPt+Zqy/zTdzXB8CLCxiUwAA0LiITdHcY1OvPtI/ei/WMorRsOFlsf7WQ4r2GrvyFJPTp0+vte20adMK6+3atat1P21rmbqytv00ZhKwilDlOT/Tl29hz/EJAADMm/JK/4aHBXV9CLCwiE0BAEDjIjZFc49NpeSrfn1aRbErxmvsTp061Xk6wEmTJtU4zWCn2fZTWwJWbftpzBrHtwUAAAAAAAAAAGZTHrkoj/Io1r4Vs8oJYd98U1H5rCZDhlRU8kr69+9f63569uw51/2UlJQUXULa/GixqDsAAAAAAAAAAAAsXCuvvHJh/aOPPqq1beX7V1pppfneT//+/aNDhw7RVEjAAgAAAAAAAACAZmbAgAHRp0+fbP25556rte3zzz+f/e3bt28svfTSVe7bcMMNC+u17ee7776Ljz/+OFvfYIMNoimRgAUAAAAAAAAAAM1MmgZwhx12KFSmevXVV6ttl7bnK1el9ulxlS2//PKFqli33357TJ48udr93HDDDYX1nXbaKZoSCVgAAAAAAAAAADRKZbnyol6K3RFHHBEtW7bM1g899NCYMmVKlfvT7bQ9KS0tzdpX5+ijj87+jh49Oo499tg57v/ss8/iz3/+c7a+7LLLNrkErNJF3QEAAAAAAAAAAGDevPjii/Hpp58Wbo8cObKwnrZXrjiV7L333nPsI1WvOuaYY+Kcc86JN998M5sa8LjjjotlllkmS5o699xz4+23387apnbLLbdctX3Za6+94vrrr4+XXnop/vrXv2bTDe6///7RrVu3eP311+PMM8+M8ePHR4sWLeLSSy/Nkrmakqb1agAAAAAAAAAAoBm49tpr48Ybb6z2vpQIlZa5JWAlZ599dgwfPjxLoErJVrvtttscbfbdd98466yzauxLy5Yt4957741tttkm3njjjbjrrruypbI2bdrE5ZdfHltvvXU0NaYgBAAAAAAAAACgUSqPXFEvjUGqSnXdddfFQw89FDvssEP06dMnWrdunf1Ntx9++OEs2Su1q03Pnj3j5ZdfjiuuuCI23HDD6NGjR7Rt2zYGDhyYVcN66623Yr/99oumSAUsAAAAAAAAAABoZNIUg7NPMzg/UvWqtMyP0tLS+N3vfpctzYkKWAAAAAAAAAAAAPWkAhYAAAAAAAAAAI1Smugv/VesfaN5UAELAAAAAAAAAACgniRgAQAAAAAAAAAA1JMpCAEAAAAAAAAAaJTKcrlsKUbF2i8angpYAAAAAAAAAAAA9SQBCwAAAAAAAAAAoJ4kYAEAAAAAAAAAANRTaX0fCAAAAAAAAAAAi1J55LKlGBVrv2h4KmABAAAAAAAAAADUkwQsAAAAAAAAAACAejIFIQAAAAAAAAAAjVJ5RJQV6VR/qW80DypgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoyBSEAAAAAAAAAAI1SeeSypRgVa79oeCpgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoyBSEAAAAAAAAAAI1SWS6XLcWoWPtFw1MBCwAAAAAAAAAAoJ4kYAEAAAAAAAAAANSTBCwAAAAAAAAAAIB6Kq3vAwEAAAAAAAAAYFEq/2EpRsXaLxqeClgAAAAAAAAAAAD1JAELAAAAAAAAAACgnkxBCAAAAAAAAABAo1QeuSiLXBRr32geVMACAAAAAAAAAACoJwlYAAAAAAAAAAAA9WQKQgAAAAAAAAAAGqWytOSKt280DypgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoyBSEAAAAAAAAAAI1S+Q9LMSrWftHwVMACAAAAAAAAAACoJwlYAAAAAAAAAAAA9SQBCwAAAAAAAAAAoJ5K6/tAAAAAAAAAAABYlMqjJMqiJIq1bzQPKmABAAAAAAAAAADUkwQsAAAAAAAAAACAejIFIQAAAAAAAAAAjVJ5rmIpRsXaLxpek66A9fXXX8epp54a66yzTvTq1Svatm0b/fv3j4022ihOOeWUeO+99+q8r8mTJ8fAgQOjpKQkW5ZeeukF2ncAAAAAAAAAAKD4NdkErMsuuyxWXnnlOOOMM+Ktt96KkSNHxrRp0+Kbb76JF198Mc4888y49tpr67y/lLD1xRdfLNA+AwAALEo33TkhDjpmeKy71ZBot9Sn0bL3p3HDbeNrbD9+QnkcdeqIGLDOl1n7gYO+jGPPGBkTJ5VX2768PBeXXzc21tj06+gw4LNYfJXPY4/ffReffzVjjrZlZbn48yWjY9n1voxuy38eW/5qaHzwv+nV7vfqf46LjgM+i8++nHM/AAAAADQOYlNAY9YkpyA866yz4o9//GO2vvzyy8f+++8fgwYNii5dusSoUaPi7bffjnvuuSdatKhb/llqf/HFF2cVtFq1ahUTJkxYwK8AAABg4Tvl3FHx1Tczo2f3FtF7sdJsvSaTJpfHpr/4Jt55b3pssUm72G2njvH2u9PiwivHxvOvTIln7+kbbdtWveY66JgRcd0t42OVFVrHoft2iW+/K4s7HpgQTzw3OV5+sF8sN7B1oe3FV4+Nk88ZHVtv1j6WH9gqbr5rQvxs96HxwQtLRccOs/Y77PuZcfxZo+LUo7vHMku3WkDvDAAAAAALmtgU9VUWJdlSjIq1XzS8JpeA9dRTTxWSr37zm99kVa5S0lRlm222WRx99NExfXr1GaqVlZWVZQlc6W+azvC6666TgAUAADRJV1+4WCw3oFUs1b9VnHvZmDjxT6NqbHv+X8dkAa5jD+kafz6pZ2H7CWePjPMuH5sFqY4/rHth+zMvTc4CXBuv3zYeu61vtG5dEXjYfaeOse3/DYtDTxwRj97at9D+2pvHx2Ybt4sHb+qT3d5pm44xeKeh8eATk2K3HTsV2h1ywogYuGSrOPLArg3+fgAAAACw8IhNAY1Zk5qCsLy8PH73u99l62ussUaWLDV78lVlrVvPymCtySWXXJJNYbjCCivEcccd16D9BQAAKCabb9w+C3DNTS6XywJWHTuUxMlHzgpkJel22p7urywFrZLTj+1RCHAlW2/WIQb/pF088dyU+PqbWWXahwydGWuv3qZwe5012hS259390MR44PFJcfWFvaK01EgyAAAAgMZMbApozJpUAtbjjz8en3zySbaekqVKS+evwNdXX30Vp5xySrb+t7/9rU4JWwAAAE3dJ5/PyEq0/2RQu+jQvuplZbqdtn/+1cwYMnRW0Oq5l6dEh/YlscG6befY35aD21e0eWVKYVv/vqVZ2fi8f/+wnrYn48aXxWEnjYgjDugaP1p9zn0CAAAA0DSJTVHTFITFutA8NKkErDvuuCP7W1JSEttuu21h++jRo7PErPR3Xhx88MExadKk2HPPPWPw4MEN3l8AAIDG6JMvKoJXyw2sfkRifnu+3aTJ5THs+7IYsGSraNlyzoDDsgMq2n/6Q/tk3z06ZyMPt9vz2zjq1BGx82+/iz5LtIxtt+iQ3X/sGaOiXduSOP2YqqMcAQAAAGjaxKaAYtSkErBeffXV7O/SSy8dnTp1iltuuSVWW2216NGjRyy//PLZ3zSV4AUXXBDTps3KVq3OrbfeGg8//HB069YtLrzwwoX0CgAAAIrfuPHl2d8unaq/pOzcsUWVdnNt/8P2fLvkyAO7xhnHdo8P/jc9rv/XhFh95dbx2K19o2OHFtmIxVRG/srzFotWrUri6NNGRs+VPo/2S38WO+09LIaPnFUKHgAAAICmRWwKKEbzN0dfESkvL4+PPvooW+/Zs2ccfvjhcemll87R7uOPP45jjjkm7rnnnnjooYeia9euc7QZM2ZMHHHEEdn6OeecE7169WrQvn7zzTe13j9s2LAGfT4AAIDGJo1GPOnI7tlS2dSp5XHQscNjz192is03bh/nXDo6rrhhXFx4es/o17s0DjtxROxz+PB46OY+i6zvAMVObAoAAKB2YlNAs03AGjduXJaElbz77rvxxhtvRO/eveP888+PbbbZJtq2bZttO+6447JKWS+//HL89re/jbvvvnuOfaUEre+//z5+/OMfx/7779/gfe3fv3+D7xMAAGBh6dL5h1GBE2aNCqxs/MTyKu3m2v6H7fl2tTnzL2Ni7LjyuPC0ntntS68dF3vu0il+t1eXwr5+c8j38b9Pp8cKy7aux6sDaPrEpgAAgMZMbIrZ5XIR5bk5p5cslr7RPDSZKQgnTZpUWJ86dWq0b98+nnnmmfj1r3+dTSPYrl272HjjjePpp5+ONdZYI2uXqmC99tprVfbz/PPPx/XXXx+lpaXxt7/9LUpKivNLCgAAsKgsN6BV9veTz2dUe39+e75dh/YtovfiLeOLr2dEWdmcEYdPv6hov+wP7Wvy3w+mxQVXjomLzuwZ3bu1jHHjy+L7EWWx5qptCm3W+mH9o0+n1/v1AQAAAFC8xKaAYtRkKmClCleV7bfffrHCCivM0S4lYp199tmx7bbbZrdvu+22WG+99bL1adOmxQEHHBC5XC6bwnD11VdfIH0dMmTIXMu8r7vuugvkuQEAAObXcgNbRZ8lWsbLb0yJSZPLsyBWXrqdtg9YsjT6950VtNr4x+3itnsnxkuvT83WK3v82ckVbdavur2yFBw74KjhseXg9rHbjp2q3Ddt2qzA2bTpFesG0wDUTGwKAABozMSmgGLUZCpgdepU9SS35ZZb1th2s802yypcJWlawryUmPW///0vK8N++umnL7C+9uvXr9YlTZ0IAABQrFIAad89OsfESbk466LRVe5Lt9P2/X7ducr2/f+v4vap542K6T8EopJHnpoUz748JbbYpF0s1b/mUYaXXjM2PvxkelxxTq/Cti6dW2ajFx9+elKV/SUrLVf7iEWA5kxsCgAAaMzEpphdWZQU9ULz0GQqYLVp0yZ69eoVI0aMyG6nJKraqmX17Nkzvvvuu0L75Nxzz83+br755vHAAw/UOtVh+nvrrbdm64sttlj89Kc/bdDXAwAAsLBde/O4bBRg8t6HFWXSr795fDz38pRsfYN128Z+v+6SrR/z+25x/2OT4rzLx8bb706LH63WJv797rR44rkpMWjNNnH4/l2r7HvTDdpngbHrbhkf62w5JLbZvH0M+74sbr9/QnTv1iIuPXtW8Gp2Xw6ZEaeePzr+dGKPKiMXk8P26xonnD0qtv2/b6Nf79L4+63j4+dbtI/lBrZu8PcHAAAAgAVHbApozJpMAlayyiqrxLPPPputl5WV1do2f3++ElYyfXrFSfzvf/97ttRm5MiRsfvuu2frm2yyiQQsAACg0UsBrn/cPqHqtjemZktePsiVSrs/c3ffOP2C0XH3QxUjBXsvVhp/OKhrnHJU92jXbs6Cy387v1estlLruOam8XHpteOiY/uS2HHrjnHW8T1imaVrHhV40DHDs8cdvE/Fc1d21O+6xqgxZXHDrePj2Zdysd2WHeJv5y02n+8EAAAAAAub2BTQmJXkcrlZ9fUauVNPPTXOOOOMbP3OO++MnXfeudp248ePj65du0Z66Wmqwscee2y+5mFNCVj5xK+G8M033xQqeA0ZMiQr/Q4AABSv8u+WW9RdoAn55tuZsdTaX2brrgmBRUFsCgAAGhexKZpjbKrytesDr/aNxXsXZ/2h74fNjO3WH1r07yfzb860z0ascsLVPffcU2O7dF8+72yjjTYqbE/b5rYstdRSWdv0N7+tIZOvAAAAAAAAAACAxqNJJWCtvvrqsfXWW2fr//rXv+Kpp56ao813330XJ598crbeunXr2GeffRZ6PwEAAAAAAAAAgKahOGuwzYeLL744XnnllRg7dmxsu+22ccQRR8Q222wT7dq1i9dffz3+/Oc/Z6XokjPPPDP69u27qLsMAAAAAAAAAEA95HIlUZ4riWLtG81Dk0vAWn755eOBBx6IXXbZJb7//vs455xzsqWykpKSOOmkk+LYY49dZP0EAAAAAAAAAAAavyaXgJVsuOGG8f7778dll10W9957b3zxxRcxffr06N27dwwePDgOPfTQWGuttRZ1NwEAAAAAAAAAgEauSSZgJT169IjTTjstWxrSl19+2aD7AwAAAAAAAAAAGq8mm4AFAAAAAAAAAEDTVhYl2VKMirVfNLwWC2CfAAAAAAAAAAAAzYIELAAAAAAAAAAAgHoyBSEAAAAAAAAAAI1SWa5FthSjYu0XDc8nDQAAAAAAAAAAUE8SsAAAAAAAAAAAAOrJFIQAAAAAAAAAADRK5VES5UVafyj1jeahOI9AAAAAAAAAAACARkACFgAAAAAAAAAAQD2ZghAAAAAAAAAAgEYpTfNXVqRT/ZmCsPlQAQsAAAAAAAAAAKCeJGABAAAAAAAAAADUkwQsAAAAAAAAAACAeiqt7wMBAAAAAAAAAGBRKsu1yJZiVKz9ouH5pAEAAAAAAAAAAOpJAhYAAAAAAAAAAEA9mYIQAAAAAAAAAIBGqTxKsqUYFWu/aHgqYAEAAAAAAAAAANSTBCwAAAAAAAAAAIB6MgUhAAAAAAAAAACNUnm0iLIirT+U+kbz4JMGAAAAAAAAAACoJwlYAAAAAAAAAAAA9WQKQgAAAAAAAAAAGqWyXItsKUbF2i8ank8aAAAAAAAAAACgniRgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoqre8DAQAAAAAAAABgUSqPkigv0vpDqW80D8V5BAIAAAAAAAAAADQCErAAAAAAAAAAAADqyRSEAAAAAAAAAAA0SuW5kijLlRRt32geVMACAAAAAAAAAACoJwlYAAAAAAAAAAAA9WQKQgAAAAAAAAAAGqWyaJEtxahY+0XD80kDAAAAAAAAAADUkwQsAAAAAAAAAACAejIFIQAAAAAAAAAAjVJ5rkW2FKNi7RcNzycNAAAAAAAAAABQTxKwAAAAAAAAAAAA6kkCFgAAAAAAAAAAQD2V1veBAAAAAAAAAACwKJVFi2wpRsXaLxqeTxoAAAAAAAAAAKCeJGABAAAAAAAAAADUkykIAQAAAAAAAABolMrTVH+5kijWvtE8qIAFAAAAAAAAAABQTxKwAAAAAAAAAAAA6skUhAAAAAAAAAAANErl0SJbilGx9ouGJwELAIBmpfy75RZ1F2iCln1270XdBZqQmaPGRcT5i7obAAAALABiUywIH06fvKi7QBPy3YyyRd0FaJSk2gEAAAAAAAAAANSTClgAAAAAAAAAADRKZbkW2VKMirVfNDyfNAAAAAAAAAAAQD1JwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1VFrfBwIAAAAAAAAAwKJUHiXZUoyKtV80PBWwAAAAAAAAAAAA6kkCFgAAAAAAAAAAQD2ZghAAAAAAAAAAgEapPNciynItirZvNA8+aQAAAAAAAAAAgHqSgAUAAAAAAAAAAFBPpiAEAAAAAAAAAKBRKouSKCvS+kOpbzQPxXkEAgAAAAAAAAAANAISsAAAAAAAAAAAAOrJFIQAAAAAAAAAADRK5bmSbClGxdovGp4KWAAAAAAAAAAAAPUkAQsAAAAAAAAAAKCeJGABAAAAAAAAAADUU2l9HwgAAAAAAAAAAItSebSIsiKtP5T6RvPgkwYAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAapfJci2wpRsXaLxqeTxoAAAAAAAAAAKCeJGABAAAAAAAAAADUkykIAQAAAAAAAABolMqiJFuKUbH2i4anAhYAAAAAAAAAAEA9ScACAAAAAAAAAACoJ1MQAgAAAAAAAADQKJXnWmRLMSrWftHwfNIAAAAAAAAAAAD1JAELAAAAAAAAAACgniRgAQAAAAAAAAAA1FNpfR8IAAAAAAAAAACLUnlElEVJFGvfaB5UwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAapfJci2wpRsXaLxqeTxoAAAAAAAAAAKCeJGABAAAAAAAAAADUkykIAQAAAAAAAABolMpyLbKlGBVrv2h4PmkAAAAAAAAAAGikpk+fHtdee21stdVW0bt372jTpk107NgxVlhhhdhnn33i5ZdfrtN+Hnnkkdhpp52iX79+2T7S33Q7bad2KmABAAAAAAAAAEAj9NVXX8XPf/7zeP/99+dIyvr444+z5YYbbohDDz00LrnkkigpKZljH+Xl5XHAAQfEddddV2X70KFDs+Xee++N/fbbL6666qpo0UKtp+p4VwAAAAAAAAAAoJGZMWNGleSr1VdfPUu2euWVV+Lxxx+PU045JTp06JDdd9lll8W5555b7X5OOumkQvLVWmutFf/617/i9ddfz/6m20mqsHXyyScvtNfW2KiABQAAAAAAAABAo5SLkiiPOas6FUvfFqT77ruvkHz14x//OF544YVo2bJl4f4tttgitt9+++y+lKyVErCOPvroKC2dlS6UKmRdcMEF2fo666wTzz//fLRr1y67PWjQoOzxm2yySbz55ptx/vnnx29/+9tYdtllF+jraoxUwAIAAAAAAAAAgEbm5ZdfLqyfcMIJVZKv8tZee+3Ydttts/WxY8fGhx9+WOX+iy++OGbOnFmokpVPvspr3759tj1J7S666KIF8loaOwlYAAAAAAAAAADQyEyfPr2wPnDgwBrbLbPMMtU+JpfLZVW0khVXXDHWX3/9ah+ftq+wwgrZemqfHkdVErAAAAAAAAAAAGiUynItinpZkPJJUcnnn39eY7vPPvss+1tSUhLLLbdcYfsXX3wR3377bbaephmsTf7+oUOHxpdffjnffW9qJGABAAAAAAAAAEAjs/vuu0fnzp2z9XPPPTfKysrmaPP222/HQw89lK3vsccehfbJBx98UFhPFbBqU/n+2acxJKJ0UXcAAAAAAAAAAACasmHDhs21Tb9+/eZpnz179ox//vOfWSLWSy+9FIMGDYojjjgill9++Zg4cWK27cILL8ymHfzRj36UrVf2zTff1Pm5+/fvX1gfMmTIPPWzOZCABQAAAAAAAABAo1QeJVGeK4li7VveuuuuO9f2uVxunp9j++23j7feeitLrrruuutir732qnL/4osvHmeeeWbsv//+0b59+yr3TZgwobDesWPHWp+nQ4cOhfWU3EVVpiAEAAAAAAAAAIBGKFW3+sc//hH33XdftQlc33//fdx0003x5JNPznHf1KlTC+utW7eu9XnatGlTWJ8yZcp897upUQELAAAAAAAAAAAWoNdffz169+7doPucNGlSbL311vHCCy9Ey5Yt49hjj4199tknBg4cmCVXvfbaa3HGGWfEiy++GDvuuGNccMEF8Yc//KHw+LZt21ZJ5KrNtGnTCuvt2rVr0NfRFDSpBKzx48fHww8/HG+88Ua8+eabMXTo0BgxYkSWede1a9dYeeWVY5tttol99903evToUe0+ZsyYEU899VQ89thj2YH48ccfx7hx47JSaukA3WyzzeJ3v/tdtg4AAAAAAAAAwKJTFiVRVqQTwKW+5aXkq379+jXo/k877bQs+SqZffrBVNFqiy22iE033TS23HLLeOaZZ+KYY47J8l7WWGONrE2nTp3qPK1gSvaq63SFzVFxHoHzkS24++67x1/+8pd4/vnn47PPPsuSslJSVUrEeu655+K4446LFVdcMUuwml1qkw74lB148cUXxyuvvBKjRo2KmTNnZklYb7/9dpYNuNJKK8Ull1yySF4jAADcdOeEOOiY4bHuVkOi3VKfRsven8YNt42vsf34CeVx1KkjYsA6X2btBw76Mo49Y2RMnFRebfvy8lxcft3YWGPTr6PDgM9i8VU+jz1+9118/tWMOdqWleXiz5eMjmXX+zK6Lf95bPmrofHB/6ofJXP1P8dFxwGfxWdfzrkfGodJb3wQw87+e3y1/9nx5W9OiyGHXRDDL70tZo4aW6Vd+eSpMeqfD8fXh54fX+x5agw59IIYffOjUT511gipvLKJU2LE3+6Krw78c3x90Dkx4m93Z9uqM/yy2+ObYy6N3MyyBfYaAQAAgLkTn2JhSsfDLTdMil9uMyLWWWFYrLfKsNjrlyPjmSdmTZ1WkyFfz4xBKw2LVZf6Nk4/sWoMK5k2NRfnnTEuNlv/u9hgjWFx+AGj47th1ceeLj5vfGyyzncxblz1xy0sbGm6weuvvz5bX3755askX1VWWloaZ555ZrZeXl4eN9xwQ+G+yglh33zzTa3PN2TIkMJ6//7957v/TU2TqoCV/5BT9t7aa6+draeEqnQApQPlzjvvjLvvvjtGjhwZ22+/fZawlc/qy5dLSwlXyZprrhk77LBDrLfeerH44otnCViPPPJIXHbZZVmZtiOOOCIrqXbAAQcswlcLAEBzdMq5o+Krb2ZGz+4tovdipdl6TSZNLo9Nf/FNvPPe9Nhik3ax204d4+13p8WFV46N51+ZEs/e0zfatq06LuOgY0bEdbeMj1VWaB2H7tslvv2uLO54YEI88dzkePnBfrHcwFnzwF989dg4+ZzRsfVm7WP5ga3i5rsmxM92HxofvLBUdOwwa7/Dvp8Zx581Kk49unsss3SrBfTOsCAv5Eddd19MeOrNKF28e3T48erRol3rKBszIaZ8+EXMHDE2Snt0zdqWT50ew864LqZ/NSzarb5stP7J6jH9y2Ex7sEXs7a9T9kvWrSedQyMuOLOmPLfT6PjxmumJ4qJL7wT5RMmx+LH/F+VPkx++38x6ZV3o/fpB0RJacuF/h4AAAAAs4hPsTDjUkcdPCaeeGRq9F+qZfziV+1j+vRcPP3E1Dh0v9Fx4uldYo+9O9SYuHXyUXMmXVV2wdnj4tZ/To6ttm0b3bq1iHvvmBKH7js6bn2gZ7RsOaty0f8+nBE3XDUxzrmkW3Tp0qTq3NCIff/99zF69Ohsfa211qq1bcqhyfvoo48K62kmueq2V6fy/alwEU04ASslXn399dc13r/rrrvGvffeGzvttFM2d+Xpp5+eJWTllZSUZOXX0vyX66+/frX733nnnbO/aVrDNHdmqrhVuSQbAAAsaFdfuFgsN6BVLNW/VZx72Zg48U8Vgwiqc/5fx2TBrWMP6Rp/PqlnYfsJZ4+M8y4fmwWojj+se2H7My9NzoJbG6/fNh67rW+0bl0RZNh9p46x7f8Ni0NPHBGP3tq30P7am8fHZhu3iwdv6pPd3mmbjjF4p6Hx4BOTYrcdZ/07+ZATRsTAJVvFkQdWJOnQuIx/9JUs+arTFutFj71/HiUtqgaZcmWzRgWOe+CFLPmqy/YbRffdtypsH/2vx2Lc/S/E+Idfjq47bpJtm5kSuN7+X3TbdfPoutPgbFtpr24x9o6nYubYCVHateIYSpWzRl5/f3Tecr1ou5yRVQAAALCoiU+xsDzx8NQs+WqtdVrHNTf3iLZtK46Hw48ti19tNzIu+NO42GSzNtG3/5ypD/+4dlL859/T46gTO8e5Z4yvNkHr7tsmZ0ldp59bcVystlbrOPHIsfHef2bEGj9qXaiydupxY2PDwW3iZ9u2W+CvGeoqVbbKSzO71SbNHFfd4wYMGBB9+vSJb7/9NptVrjZpJrqkb9++sfTSS89Hz5umJpWa2bLl3EdB77jjjrHCCitk6/l5MPPSQfL4449Xm3yVlypiHXzwwdl6qor1xBNPzHe/AQBgXmy+cfssuFWX0WEpWNWxQ0mcfOSsIFaSbqft6f7KUsAqOf3YHoXgVrL1Zh1i8E/axRPPTYmvv5l1oTZk6MxYe/U2hdvrrNGmsD3v7ocmxgOPT4qrL+wVpaWz9knjUD59Roy965koXaxb9NhrmzmSr5KSH67F0jE34Zk3o6Rt6+i606ZV2qTbaXu6P69s1Ljsb+sBFQHSpM3AigBq2ciK+5Ixtz4RkYvottsWC+AVAgAAAPNKfIqFJVW6Svb/fcdC8lXSrXvL2HPfDjF9WsQ9d0ye43GffzojLrtgfOx3cMdYYeXqj9Uxo8tj2rSIlVebdf8qP6wP+3bWgMObrp8UX3w2M04+S/JescrlSqK8SJfUtwWle/fu0blz52z9lVdeqTUJq3JyVUq6qlyoKM0Ol69w9eqrr1b7+LQ9XwErtU+PowknYNVVvmJVmkqwPlIFrLzPPvuswfoFAAAN6ZPPZ2Tl2X8yqF10aF/1n/7pdtr++VczY8jQWQGr516eEh3al8QG67adY39bDm5f0eaVKYVt/fuWZiXj8/79w3ranowbXxaHnTQijjiga/xo9Tn3SfFL0wOWT5oS7ddZOaI8F5Nefz/G3vdcjH/i9ZjxXdXRrTO/G5VNS9h2+aWiRdtZUwEk6XbaPnP4mJg5qqL0e8seXbK/aYrCvOlffFtxX8+K+6Z+MiTGP/5a9Pzt9tGi7axgKgAAAFD8xKeYXyNHVCRC9e0/ZzGWfj9UvXr95elVtqeKVScdNTaWHFAaBx5a82xW3bq3iDZtIj56f9bx9+F7Feu9+1Q839AhM+Pyv0yII47tHEv0nntBGFiYWrRoET//+c+z9VTB6uyzz6623ZgxY+K4444r3N52222r3H/EEUcUCh4deuih2YxwlaXbaXu+elZqTxOfgrAu/ve//8U777yTra+44or12se0lAY7D1W3AABgUfjki4pgwXIDqx/hlbY//mxFu/59W8WkyeUx7PuyWHXF1tGy5ZyjV5YdULGfT3/Yb7LvHp3juDNHxXZ7fhvLD2wVN981Mfos0TK23aJDdv+xZ4yKdm1L4vRjqo5wpPGY/sXQ7G9Ji5IYetzlMWPYyFl3lpRE521+Ej3+b+vs5oxhFQlZrZboUe2+0vYp//0ka1fao2uUdusU7dZcPsbc+XTMGD46azPx+Xei/Y9WzKYfzM0si5HX3Bsd1l812v+oopIxAAAA0HiITzG/UqWrZOiQslhmuarH0TdDKqr9fPlF1ao/1/51YpZIdfO9PaNVpSpqs2vRoiR22rV93HbT5Jg0MRddu7WIe++cHCut0ipWXaPiuU4/cVyssFJp7PabiuQ/KDannHJK3HfffTF58uQ47bTT4q233oq99torBg4cmBUlSpWrLr744vj666+z9ptttllsueWWVfax/PLLxzHHHBPnnHNOvPnmm7HBBhtkCVvLLLNMVpTo3HPPjbfffjtrm9ott9xyi+S1FrtmkYCVDrShQ4fGAw88EOedd16h7Fp9s/Iql2ZbaaWVGqyfAADQkMaNL8/+dulUfeHbzh1bVGk31/Y/bM+3S448sGtMm5aL6/81Pl58bWoMWrNNXHxmr+jYoUU2WjGVkH/01j7RqlVJHH3ayLjhtvExeUouthrcPq66oFcs1rNZXJI0amXjJmV/xz38crQe0Dv6nHVQtOrbK6taNfKa+2L8Qy9Fq8W7R+ct1ovyKRVVhkvaV1+pKr+9fMqsQS29fr9LjP7HwzH5rYry1R03XD26/9822XqqtFU2Znz0OGmfKBs7MUZed19M+c8nUdK6NDpusnZ0//VW1U6JCAAAABQH8Snm14aD28Qj90+J666cGOv9pE20+WEawrFjyuOm6yriVhMqHQ8ffTAjrrx0Qux9YMdYZbWqFdqrc/TJXaK0VUk8/tCUmDo1Fz/esE2ccHqXLAHwvrsmxxuvTos7H+oVUybn4uxTxsbjD1fEv7bcpm2cdGaXaD9bZTcWjfJokS3FaEH3KxUeSglYu+++e4wcOTLLi0lLdX7605/GHXfcUe19qXrW8OHD4/rrr8+SrXbbbbc52uy7775x1llnNfhraCqa7K/JDTfcEPvss0+N9x9//PGxxx57zPN+hw0bFn//+9+z9V69elWZjrCuvvnmm7k+BwAANAYpEHHSkd2zpbKpU8vjoGOHx56/7BSbb9w+zrl0dFxxw7i48PSe0a93aRx24ojY5/Dh8dDNfRZZ36mjXC77U1LaMhb/w6+jtHvn7HbbFZeOxY7YLauKNe6hl7IErPpo2bF99Dp4lzm2Tx86PMbd93z02Hf7aNmlY3z35xti+rcjotdhv8qmORz9z4ez7V2332g+XyBA8yM2BQBAUyI+1bT9fId2cd8dk+P1V6bHTlsNjw03aRszZubi6cenRo+eFYktLX4ocjVjepp6cEwsuVRpHHx4zVMPVta2bUkcf2qXbKls9KiyOP/M8bHfwR1jmeVbxeknjI1nHp8ap/25SyoKH2edPC577B/P7trwLxrm0eabbx4fffRRXHfddfHII4/E+++/H2PHjs2mC1xiiSVi0KBBWX7M9ttvHyXpAK5hOsP0+J133jmuvvrqeOONN7KErp49e2aPP/DAA2PrrStmQqCZJWDVZM0118wOlnSAzKtcLpcdVBMmTMhu//GPf4y2bed9nuD+/fvP82MAAGBeden8w4jACbNGgFU2fmJ5lXZzbf/D9ny72pz5lzExdlx5XHhaz+z2pdeOiz136RS/26tLYV+/OeT7+N+n02OFZec+Eo1Fp0X7imue1gP7FJKv8lr3XzxKF+8eM78bFWWTpkSLdhVtc5NnVbiqLL+9RbvqK2QV2uVy2dSDbVZYKjpt8qOYPnRETPnvp9HrkF9Gh3UqqhBP+2JojH/kJQlYAPUgNgUAwMIiPsX8Ki0tib/d2COuvXJiPHzf5LjjX5OiU6cWsdlWbWPvAzrGzwcPj+49K6YpvOaKifHJRzPjprt7Rus2NU89WBfnnDY+S/A64PedYtLE8rjn9slx8JGd4uc7VkxFOOTrsrjykglx1Imdo32H4qy8RPPSo0ePOPbYY7NlfmyzzTbZwrxrsglYO+64Y6yzzjrZ+pQpU7J5KW+//fa45557stJraY7Lbbfddp72+ac//alQqi1Vvvr973+/QPoOAAANYbkBrbK/n3w+o9r789vz7Tq0bxG9F28ZX3w9I8rKctnowco+/aKi/bI/tK/Jfz+YFhdcOSZuvGzx6N6tZYwbXxbfjyiLNVedlXSz1g/rHwlwFb1WvSuClC3bt6s1QSs3fWa06t0jW5/x3ahq2+a359vVZMITr2dTHPY999CKxw0bmf1tvVTvQps2S/eJic+8FeWTpxb6AAAAABQX8SkaQkqmOviITtlS2euvVAz2W2W1iuPho/dnRHl5xB47VsSSZnfHzZOz5adbto1Lr6laMa2y55+eGo8+OCVuvKNntGpdEp99OjNmzoxYceVZx91Kq7SKmTMivv6qLFZcWQLWolaWK8mWYlSs/aLhNdkErK5du2ZLXqp4leao/Oc//xl77bVX7LDDDln5tL333rtO+7v55puzilfJgAED4pZbbslKsNXHkCFD5lrmfd11163XvgEAIG+5ga2izxIt4+U3psSkyeVZACsv3U7bByxZGv37zgocbPzjdnHbvRPjpdenZuuVPf7s5Io261efiJOkwNgBRw2PLQe3j912rBoQmTYtN2t9+g/T2tVQ7pji0XaVAdnfNP3f7HIzy2Lm96OipE3raNm5fUTXjtGyW6eY+vFXUT51erRoOyt4mW6n7aWLdYvSHjWXZp85enyMvvXx6LbLZtFq8aqBsNyMmZWee9Y6APNGbAoAgIVFfIoF6aF7p2R/t96+4nj48YZtomu3Of8f/ojhZfHCM9NiwDKlsdY6rbPkqZpMnlQeZ548Ln71f+2ztpVN/+GYqbzu8AHyml0q5p577hm//OUvo7y8PA455JAYPXr0XB/z0EMPxT777JNNg5Hmx3ziiSeyv/XVr1+/WpfevWeN6gYAgPpKwaN99+gcEyfl4qyLqv67N91O2/f7ddUp5fb/v4rbp543qkpA4ZGnJsWzL0+JLTZpF0v1rzlAcek1Y+PDT6bHFef0Kmzr0rllNnLx4acnVdlfstJytY9WZNFrtXiPaLf6stk0gxOefrPKfWPvfz7KJ02N9oNWipKWLbNjrtOm60Ru6vQYe88zVdve80y2Pd1fm1HX3x+tlugRnbf5yaw+9KmowjXlnY8L2ya//XGW7KX6FcC8E5sCAGBhEZ+iIUysZkrKxx+akk0LuOoarWLzn1XEh3bfq0OccV7XOZZ9DuyY3b/O+q2z26ldTS4+b0KUl+fiiONmHZdLLtUySltFlsSVl9ZbtY7ov1TF9IcATbYCVm1S9as0HeGkSZPi0UcfjT322KPGts8++2zssssuMWPGjOjWrVs89thjscwyyyzU/gIAQGXX3jwuGwGYvPfh9Ozv9TePj+derhjxtcG6bWO/X3fJ1o/5fbe4/7FJcd7lY+Ptd6fFj1ZrE/9+d1o88dyUGLRmmzh8/6qViDbdoH0WFLvulvGxzpZDYpvN28ew78vi9vsnRPduLeLSs2cFrmb35ZAZcer5o+NPJ/aoMmoxOWy/rnHC2aNi2//7Nvr1Lo2/3zo+fr5F+1huoPLujUGP324X355ydYy85t6Y9OaHWUJUmiJw6vufR2nPrtH91z8rtO2y3UYx+a0PY9z9L2RtWi/dJ6Z/+W1M+e+n0XqZvlUSq2Y38ZV3Y/I7H0efMw+KkkoVh1v36RXt1lguxtz1dMwcOTZmjp0QU9/7rMrzAgAAAAuP+BQL0+47jIwl+rSMgcuWRps2JfHuO9PjjVenR78lW8Zfrug2x1SV9fWff0+PW/8xKZuesEPHWbGp9h1axC9+1T5uv2lyTJ1SkRT40H1TYo+9OkT7SlXdWHTKcyXZUoyKtV80vGaZgNWr16wf5a+++qrGdq+//npst912MXXq1OjYsWM88sgjsfrqqy+kXgIAQPVScOsft0+ouu2NqdmSlw9wpbLuz9zdN06/YHTc/VDFKMHei5XGHw7qGqcc1T3atZszQPC383vFaiu1jmtuGh+XXjsuOrYviR237hhnHd8jllm65hGBBx0zPHvcwftUPHdlR/2ua4waUxY33Do+nn0pF9tt2SH+dt5i8/lOsDCrYPX90+9izB1PxZT/fJIlU7Xs2jE6bbledPvFptGyS8UowiRNO9j7lP1izJ1Px6TX348p738RLbt1jM4/3yC67fzTaNG6+mOobOKUGH3jQ9Flmw2izYA+c9zf63c7x8jr74+JL/0nSlq1yhK9akvmAgAAABYc8SkWpp9t1zaefHRq/Pft6TFzRi769i+NAw/tmFW26tipYRKgZszIxWnHj40ttmkbgzefs+L60Sd1jhnTI554pCLJMCVk/eHEqtXbgOatJJfm1WtmbrjhhmxKweTSSy+NQw89dI42//3vf2Pw4MExZsyYaNu2bZZ8lW4vDN988030798/Wx8yZEhW+h0AgIZR/t1yi7oLNEHLPrv3ou4CTcjMUeNiyCHnZ+uuCYFFQWwKAGDBEZtiQfhw+uRF3QWakO+GlcXm639f9NeEla9d93lk++i0ePsoRhO+nxx/3/r+on8/mX/Nsh7eHXfcUVhfbbXV5rj/448/ji233DJLvmrVqlXcddddCy35CgAAAAAAAAAAaDxaNLXKVmm6wNpcdNFF8fDDD2frAwYMiI022qjK/V9//XVsvvnm8f3330fLli3jlltuiW222WaB9hsAAAAAAAAAgHmXy7WI8iJdUt9oHkqjCTnttNPiqKOOip133jk23HDDWGaZZaJjx44xYcKEePfdd+Pmm2+Ol156KWvbunXruPrqq7Mkq7xRo0ZlyVep7FuS9rXiiivGe++9V+NzduvWLfr27bsQXh0AAAAAAAAAAFBsmlQCVjJ69Oi45pprsqUmaU7N66+/Pku2qiwlaX3yySeF2+edd1621GavvfbKKm8BAAAAAAAAAADNT5NKwHrsscfioYceyqpcffrpp9k0gqmqVbt27WKxxRaLNddcM7bddtvYddddo3379ou6uwAAAAAAAAAAzIeyKMmWYlSs/aLhNakErBVWWCFb/vCHP9Tr8YMHD45cLtfg/QIAAAAAAAAAAJqmFou6AwAAAAAAAAAAAI1Vk6qABQAAAAAAAABA81GeS0tJ0faN5kEFLAAAAAAAAAAAgHqSgAUAAAAAAAAAAFBPpiAEAAAAAAAAAKBRKs+1yJZiVKz9ouH5pAEAAAAAAAAAAOpJAhYAAAAAAAAAAEA9ScACAAAAAAAAAACop9L6PhAAAAAAAAAAABalXJREeZREsfaN5kEFLAAAAAAAAAAAgHqSgAUAAAAAAAAAAFBPpiAEAAAAAAAAAKBRKsuVZEsxKtZ+0fBUwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAapfJci2wpRsXaLxqeTxoAAAAAAAAAAKCeJGABAAAAAAAAAADUkykIAQAAAAAAAABolMqjJMpzJVGsfaN5UAELAAAAAAAAAACgniRgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoqre8DAQAAAAAAAABgUcpFSZRHSRRr32geVMACAAAAAAAAAACoJwlYAAAAAAAAAAAA9WQKQgAAAAAAAAAAGqXyXFpKirZvNA8qYAEAAAAAAAAAANSTBCwAAAAAAAAAAIB6MgUhAAAAAAAAAACNUnmuRbYUo2LtFw3PJw0AAAAAAAAAAFBPErAAAAAAAAAAAADqyRSEAAAAAAAAAAA0SuW5kmwpRsXaLxqeClgAAAAAAAAAAAD1JAELAAAAAAAAAACgniRgAQAAAAAAAAAA1FNpfR8IAAAAAAAAAACLUnmUZEsxKtZ+0fBUwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAapVyuJMpzJUXbN5oHFbAAAAAAAAAAAADqSQIWAAAAAAAAAABAPZmCEAAAAAAAAACARqm8iKcgLNZ+0fBUwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAaJVMQUgxUwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1JAELAAAAAAAAAACgnkrr+0AAgAWt/LvlFnUXaIJWfHHPRd0FmqCyKS6taDhlUx1PAABQDMSmWBA+njFpUXeBJuj7sk6Lugs0ISPLZkRjU54ryZZiVKz9ouGpgAUAAAAAAAAAAFBPErAAAAAAAAAAAADqybwGAAAAAAAAAAA0Srk01V+UFG3faB5UwAIAAAAAAAAAAKgnCVgAAAAAAAAAAAD1ZApCAAAAAAAAAAAapfJcSbYUo2LtFw1PBSwAAAAAAAAAAIB6koAFAAAAAAAAAABQT6YgBAAAAAAAAACgUSqPIp6CMIqzXzQ8FbAAAAAAAAAAAADqSQIWAAAAAAAAAABAPUnAAgAAAAAAAAAAqKfS+j4QAAAAAAAAAAAWpfJcSbYUo2LtFw1PBSwAAAAAAAAAAIB6koAFAAAAAAAAAABQT6YgBAAAAAAAAACgUTIFIcVABSwAAAAAAAAAAIB6koAFAAAAAAAAAABQT6YgBAAAAAAAAACgccqVRK5Yp/or1n7R4FTAAgAAAAAAAAAAqCcJWAAAAAAAAAAAAPVkCkIAAAAAAAAAABql8ijJlmJUrP2i4amABQAAAAAAAAAAUE8SsAAAAAAAAAAAAOpJAhYAAAAAAAAAAEA9ldb3gQAAAAAAAAAAsCiV50qypRgVa79oeCpgAQAAAAAAAAAA1JMELAAAAAAAAAAAgHoyBSEAAAAAAAAAAI1SLleSLcWoWPtFw1MBCwAAAAAAAAAAoJ4kYAEAAAAAAAAAANSTKQgBAAAAAAAAAGiUynNpKSnavtE8qIAFAAAAAAAAAABQTxKwAAAAAAAAAAAA6skUhAAAAAAAAAAANEq5XEm2FKNi7RcNTwUsAAAAAAAAAACAepKABQAAAAAAAAAAUE8SsAAAAAAAAAAAAOqptL4PBAAAAAAAAACARSmXK4nyXEkUa99oHlTAAgAAAAAAAAAAqCcJWAAAAAAAAAAAAPVkCkIAAAAAAAAAABqlXDbVXxSlIu0WC4AKWAAAAAAAAAAAAPUkAQsAAAAAAAAAAKCeTEEIAAAAAAAAAECjVB4l2VKMirVfNDwVsAAAAAAAAAAAAOpJAhYAAAAAAAAAAEA9mYIQAAAAAAAAAIBGKZcryZZiVKz9ouGpgAUAAAAAAAAAAFBPTS4Ba/jw4fHggw/GKaecEltvvXX07NkzSkpKsmXvvfeu1z6ffPLJ7LHLLrtsdOjQIbp06RLLL7987LLLLnHllVfGxIkTG/x1AAAAAAAAAAAAxa/JTUG4+OKLN9i+xowZE/vss0/cd999c9w3fvz4+OSTT+Kuu+6KH//4x7Hmmms22PMCAE3HTXdOiBdfmxL//u+0ePejaTF9esR1Fy8We/+qc7Xtx08oj9MvGBV3PzQpvhsxM3ovVhq7bNcxTjmqe3TsMGfufHl5Lq74+7i45qbx8emXM6Jj+5LYbOP2cdbxPWLgUq2qtC0ry8V5l4+J624ZH6PGlMegtdrExWf0ipVXaD3Hfq/+57j4wykj4z/PLBnLLF11PzQOE1/7MMY+9npM+2JY5KbNiJZdO0bb5ftFz//bMlr17JK1SfdNeOX9mPb5tzHt82FRNmFytFt56eh3+j7V7rN8+owYdctTMfHV96N82oysba/fbh2telTsr7KRtzwZ459+O5a6+JBo2bHdAn+9LFhDjzknykaNrfa+NisMiMWPO3CO7WXjJ8b4h56JKf/5KGaOHhct2rSO0iV6Roef/Cg6bbp+oV2uvDzGP/xcTHz+jSifNCnaDOgf3XbfLlr1nfPabuKzr8WYWx+MJc44Ilot1qOBXyUAAEDTIzbFwpaOiX/9Y3Lcdfvk+OLTmdGytCRWXLlV/PaADvHTLdvW+tghX82MHbcaGZMn5+JXv24fp/25asxp2tRcXHTehHjsoSkxZUouBq3fOk46vUss0bvlHPu66NzxcfftU+LBp3pFl65NriZJszyu7r9pbDxyx/gY8tn07LhaZqU2sev+3eInm3eco/2kCWVx4yWj4oVHJ8aYkWXRvVfL2GSbTvGbw3pEu9nOZRPGlcWVZ42I156dFCUlEesN7hAHndQrOnWZ87g6+/Bh8fn/psVVDywVpa1MKwc08QSsypZccslYccUV4/HHH5/nx44bNy622GKLeOutt7LbO+20U1bxaplllomWLVvGkCFD4rnnnssSsAAAanLKuaPiq29mRs/uLbKAVVqvyaTJ5bHpL76Jd96bHlts0i5226ljvP3utLjwyrHx/CtT4tl7+kbbtlUvDg86ZkQWtFplhdZx6L5d4tvvyuKOBybEE89Njpcf7BfLDZwVwLr46rFx8jmjY+vN2sfyA1vFzXdNiJ/tPjQ+eGGpKgG0Yd/PjOPPGhWnHt1dgKsRyuVyMfzqB2L8k29Fq8W7R6cNVo0WbdvEzDETYsoHX8bMEWMLCVgT3/goxtzzQpSUtoxWvXtkCVi1GfmPx2Pc429Exx+vEi07tY/xz74dw879V/T/8wFR0nLWMTTtq+9izP0vxRKH7Sz5qgkpadc2Om2xwRzbS3t2m2Pb9K+/jeEXXhflk6dEu9VXjPbrrBbl06bFjG9HxJR3PqySgDXh8Rdj3N2PRdvVV4hWi68Uk155J4b/5broffZR2bGbVzZ2fIy545HossPmkq8AAADqSGyKhR2XOvJ3Y+PxR6bGkku1jJ13ax/Tp+Xi6Semxe/3GxMnn9E5fr13hxoTbE44alyt+z/v7PFZctfPtm0b3bq3iHtunxIH7zs67nigZ7RsOSsZ5n8fzojrr5oU513SVfJVEzmuzjhkWJZM1WepVrH1rl1ixvRcvPTExPjjAd/Goaf1ih1/Mys+NWVyefxh92/i0w+mxTobtY+fbtcmW7/9mjHxn9cmx8W39Y/WbWYdF3/+w3fx1ouTYoudOkcuF/HEPeNj3JiyOOuavlX68dozE+PZhybEJXf0l3xVhMpzJdlSjIq1XzS8JpeAlaYeHDRoULakalhffvllDBgwYJ73c+ihh2bJV23atInbb789tt9++yr3r7POOllS1kUXXRRlZWUN+AoAgKbk6gsXi+UGtIql+reKcy8bEyf+aVSNbc//65gswHXsIV3jzyf1LGw/4eyRcd7lY7Mg1fGHdS9sf+alyVmAa+P128Zjt/WN1q0r/hG/+04dY9v/GxaHnjgiHr111kXitTePj802bhcP3tQnu73TNh1j8E5D48EnJsVuO3YqtDvkhBExcMlWceSBXRv8/WDBG/vwq1nyVZetBkWvfbapkhiV5Cr92zUlUnVYZ4Vos+TiWfLVFwdcUON+sypFT/87Ov90rVj8oB2ybW2X6xffX353TP1saLRbvv8P+y+P76+8PzqsuVx0+smqC+x1svC1aN82uu64xVzblU+ZGiMu+0e2vsQph0br/r1rPAaTic+9Hm1XXjYWO6Ki8lq7tVeN4edclVXO6rDeGoV2o2+6L0p7dY9OW27YQK8IAACg6RObYmF6/OGpWfLVj9ZpFdfd0iPatq04Jo48rjx22XZklkA1eLM20bf/nP+L+sZrJ8V//j09jj6xc5xzxvhqE7TuunVy7PyrdnHmeRXHxuprtorjjxwX7/5nRqz5o9aFSmt/PHZcbDS4TWy9nYGBTcHzj0zMkq9WXbttnPfPftHmh0TQfY/uGb/b4av4259Gxvo/7RhL9KtI2LztqtFZwtVuB3aL/Y/rVdjPNeeOiFuvGhN3Xjc29ji44lw2avjMeO2ZSfHbo3rEr39fMeAv7eeGi0bF6BEzo3uvimN1yqTyuPiPw2OHPbvGyms5roDqNbmU39NPPz223Xbb+ZqK8MUXX4x//vOf2fpZZ501R/JVZSUlJVFa2uTy2ACABrL5xu2zAFddRvGkgFXHDiVx8pGzAllJup22p/srS0Gr5PRjexQCXMnWm3WIwT9pF088NyW+/mZGYfuQoTNj7dVnVZNZZ402he15dz80MR54fFJcfWGvKC01KqOxSdMCjr7juWi1eLfotc/WcyRfJSUtZ5XObtN/sWg7sE9WAWtuUoJWbsbMaDOwIkiatF2mYn3myHFVEsBmfDsyeu3/8wZ4RTRGE55+NZuusOsuP5sj+Wr2YzApGzMuWi81KyDfeul+FdtHz5rycPJb72WVs3rss/McjwcAAKBmYlMsTE89Pi37e8AhHQvJV0mqVrXXvh1i+rTIpgWc3eefzoxLzp8Q+/++Y6y0SvX/33XM6PKYNi1ildVmHc+rrl6xPmzorMFe/7x+Unz+2cw45eyq0xfSeL385MTsb0qayidfJV26t4ydf9stq4b16B3jCueyh28fF+06lMT/HVq1gnq6nban+/NGDKs4Ry236qzpMZdfrWJ9+Lezzl/XXTAyIleR9AXQbBKwGsLll1+e/e3SpUsccsghi7o7AEAz8MnnM7IS7T8Z1C46tK/6T7R0O23//KuZMWTorIu+516eEh3al8QG6866OMzbcnD7ijavzApo9O9bmpWNz/v3D+tpezJufFkcdtKIOOKArvGj1efcJ8Vv8n8/i/JJU6LDoBUjV56Lia99EKPveSHGPv5GTB9W8wjXukhTDpa0Ko1pXwwrbJv6w3rpD1Mazhg+Jkbd9kz02GOzaNVDkKupyc0si4kvvhnjHnwmJjz1ckz77Otq201+4z9ppEq0X3u1mDFsREx48qUY/8hzMfntDyI3c86pLlp265JNWZg346uhFdu7V4xmLZ88NcbcdF9W+apyohYAAAANR2yKhjByREUiVL/+cw6eym977eVZx0C+YtUJfxgbSw0ojYMO7VjjvlMSV5s2ER++Pyu28MF7Feu9+1bse+iQmXHZhRPjyOM6xRK9DeBqKkb/cFwtUU0yae8ftr39w7nmmy9mxKjvy2LVtdtFu9nOZel22j7s6xmF5KpevSse/+n7s47LT9+fmv1drE/FfR+8PSXu++fYOPzMxaJdpelSKS5p+shiXmgelG6azfTp0+O+++7L1rfYYoto27biH3hpmsFvv/02+7vEEksUtgMANIRPvvhhpM3A6kckpu2PP1vRrn/fVjFpcnkMSxeSK7aOli3nHA247IAfLhx/2G+y7x6d47gzR8V2e34byw9sFTffNTH6LNEytt2iQ3b/sWeMinZtS+L0Y6qOcqTxmPZZRRJLSYsW8fVRV8SMyklXJSXRddsfR6/fbFWvfad9pukHxz3+ZpRPmR4tO7WL8c++E20G9I62y1QkxQy/+oFos/Ti0WWrdRvmBVFUysdNiNHX31llW+sB/aLHgbtHq8UqRhSmBKsZ33wfLTp1iAlPvRTj7n2ySoQhTSHY89DfROt+SxS2ddx4UIy945EYfvEN0WqJnjHplbejZdfO0W6NFbP7x9z+cJS0bhVd6jD9IQAAAPUjNkVDSElSyTdDymKZ5aoeS2lb8uUXs6pVJVf/dWJ88N6MuPXenlUqqc2uRYuS+MWv2set/5wckyaVR9duLeKeO6bESquWxmprVDzXqSeMixVWKo09flORAEjT0KVbRTLdd0NmxFLLzqqilwwbUnGO+eaL6dnfoV9W/O27dMWUlLNL2994fnIM/XJGlmDVY7HSWG9wh7jxkpExbMj0LIz1xD3j48ebdcimH5w5Ixd/OeH72GSbTtk0hwC1kYA1m//85z8xdWpFVutqq60W48ePj1NOOSVuvPHGGDu2YgqM1q1bx8YbbxwnnXRSDB48eBH3GABoCsaNL8/+dulU/Qiazh1bVGk31/Y/bM+3S448sGtMm5aL6/81Pl58bWoMWrNNXHxmr+jYoUU2YjGVkX/01j7RqlVJHH3ayLjhtvExeUouthrcPq66oFcs1tM/HYvdzPGTsr9jHnwlS4zq/+cDonXfnjHty+/i+6vuj7EPvJxNT9i1nglSPffcKpv+bcIr70du+sxov/oy0eu3FVMdjn/unZjy/pfR/7yDIjd1enx/3cMx8dUPssd1XH/lWGy/n0eLttUHPih+HTdcJ9osv3S06rtElLRpHTO/HxnjH3shJr/ydgw//5rofcaR0aJdm6wCW5SXR/nEyTHu/qej6y+3jg4/+VHkyspi4rOvxfgHn4kRl9wQff50VJS0qgiOdtpqoyxxa+ILb8a0T76I1kv3j+57bBct2raJqf/7PCa98EYs9offZsfZmFsfjEkvvZVNt9luteWj+16/iJadBb8AAADml9gUDWGjwW3i4funxjVXTIr1f9Im2vwwDeGYMeXxj+sr4lbjKx0TH30wI668ZGL89sAOscoP0wnW5tiTO0dpacRjD02NaVNz8ZONWsdJp3fJkgDvvXNyvP7q9Lj74Z4xeXIuzvrjuHj84Yr/57vlNm3jj2d1jvazVUSicVh3cId45sEJ8a+/jYm1ftI+Wrf54fwypizu/vuYbH3ShPIqfzvUcG5q/8O5bNKEWYmAx/9libjirBHx8pMVx+hm23eO353cK1u/5crRMXL4zDj/pn4xesTMuOjk7+ON5yZnx/bPftklDji+Z7VJqEDz5F8qs/ngg4r/SZSUl5fHOuusE5988skcVbKefPLJeOqpp+LPf/5zHHfccfP0HN98802t9w8bNmtaFwCAhpIuBE86snu2VDZ1ankcdOzw2POXnWLzjdvHOZeOjituGBcXnt4z+vUujcNOHBH7HD48Hrq5zyLrO3VUXlFpqKS0ZfQ5drco7d45u91upaWi9x92ja+PvjLGPvBKvROwWrRpFb322TpbKps5blKMuPGx6LbTRtGm/2JZstekNz+KxQ7cLkpKSmL4tQ/GyDatYrH9t22AF8mi0GWHzavcbr1kn+i5/69iZJpy8JW3Y+Lzr0fnlEj1wzGYkrA6bb5BdP7ZxoXHdN1py5j53ciY/MZ/Y/Kb70WHH69VqK7WZbvNsqWy3IwZMfqGu6PDT9aKtqssF+MeeiYmPP1qdNt922jZrXOMufn+GHXdHbHYkfssjLcAoEkRmwIAFgWxqaZv2x3bxb13TonXXp4e2285IkvImjkj4qnHp0aPnhWJLy1+yFWZPr1i6sEllyqN3x/RqU77b9u2JE48rUu2VDZ6VFmce+b4OODgjrHs8q3i1OPHxdOPT43Tz+mSisLHGSeNi7btSuLUs6s+jsZhs+07xWN3jYt3XpkS+/3sqxi0SYesMtVLT0yMbj0rqmOlz7m+OndtGcdfMKtae95Xn06LW64YHUectVh061kax+31TXz92fQ45fLeMer7mfHXM0dkz7/bgar2FYVcSeRyRZoMV6z9osFJwJrN6NGjC+vnnntuVg3rZz/7WZxxxhmx+uqrZxWx7rrrrjj++ONj3Lhx2d8VV1wxdthhhzo/R//+/RdQ7wGAxqpL5x9G7fwwQmd24yeWV2k31/Y/bM+3q82ZfxkTY8eVx4Wn9cxuX3rtuNhzl07xu726FPb1m0O+j/99Oj1WWFYFo2LWon1FCe42y/QpJF/ltVly8az61YzvRkfZpCnRskO7BnveEX9/JEq7dIjuO20U5VOmxfhn3o4eu24anTdaPbt/xvejY9Qdz0XP/9siq5JE09Fp8HpZAta0T7+M2GqjaNF+1lTt7dZaaY727dZcKUvAmv7FN4UErJqMu/+pKJ8yNbr+qiJxb8ITL2XVtDptun52OzdlWoy65raYMWxEtOpdMSoRgLoRmwIAZic2RUMoLS2Jq2/sHtdcMTEevG9K3H7L5OjUqUVsvlXb2OfADrH1JiOi+w8JM9f8dWJ8/NHMuOWeHtG6zfwlJ/zptPHRo2fLOOCQjjFpYnncffvkOOQPnbKEsGTI1zPjiosnxtEndooOHVTBamxalpbEn6/vG7f+bUw8df/4eOjWcVmFqw227Bi77tct9trsy+jao2WVylf5Slizm/zDuaxDp4r2NcnlKqYeXG1Qu/jZLl2yxKs3X5gcJ160RPxk84pq7B+/NzXuun6MBCygQALWbCZNqigtmKTkqy222CIefPDBaNmy4iTcq1evOOigg2LVVVeNTTbZJKuSdcIJJ8T222+fje4HAKiP5QZUlNj+5POKOetnl9+eb9ehfYvovXjL+OLrGVFWlpujzPGnX1S0X/aH9jX57wfT4oIrx8SNly0e3bu1jHHjy+L7EWWx5qqzkmTW+mH9I0GuopemG0xaVkqCqaxFh4rtafrA6NAwzznp3x/HxJffi35n/jZKWpXG9KEjI8rKo83Ss0aNpekQo6wsZnw/psp2Gr8WHSsOpNy0inNOizats+pUZWPGR4v2cyb55bel6la1mT5kWIx/9Pnosd+vomXH9lE+eWqUj58YrZfsXaUKVzLju+ESsAAAAOaT2BQNJSVT/f7ITtlS2euvTMv+rvrDVIMfvj8jFdCO3XYYVe1+brt5crZstmWbuPzamhNcnnt6ajzywNS46c4e0bp1SXz+6cyYOTNixZVn/W/wlVZpFSkUMeSrslhxZQlYjVGadvA3h/fIlsreeXVy9neF1Srinn2XrjhHDP1yerX7yW/vu3Tt56b7bxoXn34wLa55ZKns9pDPKx63zMqzzk3Lrtw2Hr5tfEwcXxYdO9ee0AU0DxKwZtO2bdX/WZWqYOWTryrbcMMN4xe/+EXceeed8eGHH8a7776bVciqiyFDhsy1zPu669ZvWhgAoHFabmCr6LNEy3j5jSkxaXJ5FsTKS7fT9gFLlkb/vrMuDDf+cbu47d6J8dLrU7P1yh5/tuLCc+P1a65ylIJjBxw1PLYc3D5227FqQGTatNys9ek/TGsn2bzotVtlQPZ3+tARc9yXm1mWVb8qSQkynds3yPOlalfDr3kwumw5KNqtsGTV55tRNue6Q6jJmfb519nf0p7dCtvarLhMVhVrxrfDo/VSfau0n/Ht99nflpXazy5XXh6jb7gr2q6yfHRYb42q96UI6hzrDiyAeSU2BQDMTmyKBe2Be6Zkf7fZruL/xf54ozbRtfucyVAjhpfH809Pi4HLtoy11mmdJU/VZNKk8jj9pPGx257ts7aVTZ8+57pDqOl56r7x2d9Nt6s4h/Qb0Cp6LN4y3ntrSkyZXB7tKp3L0u20vXf/VrFYn5qPqxHfzYjrzh8Zex3RI/osWfW4mvHD+ajyuuOqOOSKeArCYu0XDU+K72w6dZr1D7xU7WqttWqeFmOrrbYqrL/xxht1fo5+/frVuvTuPWtUNwDQPKQA0r57dI6Jk3Jx1kWzpkRO0u20fb9fV51Sbv//q7h96nmjYnqlC79HnpoUz748JbbYpF0s1b/mC8lLrxkbH34yPa44Z1blmC6dW2ajFx9+elKV/SUrLVf7qCAWvdZLdI/2ayyTJVqNe+qtKveNvveFKJ80NTquu2KUVDPAoD5G/uupdPUYPX+9eWFbmuYwWraMSW9/XNiW1ktKW0arxZXjboxmDBse5dOmV7t97J2PZuvtKyVK5acIHP/ws1E+uSK4mpSNmxATnnwpi0q1X3vVGp8vTTWYkre6/2bHwrY0tWHLLp1i6n//V9g25Yf1Vn0Wm+/XCNDciE0BALMTm6KhTKxm6rfHHpoSd98+JVZbo1VssXVFAtav9+oQZ53XdY5l3wMrqm0PWq9Ndju1q8nF506IXHku/nDcrP+/23+pltGqVcTzT08tbEvrrVpX3EfjNGnCrMGeec89PCEevWN8rLB6m9hwq46Fc9k2u3aJKZNycdNlVaurpdtp+za/qpjetCaXnjI8+izdKnb+7awBhEsuU5GI9fqzs85Nrz07KUv2mtt0hkDzoQLWbPr3719YTwGnurYdMWLOKgMA/D979wEdRdm2cfxKr6QHCJBA6FWaIAoiRVAEbFiwoqCon72hWEBFVBQVxdcK9gIoTQEp0quAAlKll9CSkN7bfmeeNZvEUE0ghf/vnDkzO/tMWd95N8lwzX0DGPddonkK0LJpqz3A8Pl3SVq8wh5K6NjeU/fcZv+D7+kHA/XznFS9+UGC1m3MVJsWHvpzY6bmLU5Xu1YeevTegCL77trR29wYG/99ki7seUBXXe6tw0dzNennZAUFOuv9kSduybX3QLaGvxWn154LLvLkouWRewI0dOQx9bn9kGqFueqLCUnq3cNbDepS4r0iCL2nj6JeGKfoj39Wyuptpi1h5p7DSt+0R66hAQq5o6djrFUpK27qMrNsy7K3BrBaCB75YKpjTPWHrjvucdK3H1Di7NUKG3KLnL0KSm9by/7dWitx3lpHW7rkZRvlf2V7OXtyDVVEqb9vUPLcZfJoGCnX4ABTRS3naKw9AJWbK7/eXeTZqK5jvEf92qrSs5PZ5vCwMfJq2US23Dylr99i2gj697tCbtWP//2UExunxGnzFNDvCrkGFf3Oq9Kjowl8RY/5Qq6B/kpZtlaeLRvLrZq99SYAAAAAoDjuTeFcu/maWFUPc1G9+q6mHeHGDdlavTJL4REuevejgGLtKv+r9X9m6fuv0/TBZ4Hy8S2oOeLj46zrb/bWxG/TlJFhDwbOmJah2+7ylnehakioWB66/oBCw1wVUd/dtJrc9leGNqxKV1iEm4b/r0aR6+rm+4K04rdUTfgk3rQRbNDMQzs2Z2rt0jQT1uo3sOh3WWGLZiabYNX/pkYU2Wd4XXe1u8xbX713TEcP5uhYdI7+XJ6m+57jvhSAAgSw/qVZs2aO5dzc4knawgq/7+rKf0oAAFCcdYPr60nJRdetyTBTvvybXFZp94VTaurl0XGaMtP+pGBYVVc9cX+Ahj0ZJC+v4jcIPn4rVC2auOuzb5P0/rhE+Xo76dpevnr12WDVO0kf+/ufjjbb/d/dxZ/2efKBAB2Lz9WXE5K0aLlNfXv66OM3qTBTkapghb9xn45NXKC09TuVtmGXXAN85X9FewXdeJlc/e1Pg1lyElKUvHh9ke1zE4uuO14Ay2pnaAW8fDs0le+FjYq9H3LnFWZMyqot5rVftzYKub0g+IWKxbNJPeUcjlHW/kPK3LHHhPWcfX3kdUEj+XbtIK/mDYttE9i/j9xqVVfKglVKXf6HqXrlHlFDVe649qTVr+K+mmq28+12cbH3qlzZWbkpaUpd9ocys3bLq1UTBd15fal/XgAAAACoTLg3hXOtVx8vzZudoQ3r0pWTbVOtcFfd/4ivqWzlW6V0AlDZ2TYNeyZRPa/yVNce9opahQ15oYoZM3eW/Trv199LTz1XtIIbKpYuvX21dE6Ktq7PMNdV9XA33f5QkG66N7BYBSqr7eA7P9TS1+8d09LZKVq/Kk1Boa668Z5A3flIsDw8j38dJifm6oOXo3XDwEA1aFb8unrmrep678Vo0/bQ3dNJNw8ONGMBIJ+TzWYrqAlaCe3du1eRkZFmecCAAfryyy9PuU3t2rW1f/9++fn5KSEh4YQ9pceOHatHHnnELH///fe65ZZbSuWco6KiHNW1Dhw4cMpKXAAAVFZ5RxqU9SmgEmq87I6yPgVUQpnJBVXAgJLKiUvUoadeN8v8TQigLHBvCgAAO+5N4WzYnl3QwgwoLYdyCtowAiUVczhb/TvuKfd/Exb+27XBuMflFlI+g5bZsUnacc+75f6/J0qOOovH0a9fPzNPSkrS/PnzTzhuypQpjuVOnTqdk3MDAAAAAAAAAAAAAAAAUH4QwDqOxx57TJ6e9rKCTzzxhAli/du3336rRYsWmeXevXs7kpUAAAAAAAAAAAAAAAAAzh+uqmSWLVumnTt3Ol7HxsY6lq31/25BeNdddxXbR0REhF555RUNGTJEGzduVPv27fXMM8/oggsuMGEsq/LVRx99ZMZabQrffddeLg4AAAAAAAAAAAAAAADnjs1mn8qj8npeKH2VLoA1btw4ffXVV8d9b/ny5WY6VQDL8vTTTysuLk6jRo3S33//rYEDBxYbU7VqVU2bNk0NGtADHAAAAAAAAAAAAAAAADgf0YLwJF5//XUT2LrjjjtUp04deXh4yN/fX+3atdOIESO0fft2XXzxxWV9mgAAAAAAAAAAAAAAAADKSKWrgGW1GPx3m8GSsAJWhKwAAAAAAAAAAAAAAADKawtCJ5VHtCA8f1ABCwAAAAAAAAAAAAAAAAD+IwJYAAAAAAAAAAAAAAAAAPAfVboWhAAAAAAAAAAAAAAAAADOP7t379Yff/xh5keOHFFqaqrc3NwUEBCgiIgINWvWTG3atJG3t3epHpcAFgAAAAAAAAAAAAAAACokm5xkszmpvJ4bzr6FCxfqhx9+0OzZs3Xw4MFTjrcCWRdffLGuu+469e/fX1WrVi3xOdCCEAAAAAAAAAAAAAAAAECFkZ6erjFjxqh+/fq6/PLLNX78eEVFRclms51yysrK0uLFi/X4448rPDxct9xyi1avXl2i86ECFgAAAAAAAAAAAAAAAIByLzc3V2PHjtUbb7yhmJgYE6iyREZG6qKLLlL79u3Vtm1bU9UqKChIgYGBJqwVFxen+Ph4bd++XWvWrDGBK2uekZGhiRMnatKkSerVq5fefPNNNW3a9IzPiwAWAAAAAAAAAAAAAAAAKiQrfmOP4JQ/5fW8KrJmzZppx44dJnhVs2ZN3XzzzbrtttvUunXrE25TpUoVM9WuXVutWrXSTTfdZNanpKRoypQp+v777zV//nzNmjVLc+fO1eeff67bb7/9jM6LFoQAAAAAAAAAAAAAAAAAyr3t27erSZMm+u6777Rv3z6NHj36pOGrk/H19dWdd96p2bNna9euXbr33nvl7Oys3bt3n/G+qIAFAAAAAAAAAAAAAAAAoNybNGmS+vXrJycnp1Ldb0REhD755BO9+OKLOnDgwBlvTwALAAAAAAAAAAAAAAAAFZLN5mSm8qi8nldFdsMNN5zV/deqVctMZ4oWhAAAAAAAAAAAAAAAAADwHxHAAgAAAAAAAAAAAAAAAID/iBaEAAAAAAAAAAAAAAAAqJhs/0zlUXk9r/PMvn379N1332n9+vVKTEyUn5+fWrVqpVtvvVWRkZGlcgwqYAEAAAAAAAAAAAAAAAAV3P79+zV8+HBdeOGFCg0Nlaenp8LDw3XppZdq2LBh2rRp00m3//XXX3XdddepVq1a8vDwMHPrtbW+onrnnXfUqFEjvfjii/rpp580b948TZ482fz3aNy4sUaPHl0qx6ECFgAAAAAAAAAAAAAAAFCBjR07VkOHDlVqamqR9VFRUWZatmyZkpKSNGbMmGLb5uXlafDgwRo/fnyR9QcPHjTTtGnTdM899+iTTz6Rs3PFqfU0adIkPfXUU3JyclLv3r3VsWNHBQQE6MCBA5o4caJ27dqlZ555RhEREbrppptKdCwCWAAAAAAAAAAAAAAAAEAF9eqrr5oKT5aGDRvq3nvvVbt27eTv769jx45p3bp1mjp16gnDU88//7wjfNW6dWsNGTJE9erVMwGlN99802w/btw4U1XrtddeU0Xx9ttvm/CVVfHq2muvLfLeK6+8omuuuUYzZ840VbIIYAEAAAAAAAAAAAAAAOD8ZHOSzeakcukcnNf8+fMd4as777zTBKXc3NyKjOnevbupBJWVlVVs++3btzva8FmtC5csWSIvLy/z2gpxXX311brsssu0du1avfXWWxo4cKDq16+vsrRw4UJ17dr1lOOslouRkZHFwlcWK4z2xBNPmADWxo0bS3xOFacuGAAAAAAAAAAAAAAAAABH68AHHnjALLds2dJUsfp3+Kowd3f3YuusloQ5OTmONob54at83t7eZr3FGvfuu++qrHXv3l233nqrDh8+fNJx1ue12i6eSGJiomNcSRHAAgAAAAAAAAAAAAAAACqYuXPnaseOHWb5mWeekavrmTXCs9lsmj59ullu3LixOnTocNxx1vpGjRqZZWu8tV1Zql27tiZMmGDO2WozmJube9xxHTt2NC0YrUpX2dnZRd7bu3evnn32WdOisFOnTiU+JwJYAAAAAAAAAAAAAAAAqJCsLFB5ns6mH3/80cytEFGfPn0c6+Pi4kwwy5qfzJ49e3To0CGzbLUZPJn89w8ePGjCS2Vp69ateu6550xLxSFDhpjqX4sWLSo27uWXXzbVrd577z2Fh4erd+/epnJW586d1bBhQ9N+0cPDw4wrKQJYAAAAAAAAAAAAAAAAQAWzatUqM69Tp46qVKmi77//Xi1atFBwcLAJGFlzq3LV6NGjlZmZWWz7LVu2OJatalInU/h9KwBVljw9PfXqq69q06ZN6tmzp/kc+W0J8wNllrZt22r27NmKjIxUdHS0fv31V1M5a9myZaadYt26dc37bdq0KfE5nVntMQAAAAAAAAAAAAAAAABn5PDhw6ccU6tWrdPeX15enrZt22aWQ0JC9Oijj+r9998vNs6q8vT0009r6tSpmjlzpgICAhzvRUVFnfaxrQpS+Q4cOKDyoF69eiZUNWXKFD3++OMmXGV9xmHDhumxxx6Ti4uLqdxlVQNbvny51q9fr8TERPn7+5uqWVbrQat6WGkggAUAAAAAAAAAAAAAAIAKyWZzMlN5VPi82rdvfxrjT79noRUkskJYlo0bN2rNmjUKCwvTW2+9pauuuspUibLWPfPMM6ZS1ooVKzRw4EATVsqXnJzsWPb19T3p8Xx8fBzLKSkpKk+uv/569erVSyNGjNA777xj2hJ+8cUX+uCDD9SlSxcTsrLCVtZ0ttCCEAAAAAAAAAAAAAAAAKhAUlNTHcsZGRny9vbWwoULddtttykwMFBeXl7q3LmzFixYYKo9WawqWL///nuR7fK5u7uf9HgeHh6O5fT0dJU3Xl5eeu211/TXX3/p8ssvd7QlvOWWW4q0JTxbCGABAAAAAAAAAAAAAAAAZ9Hq1atN676TTWfCqnBV2D333KNGjRodN5g0cuRIx+uJEycedx9ZWVknPV5mZmaRfZZXDRs21Jw5czRp0iTVrFnTfN7GjRtr9OjRys3NPWvHJYAFAAAAAAAAAAAAAACAislq81eep39Y7QFr1ap10ulMVKlSpcjrnj17nnCsVQnK1dXVLFttCY+3j1O1FSxccetU7QrLgxtuuEHbtm3T008/bcJjVitGqxKYVSXsbCCABQAAAAAAAAAAAAAAAFQgVkvA0NBQx+vw8PATjrUqXYWEhJjlmJgYx/rCoa+oqKiTHq9wha6THetcWrlypQYPHqz27dub6l/W3Hq9fPly877VlnHUqFHasGGDunbtatoSWu0Jz0ZbQgJYAAAAAAAAAAAAAAAAQAXTrFkzx/Kp2uvlv59fCcvStGlTx7JVLepkCr/fpEkTlbUnn3xSnTp10vjx47V27Vrt2LHDzK3XnTt31uOPP+4Ya7Ug/O233/TDDz+YSmSF2xLm5OSUyvkQwAIAAAAAAAAAAAAAAAAqGCtolG/37t0nHJeUlKTY2FizXLNmTcf6yMhI1ahRwywvXrz4pMdasmSJY/s6deqoLI0bN07vvvuubDabevTooS+++EK//vqrmVuvrfXvv/++GVfYzTffrL///tuEt0q7LSEBLAAAAAAAAAAAAAAAAFRINlv5ns6mfv36OZanTp16wnHWe1YoyXLppZc61js5Oemaa65xVLhatWrVcbe31udXwLLGW9uVpY8++sicw8CBAzV79mwNGDBAV1xxhZlbrwcNGmQ+74cfflhsWx8fH7311ltat26dLrvsMm3dutWEtkqKABYAAAAAAAAAAAAAAABQwVxwwQXq1auXWbba682fP7/YmCNHjuiFF14wy+7u7rr77ruLvP/YY4/JxcXFLD/88MNKT08v8r712lqf377QGl/Wtm7dauZ33XXXcd+3glinaqtotV9csGCBvvvuO1WvXr3E50QACwAAAAAAAAAAAAAAAKiAxowZo4CAAOXl5alPnz4aOnSoli5dqrVr15oKUO3atVNUVJQZO2LEiCItCC0NGzbU008/bZatbTp27KiJEyeaZWtuvbaWLda4Bg0aqKx5enqa+bFjx477fv76/HEnc8stt5w0qHW6XEu8BwAAAAAAAAAAAAAAAKAsWJ31znKrv//sHJyXFaD65ZdfdMMNN+jo0aN64403zFSY1a7v+eef15AhQ467j5EjRyo6Olqff/65ac3Xv3//YmOstn6vvvqqyoNOnTppxowZJmzWtm1b1apVy/He4cOHTcUv6zNb406Hr69vic+JABYAAAAAAAAAAAAAAABQQVlBo82bN2vs2LGaNm2a9uzZo6ysLIWFhalLly6mhWDr1q1PuL2zs7PGjx+vfv366dNPP9WaNWsUGxurkJAQU0Hrvvvuc7Q6LA9eeeUV027x77//Vv369XXJJZeYz2q1W1yxYoUyMzNN9auXXnrpnJ0TASwAAAAAAAAAAAAAAACgAgsODjaBo5KEjq666iozlXetWrXSnDlzdPfdd2vXrl1atGhRkfcjIyNNoKxNmzbn7JwIYAEAAAAAAAAAAAAAAKBCstmczFQeldfzqixVv7Zv367ly5dr/fr1SkxMlL+/v1q2bGnes1oQnksEsAAAAAAAAAAAAAAAAABUKE5OTiZsZU1lzbmsTwAAAAAAAAAAAAAAAAAAKioqYAEAAAAAAAAAAAAAAKDispX1CeB8V6oVsKx+iuPHj9c999yjPn36qFu3btq3b1+RMYcOHdKWLVu0e/fu0jw0AAAAAAAAAAAAAAAAgErskUce0eHDh8/a/n/66SdNmDCh7AJYH3zwgSIiIjR48GB98cUXmjVrlhYvXqzU1NQi4xYtWqTmzZubKS4urrQODwAAAAAAAAAAAAAAAKAS++CDD1S3bl099NBDpVb8KTs7Wz/88INatGihm2++Wdu3by+bANbw4cP16KOPKjk5We7u7mrbtu0Jx/bv31/Vq1dXZmamJk+eXBqHBwAAAAAAAAAAAAAAAFDJ3X777crKytJHH32kBg0a6JJLLtGHH36oI0eOnHHoasGCBabLX7Vq1cx+N2/erMjISHXv3v2Mz8tVJfTHH3/o1VdfNcvWyYwdO1b+/v5ydj5+tstaf+ONN5px8+bN07333lvSUwAAAAAAAAAAAAAAAMB5yGZzMlN5VF7PqyL7+uuvTfWrF154Qb/99ptWrVql33//XQ8//LDCw8PVrl07tW7dWlWrVlVgYKCZ0tPTTZe++Ph4U91qzZo1+uuvv0yQy2Kz2RQaGqoXX3xR999/v1xdXc99AMsq7WWdiJUosz7k6bj44otNAGvjxo0lPTwAAAAAAAAAAAAAAACA80T79u01d+5cE6QaM2aMpkyZYjrx7d+/XwcOHDCvT8bKOeWzuvwNHjxYt956q3x8fP7zOZU4gLVkyRI5OTmZdNnpqlOnjpkfPHiwpIcHAAAAAAAAAAAAAAAAcJ5p166dvvvuOyUlJWn69OlauHChli5dql27dp1wG29vb3Xo0EGXXnqprrnmGrVq1apUzqXEAazDhw+beaNGjU57G09PTzO30mcAAAAAAAAAAAAAAADAf2IVMyooaFS+lNfzqmT8/Px0xx13mMkSExOjqKgoM7daD1o5JavFoDXVrVv3P7UYPJUS79Hd3d0EqRISEk57m6NHj5p5QEBASQ8PAAAAAAAAAAAAAAAAAEZ+2OpcKnEAKyIiQps3b9aOHTvUtWvX09pmwYIFZ1w1CwBQfuUdaVDWp4BK6uIN/cr6FFAJOTvzuAlKn1NK6T8tg/OXU6pLWZ8CAABAhcK9KZwt27NTy/oUUAnF5HqV9SmgEtqWGVbWp4BKJD7L6mS2p6xPA6hwnEu6g+7du8tms+njjz8+rfEHDx7Up59+KicnJ/Xs2bOkhwcAAAAAAAAAAAAAAMB5y6mcTzgflDiA9dBDD8nNzU0bNmzQiBEjTjr277//1pVXXqnExER5e3vrvvvuK+nhAQAAAAAAAAAAAAAAAKDMlLhPRr169TRy5EgNGTJEL730kmbOnKnrr7/e8f6PP/5oAlrLly/X3LlzlZeXZ6pfjRkz5pz3WwQAAAAAAAAAAAAAAACAchXAsjz11FOmDeELL7yg1atXa82aNSZkZXnllVcc46wxLi4uGj16tAYNGlQahwYAAAAAAAAAAAAAAMD5yvbPVB6V1/NC+WtBmO/pp5/W+vXrdffddyskJMSErQpPfn5+uuWWW7Ru3To9+uijpXVYAAAAAAAAAAAAAAAAAKjYFbDyNWnSROPHjzfL+/fvV3R0tHJzcxUcHKy6devK2bnU8l4AAAAAAAAAAAAAAAAAULkCWIVFRESYCQAAAAAAAAAAAAAAAAAqq7MWwAIAAAAAAAAAAAAAAADOKts/U3lUXs8Lpa7EPQFdXFzMZLUY3Lhx42lts3nzZtOO0NWV/BcAAAAAAAAAAAAAAACA8ziAZbPZzLR371517NhR06dPP6NtAQAAAAAAAAAAAAAAAOC8DWBZnJyc5ObmppSUFPXr10+vvfZaaewWAAAAAAAAAAAAAAAAOEULQqdyOpX1fxycK6XWA3DChAl69tlntWPHDr344oumzeDnn38uDw+P0joEAAAAAAAAAAAAAAAAgPNUt27dSn2fVuGp+fPnl48AVqNGjbR69WrdcMMN5qSsQNauXbs0depUhYWFldZhAAAAAAAAAAAAAAAAAJyHFi1aZAJTNlvJy4vl78eal1SpBbAs/v7+mj17th599FF9+OGHWrNmjdq3b6/p06erTZs2pXkoAAAAAAAAAAAAAAAAnOesHE4pZHHOivJ6XhVZ586dSyUwVdpKNYBlcXFx0QcffKDmzZvrkUce0cGDB3XppZfqiy++0E033VTahwMAAAAAAAAAAAAAAABwnlTAKo+cz9aO77//fs2ZM0dBQUFKT0/XLbfcomHDhp2twwEAAAAAAAAAAAAAAABA5QlgWbp27apVq1apUaNGpmfiyJEjdcMNNyg1NfVsHhYAAAAAAAAAAAAAAADnA1s5n3BeOKsBLEv9+vX1+++/64orrjAhrKlTp+r6668/24cFAAAAAAAAAAAAAAAAgIofwLL4+flp5syZeuSRR0wI6/Dhw+fisAAAAAAAAAAAAAAAAABwVrmWdAcRERFycnKSu7v7Scc5OztrzJgxatasmR566CFlZ2eX9NAAAAAAAAAAAAAAAAAAzhMuLi6lvk8r95STk1O2Aay9e/ee0fh7771Xl112GVWwAAAAAAAAAAAAAAAAUDI2J/tUHpXX86rAbDabyqMSB7D+i4YNG5oJAAAAAAAAAAAAAAAAAE7H8OHDVR6VSQALAAAAAAAAAAAAAAAAAM4EASwAAAAAAAAAAAAAAACgFFlN/pxs5ffccH447QBW3bp1zdzJyUm7du0qtv6/+Pe+AAAAAAAAAAAAAAAAAKBSBrD27t3rCE0db/1/8e99AQAAAAAAAAAAAAAAAEClDGANGDDgjNYDAAAAAAAAAAAAAAAAZ5XVfrCctiAst+d1HoiPj9eGDRsUGxur9PR02Wwn/x/jzjvvPDcBrC+++OKM1gMAAAAAAAAAAAAAAADAubJo0SINHz5cy5YtO6MOfucsgAUAAAAAAAAAAAAAAAAA5dFHH32khx9+2FS7OlXFq9LmfE6PBgAAAAAAAAAAAAAAAJQWm1P5nnBObN26VY888ogJXrVo0ULTpk3TzJkzHRWudu3apTVr1piQVps2bcz6Tp06afPmzdq9e3eJj39OKmBlZmaa0l5WX8XIyEi1b9/+XBwWAAAAAAAAAAAAAAAAQCU3duxY5ebmKjQ0VEuXLlWVKlVMuCqflVeyprZt22rw4MF69tln9dZbb5mKWb/99lvZV8Dat2+fhgwZYqaEhIRi769atUr16tVTz549deutt+riiy/WhRdeaLYDAAAAAAAAAAAAAAAAgJJYvHixqXRlVcGywlcnY40bNWqUunXrpoULF+rzzz9XmQewpkyZotGjR5s0WEBAQJH3kpKSdO211+rw4cOO/orW9Oeff6p3797Kzs4u6eEBAAAAAAAAAAAAAAAAnMeioqLMPL+9YH7QKt/xMkpWJSwrx/Ttt9+WfQBr3rx55oSvueaaYu99+umnio6ONstWwmz69On6v//7P0fvxa+++qqkhwcAAAAAAAAAAAAAAMD5ylbOJ5wTGRkZZl6jRg3HOh8fH8dyfHx8sW3q169v5lu2bCn7ANbu3bvN3Gor+G+TJk0y4azrr79eY8aMUd++ffXBBx/oxhtvNAmyyZMnl/TwAAAAAAAAAAAAAAAAAM5jQUFBZp6amupYFxoa6qiCtX379mLbxMbGmnlCQkLZB7BiYmLMPCwsrMj6xMRE02rQctdddxV5r3///ma+YcOGkh4eAAAAAAAAAAAAAAAAwHmscePGZr5jxw7HOm9vbzVo0MAs//zzz8W2mTp1qiOoVeYBrOTkZDPPzc0tsn7FihXKy8uTi4uLunTpUuS98PBwM4+Liyvp4QEAAAAAAAAAAAAAAHC+KusWg7QgLBc6depkuvEtXbq0yHqra5+1/v3339cXX3xhKmRFR0frzTff1Lhx40yFrG7dupV9ACsgIMDMDx06VGT9okWLzLxVq1ZFeioW5unpWdLDAwAAAAAAAAAAAAAAADiP9enTx8ynTZumjIwMx/onn3zStCfMzs7WPffcIz8/P9Plb+jQoabYlJVdevbZZ8s+gNWsWbMiZbks1glOmjTJpMT+Xf3KcvDgQTOvVq1aSQ8PAAAAAAAAAAAAAAAA4Dx20UUXmQpXo0aNUnx8vGN9cHCw5syZozp16phKWIWnqlWrmrxTkyZNSnx815Lu4LrrrtPixYv1zTffmEDVpZdeapb37dtnAlg33XRTsW3Wrl1bpBUhAAAAAAAAAAAAAAAAcMbKc6u/8npeldSAAQOOu75t27batm2bFixYoM2bNysnJ0cNGjTQFVdcIW9v71I5dokDWPfdd58++eQTbd26VaNHjzZTvr59++rCCy8sto2VHrPCWR06dCjp4QEAAAAAAAAAAAAAAADghNzc3EzgyprOhhK3IPTw8ND8+fN1/fXXy9XV1ZTosk76jjvuMJWw/m3JkiXasmWLWT5bHwoAAAAAAAAAAAAAAAAAzoUSV8CyVK9eXT/99JMyMzMVFxdn+ie6u7sfd6zVdnDhwoVmuVOnTqVxeAAAAAAAAAAAAAAAAJyPbE72qTwqr+dVSe3fv9/Mq1WrZgpKnUxGRoaio6PNckRERPkIYOWzTj4sLOykYyIjI810IjExMfroo4/M8rBhw0rz9AAAAAAAAAAAAAAAAABUMnPnzlWvXr3k6+urvXv3njKAlZaWpmbNmik9PV2//fabunTpUrYtCEublS576aWX9PLLL5f1qQAAAAAAAAAAAAAAAAAo53788UfZbDZde+21CgwMPOX4oKAg9evXT3l5eZo4cWKJj1/uAlgAAAAAAAAAAAAAAAAAcLpWrlwpJycn9ezZ87S3ueKKKxzblqsWhAAAAAAAAAAAAAAAAMC54mSzT+VReT2vymjv3r1m3rBhw9Pepn79+ma+Z8+eEh+fClgAAAAAAAAAAAAAAAAAKqycnBwzd3FxOe1t8sdmZGSU+PgEsAAAAAAAAAAAAAAAAABUWCEhIWa+e/fu094mf2xQUFCJj08A6ySysrI0btw40/MxLCxMHh4e8vX1VaNGjXT33XdrxYoVZX2KAAAAAAAAAAAAAAAA5y9bOZ9wTrRq1crMJ06ceNrbTJgwwcybN29e4uO7lngPldS+ffvUu3dvbd68uVgoa/v27Wb68ssv9fDDD+u9996Tk5NTmZ0rAKB0fPtTspb9nq4//8rUxm2ZysqSxo+pqrtu9jvu+KTkPL08+pimzEzVkZgchVV11Q19fTXsySD5+hTPOOfl2fThF4n67Nsk7dybLV9vJ3Xv7K1Xnw1W3dpuRcbm5tr05gfxGv99ko7F56ldaw+NeSVUTRu5F9vvp98k6olhsdqwMEL16hTdDyqGuOXbFT3jT6XuPKq8jGy5BfnKt3ENhd/TRR6h9utv9ZWjTrmflt884Bifl5WjA18sVvzSv5WbmS2/FhGq/UB3uf/zfmHWuNi5G9Xi03vkWsXzLHxClIXk37cqYfYaZew+LFtmllwDq8izQS2F3tlDbiH+suXkKmXN30pZ+7cydhxU9rFEqxu9PMJD5dellQJ6tJWTS9HvsrysbMV+N1/JK7coLzNb3s1qq+qgXnIL9i92/JjvflPignWKfO8hufh6ncNPjrMh6qWRyo2LP+57HvXrqvoj/+d4nR0Tq9Q1fygr6qCyDkQpNzFJLkGBqvXS88fd3paXp6TfFipl5e/KTU2TR+1wBV5/jdzDqhcbm7x8leKnTFfYs0/KLdT+NBMAAABQWXBvCueadU388HWaJk9K056dOXJxdVLjpm4aONhH3Xqe/B7RgX05uvaKWKWl2XTzbd566fWi9wYyM2x6981kzZmZrvR0m9p1cNfzL/ureljxlkDvjkrSlEnpmjE/VP4B1I6oDNfV1G+SNOvHZO3flS0XV6l+Ew/1v9dfnXr4FBm7Y0umFs5M1d8bM7V9c6YS4/LU6iJPvT+hxnH3nZmZp8/eitfCWSnKTLep5UWeenR4iKqGFf8n70/fitOsScn65rdaquJ/+q2oUD7ZbDZtmBerRd8d1NHd6UpPyVFgdQ81aB+gnveEKyT8xPcfYw+ka+S1a5WVlqdON4fplpcaFnk/OzNPP7+7W3/OiVV2eq7qtwvQjc/XN/v/t+nv7tbKKUc0bEY7efvzMw8ob6655hrNmjVLU6ZM0Y8//qgbb7zxpOMnTZpkxlp5n2uvvbbEx+e3mOPIzs4uEr664IILTNhq5cqVmjt3roYNGyYfH/svCGPHjtWoUaf+B1EAQPk3bNQxcwNqX1S2uWF1Mqlpeep6fZTGfJqoRvXd9NjgADWs56a3P0rQ5TccVEZGXrFt7n86Ro++ECubTXp4kL+u6OqjqbNSdFGvA9qxO6vI2DGfJuiFN+LUuIG77u5fRRs2ZerKWw4qJbXofg8fzdGzrx7T8KeCuMFVQf9o3PPebO0cMVWZRxIVfFkTVb/uQlVpXkspWw8q62iSY2yN2zoedwru2tS87xUR7AhfWfZ/tlBHp62Vb7OaCu7SVIl/7NH2l6bIllv0GkrbHa0jP61WxAPdCV9VouvqyMe/6NCbE5UdHS+/Ts0V2LuDvJpEKP3vA8qOSTDjso7E6dDoSUpetVXuNYIVeGV7+XVuoZxjSYr+bKYOjppg9lVYzFdzFT9zlbwah5v9pq7fpYOv/1DsusrYe0Rx01eo6sBehK8qEScvT/lf2aPY5HtRuyLjMnfvUeLseUrfsk3O3t7SKR5WSVq4RAkzfpVbtary7dBOWVGHFP3hZ8rLzCwyLicxSfE/z5B/r56ErwAAAFApcW8K55L1N//jDyTo1WFJSk22qV9/b13V11N7d+fowXvi9d2XqScN2Ax90nqQ68TeHJmkr8enqvWF7up9jZeWL87S/w2KM+G+wv7emq3PP0nVcy/5Eb6qJNfV8Aej9d5Lx5SWkqfeN1VR9z6+OrA7W88NPqrJXxW9bpbOTdW3HyZo/e/pCgo9dUjqw5Fx+vHzRLVo66nufX21Zkm6ht57pNh1tWtrpn74NEGPDA8mfFVJTHlztz57dIui96Trgu7B6nJbTQXX8tSKHw/r9ev+0KHtqSf8vvp66N+n2PcuLfz6oOq19lPb3lW1dXmcPvm/Tcr713V18O8U/fZ5lG58rj7hK6CcGjBggOrUqWN+Ht1666166qmndODAgWLjrHVPPPGEbrvtNhO+Cg8P1z333FPi41MB6zimT5/uCF9dfPHFWrp0qVxcCn449+jRQ1dffbV5zwprWQEs6384V1f+cwJARfbp21XVINJNtcPdNGpsvJ577dgJx771v3it35SlIQ8F6PXnC/4ReOjIWL35QYK5SfXsIwW9ghcuTzNPDHbu4Kk5E2vK3d3+j9G3XOerPrcf1sPPxWj2hJqO8eO+S1L3zl6a8a39SZ/rrvJVl+sOasa8VPW/topj3ENDY1Q3wk2P3xdQ6v89cPYdnf6HYn7doKp9Wqv2A5cXqzZUONRS645Ox93H3g/nmXnIFRcUbJdnU8ycvxR6xQWKfKyXWefbKEy7R89U6vbD8m1S07H/PWNmy//Cugru3OSsfEacewkzf1fivD8UcGU7E4Aqfl3lmrmzl4eq3nuV/Lu0krNnwRPMeQOydGDYl0r9Y7tSVm5RlUua2bfLyzMVrfy7t1H1B64266yKWkfGTlXGroPyahj+z/7zdPSjn+XTur78Opa8ZC/KD2cvLwVcdcUpx3nUq6vqjz8st5o15Ozupn1PPHvS8VblK89GDVT1fvsfuN4tW+joex8qfdMW+bRt7RgX9+MUuQUHy69r51L4NAAAAED5w70pnEtzZ2Vo7q8ZanOhm8Z/HyxPT/s18fgzebqhT6wJUHXp7qGa4cX/7eurcana8GeWnnrOT2+8UvAAYeHAw+QJaep3s5dGvGm/Ni5o5aZnH0/Uxg3ZatXGfh/CCs28OCRRl3bxUK++PMBVGSz+NVWLZ6eqxYUeeuebMHl42u9L3ft0rgZffVAfvRanS7p7K6yWPbzS9SpfdbzcR/UauSsxIVfXtd9/wn1b19XMSckm1DXkjVCzrmkrD418Mkbb/spUs9aejutq1LOxuugyb3Xr43tOPjfOrsSYLC38OkpBNTz03LQL5VWl4HtpwZdRmjxql+Z/FaU7RjYqtu2Cr6K0Z0OSrnuqria/seu419XKyUd0cb/qum2Effs6F/jp62e3ad/GZEW2+qfjRK5N3724Xc0uDVLbXlXP6ucF8N+5u7ubiladO3dWSkqK3n33XTNFREQoLCzMjDl8+LD277f/vLGCWr6+vpo6dao8PIpXvTtTRMmPY8WKFY7loUOHFglf5Wvbtq369OljlhMSErR169Zzeo4AgNJ3eWdvc4PrVKwfxtYNK18fJ73weMGNLIv12lpvvV+YddPK8vKQYMcNLkuv7j7qcomX5i1O1/6obMf6Awdz1PaCgh/0F7b0cKzPN2Vmin6Zm6pP3w6VqyutcCsaq33bwW+XyyMs4LjhK8vx1hXZR1aOji3YIic3F4V0Lwi65CSlyZaVI58GBe27fBralzNjCq7NI9PWKj3qmOo81KOUPhXKw3UV++MiuVULVNWBV57gurL/busW7GeqXhUOX1ms14F9LzbLaZv3OtbnJtuvK8+69j9SLJ717Tfis2MKnl60KmRlHYxVtcG9z8InREXgFhIsj8jaJnx1OnLjE+QeXsvx2j3cHubLibdXa7OkbdhoAllBt9zouIYBAACAyoZ7UziX5s+1Vx0e/JCvI3xlCQxy1oBBPsrKlGkL+G+7d+bovbeSde+DvmrS7PiFCeLj8mQVNW7WouB6bn6BffnwQfuDYZZvPk/V7l05GjayaPtCVFzL5qWZ+e3/F+gIX1kCglx04yB/ZWXZ9OuPyY71kQ3d1ai5h1zdTv0dYrUnzMq0qVGLgu+mRv98Tx0t9N300xeJ2r87S0+MoHp2ZRF3MEO2PKluG/8i4StL8y72n4MpcUUrOVqO7E7TjPf26op7w1WryfHDeKnx2aYFYUSzgnBx7eb2sXGHMxzrFn4TpaO703TzsAal9rkAnB2tWrXS77//rtatW5vfm61p3759Zp01Wcv5663cz+rVq83Y0kAA6ziyrMbq/6hbt+4Jx9WrV++42wAAKrcdu7N16EiuLmnnJR/voj9KrdfW+t37cnTgYMFNq8Ur0uXj7aSO7Yu3eOvZxds+ZmXBDY3wmq5at7Gg9dKf/yxb6y2JSbl65PkYU16+zQW0jauIEv/cq9yUDAVe3MBUDIpb9rcOTVyl6JnrlHEo/rT2Ebd8u9lHwEX15RZgv44srn7ecnJ3VerOo451+cv5bQqtlocHv1mm8Lsuk3uh1oWo2FI37FJeSoZ82zc2ldCSV23RsSlLlTBnjbIOn/jJ6X9zcrV/txUOcLlUsV9XGXuOONZl7j5s5m6h9hulVsvD2IkLFXLb5XIL5uZppZOTo5Tf1yhx7nwlLVmmzL37SmW3LoEByoo66HidFRVl5q6B9qek89LTFffjVPl1uVQehYJaAAAAwPmKe1MoDbEx9iBUrfDiD7nkr/t9RdHW8FZloaFPJKh2pKvuf/jElYWsEJdVRGLr5oJQzJZN9uWwmvZ9HzyQo7Fvp+jxZ6qoehgP2lQWcf9cV2HHqZwWVsu+7s8VBaGWM+Ef5Cx3Dydt31xwXW7fZF+u9s930+GobH3+brwGPx2kqmF0LqosQmt7mZDe7j8TlZ5S8L1i2bQozswbdQgsst6qWPX10G1m2yvvr33CffsEusnNw1kHtqY41u3fYl8OCrP/fDt2MEMzxu7V1Y9HKrB6ySvkADj7mjRpoj/++ENz5szRww8/rE6dOqlRo0ZmspYfeeQRzZs3T2vWrFHjxo1L7bj85DkO6z96vt27d6tZM3vblX/btcteptDqCdmgAWlXADhf7Nhjv3nVoO7xn0i01s9dZB8XXtNNqWl5Onw0V80bu8vFpfiTPPUj7fvZ+c9+LYNu9dMzI46p7x2H1LCum76bnKIa1V3Up4ePeX/IK8fk5emkl58u+pQjKo7UHf+EWJydtOmBL5Rx0P6HYv666tddqIh7u510H7Fz/jLz0CsL2g9anJydFNqzhQlz5aZnydXPS7HzNsm7XjX5NLRXL9rz/mx5162qqn1LJ9WP8iFz1yH7grOT9j7xkbIPFQpdOTspsE8HVR1w6hZyifPXmbl3y4IHDpycneXfrbUJc+WlZ5pAVuLC9fKIrC7PevY2FUc+niGP2tVN+0NUPrlJyTr23cQi69wjwhUy4Da5hf73p0p9L26vhOkzFf3JeLmGhip17R9y8feTV/Om5v346TPk5OYm/6uuLPFnAAAAACoD7k2hNFghKUvUgVzVa1D0WrLWWfbuKahWZfn0fynasilbE6aFFKmk9m/Ozk66/mZvTfgmTampeQoIdNbUH9PVpLmrWrS0H2v40EQ1auKqW+8seKgQFZ8VkrIcPpCjOvWLVl0/HGUPzhwo9F1zJqzr6qobq2j6d0lKT82TX4CLfp2crAbN3NX4n0pYo5+LVb0m7rruDh44rUx8A910zRN1NeXNXRpx1Rq16BYsL19XRf2dou2/J6jzLTV02W0FbXQtcz7drwNbUvT0hNZydXc+6XV18fXVtXTCIWWm5sonwFWrph5VeBNf1W5hr4r1w/DtqtXIV51vtXcDQPlk/VRysqlcok5o2enRo4eZzhUCWMdxyy236IUXXlBSUpJGjRqlq666qlgbwnXr1mnmzJlm+dZbb5WfHz/IAeB8kZiUZ+b+VY7/S7ufr3ORcacc/8/6/HGWx+8LUGamTZ//kKRlv2eoXSsPjRkRKl8fZ/PEolVGfvaEGnJzc9JTL8Xqy4lJSku36You3vpkdKiqhvAjvrzLTrCX4z4yZY186ldX0/fulFdEsNJ2HdWe92bryOQ18ggLVLU+xw9IZR5JUNKGfXKv6if/NpHF3o+4t6upYhS39G/lZebIv3Ud1X6gu6loFPvbJiVvPKDmH9ylvIxs7fvfPFOByxLUqZFqP9RDLv9qS4eKIScp1czjf1lpWgWGjbpXHjVDTNWqox//ovifV8qtWpACTxKQSpi7Vqnrdsq7RaR82zYs8l7onT3NNZS8covysrLl07Kuqg7qZdYlLlqv9M17VXv0fbJlZOnIuFmmApelSoemqnZv72LtDlFx+F7UTh71IuUeVl1OHh7KiY5R0sIlSl3zh47+7xPVePZJOXv+t6fe/bpeJltOrlJW/q6MXXvkERGuwH7XyNnDQxk7dill5WpV/b97zXUWN/Vnpf6+xlx/Xk0aKbj/DXKpUlAiHgAAADgfcG8KpeHSLh6a9XOGPvswVR0u8ZDHP20I4+Pz9PXn9vsLSYWuiW1bsvXReykaeJ+Pmv3TTvBkhrzgJ1dXac7MDGVm2HTJpe56/mV/EwKc9lOaVq/K0pRZIUpLs+nVFxM1d5a9KlLPqzz14qt+8v5XdTdUDBdd5q35v6Tqu48S1OYST3l4/PP9Ep+rHz9PNMspyUWDfWfiweeD5OomLZqVaq6rCzt56dHhIea6mj05Wet/T9f4GbWUnmbTmOExWvyr/Vq+rJePHn8lRF5cVxVWt7tqyb+au75/cbuWTbRX5bfUa+unC/tUlUuhVrhR21L060f7dPnAWkVaC57IdUPqmu3/nBNj2hE2viRQNz5fX84uTvp92hHtWJ2gZ6e0VWZania9ukPr5saY7Vr3DNXNLzaQhzdV/ADYlbvfgN3d3RURESFn57L7ARgSEqJvvvnGBLGWL1+udu3a6bHHHlPDhg2VkpJi1r399tum7WCbNm3M8pmI+qelxokcPlzwQwMAcH6y/mB8/vEgMxWWkZGn+4dE644bq+jyzt564/04ffhlot5+OUS1wlz1yHMxuvvRaM38jicxyj2b/VEMZzcXNRh+ndyD7X8IVmkervrPX6tN//eFjkxefcIAVoxV/comhfRoYSpe/Zuzh5tq33+5mf4d/Nr/6QKF3dRBXrVDTNgrftUO1Xn0SvMUxt7/zZWzp5vqPNTzrHxsnGV59uvKydVFNZ/pL9cg+0MC3k1rq8ZTN2rvkx8r/pcVJwxgpaz9W0fHz5JrqL/CHr3+uNdV1YG9zFRYTmKqYr6co6DrO8kjvKqOfPyLUtb8rer39zXP9xz9bKbZttrgPmflY+PsC+hV9DvBvVZNhdxxi1m2QlgpK36XX7fL/tO+repqAVdcbqbCbNnZOjbxJ/m0ayuvRg1N68PkpSsUdN3VcgnwV9xPUxX73URVu/+eEnwyADg/cW8KAHAq3Juq/Ppc66VpP6Xr9xVZurpnjAlk5WRL8+dmKDjE/m90+becsrLsrQcjarvqwcdO7yEYT08nPfeSv5kKizuWq1EjkjT4/3xVv6Gbhj+bqAVzM/TyG/5ycpJeeT5Rnl5OGj6y6HaoGC6/xtdUpVq3MkN3XRmlizp7KyfHpmVz0xQY4uLoLPRfeXg665FhIWYqLOFYrv438phueyBAdRq4663nYrRsXpqeei3UXFfvvBgrT684PTHiv1fwRtma9b+9mv3JfvV5uI7a9a0mryquJmg1+Y1dGjNgg+59r6ku6BainKw8e+vBCC9d9WCd09q3u6eLbniuvpkKS47L0uRRu9RzcITC6vvo++Hb9deCY7r15YbmOp7wyg6zbf/hdMoCyrO8vDzFxcUpLS1NNWvWLFZ8qVIHsKxWfnv37i3r09DVV19tekJa4arx48drwIABRd6vVq2aRowYoXvvvVfe3mdWHjU8PLyUzxYAcC75+/3z1E5ywRNghSWl5BUZd8rx/6zPH3cyI96JV0Jint5+yf6H4vvjEnXHDVX0wAB/x77ufOio/t6ZpUb/KvGM8sXF214W26dBdUf4Kp93nVB5VA9Q5qF45aRkyNW3aFUZW57NtBS07oKFXlG0/eCp7Pv4N7kFeKtG/4uVm5ap2LkbVfOOTgrp2tRRWevgd8sVPqiLXLy4hioaZ2/7teJZr4YjfJXPI6Ka3KoGKvtInHJT0+Xi41Xk/ZQ/tuvQ6Ely9fdV+EsD5Bp4+lWFoj//VS7+vgq+/lLTnjBxwTqF3NxFfpfar8/so/GK/XGRQu/oIWcv+7WPysG3YwcTwMrcY/0N998CWCeSMHue8tLTFXjd1eZ10uJl8m3fVlUuvcS8zsvI1LFvvlf20Wi5VataqscGgMqOe1MAULFxbwqlwdXVSZ9+FaTPPkzRjOnpmvR9mqpUcdblV3jq7vt81OuyGAX9E5j57H8p2r4tR99PDZa7R8kaKb32UpKCQ1w0+CFfpabkacqkND30RBUTCLMc2J+jD8ek6KnnqsjHh2pFFfG6euuLMH33cYJ+m56iXyYkyaeKsy7t6aP+9wbotm4HFBhc+v/w/f4rsSbgdcf/BSotJU+zfkzWwMcC1eMaX/P+of3Z+vL9eN3/bJC8ua4qnG0r4jXzg33qNqCmet4b4Vhfv62/7v+wuYb3/F1TRu02Aaw5n+3Xoe2pevL71nI7SevB0/HTa7tUJdhdVwyOUEZqjlZOOaLeD9VWuz7VzPuxB9I168N9uvapuvL0oQoWUJ7k5ubqyy+/NNOaNWuUnZ1tgpN//fWXmja1/3uYZcaMGVqyZIn8/f31/PPPV74AVnlhVbf6+uuvNX36dNn+qVBR2NGjR/Xtt98qMjLShLUAAOePBpH2Ets7dh+/V33++vxxPt7OCqvmoj37s5WbazNPEBa285+e9/X/GX8if23J1OiP4vXV2GoKCnRRYlKujsbkqlXzgjBD63+Wt3GTq9zzrGV/gtTF5/gtu1x9PJRpBQwycyT7fQKHxLW7lRWbLP+2kfKoevptkBNW71Lckm1qMvpWU3kr7cAx2XLz5F23ILjgXa+abDl5yjycUGQ9Kgb3msFm7nyC68q63qxvHFtWjuTzr/DVWxPlUsVb4S8PkHv1ok84n4y1bfKKzYoYcbec3FyVeTBWys2TR53qjjEekdWlnDxlHY2XZ6H1qPhcfOwXUl5mVqnuN+vgISXNX2SqbLn4eJsgVl5ystxrFjxF717LvkwACwAAAOcb7k2htFhhqgcfr2KmwlavtO5KSc3/aTW4dXO28vKk/tccO+5+Jn6XZqbuPT30wbgT31NYvCBDv/6SoW9/Cpa7u5N278xRTo7UuGnBP1c2aeam7GzpwL5cNW5KUKaiXld3PxpopsLWrUo380YXlO53w8qFaVowI1VjJ9WQm7uT9u3MUm6OVL9pwXdTg2b2Cm+H9mUXWY+KYfPSODNveFFAsff8Q91VPdJbB7amKCM1V1FbU2TLk0b3X3fcfVntC63pgu7Buu+D5ic85qbFx/THr9F64ttWcnV31pHdacrLsalW44Kb9bWa+Co322aCWIXXo4zYnOxTeVRez6uSio6O1rXXXqvff//9uFmfwurUqWPyPlY4q3fv3mrVqlX5CGBt3bpVn376qZYuXardu3crOTnZlPI6GetD5Fi/WZUzqamp6tWrl/ksVvmxIUOG6O6771bdunWVkZFh/od65ZVXtGzZMvM/3OjRo/XEE0+c9v4PHDhwyjLv7du3L4VPAgA4GxrUdVON6i5asSZdqWl55iZWPuu1tT4ywlXhNQtuWnW+2EsTp6Vo+eoMs1zY3EVp9jEdiq4vzLo5NvjJaPXs4q3+1xa9IZKZWfDLQ2aWrcRlnHFu+LW0P6mTfqD4jau8nFxlHI43rQCtalXHbT8oKfTK069+lZuepb0fzFXV3q1VpWmtosfLzj3uMioe7+aRZp4VFVvsPVtOrrKOxMnJ000uft7FwlfOvl4Kf/kuuYfZQ1ynw6p2dfTTmQroeaG8GkcUO97xllG5ZO7bb+auwUVvqpaELS9Px374UV5NGsmnbdE2rEWupfxlfuYBwBnj3hQAVGzcm8LZ9stUe1Dmqr72B7wuvtRDAUHFw1Ax0XlasiBTdeu7qPWF7iY8dSKpqXl6+fkk9b/D24wtLCur+DKXUOUzb1qKmXfvU3pBlbTUPL3zQqyuuc1PLdoWfSAx+5/vo8LLXFcVU262PXOQHHf84HFyfLacnCUXNyc1vjhQvgHFv4sSY7K0eUmcqtX1Vr3WfiY8dSJWkGvCyzt0af8aqtu6aDvUnELXVf4y1xVQvipf9e3b11S9cnZ21o033qjOnTvroYceOu745s2b66KLLtLq1as1derU8hHAeueddzR06FATpjpVgqwieOmll0z4yvLv9oPu7u7q0aOHunbtqp49e2rhwoV6+umn1b17d7Vs2fK09l+rVtF/9AQAVCzWDaRBt/qZkuuvvhun158v6BtvvU5JtWnoI0WrEt17u5+5yTX8zWOaM7GmecLL8uv8VC1aka4el3mpdviJb1C8/1mCtu7I0o/jCgIO/n4u5unFWQtS9dh9AY79WZo0OPkTiyh7njUC5demjpL+3KvoXzeoaq+C3yMOT1yl3JRMBXdrJieXoje3shPSlPD7Trn6eyugw+n3lo/6YomUZ1P43Z0d6zzCAuTk6qzENbsU1LGhWWctO7m5yKNG8aeJUP5Zlau8W9ZT2oZdSvjtDwVc3tbx3rGpy5SXmiG/zhfI6Z8e5yl/7rCHr3y8FGGFr2qcfvjKEvP9fMlmU+jtlxecQ7VAydVZqX/uUJWLmph11rKTq8sZVdZC+WFVmHIJDJCzu3ux9Qk/zzTL/w5KlUTyoqVm36GDCv4Oc/bykoufn9K3bJVfV/v3mLVsofoVAJw57k0BQMXGvSmUlpTkPPlWKXrvac7MdE2ZlK4WLd3Uo5c90HLbgEJltP9VKcsKYLW7yEMvvV40pPBvY0Yly5Zn0xPPFAT4wmu7yM1NWrIgQz2utB/LWnZzt7+Hiik1Oc+0HSxs0awU0xaw8QUe6nzl8a+n/+Kzt+KUZ7PpviEF95xq1HaTq5u0amGaOl9hP5a1bF1X1nuoeKwQ1OLvDmnBl1Fq3TNUXlUKIg5LJxxSwpFM1W3jZ1oOXnZbzePuY/vqBBPAatDOX7e8ZL8XfiI/j9lj3fLUNU/YH3a1hIR7mYDX5iXH1KqH/eeutezq5mTeA1A+fPXVVyZ85ebmpp9//llXXHGFWX+iAJbFqoBlFWGyCjCVVIkDWLNnz9ZTTz3l+KW/Q4cOatu2rYKCgkyirKKxAmSff/65WW7YsGGR8FVhrq6uGjFihDp16mQqfVm9I999991zfLYAgNI07rtE8xSgZdNW+6NWn3+XpMUr7E98dWzvqXtus99IePrBQP08J1VvfpCgdRsz1aaFh/7cmKl5i9PVrpWHHr23aHila0dvc2Ns/PdJurDnAV11ubcOH83VpJ+TFRTorPdHhp7wvPYeyNbwt+L02nPBRZ5ctDxyT4CGjjymPrcfUq0wV30xIUm9e3irQV1KvFcEdR7qqS1PfKu9781W/Mod8goPUtquaCWt3yf3qn4Kv6dLsW1i528yLQJDujczbQRPR8rWgzo64081GHa9XLwLSmy7eLkr9IoLFD1zvb3VoRXSWbhFVa9uIxdPrqGKqtrg3tr/3Hgd/egXpazeJveaIcrcc0RpG/fINdRfoXf2MOMyo2J06M0JsmXnyrtZHSUt21hsX26hAfLvdvxgTfr2A0qYvUY1h/SXs1fBdWUt+3dro8S5a5WXaX8qLXnpRgX0ai9nrqsKKfWPdUpauESe9evKJTBQzh7uyo6OUfqWbdYjRfLr0U2e9es5xuempCp+2i8FO8jNVV5KqmK/neBYFXhtX7n4Fr/hmnMsTgmz5iig71VyDSz6s7TKZZ2U8MssRX88Ti4BAUpZtVpezZrIreqJf4YCAAAAFQn3pnCu3XxNrKqHuahefVfTNm7jhmytXpml8AgXvftRQLF2lf/V+j+z9P3Xafrgs0D5+Bb826GPj7Ouv9lbE79NU0aGvcDDjGkZuu0ub3kXquyGiuW+6w6qapiratd3M9fVtg2ZWrcqQzUiXPXK/6oWua727crSdx8lmOXMf66B/buy9dpT0Y4xz40+/oNXm9dlaOo3SRr5STV5F7quvH2c1fumKpr+XbLjuvpteoquv9NPXlxXFVKbK0NN0Grn2kS93Gu1WnQNlpefqw5sSdH2VQly83RWv2cK7k2VxJ71SVry/UHd90EzefoURCk8fVx08fXVTfvCrAx7Ra61M6J12W015OFNYLRcsP7vXl5rBZXX86qEfvjhB5Nbuu+++xzhq1Np3dr+byB///132QewxowZY+aBgYEmQdaxY0dVZEePHlVcXFyR/9AnYgXN8m3btu2snxsA4OyybnB9PSm56Lo1GWbKl3+TyyrtvnBKTb08Ok5TZtqfFAyr6qon7g/QsCeD5OVV/A+5j98KVYsm7vrs2yS9Py5Rvt5OuraXr159Nlj16pz4yZv7n4422/3f3cWfInvygQAdi8/VlxOStGi5TX17+ujjN6kEUpGqYDUbO0AHv16qxLV7lPTnHrkF+qhq3zaqedslcgvwKXH7Qaud4Z73ZiuoUyMFdqhf7P3we7uatoPxy+y/WFqBrIhBxYNfqDisKlO13xys2AkLlbpup1I37JJrgK8Crmyn4Jsuk6u/vbx2bkKKCV9ZkpdvOu6+vJrVPm4Ay2oDd+SjX1SlQ1P5tmtU7P2qA3qa9nDJq7aY1/7dWyv0DnvwCxWPZ4P6piJVVtRBZezaI1tWlglPeTVtrCqdLjGtAguzZWYqdfXaouuysoqsC+jVUzpOAOvYxJ/kViNMVS69pNh7ft27KC8tTSmr1si2Y5e8WzRT0M03lOpnBQAAAMoS96ZwrvXq46V5szO0YV26crJtqhXuqvsf8dWg+3yKVcb6r7KzbRr2TKJ6XuWprj2KtoizDHmhihkzd5b9Ou/X30tPPVe0ghsqlm59fLRkdpq2rM9QTrYUFu6qOx8K0C2DA4pVxoqLydXsySlF18UWXXe8AJZ1vb45NEaX9fJRx8uL31/4v+eClZ0tLf7Vvh8rkPXAUCqzV1TOLk56aPwFWvhVlP78NUZrZ0aba8Av2E3t+lbVlfdFqHo9n1Jpdfj9sO2mylaLrgXVJfNdP6SecrNtWjc3xry+pF91XftU3RIfF0Dp+euvvxxVrU5X1ar2nzPHjh0r8fGdbCXsGRgSEqL4+HjThvDRRx9VRRcbG6vQUPuTHv369dNPP/10wrHJycny87P/EtinTx/98kuhp7xLICoqSuHh4Wb5wIEDlIUHUO7lHTn9NmjAmbh4Q7+yPgVUQomplIRG6cs4aA+2AaUhJz5BB4e/apb5mxBAWeDeFICKhntTOFu2Z9tbKgKlKSaXe1MofRsz7L+/A6Uh/kimXui6qtz/TVj4b9fw4S/KNaBoBdDyIichQQdeHlHu/3tWBh4eHsrJydHatWuLFFyyuvdZlbE2btyopk2bFtnGall40UUXydvbWykpRUPBZ6rE8fW0tDQzt1rxVQZW68T8UNXKlSvN/zgnsnjxYsdyZGRBD1gAAAAAAAAAAAAAAACcwxaE5XXCOcv75AfdTteOHTvMPL9QU5kGsGrWrGnmWVn2fuQVnZV86927t1k+dOiQRo4cedxxVtWvZ555xvHaqoAFAAAAAAAAAAAAAAAA4Nxq1qyZo6rV6Zo4caKpjtWuXbuyD2D17dvXzJcvX67KYtiwYaa8mOWll14y/SEnT56sdevWmapY7777rlq1aqUtW7aYMd27d1fPnj3L+KwBAAAAAAAAAAAAAACA88+1114rm82mDz74wBRVOpWffvpJv/zyi1nu169f2QewnnrqKVPG6+2339aRI0dUGTRu3FjTp09XSEiIeW39B7/hhhvUpk0bXXLJJXriiSe0f/9+8163bt30448/lvEZAwAAAAAAAAAAAAAAnH+cbOV7wrlx7733KiIiQklJSaaIUn5RpX+Ljo7W888/r1tvvdVUv2revLluuummsg9g1ahRw4SVcnNzTThp1qxZqgwuv/xybdu2TaNGjVKXLl1Mv0c3Nzd5eXkpMjLS/MefNm2afvvtNwUGBpb16QIAAAAAAAAAAAAAAADnJQ8PD5Nf8vPz0x9//KEWLVqoadOmjvdvv/12NWzY0OSc3njjDeXk5JiCU1ZHPCuIVVKupzvQqvR0MtZJbd++3bQkDAgIUIMGDRxt/E7E+gDz589XeRUcHKwhQ4aYCQAAAAAAAAAAAAAAAED51LJlS61Zs0YDBgzQypUrTeGlfBs2bDAtCvO1b99e33//verWrVsqxz7tANaiRYtMYKrwyRSWnwaz3rd6Ka5evfqE+8rfT2kkyAAAAAAAAAAAAAAAAACgfv36Wr58uZYtW6aff/5Za9euNW0Hrc5+ViGm1q1b6+qrr1aPHj1K9binHcDq3LkzgSkAAAAAAAAAAAAAAACUH1YdoePXEip75fW8KqH9+/ebua+vr+ni16lTJzOdK2dUAQsAAAAAAAAAAAAAAAAAypM6deqYwlJjx47V//3f/53z4zuf8yMCAAAAAAAAAAAAAAAAQCnx8vIy83bt2qksEMACAAAAAAAAAAAAAABAxW5BWF4nnBM1a9Y089zcXJUFAlgAAAAAAAAAAAAAAAAAKqyePXua+bJlyypmAGvFihVycXExpbwOHjx4yvHWGE9PT7m6uuqPP/4o6eEBAAAAAAAAAAAAAAAAnMceffRRk10aPXr0aeWXyl0Aa8KECbLZbOrTp4+jnNfJWGP69u2rvLw8ff/99yU9PAAAAAAAAAAAAAAAAM5TTrbyPeHcaNCggckhpaWlqUOHDmY5KyvrHB1dci3pDqzSXU5OTurVq9dpb9O7d29NnjxZS5YsKenhAQAAAAAAAAAAAAAAAJzHunXrZuahoaHas2eP7rjjDg0aNMgEswIDA013vxOxck/z588v2wDWrl27zLxp06anvU3jxo3NfOfOnSU9PAAAAAAAAAAAAAAAAIDz2KJFi0yQKp/VzS8zM1ObNm064TbWeGtc4e3KLICVkZFh5p6enqe9jYeHh5mnpqaW9PAAAAAAAAAAAAAAAAA4X9mc7FN5VF7PqxLq3LlzqQSpyiyAFRQUpOjoaO3fv1+tWrU6rW2ioqLMPCAgoKSHBwAAAAAAAAAAAAAAAHCeV8AqS84l3UF+68Gff/75tLeZNm2amTdq1KikhwcAAAAAAAAAAAAAAACAihvAuuqqq0w/xK+//lpLly495fglS5bom2++MWW/+vTpU9LDAwAAAAAAAAAAAAAAAEDFDWDdd999CgkJUW5urgljffDBB8rIyCg2zlr3/vvvq3fv3srJyVFgYKAeeOCBkh4eAAAAAAAAAAAAAAAA5zNbOZ1w3nAt6Q58fX31/fffm/BVWlqaHn30UT333HNq27atwsLCzJjDhw9r7dq15n2rWparq6t++OEH+fn5lcZnAAAAAAAAAAAAAAAAAICKGcCyXH755ZozZ47uuOMOHTp0SCkpKabVYGFW8MpSs2ZN04KwS5cupXFoAAAAAAAAAAAAAAAAAKjYASxL165dtWvXLn399deaMWOG1q1bp9jYWPOe1aKwTZs26tu3r26//XZ5eHiU1mEBAAAAAAAAAAAAAABwnnKy2afyqLyeF8pxAMtiBavuvfdeMwEAAAAAAAAAAAAAAABAZedc1icAAAAAAAAAAAAAAAAAAOdtACsyMlL16tXTzp07T3ub/fv3q27dumY7AAAAAAAAAAAAAAAA4D+xlfMJ54UStyDct2+fnJyclJWVddrbZGdna+/evWY7AAAAAAAAAAAAAAAAADhvA1gAAAAAAAAAAAAAAAAAUFaWLFli5u3atZOXl9dpbZORkaHVq1eb5c6dO1e8AFZiYqKZe3t7l8XhAQAAAAAAAAAAAAAAUBnYJKfy2uqvvJ5XJdSlSxc5Ozvrr7/+UtOmTU9rm4MHDzq2y8nJKdHxnVUGvv32WzOvXbt2WRweAAAAAAAAAAAAAAAAQCVis9nO6XYlqoDVrVu3466/++675ePjc9JtMzMztXv3bkVHR8vJyUk9e/Y808MDAAAAAAAAAAAAAAAAQInk5eWZuYuLy7kPYC1atMiEpwqnv6zlNWvWnNF+6tatq6FDh57p4QEAAAAAAAAAAAAAAACgRPbt22fm/v7+5z6A1blzZxPAyrd48WLzum3btietgGWN8fT0VFhYmC655BL179//lBWzAAAAAAAAAAAAAAAAgBOy6geVvIPc2VFez6sS2L9//3HXHz58WL6+vqfs4Ldr1y69+OKLJs/UrFmzsqmAVZizs7OZf/nll2ratGmJTwgAAAAAAAAAAAAAAAAATiQyMrLYOquDX8+ePXWm7rzzTp3zANbxTsJKgwUGBpb4ZAAAAAAAAAAAAAAAAADgZKyw1ZmsPx6rk98jjzyigQMHqswDWFblKwAAAAAAAAAAAAAAAOCcowXheemLL74o8vruu+82BaRGjBihmjVrnnA7a4wVvAoLC1Pr1q1P2a7wnAWwAAAAAAAAAAAAAAAAAOBcGTBgQLEAluXaa69V06ZNda6dlQBWbm6u4uPjlZ6efsrSXhEREWfjFAAAAAAAAAAAAAAAAACcBxYuXGjmkZGRZXL8UgtgxcbGauzYsZo2bZq2bNmivLy8U25jlfXKyckprVMAAAAAAAAAAAAAAADAecTJZp/Ko/J6XpXRZZddVqbHL5UA1ooVK3T99dcrJibmlBWvAAAAAAAAAAAAAAAAAKA0u/UtX77cLLds2VL+/v4nHZ+QkKC//vrLLF966aWmiFSZBrCOHTuma665xsx9fX11zz33KCAgQC+99JI5uXHjxikuLk5r167Vzz//rIyMDHXs2FGDBg0q6aEBAAAAAAAAAAAAAAAAnOemTZumG2+8UcHBwdq3b98px7u7u5tiU/Hx8Zo+fbr69OlTouM7l2hrSR988IEJX3l4eGjlypV655131K9fP8f7d999t5588kn98MMP2rlzpzp37mwSZ1abwgEDBpT08AAAAAAAAAAAAAAAAADOY1OnTjVzK4Tl7e19yvHWmJtvvtl0+ps8eXKJj1/iANavv/5qKl0NHDhQzZo1O+nYsLAwzZo1S/Xq1dPo0aO1YMGCkh4eAAAAAAAAAAAAAAAAwHlszZo1Jr/UrVu3094mf+yqVavKPoBlVbWyXH755Y51hfsiWj0WC/Py8tLjjz9uEmQff/xxSQ8PAAAAAAAAAAAAAAAA4Dx24MABM4+MjDztberUqVNk2zINYCUlJZl57dq1Hes8PT0dy8nJycW2ufDCC838999/L+nhAQAAAAAAAAAAAAAAAEBWQagzHZuTk1P2ASxfX99iJxMUFORY3rt3b7FtMjIyzDw6OrqkhwcAAAAAAAAAAAAAAMD5ylbOJ5wToaGhZr5t27bT3iZ/bEhISNkHsOrXr2/m+/fvd6wLCAhQ9erVzfLChQuLbbNs2TIz9/HxKenhAQAAAAAAAAAAAAAAAJzH2rVrZypaff3116e9zZdffiknJye1adOm7ANYF110kZmvWbOmyPorr7zSfLA333xTO3bscKxftWqV3nrrLfMBrA8PAAAAAAAAAAAAAAAAAP/VDTfcYObz58/X22+/fcrx1pgFCxaY5RtvvFFlHsC64oorTNBqypQpRdY/8cQTcnV1NW0GmzVrZsJWTZs21aWXXqqEhAQz5tFHHy3p4QEAAAAAAAAAAAAAAHCecrKV7wnnxs0336yWLVuaDNOQIUNMIMvq0JeTk+MYYy0vXbpU/fr1M2Os4lHNmzfX7bffXuLju5ZGAOvOO+9Ubm6u9uzZo8jISLPeOsGPPvpIDzzwgPkAf/zxR5HtXnrpJVMlCwAAAAAAAAAAAAAAAAD+KytMNXXqVHXs2FGHDx82y9bk5uamoKAgMyYuLk7Z2dlm2Qpq1ahRQ9OnTzfblnkAyzpRqyfi8QwaNEidOnUy72/evNkEsRo0aKA77rhDF154YUkPDQAAAAAAAAAAAAAAAACqU6eO1q1bp/vvv98Eq6yQVVZWlo4cOVJknBW4uv766/Xhhx+qatWqpXLsEgewTqVRo0Z6/fXXz/ZhAAAAAAAAAAAAAAAAcD6i1R/+YQWqpkyZou3bt2vmzJkmkBUbG2veCwkJUZs2bdS7d29TQKo0nbUAllXtKj4+3iwHBgbK1fWsZ70AnIa8I6X7JQJY2v15U1mfAiqpxBTPsj4FVEI5mfxeitLnbK9YDJQK55yyPgMAAM4e7k3hbNienVrWp4BKane2vVUNUJoOZgeW9SmgEtqVUTrVWwBLcmZaWZ8CUCoaNmxopnPFuTR3tmXLFj3yyCNq2rSpPD09Vb16dTNZy02aNNHDDz+sTZs2leYhAQAAAAAAAAAAAAAAAKDMlEoAKy8vT08++aRatmyp//3vf9q2bZtZZ/VStCZr+e+//za9E1u3bq3HH3/crAMAAAAAAAAAAAAAAACAiqxU+q/ceuut+vHHH03YytKsWTO1b99e1apVM6+PHj2qNWvWmOpXubm5ev/993Xo0CFNnDixNA4PAAAAAAAAAAAAAACA85EVVbHHVcqf8npeFdj+/fsdyxEREcdd/18U3leZBLAmTJigSZMmycnJyVTA+vTTT9WuXbvjjrVCWPfff7/WrVunn376yWzbv3//kp4CAAAAAAAAAAAAAAAAgEouMjLSzK2cUk5OTrH1/8W/91UmLQitwJWlYcOGWrZs2QnDVxbrvSVLlqhRo0amWtYnn3xS0sMDAAAAAAAAAAAAAAAAOA/YbDbHdKL1/2UqqRJXwNqwYYNJgj3zzDPy8fE55XhrjDV24MCBZlsAAAAAAAAAAAAAAADgv3Cy2afyqLyeV0X2xRdfnNH6c6XEAaysrCwzv+CCC057m/yx2dnZJT08AAAAAAAAAAAAAAAAgPPAgAEDzmj9uVLiFoS1a9c288TExNPeJikpqci2AAAAAAAAAAAAAAAAAFARlTiA1a9fP9MLcfLkyae9zU8//WTaFl533XUlPTwAAAAAAAAAAAAAAADOV7ZyPuGcqFu3rpk++OADVcgA1hNPPGE+wCeffKJJkyadVvjKGhsZGamnnnqqpIcHAAAAAAAAAAAAAAAAcB6LiorSvn371KpVq4oZwPL399dvv/2mNm3a6JZbbtG1116radOm6eDBg8rOzlZOTo5ZttZZFa9uvvlmM3b+/PlmWwAAAAAAAAAAAAAAAAD4r6pXr27mXl5eKguupzvQxcXllGOsVoS//PKLmU42Zu3ataZqltWG0ApoAQAAAAAAAAAAAAAAAGfKyWafyqPyel6V0UUXXaQpU6Zo8+bNatu2bfmtgGUFp041nc64f48BAAAAAAAAAAAAAAAAgP/qgQceMDmkd99913TsK7cVsIYPH352zwQAAAAAAAAAAAAAAABAiT3zzDN68803Ha8XLlyoLl26nHSbX3/9VZ9++qnWrFmjmJgYhYaGql27dho8eLB69eql8qxbt24aOnSoXn/9dfXp00fjxo1TeHj4OTs+ASwAAAAAAAAAAAAAAACgkli/fr3eeeed0x6fl5dnQlbjx48vsv7gwYNmmjZtmu655x598skncnY+7WZ759Qrr7wiDw8PtWjRQvPmzVPdunXVsWNHXXDBBQoMDJSLi8tJtx82bNi5CWABAAAAAAAAAAAAAAAA5Yrtn6k8KoPzyg9T5eTkqGrVqoqOjj7lNs8//7wjfNW6dWsNGTJE9erV065du0wVrXXr1pmKUlZFrNdee03l0UsvvSQnJyezbM1zc3O1dOlSM52OkgawymcsDQAAAAAAAAAAAAAAAMAZef/9900LwcaNG2vQoEGnHL99+3aNHj3aLF944YVavny5+vfvb1oPWvNly5aZ9Za33npLO3fuVHlls9kc079fn2oqKQJYAAAAAAAAAAAAAAAAQAW3f/9+vfjii2b5448/lru7+ym3GTNmjKmWZRk7dqy8vLyKvO/t7W3WW6xx7777rsqjvLy8Ek0lRQALAAAAAAAAAAAAAAAAFbsFYXmdzqEHH3xQKSkpGjBggC677LJTjrcqP02fPt0sWxWzOnTocNxx1vpGjRqZZWt8aVSMqmwIYAEAAAAAAAAAAAAAAAAV2KRJkzRjxgwFBQU5Wgqeyp49e3To0CGzfKrAVv77Bw8e1N69e0vhjCsXAlgAAAAAAAAAAAAAAABABZWQkKBHH33ULI8aNUohISGntd2WLVscy1YFrJMp/P7WrVtV3kRGRqpevXrauXPnGbVsrFu3rtmupFxLvAcAAAAAAAAAAAAAAACgDDjZ7FN5VPi8Dh8+fMrxtWrV+k/HGTJkiI4cOaKOHTtq0KBBp71dVFTUaR87PDzcsXzgwAGVN/v27ZOTk5OysrJOe5vs7GxTzcvarqQIYAEAAAAAAAAAAAAAAABnUfv27U85xmY78yTZ0qVLNW7cOLm6uurjjz8+ozBRcnKyY9nX1/ekY318fBzLKSkpZ3yelR0tCAEAAAAAAAAAAAAAAIAKxqr2NHjwYBPcevzxx9W8efMz2j4jI8Ox7O7uftKxHh4ejuX09HRVBomJiWbu7e1d4n1RAQsAAAAAAAAAAAAAAAAVk1U0qpy2ICx8XqtXr1ZYWFip7v61117Ttm3bFBERoeHDh5/x9p6eno7lU7Xuy8zMdCx7eXmpMvj222/NvHbt2iXeFwEsAAAAAAAAAAAAAAAA4Cyywle1atUqtf1ZwavXX3/dLI8dO7ZIi8DTVaVKldNuK5iamnra7QrPhW7duh13/d13333K/xZWmGz37t2Kjo42LRt79uxZ4vMhgAUAAAAAAAAAAAAAAABUIO+++66pWlW3bl2lpaVpwoQJxcZs2rTJsbxgwQIdOXLELPft29eElAoHwqKiok56vAMHDjiWw8PDVdYWLVpkwlNW+8V81vKaNWvOaD/Wf7+hQ4eW+HwIYAEAAAAAAAAAAAAAAAAVSH5LQKuS0y233HLK8SNGjHAs79mzxwSwmjZtWqSi1skUfr9JkyYqa507dzYBrHyLFy82r9u2bXvSCljWGKv1olWR7JJLLlH//v3/U/WwfyOABQAAAAAAAAAAAAAAgIqroAgSzkBkZKRq1KihQ4cOmQDTySxZssTMa9asqTp16qg8VMAqzNnZ2cy//PLLIsGyc8V+dAAAAAAAAAAAAAAAAAAVghU0slrunWwaPny4Y/zChQsd6/MDVFY1qGuuucZR4WrVqlXHPZa1Pr8CljW+cOWp8uLOO+80U2BgYJkcnwAWAAAAAAAAAAAAAAAAcB567LHH5OLiYpYffvhhpaenF3nfem2tt7i6uprx5TWQ9sUXX5jWgmWBABYAAAAAAAAAAAAAAAAqJCdb+Z7Ku4YNG+rpp582y2vXrlXHjh01ceJEs2zNrdfWssUa16BBA1VUx44dU1xc3FnZt+tZ2SsAAAAAAAAAAAAAAACAcm/kyJGKjo7W559/rnXr1ql///7FxgwaNEivvvqqKpqjR4/qxRdf1JQpUxQfH2/W+fn5mVaKr7zyiiIiIkrlOFTAAgAAAAAAAAAAAAAAAM5Tzs7OGj9+vGbOnGmCSTVq1JC7u7uZW69nzZqlcePGmXHlQVRUlDk3a/roo49OOG737t1q27at+WxW5SubzWamxMREffPNN2rdurXWr19fKudEBSwAAAAAAAAAAAAAAABUTFabv/La6q+Mz+ull14y0+m66qqrzFTezZ49W0eOHDEhsZtuuumE46xKXocOHXK8Dg8PN6GtLVu2KDk52VTEuuWWW7Rx40a5upYsQlU+omkAAAAAAAAAAAAAAAAAcAorV640865duyo4OPi4Y2bMmKG1a9fKyclJQUFBJrS1b98+s60V3rr77rvNuO3bt2vy5MkqKQJYAAAAAAAAAAAAAAAAACqEjRs3mmBVjx49Tjjmu+++cyy//fbb6tmzp+O1l5eXaanYokUL83r69OklPicCWAAAAAAAAAAAAAAAAKiQnGzle0Lp27t3r5m3bNnyhGMWLVpk5v7+/rr11luLvW8FuAYOHCibzaYNGzaU+JwIYAEAAAAAAAAAAAAAAACoEJKSksw8JCTkhAGto0ePmpBV586d5ebmdtxxrVu3NvNDhw6V+JwIYAEAAAAAAAAAAAAAAACoEJycnMw8KyvruO+vXr3asXzhhReecD8BAQFmnpqaWuJzIoAFAAAAAAAAAAAAAAAAoEIIDg428+3btx/3/RUrVjiW27Vrd8L9JCcnm7mnp2eJz4kAFgAAAAAAAAAAAAAAAComWzmfUOpatmxp5pMnTy72ns1m088//2yWXV1d1bFjxxPuZ9++fWZerVq1Ep8TASwAAAAAAAAAAAAAAAAAFcLVV19tglbTp0/XN998U+S90aNHa+/evaZN4eWXXy5fX98T7mflypVm3qhRoxKfEwEsAAAAAAAAAAAAAAAAABXCHXfcofDwcLN811136aKLLtJtt92mNm3a6Nlnn3WMe+KJJ064DyvANW3aNBPU6tChQ4nPybXEewAAAAAAAAAAAAAAAADKQnlu9Vdez6uC8/b21oQJE3TllVcqOTlZa9euNVN+sMoycOBAde/e/YT7mDVrlg4ePOiolFVSVMACAAAAAAAAAAAAAAAAUGFcfPHFJnTVr18/eXp6muCVNdWuXdu0Ifz0009Puv2IESPMvHr16lTAAgAAAAAAAAAAAAAAAHD+adCggX788Ufl5eUpJiZG7u7uCgwMPK1t58+fb+aurqUTnSKABQAAAAAAAAAAAAAAgArJ6Z+pPCqv51XZODs7q1q1ame0jY+PT+meQ6nuDQAAAAAAAAAAAAAAAADOIwSwztAzzzwjJycnx7Ro0aKyPiUAAAAAAAAAAAAAAAAAZYQWhGdg/fr1euedd8r6NABI+vanZC37PV1//pWpjdsylZUljR9TVXfd7Hfc8UnJeXp59DFNmZmqIzE5Cqvqqhv6+mrYk0Hy9SmeRc3Ls+nDLxL12bdJ2rk3W77eTure2VuvPhusurXdiozNzbXpzQ/iNf77JB2Lz1O71h4a80qomjZyL7bfT79J1BPDYrVhYYTq1Sm6H5R/CSv+VszMP5S266jyMrLkFuQrn0Y1VXNgN7mHFr32Mo8k6MikFUr+c7ey41Pl4ushz/AQhfZuq8BLmzjG5WXl6NBXixS/bKvyMnPk2zxc4ff3lHtI8Wv54FeLdGzuBjX9eLBcq3idk8+McyNl9RYlzV2tzD2HZcvMlkuArzwbhCv4tp5yDfE3YzL3HlbKyk3K3H3IjMtLTpNn0zqqOXzgcfeZl5WtuAm/KWXVZrNPryZ1FHL3VXINtu+vsGM/zFPywnUKf+dhufhybVV0UU+8qdzYhOO+59E4UtWfu7fIupz4JCXNXKyMTTuVE5sgJ093uVULkW+39vK5uKWcnAt+Ttry8pQ0Y4lSFq9RbkqaPOqGK/D23nKvWbysb/LC1Yr/bqbCRj4it2rBZ+GToqzd166dnrm0s1m+/ofvtf7w4SLvt6xeXf/X/iK1rVlTPm5uOpycrJ//3qaPVq9WZk5OkbHuLi56ulMn9WrYSF6urlodFaWXFy7QkZSUYsd9qmMn3di8uXp8+YWSMjPP8qcEAAA4Pu5N4Vyyrocfvk7T5Elp2rMzRy6uTmrc1E0DB/uoW0/Pk257YF+Orr0iVmlpNt18m7deer3ofYHMDJvefTNZc2amKz3dpnYd3PX8y/6qHuZSbF/vjkrSlEnpmjE/VP4BPN9fGdhsNq2Ym6xfvjqmqN1ZSkvOVUiYm1pc5KMb7gtRWETR75Ft69M06aNYbf0jTWmpeaoa5qbOff110wMh8vAsek1kZebpq9HRWjYr0Vxnzdt76/5hYWb///bV6KOa+2OCPp5bX1X8i197qHjX1bp5x7Tg28M6sidN6cm5CqruoYbt/XXlvbUUGl7wvfXz2H2a8b8DJ9zXa79dqJBaBePzcm2a/VmUlv10RCkJOYq8oIpufq6uatT3LrbtkolHNPH13Rr+c2tVjeCeZ0W2+ee9mjN8zUnHhLevqhs/uczx+vDGY1o9fpsObohVdmqOqlT3VqMrw9V+YBO5eRb9nsnJzNWysRu1/bco5WTkqlbbUHUd0kpVqhW/rqxxm6bv0V1TrpSnX/HftVCGbP9M5VF5PS+UOgJYpykvL0+DBw9WTk6Oqlatqujo6LI+JeC8NmzUMe2LylFIkLO5YWUtn0hqWp66Xh+l9Zuy1OMyL/W/zlfrNmbq7Y8StGRluhZNrSnPf/1xeP/TMeamVbNG7np4kL8OHcnVj78ka97iNK2YUUsN6hb8UjXm0wS98EacenX3VsO6bvpucrKuvOWgtiytXeQG2uGjOXr21WMa/lQQN7gq4B+MBz74VbGz18sjLFCBnZvIxctD2XHJStm4X1nRiUUCWEnr9mj3iJ/Msv9F9eVePVC5KelK3xOj5PV7igSwDo6fb0Jd1jpXP28dm/eXdr3yoxq/e7ecXAqun7Q90To6eZUin76a8FUlu7ZiP/tFSfPXyrVakHwvaSFnL3flxCUrY+teZccmOAJYqWu2KmHaUsnVRe5hwcpKTjvpvo99O0dJc9fIt0MzOft5K3nROh1+83vVev2+IoGazH1HlPDLclV7+AbCV5WIk7en/HpeUmy9a2hgkdfZ0XE68vKHyktJl2eLBvJq3UR56RlK/2Orjn3yozK27FLIvTc4xifNXq6En+bKq2UjeVUPUeqKdYp+8wvVGPW4nD09HONyEpIUP3G2/K/rTviqkmoYHKzHLr5EqVlZ8nEvfrPpivr19X7vPsqz2TR7xw7FpKaqbc0aeqTDxbokPEK3//SjsnJzHeOfu+wy3d6ylWb+/bfiM9J1Q7Pm+vSaa3Xt99+ZfeRrHBKiey+8UI//OovwFQAAKFPcm8K5vHfw+AMJmvtrhiJqu6hff29lZdq0YF6mHrwnXi+84qfb7vI5YXBr6JOJJ93/myOTTLjryj6eCgxy1tRJ6fq/QXH68ZcQubg4Ocb9vTVbn3+SqjffCyB8VYmMf/2opo4/pqCqrrq4RxV5+Tprz9ZMzZkYr8UzEjV6UqTqNLKHX5bPSdKoRw7I2dlJHa/0U2Coq7b8kaYJH8Tor5Wpeu2b2nLzcC6y75nfxunSq/zkF+SqeT/F65X79uvdqXWLXFt7tmVo8mexevqdWoSvKomfRu3RvC8PyT/UXa27B8vT10VR21K17McjWjMzRs/8cIFqNiz6vXXxtVUVXLPg3lI+b7+i/5T925cHNW3MPjW/LFDV6njp95+jNWbQJr0yq608fQqun4ToLE0evUd9H4ogfFUJhDYKUIf7mh73vR2/RenYriTVubjgAdEd86M089lVcnJ2UoPuteQT7GmCWL9/tlUH1kTrhk8uk6t7wfWy+N0N2jBplxr1CJdnoLs2T9+r6Y8t163fXi7nQt9XMdsTtPbrv9Vr5EWErwAcFwGs0/T+++9rzZo1aty4sa677jq9/vrrZX1KwHnt07erqkGkm2qHu2nU2Hg999qxE45963/x5gbXkIcC9PrzIY71Q0fG6s0PEsxNqmcfCXKsX7g8zdzg6tzBU3Mm1pS7u/2Xq1uu81Wf2w/r4ediNHtCTcf4cd8lqXtnL834toZ5fd1Vvupy3UHNmJeq/tdWcYx7aGiM6ka46fH7Akr9vwfOrpif15jwVUjvNgq/r2eRYJTFlpvnWLbCWLtfmyK34CpqMPIWuVf1P+FYW55NsXM3KLhnK9V+5CqzzrtRDe17+xel7Tgsn8Y1Hdvsf3+m/NvWU+Clx/8jAxVT4q+rTPjKr2d7U52qcDDKYisUTvDt0Fw+bRvLPaKaqTy07763Trhfq0pR8oI/VaVrG1W97xqzzrN+LUX/b4oydx6UZ8Nwx7iYT6bLu1UD+V7c/Kx9Tpx7zt6eCrj+8lOOS5q11FRTC7ytt/yu6OhYn3fjFTr0wlilLv1TAdd1l2uIPbiVsmiNPJvVV9UnB5jX3hc21dGRnyl9/Tb5dGjp2D7uq5/lFhokvysL9onKw9XZWW9d2UtbYqK1Nz5B1zUt+rPJw9VVIy7vYR7sunHCD9pU6OGVl7p1052tWmtgm7b6eM1qs876Teum5s01adNGPTdvnllnVdN6p9dVuqB6dUdlLWcnJ73es6cW792rWdu3n9PPDAAA8G/cm8K5MndWhglftbnQTeO/D5anp/16ePyZPN3QJ9YEqLp091DN8OL/3PPVuFRt+DNLTz3npzdeSTpuQGvyhDT1u9lLI960XxcXtHLTs48nauOGbLVq4+6osvbikERd2sVDvfoSZKgs4mKyNf2LY6pa000fzKwnnyoFYYSpn8dq3Mijmvb5MT02qqYyM/L0vxcOycnJSW9NilSDFl6OgODHLx/RjG/iNPWLY7rp/lDHtTV3Urx63higR163f181aumlt586qB1/patxa2/HtfX+0ENqe1kVXdq7eNV2VDyJMVn67etDCq7hoRent5Z3lYLvpnlfHtSPb1jhrIO667WGRba75LqqanTRqX8+Lf3xqJpcEqBHPmlmXrfpEay3bt+ovxbFqX1v+/Vn+WHELoWEe6rHXQU/L1FxVW0UYKZ/y83O0/qJO+Xs6qSmfeuYddkZufpt5J9muf8X3VStaaDj+2rBqHXaMHGX/vx2h9oPbGxfn2fTpml71PzaSPUcdqFZF9Y8WLNfXK0jm+NU44JgR/W1ua+sVZ1LqqtRT/v9dQD4Nx5TOA379+/Xiy++aJY//vhjuR/nCW8A59blnb3NDa5TsX6hsm5Y+fo46YXHC25kWazX1nrr/cKsm1aWl4cEO25wWXp191GXS7w0b3G69kdlO9YfOJijthcUPJlxYUsPx/p8U2am6Je5qfr07VC5uhbsE+VfXma2Dn+/TO7VA44bvrIUXme1HcxLy1TEQ1cWC1/9e2xOUppsWTnyrl/dsc67fpiZZ8UUPJ0Y/fMaZRw4pvAHryjVz4ayZbUIjP9pkVyrBSrkrl7FwlcWJ5eCG1/u4VXlUbeGnFxP/SRgbnKabNk5Znw+j7r2mw05xwqurcRZK5V1KFahg/qUwidCRZQTE2fmVkWrwpx9vOTRsLbjesqXG5co9zoF15V7ZK1i11Xamk1KX7dNQYOuK3INo/J48KKLTAWsZ+bMUa6tIFicr21YDYV4e2vezp1FwleWt5cvN/NbL7jAsS7Iy0uerm7adPSoY93Gf5ZrVCn4B8O7W7dR3cAgDZv/21n5XAAAAGeCe1M4V+bPtVd+HfyQryN8ZbGqVQ0Y5KOsTJm2gP+2e2eO3nsrWfc+6KsmzY7/LH58XJ6swrLNWhRcy80vsC8fPljwUNg3n6dq964cDRtJQKYyiY7KVl6e1LStd5HwlaV9V/vfYolx9u8Rq+VgYlyuOvSo4ghfWaxA1h1PVDXLv34fb77zLElxuaZSW/1CY/OXYw4VfH/9/OUxHdidqQdftt8TRcV37GCGrFsF9dr4FQlfWS7oYv85mBJXcA2cqbgjmardzNfxunZz+3Lc4YIq2X/OjdWGBcd054gGpmUrKq+dCw8qIyFLkZeGmSpXlsMbYpUen6n6XWs6wlf531cdH7Q/hPzXT7sc31fpCZnKzcxTtSYFY/O3Sz5ScF903fc7FL83Wd2fa3POPh+AiocA1ml48MEHlZKSogEDBuiyywp6xwIo/3bszjYl2i9p5yUf76JfedZra/3ufTk6cLDgF/7FK9Ll4+2kju0L+orn69nF/mTO4pUFNzXCa7qasvH5/vxn2VpvSUzK1SPPx+ixwQFqc0HxfaJ8S/pzj3JTMhRwcUNTLSh++TYTsoqZ9acyDtmDC/msX9jjl22Ti5+XqrSsY6pYHZ36u2kdaLUltJ6kKMxqOejk7qr0XUcc6/KX3UPtN7Qyjybo8LdLVPOuLnIPKWhziIovfcNO5aWmy+fCJlKeTSm/b1H8tCVKnLdG2UdO/OT06XCp4i0nN1dl7bFXjbFk7jlk5q7B9msrOzpecZMWKviWyx3rUIlk5ypl6R9K/HmRkuatVOauA8cd5l7LXpo7fcPfRdZb12bmjn1y8a8it5r2G6kWlyB/Ze0ruK6y9ha9rvLSMhT3zS+mmpZHHZ4wrIyaVa2q/2t/kd5fuVI744r+HMwX6mP/fSkqqXirk+TMTCVkpKuWv78i/O3XTVx6ujJystW0asG11vyf5UPJyWZe089Pj11yiUYvW6YjKSln5bMBAACcDdybQknFxtiDULXCiz/gkr/u9xVF23NbVYWGPpGg2pGuuv/hgqDCv1khLg8PaevmgrDelk325bCa9n0fPJCjsW+n6PFnqqh6GA/ZVCY16rjL1d3JtBFMSy4I3FlWL7T/LdbyEvv1Ex9rvy6q1SoePPX1c5Gvv4uiD2bryH77d5lfkIvcPZy0a3OGY9yuzfbvrdAa9n0cjcrSt2NidNdTVRUSRlvUyqJqbS+5ujlp159JSk8p2p7XqlJlaXxx8UpGO9YmafZnUZozPkrrfjumjNSi12S+oOoe2r+l4L7A/i2p9vVh9vBxWnKOfhixW5cPqFkkqIXKadPUPWbe4rq6jnWpx+zfO341i7fn9aziLg8/NyUdTlNilP3a8QrwkIuHs6L/TnCMi94Wb+ZVqtt/70o8lKoVH21Sp4dbqEo1+zqUQzbJqZxOplUAzgu0IDyFSZMmacaMGQoKCtLo0aPL+nQAnKEde+x/8DWoe/w/4Kz1cxfZx4XXdFNqWp4OH81V88buRfrQ56sfad/Pzn/2axl0q5+eGXFMfe84pIZ13fTd5BTVqO6iPj3sv9wNeeWYvDyd9PLTRZ9yRMWQtvOfoIGzs7Y+OE6ZBwv9Y7Ozk6pe01617uluXmYdSVBucrq8G4Rp/9hZpm1hYV71qqnesBsdQSqr/3hwjwsUO+tP5aZnybWKl47N32jGWfuw7P/gV3lFVlNI77bn7DPj3MgPRFnXwYGn/6fsw4VCV05O8u99sULuuPI/7duqpmW1H0yat0Z5GZly9vVW8uJ1cq8TJo/69lBMzGc/y6N2NdP+EJVPbmKyjn02ucg697q1FPLAzXKrZi+bbfG76lKlrdum+O9nKX3jDrmHV1deeobS/9gqJw83hTzaX87uBT9DfS+7UAkTZyv67a/kWj1EqSvWyyXQT16t7CW74yf8Kid3N/n3O3X7Q1Q87i4uGn1lL22NidEna9eccJwVqLLU8ise7qzi7q4AT/tTz5GBgdqfmGjuP/y4abNua9lSvu7uik/PUL9mzUxFrL+O2IPJIy/vYY77zYaiP1sBAADKO+5NoaSskJQl6kCu6jUoeh1Z6yx79xQNKnz6vxRt2ZStCdNCilRR+zdnZyddf7O3JnyTptTUPAUEOmvqj+lq0txVLVrajzV8aKIaNXHVrXfyD86VjV+gq+56uqrGv3ZU9/XcqQ6XV5GXr7P2bM3UX6tS1fv2QPW9I8gx1nK0UPW9fKnJuUpJtF+DB/dkKqy2u7m2etwYoFnfxSs9NU9VAlw0f0qC6jXzVIML7H8TfvDCIUU29lDv2/luqkx8A9103ZN19NOoPRrW60+16h4kT18XRW1L1bbfE9Xl1jB1va2gunq+n8fuL/La289FNz9XVxdfa394MF+nG6tp8lt7Nfa+zapWx0u//xKjgKrujupak9/cIzdPZ139SMRZ/qQoa0mHUrV/9VH5VvMybQHzWYEq8/5Be8CqsMzkbGUm2b/H4vclKyDc19yfb35NpDb8uEtZqdny8vfQ5l/2qmrjAFVvZr+ufnv1D4U2DFDLm+qds88HoGIigHUSCQkJevTRR83yqFGjFBISUtanBOAMJSbZ2+L4Vzl+wT8/X+ci4045/p/1+eMsj98XoMxMmz7/IUnLfs9Qu1YeGjMiVL4+zuaJRauM/OwJNeTm5qSnXorVlxOTlJZu0xVdvPXJ6FBVDeGruDzLSbSXmI2e+rtpFdjo3bvkGR5iKlXtG/urWe8RFqDQ3m0dY9N2HVFG1DHVfqyP/Ds0UG5apo5MXKFjc9Zr92tT1Piduxz7rzWou2kpl7Bsq/Iyc1SlVR2F329vdWiFsVL+2q/GYwcqLyNbBz6ao4Tl28x2AR0bK/z/rpCLJ21xK6rcRPsfgAkzV8ojMkw1R94n91ohytxzWDGf/qzEGSvkVi1I/v8xIBV8xxXmOkpZtdne6rJFPYXcfZUJZyUvXq/0LXsVPuoB2TKzFPP5TKWs2mK28+3QVCED+8iZa6vC8r20rTwa1THVrZw83JVzJFZJs5crdfk6HR01XjVGPipnL/uNCKvCVfVh9yv240nK+Gu7mSxWiMqvW3u5RRRtAeDXq5NsOTlKWfyHMrbvlUdkLQXeYV0vHsrYtlspi9eq6tN3m2sv7vtZSl36h2m36dWigYIHXicXP548rMgev+QS1QkI0DXffau8f8q0H88fhw6ZSlc96tdX09Cq2hJT0IbwsUs6Opb9PAqqL7y2ZLFy8nLVq2FDebq6avm+fXp54QJznOuaNNVFtWqp77ffyNvNTS9166ZeDRqa7X7dsV3D589Xek7Rp2oBAADKC+5NoaQu7eKhWT9n6LMPU9XhEg95/NOGMD4+T19/br+3kFToeti2JVsfvZeigff5qNk/7QRPZsgLfnJ1lebMzFBmhk2XXOqu51/2NwHAaT+lafWqLE2ZFaK0NJtefTFRc2fZK4v0vMpTL77qJ+9/VXZDxXLdwBCFVHPTe88d0qzv7RVfLM0u9FaXvgGO9m1N23rJ29dZq+Ylm0pW9ZoVtBb89t2Cv/lSCl2Lg4ZWNy1Pl/2aZK6tVh19dP+wMHNtWWGsv35P09if6yojLU8fvXREy2fb2692vNJP//dymDy5tjwfo8AAAQAASURBVCqsHnfVVGA1d339wk4tnlDQ/aF+Wz+17xNapC1geGMfDRjZQI0u8pd/qLsSY7JMpSwrkPXl0B3y8nNVq27BRfadk5WnZT8d1Y4/klSnha/6P19Pnj4u+nt1oln/6PjmcnF11o9v7NbyqdHKSs9Vs0sDdccr9eUXzD3PymLTz3tNu8tmfevIuVBovUarELn7upr2hFYlq6qNC1oLWlWsCoex8nV+vKWcXZ21fd4B5WTmqnaHauo6pJXZ75Zf9ipqbYxu/6GHstNzteCNP7XjtyizXYPLa6n70DZy8+J3KQB2fBucxJAhQ3TkyBF17NhRgwYNKrX9RkXZv5RP5PDhgrYuAMo/6w/G5x8PMlNhGRl5un9ItO64sYou7+ytN96P04dfJurtl0NUK8xVjzwXo7sfjdbM74o/7YHyI79toJObi+q+cIPcg6uY177NI1R36HXa+vB4RU9dbQJYjhaDeTbVuL2zqW5lsSpb1X7kKqXvjVba34eUsvmAfJuFm/ecPdwUPriHmQrLTkxV1LjfVO2mi+UVEWoqaiWu2qGIh68y7x/4cI7ZNuLB/1YhCWUvv8e8FcCr/tQtcg2yV0bzalJH1R6/WVFDPlTCjBX/OYBlVS0KuesqMxWWm5Sq2G9mK/DaS+Veq6oJe6Wu3abQwVdLTlLs+BkmfBN6T99S+JQoCwHX2avy5XOvXUMh991olq0QVsqiNSZIZck+ekzR73xtAnfVnh8s99phpo1g6vL1Spg8Txkbd6jaC4NNcM9izQOu6WamwmxZ2Tr2+TT5dGwtr+b1lfjLIiXPX6WgW68ybQvjvv5FsZ/+pGpPFQRQUbG0DgvTPW0v1HsrV2r7sZO3SU3LztbIxYv0Rs8rNPmWW0xIKiY1TW1q1DCtBXceO6b6wcFFQlyZOTkasWiRmQoL8vLS81266OM1q03Lw1cvv1w96tXX87/Nk7X5K927KyM7R8MWzD9rnx0AKiPuTQGVC/emKrc+13pp2k/p+n1Flq7uGWMCWTnZ0vy5GQoOsf+t5vzPvztnZdlbD0bUdtWDj9nvYZ2Kp6eTnnvJ30yFxR3L1agRSRr8f76q39BNw59N1IK5GXr5DX+rcLdeeT5Rnl5OGj6yeOVbVBzfj43WxP/F6rbHQtXtmgD5+Dlr99YMffbqET172x49979wdbjcT14+Lrrn+ep6f+ghPXnDHnXs5afAEFdt/TNNOzdnqFY9d0XtyrKaCDh4eDpr8IthZios8ViOxr12RDfdH6KIBp4a+/whrfotSQ+PtMY56cPhh+Th5aQHX+G7qaKa8b/9mvnxAV39cIQ6XF1VXlVcdWBbiia9vkej79yo+99v7AhVte5RtPhFSC1Pdbu9hsLqeWvMwE2aPmZfkQCWFYjp/UCEmQrLzszTt8N2qsM1VdX0kgD9+skBLfz+sG4aWteEwX54dbcJdD3yabNz9F8BZ5P1bzGbp+8197ObXxtZ5D13b1dd9kQrzXtlrX4YsMCEpHyCPXVowzFFb41XUGQVxe1JNpWv8rl5uqjr063MVFhaXKYWvbNB7QY2VnA9P8179Q/tWnRIl794oXVozX/9T7l5uqr7c23O2WfHSZTnVn/l9bxQ6ghgncDSpUs1btw4ubq66uOPP5aT9RdFKQkPt/+jO4Czz9/vn6cCkwuevCksKSWvyLhTjv9nff64kxnxTrwSEvP09kv2PyDeH5eoO26oogcG+Dv2dedDR/X3ziw1qs9TF+WVi4+9SoxP/TBH+CqfV52q8qgeoMxD8cpJyXCMtfhf1KDYvvzbNzABrLQdhx0BrBOJ+mSe3AJ8VP2mjqaCVuy8v1TjtksV1MX+B2LmkQQd+WGpag7sJhcvrp+KyNnbXvnFo24NR/gqn0dENblVC1T2kTjlpqbLxafgqcKSiv1yllz8fRR4XWflpWcqadGfCrqxq6p0sgcGc47GK+6nRQq+vaepaoTKw7drexPAytyxT/ongHXs05+UeyxB1Uc/JZcA+3ec9b+7f9/LlJuUouQ5y5W66i/5XlL05sO/JUxfoLy0dAXeag/8Jc1dId+OrVWlewfz2rrWjn08SdmHY+QWFnrWPytKl4uTk0ZfeaW2xcaaINTpmLRpk46m/D979wHfRn3+cfxrW/LeK55JnL33HpCETEZZZZW9+dOWQpldUPYqhUJbNgXKhoaZhCRkJyRk772deMd7D+n/ulMs27EdQNixZD7v1+uq0+kkncjTs+6n5/c8xbpp+HBN7trNfI3NmRm68pNPdPPw4WYC1rEyR+XIk7l/4kTllJTo3999pyCrVRf17ad/rPxWX+x0VIRMDgvTbaNH64llS83ELwDAD8PYFHDqMDaFn8qoIPTKW5F69d/F+urzMn30XqlCQrw1eZq/rr05SDNOz1ZktI+576v/KtbundV679Mo+fr9tN80HvtroaKifXTTb4JVUmzTzI9K9Zvfh5gJYYbUw9X693PFuuuPIQoKolKRJ9qwoljvPpet866L0sW31F2r9x0WpPtf7agbJuwx2xMaCViGaRdHKCrWok9eydF33xTJVmM32wk+9t9O+uTlHDMBKyzq+392fPnhDIVHW3Tx/0WrtLhG8z/J0+W/i9WEX4Sbj2ekVur9F7J13b0dzMQveJbt3+ab1asmX52gGTfVfefsPjRMv3mxj/44Za3ZnrB+UlVTeo8OV0xHfx3dXaqy4moFBFu+N+mrtKhaF9/nSMZZ8N80jT43VhMucyQAlpfU6PW7dytjf6niutBS1dMd+i5TRRml6jgiVmGJjpbL9fU/P0XBMf5a89YuM2HKSNjq0CdCv3z5dK15c6eZgBUQ+f1j34ue3qCgSH+NvL632Z5w2+cHNPqWvuo9w5EAWHC0RCtf3qbxtw8wE78AgDNBEyorK3XTTTeZlSnuuOMO9evXr60PCYCLuqc4ymzv2d/0D3K122v3Cwr0VnwHHx04XKWaGrs5g7C+vQcc+3c7vn9zNm+v0N9ezNNbL3RQZISPCgprlJldo0H96r7QDT6+vpNBLrfmn+S4EPQJqmuTVF/tdqPFm198hGPKoc0un+DG+1uCHf/mtsqTt0kqWLNXect2qMeTV8rb6qPS1BypxqaALnX97gO7dpC92qaK9DwF1tsOz+Eb7xgA924mtmoTtIzYUuNrSJeUbNit4m+3KvHB6+VlsajyiCO2fDvXzUT0TYmXampUlZEnv85xLfPGcAs+IY7BJVtFpeO2rMJMxvLtnOBMvqrPv3cXMwGr6lCadJIErMrD6SqcvcyssuUTHGhW0LIVFMu3XvtCo7KWoSqNBCxPFOjrq5QIRzWF3bff0eQ+My/7lXl78+efa/6+veb6koMHzeVEz0TPUI3Npm2ZmSd93wkpKTqrR09d8uGHqrLZ1DUySlYfH23PznbuY7Q39PXxUcewcO3MqdsOAADgLhibQkswkql+fUeIudS3emWFedvveKvBHduqZLNJl57bdNXaD98tNZczpvrpn681rJhW35KF5ZrzZbne+SRKvr5e2r+3WkbX71596n5S6t3XKmMOROqhGvXqQwKWJ1q3pNi8HTCq8cBTZIxVSV39tG9bucpKapyJUMMmhJjLiZ6586hZ/apbv6bHuWqtWVSkZbMK9OQHKbL6eit1X7lqqqUuveue17WPv6qr7Eo/XKUuvUnA8jTbluaat0ZLwRMZLQbjugQodXuJmRBltA08meBwq7IOlauyzKaA4Ob3O7KrRHPfOKrrnuyhoHCrmYhVmFOl5N51T6pdzzhQRgJWO7D10wPmbb/zG1a/qi9lXLy5nGjOnwvk5S11qNeasCn7l6Vr97xUXfL6RPlYvZW7v1C2artiejiSRQ0xPcPNbQWpxeY6AJCA1YTHHntMO3fuVMeOHfXAAw+0+OunpqZ+b5n3ESNcazcEoKHuXaxKiPPRt2vKVFJqMwexahn3je0pHS1KTqwbtDptdIA+/KxYK1aXm+v1zVvsqNRw2qjmq9EYg2M33ZmlqRMCdel5DS9GKyrqtdqpPN5+rAUr7KHlhQzoZN6WG4kqJ7BX15jVr7z9rbKEBcrLx1vBvZPMFoPlh3MaVbkqO+x4Dd/Y5kuz15RVKvVfXyvmzCEK7pPU8P2qahqvEz8eK6Cv4+Kw6mh2k7FVlZkrLz9f+YS2zICArbxCOa99qdCpw+Xfs2GJbntVdeN1Qqvdqdjn+A5qiY5wxpmhpqjpKkQ1RSWOFUvzlwx2m03H3vhUAf26K2jUwIaPGaPztThnebTKmhp9uGVLk4+NSEo0k7Pm792r3LIyHSksOOlrDU1IMKtWLdq/X0WVjmTApgRarXr4jMl6d/MmrU9Pa/CYkXDVeJ063gDwYzA2BZw6jE2hNX35aZl5e+Y5juSV0eP9FB7ZOBkqO8umpQsr1KWbjwYP8zWTp5pTUmLTg38q1KVXBpr71lf/K3ztOuHjuaqOnwMKcpueLGq0CjSSqowqbCezfW2pMo9UadiEYAWFNJ9QYyRy/ev+dJ15eaT6DA1s8ljqrxNbnslInjMU5TWdeFycW2Umv/hYT/4PXFFao7S9pfIL9FZwRPPnLKMS29t/3qO+Y8M14qyGk/6qKuuqSVbXrhNXHq8sv8KsauUf5qtukxJ/1HOPbsxRYVqpUsbFyS+k+biqLK3WgsfWa8BFXZUwqGGbzJoqW+N14sp9MESINsa0hBMYiVePP/64uf7CCy8oKKiFSk7Uk5SUdNIlPr5xNi4A1xgDSNf/KlTFJXY98qxj5kUt476x/YbLG7b+uvEKx/0HnjqmynoXfnMWlGjxt2WacnqAOiU3/8Xs+VfztWNPpf79RN2X/bBQH3P24uyFJQ1ez9C7+8lnLKJtGVWtQoakmIlWOXM3Nngs4+OVqikpV/jonmbylSH6TEev7/R3l8lWL6mlPDVHud9skXeAr0KHdmn2/dLeWmxWYEy4ekKDY/CyeKtg7T7nNmPdy+Ijv3hmVXgqa1ykAgZ0NdsMFi5Y1+CxvM+XyVZSrqARveVVL9Hgp8h9/xsztqIum1LvGCIkHx+Vbtjj3GauW3xk7dD8TFi4r6q0LGeFqxO3538411wPGj3QWRHLEh9ttiAsWrymwf62kjKzqlVtJazmFM391nztyGvObVC9zaioVbZpt3Nb2eZd5q01gepXnqiiulp/mD+vyWVdmiM56sU1q837O45Xpwr2bVxBITYoSI9Pmaqqmhr9/dsVJ33Pu8aNM7/HPb3MEYeGwwX5ZjKYURmrlrFuHN+h/PwW/MQA0P4xNgWcOoxNoSUUN9GScu6sMs38qEz9B1o1ZYYjAevyq4P0yFPhjZbrb3b8zjF8pJ9539ivOc89WWS2avr9vXXJe8mdfGS1SksXlju3GetWX8dj8Ey1SVCfvX5MJUV1Ez8Ns9/LVU5GtXoNDpTVzzHuWXrCPoZjmVX6xx+PysciXXlH7Enf762/ZZmxdfVddfvFd7TKYvXS2sVFzm3GusXXS/EdqczniboOcfwN++bNNLMSVX1LPkhXXkalugwKNSuglRdXK/OAI5G0vsryGv33L3vNKllDp0fL5yRJgAveTlP6vjJd/tduzm2BIRaz2tbWpXnObVuOr8dT/crj7Zh1yEx86n1mR1l8m/4bVFHcOAGwOKtM8x9aK2+Ll8bcevLuV8tf2GKOpY//bX/ntrDkYPO5B5anO7cZ60Z1rPDkk5RoA/CzQgWsEzz77LNmC8IuXbqotLRUH3zwQaN9tm7d6lxfuHChMjIyzPVzzjmnVRK2ADT22rsF5ixAw9Ydjh+a33i3UEu+dXxZHzvCXzdc7qgydPevI/TF3BI99c98bdhSoSH9/bR+S4XmLynT8EF++t2NDRNYJo4NNAfGXn+vUMOmpurMyYFKz6zRR18UKTLCW88/2vyPxwdTq/TA07l67I9RDWYuGm67IVx/ePSYzr4iTUnxFv3ng0KdNSVQ3btwIenuOt46XbvuekuHn5+t/JW7zbaEZfszVLTpkFnNKvG6Sc59I07vo/xvdyl/xU7t+M1rCh3SRTUlFeY2IyGr8+/PkSWk6VmqJTuPKnvWOnX58y/lE1jXEsAnwFdRUwcqZ/YG2SocFw55i7cp5uyh8vEnfjxZzPXn6Oj9ryr7lc9VsnaHrAnRqjyYrrKtB2SJCVfUFVOd+1YezVb+58satLGsOpqjrH/PdO4Te+sFTb5P+e5UFcxdrbi7L5N3QF1sefv7KXTSEBXOXyP78dgqXrFZodNGypvY8kglqzar8OsV8u/ZWT7R4fL281VVRo4jGaqmRqHnnC7/XnXJK5G/OktZz/1XuW98qtJVm+XbKUG20jKVrt8hW1GJAof3VUC/ugGs+qqz85Q/8xuFXzRVlqiGf0tDpo5R/kdzlfXMW/KJDFXx0nUKGNRL1riGM8bQfl09eLDO691Ha48e1bHSUsWHhGhy164KsFp137y52paV1exzB8XH68qBg3TzF5+rxOhpclxpVZU+3rpFlw8cpACL43vWub17660NG1RWv+IaAADAKcDYFE6lS87NUVy8j7p2s5jtCLdsqtLqlZVK7uijZ18Mb9Sq0lUb11fqvbdL9c9XIxQUXDd/PyjIWxdcEqgP3ylVebkjKfCrz8p1+TWBCqxX1Q2eZdyZoZr9XqC2ri7VTWfs0cgzQhQU6mO2Hdy0skR+/l664U8dnPt/8VauFn2erz7DAhUeZVF2epVWfVOkijKbfvd4orr1a74y384NpZr1Tq7+/FJHBQbXJUwYrQ2nXhSu2e/lqeJ4bC3+okBnXxkpf2LLIw2bHq0l76drz9pC/WX6Og2cFGkmRB3eXqydqwpk9ffWxfc5xqaK86t1/5nr1Kl/sJkYZSRNFeZUasfKfDNRK7FHoH55d/Mt5nKOlOuLFw7p/Ds6KzK+bszTcMZVCZr5zEE9f/M2RXTw04qZmRowIUIdOjcfp/AMWz6rbT/Y/KTRDe/v0Y7Zh5U4KFqBkX4qyiw1q2ZVlddo6v3D1KF38+0H0zYf06aP9uoXfx8r36C671K+gRb1Oy9Fmz/Zr+pyR0LqzjmHNeiSbrIGkHIBwIGzwQkqKhw90/fv36/LLrvse/d/+OGHnesHDhwgAQs4RYwBrrc/Kmq4bU25udSqHeQySrsvmpmoB/+Wq5mzHDMF42Mt+v0t4br/zkgFBDS+kHvp6Rj17+2rV98p1POvFSg40EvnzQjWI/dFqWvn5mcF3nJ3lvm8W69t3GLuzv8L17G8Gr35QaEWr7DrnKlBeumpk88KgnswKlD1eu46pb2zVIXr9qlow35ZIoLNBKi4y8bJGh7UYGZryr3nKeuLtTo2f6Ny5myQl9WioN6Jirt4jEL6O1oanshoBXbo+dkKH9tL4SO7N3o88fozZK+yKW/FTvO+kZBVP/ELnlsFK+mxW5T70UKVbtqj0k37ZAkPVui0EYq4cIIsYXUzZ2ryi1W0pGEVtpqChtuaSsAyYstI8Aoa1VdBQ3s1ejzqimnmPiWrtpn3QyYOaZD4Bc/i36eLqtKyVXkoTeW7D8peWSWf4CAFDOyhkDNGKaB/w/NLwMCeivvLLSqcvVQVuw+pfNcB85xlTYhV0HmTFHLGyGbf69h/PpM1qYNCJo9q9FjomeNlKy5V8bJ1su+oUuDg3oq89rxW+cxwT+vT0jQyKVlndOmiUH9/5ZeVafGBA3p5zRptz24++cri7a3Hp0zRnD17tHD//kaPP7Zkiaw+PprRvYd532iN+MSypa36WQAAAJrC2BROpRlnB2j+1+XatKHMbO+VlGzRLbcFm5WtgkNaJkmlqsqu++8t0NQz/TVxiqOiVn33/DnE3GfebEeMX3hpgO76Y8PqbfAsRuLeI2920qf/Oablswu1+MsCM77Coy2aeF6YLv6/GHXsVpfU0ntIgLasLtHqBUUqLrQpJNxHw08P1i9vjlbXvs0ntRiv+fwf0zR2eqiZ5HWi6/8QZ8bWijmF5v2pF4fruvvqEr/gWbx9vHT7G/30zZtHtfbrHK3+KtuMgdAoq0b+IkZn3pys+K6OKlRB4Radflm8Dm4pMqtVlRRWy9fPW3FdAzTpygRNvDxevv7NV9l754G9SuwepAmXN67eOvW6RBXnV+nbmZnaVVaggRMjdcVDTU8yhOdI35qrY3sLFdcvUjHdG3/XqZUwMFpH1mVr/9I0lRdWKiDcTylj4zX82p6K7dV88pVRWWv+w2vVfXKSup6e0Ojx038/0Nxnz4Ij5n0jIWv87QNa6NPhp/KyOxZ35K7HhZbnZTfq58Hpmmuu0VtvveXSc40ErM6dO//kYzhy5IiSk5PN9dTUVLP0O9BSbBmNEzuAn2r4+ovb+hDQThUUNx7wA36q6grmIKDleWdTNQAtpzo/X6kPP2Kuc00IoC0wNoXWxNgUWsPuqrrWikBL2l8V2daHgHboaFXzCSCAq3aW0UYcLceoGvbq9Fluf01Y/9q19zX3yze4YWVZd1FZnK8dbz7k9v898dNRv/MEb775ptnT9WTLAw884Nx/0aJFzu0tkXwFAAAAAAAAAAAAAAAAwHOQgAUAAAAAAAAAAAAAAAAALqL/CgAAAAAAAAAAAAAAADyT/fjijtz1uNDiqIAFAAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAXEQClgv++te/ym63m8uECRPa+nAAAAAAAAAAAAAAAAB+lrzs7r3g54EELAAAAAAAAAAAAAAAAABwEQlYAAAAAAAAAAAAAAAAAOAii6tPBAAAAAAAAAAAAAAAANqU0ebPXVv9uetxocVRAQsAAAAAAAAAAAAAAAAAXEQCFgAAAAAAAAAAAAAAAAC4iBaEAAAAAAAAAAAAAAAA8Ehedsfijtz1uNDyqIAFAAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAXEQCFgAAAAAAAAAAAAAAAAC4yOLqEwEAAAAAAAAAAAAAAIA2ZT++uCN3PS60OCpgAQAAAAAAAAAAAAAAAICLSMACAAAAAAAAAAAAAAAAABfRghAAAAAAAAAAAAAAAACeiRaEcANUwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAuogUhAAAAAAAAAAAAAAAAPJKX3bG4I3c9LrQ8KmABAAAAAAAAAAAAAAAAgItIwAIAAAAAAAAAAAAAAAAAF9GCEAAAAAAAAAAAAAAAAJ6LVn9oY1TAAgAAAAAAAAAAAAAAAAAXkYAFAAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAXGRx9YkAAAAAAAAAAAAAAABAW/Ky283FHbnrcaHlUQELAAAAAAAAAAAAAAAAAFxEAhYAAAAAAAAAAAAAAAAAuIgWhAAAAAAAAAAAAAAAAPBMRpc/d+30567HhRZHBSwAAAAAAAAAAAAAAAAAcBEJWAAAAAAAAAAAAAAAAADgIloQAgAAAAAAAAAAAAAAwCN52R2LO3LX40LLowIWAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAAAcBEtCAEAAAAAAAAAAAAAAOCZjDZ/7trqz12PCy2OClgAAAAAAAAAAAAAAAAA4CISsAAAAAAAAAAAAAAAAADARSRgAQAAAAAAAAAAAAAAAICLLK4+EQAAAAAAAAAAAAAAAGhLXnbH4o7c9bjQ8qiABQAAAAAAAAAAAAAAAAAuIgELAAAAAAAAAAAAAAAAAFxEC0IAAAAAAAAAAAAAAAB4JqPNn7u2+nPX40KLowIWAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAAAcBEtCAEAAAAAAAAAAAAAAOCRvOyOxR2563Gh5VEBCwAAAAAAAAAAAAAAAABcRAIWAAAAAAAAAAAAAAAAALiIFoQAAAAAAAAAAAAAAADwTEabP3dt9eeux4UWRwUsAAAAAAAAAAAAAAAAAHARCVgAAAAAAAAAAAAAAAAA4CJaELo5W9Z42Sz8M6HlDF9/cVsfAtohH29bWx8C2iu7V1sfAdohexVzENAKOF+hJRFPANwIY1NoaX/O6t/Wh4B2KN43v60PAe1Uqc23rQ8B7VBWZWhbHwLaoR2FcW19CGhHyoqK2/oQAI/E6AkAAAAAAAAAAAAAAAA8lpe9rY8AP3dM/wcAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAuogUhAAAAAAAAAAAAAAAAPJPd7ljckbseF1ocFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi2hBCAAAAAAAAAAAAAAAAI/kZXcs7shdjwstjwpYAAAAAAAAAAAAAAAAAOAiErAAAAAAAAAAAAAAAAAAwEW0IAQAAAAAAAAAAAAAAIBnMtr8uWurP3c9LrQ4KmABAAAAAAAAAAAAAAAAgItIwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAusrj6RAAAAAAAAAAAAAAAAKAtedkcizty1+NCy6MCFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHARLQgBAAAAAAAAAAAAAADgmezHF3fkrseFFkcFLAAAAAAAAAAAAAAAAABwEQlYAAAAAAAAAAAAAAAAAOAiWhACAAAAAAAAAAAAAADAI3nZHYs7ctfjQsujAhYAAAAAAAAAAAAAAAAAuIgELAAAAAAAAAAAAAAAAABwES0IAQAAAAAAAAAAAAAA4Jnsdsfijtz1uNDiqIAFAAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAXEQCFgAAAAAAAAAAAAAAAAC4yOLqEwEAAAAAAAAAAAAAAIC25GV3LO7IXY8LLY8KWAAAAAAAAAAAAAAAAADgIhKwAAAAAAAAAAAAAAAAAMBFtCAEAAAAAAAAAAAAAACA56LVH9oYFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi2hBCAAAAAAAAAAAAAAAAI/kZXcs7shdjwstjwpYAAAAAAAAAAAAAAAAAOAiErAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAiyyuPhEAAAAAAAAAAAAAAABoU3a7Y3FH7npcaHFUwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAuogUhAAAAAAAAAAAAAAAAPJKX3bG4I3c9LrQ8KmABAAAAAAAAAAAAAAAAgItIwAIAAAAAAAAAAAAAAAAAF9GCEAAAAAAAAAAAAAAAAJ7JaPPnrq3+3PW40OKogAUAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAABcRAtCAAAAAAAAAAAAAAAAeCQvu2NxR+56XGh5VMACAAAAAAAAAAAAAAAAABeRgAUAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAABcZHH1ie3Z2rVrNXv2bC1fvlzbt29Xdna2rFarEhISNHbsWF1//fUaN25cWx8mAAAAAAAAAAAAAADAz5vN7ljckbseF1ocCVgnOO2007Rs2bJG2ysrK7Vnzx5zefPNN3XVVVfp1Vdfla+vb5scpyd555MiLf+uTOs3V2jLzgpVVkqvPxeray4JbXL/wiKbHvzbMc2cVaKM7GrFx1r0y3OCdf+dkQoOaly0zWaz69//KdCr7xRq78EqBQd66YzTAvXIfVHq0snaYN+aGrue+meeXn+vUMfybBo+2E/PPRSjPj0b/zu+8t8C/f7+HG1a1FFdOzd8Hbi//G93KXvWOpXuy5StvFLWyGAF9UxU4nWT5BvTMPYqMvKV8dG3Klq/X1V5JfIJ9pN/crRizhqqiPG9nfvZKquV9tZi5S3fIVtFtYL7JSv5lqnyjW4cy0ffWqxj8zapz0s3yRIScEo+M1pf3opdypq1QSV7M2QrrzLjKrhXgpKunyi/JuIq7cOVKlx/QFW5jrgK6Bit2LOHKHJ8rwZxdeTNJcpdtlO2iiqF9O+oTrdMbhSnBmO/7Hmb1f/lG2UJ8T8lnxmnRvHq7Sqcv1oVB9Jkr6iST3iw/LsnK+pX02SJDnPuZystV+4ni1Syepuq84tlCQ9R0Ki+ivzlRHn7+zV4zZriMh377xyVbtwtyUuBg3so6orp8glufE7KfP4jVRzOVPITt8rL4nNKPjNaz9F7nlDNsfwmH/PrmaIO99zcaHtNYbEKZy9S2aadqs4tkLefrywdohU0ZohCJo5y7me32VQ4Z4mKl66RraREfinJirjsHFkTOjR6zeIl3ynvg68U9+DtssZGtfCnhDu4efhw3XvaeHP9gvfe18b09AaPD4yL060jR2hoYqKCrFalFxXpi5279OLq1aqorm6wr6+Pj+4eN04zevZQgMWi1UeO6MGFi5RRXNzofe8aN1YX9eunKf95U4UVFa38KQEA7QFjUziV7Ha7di9I09r39+vYwSJVFFcrtEOAOg6L1qjreigiKajB/hXFVVr24g7tWpCmkpwKBcf4q9eUBI27pbd8AxsO35cVVmrB01u0b3mmvLykruM6aNJd/RUQ2jh+Pr9vjbJ2F+i6DyfJx0ojjPYSW5vn52jJu0eUtb9UZcXViojzU7cREZp8Q0dFJzc/BpmTWqYnzlujytIajb0kQZf8tWeDx6sqavTls/u1cW62Kstq1G14uC78U3dFxDUef/ry2X1aNTNDf/pqhALDODe1h7ja9k2Wvn33kLIPlKi8uFphcf7qMjxSp1+foqjkQHO/miqbti/K0o5F2UrdWqCC9HJjuEkdugZr6HkJGnFRsrx9vBrF1dzn9mjLvExVldUoZXiEfvGH3ubrn+jr53Zr7cyj+v2X44grD7fti4Oa+8Cak+6TPCJWF718uvN++pZjWv36Th3dlKOqkmqFxAWq5/Rkjbiut6z+DccqqytqtPyFLdr9zRFVl9coaWiMJt4zSCEdHLFan7Hf1s8P6JqZ0+XfxN9KeI4jc3ZoyxPfnHSfqCFJGvHs+eZ64Z5spS/ao8Ld2SrYnaWqgnJFDkrUyH9c0ORzayqqtfvVlcpYvNdcjxyYoN63na6A2OBG++565VvzeE57+3JZ+Z0GwAlIwDpBWlqaeWtUu7rooos0fvx4dezYUTU1NVq5cqWeeeYZHT16VG+//baqqqr03nvvtfUhu737nzymQ0eqFR3pbQ5YGevNKSm1aeIFR7Rxa6WmnB6gS88P1oYtFXrmxXwtXVmmxZ8myt+/4YDBLXdnm4NWfXv66rfXhykto0Yff1mk+UtK9e1XSerepe5L1XOv5OvPT+RqxhmB6tHFqnf/V6Tplx3V9mWdGgygpWdW675HjumBuyIZ4PLAC8bUf85Rztcb5RcfoYjTessnwE9VuUUq3nJYlVkFDRJbCjcc0P6HPzHXw0Z2k29chJm0UHYgW0UbDzRIwDr6+gIzqcvYZgkN1LH5m7XvoY/V69lr5eVTFz+lB7KU+b9VSrn7FyRftaO4OvTCXGXPMeIqXFGn95F3gK8ZV0VbUlWZWdAgAatg/QHtfWimuR4+spv5nOqicpUdzFLhhoMNErBSX1uorK/WK9KIq7AA5czboj0P/k99/nF1o7jK+OQ7dbnnHJKv2lls5bz2hQoXrJWlQ6SCx/Q3E6mq8wpVvuOgqnLynQlYRjLp0YdeV+XBDAUM6KbgMQNUcTBdBV+tMPdNeOB6efvW/c3K+tcnKt28TyGnDTLeSEXLNqqmqETxd1/R4BhKNuxW8cqtSnzoRpKv2hGvAH+FTBnbaLslKqLRtsrDacr6++uylZYpoH8vBQ7rL1t5harSs1W2aUeDBKyiectVMHOu/Pv3lDWut0pWbjSfG//InQ2SAGvyC5X38RyF/WIyyVftVI+oKN0+ZrRKKisV1MSklGnduun5s8+SzW7X13v2KLukREMTEnXb6FEa0zFZV3z8iSprapz7//H003XFoIGatWuX8srK9ct+ffXKeefqvHffM1+jVq/oaN04bJjumD2H5CsAwA/G2BROpYXPbNXq/+41E6l6TEyQX5BFmbsLtHHmQW3/+oiueut0xXR3jCFUllbr3euWKXNXgVJGx6rP9CRl7izQd2/t1eG1x3TFf8bL4ld3nfblH9fqwMos9T+no3GZp61fHVZpfqUuen50g2PYuyxDO+Ye0ZVvnU7yVTvy2VP7tOjNVIXG+Kr/GdHyD7bo6K5irfw4TetmZeqO94YooUdwk0mi7/5hx/e+9vL3j2rw9FgFRVj13afpevXWLbrr42ENkmqM91vwRqqueqoPSTLtxKynd2n5W4cUEuOnPmd0kH+Qj9J3FWnNJ0e0aXa6/u/dkYrrHqJjqaV6945N8g30UbdRUeozIcZM1tqxOFufPbxDO5fm6Op/DZaXkR163Oynd2nVB6nqPz1OQeFWrf0sTW/9Zr1+8+HoBnFlvN/S/xzUpU8OIK7agZie4Rp1c58mH9vzzREd21eozqPrJvLtWXBEs+5bJS9vL3U/I0lBUf5mItZ3r+5Q6pos/fLl02XxrftbuOTZTdr00T71nJIs/whfbfv8oD6/fYV+9c7kBnGVvTtfa9/epRmPjiT5qh0I7RatbteMaPKxjCV7VXwgV9HDOzq3ZS7fr/3vrpOX1VtBSRFmAtbJ7HxxuQ5/tkXxE7vLGuavo3N2aP0fv9KYly9u8DtN4b4cHfhggwb+eSrJVwCaRALWCXr16qXHHntMF154oXx8Gv4IOWrUKF155ZVmG8Ldu3fr/fff1y233GJWzULzXnkmVt1TrOqUbNWTL+Tpj48da3bfp/+VZw5w3fObcD3+p2jn9j88mqOn/plvDlLdd1ukc/uiFaXmANdpo/w198NE+fo6vlxddn6wzr4iXb/9Y7a+/iDRuf9r7xbqjNMC9NU7Ceb9888M1oTzj+qr+SW69LwQ536/+UO2unS06o6bw1v8vwdaV/YXa8zkq+izhij55qkNvhgZ7DU257qRjLX/sZmyRoWo+6OXyTc2rNl97Ta7cuZtUtTUQep025nmtsCeCTr0zJcq3ZOuoF6Jzuccfn6WwoZ2VcT4pi8y4HkyP19rJl8Z1as63jL5pHFVkVWgfY9+Jmt0sHo+dqn8vieusuduVvS0gUr53QxzW1DPBB3421cq2Z2u4N51cXXwuTkKG9ZFkafVJQXC8xXMWWUmX4VOHaHoa86Sl/eJsVWXnJD/5TIz+Sr8F+MV9aupzu3H3pun/C+WqWD2t4o4zzFzrDqvSKUbdivykjMUcf4Ec5slJlx5Hy9UdX6RWTnLYCTZ5Lz+hcKmjTQrbqH98A70V/i5U753P1tZubJfeNtcj/vLb+WbHN9sDBqKl66Wf59uir39WvN+wJB+ynryZbNyVtDIgc79ct/9XJaYSIVMpW13e2Tx9tbTM6Zre1a2Dubn6fw+Db/z+FksenjKZBlpUxe9/4G2ZmU5H/vrpEm6avAgXTd0iF5a7ZgRa3yDv7hfP320Zav+OH++uc2opvX3M2doQFycs7KWt5eXHp86VUsOHtTs3UZ1PwAAfhjGpnCqFOeUa827exWWEKjrPpok/5C6RAIjKWvB37Zo9X/36KyHhprbVr25x0y+GnVtd028vZ9z30XPbdWq/+zR6nf2asz1jkpFxdnl2rcsU6f9po/G3ujYZrzPsn/vMN83ONrfmdQ199GNGnJJFyUOqItVeLbC7AotfjtVkQn+uvez4QoIqftpx0jK+vTJvVr0Vqouf7TxuNHit1J1YFOhzr2rqz59Ym+TCVqr/peuURfG67KHHZMGOw0I1Tv37dChLYVKGXR8YliNXe//Zaf6jI/UkBmxrfp5cWoUZVdoxX8PKTzBX7fPHNPgnLXsrYOa9dQuLXvrkC56pJ+ZTHrun3tr6LkJDarznXV3tV65Zo12Lsk2K10NmBbnjKs1M49q2AWJuvAhx/kteUC4PvrDFh3ZWqCOA8OdcfW/+7eq57hoDZjueC48W2zPcHM5kVFFbeOHe+Vt8VKfczqb26rKa/TNo+vN9Uv/M0kd+kQ4J60ufHKDNn24T+vf2aMR1/Vyjqdv/eyA+p2Xoqn3DzO3xfeL0td/Wa2MbblKGBDljKt5D61V5zFx6jmVMc/2ILR7jLmcyFZVo0OfbjZ/s0mcXvc3MG5CN8WOTVFIlygz+WrhBW80+9pGXB2ZtV1JZ/ZR/3vOMLeF947T5sfmK39nliL6xjl/p9n61ALFjOyk+EndW+Vz4icyBiPdtdOfux4XWhzTX07w1Vdf6eKLL26UfFUrOjrarIJV65NPHJVz0LzJpwWaA1zfx/hCZQxYBQd56c93NBwcMO4b243H6zMGrQwP3hPlHOAyzDgjSBPGBGj+kjIdPlLl3J56tFpDB9RVZxg20M+5vdbMWcX6cl6JXnkmRhZLw5K5cG9G+7b095bLNy68yeQrQ/1tRttBW2mFOv5meqPkqxP3rS4slb2yWoHd6i4CA7s5fqSuzC5wbsv6Yo3KU48p+dfTWvSzoW3jKu3dFfKLC28y+cpQf1v6hytVU1qhzr+Z1ij5qrm4CqoXV0HdHeuV2YUNEsDKUo+p06/rkm7g+WyVVcr73yJZYiMUffWZjZKvDF7Hv48YfyMLF66Tl7+vIi5wJFTVMu4b243Ha1Ufc5yX/FLqfujx6+JYr86pO2flfvCN+cU/8tLJrfAJ4QmKFq1STW6+wi+c3ij5qn4M1qrJK5Bvp7q48u2c5NieW9fysHTdVpVt3KGoay5s9Hy0D78eOdKsgHXv3LmqsTUePRiaEK/owEDN37u3QfKV4ZkVK8zbXw0Y4NwWGRAgf6tFWzMzndu2HF9PCKn7IfraIYPVJTJC93+zoFU+FwCg/WJsCqdKQVqp7DYpcVBkg0QGQ7fTHNf7pXmVznjbNPOgmcgw9qa6StkG476xfdPMQ85thRml5m1cn7ofteP7OtYL0x2PGRY/v828zptwW99W+YxoG8eOlpuxlTIkrEHylaHvBEfCQXFu3bmmVub+Es36xwFNubGjkno3ro5lKMmrUlWFTcl96757d+znWM9Lr6s6u/i/qcrcX6qL7u/RYp8LbSsvrcyMq86DIxqds3pPcCQ6lOQ6zllhHfw1+rKOjVqjGvfHXe1IpjmwJte53TjXVVfYlNi3bnw0qa+j+l++0b7wOCMBzGh9eN5fmMzc3u1ddFTl+ZVKGR9vVrkypG/KUVlehbpNTHQmXxmMSmpjf+1I3Nv8yT7zb6ahLL9CNRU2dehdt2/t84qO/500bHhvj/IOFumMPw45ZZ8PbSNz2X4zwSp2dGf5Rda1oQxJiVJYj1h5/4COD5UFZbJV1iisZ11yce16eWaRc9vBTzap+HCe+tzRcHweAOojAcsFEydOdK7v27evTY+lPdmzv8os0T5meICCAhuGpnHf2L7/ULVSj9ZdSC75tkxBgV4aO6JxmcepExx/aJesLHNuS060mGXja60/vm5sNxQU1ui2P2Xr9pvCNWQApSM9TeH6A6opLlf46B6y22zKW7HTTLLKnr1e5Wl1F38G4wt73vKd8gkNUMjAzmYVq8xPvzNbBxptCY2M9/qMloNevhaV7ctwbqtd941xXERWZOYr/Z2lSrxmgnyj69rRwbMV1MbVmO7mDIfcFbuU/tFKZc3aoPK0vEZxlbtspyyhAQod1FklezKUMXO10j/5TgUbDjYbV6X76n5wLt3rWK9tlWnE1dH/LlPStac3aJ8Jz1e2ea9sJWUKGt5bstlVvHqb8j5fqoL5q1WV0XBGflX6MdXkFcm/Z0d5+zcsmW3cN7ZXZ+U5k6ssUcfPSwcdrZUNlcfXa1salu9JVcHc7xR9/TkNWsehfbBX16h4+VoVzFqkogXfqmL/4Sb3K129yRjVUuDQ/qrKyFbRghUqnLNEpRu3y17duDWPT0SY2bKwVtWho47tkcdnrpaWK+/dzxUyZVyDRC20H31jY3XryBF6fuVK7c1t+P2qVkxgkHl7pKDhD9SGoooK5ZeVKyksTB3DHOej3LIylVdVq09s3UBXv+PraUWOga7E0FDdPmaM/rZ8uTKKi1vlswEAwNgUfqqIjkFmy7+jG3NVUdwwGWbvUsc4UqeRjqSG3EPFZlUrI1mrqYQGY3v+kRJn4lVonCOeMnfWTX7I2OG4BgyNdzx2dHOu1n+4X9P+NKjRa8KzxXYKlI/VSwfWF6isuOG12rbFjjGEHqMatpw3KsC884cdiukUoGm3OBJkmmK0HLT6eevIjrrv2anbHd/DI+Id4wXHjpZp9gsHdc4dXRQRx7mpvYg6HlcHN+SZ7QTrM1oLGrqN+v5Kej7Hk4Xrt38LjPCVxc9baTvqrguPHl8Pj3fEUO7RMs3/515Nv72Hwoirdm/rpwfM2/7nd3FuKznmSMYLTXSMI9TnH+Irv1CrmWRccKTE3BYQ7icfP29l7ar7W5i10zFGH3L872RBWom+fXGrxv22v0I61CXkoH1KnbXNvE062/UkTt+wAHn7+qhwj+O8Zyg4vu7fwZGQXJpeqD3/+U49bxqjgNimE5oBwMBVmAsqKuoGSZqrlIUfb88Bx6BE9y5Nz0g0ts9b7NgvOdGqklKb0jNr1K+Xr3zqfbGv1S3F8Tp7j7+u4fpfhereh4/pnCvT1KOLVe/+r1gJcT46e4rjy909Dx1TgL+XHryb8tyeqHSvoz2NvL2149evqeJovR8Fvb0Ue+4IJd3gKB9amZGvmqIyBXaP1+EXZpttC+sL6NpBXe+/yJlIZfQfj5oyQDmz16umrFKWkAAdW7DF3M94DcPhf85RQEoHRZ/lKCOP9qF0j2OA1KhOtO3WN1R+Qlx1OG+4Ot44ybxbkVGgmqJyBXaP08HnvzbbFtYX2LWDuj9woTORyoirmKkDlDWrNq78lfPNVnO/oB6OuDr4/FwFdok12x+ifanYn+aMrdR7/mkmWTl5eSnszDGKvnK6ebc2Icsa55jVeiJje9mmvarMOGYmWFkiQhQ4uIdyP16kqqw8c/Zz0dKNChza02w/aCTnZL/ymYJH91PQEEfrCrQvtoIi5f6nYaVW35QkRd10mayxjjgyEqyqjmbKOyTITLwq+NyoiFaXKGq0EIz+zVXyTaqr0hd82nDlfzxHWf94U9YO0SpZtUE+4aEKGOiYsZ/38Wx5+VoVdt73tz+E5/H18dHfZkzXjuxsvbxmbbP7GQlVhqSwxonDIb6+Cg9wDKynRETocEGBWYH7421bdfnAgQr29VVeeZku7NvXrIi1OcPxd/jRKZPN9/3vxk2t9vkAAGBsCj9VYLifJvyurxY8s0WvnPeNuk+IN9t2Ze4u0KHV2RpySYqGXer44TnvsOPH5MiOTf+IZ2w/8G2Wcg+VmMlXwTH+6jq+g9ly0EjMMr5EbfnysLqdHme2HzRaO815cIN6TU1yVttC+2EkSf3i91312VN79eiZ36n/pGj5B1t0dFex9nyXp3GXJeq0yxtOgpn/yiGlbi/W7z8YKotv83Pxvb29NPKCeK344KgqSqoVFG7Vd59mmBWzOvV3fKf/8IFdSuwZpPG/YqJNexIU7qvpd/TQ7Kd36Zmzl6vPpFj5B/kofVeR9n2Xq1GXJmv0rzp+7+us/dQxOav72OgGcTXs/ER992GqGVeB4b5a99lRJfQOUVI/x2ScT/+6TfE9QzTqMlrEtXeFaSU6vDpTwR0CzLaAtYyEKvPxo46/ifVVFFWpotDxHSrvUJHCk4PN8fR+56Zo08f7VFlSpYAwP2378qBie4Urrq/ju9M3j6xTTI9wDby46yn7fGgbZRmFOrb+iPxjghUzopPLr2PEldF+8PDnW1RdWiXfUH8d+XqH2fIwvJdjguC2ZxYppGu0Op7XvwU/AVqacUXm5aat/qhr/PNBApYLlixZ4lzv3btxT3W4pqDQZt6GhTR9MRga7N1gv+/d//j22v0Md9wcrooKu954v1DLvyvX8EF+eu7hGAUHeZszFo0y8l9/kCCr1Ut3/TVHb35YqNIyu6ZNCNTLf4tRbDT/l3Fn1QWOGYFZn35ntgrs+ew18k+ONitVHXphjrndLz5cMWcNde5bui9D5UeOqdPtZytsVHezdVzGh9/q2NyN2v/YTPX6+zXO10+6/gx5WXyUv3yHbBXVChnUWcm3OFodGslYxZsPq9cL18lWXqXUF+cqf8VO83nhY3sp+dZp8jmhag08Q9XxWDEqWRmtAns/d7UCOkaZVauMJKvMmavlHx9uJkhV5zsuFI3Hyo/kKuX3Zyp8VA/VlJYr/YOVyv56k/Y++pn6PHeV8/WTb5hoxlDu8p1mXIUO7qxOx1sd5nyzRUWbD6vvP6814+rQv+cpb/ku83kR43qaLQmJK89VU+iIl/xZ38ovJV6Jj94s38QYVRxIV/arn6tg1gpZO0QqbOoIs6qQwTuw6dmA3gGOwYra/Qyxv75QOW/PUcnanUY+l0LGDVDUlTPMx4xKW9V5RYr/87Wqzi9W9mufmwlcRkW2kAlDFHX5tCZbIsIzBI8dJr8enWVNjJOXn6+qM3NUOG+ZSlduUNbfXlX8g3eYMWNUYJPNJltxqQq+XKjwi2YoaPQQ2WtqVLzkOxV+tUjZz7+phEfvlJfV8eNhyNTxsldVm9W1KvYckG/nZEX+ylFFrXzXfpUsW6PY319nnsPyPvxKJcvXme02A/r1UOTVF8gnlBlinuyOMWPUOTxc577zrmz1kvVOtC4tzax0NaVbN/WJjdH2rLoZhLePHeNcD61Xfe+xJUtVXWPTjB495G+xaMWhQ3pw4SLzfc7v01sjk5J0zn/fUaDVqr9OmqQZPbqbz5uze48eWLBAZU1UbAMA4MdibAotYcSV3RQS66/ZD27Qho8d1T4MSYOj1HdGsrwtjriorZDld0Lbr1p+wY5/6/qVtM55dJi+eXqz9ixKNyfu9D0zWWfc7fghcOXru1WUXabLXhlnVhSZ8/BG7V+RKaufjwac10kT7+jXoDoNPM/Ea5IV1sFP7/9lp1Z8WFeZuMvQMA07O1Y+x2PLcHRnsb5+8aDOuC5ZHeu1FmzOefd0NasYbZybZbYj7DkmQhf+qbsZM6s/y9Ce1fm6Z+ZwVZbW6ONH9mjjPMd3/EFTY3TRX3rIL5CJ6p5q/NWdzfaC/7t/q5ksVavzkHANOiu+QVw15buPUrVrWY66joxUr9McFf5qnXV3TzOutszLVFV5jbqPidIv/tDbjKt1nx/V/jW5uu2TMWZcff7oDm2d5+gM0G9qB533595U8mtHtn5hdIeQ+p7TucHfooRB0fINtpjtCY1KVrG96ir5GVWs6idj1TrtjoHm39Ld81NVXVGjTqM6aOI9g8zX3f7lQR1Zm60r3p+iqrIaLXxivfZ8c8R8XvfJSTrjD0NkDSCu2osjc3aYnSUSZ/Q2xyJ/il63jpOXxVsZi/eav9NED0tW79tON1/36Nc7dGzjEY197TLVlFVp+z+WKGOJo0NW3Old1ef2CbIEfH+7cwA/D/yV+ZFsNpueeOIJ5/2LL774R7/GkSOOP/bNSU8/XsUHLc6YjfinOyLNpb7ycptuuSdLV14UosmnBeqJ53P17zcL9MyD0UqKt+i2P2br2t9lada7CW127Ph+te3dvKw+6vLnX8o3yjG4ENyvo7r84Xzt+O3ryvp0tZmA5WwFZ7Mr4YrTzOpWBqOyVafbzlTZwSyV7kpT8bZUBfd1zMDx9rMq+aYp5lJfVUGJjrz2jTpcPFoBHWPMiloFq/ao42/PNB9P/fdc87kdf+2oZAMPczxWvK0+6nb/Bc64CumXrK5/PE/bfv2GmZxlJGDV9qI3v/RfOV7RzrjyV+ffzVDpgWyV7EpT0dZU8/nm6xqxcctkc6mvKr9Uqa8uVPwloxTQKdpM9spftUedb5tuDrIe+pcjrjr/Ztqp/e+Blj9nWXwUd+evZIl0zCoN6N1ZHe64VEfu+ZfyZ60wE7Bc4RMcqA63Xthoe+XRLOV/ttRsPWgJC1baY2+pKi1bHX53sZmUdeztOfIJC1bEL8b/xE+IthJ2bsPziW/HBEXfcIlyjATRlRtUvHS1QqeNr/e30KaQyWMVOu0053PCz5uq6owcla7ZrNK1WxU0erC53UjMCzvnDHOpz15Vpdy3Zpr7+ffp7mh9uHCVIi49Wz4Rocp79wsde+Njxd5+7an4T4BWMDg+XjcMG6p/rFyp3ccatkk9UWlVlR5dvERPTJuq/112mZkklV1aoiEJCWZrwb3HjqlbVFSDJK6K6mo9vHixudQXGRCgP02YoJdWrzFbHj4yebKmdOuqP83/RnbZ9dAZZ6i8ukr3L1jYap8dANojxqbaDmNT7d/yl3Zqxas7ddqtvdX37I7yD7GabQO/+dsWvXvDMl3wzEizMpYrAsJ8dc4jwxptz9lfqG9f36Xpfx6koCg/fXDLCh07WKTznx6hoqxyM2nL2D7q2h4t8AnRVub864DmvXxIZ/42RcPO6aDAEIuO7CzWp0/s1fNXb9T1/+hnVsaqrrSZrQejOwZo+q9TftBr+/r76MI/djeX+opyK/Xpk3s15aZOiu8WpA8e2KUtC3N06YM9zcleHz20W77+3rr4Aapre6pv/r1Xi17erym/6abB5yTIP8Si9J1F+urJnXrl2jW64tlBZmWspuxYnKUvHt2h8AR/XfKkYxy0Pqu/j875Q29zqa84t1KzntqlCTd2UYduwZr5123avihLF/y1jznu+dkj282YPO9+11uKwX0Y40/bPj9oln/pd17Dc5KRZHf67wdp/kNr9f7VC80kqaAof6VtOqasHXmKTAlR7oEis0JR/biaePcgc6mvNLdCi/++ScOv66WorqGa/8g67Vucpsl/GWZWnlnw+HpZ/S064490mmgvcWUmYHlJSWf+9GIpPn4W9fntaeZSX0V+mXb8e7m6Xj5MIZ0jtfVvC5W5/ID63TnRPF9te3axfPys6vv7CT/5GAC0DyRg/UjPPvusVq9eba5fcMEFGjr0x7caS06mnGpTwkKPzwosqpsVWF9hsa3Bft+7//HttfudzMN/z1N+gU3P/NVRIvf51wp05S9D9H9Xhzlf66rfZGrX3kr17Ea1GXflE+SoohDULd6ZJFMroHOs/OLCVZGWp+ricue+hrCRDQcWzG0jupsJWKV70p0JWM058vJ8WcODFHfxWLOCVs78zUq4fLwiJ/Q1H6/IyFfG+8uUeN0k+QQQP56mNlaMtoInxlVg55gGcWWpF1fhoxrHVfjIbmYCVsmeDGcCVnMOv/yNLOFBir9kjCOu5m1WwhXjFDXxeFyl5yvtveVKvn4iceWhvAMd8eLXJcGZfFXLL7mDrB0iVJWRq5qSMmflq/oVruqzlVWctEJWLSNJMPuVz+Xfq5NCJwxR5dFslW3eq9jf/FJBwxwXqhUH0lQw+1sSsNqhkNNHmglYFXsPStPGN4iXgEGNByqMbUYCVuXBI84ErOYUfLFAtrJyhV9ytnm/6JsVChozRCETR5n37eUVOvbqh6rKyJY1ruGMWLg/Hy8v/W36dO3MyTEToX6Ij7ZuVWZxsW4aPlyTu3U1X2NzRqau/OQT3Tx8uJmAdazU0arwZO6fOFE5JSX693ffKchq1UX9+uof367UFzsdlUaTw8J02+jRemLpMjPxCwDwwzA21TTGpvBTHViVpWUv7tDwK7pq9PV1CSnJQ6J10fOj9eJZ88z2hGZrwmBro6oe9VUUOyp81u53sus8o/Vg8pAoDTi3k44dKNKBlVn6xePDnIleGTvytPqdvSRgebBd3+Zqzj8PasLVSZpyY12bpa5Dw3XTv/vrwamr9NmTe80ErPmvHlLa7mLd8d4QWU/SevCHmPnYHoVEWTX1pk4qL6nWqpnpOvM3nTXs7A7m4zmpZfr63wd17l1dzXab8Cx7Vh7TN//ap3FXdTKToWp1Hhqhq/81RE9NX6pZT+9qMgFr59JsvXvHJgVH++nGN4YrNKZuXPT7fPn4DgVH+WrijV3M9oRGC8Mpv+6mQWc7koxzj5Rqwb/3acadPYirduDQd5kqyihVxxGxCkt0tFyur//5KWab3TVv7TITpozEmg59IvTLl0/Xmjd3mglYAZHfH1+Lnt6goEh/jby+t9mecNvnBzT6lr7qPcPRRrPgaIlWvrxN428fQHW1diBnXarKM4sUNTRJgfGO78utYcfzS+UXEaiuVwxTdWmljszeoe7XjlDCFMf3vNL0Au19c7V63jJGlkC+o7c5Y67nSar2tyk3PSy0PP7C/MjWg/fdd5+5HhsbqxdffLGtD6ld6Z7iGEzYs7/pQYfa7bX7BQV6K76Djw4crlJNjd2cQVjf3gOO/bsd3785m7dX6G8v5umtFzooMsJHBYU1ysyu0aB+dV/oBh9f38kgl1vzT4oyb32Cmk5AqN1ur6yWX3yEZMyasNnlE9x4f0vw8XZelSdvZ1OwZq/ylu1QjyevNCsklabmSDU2BXRxDEIYArt2kL3apor0PAXW2w7PiitLs3FVFyv146o2hhrs+wPjKn/1PuUu3aFeT1/ujCt7ja1B/BBXns83wfHDinczseUdGOA8Z1njHHFYldF01Zna7b7H92tO4fzVqjiYruSnfuN4XrpRE0ny61w3+9pYL1q4zmyd6fM9CV3wLN4hjkEue6XjO5K3n69Znaomr9AZbw32Dzgeg9+T1FKZmq7CuUsVdf0lZuU1I1HQVlgs3+T4BlW4DFXpWSRgeaBAX1+lRDraAOy+4/Ym95n5q8vM25s//1zz9zrKsC85eNBcTvTMjGjV2GzaluloL9GcCSkpOqtnD13y4YeqstnUNSpSVh8fbc+ua2lotDf09fFRx/Aw7cx2nNMAAHAVY1P4qfYvd3y/6TS88Xfe4Gh/RXUOVubOAlWWViuio+P7ee7h4iZfq3Z7ZKfGP1bXt/6jA+ZrXv8/R5Vao/KVoUPPuh8jO/QK16aZh1ReVGVW5ILn2b4s17ztPrKuPVctI/GlQ0qgjuwoNpNZjFuj1dffL13f5GsZ7QuNpf8Z0brxn44Wlk3ZtuSY1s/J0u/eGSKLr7cy95fKVm1XYq+6CYpJvUNUU2VXTmq5EnvRct7T7FrmuLbqMqJhVUZDSIyfYlKClLajyIyr+olQO5dk653bNyowwqob3ximqOTAH/yeRuLW5q8zdMvbI8y4ytpfbMZVfL24Sugdqppqu46lliqhV8NJi/A8Wz91tOPtd37zFflSxsWby4nm/LlAXt7G37HG57769i9L1+55qbrk9YnysXord3+hGVcxPcKd+8T0DDe3FaQWm+vwbEe+2mbeJp3lmLDeGrJWHVT6oj0a9cKF5u80xYdyzd9pQrrXfc8L7R5j/k5Tmlag0G6MeQIgAesH27Ztm84//3xVV1fL399fH3/8sZmE5YrU1Lo+2s2VeR8xwrV2Q56sexerEuJ89O2aMpWU2sxBrFrGfWN7SkeLkhPrBglOGx2gDz8r1orV5eZ6ffMWlzr2GdX4B8VaxuDYTXdmaeqEQF16XsPKNhUV9VqiVB5vE2XUVYbbChngmP1VfqTxj2/26hqzSpG3v1WWsECzb3Nw7ySzxWD54ZxGVa7KDjtewze2+cz5mrJKpf7ra8WcOUTBfZIavl9VTeN14scjhQxwzJApS22c+GIz4irdEVfW2rjqk6jirUdUdiinUZWr8sOO1/DrcPK4MtoLxp41WCGN4qq68Tpx5bEC+jhmFlYdrUskqH/Oqso8Ji8jQSY0UD7hwfKJCFH5rsOylVfK27/uBxfjvrHdEhshS3TzsVWdW6jc9+cr8peTZO0QeZLYcpyziKz2p2L/YfPWElU3aOXXq6tZFasqLUu+nRIb7F+V7vjxyKfe/iey22zKfet/8u/bQ0EjBzZ8rJpzVntRWVOjD7dsafKxEYlJZnLW/L17lVtWpiMFhSd9raEJCWbVqkX796uosrLZ/QKtVj08+Qy9u2mz1qc1bINlJFw1WmcWGQD8KIxNNY2xKfxUNVWOqmeleY4qxScqzas0f0j2tngpslOwWfHj6MZcMyGrfjUO476xPTwxUKFxzSc2FGWWacnz2zT+1t6KSGqYqGW0oXMe1/F1wsfzY6s4t+kE0eK8KkdsWb3Vc3SEgsIbJ9oVZldo+9JcdegSqJTBYUrq3XzClJFw89GDuzTu0kR1GRzWbGw514ktj2QkzxlK8pq+Nis5HldGQsuJyVcBYVbd9J/hiv6eJNET4+qzh7Zr1CXJ6jQ44nvjir95nq8sv8KsauUf5qtukxqOO32foxtzVJhWqpRxcfI7SfKw8TdzwWPrNeCirkoY5JjweuK5s8E6YeXxKgvKlLliv6yh/uowvmurvIdR7Wrb3xer47n9FNGvYXKgrbKm8TrnKwDH/bT6sz8TBw4c0NSpU5WXlycfHx998MEHOu20hj1gf4ykpKSTLvHxjbO8fw6ML9PX/ypUxSV2PfKsY0ZPLeO+sf2GyxvOdrjxCsf9B546psrjA1GGOQtKtPjbMk05PUCdkpv/Yvb8q/nasadS/36iLis5LNTHnL04e2FJg9cz9O7ODDF3ZlQfChmSYiZa5czd2OCxjI9XqqakXOGje5pJMoboMx29vtPfXSZbveSD8tQc5X6zRd4BvgodWld6+URpby02y7wnXD2hwTF4WbxVsNZR+cFgrHtZfOQXz6wKT+SfEKHQ43GV/fWmBo9lfLRKNcUVihjTwxlXsWc54irt3eUNKl0ZCVw58x1xFXaSuDry5hKzzHLSNac3iqv8tfud24x14sqzWeMiFTCgm9lmsHDh2gaP5X2+VLaScgUN7y0vHx/zb2TopKGyl1cqb+bihvvOXGxuNx4/mezXv5QlLkphZ42pO4bjVbhKN+52bjPWjWSv72tnCPdkVJiyVVQ2uT3/k6/N9cB6iVIhExwtAgtnL5atXju4moIis42gMXgQOLRfs+9XNH+FmbwVeeV5zm1G7PiEhah8yy7ntrLj69Z41yYwoG1VVFfrD/PmN7msS0sz93lx9Rrz/o7j1amCfRtX5ogNCtLjU6eoqqZGf1/x7Unf865x48xz39PLljm3Hc4vMJPBjMpYtYx14/gO5ee34CcGgPaPsammMTaFnyppkKMq8er/7jWrTZ1YqcpImEocECmLr+M6b+AFnc0fjle84mivXMu4b2wfeGHnk77f3Mc2KiI5WMOv6ObcFpXiSOTbd7wal2M9w0z2+r52hnBfRsKUYfGbqSoralhZffkHR5WfUaGUQWFmy8HTLk/Srx7p1Wg543rHJMNuw8PN+8Z+zfnyuf1mB59zfl83hhWd7C8fq5e2L62bpGisG9uik5tPNIX76jzYMa64/C1Hhbz6Vn2YqoKMcnUcGG5WqqqtmGUmX4VafnTylWHuP/aYcTX9jrp2qEb1LB+Ll3YtrZugaKwbcRVFXHm8HbMOmYlPvc/saP7ta0pFcePE0uKsMs1/aK2ZsDzm1ubHpQzLX9hi/k4z/rd1Ff3CkoPN5x5YXjehy1g3kgnDk6nW5+mOztsle5XNbAPo00xc/VS7X11pdjrpeVPdWHpgQpj5O032qrpq78a6l9XbfAxoS2vXrtVDDz1k5rQY1/R+fn4KDg5Wjx49dO2112r58uU/6vXmzJljFieqfS3j1rhvbMfJUQHre6SlpWny5MnmrXFR/MYbb+jcc89t68PyKK+9W2DOAjRs3eH4QfCNdwu15FvHj3xjR/jrhssdf5ju/nWEvphboqf+ma8NWyo0pL+f1m+p0PwlZRo+yE+/u7FhosHEsYHmwNjr7xVq2NRUnTk5UOmZNfroiyJFRnjr+UebL/d4MLVKDzydq8f+GNVg5qLhthvC9YdHj+nsK9KUFG/Rfz4o1FlTAtW9CyXe3V3HW6dr111v6fDzs5W/crfZPq5sf4aKNh0yq1klXjfJuW/E6X2U/+0u5a/YqR2/eU2hQ7qopqTC3GYkZHX+/TmyhDR9kVey86iyZ61Tlz//Uj6BdS0BfAJ8FTV1oHJmb5CtwnHhkLd4m2LOHiqfehVr4Fk6/Xqqdtz5Xx38xxzlHY+r0n2Zx+MqVMnXT3TuG3l6b+Wt2KW85bu07ddvKHRoihlXeSt2m3HV5c6zZQlpOrGleMdRZX21Xt3/ckGjuIqeOlDZRlyVO+Iqd/F2xZ4zhLjycDHXnaOjD7yi7Fc+V8maHbImxKjyYLrKtu2XJTpcUVdMc+4bfs54lazdqfwvlpltBP1S4lVxIF1lm/fKr2uiws6suxg8UfHKLWZiVdIjN8vLuy7/3jchRgEDuyv3k0Wqyi5QTX6RyrbsU9QV01v9s6N1lKzepKJ5y+XXI0WWqHCzilp1Ro4jAaqmRqFnTpB/z7oBdL9unRQydZz5nPQHnlPAwN5mKe2yjdvNNoJhF0xrtmVgdU6uCj6fr/ALp8kS2fA7Wsjkscr/39fKeu4/skSGqXj5WvkP7CVrh4YzEdF+XT14sM7r01trjx7VsdJSxYeEaHLXrgqwWnXf3HnalpXV7HMHxcfrykEDdfPnX6ikXgvM0qoqfbxlqy4fNFABVsel7Lm9e+utDRtUVq/iGgAAJ2JsCqdKr6mJWv/xfqWuO6aXfzFf3SfEmS3/MnYU6NDqbFn8fXTGXXU/EI+6prv2LE7Xqv/sMdsIxvUOV8aOfB1YmaX4vhEafnldYtWJdsw9YiZZXf3OBHnXa38Z1TlEXcZ20PKXdqgwvVTF2eU6uCpbk35/8h+w4d4GT481E632rS3QIzNWqd/EaDMJ5sj2Iu1elS+rv7fOv7f5ePkxDmws0LL3juqGf/aXf722c0YLulEXxJvtCyvLHZVk1n2VqdMuT5RfYOv8AI7W1X9anJlodWBtnv521nL1nhCjgFCrjm4v1L7vcs24Ovuenua+RqvA/9620axO1WV4pDbOblip2BCREKBh5zdd5ejwpnytfP+wrnx+cIN2hsb6sAuT9N2Hqao6HlcbZ6Vr9K86NqgMCM+05bPa9oPNT0je8P4e7Zh9WImDohUY6aeizFKzalZVeY2m3j9MHXo3X5k9bfMxbfpor37x97HyDar7LmXETr/zUrT5k/2qLndUKNo557AGXdJN1gDiytMdmbXdvE0+q0+z+xjtAve/t85cr6lwjBkVH87T5sfnO/cZ8IcpTT43b1uGDn22RUMeOUuWwLrv3sZ60pl9lPrFVudrpn+zW53OHyBLAEnubsEueblrlfxWPC6jcNCyepNYa1VWVmrPnj3m8uabb+qqq67Sq6++Kt8mJs7Wstlsuummm/T666832H706FFz+eyzz3TDDTfo5Zdflne935pQh78yJ5GTk6MpU6Zo/35HxZEXXnjBDEz8OMYA19sfFTXctqbcXGrVDnIZpd0XzUzUg3/L1cxZjpmC8bEW/f6WcN1/Z6QCAhr/H/mlp2PUv7evXn2nUM+/VqDgQC+dNyNYj9wXpa6dm/+Dd8vdWebzbr22cVbynf8XrmN5NXrzg0ItXmHXOVOD9NJTVGzwBEaloF7PXae0d5aqcN0+FW3YL0tEsJkAFXfZOFnD62blGEmVKfeep6wv1urY/I3KmbNBXlaLgnonKu7iMQrp72hp2FRrsEPPz1b42F4KH9m90eOJ159hZt/nrXDMXjQSsuonfsEzq2D1ef4apf13mQrW7lfh+gOyRgSbCVAJvxrbKK663neuMr9Yq5y5m5U9e6O8rRYF905U/CWjFXq8pWFT7QwPPv+1Isb1VPioxnGVfONEM/aMxC5D9LQBDRK/4LlVsJIe/T/lfrxApZv2qHTzPlnCgxU6daQiLpwgS1jdjCyj7WDCA9cr7+OFKlm9XWXbDpjnt7CzxirylxPl7dv037ya4jLlvDlb4WeOkV9KQqPHY2+9QDmvf6niFZvk5WtV+DnjFHbm6Fb93Gg9/r26qjo9W5WH01Sx54DslVXyDg5SQP+eCp44SgH96maZ1oq45GxZE+NUvGiVSlasM6te+XZMUMiV5ylwSPM/0uS+/an5vOCJjeMlZPppqikpVcnydarYtd9M7Iq86oIW/7xwX+vT0jQyOUlndOmiUH9/5ZeVafGBA3p5zRptz2rcerWWxdtbj0+Zojl79mjh8euw+h5bskRWHx/N6OH4W2m0RnxiaeMBBgAA6mNsCqeKkQh16Utjtea/e7Vj3lFtn31ENdU2BUX6qe9ZyRpzQw9Fdwlt8APx5a+PN5Oldn2TpkNrss1KVSOu6qZxt/SS1b/ppJaywkrNf3KzRlzRzUzaOtHZDw/V3Ec3atusVDPpy0j0GnFlyyTnoO1i69bXB2nxW6naMCdL62ZlqrrKrpAoXw07p4Om3txJcV1/XDWiphiVaj64f5cGTY1V/4mNJ9Ccd083s23dxnmOCRWjLozXL+5qnfZPODVxdf2rw7T8rYPaPDdDG2dnmDEQHOWrwefEa+KNXRTb1TE2VZRT6WwNuGlORpOvlzI8oskELOM1//fANvWfGqc+Exv/LTvrrh7mPlvmOSr3DbswUWfe2Xj8Ap4lfWuuju0tVFy/SMV0b746UMLAaB1Zl639S9NUXlipgHA/pYyN1/Breyq2V/PJV0bMzH94rbpPTlLX0xuPeZ7++4HmPnsWHDHvGwlZ428f0EKfDm0lf0eGig8cU1jvDgrp2vxEz4rcUh39umGF0coTtjWVgGX8TrP16YWKO72rOoytq8Beq9et42SvtiljyV7zftJZfdTz/8b+xE8F/DRGISFDQkKCLrroIo0fP14dO3ZUTU2NVq5cqWeeecZMnnr77bdVVVWl9957r9nX+tOf/uRMvho8eLDuuecede3aVfv27dNTTz2lDRs26LXXXlNMTIwee+yxU/YZPYmX3ajLiEYKCgo0adIkrV+/3rz/xBNP6N577z0l733kyBElJyeb64fWdVZSAnlyaDnD11/c1oeAdsjHu66XOtCScgt++uAhcKKqEmYkoeX55BFXaDnV+flKfeRhcz01NdUs8w0ApxJjU2hNf86qqwAFtJR4X1pSo3WU2qg8iJaXVdmwpTHQEnYUxrX1IaAdKcsq1uKL/uP2Y1P1r11HnfYH+fu7ZzvI8vICrVr6eKv89zz77LPNIkIXXnihfHx8miw6NHbsWO3evdu8v2TJErNq1omMx/v27avq6moNGzZMS5cuVUBAXaeo0tJSnX766Wa7Q4vFoh07dqhbNyZ5nIi6YE0wguess85yJl8ZmX6nKvkKAAAAAAAAAAAAAAAAP5DdzZdW8tVXX+niiy9uMvnKEB0dbVbBqvXJJ580ud9zzz1nJl/Vdoarn3xlCAwMNLcbjP2effbZFvwU7QcJWE30wjz//PO1YsUK8/7vfvc7PfLII219WAAAAAAAAAAAAAAAAMAPNnHiROe60U7wREbTvM8//9xc79Wrl0aNGtXk6xjbe/bsaa4b+9NsrzHqh5/gsssu07x588x1owXh9ddfr61btza7v6+vr3r0oBc1AAAAAAAAAAAAAAAA3EdFRYVzvalKWQcOHFBaWpq5brQZPBnj8V27duno0aM6ePCgUlJSWuGIPRcJWCeYOXOmc33hwoUaMGDASffv1KmTGVgAAAAAAAAAAAAAAAA4tbzsdnNxR219XEuWLHGu9+7du9Hj27dvd64bFbBOpv7jO3bsIAHrBCRgAQAAAAAAAAAAAAAAAK0oPT39e/dJSkpqsfez2Wx64oknnPcvvvjiRvscOXLkB793cnKycz01NbXFjrO9IAHrBPSpBAAAAAAAAAAAAAAAQEsaMWLEKc1ZefbZZ7V69Wpz/YILLtDQoUMb7VNUVORcDw4OPunrBQUFOdeLi4tb7DjbCxKwAAAAAAAAAAAAAAAA4Jlsxxd3ZGu71oP33XefuR4bG6sXX3yxyf3Ky8ud676+vid9TT8/P+d6WVlZix1re0ECFgAAAAAAAAAAAAAAANCKjGpU8fHxrf4+27Zt0/nnn6/q6mr5+/vr448/NpOwmmI8XquysvKkr1tRUeFcDwgIaMEjbh9IwAIAAAAAAAAAAAAAAABakZF8lZSU1KrvceDAAU2dOlV5eXny8fHRBx98oNNOO63Z/UNCQn5wW8GSkpIf3K7w58i7rQ8AAAAAAAAAAAAAAAAAgOvS0tI0efJk89bLy0tvvPGGzj333JM+p35C2JEjR066b2pqqnM9OTm5BY64faECFgAAAAAAAAAAAAAAADySl91uLu7oVB1XTk6OpkyZov3795v3X3jhBV111VXf+7w+ffo413fu3HnSfes/3rt37590vO0RFbAAAAAAAAAAAAAAAAAAD1RQUKBp06Zp+/bt5v0nnnhCv/71r3/Qc1NSUpSQkGCuL1my5KT7Ll261LxNTExU586df/JxtzckYAEAAAAAAAAAAAAAAAAeprS0VGeddZbWr19v3v/Tn/6ke++99wc/32hVWNum0KhwtWrVqib3M7bXVsAy9jeeh4ZIwAIAAAAAAAAAAAAAAIBnsrv50koqKyt1/vnna8WKFeb93/3ud3rkkUd+9Ovcfvvt8vHxMdd/+9vfqqysrMHjxn1ju8FisZj7ozFLE9sAAAAAAAAAAAAAAAAAuKnLLrtM8+bNM9cnTZqk66+/Xlu3bm12f19fX/Xo0aPRdmPb3XffbbYuXLt2rcaOHWtW0eratav27dunJ598Uhs2bDD3Nfbr3r17K34qz0UCFgAAAAAAAAAAAAAAAOBBZs6c6VxfuHChBgwYcNL9O3XqpIMHDzb52KOPPqqsrCy98cYbZrLVpZde2mgfI8HLlQpbPxe0IAQAAAAAAAAAAAAAAICHskt2N11aswdhC/L29tbrr7+uWbNm6dxzz1VCQoJZMcu4Ne7Pnj1br732mrkfmkYFLAAAAAAAAAAAAAAAAMCD2M0Er5Z15plnmgt+PFLTAAAAAAAAAAAAAAAAAMBFVMACAAAAAAAAAAAAAACAR/KyOxZ35K7HhZZHBSwAAAAAAAAAAAAAAAAAcBEJWAAAAAAAAAAAAAAAAADgIhKwAAAAAAAAAAAAAAAAAMBFFlefCAAAAAAAAAAAAAAAALQpu92xuCN3PS60OCpgAQAAAAAAAAAAAAAAAICLSMACAAAAAAAAAAAAAAAAABfRghAAAAAAAAAAAAAAAAAeycvmWNyRux4XWh4VsAAAAAAAAAAAAAAAAADARSRgAQAAAAAAAAAAAAAAAICLaEEIAAAAAAAAAAAAAAAAz2S3OxZ35K7HhRZHBSwAAAAAAAAAAAAAAAAAcBEJWAAAAAAAAAAAAAAAAADgIloQAgAAAAAAAAAAAAAAwDMZXf7ctdOfux4XWhwVsAAAAAAAAAAAAAAAAADARSRgAQAAAAAAAAAAAAAAAICLSMACAAAAAAAAAAAAAAAAABdZXH0iAAAAAAAAAAAAAAAA0Ja87HZzcUfuelxoeVTAAgAAAAAAAAAAAAAAAAAXkYAFAAAAAAAAAAAAAAAAAC6iBSEAAAAAAAAAAAAAAAA8k9Hmz11b/bnrcaHFUQELAAAAAAAAAAAAAAAAAFxEAhYAAAAAAAAAAAAAAAAAuIgWhAAAAAAAAAAAAAAAAPBMRpc/m9wTHQh/NqiABQAAAAAAAAAAAAAAAAAuIgELAAAAAAAAAAAAAAAAAFxEC0IAAAAAAAAAAAAAAAB4JC+73VzckbseF1oeFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi0jAAgAAAAAAAAAAAAAAAAAXWVx9IgAAAAAAAAAAAAAAANCm7MZi/I8bctPDQsujAhYAAAAAAAAAAAAAAAAAuIgELAAAAAAAAAAAAAAAAABwES0IAQAAAAAAAAAAAAAA4JmM9oNu24LQTY8LLY4ELDc3ad35sh4KbevDQDtit3u19SGgHbLZiCu0Dou1pq0PAe1QlZe1rQ8B7ZEXF9FoQcQTADfC2BRaGmNTaA2MTaG1eHvz3Rwtr6zAv60PAe2QTx4/+6PlVOfnt/UhAB6JFoQAAAAAAAAAAAAAAAAA4CJSYQEAAAAAAAAAAAAAAOCZbMcXd+Sux4UWRwUsAAAAAAAAAAAAAAAAAHARCVgAAAAAAAAAAAAAAAAA4CJaEAIAAAAAAAAAAAAAAMAjednt5uKO3PW40PKogAUAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAABcRAIWAAAAAAAAAAAAAAAAALjI4uoTAQAAAAAAAAAAAAAAgDZltzsWd+Sux4UWRwUsAAAAAAAAAAAAAAAAAHARCVgAAAAAAAAAAAAAAAAA4CJaEAIAAAAAAAAAAAAAAMBDuXELQuPY8LNABSwAAAAAAAAAAAAAAAAAcBEJWAAAAAAAAAAAAAAAAADgIloQAgAAAAAAAAAAAAAAwDPZ3bgFobseF1ocFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi2hBCAAAAAAAAAAAAAAAAM9kO764I3c9LrQ4KmABAAAAAAAAAAAAAAAAgItIwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAusrj6RAAAAAAAAAAAAAAAAKAtednt5uKO3PW40PKogAUAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAABcRAtCAAAAAAAAAAAAAAAAeCajzZ+7tvpz1+NCi6MCFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHARLQgBAAAAAAAAAAAAAADgmWx2x+KO3PW40OKogAUAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAABcRAtCAAAAAAAAAAAAAAAAeCajy5/dTVv9uelhoeVRAQsAAAAAAAAAAAAAAAAAXEQCFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHCRxdUnAgAAAAAAAAAAAAAAAG3LLtntck/uelxoaVTAAgAAAAAAAAAAAAAAAAAXkYAFAAAAAAAAAAAAAAAAAC6iBSEAAAAAAAAAAAAAAAA8k92NWxC663GhxVEBCwAAAAAAAAAAAAAAAABcRAIWAAAAAAAAAAAAAAAAALiIFoQAAAAAAAAAAAAAAADwTDa7Y3FH7npcaHFUwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAAAuogUhAAAAAAAAAAAAAAAAPJPd5ljckbseF1ocFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi0jAAgAAAAAAAAAAAAAAAAAXWVx9IgAAAAAAAAAAAAAAANCm7HbH4o7c9bjQ4qiABQAAAAAAAAAAAAAAAAAuIgGrCVlZWfrqq690//33a8aMGYqOjpaXl5e5XHPNNW19eAAAAAAAAAAAAAAAAADcBC0Im9ChQ4e2PoSflaJVO5T39VqV70+XvaJSlogQ+fdIUuxVk2WNDjP3KViyWUUrd6jiUKZqCkpkl13WmHAFDeyiyHPHyBoV2uA1bZXVyn53gYq+3S5bRZUC+3ZSh+tnyBrdcD9D9jsLlL9wg7o8/2v5BAecss+N1lX03Q7lf72mYVx1T1LMVVPMuLJX16h4zS4Vr92l8j1HVXWsQJKX/JJjFDphkMKnDJWXT8McVVtllXKMuFpZF1exRlxFOeK0vux3v1HBwg1K+cdviKt2pNiIq7mrVXHAiKsq+YQHm+er6Cum1sXV2l0qWbtT5XuPqjqn0Agr+SY54ips8rAm4+rYewtUvGqbGVcBfTor5rqm4yrnvW9UuHCDOj1HXLU3nLPQko7e/YRqjuU3+ZhfzxR1uPfmRttrCotVOGuRyjbtVHVugbz9fGWJi1bQmCEKmTjKuZ/dZlPh7CUqXrpGtpIS+aUkK+Kyc2RNbPz9uXjxd8r74CvFPXS7rLFRLfwp4Q5uHj5c944/zVy/4P33tDE9vcHjA+PidOuIkRqamKggq1XpRUX6YtdOvbh6tSqqqxvs6+vjo7vHjdOMHj0VYLFo9ZEjenDRQmUUFzd637vGjtNF/fppypv/UWFFRSt/SgDAzwFjU2gNXOehtTA+hdbAOQstibEpnCqMTaEBm92xuCN3PS60OBKwvkfHjh3Vq1cvzZs3r60Ppd2x2+3KfOkr5c9fL2tchELH9ZV3gJ+qc4tUuu2QqrILnINchSu2qSr9mAJ6JMkSEWw+t+JgpvJmfaeCRZvU6dFr5dcx1vnaWW/NMy8WQsb0lU9ooAoWbtSRx99X56dubHARUH4wU8c+/1YJt1/Al/r2FFcvf6WC+euOx1U/efv7qjqvNq7yzbiqzMhV2t8+kpe/r4L6pyh4eE/VlJarZO1uZb06SyXr9yjxD5eZle9qZRtxNfd4XIUEqmDRRh19/H11evKmE+IqQ7mff6v43xFX7Smusl75UoXfrJO1Q6RCxhpx5WfGVdn2g6o+HldVmbnKeOZDM64C+3dR8DAjripUsnaXsl+bpdINexR/768axFXO2/NUMG+Ngkc74qpw8QalP/m+kh9vGFcVhzKU98UKxd12IXHVjnDOQmvxCvBXyJSxjbZboiMabas8nKasZ16XrbRMAQN6KXBYf9kqKlSVlq2yjTsaDHIVzVuugplz5T+gp6wdeqtk5UZl/f11xT96p3lerFWTX6i8j+co7NzJDHC1Uz2ionT76DEqqaxUkK9vo8endeum5886Wza7XV/v2aPskhINTUzQbaNGa0xyR13xyceqrKlx7v/H00/XFQMHadauXcorL9Mv+/bTK+eep/Pee9d8jVq9oqN147BhumPObAa4AAA/GWNTaA1c56G1MD6F1sA5C62FsSm0NsamALgjErCaYLQeHD58uLkY1bAOHjyolJSUtj6sdscYoDIGuMKnDzNnAJ44O8JeY3OuJ951kbx9G4dr/jfrlfHvL5Xz4RIl3n2R43k2uwoWbFDYGYMVf+svzG0B3ROV/vxnKt+bpoCeSc7Xz/j3Fwoe3E2hY/u28qfFqZJvDHzOX6fw6cMVe11TceX4MmUMqMbeeKbCJgwyLyhr2a6uVOr9b6pk3W4Vr9xuXhyaz7PZzBk4YWcMUdz/OeLKmAGU8cKnKt93VAE9ko+/vk2ZL36hIDOu+p3CT47WlD97lTm4FTZtuGKuPbP5uPL3U8wNZyn09BPi6qppOvLX/zjiatV2hYyui6vChesVOmmwOtxyrjOuMv85s+m4GtRdIWOIq/aEcxZai3egv8LPm/K9+9nKypX9wtvmetz9v5VvcnyTMVireMlq+ffpptjbrzXvBwztp6wnXjZnJwaNHOjcL/edz2WJiVTI1HEt9IngTize3np6+gxtz87Swbx8nd+nT4PH/SwWPTx5ioyhqYs+eF9bs7Kcj/110iRdNWiwrhsyVC+tWW1uM4bnL+7XTx9t3aI/zp9vbjNmLP59xpkaEBfnnL3o7eWlx6dO1ZKDBzV79+5T+pkBAO0TY1NoDVznobUwPoXWwDkLrYWxKbQmxqYAuKuG36RgevDBB3X22WfTirAVGeVmcz5aImuHiCYHuAz1tzU1wGWo/TJvzL6oVVNYKntltfy7Jji3+XdzrFflGGVx6wbZKo/mqMNNZ7XQp4JbxNXHi824ir1uejNx5WPeGq0BIqaPaHCxaDDuR5wz2lwv3XbQub2m6HhcdYlvHFfZ9eNqFXHVDuMq92PH+Srm2hknjStLVKjCpzUTV2ePMdfLToyrqmr5dal3vjp+7qqud74yBtiq0nIUcyNx1Z5wzoI7KFq4yiwJH/7L6Y0GuOrHYK2avAL5dkp03vft7PjxsCa3rqx86bqt5uzEqGsvbPR8tA+/HjnSnGV479y5qrHX/TBda2h8gqIDAzV/794GA1yGZ1asMG9/NWCAc1tkQID8LVZtzcx0bttyfD0hJMS57drBQ9QlIlL3L/imVT4XAODnhbEptAau89BaGJ9Ca+CcBXfA2BRcwdgUmmRUKnPnBT8LVMBCmyjZtE+24nKFTRxkzoQweodXph2Td5C/ggZ0kW985A97nXWO7OL6Jd6Nsu5evhZV7K/r81u+z7FeWza+Mitf2R8sUuyVk2WNDm3hT4e2j6vB5mzT4jXbzbjyCfJXoBlXP6zMrJfFcaFZ/4LTKJFsxFX5gQznttoYs8Y44qoqK085Hy5SzBVTmuxjD89UunmfbCVlCjXPV3aVrN3uPF8ZZdx/aFzJp5m4slpUcaDe+er4uiW6Lq6OfbhI0VdMJq7aGc5ZaE326hoVL1+rmvwic5aqMRjl17Vjo/1K12ySvLwUOLS/qtKzVb5ttznwbomLUUD/HvKyNLxc8IkIM8vC16o6dNSxPTLcvLWVlivvnc/N2YX1B8PQfvSNjdWtI0bquW+/1d7cuh+a64sJCjRvjxTWDarXKqqoUH55mZLCwtQxLEyHCwqUW1am8uoq9Ymt+07f7/h6WlGReZsYGqrbx4zRU8uWKaO4uJU+HQDg54SxKbQGrvPQWhifQmvgnIXWxNgUWgtjUwDcGQlYaBO1g07GF/KDd7xkfql38vZS5NmjFHvN1EbPK1yxTRWp2bJXVqnicLZKNu6VtUO4oi+d4NzHy9tLYZMGKX/uWtnKK+UdHKDCRZvklxLnnGGR+dJX8u8UZ5bVRftRse/4l25vLx38/YuqOiGuIoy4unra976O0SbAEDiwq3Obl7e3wiYNNnvW28oqnD3rzbjq6vgSn/HSV/IjrtptXBkxcPjOf6sqvV5ceXkp/OzRirnq++OqcFHTcWWUdy+Yt1a2skr5hASocLERV/HOuMp65Uv5de6gsGkjWv7DoU1xzkJrshUUKfeNTxps801JUtTNl8ka6xhAtVdXq+pIprxDglS0YIUKPvumwUwco0x79G+vkm9SnHNb8GnDlf/xHGU996ascdEqWblBPuGhChjYy3w876PZ8vK1KuwHlJiH5/H18dHfps/Qjuxsvbx2TbP7GYNWhqTQxgPoIb6+CvcPMNdTIiLMQS4j6j7euk2XDxyoYF9f5ZWV68K+fc1Zh5szHIP1j06eYr7vfzdtbLXPBwD4eWFsCq2B6zy0Fsan0Bo4Z6E1MTaF1sDYFAB3RwIW2kRNQYl5m/vFSrMEbacnb5BfUow5sybjxa/M7da4CEWc8MW7aMU2Fa3a0aAUcsKdF8q3Q0SD/WKvnmqWFS1auV22yioFDuziLCdfsGiTSrceVOdnbpa9vErpr8029zOEjO6juBvPbFRGF56hutARV3lfOuIq/skb5ZcYbc6yyXzpS+UZcdUhslFc1Zc/b61KNuxVYP8UBQ/t0eCxmKuMuPJ2xlXQwC6KrY2rxRvN0t2d/mbEVaUyjLhadTyuRvVRhxvPIq48Pa6+WmkOPCU/fpN8E6NVcTBDmS9/ofwvvzXLdBul3ZtTMH+tSjfsUUC/FAUNaRhX0VdOO36+2maW5Q4c0FUx1zniqnCJI66Sn7rFjKvM12er+HhcBY/qo9gbiCtPxjkLrSV43DD59egsa2KcvPx8VZ2Zo8K5y1S6coOynn5V8Q/dYc48NGZPy2aTrbhUBV8sVPhFMxQ0ZojsNTUqXvydCr9apOx/vKmEx+6Ul9VqvnbItPHm4FjxsrWq2HNAvp2TFfmrc+Tt76fyXftVsmyNYn9/nRlneR98pZIV68yWBsaMxcirL5BPaHBb/+fBT3DHmDHqHB6uc999R7aTlM1el5Zmziac0q2b+sTEant2Xan328eMda6H+vk71x9bukTVthrN6NFD/haLVhw6pAcXLTTf5/zefTQyKUnnvPNfBVqt+uukSZrR3XHOm7Nntx5YsEBl1dWt9rkBAO0TY1NoDVznobUwPoXWwDkLrYWxKbQWxqbwvWj1hzZGAlYbOHLkyEkfT0+vK/XbXtmPn/y8LD5KvO9SWSMd/XMD+3RS4l0X6cCdL5kDXSd+sU+852LztqakXOX705Xz3kIdvOsVJd57iYL6pzj38/azqsP1082lvuqCEmW9OVeRF4yTX3KMMl78UsWrdynulnOMiULKeGW2snytiruZfuMeyVYvru69VJbIUGdcJdx1kQ7e+ZLyvvy22QvG4rW7zAEES0yY4n93QaPHjbiKvW6GuZwYV9nOuIpVxktfmq0LjLiSvJT56ixHTN50dqt8bJy6uEq4py6uAnp3UvzvL9bhu15U/pcrmx3gKl63S1lmXIUr7rYLGz1uxEbMtTPMpVFcvTVXEeePN+PKGEwrWbtTsTcb5ysvZb32lXKMmLyRuPJYnLPQSsLOndzgvm/HBEXfeIlyjLLuKzeoeOlqhRqDVcdj0BjoCpk8VqHTT3M+J/z8qarOyFHpms0qXbtVQaMH181gPecMc6nPXlWl3DdnKmjMYPn37a6CWYtUtHCVIi47Wz4Rocp79wsde/1jxd5x7an4T4BWMDg+XjcMHaZ/rFyp3cfqzYpuQmlVlR5dslhPTJ2m/112mTkQlV1SqiEJCWb59r3HjqlbVFSDgbKK6mo9vHixudQXGRCgP02YoJfWrDbLyj8yebKmdO2mP30z3xxPeeiMM1ReVa37Fy5otc8OAO0RY1OMTaGVcJ2H1sL4FFoD5yy0Esam0BoYmwLgCeoaMuOUSU5OPukyYkT7L+PrE+hn3hpl12sHuGr5dYo1Z+tUZeSZg1lNPj/I3xzUSvrLFWYp0fR/fGr2k/4+WW98LZ/wYEVfOF41ZRXKX7hRkeeOUdhp/RU6vr8izx2t/AXrzVLL8Dzegf7O2ae1F4u1/Dp2kDW2Nq4cpUfrK163W2l/+0iWsGAl//VqWSIaxuXJZL0xRz5hwYq6YLxZTrlg4QYzrkLHD3DE1S/GHI+rihb4lDjVvI+fr/yaiyvjfJWZ22RclazfrYxnPpIlPEhJD/y4uMr+zxxZwoIUeb4jrowS8RG/GGvGVci4/oo4Z4wKiCuPxjkLp1rIhJHmbcXegw1i0BAwuHej/QMGObZVHjj5D7SGgi8WyFZWrvBLHIOjRfNXmDMWQyaOUuCgPgq/YJrKt+xSVXp2i30enDo+Xl762/Tp2pmTYw42/RAfbd2qa2f+T+vT0zS5azddMXCgOYvwyk8+0aH8fHOfY2Wl3/s690+cqJySEv37u+8UZLXqor799OraNfpi5059uWunXl27Vhf372/OPgQA/HCMTTE2hdbBdR5aC+NTaA2cs3CqMTYFVzE2BcBTUAELbcI3Idq89an35ao+Y3uVkbFeUSUFNb2PYz8/BfRIUvHqnarMyDVLxTeneN0eFa7Ypo6PXCsvq4+qjmRLNTb5p9T1jvZPiZeqbeZr1d8Oz+Cb6Ogb7t1MzBiDo2ZcVVZLQSdcLD79odmHPvnBq+UbF/mD39N4btG329TxYSOuLKo4mmPGlV/nuvgx+tqbcZWZJ/962+EZjHLuJztf1cbbiXFVsm630p9xxFXiA9eY5bp/KGNgrPjbrUp6+DozriqbjKt4qaZGVZl5DbbDc3DOwqnmHewIJPP7lTkT1decAViTVyjvwIDG+x/fZswgPJnK1HQVfr1UUTdcIp/gQNlKy2UrLJZvx/gGMx0NVRlZssY3/30N7inQ11cpEY5zze7b72hyn5mX/cq8vfnzzzV/315zfcnBg+ZyomeiZ6jGZtO2zMyTvu+ElBSd1aOnLvnwQ1XZbOoaGSWrj4+2Z9cNlhol5H19fNQxLFw7cxhEBQD8cIxNoTVwnYfWwvgUWgPnLJxqjE3BVYxNAfAUJGC1gdTU1O8t897eZxoG9u9s3ppfrk9gzBY0Bpm8/K3yCav3rb4Z1XlF5q3Ro745xqzBjJdnKXzaMAX2Sm74flXVjdeNmu/wOIH9HKX+K498T1yFBja6WPQODlDyg9fIN95x0flDGDNwMl+ZpfCpwxTQq2Oj92tqHZ4noO/xuDra+Iuz8W9bZcSVcaFYL65qB7eMuEr864+Pq6xXv1LY1OEK6HlCXFXVNF7ndOWxOGfhVKvYf9i8tURHOLf59epqln6vSsuSb6fEBvtXpTkGIHzq7X8iu82m3Df/J/++PRQ0cmDDx6qrm1jnpOWJKmtq9OGWLU0+NiIp0RwAm793r3LLynSksOCkrzU0IUHJYWFatH+/iiqbr+xhzBp8+IzJenfzJnOmYn3GoFbj9bqS8QCA78fYFGNTaB1c56G1MD6F1sA5C6caY1NwFWNT+EGMnpD12kq6FXc9LrQ4ErDaQFJSkn7ujBkRQYO6qmTjPuXPX6/wKUOcjx2buVy2knKFnj5AXj7eZjn26twi+R2f5VNf/oINKt9zVNb4SPnGNz/LIvvdBeaJLeaKup7Q5qwMi7eK1+9RyChHGVNj3eh37hvX/Jc5uC/j3zRwYFeVbtqn/G/WKXzyUOdjxz49HlenGXHl4/z3Ni8WgwLU0bhYTPjhF4uG7Pdq46qun7lvhwgzrkqMuBrpiKsSZ1z98JlAcM+4KliwTmFn1MVV7mfLzLgKGV8XVyUb9jgGt4L8lfTAjxuEMOS874ir6Mvr4sooIy8fH5Vs2K3g2rjasNuMqx8zcxHuhXMWWkNVepZ8IsPNGYQnbs//5GtzPbDeYJRRht0Y5CqcvVgBA3s5ZxbWFBSp6JsV5g9/gUP7Nft+Rjl3Y4As/tErnNuM8vE+YSEq37xLoVPHm9vKNu8yb60JsS38iXEqVFRX6w/z5zX52FPTppmDXC+uWa2N6enO7cG+vio+YRArNihIj0+ZqqqaGv392xUnfc+7xo2Tl5eXnl62zLntcEG+OeBmzD6ct9cxk9FYN46vtnQ8AOCHYWyKsSm0Dq7z0FoYn0Jr4JyF1sDYFFoDY1MAPAUJWGgzHW46U4f+8IYyXvxSRat3moNY5QcyVLrlgCwxYYq9aoq5X01RmQ7c9i+zD7lRatkSFSJbcbnK9qapYn+6vAP9lHDbec2+T9muI8r7eo0S771EPgF+zu3eAb4KP2Ow8ueuk73CkfleuGyLwmcMl7d/wy+G8BwdbjpLh//4ujJf/NIs/2/ETEW9uIo5HlcVR7KV9tQH5iytwL6dVbi8cea8NSZcYZMGN/k+ZbtTlW/E1T2XyrtBXPkpbNIQFcxbK9vxMrpFZlyNIK48WMwNZ+vIn19T1ktf1IurdJVtNeIqXNFXTnXOQkx/2oiragX07ayiFU3HVejE5uOq4OvVir/nsibiarAK5q91lmcuWr5FYdOJK0/HOQstreS7TSqat1x+PVJkiQo3Z0BXZ+Y4BplqahR61gT59+zi3N+vWyeFTB1nPif9/ucUMLC37DU2lW3cbpZqD7twmqxxTZdlr87JVcFn8xV+4TRZIsMbPBYyZaw5qJb13H9kiQhT8fK18h/YS9YOjX+0RPt09eDBOq93H609elTHSksVHxKiyV27KsBq1X3z5mpbVlazzx0UH68rBw7SzV98rpJ6bQZKq6r08dYtunzgIAVYrOa2c3v31lsbNqis3qxWAAB+KMam0Bq4zkNrYXwKrYFzFloaY1NwF4xNAWgLJGChzRizFzo/faNy3l+s4g17VbJpnyzhweYgU/RFp8sS7ijxbgkNVNRFp6l06yGVbNqvmuJSx6yamHBFnDNKkeeMljU6tMn3MErVGoNoIaP6KGR4z0aPx1491dynaOUO837YGYOdg2vw3Ljq9NRNyvlgkUrqx9X04Yq6+HRZwoLN/Wryi50lsotWbG3ytQL6dmrygrF+XAU3E1cy4mrVdmdcxVxJXHl6XCU/cbOOfbhQpRv3mrPCjLgKmzZCkRfVxVW1GVeOL9nFzcVVn85NDnAZcWUMoAUbcTWscVxFXzXN3Kf4eFyFThqi6CscA2vwXJyz0NL8e3dVdXq2Kg+nqWLPAdkrq+QdHKSAAT0VPHGUAvr1aPSciEvPljUpTsULV6lkxTpzZqFvxwSFXHneSWcY5r71qfm84EmjGz0WMv008ztbyfJ1qqjcr4BBvRV51QUt/nnhvtanpWlkUrLO6NJFof7+yi8r0+IDB/TymjXant38AJfF21uPT5miOXv2aOH+/Y0ef2zJEll9fDSjuyOWjfLzTyxb2qqfBQDQfjE2hdbAdR5aC+NTaA2cs9DSGJuCu2Bs6mfIZpO8bHLbY8PPgpfdTsPJ73Pw4EGlpDh6YV999dV68803W/X9jhw5ouTkZHO96yt3NDuAA7jCbqe/NVqezUZcoXV4e/M1BS2vrMC/rQ8B7ZBPHnNb0HKq8/OV+vAj5npqaiqtwgCccoxNoTUxNoXWwNgUWgtjU2gNjE2hNTA2hZ/j2FT9a9cJMVfJ38eROOxuymuKtTj7bbf/74mfzrsFXgMAAAAAAAAAAAAAAAAAfpZIhQUAAAAAAAAAAAAAAIBnMhq/uWvzN3c9LrQ4ErCasHz5cu3du9d5Pycnx7lubD+xBeE111xzSo8PAAAAAAAAAAAAAAAAgHsgAasJr732mt56660mH1uxYoW51EcCFgAAAAAAAAAAAAAAAPDz5N3WBwAAAAAAAAAAAAAAAAAAnooErCYYLQbtdvsPXgAAAAAAAAAAAAAAANAGjLwNd17ws0ACFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHCRxdUnAgAAAAAAAAAAAAAAAG3KZpe87O57bPhZoAIWAAAAAAAAAAAAAAAAALiIBCwAAAAAAAAAAAAAAAAAcBEtCAEAAAAAAAAAAAAAAOCR7Habubgjdz0utDwqYAEAAAAAAAAAAAAAAACAi0jAAgAAAAAAAAAAAAAAAAAX0YIQAAAAAAAAAAAAAAAAnskuyWb8jxty08NCy6MCFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHARCVgAAAAAAAAAAAAAAAAA4CKLq08EAAAAAAAAAAAAAAAA2pTd7ljckbseF1ocFbAAAAAAAAAAAAAAAAAAwEUkYAEAAAAAAAAAAAAAAACAi2hBCAAAAAAAAAAAAAAAAM9ksxn/I/c9NvwcUAELAAAAAAAAAAAAAAAAAFxEAhYAAAAAAAAAAAAAAAAAuIgWhAAAAAAAAAAAAAAAAPBMdrtjcUfuelxocVTAAgAAAAAAAAAAAAAAAAAXkYAFAAAAAAAAAAAAAAAAAC6iBSEAAAAAAAAAAAAAAAA8kt1mk102ueux4eeBClgAAAAAAAAAAAAAAAAA4CISsAAAAAAAAAAAAAAAAADARSRgAQAAAAAAAAAAAAAAAICLLK4+EQAAAAAAAAAAAAAAAGhTdrtjcUfuelxocVTAAgAAAAAAAAAAAAAAAAAXkYAFAAAAAAAAAAAAAAAAAC6iBSEAAAAAAAAAAAAAAAA8k9Hmz+amrf5oQfizQQUsAAAAAAAAAAAAAAAAAHARCVgAAAAAAAAAAAAAAAAA4CJaEAIAAAAAAAAAAAAAAMAzmW3+bHJLtCD82aACFgAAAAAAAAAAAAAAAAC4iAQsAAAAAAAAAAAAAAAAAHARLQgBAAAAAAAAAAAAAADgkew2u+xe7tnqz04Lwp8NKmABAAAAAAAAAAAAAAAAgItIwAIAAAAAAAAAAAAAAAAAF5GABQAAAAAAAAAAAAAAAHiwQ4cO6c4771SvXr0UFBSkyMhIDR/+/+zdB5gTZdfG8bOw9CJIb1IFrKgIIqJgA7ti79g7ghWxgIiovDYU7KIoqIAKKIqKIF0QQSyAikpXQHrv5Lvu5/0mb7Ykm82m7/93XYHZzWTyJJlMdk7Oc04Le/rpp23btm2JHl7ay0z0AAAAAAAAAAAAAAAAAICI+PaZmS7JOrbYGz16tF155ZW2adMm/++UdDVr1ix3efPNN+3zzz+3Ro0axWU8hREVsAAAAAAAAAAAAAAAAIAUNGfOHLvkkktc8lXZsmWtT58+9u2339r48ePtxhtvdOssWLDAzjzzTNu8eXOih5u2qIAFAAAAAAAAAAAAAAAApKAuXbrY9u3bLTMz08aOHWvHHnus/7qTTjrJDjzwQLv//vtdEtazzz5rjz76aELHm66ogAUAAAAAAAAAAAAAAICU5NvnS+pLLM2cOdOmTJnilq+//vosyVeee+65xw466CC3/MILL9ju3btjOqbCigQsAAAAAAAAAAAAAAAAIMWMGjXKv3zttdfmuk6RIkXs6quvdssbNmywCRMmxG18hQkJWAAAAAAAAAAAAAAAAECKmTp1qvu/TJky1rx586DrtW3b1r88bdq0uIytsMlM9AAAAAAAAAAAAAAAAACAiPj2mZkuyTq22Pn111/d/40aNbLMzOApQE2bNs1xG0QXCVhJaM+ePf9bXr85oWNB+olth1kUVvv2ZSR6CEhTRYpw1EL07dm0M9FDQBrybSya6CEgjezZtCnX80MAiBdiU4glzvIQC8SmECvEphALxKYQC8SmUNhjUzttR9KebLix/b8VK1bkuX7t2rXD3vaOHTtszZo1Yd2uYsWKrkrW1q1bbdmyZWHfB8JHAlYSWr16tX95Sbc3EzoWAAAAAEBizw/r1auX6GEAKGSITQEAAAAAUik29b19k+ghhKVly5Z5ruPzhZ9Jtnnz/yZNlS1bNs/1vQSsLVu2hH0fCF+RfKwLAAAAAAAAAAAAAAAAIMFUActTvHjxPNcvUaKE+3/79u0xHVdhRQWsJHTYYYfZzJkz3XKVKlVC9uks7FSiz8sS1XNWo0aNRA8JaYJ9C7HAfoVYYL9CLLBfIRbYr8Kn0u5e9RmdHwJAvBGbCh+fb4gV9i3EAvsVYoH9CrHAfoVYYL9Kv9hU9erVU6qVnvbBaJ9jlyxZ0r+8a9euPNffufO/bXBLlSoVtTHgf4ieJCG9SVq0aJHoYaQcfUjmpx8qEC72LcQC+xVigf0KscB+hVhgv8pbKpR2B5C+iE1Fhs83xAr7FmKB/QqxwH6FWGC/QiywX6VHbEqJTKn0OsZirOXKlfMvh9NWUO0Hw21XiPyjBSEAAAAAAAAAAAAAAACQYhOoKlWq5JaXL18ect3169f7E7Dq1KkTl/EVNiRgAQAAAAAAAAAAAAAAACnm4IMPdv//+eefrn1kML/99pt/+aCDDorL2AobErAAAAAAAAAAAAAAAACAFNOmTRv3v6pbzZ49O+h6kyZN8i8fd9xxcRlbYUMCFgAAAAAAAAAAAAAAAJBizjvvPP/y22+/nes6+/bts3fffdctV6hQwU488cS4ja8wIQELAAAAAAAAAAAAAAAASDEtW7a0448/3i0PHDjQpk+fnmOdZ5991n799Ve33KVLFytWrFjcx1kYZCZ6AAAAAAAAAAAAAAAAAADy74UXXnBtBbdv327t27e3Bx980FW50s9Dhw61119/3a3XuHFju+eeexI93LRFAhYAAAAAAAAAAAAAAACQgo488kgbNmyYXXnllbZp0yaXgJWdkq8+//xzK1euXELGWBhk+Hw+X6IHAQAAAAAAAAAAAAAAACAyS5YscdWwlGi1fPlyK168uDVq1Mguuugiu+OOO6x06dKJHmJaIwELAAAAAAAAAAAAAAAAACJUJNIbAgAAAAAAAAAAAAAAAEBhRwIWAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiBAJWAAAAAAAAAAAAAAAAAAQIRKwAAAAAAAAAAAAAAAAACBCJGABAAAAAAAAAAAAAAAAQIRIwAIAAAAAAAAAAAAAAACACJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACJEAhZSzqxZs+yxxx6z9u3bW+3ata1EiRJWtmxZa9y4sV177bU2derURA8RaaRbt26WkZHhv0ycODHRQ0IK2rVrl7355pvWoUMHq1Gjhv+41aRJE3fc+vbbbxM9RCSJf//91z777DPr0aOHnX766Va5cmX/8eeaa66JaJvjxo1zt23UqJGVKVPG9ttvP/eZeeGFF9orr7xiW7ZsifrjQHLZtGmTDR061O655x5r27at2xe0HxQvXtyqVq1q7dq1s//85z+2du3aoNvYvXu3ffnll3bXXXdZ69at3b5ZrFgxq1Chgh111FF233332cKFC+P6uJB8li5daj179rSjjz7aqlSpYiVLlrQ6derY8ccf745rc+fODXtb27ZtswYNGviPgfXq1Yvp2AEAyA9iU4gnYlOIBmJTCBexKcQCsSnEC7EpAImW4fP5fIkeBBCuE044waZMmZLneldffbW98cYb7o83IFI//vijtWjRwvbs2eP/3YQJE9zJABCuJUuW2Jlnnmnz5s0LuV7nzp3thRdecH/Io/AK9fp36tTJBg0aFPa21q9f74Kon3zyScj15syZY0cccUS+xonUokDnqaeemud6ClwNGTLEBeQDrV692g466KCQQTDR310KlnXp0qXAY0bq6d+/v3Xv3t22bt0adB3tG/369Qtre/fee689++yz/p/r1q1rixcvjspYAQAoCGJTiCdiU4gGYlPID2JTiAViU4gHYlMAkkFmogcA5Mc///zj/q9Zs6ZddNFFLmP5gAMOsL1799r06dPdB+Hff/9t7777rsuGf//99xM9ZKSoffv22U033eQCXJqBoZk/QH7pOBQY4Dr88MPt7rvvdrMLN2/e7GZF67ilEwKdHOjY9sADDyR62EgS+nxr2rSpjR07Nt+33bhxowtqzJ492/3csWNHN6uwYcOGVrRoUVu2bJlNmjTJPv744xiMHMlIM71OPPFEa968uVvWjGd91i1fvtw++ugjGzFihK1Zs8bOOeccmzlzpjVr1sx/2507d/oDXAqInnvuuXbMMcdYtWrV3L72xRdfuGPYjh07rGvXrlaqVCn3GYrC4/HHH7dHHnnELWsW84033ui+KNRsVu07CqaPHDnSihQJrwCz1lcwTLMUNZtVn5kAACQLYlOIF2JTiAZiUygIYlOIJmJTiCViUwCShipgAanizDPP9A0bNsy3Z8+eXK9fvXq1r3Hjxqrq5i6TJk2K+xiRHp5//nm3DzVt2tTXvXt3/z41YcKERA8NKeTDDz/07zvHHntsrseuWbNm+YoVK+bWqVChgm/37t0JGSuSQ48ePXyjR4/2rVy50v28aNEi/z7UqVOnsLdz1VVXuduUKFHC98knnwRdb9++fexzhUCwv5sCjRw50r+vdezYMct1y5cv95166qm+6dOnB739jBkzfKVKlXK332+//XybNm2KytiR/MaNG+ffd66++mrfrl27gq67c+fOsPbX5s2bu+099thjvrp167pl/Q8AQDIgNoV4ITaFaCA2hfwiNoVYIDaFWCI2BSCZhJfmCSQJ9R6/+OKL3QyJYOVJA8tBKmseiKRHtJcp/+qrr9IuABH79ttv/csqfZvbsUszfs466yy3vGHDBvv111/jOkYkl169ern9QbO3IqXZq4MHD/bP/NGssVBl5TMzKYia7oL93RTovPPOczOgJXtLnVq1arnZrq1atQp6e806vO2229yyZh5+/fXXBR43kp9mqt56661uWTNTBw4c6GYFBhPO31RqeaIZ0tofu3XrFtXxAgAQDcSmEA/EphAtxKaQX8SmEAvEphArxKYAJBsSsJB2VMLU89dffyV0LEhNt99+u23ZssX1tG/btm2ih4MUtmvXLv9ygwYNgq6n0tu53QaIxIABA9z/Kq98xx13JHo4SCHlypVz/6tceyT4G6zwUfDzjz/+cMsKSBU0aL5kyRLr0aOHW+aLRgBAKuPvIhQUsSlEC7EpJAKxKUSK2BTyi9gUgGRDAhbSjnpB5yerHgg0fPhwN5t1//33t2eeeSbRw0GK82bsyMKFC4Ou550MasbXgQceGJexIT0pSPrJJ5+45VNPPdX1qJe9e/fasmXLbPHixREHMJDefv/9d/vxxx/dctOmTSPaBn+DFT4ffvih//PLmzEv69atc8Ev/Z8fmqm6detWu+qqq6xdu3ZRHy8AAPHC30UoCGJTiCZiU4g3YlOIFLEpRILYFIBkQwIW0s6kSZP8ywcddFBCx4LUohLbXbp0cct9+/Z1bQOAgrjsssusfPny/n1KgYbs5syZY59//rlbvvzyy/3rA5H46aef/EGsww47zDZt2mRdu3Z1x7MDDjjA6tev72YfKgA2ceLERA8XCbZt2zYXiHjuuefcrPo9e/a432ufiQR/gxU+M2bMcP/Xq1fPzVJ9//333bGnUqVK1rhxY/e/vvDRF4eBQdDcDB061MaMGWMVK1bM0rYJAIBUxN9FiBSxKUQbsSnEG7Ep5AexKRQUsSkAyYYELKRdr9+nnnrK//PFF1+c0PEgtdx///22cuVKO+644+z6669P9HCQBhRYGDx4sJUuXdqmTZtmLVq0sHfffdedFIwbN8569erlTiw1M+yoo47ij3oU2Pz587N8Jh599NGuZ72C+B7tb9r/TjrpJBd8ReEyaNAgNyNMlzJlyrhAxD333GOrVq1y1z/wwAMu4J5fK1assLffftstV6lSJUvJd6QnHWN+++03/+edvii84oorbO7cuVnWW7Bggd13333umBN4LAq0fv16f3BVf8trHwIAIFURm0JBEJtCtBGbQrwRm0JeiE0hWohNAUhGJGAhrTz//PM2c+ZMt3z++edb8+bNEz0kpIgpU6bYm2++6fpDq6+z/vgHouGcc86x2bNn2w033OBKKHfq1MmOPfZYN8vr0UcfdQGwfv36uX2wWrVqiR4uUlxgSWUFsDSD7LTTTnOfjZp9+O+//9orr7ziZhr6fD4X0PDKwqNwO+KII9x+8uSTT+b7M1D70s0332ybN292Pz/yyCP+FgNIXxs3bnSBLvnll1/sxRdftBo1atiQIUPcsUizWDXztFWrVm6db7/91q677rpct6UgmAKt+ny88cYb4/o4AACINmJTiBSxKcQKsSnEE7EpRIrYFPKL2BSAZEQCFtKGPkT1x7pUrVrV/REPhEMzbm666Sb3R/pdd91lhx56aKKHhDTbvzSzUIEE7WPZ6Y96nRBo1hdQUOpP71FQS8HUzz77zM1wLVGihJu5c8stt7jfFSny3z8Du3fvnuu+ifR03nnnuYCELgpqffDBB9axY0cXhFdrCu0b+fXEE0/Y6NGj3bJmF95+++0xGDmS/XijL20mTJjgZhqqVHupUqXshBNOsG+++caaNWvm1hs5cqR99913WbYzefJke+utt/iiEQCQFohNIVLEphBLxKYQT8SmkBdiU4gWYlMAkhEJWEgL8+bNc3+gqT+0sto//PBDF+gCwv3jXGVK1YO+Z8+eiR4O0uwE4JRTTnGzdjTjQq0Efv31V9drXLMzxo4da23atLFZs2a5E0/1ugcKIvvMLs00LFq0aI71tN9pNr5on1TAA4VDhQoV3Jc5uij4eemll9qIESNcMH7hwoV27rnnulLw4XrvvffcrEKpX7++vf/++/4AKgrX8Uaz6Zs0aZJjPQW7+vTp4/952LBh/mV9HnpfNKpM/OGHHx7jUQMAEDvEplAQxKYQK8SmEG/EppAXYlOIFmJTAJIRn0BIeYsWLbL27du7/rz6Q37o0KEuoxkIh4JbCkBI//79Xc9xIFpUxl3l22XgwIEu4NC0aVMrXry4lS9f3s0A04wMzcrRH/gqc/vTTz8lethIYeXKlfMva0bhkUceGXTdDh06+Je///77mI8Nye2qq66yiy66yJXtvuOOO7K0DAjm888/t2uvvdYdv6pXr25ff/21+x+F73gj+ns8mJNPPtnNIsx+vFHw6/fff7c6depYr169YjhaAABii9gUCoLYFGKJ2BTijdgUIkVsCvlFbApAMvrvkQZIUf/884+bwaP/VRJSJSKVHQ+E6/nnn3dluBs0aOD6QStImt3cuXP9yypVunLlSrd89tlnExRDUDrp0zFJGjdubJ06dcp1Pf3R37t3bzfrSyeXmt2j/RKIhE4UPbVr1w573dWrV8d0XEgN+htq+PDhbob0l19+aZdffnnQdSdOnGgXXnih7d6925X0/uqrr6xhw4ZxHS8Sy2sd4R0/Ao8puc1IrFy5svsbKvB4oy9/RH/Pe60CgpWT1//e32mqJnLSSSdF9fEAABApYlMoKGJTiBViU0gEYlMoCGJTyA9iUwCSEQlYSFlr1qxxM3RUktSbIXb11VcnelhIMSovKtqP1F88LwpGBM5wJciFYFatWuWfpRNqppc0b948y8xXIFKHHHKIf3nv3r0h1w283pv9g8JNAQvPkiVLgq43c+ZM90XPjh07rGzZsvbFF19QnrsQH3MU8MzPMSfweKMvGuXtt992l7z+9vf+Vmvbti1BLgBAUiA2hWggNoVYITaFRCA2hYIgNoX8IjYFINnQghApSf3pVZ52/vz57uennnrKbr/99kQPCwD8Av+I37NnT8h1NUsnt9sB+VW3bl074IAD3PLixYvdbNdg/vrrL/9yrVq14jI+JLe///7bv6zgVW5+/vlnO+2002zLli1u5phmhh1zzDFxHCWSSWBrJe+L59xs2rTJBamE4w0AIF0QmwKQ7IhNIRGITaEgiE0hv4hNAUg2JGAh5agU95lnnmk//PCD+/mhhx6ybt26JXpYSFEqqa2TwFCXnj17+tefMGGC//f16tVL6NiR3Pbff38rX768W54+fXrIQNekSZP8y/Xr14/L+JC+LrjgAv9J5fjx44OuN2LECP+y2gwAH374oX/5sMMOy3H9ggULrH379rZ+/XorVqyYffzxx9auXbs4jxLJeLyRkSNHBl1P13lB9+OPP97/+7z+BtNFwXvR/97vvJmNAAAkCrEpRBOxKcQKsSkkCrEpRIrYFPKL2BSAZEMCFlKKSkF27NjRpk2b5n7u0qWLPf7444keFgDkUKRIEReQl3/++cf69OmT63o6WQwM1J911llxGyPSU9euXd3sL7n77rtdsCu7IUOG+E8StZ/WqVMn7uNEfL/QUUn2UJ5//nkbM2aMP9geGIiQpUuX2imnnOJaWBQtWtTef/99O+OMM2I6biQ/lfc//fTT3fIHH3yQa2B95cqV9vDDD7vl4sWL27XXXhv3cQIAEE3EpgCkCmJTSBRiU8iO2BRihdgUgGRDLVmkFPXWHTt2rFtWb93rr7/e5s6dG3R9fZA2btw4jiMEgP/p0aOHffLJJ2529KOPPmqzZ8+2Tp06WYMGDdwJ54wZM6xfv37u5FFOPvlkN4MHhdfUqVPtzz//9P/slUUW/V7BikDXXHNNjm2ozPtjjz1m999/v/3yyy/WsmVLF0jVyagCXppd+Morr7h1NRNWwQ2kNx1/7rnnHjcjTDNKGzZs6Mq4b9682e0j7733nv8LRP3t9Prrr7tAlmft2rUuwLVs2TL3s7bVtGnTkH+DVaxYkXLehYQ+xzSbfsOGDe6LGgXaFQAtVaqUzZw505588klbvny5W7d3797sFwCAlEdsCkAqITaF/CI2hVggNoVYIjYFIJlk+EI1YAaSTEZGRr7WVzlI9RkHCnpy0KtXL3+Zd0raIj/GjRvnAvSBwYrcKHD/0UcfuRNDFF4KWr3zzjthrx/qz7ju3btb3759g65TtWpVGzVqlB177LERjRWpQ21JlixZkud6tWvXtrfeestOPfXULL/XjNQTTzwxX/epgH72oCzSO0B/4YUXulmowf6GV2smBbki3X/5ux4AkCyITSERiE2hIIhNIT+ITSEWiE0h1ohNAUgWVMACACCGNDPnt99+s4EDB9oXX3xh8+bNczMxMjMzrXr16taiRQu7/PLL7Zxzzsl3IB8IRTN7tF9pRuGUKVNsxYoVrvy7Zt/r9507d7b99tsv0cNEHHz11Vf2+eefu5mEmq2qQIRmDmoWmIKdRxxxhJsddvHFF1vp0qUTPVykIM1e1edb//79XfB80aJFrj1TjRo13JeDOt4ceeSRiR4mAAAAUCgRm0KiEJuCh9gUYo3YFIBkQQUsAAAAAAAAAAAAAAAAAIhQkUhvCAAAAAAAAAAAAAAAAACFHQlYAAAAAAAAAAAAAAAAABAhErAAAAAAAAAAAAAAAAAAIEIkYAEAAAAAAAAAAAAAAABAhEjAAgAAAAAAAAAAAAAAAIAIkYAFAAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIkQCFgAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIgQCVgAAAAAAAAAAAAAAAAAECESsAAAAAAAAAAAAAAAAAAgQiRgAQAAAAAAAAAAAAAAAECESMACAAAAAAAAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiBAJWAAAADGWkZHhLo8++miihwIAAAAAAIBCiPgUAABAbJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACJEAhYAAAAAAAAAAAAAAAAARIgELAAAEujRRx+1jIwMd5EdO3bY008/bUcddZSVK1fOXVq2bGkDBgywPXv25LoN7/baVijt2rVz6+n/7CZOnOjfjpZ9Pp8NHDjQ2rRpY5UqVbLy5cu7cQwePDjL7Xbt2mWvvvqqtWrVyvbff3833uOOO86GDx9u0ZZ9jPv27bM33njDWrdu7e67TJky1qxZM3vyySfd8xjKjBkz7OGHH3bPRfXq1a148eLuMR588MF266232vz580Pe/pprrnHjqFevnvt5xYoV1q1bNzvkkEPcc+CNUdd7r6306tXL/xi8i7YVSGN/8cUX3diqVKlixYoVc4+vSZMmdvrpp9tzzz1nixcvLtBzCQAAAAAA4CE+FT7iU8SnAAAAgskMeg0AAIirVatW2WmnnWY//vhjlt9///337jJ27FgbNWqUFSkS2/zp3bt327nnnmujR4/OMY6rr77aZs2aZS+88IKtX7/ezjvvPJs8eXKW9b799lt3+fPPP+3BBx+MyRgVWDvzzDPtyy+/zPL7n3/+2V2GDBli48ePd8Gr7AYNGmTXXnttro/7119/dRcFzhRkuu222/Ici4JlZ599tq1Zs6aAj+q/gbJTTjklR4BNz7UuCxYscI/5n3/+sWeeeabA9wcAAAAAABCI+FT4iE8RnwIAAAhEAhYAAEni/PPPd4GNO++80wVMNKvs999/t969e7ugiwJOCrzcfPPNMR3HI488Yt99951dccUVdvnll7sgkQIrmsGo8Sjwo/H179/fBbI0I69jx45uJqKCc7q9AjA9evRwgTLNuos2zQ5UwK19+/bu/uvUqWPLli2zl19+2b7++mv3PGqMCj4VLVo0y201U7NixYpubCeccIIdeOCBbnaixvzDDz+4x6dg1R133GFNmza1k046Keg4tmzZYhdccIGbFfjQQw/ZqaeeaqVLl7ZffvnFatSo4YKSCsYddthhbn2NNXvQTGPxdO7c2R/cuvLKK90+UbNmTfcYFPxScPGTTz6J8rMJAAAAAADwX8Snwkd8CgAAAFn4AABAwvTs2dOnj2NdihUr5pswYUKOddauXeurVq2aW+fwww/Pcb13e20rlLZt27r19H92ul9vO7r069cvxzorVqzwlStXzl1fpUoVX0ZGhm/kyJE51vvpp598RYoUcevdeeedvmjJPsabbrop1/Wuv/56/zovvfRSjuuXL1/u27p1a9D72bBhg3uedfs2bdrkuk6nTp3891G2bFnfjz/+GHLs4bxG27dvd/uA1rvnnntCbk/7BAAAAAAAQDQQnwof8an/IT4FAACQVWxrxAIAgLBpdlm7du1y/F4zDb2S5Jq5tnHjxpiO45hjjrEuXbrk+L1mGmomoaxevdouvvhiV+I9u8MPP9zatGnjlqdMmRKTMVarVs2ef/75XK/r16+fValSxS1rxmF2tWrVcrMAg9lvv/3ssccec8tTp061tWvXhhzL/fffb82aNbOCWrdunSszL5r5GIr2CQAAAAAAgGgjPhU+4lPEpwAAAAKRgAUAQJJQSfVgmjdv7v7XZLVFixbFdByXXnpp0OsCAznhrLdw4UKLBQXXggWpypYt666XefPm2cqVK0Nua+vWrbZ48WK37ty5c92lWLFi/ut/+umniF+3/FCJ/OLFi7vlwYMHu1L0AAAAAAAA8UR8KnzEpwAAABCIBCwAAJJE06ZNw5pRtnnz5piOo3HjxkGvq1ChQr7Wi9VYW7RoEfL6li1b+pc1KzO7NWvW2IMPPmhNmjSxcuXKWf369e3QQw+1ww47zF3OPPPMLOsGo2BagwYNLBpKlChhl1xyiVv+6KOPrFGjRm724pgxY2zDhg1RuQ8AAAAAAIBQiE+Fj/gUAAAAAmVm+QkAACRMqLLjRYr8L2d67969STGOcNbbt2+fxULVqlXzLAEfWDo90OzZs61Dhw55lm73bN++PayAXzQMGDDABbNGjx5tS5Yssaefftpd9HweddRRbubkTTfd5MrQAwAAAAAARBvxqfARnyI+BQAAEIgKWAAAIOVkZGREdLtdu3a5IJGCWyrjfvfdd9ukSZNsxYoVtmPHDldCX5e//vrLfxv9HEzRokUtmsqXL2+ffvqpfffdd3bPPfe40v66DwUKZ82a5WYcambn9OnTo3q/AAAAAAAAyB/iU8SnAAAAAlEBCwCANAj2KAiT12y+rVu3WrpYtWpV2NcHlsf/5ptvbOHChW755ZdfthtuuCHX22eflRhvKlHvlalXmfyJEyfaoEGDbMSIEfbvv//aBRdc4IJwpUqVSug4AQAAAAAAhPhU6OuJTwEAAKQ/KmABAJDiypUr5/5fv3590HUUAPvzzz8tXXz//fdhX3/ooYf6l+fNm+dfvuSSS4LeXrP5kun1Pfvss+3jjz+2O++80/1OMyKnTp2a6KEBAAAAAAA4xKdCX098CgAAIP2RgAUAQIqrX79+nkGZL774wjZs2GDp4sMPP7Tt27cHnUk5fPhwt3zwwQdbjRo1/Nft2bMny3q50UzNN954I6rjLVmypPt/586dBdrOySef7F9es2ZNgccFAAAAAAAQDcSnsiI+BQAAUPiQgAUAQIpr27at+/+7776zadOm5bh+5cqV1rlzZ0snekz33HNPrtfdfffdrgy63HrrrVmuO/DAA/3LKpmem+7du9sPP/wQ1fF6QTaVZQ9GpecnTZoUcjtjx47NEdgEAAAAAABINOJTWRGfAgAAKHwyEz0AAABQMDfddJO9/PLLbvacSoH36NHD2rRpY7t27XIBr+eee852797tgjt//PGHpYOjjz7aXnnlFVu0aJHdcsstVqdOHVu2bJn73VdffeXWOfLII911gTp06GBVq1Z1AbCHH37YFi9ebB07drTKlSu7EviaWTh+/Hg77rjjcg0WRqp169ZurJ9++qm99tprbvverMPy5cu7MS1dutROPPFENytSY9JjrFWrlltHj23YsGH+mZNHHHGEHXPMMVEbHwAAAAAAQEEQnyI+BQAAUNiRgAUAQIo75JBD7D//+Y+bWbd+/Xq76667sly///7726hRo+yRRx5JmwBXnz597Nlnn7Uvv/zSXbJr2rSpffbZZ5aZmfVPnTJlyti7775r5513nu3YscMFm3QJ1K5dOxswYIAdeuihURvvvffeax999JEr8Z496NapU6cssx3nz5/vLsHosY0YMcIyMjKiNj4AAAAAAICCID5FfAoAAKCwowUhAABpQEEtBXo0g65ixYpWokQJVwL89ttvtzlz5tjxxx9v6aR48eI2ZswYN7OyVatWVqFCBStdurQddthh9vjjj7sS7TVr1sz1tnqOZs2aZVdeeaVbp1ixYlalShVXKv/11193MwwVCIsmzQicPn26XXbZZXbAAQe41yc7vUYTJ050JeY107BRo0ZWrlw5N75q1apZ+/bt7dVXX7Uff/yR8u4AAAAAACDpEJ8iPgUAAFCYZfh8Pl+iBwEAAJAXBX8U+JEJEya4mYAAAAAAAABAvBCfAgAAQDBUwAIAAAAAAAAAAAAAAACACJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACKUGekNAQAA8mPBggW2a9eufN+uatWq7gIAAAAAAAAUBPEpAAAAxAoJWAAAIC7at29vS5YsyfftevbsaY8++mhMxgQAAAAAAIDCg/gUAAAAYoUELAAAkBLatWtnPp8v0cMAAAAAAABAIUV8CgAAAMFk+PhLEQAAAAAAAAAAAAAAAAAiUiSymwEAAAAAAAAAAAAAAAAASMACAAAAAAAAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiBAJWAAAAAAAAAAAAAAAAAAQIRKwAAAAAAAAAAAAAAAAACBCJGABAAAAAAAAAAAAAAAAQIRIwAIAAAAAAAAAAAAAAACACJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACJEAhYAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACIEAlYAAAAAAAAAAAAAAAAABAhErAAAAAAAAAAAAAAAAAAIEIkYAEAAAAAAAAAAAAAAABAhEjAAgAAAAAAAAAAAAAAAIAIkYAFAAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAgDAtXrzYMjIy3KVevXqJHk5aGjVqlP85HjFiRKKHk5IGDRrkfw6vueaahO/Ll156qbufqlWr2oYNG2J6X0h+2ie9fU/7aqT7MBCuiRMn+vendu3aJXo4AIA0RQIWAAAAAAAAACAt6EtV7wvW7JeSJUtatWrV7MADD7Q2bdpY586d3Rf8S5cuTfSwk8L69evtww8/tNtuu81at27tEmWKFy9u5cuXt4YNG7oEmvfee892794d03Fs377d7rrrLrfcqlUrO//885N+zMjb448/bpmZmbZ69Wrr0aOHpbJHH3006HFGl1KlSln16tXdceaee+6xOXPmJHrIAAAAiIPMeNwJAAAAAAAAAACJtHPnTvv333/d5c8//7Rp06a53xcpUsROO+00u/POO61Dhw5W2GzZssUuu+wyGzt2rO3atSvH9Upe2rx5sy1cuNCGDRtmDz/8sL3zzjt2wgknxGQ8/fv3d5WZvESXVBgz8taoUSO7/PLL7d1337VXXnnFunTp4pLk0tGOHTvcZdWqVe4489xzz9lFF11kr732mlWsWDHRwwMAAECMkIAFAAAAAAAAAEg7LVq0sJYtW/p/3rdvn23cuNG1P5s3b54tWbLE//sxY8a4i9pcvfjii1auXDkrLJTM9Nlnn2X5nSqFHX300a6Kj5KZfvzxR/v555/ddUqOOvnkk23kyJF21llnRXUsmzZtsr59+7rlI444ImhCXDKNGeHr1q2bS8Das2eP9ezZ04YMGWKprmbNmtaxY8csv9u2bZv99ddfNn36dH/1NVVqW758uX3zzTeuGh8AAADSDwlYAAAAAAAAAIC0c8YZZwStoCQrV660wYMHu4QrJUaIWhIqOWvSpEmujVhu6tWrZz6fz9KNKvNcffXVdu2111qzZs1yXD916lR3/aJFi1wCzRVXXGELFixwiU/R8sYbb9i6devc8u23354SY0b4Dj74YGvbtq17fw0dOtT69OljdevWtVSmlqYDBgzI9bply5a5/W/ixInuZyVkvfTSS64tIQAAANJPkUQPAAAAAAAAAACAeFOlpPvuu89+/fVX1x7M8/3337tKWIVF8eLFrUePHq5KVL9+/XJNZJI2bdq46j3ly5f3V6vS+tGyd+9e135QypQpY5deemnSjxn5d8MNN/hf72CJS+miTp06Nnr0aPe/R20IAQAAkJ5IwAIAAAAAAAAAFFply5a1YcOG2Zlnnun/3fDhw23y5MlWGOy///7Wq1cvf5JSKKr+dcstt/h//vzzz6M2jvHjx/vbQuq10OuS7GNG/p177rlWokQJt+y1I0xn2o+9pDP5448/XPU9AAAApB8SsAAAAAAAAAAAhVpGRoZLBilXrpz/d2qPlhtVXdL6uii5J9Q2vYvnxx9/tFtvvdWaNGniEjN0OeaYY+zll1/ONRFl1qxZrhrXQQcd5KpCVapUyU488UR77733LFGOO+64LM9FtAQ+pvPOO89SYczZ/fzzz/bAAw+411QV1lSpS6+xXu9LLrnEBg4caBs3bsxzO2vXrrVnn33WTj31VFc9qWTJklahQgXXwk+tGbVfxJva6Snp7YQTTnAtHJVEpcenfVIVyC6//HJ75ZVX8kwu0nvs5JNPdsv//vuvff3115bujjjiiCw///PPPwnZB9SSs0uXLnbkkUda1apVrVixYi6J8bDDDrNOnTrZBx98YNu3bw96e1ULfP755+388893+7ReS22jSpUqdvTRR9tdd91l8+fPt2Tz3HPP+Y/FHTp0CPt23377rf92SvrcuXNnjnXWrFljzzzzjJ1yyilWs2ZN9zrpOdFrdcghh9iFF17o7l9tUKNp69at7v129tlnuzaepUuXdq+HWmJed911rvJfXtRy13t8XtXH3bt32zvvvOP2u9q1a7v3uf7XMfmTTz7J9zi/+uorN57GjRu7fU2tfTXejh07uvvX/eXXF198YTfffLMdeuih7vjjPd9HHXWU+/2nn36ar8ROPVequNigQQP3+mmbOs6pQl+44/vtt9/s/vvvt1atWlnlypXdsVHb0vusefPmrk2untf169fn+/ECAFKMDwAAAAAAAACANNC2bVufwt669OzZM9+379y5s//2GRkZvrVr1+ZYZ9GiRf516tatG3Rb3jpeGL5v376+okWLZvl94KVDhw6+HTt2uHX37Nnju/XWW4Ouq8ull17q1ou3Tz/91D+G0qVLR2Wbe/fu9VWuXNm/3ZUrV/qSfcyB1q9f77vkkkvcPhPqNdOlWrVqIbc1YMAA33777RdyG7qf6667zrdz586g23n77bf963fq1CnXdcLdl1977TVfqVKl8nxsuhx33HF5Pl/PPPOMf/3bbrvNl2p0bPHGr2NOXsaOHZvlOZo2bVpc9gHPsmXLfKeeempYr98xxxyT6zYuuuiisG6vcXXt2jXPY5P2Se822lcj3YfD8c8///iPvfp/xYoVYd0u8Bh800035bh+1KhRvooVK4b1vNSqVcsXLcOHD/dVr149z/s866yzfBs2bAi6nezPr56n1q1bh9zm2Wef7duyZUueY1y1apXv5JNPznOMBx54oO/7778P63HPnTvXd/TRR4f1fOt4nN2ECROyvG/13rnxxhtDbueoo47yrV69Os/jQajP9sDLFVdcEdZjBQCkrsxEJ4ABAAAAAAAAAJAMLrroIuvfv79bVg6VKsacc845Bd7ua6+9Zt26dXPLhx9+uKuIU7RoUfvuu+/8FWNUKeTOO+9069522232+uuvW5EiRaxFixauAta+fftsypQp/koqQ4cOdZWHVHEpnn755Rf/sirzRMOcOXNcJRlRBRdVWEr2MQdWMzrppJPs999/9/9O1VhUdatGjRqugsrSpUtt9uzZtmnTJtuxY0fQbXXt2tVeeOEF/8+qpHLssce6alq6nZ6nuXPnun3zrbfecvetloraT2Jl1KhRrqqMR1VsNCZVxcnMzHQVvRYsWODGtWvXrrC2efzxx/uXC0MFrOwVr0Lt39HeB+bNm+eqGa1YscL/O1Xlad26tatcpW3+9ddfbruqfhVs/9Q+LHrNVYVL71Pt5zqOqZLZ999/b3///bcbV79+/Vy1KFX2SwZ6H+o9qn1t79697tip5zkUvW/VitZz1VVXZbleFchU3cqrtKTKTqp+pKqIqhql97qeVx17tm3bFrXHogpk99xzj3ues78f9dj0emtsuv6zzz6zdu3a2bRp01yFrLwer6pS6TNJr6neow0bNrTNmzfbpEmTbNWqVW690aNHu6pbY8eOdftCbrSujn96/B5tS5UB9dzoM0/347XkVFXHL7/8MkulwuwmTpzoPos1Hs8BBxxgLVu2dNXJVBFMx+CffvrJPZZQx1nPTTfd5KpS6b2jsTVt2tR9zs6YMcN/PP/hhx/s6quvtjFjxuS6Db1XVRkw8P2q/UD7nCqLrVu3zlXHUvU4vT4AgEIg0RlgAAAAAAAAAAAkQwWsrVu3Zqlk0b1796hUwCpRooSrWKIKHKGqAWVmZvqee+45t3zQQQf5fvzxxyzrqqqMqst465ctWzasaiTRokpVTZs29d//7bffHpXtvvTSS/5tXnDBBb5UGLPs3r3bVXzytq0qUapetGvXrhzrqtqKKnGdd955uW5r4MCB/u2UL1/e98Ybb+S6nW+++cZV0/HWVWW1WFbAOuKII/zr3HHHHe49kpvNmze7yjzdunXz5WXbtm1Z3mfr1q3zpXMFrMsuu8y/fpUqVXz79u2Lyz6wceNGV2HIW09V5t5///1c71/Hkffee8937bXX5rqtBx54wL2+2mZutE3t33p83v1NmTIlKSpgyTvvvOPfVvPmzfNVNa9+/fo5njO9jwOPWcH24e3bt/s+//xz38033+wrqHHjxvmKFCni7rN48eK+p556Ktf345w5c3wHH3ywf3yq5JXX86vteRWfFixYkONzp3fv3lk+05544omg4zz99NP965UpU8b3wQcf5FhHVa8aNGjgX69OnTqukmBuli5dmqVCol6PL774Itd19Tq8+uqrvnvvvTdkBSx9Juv/Fi1a+H799dcs6+m17tevX5bHO2nSpFyP/4HjevLJJ3N9v4qqab711ltB36sAgPRBAhYAAAAAAAAAIC0UNAFL6tWr59+GWnxFIwGrZMmSrn1SMKecckqW9atWrepaOOVGX4Y3adLEv+6wYcN88dK/f3///SoRINRjyg8lJ3jbfeihh3ypMGZRgoy37WLFivkmT54c0XY2bdrkq1Chgj8RYsaMGSHXnz9/vtuntH6lSpVyTcKIRgKWkqoCEySCJQ5FIjD5YuLEib50TcDSY1Nipbf+gw8+GLd9QO8l737V0vC3337zxZrG7d3nxRdfnDQJWNqX1X7U215ez4Va2HnrPvzwwzmu13PuJfJo27GmRNLAZLoRI0aEXF9tFtXu1Ds2qQ1lqOdXFyX1rVmzJug29TwEJlblloyn5MDAbX722WdBt6fjT2CrzV69euW6ntr2BR6nIm1RG5iApYuez1Cv3YUXXuhf95Zbbslx/S+//JKv1qsAgMIhdnVpAQAAAAAAAABIMfvtt59/ef369VHZplq4HXLIIUGvv+yyy7L8/OCDD7o2YblRe6iLL77Y//PMmTMtHtTaqnv37v6fr7/++pCPKT+8toqiVlqpMGZ59tln/ct33313ltZ6+aFWchs2bHDLaj+pdlihqCVlp06d3PLatWtd+65YUBs1T6VKlVxLrWipVauWf3nx4sWWTtTKT63nHnnkEevQoYO/TV2bNm3cezse+4BaAL700kv+n5966ilr0qSJxZrGrbHJ+PHjLVmULVvWzjvvPP/PQ4YMCbqu2tx9+umn/p+vvPLKoO8NtfbTtmNNrf/Urk/0ONQuMBS1rPTaLGZvpxjMY4895t7nwTz88MOutZ6o5d8HH3yQYx210PWoZeCZZ54ZdHtq1xj4fnj11Vf9rRU9ams5bNiwLOtEq0Wt3hOhXrvrrrsu5Ods4PFR7TwBABASsAAAAAAAAAAA+H+BX8jqi/houPDCC0Nef9hhh+Vr/UMPPTTX5KVYUWKIvvTfsmWL+/nAAw+05557LmrbX7VqlX85VAJAMo15yZIl9ttvv/l/vuOOOyLe1pgxY/zLl19+eVi3Oemkk/zLU6dOtVioXLmylSxZ0i3PnTvXpk2bFtVte1auXGmpatKkSS4xLfCipJzDDz/cHn/8cZcIVbx4cZfM8cUXX1iZMmXisg/MmDHDn9BVrlw5f7JWNCxYsMDef/996927t917773WuXNnt/97l40bN/oTw5YtW2bJIjCRSuMPZsSIES6JTo4++uhcE9fq1KnjT9INTBCKlVgfI0qUKJElsTfYOpdeeqn/5wkTJuRYJ/B3gQlMwVx77bVWpMh/v6pesWKF/f7771muHzdunD+BUcfw0047zaJBx7Wzzz475DpHHnlkyCRRbx/wHrfeFwAAZCZ6AAAAAAAAAAAAJIvApKvy5ctHZZuBCVO5qVixYpYKXIHVgXKz//7751qFIxZ27Nhh5557rv3555/+5+Sjjz6KatUXVVPxKHklFcasBBePEgMKUrlr+vTp/uXXX3/d3nnnnTxvs3z5cv9yrJJclDikJLahQ4e6JAgldFxyySUuQfCEE06wChUqRLztwNc58PVPR0pEef755/3JbPHYBwL3z1atWlmpUqWsoD7//HNX1WvOnDlh32bNmjVZElUS6dRTT3WVBf/9919buHChffvtt9a6desc6wVWx7rqqqty3ZaSlVRByatgqCQsvTdOPPHEoNULCyJw//j4449d4l9evES4cI4RSgIO5/h47LHHun1Zsu8Hqlal59aT23ObnSpHNW7c2J/M+sMPP1jTpk1z3Y/btWtn0aKkumLFioVcJzAZOLfPWe3Xem9pjHqumzdv7vYXVSc77rjjovJZBgBIPSRgAQAAAAAAAACQy5fWgYlO0WprmJvMzMyw182+vtpLxYqSbpRUMHnyZPezEkjUmkvVfWIlewuqeI35hRde8Lf4CmbAgAG5Vu1q0KBBxONVha7ApL8333wz39uIVqvM3CjZYvbs2e652bVrlw0ePNhdVLVG7RzVdlGJLaeffrqrkBOv19nz3XffufHkV+BrWRA1a9bM0g5Oz5ESo77//nuXfOS1TdPzpzZyuSVCxWIfiNb+6Xn00UetV69e+b5dtKoIRoOOm6rg9OKLL7qf33vvvRxJQqrC9M0332RZP1g7vokTJ7rkG+3LI0eOdBcvIVPvi5NPPtlVWVIFsoL6559//MuRVNzK6xhxwAEHhLWdwPVWr16d5brAn7Wfh9uWT60IvQQs7z0Tq/04P5+zgQlaXhWu7AYOHOgSUzVOvY9feeUVd9G+c8QRR7hEVbUh1b6g9sEAgPRHAhYAAAAAAAAAAP9fiSewqkz16tWjsl21JYvFurG0b98+u+aaa1zykugL5Q8//NDatm0b9fsKbMvmtf6K95iVPJFXVZnApJ3AxJKCVNYKTPiLVLDkgGjQe2DWrFn29NNP2xtvvOFPiNBz/csvv7jLyy+/7Kq43X///XbfffeFlWgQ+DoHa8sXjl9//dVeeumlhCVgKdkmt23p8SnR58EHH3TP1fjx4+3uu+92yRnx2AeitX/K119/nSX5SlWQ1DquRYsWrgqQth+YfKdKRd57SY89mahCkZeANXz4cOvXr1+WRJsPPvjAP+b27dsHrWalfVaPUdvS/hfYok7Jdrq89dZbrgrS7bff7p6/glQhK+g+ktcxItxqTYHv1ezJdV671+zrFWSb0dyPY/E5e/DBB9tPP/1kffr0sXfffdf/Oun51nFTF7W+VVVLJTHecMMNUblfAEDy+m9jXQAAAAAAAAAACjl9Wbp3717/z2ovVFjdcsstrkKMqNqRvlw+66yzYnJfgYlu2SugJOuYA6vaBCYe5Ff2RIV169a5ijr5uagSTyyphWPv3r1dizFV/FEylloTVq5cOUuFne7du9sFF1wQVnWrwGo50Up0TCZKtunWrZs99thj/t+pElZur1Us9oFo7Z+i1zuwneK0adPsxhtvdBV+1KYte+WzZKp6ld3RRx/tb3GnY81XX32V5Xrv+CFXXnllni067733XtfO8Mcff3TJWKqYFdhCdtu2be75U2vCgiSXBu4jatOX3/0jMEEsNxpnOALbhWav7BWYIJWftqKhthnN/ThWqlWr5l57JafqfahjpSoCBrYw1rFT75k777wzoWMFAMQeCVgAAAAAAAAAAJi5akkeJfC0adPGCqO77rrLVTvyvPbaa3bZZZfF7P7q16/vXw6sQBbPMeuL87ySGLJ/6e5ZtGiRRapChQpZElhWrlxpyUqVrY455hiXdKKKYUo4mDJlip1zzjn+dT755BP7+OOP89yWEhICW5BFShXP8puMEq32h+F44IEH7KijjvL/rKSseOwD0do/lZDqVbPSMfHJJ5/Ms3rQ0qVLLZldccUV/uUhQ4Zkqaam5CYv8UdJhuHQ89GsWTPr3Lmzq6ClY5i2oyphga0yI6nUltvrGYtjRLiv2bJly/zLgQmYEthyUMlm4SbTBiaHZd9mtPbjeNB7WNUW1Z5yzJgx7vF/8cUXWf6O6N+/v2tPCgBIXyRgAQAAAAAAAAAKvbVr19o777zj//m0006z/fbbzwqbhx56yLXl8jz//PMxb5t0+OGH+5d///33lBhzYHW0BQsWRJw4Ji1btvQvq7pQqvCSFEeNGmWnnnqq//deC8hQ1XaWLFni/1nJK+lKSWt9+/b1/zxz5kz3fMV6HwjcP6dPnx5x9SUlkezatcstqx1fsJZ8nvnz5xeoil28ErC8JDLtq17FrsDqV+eff36BWgYeeeSRrgVh4HEor/dFKEp8jOUxYu7cuWFVrdK+5AlMLBRV/grcP7799ts8t6d9RcfPYNsM3I8nTJhgqUStLfV3xLhx4+zQQw/1/3706NEJHRcAILZIwAIAAAAAAAAAFGqqiNOpU6csLY5UxaKw6dOnjz3xxBP+n9U+rWvXrjG/38Dkk59++iklxly3bl076KCD/D8XpLpNYJvEV155Ja4VmqJBySxnn322/2dVxsor2WPfvn1u+cADD3QVoNLZKaecYscdd5z/Z7Uoi/U+oMSVihUrumUlGKkdZ6RJdp5wkrg09mSninutW7f2P6YRI0a45/v9998Pu/1guAKrw+X1vgglcP9QYteOHTssmrS9wAqQuVEi3rBhw/w/q61idoG/GzRoUJ73q3W8Y0HNmjWtSZMmWa5XYmdmZqZb/uOPP3K0jEwFqozVvn37qOwHAIDkRwIWAAAAAAAAAKDQUtLVpZdeap9//rn/d1dddZUde+yxVpi88MILWZLO7r//fnvkkUfict+qFuO1nvrzzz/D/oI6kWOWu+++27/87LPPunZ8kbj55pv9SUhqXdarV6+wb6sKMmoTFwtK3PGqH+WnNVleVZICn6fAylnprGfPnv5lvcaBx5tY7ANK+rjtttuytD6MpLpcpUqV/JUAN27c6G9HmBtVZkqFBCzvGO9R5StVa/Ja3KmS00knnRT0tjt37sySrBut90UoF1xwgTVq1Mgtr1ixwr224SbpaazhVLfq0aOHrV+/Puj1SnT1WoeWKVMm1xav2o89alMaKmFKVfCUQBt42+ztLZWUdckll2RZJ1kSmPRceclj8doPAADJjwQsAAAAAAAAAEChs3LlSnvmmWfs4IMPtuHDh/t/r8oob7zxRkLHFm+qqHLXXXf5f7799tuztE2LNVXZOeOMM/w/f/PNN0k/Zrnmmmv8lXR2797t2k29/PLLbjk7JTKp9VTHjh1zXKcEF7VN9Cj5RhXZli5dmuv9KvFCyS5KwjjggAMibi+Xl9mzZ1u9evXs0Ucfda3lcqPEH1XF6d+/v/93p59+esjtBr6+gZV90pkSzQLbqWWvghWLfUAJiQ0bNvQnT6ld5NChQ3NN3FFbyA8++MCuu+66kO9N7fNqo5idjqFaT/uDknOS3cUXX2zFixf374/6LPAosSiw8ld2SoCqU6eO3XvvvTZr1qyg63399ddZEu/yel/k1cpSyW36X95++20788wz7ddffw16mx9//NEl3mmsXnJZMHoulCSkSk1//fVXluv0mj755JOuuqCne/fuVr58+VwrYAU+zgsvvDDXylo6tqgy3IYNG9zPGuOdd96Z69h03/vvv78/aUvJ0cESu7S9119/3e37sfbJJ59Y48aN3b6zePHioMl6AwYMsI8++igq+wEAIPn9t24jAAAAAAAAAABpZMyYMa4yjEeVKjZt2uS+oFUySW5fSN94440uCULVYwqLX375xT1uLylDyRNavuOOO8K6fZcuXVwbuYK64oor/G3SRo0alWt1lWQbs1pjKflI1XLUHktJLEoEe+ihh1zLuRo1atiePXtc0oASDrT/edWEslNiy8KFC/2JOXouVJnniCOOsKZNm1rZsmVdJZvly5e7xAol1MSDkk2UDKRL9erV3Xj0vx67KtHocf3zzz/+9Y8//nhXUS5UVa3x48f7K8EUlgpYomQcL/niu+++s7Fjx2ZpTRbtfUAJMmqvp+f433//dcdDva/UolOJg1WqVHGt55Rwo6pbSuJq1qxZju2oypzek7peiSZKJFMSjJJPlFg4ffp0//FU78sFCxaErJSVDNSeUQljelxKMNL/uVXHCkafI6p6p4uSg1TFT5WzSpYs6Z7rn3/+2b2WHj1XOu4UhBKWlIR16623ujF/8cUX9uWXX7ok4sMPP9y93joG6T2rVq6rV68Oe9tKlFL1QSXXaV/T+1jJe3q/Tp482W3Tc8IJJ7jErmCUHKbjn/Yr7a9KdtPx9phjjnGJXvr81f4fePxW8l+wVqRKzlKC33nnnee2p31Nya5qA6v2tXr+9Xvtd3pfKAH23HPPtXjQY7zvvvvcRYmQeh28CldK8p4xY4atW7cuy+ecl7QLAEhPJGABAAAAAAAAANLO999/7y55UUURJUUoKeHkk0+2wmbt2rVZ2iipVZWqOOXni/toJDPpudcX6kpWUns2faGuhJNkHrPUrl3bfcl+ww03uJZbXnJG9hZznmCPSVRh5tBDD3WVvZTUpCQLJTjpEowSEIoVK2axUKpUKZdopSQyL6FACR+hnldVJgtVPejTTz91VWG8RBdtv7BQ0oheL6+ClBKtAhOwYrEPKCFE93f11Ve7RBpR4py3r4azfyrBRwkyl19+uUvwUeKMWvbpEuimm26yF1980Tp06GCp4Morr8ySeCWHHXaYe85C0XOtJF1vP1aCjZdUmJt27dq55y8alcGU4KZWhGrFp6RPvRbz5s1zl2AOOeQQfwWpUI9J+4RaHep4NmHCBHfJTlW3VEUt1Pu2WrVqrjqb9hev2p3Gqkt2eizvv/++tWjRIs/Ph6lTp7qqcEouE31W6JLf42y06D7UMtFLJFO1umAV63RMvOWWW6xfv34xHxcAILEKz1+2AAAAAAAAAIBCS5U3VCFEFYhUwUcVS5o3b+6qiiiJBomlRLjOnTu7tl5KqFLCgpINUoGSG1RpSAl/SiaYOHGiq1K0fv16l8Sk/UtVjJSAoySlUFQtRtVblOSgNlvapirZKCFNCRyqsnPQQQe5CjWq4KPKOrGiijWq5jNu3DiX/DBnzhxX8UUJcEoM0vtJVXJUEUnJLEoEysubb77pf73DrViWTnr06OFvu6jnVEkuatsWy31AiY2qSKUkIbWDmzJliqtopIps2p6u17FQyTXnnHNOrtvQeObOnWvPPfecq9ylRBMl4dSsWdNVO1L1LlVGSiV6HVR1yWuDJ9qP86LnX+8BJRfpuVRynKpH6TVSRbBy5cq551RJRZdccon7jIkm7S9qPajkMSV6KmFKyZF6PUuXLu0SoFTFSpWWlFysY0849FpqPxkyZIirvPbbb7+5qmmVKlVyj+Xaa691VajCoTFof1PCpqoEal/XGFWdShWi9Pmrben5DjeBVNXZdAzS49ZFldeUTKjPCx2LGjRo4I5BZ599dlySAHUs1/tI7wclnCkxTFXPvP1Jf2vovanWn0qAVCIjACD9Zfhya/YMAAAAAAAAAAAQR2p3Vb9+fZfcoC/b1U4K6UOtx1TdSV9LqTqOkjwAJMagQYNcUpWospR+BgAABRO8DiwAAAAAAAAAAECcqHLM/fff75ZVTSRUuzuknv/85z8u+UqVk3r16pXo4QAAAABRRQIWAAAAAAAAAABICmpDWK9ePbf82GOPJXo4iBK1LlR7RrnlllusUaNGiR4SAAAAEFUkYAEAAAAAAAAAgKRQqlQpe/75593y9OnTbcSIEYkeEqLg4Ycftt27d1uVKlWsd+/eiR4OAAAAEHWZ0d8kAAAAAAAAAABAZM477zzXqg7p44MPPnAXAAAAIF1RAQsAAAAAAAAAAAAAAAAAIkQCFgAAAAAAAAAAAAAAAABEKMNHHV8AAAAAAAAAAAAAAAAAiAgVsAAAAAAAAAAAAAAAAAAgQiRgAQAAAAAAAAAAAAAAAECESMACAAAAAAAAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCyjkFi9ebBkZGe5Sr169RA8nLY0aNcr/HI8YMSLRw0lJgwYN8j+H11xzTcL35UsvvdTdT9WqVW3Dhg1W2LVr187/3E+cONFSmfc4dElWeo69Meq5jye9t7z71nsuWvS+9rar93u8pMLrnU7C2X9ivS/069fPbbtIkSI2a9YsS7SdO3f6n5dTTz010cMBAAAA8q1r167u79nSpUvb8uXLc12Hcy8ASA7z5s2zokWLuuNxnz59Ej0cAADSDglYQIokNWS/lCxZ0qpVq2YHHnigtWnTxjp37uy+qFy6dGmih50U1q9fbx9++KHddttt1rp1a5coU7x4cStfvrw1bNjQJdC89957tnv37piOY/v27XbXXXe55VatWtn555+f9GNG3h5//HHLzMy01atXW48ePSyVPfroo0GPM6Euuh3yb+/evValShX3HDZp0iTRwwEKlVWrVlnPnj3d8iWXXGJHH310oodkJUqUsF69ernlcePGkagNAACAlDJ37lx76aWX3HKXLl2sdu3aiR5SytCEvgEDBthZZ51lderUcQlsOj9QPFCx3gceeMB+++23RA8TQD6+B9CkySeffNIuv/xya968uXs/63sc772tmP8999xjc+bMCXu7u3btcvGC7t27u4lbOl6UKlXKXXTMPf300+3ZZ5+1devWhbW9Qw45xK6++mq3/MQTT9iyZcsifswAACAnErCAFKWKCf/++6/9+eefNm3aNHfCfu2111r9+vXtzDPPtK+++soKoy1bttjZZ59t1atXt4svvtheeeUVmz59ukuUUeLS5s2bbeHChTZs2DC78sorrXHjxjZ58uSYjad///7+Kh/BElaSbczIW6NGjdyJtOj1+uuvvxI9JKQIvbfXrFnjls855xxLR4mqZgXkRYlOmzZtcvtmMiXP6rO9QYMGbrlbt262Z8+eRA8JAAAACMv999/v/n4tU6aM3XvvvYkeTspQjE+TLTWh9vPPP3eVw5S8oUQLxQMV6+3bt69LlLjjjjuYjImUFqtq6slGyagnnniiPfjgg/bBBx/YDz/84N7P+h7He28rLvjcc8/ZUUcd5SZb55U0pWOsJuEr8eqpp55yiVg6XuzYscNd/v77b/vyyy/d8feAAw5wcepwPPTQQ64K1rZt25IqPgIAQDrITPQAAISnRYsW1rJlS//P+/bts40bN7rZUiobu2TJEv/vx4wZ4y76EvzFF1+0cuXKWWGhZKbPPvssy+90kqIqF0pwUsDixx9/tJ9//tldp5O+k08+2UaOHOlmnEWTvuRVsESOOOII69ChQ9KPGeHTl+TvvvuuCzSqosqQIUMs1dWsWdM6duwY1rqBxyOE79NPP/Uvp2sCFpCM9Nn55ptvuuVzzz3XDjroIEsWCnoqWKoKmEqsV+LiDTfckOhhAQAAACEpSeiLL75wyzfeeKNVqlQp0UNKCe+//76bhOHz+fy/U6UcJWSpUs6iRYts5syZLmlDcV4ldaxYscI+/vjjhI4bQPhU0U5xB72vK1So4OLHSpyaMWOG+87AS8ScP3++TZ061XXACBZH1Pc/HiW7HnPMMVarVi3XOeOPP/5wSV36/mDr1q0urqAOKarCldfk4gsuuMCGDx9ugwcPdhX3qNQPAEB0kIAFpIgzzjgjZMuvlStXuj+WlXClP+ZFX+ApOWvSpEmuJG2wGSiBJ/zpomLFiq6UrqqCNWvWLMf1OrHR9Qpq6AToiiuusAULFrjEp2h54403/LNYbr/99pQYM8J38MEHW9u2bd37a+jQodanTx+rW7eupTK1NFU1vfxSeW2EZ/To0e5/BaZVdjzS9rSJOm7HaqaiPq+oloVYUjl+b9Z4OJ/J8XbVVVe5ma1Kyn766aft+uuvd7ODAQAAgGSlaiyiv1v1pT/ytn79elfRyjun14RNxQ+zt0dXS7CuXbv6W5Trf13OP//8hIwbQHhxVcWHNQlbsf3MzJxfv6pqVb9+/VwFKiVY/vLLL65iVqh4rLajZCnFCVRhK/t2lXB13XXX2fjx4/3H5hNOOMG1Jgzl1ltvdQlYe/futWeeecYdiwAAQMHRghBIE6qUdN9999mvv/5qF110kf/333//vauEVVho5ofK5ipJQCczuSUySZs2beybb77xzy7RzBOtHy06cVH7QW9mikoKJ/uYkX9ehRK93pEkLqFwUWWb3377zZ9Uq6o3AGJPFUPffvttt6xWzaoiGS7NII2UkqnCVbZsWbvkkkvcspKrVckUAAAASFaquqLWeaIv+pV4gLx98sknLglLNFlWz2H25CupU6eOS4w4/PDD/b9777334jpWAPmjattKplJFu9ySr0RV7lRtSt0UPOqwoMSs3Og7hd9//91N/lUbwty2q9aDOpaog4rnscceC2uCpyphiTo7rFmzJqzHCQAAQiMBC0gz+gJP5WvPPPNM/+90wj558mQrDPbff3/r1atX0LK92at/3XLLLf6fvcBRNGjGidcWUq+FXpdkHzMiO7EuUaKEW/baEQLhtB88++yzEzoWoDDR30VeIpWS1MOtLKUgZ+PGjV2gM7/UOliBzMD3fV4uvvhi//Jbb72V7/sEAAAA4kUTHLwqTt5EAuTt559/9i+rqnrNmjWDrqtJW4ETOjVRA0B6UMUqz+bNm92kzdyoI0qDBg3y3J7i0/p+wfPdd9/Z2rVr87ydN5FfCWAffPBBmKMHAAChkIAFpCF9sahkkHLlyvl/p/K3uVHVJa2vi5J7Qm3TuwR+uahSteoPrgQjXdSD/OWXX841EWXWrFmuGpf6n6sqlFpwqWxuImdwHXfccTFprRX4mM477zxLhTHnFhTSjBy9pqqwpkpdeo31eiu4NnDgQFdVJC862VPrJ83S0Qw+zfSpUKGCa+GnNlDaL+JNpdx1UqpZmmrhqJNUPT7tk6pAdvnll9srr7ziWnuGoveYV0nl33//ta+//toKI82Y8o4PwdoR6r3vreO1mtu2bZs7Xqi6m/c6aB+57LLLbNq0aWHdt1qKffXVV651l44nCl5qH9NM0tq1a7ty26oUl59KNLFuP6h97bTTTot4O3qOvedSz31+ju16v6lym5JKSpcu7VqftmzZ0p544omwKv1oW952sx9/vOveeecd/+/UUjXw88O7ZG+pm9v+kWqvd7DXRZWMtE9rRriOobo+WPVCVbHUbEm9JnpPaF+pUqWKOw6rUuI///yTrzGpOp+SsNW+Vsduvd7FihVzxzpts0uXLi5hOFhLS5XDnzJlirvv9u3bu1mV2m/0Xq1Ro4addNJJ7u+LZJ8lGclnso7pOr7rOVd7wI8++ijs+1MLgVNOOcVWrVrlgplqIRwOPZ/77befW/7ss89sw4YNYd8nAAAAEE/RiHupar93fqo4oSYo6lzoySefdFXfw6Fzv1dffdVNfvTOV3TOo7+rmzZt6iY/6Xx37ty5lgwCz1V1fpYXPSeB52fxEouYQrgx6HBjEKHWUTKLOkUceuihbl9QzEDxPo1TsajcJt+oNeRhhx3mJsgqbtmqVSt76aWX3Hl1rCkO4j0Gr5OF4h+KryieqniHzsP1v95vqqQWLsUZnn/+ede+UnEBxTL1HlGsQdXX7rrrLps/f37E8b8VK1a451X7geLHShzU8xf4enuTlL2q1LnFiXKLJ0YrfpuM9PwHUhJWNL8zUJwn8HkPpmPHjv5lVcECAABR4AOQtNq2batvRN2lZ8+e+b59586d/bfPyMjwrV27Nsc6ixYt8q9Tt27doNvy1vEOG3379vUVLVo0y+8DLx06dPDt2LHDrbtnzx7frbfeGnRdXS699FK3Xrx9+umn/jGULl06Ktvcu3evr3Llyv7trly50pfsYw60fv163yWXXOL2mVCvmS7VqlULua0BAwb49ttvv5Db0P1cd911vp07dwbdzttvv+1fv1OnTrmuE+6+/Nprr/lKlSqV52PT5bjjjsvz+XrmmWf86992222+VKNjizd+HXMKeqyaMGFCruvodfPW0es5b94830EHHRTy+e/Ro0fI+126dKmvUqVKYb2WWm/s2LF5Ppbsx7poWbdunS8zM9Nt99RTTy3QtvQc5/WaZX8/7Nu3zz2fRYoUCfoc1a9f3/fXX3+FvG9ty1tf9xHsurwu2T/Tsu8fqfh6Z39dNmzY4OvYsWOu43v++eez3FaflzfffHPIz1VddOzq379/WOOZPHmyr3HjxmE9X926dctx+127dvlq1aoV1u3LlCnjGzx4cJ5jCrX/5GdfyO97z3tey5Ur59u9e3fYt9Vr4o1F79+PP/44z9vMnTvXV6VKFf/tjj32WN+mTZvCvs+zzjrLf9vhw4eHfTsAAAAgXn766Sf/36xNmzYN6zbZz710Thjq/FTnIt9++23Iber6cM9ZdMnPuUCs9O7d2z+eww8/PM/177jjDv/6l112mS9eYhFTCDdul99zyOzr6NxU8dJg4zzyyCPdeWLgaxLqcbVr1863detWXyxlj3v+888/vtatW4fcn88++2zfli1bQm73oosuCuu9odhs165d84zNZ4//jRo1ylexYsUc21MsOPD1DueSPZ4Y7fhtsvnhhx+yPAa95gWl2EPgNmfOnBnW9xhe7F77wapVqwo8DgAACrvcGxEDSAuqutC/f3+3rFiHKjCcc845Bd7ua6+9Zt26dXPLhx9+uB1xxBFudotK23ozZlSh5M4773Tr3nbbbfb6669bkSJFXC9yVcDyqmosWrTIra/2Ppq5oopL8aQqFR5V3omGOXPm+KuBqOKJZugk+5g9qvShChya+eXRrCXNoFG1E82+Wrp0qc2ePdvNRgzWn166du1qL7zwgv/nypUr27HHHutmQ+l2ep40A1H7plot6b7VUlH7SayMGjXKbr75Zv/PmtWmMWkGWWZmpqvopZLuGteuXbvC2ubxxx/vXy6sFbDyS6+1qsNolpz2Lz2H2i/0vvnmm2/8ldUee+wxVyktWDsDza70ymlr1uUhhxxidevWdVWG9Prp+DJjxgy3v2m9M844wyZNmmStW7e2ePviiy/8lQGjcRzOL80Y1PMpOmZrVqdmPKqS4Q8//OB+r+dLMyn1s94P+dWpUyf3PKui0m+//eZ+pwpCmnWcnWZG5lcqvd46rl155ZWuipFmcmpWqfZl/V7Hl8BqknpcHTp0yFL1rWHDhta8eXP3ONetW+eu0/tm+/bt1rlzZ3f8VaWsYPSZqqpXOmZ7NEP5yCOPdLN/dft58+a5iz6PczuWa5bv33//7Zb1HOv5Vtl7HTe13eXLl7vnW9vSY1CVKO1TydZ+RMcUb8ayZjDnZ9/WTFo9Vn1G6f2r9h8ffvihaz8bbGaxPkNXr17t38+//PLLLBVJ86LjofYb7zPFawcAAAAAJIvA2EdgTCRcL774or9Vltp2qzqvqtoo3uVVSde5iCpH65xO57C5VcbReZRXNUbnIoo5anuqzKRzFFXg+emnn8KuphUPigc88sgj/srzOncLbDMYSDFWtXoUnUOqC0GixCOmEK3YiypZ6TxXMVmdk6lqtp5rVVwTxSP1nCt2rWpr3uuhGLdi0xr7zJkz3fmyqDLT3Xff7SqtxYPOQVWVSHF2xdv1HlOMQPu63g+qtOxVWVeFt7FjxwZ9vhXDFV2vmISeE8XhtF1VfdZzoveaYhWq1L1z505XqT4c3377raturvGqIpWqVCn2q+3qOVbsQJ0PRJ06vPeqYhW5nSPXqlUrpvHbZKIxB34HoriV4u7R/M4g3O8NFIfX/eu9o/1g3LhxrrIYAACIHAlYQBrTl7c6ofK+eNQXpdH44l8ti5Qsob7g2dtfqdXcvffe65b1haW+eFfylZKutL5OZD0al9b1WjGpjZG+WFbZ8XjQyfjgwYP9PyshJBp0guzRyXsqjFn05fLFF1/sT75See6nn37abrrpJhdUyX6iqECFXuPc6Pde8pVOkrVfKDkj+3YmTJjgvrTXyb6+pH7mmWdca7FY8QJ8ooBM3759XWAut5LwOvFUolleFHTy3md//PGHrV+/Pqwy8oWZgnYK6iiRU63NAl8DJZso4UBJE6IkE+2XgQkrHu2jOmYo0UUJLrkl7ynQqvvTPqh9XC3xlCQRy0S/3Hz66af+5XgnYCnRTc+BAnbvv/9+juQnJZRcccUVLmimYI3WUUAs0veXyuV7CVh6bbzy+QWVSq+3ApG6fx0f1JpD/wfS/u9RkrKXfKUkKSUuZ/9s1fFFn6VqDaDb6n2jFowKQGanQKcet5d8paQrJRLpS43sVKZfJeZza2Wh50zb0b6gJNzsx2/vcejLE71P9XhvueUW1/pDCVvJoiCfyTruvPHGG+6xKWCs51THo48//tjOOuusLOvqs1PJVwo2y1FHHeU+J/UZmB+BXy4p6A8AAAAkm4LGvdQaTkkxb775pjsXDaRzI03qUJxI53c6H1FsJvv5yHPPPedP6FCCihKZ1KI+O/0tr23q7/rc4grSs2dP/2SfaBkwYECuv9fzpRZ+euyi81sl0Cj2puQxPS9KZNI5hx6jEsk0bsWvIkl2S6WYQjTonFlxZcUlL7zwwizXDRs2zI1T59d6zhWPVvKV9huNuW3btlnW1/N/zz33uGXtP0qYCbd1YkF89NFHLu6qc0rt10qa8mjsgUljiqsqdtu9e/dct6W4gR6DkhVzOzdVwo0mAF1//fVuIpFiB0q+adOmTZ7j1PtG4+ndu7eL7wW+RxUrULtA732g+/Der4od5fU8Rit+qxij4ifRpNdD343kl15TvZc0IV0xKyUvipLRvAn00Whl6dEkOn1/E24cQs+jF4cgAQsAgAJKdAkuALFrQSj16tXzb0Nt3qLRgrBkyZKuxU4wp5xySpb1q1atGrR8rUobN2nSxL/usGHDfPGiNk7e/arUdKjHlB+BLYseeughXyqMWd544w3/tosVK+baV0Va7rhChQpuO8WLF/fNmDEj5Prz5893+5TXNiy3st7RaEG4efNm//V16tRx5dOjpUGDBv5tT5w40ZeqLQhr1qzpu/322/O8ZC8Lnt8WhLp079496JjUtlMtzbx189qHwnHLLbf4tzdmzJig6wWOMVrUys0r5x1Oi4FotyD03lt///130G3ee++9/nVPO+20uLeQi3bbuUS83oGviy7Vq1f3rV69OuRtdJz11m/YsGGe6wceC4O9Tiq9761z9NFHu2NfrD311FP++3z55ZeTqgWhWiJ729PnXCT0t4rafXjbKVGiRJb9asGCBe746V3frFmzXNs+h0OtNgPbHiZDmxQAAAAgUGAc7+uvvw7rNtlbhg0dOjTouop16W9ub92BAwfmWKd58+b+6//4448CPZ7A85RoXfJq+XX33XeHtR21NA91ThsrsYgpxKMFoVqohdonb7jhhiyPSy3uFJcMJ8bdt29fX6wEnuvrotaaa9asCbr+ww8/7F9X8bONGzcW6P4Vd/O2d/HFFwddLzD+p8vjjz8etdcxFvHb/LZBDOcSLA6Xm6JFi4bcVuPGjX2//PKLLxrmzJmT5f5CxWaye/fdd7O03AQAAAUT33IAAOJOrYY8qswTDSoBrFkUwVx22WVZflZljKpVq+a6rioHqZpEvKs9qIx04OwgzfQJ9Zjyw2urKCqNnApjFs2+8ai0dqQz6zTLbMOGDf7KLrlVXQmk6miqjiWacahKWLEQWHJepbGDzXyMRGCZbJW4T1VqcfbSSy/lefFmaUWqSpUqIWegqW2nquhE87igSj4eldOOp8mTJ/vbKiai/aB3HM5tNrDnuuuu8y97ZflTWSJfb4/2cZXfD0UzagOPwXmtr2piXktHVVfKPktbM9G9alo6xr3zzjtxqUaVDM93LD+T9beKKmBdcMEF/tm8agmhWdN//fWXm1Ws46foc1nPwf777x/RfantgFexTbP1vTaQAAAAQDJQLtWSJUsK9De24k2hWpfrb2qvdZlXfShUjEcxhlSiv/d1/qcWgzqXCEbtw1TFKVGVr1IxpqCYS6huAdlj1opxKy4ZzvrxrFCsimOKXQbz8MMP+1vWqUqauk4UhGK33vMwfvz4sG6j/UGVr1IpfpssFGPQe0qx/kMPPbTA29M+oA4TXhcUtZtUpb3CFtcGACBZ0IIQSHOBX7x6pX4LKnsJ5+yyt1rKa/3AE43AL0pjRclB5513nitT7JUODvwSvKBWrVrlXw51spxMY1bwzGsZ5pV3jtSYMWP8y+GWLFbbJrXdkqlTp9r5559v0abEBpVy37Fjh82dO9clKaitVrS2HdjSC6GdffbZ7rUIRW3Thg8fHvbJv0rdK/nkp59+cq+BjndKXsjt+FfQBLL8Gj16dJbHnghq6xiKknrU4m/79u0uqUfPl8qgJ6tkfr09ob5QEI3366+/dstqBZC9pV0wCtDreK0vPnQcC0zqC0xgPfnkk13QLRrUolAl/fVcLl++3AVEvRaH2SXq+Y71Z3JmZqYLauu99Mknn7gkrHPPPdclWnnJVwpYq31qXol0ed2Pkue9pHnt33Xr1o14ewAAAEA0aXKR4ioF+Rs7nPZ0mqjnxb2U0KMEA7WWC0xO+uOPP9zyq6++WqBEkEQkHKjN3EMPPWQLFixwyRhq69ekSRO3rEkeamu/bNky1z5Oz4PWb9WqlSVKqsQUUj1mLWrdFzhZOdg6l156qT3//PP+VoRKJgtF+9qsWbPc/qX3sc5p/1uc7r+8iYN6/bTv6T0Wip47nb8mc/xWrQ4DH2O8KZHUS4rSMUzPqxL59P544oknXNxT7QdPO+20iO9Dj0+T4vRcefuGYhfZ27aGQlwbAIDoIgELSHOBX0Ln1us9EnnNzKhYsaJ/WV8iBs6iyE1glYjAWS6xoJM3fWH6559/+p8TBTGiWSFEJ1Se3PrTJ+OYZ8yY4V9WcldBKndNnz7dv/z666+7Cix50Rf6Hp2MxkLx4sVdEtvQoUNd4oOSvpQgoYDBCSecYBUqVIh424Gvc+Drn2ratm1rEydOjPn9ZA945SYwiBvquKDgnoIWCriuWbMmrPsPd71oJ2BVr17dWrRoYfGm43BegTPNKNSxW8+n95wnYwJWKrzeUr9+/TwrIP3888/+44UCY126dAlr24GzibMfLwOP5aFmUodLx8oXX3zRBXUDj9PJ9nzH6zNZr5MCpEoS/vzzz93ns5d81bhxYzdTOFjFz/zQOL0ErFT+TAEAAED6yf73aSR/Yx977LFhxQ0U99JERCUw6Pwp8HZKUNHkB3nggQfc5JYrrrjCTj311KhWo48FJYv95z//cctKLBk0aJA1atQoyzo6z7jllltcPEFVcZWgoXNBxeziLZViCvmJWUtenQXiGbPOvu/nRe8HLwFrzpw5QdfTuesjjzwScp3czuvzes2bN29uqRa/jbcXXngh12Oouguoarpi/eoAoG4SXneI/NLx78MPP/T/rHjZ4Ycfnq9tBB7HFefQJDyvMjcAAMg/ErCANOfNXpFI2+GEamuYm8DZL3mtm339YBU1okEnbTphUzsw0WyaTz/9NN8nJflR0Fk2kY5ZJ3jeTMBgBgwYkGuFkAYNGkQ8XgXGApP+3nzzzXxvI1qtMnOjwISquOi52bVrlw0ePNhddFKpoIvKuitYd/rpp7sZQ+GK1mwqVfTRePIr8LVMBeEcFwJnagU7LmhfUSAmvxV3olUNMBwqJ75w4UK3rApHiSidHs7zHe5znkip8HrnpwWGl7jjzTBVAK6gx8toHctFs2FVXUtt9pL9+Q5XNI7VCgbrM1bPS+D75PHHH/e3gCioRM7QBQAAAGL9t+sBBxyQ5zo6d1YilVetffXq1VmuV3stVQAeNWqU+1mTIbzWadq+4jualKIJjQWpUBttSirxkq9UQVet5QMrewW2dxsxYoRrpzdp0iQX39WkncCq8/GSSjGF/MSs87t+vB5TOO+P7Otlf394Hn30UevVq1e+xxDOeX0sW3/GKn6bDPR+v//++10ypSZ3KdlJyZZ6TPmN4+hY4h1PpG/fvnbNNdfke0zEIAAAiC4SsIA0phkVgRUrVH0lGvKTQJAsfdp1MqMTECUveSfQmh2iij/RFhg48WZ+xXvMI0eOdAGacJN2Ak+sC1JZKzDhL1KBbcSiTe8Bldt++umn7Y033vAnK+i5/uWXX9zl5ZdfdjPidDJ83333ufLveQl8nXMLnIXr119/jSgJI9USsKJ1XFApby8ZR0kRamOgFn8KYioRQuXvvddPLQVUlch7vRPRfjCwVVw8JctxuDC83h6NJRHHy2gdy0VBWi/5SvuQZphfcMEFbjauvgzQYwwMsHv7WbIF7nRM9p7rgnwme1asWGFnnHFGjuD79ddf774gCmc2f7w+UwAAAIBoy/73qf52ze+5R7hVswLvK3tCiM79lKCkyjFq0Td//nz/dUuXLrX33nvPXW699VZ37qgkhWhNTC2IwGQYVSUK9fe+4oB9+vSxNm3auJ+VcKbzkWhN/EjHmEJ+x5qMjy0a7w9RVbjA/U3nqmpVp8rsqm6l921g8lK7du38seRw4ijhxD2SLX6bTDp27Ggnn3yySxxV1Sk9nmeeeSbs27/22mtZWq+qEpaei4LGIDT5m+pXAAAUDAlYQBrTiYrXZ1xatWplhZVmkijwIjqJePfdd101mlidJP70008FbsUUzzEHlgVXFatIZQ8crVu3Lkd570RTC8fevXu7WWB6j0yZMsWmTZtmU6dO9b9eqirTvXt3185LyWx5BWQCZ5pFK9ERoakEv2aOeu8PBSJDtVxLVFUeL4FSgSnNXEV6v96RHi9V1dD73EiGY7mqX/Xv39//s1pi6EuLVHy+dUz2ErAK2h5RQV9VYVuwYIH7uWHDhlavXj0XMNVzoLYgCnK3bNky4vtQYteGDRuyjB8AAABIFqoYpC/olTDg/Y2d30o427ZtC6s9XWC7w9zWV6xGEyF00d/oSh5RfEdxHq8Stf6+HjhwoE2cONGmT5+e61h79uzpqhJHU24T5ZYsWeKv6CU6t8iLkmYUT1CChCa7/PDDD65lWWGRiAlViab3Rzjyen8oeclz3XXXuS4FoeKbyXZeH434reLSavUXTapcpWp00aAqXl7lPj22cA0ZMsQll3q0/OSTT0Y8DuLaAABEFwlYQBoL7P+tL6y9GVOFzV133eVmywTOELnssstidn9e1RUJrEAWzzErsJQf1apV8y8vWrTIIlWhQgU3e0pf3svKlSuTLgHLo5lRxxxzjLvce++9Lqjz7bffugCFlzTzySef2Mcff2wXXnhhnskhHn0ZHylVPIukVHRh9M033/gr7ajkeKhkHC/QGW8KYKitpCj5KpazA9NdKrze+RV43NWxMtrbLMixfObMmf4ELpX3D5V8lezPtz6Tf//99wJ9JnvvZ81O9b4w0XYnTJjg2pmoEpuCpps2bbIOHTrYuHHjrHnz5hHdj2a0e/u6ZrzXqlUr4jEDAAAA0aYEB8U9vL+L9Te2qhLnhypU6TwjFP1NHBhryauNYOPGjd3lxhtvdD8rIUuxNLUP1+TUv/76y1UDyi0x6p133on6OU1u9xP4eKRSpUp5bkfxXMXVvAo10aiknCiBFZTDrX6fyo83Unp/hGPZsmVB3x/a571qVtqHlJyT1+TScO833goSv9U5eiSdBkJRZ4poJWAFxszDTQLV41Ts2IsbXHXVVQV+jNGKawMAgP+iliSQpvRHuwIIHlVlyKuvfTp66KGHrF+/fll6yN9www0xvU9VMvF4X/om+5gDq6MpSFWQL6kDK3/kZ/ZOonlJiqNGjXIzkDzeyXyomWmBgbpmzZrFdJz4r3/++ce/rJZoeZk8ebLF22effeafrZmo9oOJEIsS/qnweufXEUcc4S/3/++//9qff/4Z1WO5ktYilU7Pd0E/k0Wza5V8NW/ePPdz3bp1XfKV2jYosVKtRr2kQFWv0mfInDlzIm5F69GXUkrCAgAAANLpb2xVq8nL3Llz/RV5lICR31iLkrGeffbZLC3Y8orvxFr2SVmqzpMXxRQCK+Rq4mOqUkUjjyoX5dW+XglBSqApbLTvB1a3CkYV3TxHHXVUjnPYXbt2ueWqVau6Syhq4VnQitHxihNFGr9NRpqA5QmnRernn3/uJmh7HU/OP/98e/vttwv8/AbGIYhrAwBQcCRgAWlIJ7CdOnXK0n7o4YcftsKmT58+9sQTT/h/fuyxx6xr164xv9/ABKT8tpRK1Jj1ZXLgjMWCzJwJbJP4yiuv5BlQSTY6aVU1k8CWU3kFRrwkG5WhTuVgWCpRwCXc8uy6Xi08401JGd4+Fav2oclI7Sg8avdQWF7vSILvgS0nXn755QJvU9XBPKrIFBhEi9XzrePf66+/bsmqIJ/J3pciqmD3yy+/uJ+VdKXkK31uBr6WSrg84YQT/F8mKBAcyf0F3qYgrQwBAACAZP0bW+2z8hJ4TteiRYssLdzzI3AyVLD4zuLFi13sKpqX3OhcIjBRQucV4SSrBZ6TNWrUyFKV2uR5SSZ6TF5r92CGDx9uhZHaewZ2tciNkquGDRvm/zl7lfDAc3qvelooit+mWpwonPitqjlF+72d364ToSiO4MmrkqAm2anCl/f8Kf7zwQcfuATVgiIOAQBAdJGABaQZJV1deumlbkaER6Vojz32WCtMVGI8MOns/vvvt0ceeSQu933kkUf6Sz+rokleCTzJMGa5++67/cuaJThlypSItnPzzTf7k5B++OGHLLMN86LZVt4snmjTzElv9ld+ynjnNUss8HkKnHmF2GrQoIF/ecyYMSH3m3vuuSfs92G0qA3n119/7Q8WV69e3QqLwDYK2VsspOvrHalu3br5l/v37+9a14Urt7aFCpQdd9xxblmBQbUODEzGjuT5VtuCUG0fVPY/ki9d4kVJbl5AUi1Bw211kVsildoB6kuSwFbDntKlS7u/vbznX5VIAxO3wsVnCgAAAJJd4N+pU6dOzfftlcDw0UcfBb1eE0kCW/jlVhU+3Go9+YnvxJpihYHVZR5//PGQyTE67w2MEyqZRJW9UpnayHkGDRoUdD1V5lfbvMKqR48e7nw0GE3e9eItSk5UVaTscRmvE4bO5712hLlR94JYJ2DlJ04Uq/htrKlqmZLnwqXnfNasWf6fL7jggqDrquWikkm97asNoloRFi9evICj/u+kOm3fS2pTHAMAABQMCVhAmtAXsc8884wdfPDBWWYItW7d2t544w0rTN566y276667/D/ffvvt1rdv37jdv2YZnXHGGflqA5XoMYv6x2t/Ec2mUdtKVWTJbWaSToRV3adjx445rtMJvtomepSApYpsKh2eGyUJ6GT/tttuswMOOCCsmVmRmD17tgtWPfroo660drDglmaQKREit4oyuQl8fQtTlaNkSKpQwoOX6Kh9LLAsv6hU/U033WSvvvpqxLNlI6X9wkt8CZyRVxgceuih/uVPPvkk7MBZKr/ekVLQTI9FlBh05plnuiBzsKQpBdtUZv/cc88N2tbyxRdf9Lc2VDBPVZmUeBTqbwclUWVPJFaykResveiii7K0JfSSDBUUfuCBB5L6+a5YsaI/KUqB3O+//z6s22l/6tChg0sklpo1a7rkq4YNGwa9TdmyZe2LL77wJ717rQuDfeZkp33AS8BSIJUELAAAACRrC0LFb+S3337L0kYrHPpbV5NFVL0lt7Zq+jvcSzRQW25NLM1O968JgEos8aqSZ6fzoc6dO4cd34n35EdVVFfsbeHChTnW03OqajeBVbI0UTMYxbqUPOFdktXll1/uX37uuedcEkluVb90rqwEpGgkmKQaPWYlFrVv397++uuvHHFLxQzUMcHTvXv3LO0dc4tNK+Y7c+bMHPel7xC0nrYby/P6wDhRXtW9YhW/jbU//vjDVahTfCUwMSy3OIy+A1Ds33P88ccHjSnPmTPHvUZeW0olMapyVvaWppHS8+1NutME0kQnsgEAkA4yEz0AAOFRxY/A2V0KLujLQX0BrZORRYsW5bjNjTfe6BJhvC9iCwNVmtDj9sp96+RRy3fccUdYt+/SpYtrI1dQV1xxhb9cur4szz4TKRnHnJmZ6U5eleigk0aVA9fJ4EMPPeS+vK5Ro4b7cnjJkiXu5Ez7nzebKjud2CuA1Lt3b/eznov33nvPjjjiCGvatKn7kloJBprR9uOPP4asrhJNCmApIUwXVSTSePS/Hrsq5uhxBSYZ6ARYFeWC0Zf5avMlOkHly/L4JlXce++9/qCT9i8lPigQocQRvdaaVasAhV5fJRN6iS7xbD8owRJl0pWCXgoEKZlS72+VUW/Xrp2rjOcFghVI1CVdXu+CeO2119z4x44d65LVHnzwQTcTWo9NXyroM1yf9Qq8KkCvxCdp3rx5rts76qijbODAge44rGO2gnWtWrWyJk2auMQqHbd1zNXfDl4LVX2OZA/W6vh93XXXuZ9VzU0zrZWkq9Z7qu6k59ubkasWhPrcS1Ya2+TJk/2fyeFUBVXQWy0yRJ8TSqoM57NWt/nyyy/d/q3EN70Xwg1k6z68z0Ml49HSFgAAAMn8N7ZXoUh/Y996661h3/Y///mPde3a1SXj9OzZ0537FCtWzJ2fBE6YUOzonXfeyTUJR+ebOg/RRX+DK76jcxX97a34qRLD5s2b51+/SpUqLqEj0a688koXL/CSUHSeonMtPQc6Z9O5mOJpqkjjnft5E7s04SjVKcamSUCqMqzzXyWZ6RxWr5+San7++Wd3Dit6vd5++20XhyxM9Jxo4pkSphRDVWxSE4EUg9T+EpjwqAlXgZW1A6l6mt6beq+ozabiAjoX1v6m517Jjt73CYpLqyVkqEpZBaHqTop9iOI1ir/qdfcm2omOId6Ep2jHb+NF1b2UKKmLksiUeKbKd4rrKI6u45L28cCq7nrfB7aTzE4JqYFxcz1HmggXDiVuBSbi5WbkyJH+5WSO6wAAkFJ8AJJW27ZtlZGTr0vRokV9Z511lm/cuHFh3ceiRYv8t61bt27Q9QLvI1rb9EyYMMG/vh5zQQRuK5KLbh8Ne/bscY9d2yxTpoxv8+bNST9mz9q1a30dO3YM675r1aoVclvDhg3z1axZM+zH0rJlS9+OHTtybOftt9/2r9OpU6eI9rsZM2b4MjMzwx7LhRde6Nu0aVPIxzdkyBD/+vfcc48vFfXs2bPA77/AY1Ww/VGvm7eOXs+8hPOa63129dVXh3wdK1So4Bs5cmRMjnWh1K5dO+xjYH6Fc8zM73FYvGOWLrp9pOvIK6+84svIyAj6umi/y+/+kcyvd0E/y/TYHnnkEV/p0qXDOj4VK1bMd/vtt4fc5vjx433169cPa3sPPfRQrtt48MEHQ96uZMmSvldffTXs5zKc/Se/x4pwbNiwwX0Wa5t6Tvbt2xfW7bZs2eI7//zzffPnz4/oPs8991zfn3/+GfZtbrjhBv9jHz16dL7vEwAAAIiXBQsW+M/5wjn/yX6+oPOfUOeMiiVNnTo16PbKli0bdnynWbNmvl9//dWXLHbu3OliSEWKFMlz7HqO7rjjDt/27dtDbrNHjx7+22i7BRWrmIIsXLjQ16BBg5CPWeeoOm+LZpwikjhAJM9DJLLHwP7++29fq1atQu4bZ555Zsh4s4waNSrPOMNNN93kYrHhxPbCWSeYyy67LOQ4vO3FIn4bD3Pnzg3rPR34Pr3xxht969atC7ndcLcXTuwtNwceeKA/vrN69eooPiMAABReVMACUpRmf6m8sCpZaAaIqlqoGob6dNeuXTvRwyv0ihYt6sqcq2KLKrKorLpmE6WC/fff30aMGOFmHb7//vuuyokqVanSiSp5aP/SzCOVSdesrFAuvvhi1ypr6NCh9tVXX7ltrl692lW/0qxEVa5RdRzNVNKMHM3CihXNJvz3339t3LhxNnXqVDejThVlVMlFM4/0ftIsIs0I04zEli1b5rnNN9980/96h1uxDNGj512zYdUeTbNeVW1G+6mqJalykPY9VfBR6zDN9osX7Vt6zxTG9oOeW265xQ477DA3w1Gvi2YBqqqeV+kvnV7vaNBjU3UvfW6oYqCOU6pQpZnbagOr45Nmc+s5PfHEE93xUjO4Q1E1w99//90df1WeXu03dAzULGr97aDS+Jr9qlayOgbnpk+fPq6i2YABA9xxU8dvzS7X54A+A66//vqoVGCMNT3ea6+91j0OzfDV8xtOxUJ9TuXWEiPc+9Rs43Dpc1Gvleg5VQUsAAAAIFl5f7PqXENVc1RJPT/nBjr/0XmNzu3UhlvVbFQFS+cp559/vqvIHqzquiiWo2pAum/FmnT/qoyj1oWqqqNzFsVJVXlHValVWSqZYrqqAqU4kio86fH/+uuv/grDqoSr51LnaTrH1XOSF1XV8Simlczq16/vxqv2cYo/qvKSzlN1Lq/HrEpIiuEVZnoutG8PGTLEVQBX5STFBypVquTaxOn89rzzzstzO4qTqLKc2j2q6vbSpUtdFSltX90OVDlbVbTiQY9DbfYUI1e1dD0er9VorOO38aB2qWovqAriqmCnfVzV7DRuxXUUS9Hrp7iOnnt1y1BcPJG8Y7dX/UrVugAAQMFlKAsrCtsBAGSj0tAKKuhEq1mzZu7kEulDyREqJa2PUZXNVyABEJVI91obKMBFa0og8ZSUpyRfBT4VhM5PclQ8vPLKK3bbbbe5ZX0JlSpJ2wAAACi8lGSgRAJRW/N+/folekiFktrKK3FCCVxKYtNEHMUjkToGDRrkkqqkU6dO7mcg1i655BIbPny4mxSoRD21vAQAAAWXPFM/ACDNaGaLer7LTz/9ZF9++WWih4Qo+s9//uOSrzRzTAk3gGf06NHuf83Ka9u2baKHA8DM6tWrZzfccINb/vTTT90M82ShWbyaAS+ayesF3gEAAIBk1rp1a1cx16sQrgmIiD9VCPKqZ+mch+QrAHlRVTGv4rcqiZF8BQBA9JCABQAxpHZS+tLXK6+O9DlJVXtGr9VaOOXgUTiobcIPP/zgljt06OBaCwBIDj179nSJkUqeTabPZFVQVGsC6du3r0vsBQAAAFJlcpr+ft26dat/UgHi65tvvnH/lypVyh555JFEDwdACujTp4+bDKaWrckUHwEAIB2QgAUAMaTgx/PPP++Wp0+fbiNGjEj0kBAFDz/8sGtjVaVKFevdu3eih4MkUrNmTVf+XwkeKuMNIHlUq1bNX7Fw2LBhNnv27EQPyXbu3Gk9evRwy6eccopdcMEFiR4SAAAAELZDDz3Ubr/9drf8wgsv2N9//53oIRXaBKw77rjDatSokejhAEhy8+fPt3fffdctP/jgg3bAAQckekgAAKSVDJ++IQQAAAAAAAAAAAAQN4MGDfK3ou/UqZP7GQAAAKmJ/hYAAAAAAAAAAABAHsaMGeMuBVGpUiV/hWYAAACkDxKwAAAAAAAAAAAAgDzMnDnTXnrppQJto27duiRgAQAApCESsAAAAAAAAAAAAIA4u+aaa9wFAAAAqS/D5/P5Ej0IAAAAAAAAAAAAAAAAAEhFRRI9AAAAAAAAAAAAAAAAAABIVSRgAQAAAAAAAAAAAAAAAECESMACAAAAAAAyQBlmAAEAAElEQVQAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAAAAAAAAAAAEQoM9IbInZ27Nhhv/zyi1uuUqWKZWbyMgEAAABAYbFnzx5bvXq1Wz7ssMOsZMmSiR4SgEKG2BQAAAAAFF7EpoDIED1JQgpwtWzZMtHDAAAAAAAk2MyZM61FixaJHgaAQobYFAAAAABAiE0B4aMFIQAAAAAAAAAAAAAAAABEiApYSUil3QMzSmvUqJHQ8QAAAADIw/ZNiR4B0siKlSut5Qkn5zg/BIDCFJvau3evrV271i1XqlTJihYtGvcxANmxXyLZsE8iGbFfItmwTyIZJft+uWLFCn9VZGJTQPhIwEpCmZn/e1kU4Kpdu3ZCxwMAAAAgD9s2JnoEKATnhwBQmGJT+kKiRIkS/oB/sn0hgcKJ/RLJhn0SyYj9EsmGfRLJKJX2S2JTQPhoQQgAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiBAJWAAAAAAAAAAAAAAAAAAQIRKwAAAAAAAAAAAAAAAAACBCJGABAAAAAAAAAAAAAAAAQIRIwAIAAAAAAAAAAAAAAACACJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACJEAhYAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACIEAlYAAAAAAAAAAAAAAAAABAhErAAAAAAAAAAAAAAAAAAIEIkYAEAAAAAAAAAAAAAAABAhEjAAgAAAAAAAAAAAAAAAIAIkYAFAAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIkQCFgAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIgQCVgAAAAAAAAAAAAAAAAAECESsAAAAAAAAAAAAAAAAAAgQiRgAQAAAAAAAAAAAAAAAECESMACAAAAAAAAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAACr1///3XPvvsM+vRo4edfvrpVrlyZcvIyHCXa665Jt/b++KLL6xjx45Wu3ZtK1GihPtfP+v34dqzZ4+9+uqrdvzxx1uVKlWsVKlS1rBhQ7v55ptt3rx5+R4TAAAAAAAAYiMzRtsFAAAAAAAAUka1atWisp19+/bZTTfdZAMHDszy+7///ttdRo0aZTfccIO99tprVqRI8LmRa9assTPOOMO+//77LL9fuHChvf766/bOO+/YgAED3LYAAAAAAACQWFTAAgAAAAAAAAIccMAB1r59+4hu+9BDD/mTr4488kj74IMPbObMme5//SxvvvmmPfzww0G3sXfvXlcty0u+Ov/8813lrO+++85efPFFq1q1qu3cudNVwspPRS0AAAAAAADEBhWwAAAAAAAAUOip9WCLFi3cRdWwFi9ebPXr18/XNhYsWGDPPPOMWz766KNt8uTJrm2gaLvnnHOOtW3b1mbNmmVPP/20XXfdddaoUaMc21F1q6lTp7rl2267zV566SX/dS1btnQtEps3b26bNm2yO++803799VfLzCTMBwAAAAAAkChUwAIAAAAAAECh16tXLzvrrLMK1IqwX79+tmfPHrfcv39/f/KVp3Tp0u73ovWef/75XLfjJXHtv//+LlErOyVtde/e3S3/+eefNnLkyIjHDAAAAAAAgIIjAQsAAAAAAAAoIJ/PZ5988olbbtq0qbVq1SrX9fT7Jk2auGWtr9tlr6KlilZy8cUXu6St3FxzzTX+ZRKwAAAAAAAAEosELAAAAAAAAKCAFi1aZP/8849bVpvBULzr//77b9fqMJDXejCv7VSvXt0aN27slqdNm1agsQMAAAAAAKBgSMACAAAAAAAACmj+/Pn+ZVXACiXweq/aVUG2s2zZMtu6dWu+xwwAAAAAAIDoyIzSdgAAAAAAAIBCa/ny5f7l2rVrh1y3Tp06/mUlTxV0O2pjqNt5rQ3zM9bcrFixwr+8d+9ed4k33ee+ffv8y0AyYL9EsmGfRDJiv0SyYZ9EMkr2/TIZxwSkAhKwAAAAAAAAgALavHmzf7ls2bIh1y1Tpox/ecuWLTHZTrgJYHlZu3atlShRwuJNX0Zs3LjR/3ORIhTyR+KxXyLZsE8iGbFfItmwTyIZJft+qfNAAPmXXO9kAAAAAAAAIAXt2LHDv1y8ePGQ6wYmNG3fvj0m2wEAAAAAAED8UAELAAAAAAAAKKCSJUv6l3ft2hVy3Z07d/qXS5UqFXI7gT/nZzuhZG97mFsLwpYtW7rlSpUqWZUqVSyRLS8qV65sRYsWjfsYgOzYL5Fs2CeRjNgvkWzYJ5GMkn2/DDzXBBA+ErAAAAAAAACAAipXrlzY7QC3bt0atM1g9u2ESsAKtZ1QateuHfa6+iIgUV8GeG04EjkGIDv2SyQb9kkkI/ZLJBv2SSSjZN4vk208QKqgBSEAAAAAAABQQIFJTcuXLw+7AlWdOnUKvJ2MjIx8JVUBAAAAAAAgukjAAgAAAAAAAAro4IMP9i//9ttvIdcNvP6ggw4q8HaUxFWmTJl8jxkAAAAAAADRQQIWAAAAAAAAUED169e3mjVruuVJkyaFXHfy5Mnu/1q1alm9evWyXNemTRv/cqjtrFy50hYsWOCWjzvuuAKNHQAAAAAAAAVDAhYAAAAAAABQQGoDeO655/orU82YMSPX9fR7r3KV1tftAjVu3NhfFWv48OG2bdu2XLczaNAg/3LHjh2j9jgAAAAAAACQfyRgAQAAAAAAAFHQtWtXK1q0qFvu3Lmzbd++Pcv1+lm/l8zMTLd+bu699173/7p16+z+++/Pcf1ff/1lTz75pFtu1KgRCVgAAAAAAAAJlpnoAQAAAAAAAACJNnXqVPvzzz/9P69Zs8a/rN8HVpySa665Jsc2VL3qvvvus6eeespmzZrlWgN269bNGjZs6JKm+vbta3PmzHHrar0DDzww17F06tTJ3nrrLZs2bZq99NJLrt3gjTfeaBUrVrSZM2da7969bdOmTVakSBF78cUXXTIXAAAAAAAAEofoDAAAAAAAAAq9N9980955551cr1MilC55JWBJnz597N9//3UJVEq2uvTSS3Osc/3119vjjz8edCyqojVq1Cg744wz7Pvvv7ePP/7YXQKVKFHCBgwYYKeffnqYjxAAAAAAAACxktYtCJcuXWo9e/a0o48+2qpUqWIlS5a0OnXq2PHHH289evSwuXPnhr2tbdu2WYMGDSwjI8Nd6tWrF9OxAwAAAAAAIPWoKtXAgQPt888/t3PPPddq1qxpxYsXd//r5zFjxrhkL60XSuXKle3bb7+1l19+2dq0aWOVKlVysS3Fp1QNa/bs2XbDDTfE7XEBAAAAAACgEFbA6t+/v3Xv3t22bt2a5ffLly93F5WVV6n2fv36hbU9JWwtWrQoRqMFAAAAAABAIqnFYPY2gwWh6lW6FIRaC956663uAgAAAAAAgOSVlhWwVML9zjvvdMlXjRs3tqefftomTpzoyr6PGzfO/dy6des8Zxp6dDslammWYbly5WI+fgAAAABIhCEfDLObO3e1o9u0sxIVq1pGmQo2aPB7+d7Ovn37rP8rr9lhLVpbqUrVrUrdhnZZp+tt4aLFQW/z1dfjrW2HM6xctdpWvnodO/H0s2z8hEkFfEQAAAAAAAAAAMRe2lXAGj9+vD3yyCNu+eqrr3Yl3YsVK5ZlnZNPPtnuvfde27VrV57b27t3ryvrrv/VzlAl5Ddv3hyz8QMAAABAojz82OO2ZOkyq1y5ktWoXs0tR0JJXG8OetcOOeggu/PWm+2fFSts+IhRNvabb2zGhHF2YKOGORK/rrrhZqtSubJdc+Vl7nfDPhppp559ng0fPMgu7HhuVB4fAAAAAAAAAACxkFYVsDTL2ivJ3qxZM5cslT35KlDx4sXz3OYLL7xgs2fPtiZNmli3bt2iOl4AAAAASCZvvtTfFv/6s61e8pfdcv11EW1jwqTJLvnqhDat7YdvJ1nfx3vZ4IGv26ih79m6devtjrvvy7L++vUbrPO997ukL63f/9mn3UXLlSrtb7d2vZtJMAAAAAAAAACApJZWCVhjx461P/74wy0rWSozs2AFvpYsWWI9evRwy6+++mpYCVsAAAAAkKpOOamd1T3ggAJt442333X/937koSznUKd3ONXandDGxo7/xpYu+19lrQ9HjrINGzZa51tustq1avl/r+U7br7R1qxZayM//cz/+1vuvMu1Rnzqmedz3Ld3Xd9n+xXoMQAAAAAAAAAAUGgTsD788EP3f0ZGhp111ln+369bt84lZun//Ljtttts69atdtVVV1m7du2iPl4AAAAASDcTp0y1MmXK2HHHtspxXYeTT3b/T5oy7X/rT57q/m9/8kk51z/l/9ef+r/1n+/7hB3UtIn1ePwJ+372D/7fj/x0tL028G07qe0Jdt9dd0b5UQEAAAAAAAAAUEgSsGbMmOH+r1evnpUrV87ef/99O+yww6xSpUrWuHFj979aCT7zzDO2c+fOkNsaOnSojRkzxipWrGjPPvtsnB4BAAAAAKQuTWBZsXKl1a9b14oWLZrj+gMbNXD///HXX/7fecsHNmyYc/3//13g+qVKlbIP3n7TihQpYpddc71t2bLFlv/9t91w+52uZeHgga+56wAAAAAAAAAAiJeC9ehLIvv27bPffvvNLVeuXNm6dOliL774Yo71FixYYPfdd5+NHDnSPv/8c6tQoUKOddavX29du3Z1y0899ZRVqVIlqmNdvnx5yOtXrFgR1fsDAAAAgHjYuGmT+3+//crnen35cv/9/caNm8K6Tfny5XKsL80OP8z69n7Uut7f3W7tcrct/+cfW7duvX0y/H2rWaNGFB8RAAAAAAAAAACFKAFr48aNLglLfvnlF/v++++tRo0a9vTTT9sZZ5xhJUuWdL/r1q2bq5T17bff2nXXXWcjRozIsS0laK1atcqOPfZYu/HGG6M+1jp16kR9mwAAAABQmNx52y321bhvbMjQ4e7nW2+83s4584xEDwsAAAAAAAAAUAgVSadWF54dO3ZY6dKlbcKECXbFFVe4NoJqU3HCCSfYN998Y82aNXPrqQrWd999l2U7kydPtrfeessyMzPt1VdftYyMjLg/FgAAAABIRfuVz1nhKtCmzTmrXYW6zaZNm3Os79G52nlnn+n/ufMtNxV4/AAAAAAAAAAAFOoELFW4CnTDDTdYkyZNcqynRKw+ffr4fx42bJh/eefOnXbTTTeZz+dzLQwPP/zwmIx12bJlIS8zZ86Myf0CAAAAQCyVKVPGalSvbouWLLG9e/fmuP6PPxe6/w9s2ND/O2/5j7/+yrn+//8ucH3PosWL7b6Hetj++1d0yVg33H5nrvcJAAAAAAAAAECspU0CVrly5bL83L59+6Drnnzyya7ClagtoUeJWb///rtrEdirV6+YjbV27dohL2qdCAAAAACpqG2b41yF4mnTZ+S47qvx493/J7Rp/b/1jz/O/T92/Dc51x833r/NQHv27LErrrvJNm/ebMPeedvu7ny7fTvjO+v1xFNRfzwAAAAAAAAAAOTlv1lIaaBEiRJWpUoVW716tftZSVShqmVVrlzZVq5c6V9f+vbt6/4/5ZRTbPTo0SFbHer/oUOHuuWqVavaSSedFNXHAwAAAADJbM2atbZm7VqrXKmSVa5cyf/7m67rZEM/+tge6d3Hvh49yooXL+5+/8VXX9vEyVOt/cknWd0DDvCvf/H5Ha3bIz2t/6uv23VXX2m1a9Vyv1/+99824LU33LY7nnNWlvtWotX072bavV062ykntXMJXRMmT7Ennn7OTj3pRDv+uP8leAEAAAAAAAAAEGtpk4AlhxxyiE2cONEt59V6wrveq4Qlu3btcv+//fbb7hLKmjVr7LLLLnPLbdu2JQELAAAAQMp7c9C7NvXb6W75l3nz//u7dwbbxClT3XKb1sfaDddc7ZYHvPa69Xqir/V8sJs9+lB3/zZObHuCW0fbOqp1WzvztPa2YuVKG/bxSNcusP+z/8lynxUrVrABzz5tV91ws1v/kgs7ut8P+2ikrV27zoa9+3aWiseTp05ziVZHHdHM+jz6iPudkrzef/tNa96mnV15/U3204ypVqFChZg/XwAAAAAAAAAApFULQjnhhBP8ywsXLgy63qZNm1wCldT6/9nVAAAAAFDYKfnqnfc+cJcffvzJ/U6tBL3feclZeXmtfz974en/tgN84eVXbczYr10Vq5mTvrHGBzbKsf6Vl11iX4z8yJo2OdDeHvy+DRrygR18UBMb++lIu+j88/zrrV+/wa68/mYrVaqUfTBooL+6ljRpfKD1+8+TtnTZcrvxji5ReDYAAAAAAAAAAAhPhs/n81ma+Pnnn61Zs2Zu+YorrrAhQ4bkut4777xj11xzjVvu3bu3Pfzww2HfR7169WzJkiVWt25dW7x4scXC8uXL/S0Uly1bZrVr147J/QAAAACIkm0bEz0CpBG1X6zT+BC3zDkhgERIhtiUqtevXr3aLVepUsWKFi0a9zEA2bFfItmwTyIZsV8i2bBPIhkl+36ZDOeEQCpKqwpYhx9+uJ1++ulu+YMPPrDx48fnWGflypX+hCvNlr722mvjPk4AAAAAAAAAAAAAAAAA6SGtErCkX79+VqFCBdu3b5+dddZZ1r17d5syZYrNmjXLXn75ZWvRooXL2PSqX9GCEAAAAAAAAAAAAAAAAECkMi3NNG7c2EaPHm0XXnihrVq1yp566il3CZSRkWEPPfSQ3X///QkbJwAAAAAAAAAAAAAAAIDUl3YJWNKmTRubN2+e9e/f30aNGmWLFi2yXbt2WY0aNaxdu3bWuXNnO/LIIxM9TAAAAAAAAAAAAAAAAAApLi0TsKRSpUr26KOPuks0LV68OKrbAwAAAAAAAAAAAAAAAJC6iiR6AAAAAAAAAAAAAAAAAACQqkjAAgAAAAAAAAAAAAAAAIAIkYAFAAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIkQCFgAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIgQCVgAAAAAAAAAAAAAAAAAECESsAAAAAAAAAAAAAAAAAAgQiRgAQAAAAAAAAAAAAAAAECESMACAAAAAAAAAAAAAAAAgAiRgAUAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiRAIWAAAAAAAAAAAAAAAAAESIBCwAAAAAAAAAAAAAAAAAiBAJWAAAAAAAAAAAAAAAAAAQIRKwAAAAAAAAAAAAAAAAACBCJGABAAAAAAAAAAAAAAAAQIRIwAIAAAAAAAAAAAAAAACACJGABQAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACJEAhYAAAAAAAAAAAAAAAAARIgELAAAAAAAAAAAAAAAAACIEAlYAAAAAAAAAAAAAAAAABAhErAAAAAAAAAAAAAAAAAAIEIkYAEAAAAAAAAAAAAAAABAhEjAAgAAAAAAAAAAAAAAAIAIkYAFAAAAAAAAAAAAAAAAABEiAQsAAAAAAAAAAAAAAAAAIpQZ6Q0BAAAAAEDy2rNnj61cudKSQfXq1S0zkxAEAAAAAAAAgPRE9BMAAAAAgDSk5Ks6depYMli2bJnVrl070cMAAAAAAAAAgJigBSEAAAAAAAAAAAAAAAAARIgKWAAAAAAApLmOVtpKW0Zc73Ob+WykbYvrfQIAAAAAACTS5h27beXGHbZ1114rU7yoVd+vpJUrWSzbOnts0drttm33PqvlK2W1KpbOsQ6A1EMCFgAAAAAAaU7JV2XjXgR7X5zvDwAAAACAdE3YCb1OQa+Px32k8xjKlsi06QvX2uDpS2zs/FW2d5/Pv37RIhnW4ZBqdsUxB1iGZdjgGcHXubJVXTu2QSXLyIjvJDoA0UECFgAAAAAAaU6pV/FOv4r3/QEAAAAAUkt8kmVCVxpKVFJQNBJ22h9c1Y6qW9FmL9lgX0dwfTzuozCMoUiGWenimbZl5x7LjdYd88tKdwkmcJ3G1cracxcfYYfW2i/o+gCSU4bP5/vf0QFJYfny5VanTh23vGzZMqtdu3aihwQAAAAglG0bEz0CpJHlf/9tdRofUuBzwsBzy6usTNwrYG2xfTbYtrplzm2B1JIMsam9e/fa6tWr3XKVKlWsaNGicR8DkB37JZIN+ySSEftl8kjVSkHJkLAT6/vIK2EHKF28qL12VXM7/sAqhfacEEhFVMACAAAAACDNFbEMKxLn8vVFfJTLBwAAABB/qdrCLBr3UdDkpmSoFPTF3FXuUpBKQnltI9H3oaeE5CuEsm3XXrt58GwbfvOxVMICUggJWAAAAAAAAAAAAABCCi8pqGDt3iK9Xg1/Ypl4lOiKSeHcRzSSm2KdmETiEZC/JKx7hv9kX3Y93jLiPKkOQGRIwAIAAAAAIM2p+WB8GxDG//4AAACAwixR7eLikXiU1/WtGuxvS9Zus+Xrt8cs8SjRFZPCuQ+Sm4D08/uqzTZj4To7tmGlRA8FQBhIwAIAAAAAAAAAAABSTF5Vn+LRLi4eiUd5XT/tz7VB7x8AUt2QGUtIwAJSBAlYAAAAAAAAAAAASFuxansX7vWxuI91W3fZI5/MtQWrtuT6mGkXBwDp4ct5K91nQPbPFQDJhwQsAAAAAADSXEbGf2evx/U+9c//Js8DAAAASVUdKtZt8WLdmg8AUDjo2L9q0w4SsIAUQAIWAAAAAAAAAAAA0sbcvzfa3cN/DFkdKtZt8WLdmg8AUHhs2bk30UMAEAYSsAAAAAAASHNF/v8S7/sEAABA4ZaI1nwL12y1u4b9aNt28WU1ACA9lC1RNNFDABAGErAAAAAAAAAAAACQQyTJUWVLZIZs/UdrPgAAwpdZJMOqlS+Z6GEACAMJWAAAAAAAAAAAAHB8Pl/IBKpQyU9FMsxKF8+0LTv35LptWvMBAJA/HQ6pnqN6JIDkRAIWAAAAAABprkhGhrvE9T4tw4xCBAAAACll7t8b7e7hP9qCVVsiSn5SLlaw5CsAAJB/V7aqm+ghAAgTCVgAAAAAAAAAAACF3JQ/VtvNg2fbtl17Ez0UAABgZk2qlbNWDfZP9DAAhIkELAAAABQu2zYmegRIQ0NqNEr0EJBG1u2L/hdeRf7/Ek/xvj8AAABktXnHblu5cYdt3bXXyhQvatX3K5mjhZG3zs9/b7SHRv5iO3bvS9h4AQDA/5QuXtSevbiZZcS5ojmAyJGABQAAAAAAAAAAkAZ8Pp9NX7jWBk9fYmPnr3ItAz1Fi2RYh0Oq2RXHHGAZlmGDZ+RcBwAAJEfy1WtXNbdDa+2X6KEAyAcSsAAAAAAAAAAAAJK0OlWwdTbv2GOL1m63bbv3WS1fKdu4fY898slcW7BqS673qUSrMb+sdBcAAJC8bQdV+YrkKyD1kIAFAAAAAECaU7X6InGuWE+BfAAAkMryTn7K//VlS2QWqDqV1ml/cFU7qm5Fm71kg31N9SoAAJKKPuu37dpjgR/Pme4zvvp/P+MzzH3GfzUv62e4t86Vrepaqwb703YQSFEkYAEAAAAAAAAAgEIvr/Z9oZKf8rpeyfCli2falp17Iq5OpXW+mLvKXQAA6aEgCTvtD65mzetWtFlL1uf43Arn+njcR2EZQ2DylD7rV23aYVt27rWyJYpatfJZk7SPbVjZNmzdab8u+ce27dpntatVtpoVS+eohAkg9WT4dEaBpLJ8+XKrU6eOW162bJnVrl070UMCAABIH9s2JnoESENDajRK9BCQRtbt22tdtqwv8Dlh4Lnl7UXLWfmMIhZPm3z77KW9m90y57ZAakmG2NTevXtt9erVbrlKlSpWtGjRuI8ByI79Mr3N/Xuj3T38x6Dt+wAA8Uk8SoaEnXjdR7gJO15lxVDrFPT6eNxHYRlDOvxdmQznhEAqogIWAAAAAAAAAAAotKb8sdpuHjzbtu3am+ihAEBCk5uSqVLQ9cfnneiiSkKh1tE2QlUaitZ9FOR60XJeCTx5rVPQ6+NxH4VlDAAKLxKwAAAAAAAAAABA2tAX3Ss37rCtu/ZameJFrfp+OStXeNf/s36b3fPhz7Z9N8lXQKqrU7GUHVCptM1YuC4lW5hF4z6ildwUj8Sk+CXLZFr9/Uu55SpVyuaoNJQMSUEAgPRAAhYAAAAAAGkuIyPDXeJ6nxbf+wMAAIWbz+ez6QvX2uDpS3IkLhR1iQ1V7ai6FW32kg32dbbrAUReUSkeiUf5qaik855YVitKlopJed2HUCkIAID4IgELAAAAAAAAAACkrLl/b7S7h/9oC1ZtyfV6JWt8MXeVuwCFRbzbxXlJQQVp9xaNxKR0aWEWjfsAAADxRQIWAAAAAABprsj/X+J9nwAAALEQ2ELwtxWbrNfo+bQQRKHWpFo5633eIbZ/meIJbRcXjXZvVFQCAACpigQsAAAAAAAAAAAQ9+SpMsWLWvX9clavyW0dtT8L1mIQyK94tcWLdWu+7K338kJyEwAAQOyQgAUAAAAAAAAAAKIiv8lTRV0SSbX/JqpYhktUyb5OkQyz0sUzXfszIL9KFy9q/S45whpUKROTtnfhVI4qaPWpcFvvAQAAIHFIwAIAAAAAIM3pS0td4nqf8b07AACQQP/H3n2AR1GubRy/dze9UQKEjnQUERRRUEQEBbFgPSiKigWxoXwcRT027A2OHDsogmDFgogNBJUmiCAqRaX3Flp63c13vS8kJCSEhCS7m83/d675djLzzsy7sOd8ZPae58nJyTliwOpo4Skz9ptlO+xyJOZ0hK9wrK35RvVrrxMbVCt2nDfa4tF6DwAAILARwAIAAAAAAAAAAMdk+dYEDZv8u1btTC5yP+GpqstUPkvNzLafAX9vzQcAAACUFQEsAAAAAAACnMMHFan4mgsAgMA3d3W8Bk9aotRMt6+nAi8pbfjJhO9ozQcAAICqgAAWAAAAAAAAAACwQZYdCelKyXQrMsSlutUKB1lyx/y5NUEPTVmm9CyPz+YL7wgLdurpS9upfaNqpQ4/0ZoPAAAAVQUBLAAAAAAAAAAAqmjAyrSJW7BujyYt2FiompHLVjOKO9AuTg7bLu7wMQhsESEujbmuo85qWbvI/YSfAAAAgAMIYAEAAAAAEOCcDoddvHpNmhACAOD3ASunwwRsgmybuKKYsd8s22EXVD2t46I1ql97ndigmq+nAgAAAPg9AlgAAAAAAAAAAFTBgJUZeqR9CDxBtqJZ3QMVzRyyFc2mryj4mckdM6BzE3VuVlMOL4f4AQAAgMqKABYAAAAAAAHOeXDx9jUBAEDZ5eTkELDCMVWvevLStqoZGaLkDLeiQl2Kiwkr0C6wS/NaNtS3MzH9iGMAAAAAlAwBLAAAAAAAUOns2rVLixYtssuvv/5qlz179th9N9xwgyZMmFAhX4B//vnn+uijj7R48WLt2LFD4eHhiouLU8eOHdWzZ09df/31crlc5X5tAEDVtHxrgoZN/l2rdiYXuZ+AVeVkqpalZmbbv7/SVqfqdUKcOjapocUb9xUK5B1L9SoTtiJwBQAAAJQdASwAAAAAAAKcqY5hFq9es4LPb0JP3rRp0yZde+21mjdvXoHt6enp2rdvn/7++2+9//77uuyyy1S9enWvzg0AEJjmro7X4ElLlJrp9vVUUMLwU2nCUSY4V1zlqaNVp7r5LGl/Sob+2rhNqZkeNYyrpfo1IghTAQAAAD5CAAsAAAAAAFRqjRs3Vps2bTRjxowKOf/mzZvVvXt3rV+/3la3GjBggC6++GI1adJEHo/Hbp85c6amTJlSIdcHAFTNyleEr3wrPNip//broHrVw4sMPx0tHHW01n4lqTx1tDHRYUFqWjPcrteuHUUVTgAAAMCHCGABAAAAAIBK59FHH1WnTp3sYqphbdiwQU2bNq2QtoMmcGVCVjVq1NA333yjzp07Fxhz2mmn6aqrrtIbb7zBF58AgHL5/z2m7SDhK9+JCHFpzHUddVbL2mUIR9HaDwAAAKhKCGABAAAAABDgnF5oCVjUNSvS448/Lm8wbQXnzJlj18eOHVsofJVfUBC3WQAAZbdg3R6t2pns62lUWa3jojWqX3ud2KCar6cCAAAAoBLhziAAAAAAAMARvPrqq/a1devWuvLKK309HQCAHzMt53YkpCsl063IEJfqVivYcq6k+1/9YY2P3kHgCnI61OuEOHVsUkOLN+7TjJU75fbkFNjfu21dDejcRJ2b1ZTD4fDpfAEAAABUPgSwAAAAAAAIcA455JTD69es7DZt2qRffvnFrl988cV527OysrR161bbbrBu3boKDqa9EABU5XaBpmLVpAUbC4V6XDb0U0enNKmhJRv36/tS7sexCw926rG+bdWmboyiQl2KizkUdrv5rANht52J6UrOcBfaDwAAAADHggAWAAAAAABAEXLDV0a7du20Y8cOPfjgg5o8ebJSU1Pt9oiICPXq1UuPPfaYOnTo4MPZAgAqWlJ6ttbvSVNqlkcNcsKVkJatR6YuP2K7QBOm+nb5Trscy35UXAtBE7YicAUAAACgPBHAAgAAAAAAFWr79u1HHdOwYUP5m5UrV+at7927VyeddJLi4+MLjDFBrC+++EJff/213nnnHQ0YMMAHMwUA+KLCFXwjKjRIqZnZyv9XQQtBAAAAAL5GAAsAAAAAgADndBxYvHrNfOunnXZaib7g9jcmdJXLVL5KT0+3Aav7779frVq1smGsSZMm2epXmZmZuummm3T88cerY8eOPp03AKB8LN+aoGGTfz9ihSuUb3jq2tMby+SmJi3cqOkrCobdDg9YJWdk00IQAAAAgF8hgAUAAAAAAFCElJSUvHUTvjIBq3HjxuVta9CggR544AE1adJE11xzjbKysvTwww/r22+/9dGMAQDlZe7qeA2etESpmW5fT6XSK214qkvzWkpKzyp2DC0EAQAAAPgbAlgAAAAAAAQ452EVqbx1zVyLFi1SvXr1VNmEhYXlrQcFBemZZ54pclz//v313//+V4sXL9aMGTO0f/9+Va9e3YszBQCUlQn87EhIV0qmW9v2perfn/yptCzCV8cqLNippy9tp/aNqh1TeIqAFQAAAIDKhgAWAAAAAACoUCZ81bBhQ1U20dHReesdOnRQXFzcEcf27t3bBrA8Ho+WLFminj17emmWAIBjZdrfLli3R5MWbNSMlQVb3uHYRYS4NOa6jjqrZW1fTwUAAAAAvIYAFgAAAAAAQBEaNWpU5PrRxsbHx1fovAAAZbd8a4KGTf5dq3Ym+3oqAaV1XLRG9WuvExtU8/VUAAAAAMCrCGABAAAAAFAVWhA6vHzNACgi0rZt27x1t7v4NlT595t2hQAA/20x+Pf2RD0+bSUtBg8TFRqk1Mxs5S8EFuR0qHfburr29MZyOKRJCzdq+oqC1cJyxwzo3ESdm9WUwwwEAAAAgCqGO4IAAAAAAABFOPXUUxUeHq60tDStW7eu2LFr167NW2/QoIEXZgcAOBpaDJY8YJUbnkrOyNbOxHQlZ7gVFepSXEyYosOC88Z3aV7LhtmKGwMAAAAAVREBLAAAAAAAApypQ+G0/9e716zsIiMjdf7552vKlClasWKFVq9erZYtWxYa5/F4NHXqVLseERGhU045xQezBYCqLX+Fq8gQl/amZOqRqcurVIvB8ghYmfWjhalKMgYAAAAAqhoCWAAAAAAAoEqaMGGCbrzxRrv+2GOPacSIEYXGPPDAAzaAZaqo3Hnnnfr6668VHFzwS+dnnnkmrwKWOV9oaKiX3gEAVG1UuKqYgBUAAAAAoPQIYAEAAAAAgEpn3rx5WrNmTd7Pu3fvzls32024Kr+BAwce03VOO+003XHHHXr99df1/fffq2vXrvq///s/tWrVSvHx8XrvvffsYjRq1KjIEBcAoPwt35qgYZN/r1IVrvI7s3msHr+kLQErAAAAAPATBLAAAAAAAAhwTseBxdvXrEhvv/223n333SL3zZ8/3y7lEcAyXn75ZSUnJ2vixIlatGiR+vfvX2hMixYt9NVXX6lWrVrHfB0AQMnaC67bnaL/+/h3pWa6VVXd1aOlWtSJ9vU0AAAAAAAHEcACAAAAAAAohsvlsmEvE7wywa+FCxfa6ldRUVFq27atrrjiCg0ePFhhYWG+nioABAzaCx5Z67ho224QAAAAAOA/CGABAAAAABDgnAcXb1+zIpkWg4e3GSwtUxWrNJWxzj//fLsAACq2wtXelEw9MnV5lW0vWJyIEJdG9Wsvh8PLpS0BAAAAAMUigAUAAAAAAAAA8CoqXB1b+GrMdR11YoNqvp4KAAAAAOAwBLAAAAAAAAAAABWGClfl03bQVL4ifAUAAAAA/okAFgAAAAAAAc7pOLB4+5oAgKqLCldSkNOhXifEqWOTGlq8cV+hP4eS7O/dtq4GdG6izs1q0nYQAAAAAPwYASwAAAAAAAAAQLlZvjVBwyb/XqUqXJkKVU9e2lY1I0OUnOFWVKhLcTFhig4LtvtvPutAJbCdienHtB8AAAAA4N8IYAEAAAAAEOCcctjF29cEAARe+8C61QqHgvKP+Xt7oh6ftlJpWW4FutJWqDJ/bsUFqo62HwAAAADgvwhgAQAAAAAAAABK1D7QZUNHcbr29MZyyKFJC6tOi8HwYKce6XWc4qJD1DCulurXiCAwBQAAAACwCGABAAAAAAAAAErUPtAErb5ZtsMuVUlEiEtvXHuyWlc7EDSrXTtKLpfL19MCAAAAAPiJgApgJSYm6ptvvtGvv/6qxYsXa+vWrYqPj1daWpqqV6+uE044QRdccIFuvvlmxcbGFnmOrKwszZo1S9OnT9cvv/yiVatWKSEhQZGRkWrWrJl69uyp22+/3a4DAAAAAFAZmI5ITi93BDxKFyYAgB+auzpegyctUWpm4LcPLI3WcdEa1a+9jq8bZe83AwAAAAAQ0AGsRYsWqX///kXuM78Yz5492y4vvvii3nvvPfXu3bvQmOOPP1579uwpdLwJYS1dutQuL7/8sl544QXdc889FfZeAAAAAAAAAMCbla8IXx0SZFst1tWAzk3UuVlNORwOud382QAAAAAAqkAAy2jUqJHOOeccdezY0a7Xq1dPHo9HW7Zs0aeffqrPP/9cu3fvVt++fW1gq3379nnHZmRk5IWvOnTooEsuuUSnn3664uLibADr22+/1SuvvKL09HQNHTpU4eHhuvXWW334bgEAAFBVvffhx5r78wItWfq7lq1YqczMTI1/8zUNvO7aUp3H/Fv5tTFvaew772rNunWKiorUud276+kRj6hZ0+OKPGb697P0zMhR+u33P+0XUR1Pbq+Hh9+nnuecXU7vDr4yPzNd/7iztcGdrc2ebGVLGhQWpW4hYSU+x1/ZmXomNfGI+w8/39HGG3UcTo2KrlniOaAwU4zK2wWpKIAFAJVHTk6ObTtYlcNX4cFOPda3rdrUjVFUqEtxMWGKDgv29bQAAAAAAJVEQAWwTPBq06ZNR9zfr18/ffHFF7rsssvsF1SPP/64DWTlMl8enXfeeXriiSfUuXPnIs9/xRVX2FfT1nD48OG24lZ0dHSFvScAAACgKA8/8ZQ2btqsWrViVa9unF0/FoOHDNXbEyaq7fHH6+7bB2vb9u2a/PkXmvHDD1r440y1bNG8UPDrulsGq3atWho44ED12Y8/naLzLr5UkydN0JWXXVIu7w++8WlGqnbneBTtcKi6w2nXj1UbV5COdxX+0rKJq+CvobWcLl0WEl7kOVa4s7TKna12QSHHPA8AAHB0C9bt0aqdyarqLQZPbFDN11MBAAAAAFRSARXAcrlcRx1z6aWXqnXr1vrnn380d+7cAvsaNGigGTNmFHu8qYh1xx13aNSoUbYq1vfff6/LL7+8zHMHAAAASuPt115RyxbN1KRxYz038iU9+NjjpT7Hj7Pn2PBVt65n6PtpXygk5EDI5Zp+/9IFl/9Ldw27T9O/PPTAwr59+zXk3uE29PXbz7PVsEEDu/3+YUN18hnddPvQYep9bg8eUKjEbg6PUl2ny4aipmWkanJG6jGfy4SvLg+LPOq42k7XEcf9mrzPvnYvRQUuAABQeu8t3KiqpqgWgwAAAAAAHCunqqDcL4RMK8FjYSpg5Vq7dm25zQsAAAAoqXN7dLfhq7J4a/xE+/rkIw/lha+MPr3PU/duXTVj1g/atPlQZa1Ppnyh/fsTNOS2W/PCV4ZZv2vwIO3evUdTvvwqb/ttd/+fHJHVbUDscLn7nh81ukzvAeXrxKAQG77yB2vdWdricauJ06Xj8lXNWpWdpRsSd+uh5H3KyskpcExx+6o6p8M3CwDA/yWlZ2n6ip0K9ApXkwd31sxh3fTFnWfa16WPnqfXrj1FXZrHEr4CAAAAAJRZlQtgmcpXv//+u11v06bNMZ0jIyOjVFW3AAAAAH/009x5ioyM1JldCrff7t2zp32dPXf+ofFz5tnXXj17FB5/7sHx8w6Nf+n5Z3R8m9Z69Kln9OuS3/K2T/lymsaMG68eZ3fTff93dzm/K/iLHR6PvstI05cZqZqXma69Hnepjv8p88ADM2cfVv2qVVCwLgkJ1yaPWx9npORtT8nx6I20JFvm+Y7waAXzRSoAACWyIyFdbk9OQFa4urBdPX04qLO+G3qWTmsaqxZ1otWhUXX7Gh1WuFUyAAAAAADHKqBaEB5Jamqqtm7dqmnTpumFF15Qdna23T506NBjOt/s2bPz1o8//vhymycAAADgLSkpKdq+Y4dOPOGEIh8qMO0NjdX5Kr7mrrds3rzw+IPb8o8PDw/Xh+Pf1undz1X/gTfr9wVztT8hQbfcebdiY2tq0rgxcjqr3DMhVcaC7Ay75DKfsvNCwtQ/NFLOo4Sj0nNytDArU6Yu2xnBoYX2XxoaoRXuLM3ITFc7V4jaB4dofFqydud4dGNYlBrkq5iFA5xy2MXb1wQA+L+UzNKFpP1RRIhLo6/qoGa1I5Wc4VZUqEtxMWGErAAAAAAAXhOwd6UnTJigG2+88Yj7H3jgAV1zzTWlPu/27ds1fvx4u167du0C7QhLasuWLUe9BgAAAFCREhIT7Wu1ajFF7o+JPrA9ISGxRMfExEQXGm+0P6mdnn9yhIYOf1C33zNMW7Zt0969+zR18geqX69eOb4j+Itoh1NXhUaow8F2hhk5OVrjztLkjFR9l5luIznXhEUVe45FWRlKV47ODA5VpKNwSM8EuG4Pj9ZDyfs1Nj1JvT3h+iU7U6cGhajHYRWzAABA8SJDXJW+veCofu11YoNqvp4KAAAAAKAKC9gA1pF06NBBY8eOVadOnUp9bE5OjgYPHqykpCT78yOPPKKwsNLf3G/UqFGpjwEAAAAqq7vvuE3TZ/6g9z6abH++fdDN6nvhBb6eFipIQ1eQXXKFORzq6AxVc1ew/pOyz1atujAkQtWKqX42O+tg+8Eiql/lMuGuG8Oj9Fpakj7JSFVNh1M3hxcf7KrKnI4Di7evCQDwf3WrhcnldFSqNoSmvWDvtnU1oHMTdW5WUw5aDwMAAAAAfCxgA1iXXnqpTj31VLuelpamtWvXavLkyZoyZYr69++v0aNH66KLLirVOZ955hnbxtAwla/uvPPOCpk7AAAAUNGqxRSucJVfYlLhalf5jzEtBAuMT0w6YnUs84XYpRdfqG9nfG9/HnLbreX2PlB5VHc61TEoRD9lZWitO0unOIsOV213Z2uVO1txTqeODzJNCI+srStY4XIoTTnqEhyqqCKqZQEAgOKZNn2928bpm2U75K8Vrp68tK1qRobQXhAAAAAA4LcCNoBVvXp1u+QyFa+uvvpqTZo0STfccIMuueQSjRs3TgMHDizR+d5//31b8cpo2rSpPvjgAzmLeWK7OJs3bz5qC8LTTjvtmM4NAAAAlERkZKTq1a2r9Rs3yu12y+Uq2Hpm9Zp19rVl8+Z528z64t+WavXatYUCWGbb4eNzrd+wQfc99Khq1qyhffv265Y779acGd8UuiYCX25AKqOYMSagZZwdfPRqw2+lJ9vwVZTDoemZaTaE1SRf9S0AAFAyppKUPwWwqHAFAAAAAKhsqtzjwdddd53+9a9/yePx6K677tLevXuPeszXX3+tG2+80bYgrFu3rr7//nv7eqwaNmxY7FKvXr1jPjcAAABQUmd3PVMpKSmav2BhoX3TZ82yr926nnFo/Fln2tcZs34oPH7mrLxz5pedna1rb7rVtvH++N3xGjbkTv288Bc9/sxz5f5+4P/WurPta+0jVKpy5+Rofla6TDTvrKMEsL7PTNPS7EydGRyq+yOq2W2vpyUpI6fytE/yJvO1tdPLC1+VA0Dl0aVZrFrFRfmswtXkwZ01c1g3fXHnmfZ16aPn6bVrT1GX5rGErwAAAAAAlUKVC2AZpvqVYb5s+u6774od+9NPP+nKK69UVlaWatSooenTp6t5EU/1AwAAAP5q9+49+vufVfY1v1tvusG+PvLk08rMzMzb/u307/XTnHnq1bOHmjRunLe93+WX2RaDr7w5Vlu2bs3bbtZfHfOWatWK1WV9C7b5NkGrBb8s0r/vvkvn9uiuZx5/VKd0aK9nXvyv5s7/uQLfNSpaksejbe5s+5rf+oMhq8NNz0jTX+4s1XU61ewIVapMoCohJ0ftg0Jsy8Ij2ezO1ofpKarjcOqGsEgd5wrSlaER2uZx67305DK+MwAAqpak9Cyt2ZWswWc3V1iw02sVri5sV08fDuqs74aepdOaxqpFnWh1aFTdvtJeEAAAAABQ2VTJ3gy1a9fOW9+4ceMRxy1atEgXX3yx0tPTFRUVpW+//VYnnXSSl2YJAAAAHNnbEyZq3s8L7PqyFSsPbHt3kn6aO8+udz2ji24ZeL1df3XMWD3+zPN67D/3a8RDD+ad45yzu9kx5lynnHG2Ljy/l7bv2KGPP5ti2wW+MuqFAtesUaO6Xh31oq67ZbAdf9WVl9ntH386RXv27NXHE8crOjo6b/ycefNt0MoErp4ecaCdd0hIiD4Y/7Y6du2uATffqj8WzivQOhy+9VNmuv5xZ9n1LQeDVLOz0m1wymjtClb3kLC8ClRTMtN0WUi4Lg+LzDvHy6mJcjmkps4g1XS6bEWqNe4sbfS4FSGHbguPlvMIlSzMtYyzg0OPOMfMnBxb6crEvm4Pj1b4wWpaF4SEa3l2lm1heFJQiDoVc46qyPyJe7t+CPVKAMB/mUr/C9bt0aQFGzVj5U65PRVbQTI82KnH+rZVm7oxigp1KS4mjJAVAAAAACCgVMkA1tZ8T+ubYFVR/vzzT51//vlKTk5WWFiYpk2bptNPP92LswQAAACOzISv3n3/wwLbTCvB/O0EcwNYxRnzymi1a3uCxr7zrv73+puKioq0VayefuwRNW/WtND4Af2vUq3YWD0zcpTGT/rAtoTpeHJ7PTz8PlvhKte+ffs14ObBCg8P14cTxtngVa7WrVpq9AvPatCdd2vQXffok/feLcOfBMqTCV/Ny8oosG2VO9suubqr+NaAPUPC9Gd2lv5xZys5O9OGcGo5XeodEmZDUiaUVZR9Hrc9robDqQ5Bhz4vhzOVr7Z43LbiVYugQ1/cms/i4PBo/Sdln8alJdsqW7FHuBYAAFWtwtWOhHSlZLoVGeLS3pRMPTJ1uVbtTPZai8FR/drrxAYHWgYDAAAAABCIHDnmcacq5sILL9Q333xj13/88Ud1737oiyJj1apV6tatm3bu3Kng4GB98cUXuuCCC7w2vy1btqhRo0Z2ffPmzWrYsKHXrg0AABDwUhN8PQMEoPfqtfD1FBBA9nrcuid5X5l/J8z/u+Ur0TW9Hkjb43FrSNJeu87vtkDl4g/3ptxut+Lj4/Oq2btchGr9pcKVaR/Yu21dXXt6Y5milpMWbtT0FQWvkTtmQOcm6tyspg1KBwI+l/A3fCbhj/hcwt/wmYQ/8vfPpT/8TghURgFVAWvChAm6+uqrbcWqI3nppZfywldNmzbVWWedVWD/pk2bdO6559rwlfkfug8++MCr4SsAAAAAAMqbaft4pNaPFXlNAID3Ld+aoGGTfy/XCldhwU49fWk7tW9UrVD7wC7Na9kqWzsT05Wc4abFIAAAAACgSgqoANaIESP073//W1dccYW6du2q5s2b2xaDSUlJWrZsmd5//33Nnz/fjjUtUMaOHVsgTbpnzx4bvjIpTsOcq02bNlq+fPkRr1mjRg01aNDAC+8OAAAAAAAAAI7cYvDv7Yl6fNpKpWW5y/Ua6VkejZ2zTt8NPavIalYmbEXgCgAAAABQlQVUAMvYu3ev3nrrLbsciSmR984779iwVX4mpLV69eq8n1944QW7FOeGG26wlbcAAAAAAPBX5qtyb9ejov4VAFTOFoNH8s/OJC1ct1ddmsdW+LUAAAAAAKhsAiqANX36dH399de2ytWaNWtsG0FT1So8PFx16tRRhw4ddNFFF6lfv36KiIjw9XQBAAAAAAAQgDIzMzVx4kR98skn+vPPP+0Dg8HBwbaK+hlnnKFBgwbZ16P59ttvbQX3X3/9VfHx8apdu7Y6deqkW2+9VX369PHKe0HVaDFYUu8t3EgACwAAAACAQA9gtW7d2i7Dhg07puO7d+9unx4DAAAAAAAAjsXGjRt14YUXasWKFYVCWatWrbKLqaY+ZMgQ/e9//yuynZvH47Ehq3HjxhXYvnXrVrt88cUXuuWWWzRmzBg5nc4Kf0/wH3NXx2vwpCVKzSzfFoMl9d2KHbblIe0GAQAAAAAoiDs0AAAAAABUkRaE3l6AqiYrK6tA+Oqkk06yYasFCxZoxowZevTRRxUZGWn3vfLKK3r++eeLPM9DDz2UF746+eST9eGHH2rRokX21fxsvP3223r44Ye99t7gGybstHpnkn7fvF/f/LlNt070XfjKMK0Odyam++z6AAAAAAD4q4CqgAUAAAAAAAD4ytSpU/PCV126dNHcuXPlcrny9p933nnq27ev3WfCWiaAde+99yoo6NAtOlMha+TIkXb91FNP1Zw5cxQeHm5/Nu0HzfFnn322Fi9erBdffFE33XSTWrRo4fX3iopjKvQvWLdHkxZs1IyVO23oyZ8kZ/guAAYAAAAAgL+iAhYAAAAAAAGOCliAd/z888956w8++GCB8FWujh076qKLLrLr+/fv119//VVg/+jRo5WdnZ1XJSs3fJUrIiLCbjfMuJdeeqlC3gt8Y/nWBPUePUfXvPWLvl2+w+/CV0ZUaOHPNQAAAAAAVR0BLAAAAAAAAKAcZGZm5q03a9bsiOOaN29e5DGm8pGpomW0adNGnTt3LvJ4s71169Z23Yw3x6Hym7s6Xv3GLNCqncnyV0FOh+Jiwnw9DQAAAAAA/A4BLAAAAAAAAKAc5IaijHXr1h1x3Nq1a+2rw+FQy5Yt87avX79e27Zts+umzWBxcvdv3bpVGzZsKPPc4fvKV4MnLVFqpn+39+vdtq6iw4J9PQ0AAAAAAPwOASwAAAAAAAKcCXn4YgGqmv79+ysmJsauP//883K7C4dpli5dqq+//tquX3PNNXnjjZUrV+atmwpYxcm///A2hqhcTAWzYZN/9/vwlTGgcxNfTwEAAAAAAL8U5OsJAAAAAAAAAIGgVq1amjRpkg1izZ8/X506ddLQoUPVqlUrJScn222jRo2ybQdPOeUUu57fli1b8tYbNmxY7LUaNWqUt7558+ZSzTP/dYqyffv2vHUTIisqSFbRzDU9Hk/eeiBbsG6PX7cdzNUqLkqdmlQL+L+P4lSlzyUqBz6T8Ed8LuFv+EzCH/n759If5wRUBgSwAAAAAAAIcKYWlbfrUVH/ClVV3759tWTJEhuuGjdunG644YYC++Pi4vTkk09q0KBBioiIKLAvKSkpbz0qKqrY60RGRuatm3BXaeQPbx3Nnj17FBoaKm8zX0YkJCTk/ex0Bm4h/3fmHGhJ6c/Cg536T89G2r17t6+n4lNV6XOJyoHPJPwRn0v4Gz6T8Ef+/rk0vwcCKD3/+m8yAAAAAAAAUImZ6lYTJ07U1KlTbWu5w+3cuVPvvfeeZs6cWWhfenp63npISEix18kfikpLSyvzvOEbKRluzV6zX/4evnruouZqU6dgYBAAAAAAABxCBSwAAAAAAACgHKSkpKhPnz6aO3euXC6Xhg8frhtvvFHNmjWz4apffvlFTzzxhObNm6dLL71UI0eO1LBhw/KODwsLKxDkKk5GRkbeenh4eKnmebSWhaYF4WmnnWbXY2NjVbt2bfmy5YVp7Wj+PAPR/l3JchfO6flV28EXr2inExtU8/VU/EJV+Vyi8uAzCX/E5xL+hs8k/JG/fy7z/74JoOQIYAEAAAAAEOAcPiiBTQtCVEUjRoyw4Svj8PaDpqLVeeedp3POOUe9evXSjz/+qPvuu089e/ZU+/bt7Zjo6OgStxU0Ya+Stis8XMOGDUs81nwR4KsvA3LbcPhyDhUtPdv/0ldBTod6t62rAZ2bqHOzmnI4+F/0qva5ROXCZxL+iM8l/A2fSfgjf/5c+tt8gMqCABYAAAAAAABQRqbd4DvvvGPXW7VqVSB8lV9QUJCefPJJde3aVR6PRxMmTNBLL71UKBi1ZcuWElexatSoUTm9C3hbZIhvv9hoHRetJy9tq5qRIUrOcCsq1KW4mDBFhwX7dF4AAAAAAFQ2BLAAAAAAAAhwpniJtwuYUDAFVc3OnTu1d+9eu37yyScXO7Zjx45563///Xfe+gknnFDk9qLk33/88ccf05zhe1GhQXI6JI8XC2FR4QoAAAAAgPJHAAsAAAAAAAAoI1PZKld2dnaxY7Oysoo8rmnTpqpfv762bdum2bNnF3uOOXPm2NcGDRrouOOOK8PM4YtqaQvW7dGkBRs1Y+XOCg9fhQc79VjftmpTN4YKVwAAAAAAVBACWAAAAAAAAEAZ1axZUzExMUpMTNSCBQtsCCt/uCq//OEqE7rKZSoRXXLJJXrjjTdshauFCxeqc+fOhY4323MrYJnxVDCqPJZvTdCwyb9r1c5kr7UYHNWvvU5sUM0r1wMAAAAAoKpy+noCAAAAAACgYjl89B+gKnE6nbrwwgvtuqlg9fTTTxc5bt++fbr//vvzfr7ooosK7B86dKhcLpddHzJkiNLS0grsNz+b7YYJeJnxqBzmro5XvzELKjx8ZVoMXtiunj4c1FnfDT2L8BUAAAAAAF5ABSwAAAAAAACgHDz66KOaOnWqUlNTNWLECC1ZskQ33HCDmjVrpvT0dFu5avTo0dq0aZMd37NnT/Xq1avAOVq1aqX77rtPzz33nBYvXqwzzzzTBraaN2+utWvX6vnnn9fSpUvtWDOuZcuWPnmvKJmk9CztSEjXn1sT9NCUZUrP8lRIi8H/9uugetXDaTEIAAAAAICPEMACAAAAACDAmVpU3q5HRf0rVEVt2rSxAaz+/ftr9+7dmjZtml2K0qNHD33yySdF7jPVs3bt2qV33nnHhq2uvvrqQmNuvvlmPfXUU+X+HlB2OTk5WrBujyYt2KgZK3fK7cmpsGtFhLg05rqOOqtl7Qq7BgAAAAAAODoCWAAAAAAAAEA5Offcc/X3339r3Lhx+vbbb7VixQrt37/ftgusW7euOnXqpGuuuUZ9+/aVw+E4YjtDc/wVV1yhsWPH6tdff7WBrlq1atnjBw8erD59+nj9veHolm9N0LDJv1d4m0GjdVy0RvVrT4tBAAAAAAD8AAEsAAAAAAACHBWwAO+KjY3V8OHD7VIWF1xwgV1QOcxdHa/Bk5YoNdNdYdcIcjrUu21dDejcRJ2b1TxiiA8AAAAAAHgXASwAAAAAAAAAKGPlq4oOXzkd0tzh56he9fAKuwYAAAAAADg2zmM8DgAAAAAAAACqvJycHNt2sCLDV4YnR0rJzK7QawAAAAAAgGNDBSwAAAAAAKrA01emcoq3rwkAVcGCdXu0ameyV66VnFGxIS8AAAAAAHBsuB8KAAAAAAAAAMfovYUbvXatqFCX164FAAAAAABKjgpYAAAAAAAEOMfB/3j7mgAQ6JLSszR9xU6vXCvI6VBcTJhXrgUAAAAAAEqHClgAAAAAAAAAcAx2JKTL7cnxyrV6t62r6LBgr1wLAAAAAACUDgEsAAAAAAAAADgGKZlur11rQOcmXrsWAAAAAAAoHVoQAgAAAABQBdAQEADKX2SIyyvXaR0Xrc7NanrlWgAAAAAAoPSogAUAAAAAAAAAx6ButTC5nBUbcY0IcWlUv/ZyOIjSAgAAAADgrwhgAQAAAAAQ4Mx39r5YACDQRYcFq3fbuAoNX425rqNObFCtwq4BAAAAAADKjgAWAAAAAAAAAByjAZ2bVFjbwcmDu+islrUr5PwAAAAAAKD8BJXjuQAAAAAAAACgSunSLFat4qK0amdymc8V5HSod9u6NtTVuVlN2g4CAAAAAFBJEMACAAAAACDAma/vvf0VPpEBAFWFCUn9t18H9RuzQKmZ7lIfHxbs1NOXtlP7RtUUFxNm2xoCAAAAAIDKhRaEAAAAAAAAAFAGJzaopjHXdVR4iKtUx0WEuPTW9afqio4N1aJONOErAAAAAAAqKQJYAAAAAAAEOKccPlkAoCo5q2Vt3dm9eYnHt46L1uTBXexxAAAAAACgcqMFIQAAAAAAAACUgz+2JBS7P8jpUO+2dTWgcxN1blbTti8EAAAAAACVHwEsAAAAAAAAACijhLQszf4nvsC2Jy9pqy7NY5Wc4VZUqEtxMWG0GQQAAAAAIAARwAIAAAAAIMCZ+irerrFCTRcAVc2MFTuU6fbk/RzicqpvhwaqFk7gCgAAAACAQOf09QQAAAAAAAAAoLL76s/tBX4+u3VtwlcAAAAAAFQRVMACAAAAACDAORwHFm9fEwCqir0pmZq3ZneBbRedVM9n8wEAAAAAAN5FAAsAAAAAAAAASikpPUs7EtKVkunWj3/vlNuTk7cvLNipc4+P8+n8AAAAAACA9xDAAgAAAAAAAIASyMnJ0YJ1ezRpwUbNWFkwdJVfjzZ1FBnKrVcAAAAAAKoK7gIAAAAAABDgTDdAb3cEpAMhgECzfGuChk3+Xat2Jh917O+b9tvxJzao5pW5AQAAAAAA33L6+PoAAAAAAAAA4Nfmro5XvzELShS+MrYlpNvx5jgAAAAAABD4CGABAAAAABDgHD76DwAEAlPJavCkJUrNdJfqODPeHGeOBwAAAAAAgY0AFgAAAAAAAAAcJik9S6t2JOqO938rdfgqlznu35P/UE5OTrnPDwAAAAAA+A8CWAAAAAAAoNLZtWuXvvrqKz366KPq06ePatWqJYfDYZeBAweW23VGjBiRd96jLT/99FO5XReAb5ig1M9rd+v295aowxPfq9foudq0N7VM5/xnZ5IWrttbbnMEAAAAAAD+J8jXEwAAAAAAABXL4ZCcDu9fsyLFxcVV7AUAVDmmVeCwyb9r1c7kcj/3ews3qkvz2HI/LwAAAAAA8A8EsAAAgP9KTfD1DBCAvmnUxtdTQADanHFsbYmAoiTkeHw9hUqncePGatOmjWbMmFGh11m2bFmx+5s2bVqh1wdQceaujtfgSUuOudXg0Xy3YodtaRgdFlwh5wcAAAAAAL5FAAsAAAAAgABnilF5uQBWhV/PtB7s1KmTXUw1rA0bNlR4AOrEE0+s0PMD8F3lq4oMXxluT452JqYTwAIAAAAAIEARwAIAAAAAAJXO448/7uspAAgAOTk5tu1gRYavciVTMRMAAAAAgIBFAAsAAAAAgAAXiBWwAKA8LFi3R6t2JnvlWlGhLq9cBwAAAAAAeJ/T1xMAAAAAAAAAAF94b+FGr1wnyOlQXEyYV64FAAAAAAC8jwAWAAAAAABACfTq1Ut16tRRSEiIfe3evbuee+457du3z9dTA3AMktKzNH3FTq9cq3fbuooOC/bKtQAAAAAAgPfRghAAAAAAgCrRgtC7TQHzX2379u1HHd+wYUP5u++//z5vPT4+XrNnz7bL888/rwkTJuiSSy7x6fwAlM6OhHS5PTleudaAzk28ch0AAAAAAOAbBLAAAAAAAECFOu200446JifHOyGIY9GuXTtdeuml9n3Ur19fWVlZ+ueff/T+++9rxowZ2r9/v6644gpNmzZNffr08fV0AZRQSqbbK9dpHRetzs1qeuVaAAAAAADANwhgAQAAAAAQ4ByOA4u3rxkIhg4dqhEjRhTafvrpp+v666/XmDFjdNttt8ntduuWW27R2rVrFRYW5pO5AiidyBBXhV8jIsSlUf3ayxEo/6MIAAAAAACKRAALAAAAAABUqEWLFqlevXqqjKpXr17s/sGDB+vXX3/VuHHjtG3bNn322We69tprvTY/AMeubrUwuZyOCmtDaMJXY67rqBMbVKuQ8wMAAAAAAP/h9PUEAAAAAABAYDPhq4YNGxa7VGYmhJVr9uzZPp0LgJKLDgtW77ZxFdZ2cPLgLjqrZe0KOT8AAAAAAPAvVMACAAAAAKAKPH3l7SewqtITXyeccELe+tatW306FwClM6BzE32zbEe5nCvI6VDvtnXtOTs3q0nbQQAAAAAAqhACWAAAAAAAAGVAyAKovLo0i1WruCit2pl8zOdoXDNC42441bY0NFW1AAAAAABA1VOVHkgFAAAAAKBKcvhoqSpWrlyZt16/fn2fzgVAySWlZ2nNrmQNPru5woKP7TZpRIhLr197ilrGRRO+AgAAAACgCqMCFgAAAAAAQBmMGTMmb/3ss8/26VwAFC8nJ0cL1u3RpAUbNWPlTrk9Ocd8LhO+GnNdR53YoFq5zhEAAAAAAFQ+VMACAAAAAABV0oQJE2z7QLOMGDGi0P5ly5ZpzZo1xZ5j7Nixevvtt+163bp1ddlll1XYfAGUzfKtCeo9eo6ueesXfbt8R5nCV63jojV5cBed1bJ2uc4RAAAAAABUTlTAAgAAAAAg0B0MGXn7mhVp3rx5BcJRu3fvzls32024Kr+BAweW+hpLlizRLbfconPOOUd9+vRRu3btFBsbq+zsbP399996//33NWPGDDvW5XLZMFZkZGSZ3heAijF3dbwGT1qi1Ez3MZ8jyOlQ77Z1NaBzE3VuVtP7/7sKAAAAAAD8FgEsAAAAAABQ6ZiqU++++26R++bPn2+XsgawDLfbrZkzZ9rlSEwoa9y4cbr44ouP6RoAKr7y1bGGr8KCnXr60nZq36ia4mLCFB0WXCFzBAAAAAAAlRsBLAAAAAAAApyp0eLtOi2BUBfmggsusMGqBQsWaOnSpdq5c6f27NmjnJwc1axZU+3bt9f5559vw10xMTG+ni6AIpj/vg6b/PsxV75Kz/Jo7Jx1+m7oWVS8AgAAAAAAR0QACwAAAAAAVDqmxeDhbQZLywSniquMVadOHd100012AVA5LVi3R6t2JpfpHP/sTNLCdXvVpXlsuc0LAAAAAAAEFqevJwAAAAAAAAAAFeG9hRv96jwAAAAAACAwUQELAAAAAIAARwtCAFVRUnqWpq/YWS7n+m7FDnu+6LDgcjkfAAAAAAAILFTAAgAAAAAAABBwdiSky+3JKZdzmfPsTEwvl3MBAAAAAIDAQwUsAAAAAAACnMPhsIu3rwkAvpSS6S7X8yVnlO/5AAAAAABA4KACFgAAAAAAAICAExniKtfzRYWW7/kAAAAAAEDgIIAFAAAAAAAAIODUrRYml7N8qvEFOR2Kiwkrl3MBAAAAAIDAQwALAAAAAIAAZ/IHvlgAwJeiw4LVu21cuZyrd9u69nwAAAAAAABFIYAFAAAAAAAAICAN6NzEr84DAAAAAAACU5CvJwAAAAAAACqWw+GQw8slqRweSmAB8L0uzWLVKi5Kq3YmH/M5WsdFq3OzmuU6LwAAAAAAEFiogAUAAAAAAAAgYAOo/+3XQREhrmM63hw3ql97ex4AAAAAAIAjIYAFAAAAAAAAIGCd2KCaxlzXsdQhLDPeHGeOBwAAAAAAKA4BLAAAAAAAApwp3OKLBQD8xVkta+vjWzsr2OUocdvByYO72OMAAAAAAACOJuioIwAAAAAAAACgkgsNdinLnXPE/UFOh3q3rasBnZuoc7OatB0EAAAAAAAlRgALAAAAAIAA54uKVOQWAPibGSt2FPi5TnSo3r/ldKVkuhUV6lJcTJiiw4J9Nj8AAAAAAFB5EcACAAAAAAAAEPBmrNxZ4OfzT6yrlnHRPpsPAAAAAAAIHE5fTwAAAAAAAAAAKtK2/Wn6c0tCgW29Tqjrs/kAAAAAAIDAQgUsAAAAAAACncMhBz0IAVRh3x9W/SomLEinN6vps/kAAAAAAIDAQgUsAAAAAAAAAAFtxsodBX7ueXycgl3cGgUAAAAAAOWDClgAAAAAAAQ4U4yKAlgAqqqE1CwtXLe3wLZeJ8T5bD4AAAAAACDw8JgXAAAAAAAAgID1wz875fbk5P0cEuRUt1a1fTonAAAAAAAQWKiABQAAAABAgHM4HHbx9jUBwJeS0rO0IyFdHy/aXGB7t5a1FBnKbVEAAAAAAFB+uNMAAAAAAAAAICDk5ORowbo9mrRgo2asLFj5KlezWlF2HEFRAAAAAABQXghgAQAAAAAAAKj0lm9N0LDJv2vVzuRix42du04/rdql//broBMbVPPa/AAAAAAAQOBy+noCAAAAAACgYpkiL75YAMBb5q6OV78xC44avsplxpnx5jgAAAAAAICyIoAFAAAAAAAAoFJXvho8aYlSM92lOs6MN8eZ4wEAAAAAAMqCABYAAAAAAAHO6XD4ZAGAipaTk2PbDpY2fJXLHPfvyX/Y8wAAAAAAABwrAlgAAAAAAAAAKqUF6/aUuO3gkfyzM0kL1+0ttzkBAAAAAICqhwAWAAAAAAAAgErpvYUb/eo8AAAAAACgagry9QQAAAAAAEDFMt0Avd0RkA6EACpaUnqWpq/YWS7n+m7FDnu+6LDgcjkfAAAAAACoWgKuAtauXbv01Vdf6dFHH1WfPn1Uq1YtORwOuwwcOPCYzjlz5kx7bIsWLRQZGalq1aqpVatWuvLKK/XGG28oOblsZc4BAAAAAAAAlM6OhHS5PTnlci5znp2J6eVyLgAAAAAAUPUEXAWsuLi4cjvXvn37dOONN2rq1KmF9iUmJmr16tX67LPP1KVLF3Xo0KHcrgsAAAAAQHlymP94uSSVuSYAVKSUTHe5ni85o3zPBwAAAAAAqo6AC2Dl17hxY7Vp00YzZswo9bEJCQk677zztGTJEvvzZZddZiteNW/eXC6XS5s3b9bs2bNtAAsAAKA47334seb+vEBLlv6uZStWKjMzU+PffE0Dr7u2VOfxeDx6bcxbGvvOu1qzbp2ioiJ1bvfuenrEI2rW9Lgij5n+/Sw9M3KUfvv9T/vFe8eT2+vh4fep5zlnl9O7g6/8kJGmFdmZWpOdpQ3ubGVLGhoZo/NCI0p8jj+zMvRg0r4j7i/qfJNSk/RXdpa2erKV6PEozOFQHadL3UPD1Sc0wv6MymupO0MbPNnaluPWjhy3zNfQVwRFqKMrtNTnysjJ0Vx3upZ7MrUvxyOXHKrpcOp4Z7B6BoVX2HUBAFVHZIirXM8XFVq+5wMAAAAAAFVHwAWwTOvBTp062cVUw9qwYYOaNm1a6vMMGTLEhq9CQ0M1efJk9e3bt8D+U0891YayXnrpJbndPB0HAACO7OEnntLGTZtVq1as6tWNs+vHYvCQoXp7wkS1Pf543X37YG3bvl2TP/9CM374QQt/nKmWLZoXCn5dd8tg1a5VSwMH9LfbPv50is67+FJNnjRBV152Sbm8P/jGpLQk7fJ4FONwqKbTadePVbugYLULCim0vZkruNC2rzJSVd8ZpJODQlXd6VRaTo6WZWfq7dQkzcpI08iYWEJYldj32enaL48i5FC0nHb9WOzP8ejtzCTtk0fNHUFq4wq2IcE9OR6t8GSpp8Ir5LoAgKqlbrUwuZyOcmlDGOR0KC4mrFzmBQAAAAAAqp6AC2A9/vjjZT7HvHnzNGnSJLv+1FNPFQpf5WcqSQQFBdwfIwAAKEdvv/aKWrZopiaNG+u5kS/pwcdK/++VH2fPseGrbl3P0PfTvlBIyIGwzDX9/qULLv+X7hp2n6Z/+Xne+H379mvIvcNt6Ou3n2erYYMGdvv9w4bq5DO66fahw9T73B6Kjo4ux3cKb7o7spoaOINUx+XS5LRkvZuWfMznMuGrayNK9lmYVL2OQooIWI1M3q8fM9M1MyNVF4VFHvNc4FuXB0co1uFUDYdLs7PTNd2dVupzuHNy9H5WspLk0U3BUWruDC60vyKui+I5nAcWb18TACpSdFiwereN0zfLdpT5XL3b1rXnAwAAAAAAOBbcDi3Cq6++al+rVaumu+66y9fTAQAAldy5Pbrb8FVZvDV+on198pGH8sJXRp/e56l7t66aMesHbdp8qLLWJ1O+0P79CRpy26154SvDrN81eJB2796jKV9+lbf9trv/T47I6jYgdrjcfc+PGl2m94DydXJwqA1feVtR4Suja8iBihHb8lWHXZmVqYv37tBdCbuVdVjoprh98J0WzmAbgiqL5Z4sbc1xq6srrFD4ynAV8RkqzXX/cGfqPxn7NCErSTmHfXaK2wcACEwDOjfxq/MAAAAAAICqiQDWYTIzMzV16lS7ft555yks7MAXSabN4ObNm21Lw/T0dB/PEgAAVDU/zZ2nyMhIndmlc6F9vXv2tK+z584/NH7OPPvaq2ePwuPPPTh+3qHxLz3/jI5v01qPPvWMfl3yW972KV9O05hx49Xj7G667//uLud3BX+xzePWF+kptpLWDxlp2u0pfYvtX7My7GuTfNVhTwgO0dVhkVrvztb41KS87ckej15M2a9gOTQ8qrqCaVkYUJZ5Mu1rO2eIbUX4izvDVrVa5s5URjmEotq7QnSKM0SrPNn62X3gc2fsy3FranaqouTQlUGRtlox8nE47J+JNxdzTQCoaF2axapVXFSZztE6Llqdm9UstzkBAAAAAICqhwDWYf7444+8gFW7du2UmJiooUOHqlatWmrcuLGaNm1qK2OZcNZPP/3k6+kCAIAqICUlRdt37FDTJk3kKqLikWlvaKxeuzZvW+56y+bNC48/uC3/+PDwcH04/m05nU71H3izkpOTtWXrVt1y592Kja2pSePG2H0ITD9lpuut1CTbxnBUSoJu2h+vt1ISi2wVl+vTtGS9n5qksSmJGpqwW99lpOmUoBD1DAkvMO7q8CidEBSsLzNStTjzQFjm1dRE7fJ4NCgiWo1dtPMONFs92fZ1fU6W/puZYENRpqXgh9kpGpmZoHWerDJf4+KgAy0LzXm3ebLlycnRx1kpylCOrgyOVBS97wCgyjCBz//266CIkGOr4GiOG9WvPcFdAAAAAABQJnzbcZiVK1fmrXs8Hp166qlavXp1oSpZM2fO1KxZs/Tss8/q/vvvL9U1tmzZUuz+7du3l3LWAAAgkCUkJtrXatViitwfE31ge0JCYomOiYmJLjTeaH9SOz3/5AgNHf6gbr9nmLZs26a9e/dp6uQPVL9evXJ8R/AX1RxODQyP0mnBoYpzuZSek6O/srM0ITVJX2Sk2uI1t0QU/bn7LD1FifkCWueEhOnOyBgFHfblpWk3d19kdd2VuFsvpSToEneE5mam64zgUPUJi6jw9wjvS9GBz8XX2Wnq6gpVF1eY/cXzD0+mvs1O03tZKRoaEqOYMoSkQh0OXRUUqTFZSfo4O0VtnMHalOPWma5QtSqi7SEAILCd2KCaxlzXUYMnLVFqprtU4StznDkeAAAAAACgLAhgHWbv3r15688//7ythnX++efriSee0EknnWQrYn322Wd64IEHlJCQYF/btGmjSy65pMTXaNSoUQXNHgAAoGzuvuM2TZ/5g977aLL9+fZBN6vvhRf4elqoIE2Cgu2SK8whdQlxqXVQsO5K2KMv01N1ZVikqjsLV5T4sEacfd3rcevPrEyNT0vSsMS9ejK6hmodNr6Oy6W7ImL0fEqCrbJVy+nU3ZF80RmocmN5rZ3BOj/oUMjuDFeYEnM8muPO0GJ3hnoEFayWVloNnUE61xVuq2DFuzNUz+FSb1fZzhnIfNERkGIyALzprJa1NXlwFw2b/LtW7UwuUdtBU/mK8BUAAAAAACgP9GUoosVPLhO+Mq0Gv/rqK3Xq1EmhoaGqXbu2brvtNrsttw3Pgw8+qJxi2rMAAACURbWYwhWu8ktMKlztqrhjEhOTCo3PZVqvXHrxhXk/D7nt1jLPH5VPTadLnUNCZepH/JOdddSx3UPD9VBUDW1yZ+vt1AOfr8O1Dw5VxME0xtkh4YqmpWXACtWBv+fji6hEdbwzxL5uzSl5dZLimGvkZnw6uUILVWADAFQtJkz1+e1nHHF/kNOhC9vV04eDOuu7oWcRvgIAAAAAAOWGCliHCQsLK/CzqYLlchV+4r9r1666/PLL9emnn+qvv/7SsmXLbIWskti8efNRWxCedtpppZw5AAAIVJGRkapXt67Wb9wot9td6N8mq9ess68tmzfP22bWF/+2VKvXrlVsbM2C49euLTQ+1/oNG3TfQ4+qZs0a2rdvv265827NmfFNkf8eQmDLbQ9n2hKWRKugYEU5HFqWlVnk/tEpCUrNyVGMw6Gp6Sk6OyRMzfNV30LgqO1wamOOW2F50ahDcrdll8MDLO6cHH2SnZJ33u+z02wgy7TWxJEqYHk3oEYeDoAvrN+dWmjb5MGdVTMyRHExYYoO498fAAAAAACg/HFn+jDR0dF566ba1cknn3zEsb17985b//XXX0t8jYYNGxa71KtXrwzvAAAABKKzu55pK3XOX7Cw0L7ps2bZ125dDz3tf/ZZZ9rXGbN+KDx+5qy8c+aXnZ2ta2+6VUlJSfr43fEaNuRO/bzwFz3+zHPl/n7g/3IrX8WVMHyXluOxAauiRn+VnqJFWRk6JyRMT0YfCAS+kLy/xOEuVC7NDla+2lVElavcbdXLISQ1w51mK2l1d4WpX1CE0pSjyVkp8vC5AoAqbW18wfaDjWtG6LSmsWpRJ5rwFQAAAAAAqDAEsA7TqFGjvHUThirp2Pj4+AqdFwAAqBp2796jv/9ZZV/zu/WmG+zrI08+rczMQxWGvp3+vX6aM0+9evZQk8aN87b3u/wy22LwlTfHasvWrXnbzfqrY95SrVqxuqzvRQWuYYJWC35ZpH/ffZfO7dFdzzz+qE7p0F7PvPhfzZ3/cwW+a1S0BI9Hm93Z9jW/1UdoL2gqVP2Znan6Tpdaug59Ubndna2kw86RW81obGqSzJ5TQ0IL7NuQnaVxqUmq63TpjsgYtQgK1vXh0dricWtsatFtNVE5pOR4tMvjtq/5dXSF2FLLC9wZSsi3LyMnRz+50+16O9eBVoTHarUnS/PcGWrkcKmHK0xtXCHq7AzV+pxszTl4DQBA1bRmV8EAVvPakT6bCwAAAAAAqDpoQXiYtm3b5q2bFj/Fyb8/KIg/SgAAULS3J0zUvJ8X2PVlK1Ye2PbuJP00d55d73pGF90y8Hq7/uqYsXr8mef12H/u14iHHsw7xzlnd7NjzLlOOeNsXXh+L23fsUMffzbFtgt8ZdQLBa5Zo0Z1vTrqRV13y2A7/qorL7PbP/50ivbs2auPJ44vUPlzzrz5NmhlAldPj3jEbgsJCdEH499Wx67dNeDmW/XHwnmqXr16hf95oWSmp6dqRfaBMN4Gd7Z9nZGRltcCsG1QiHqHReRVoPogPUXXhEXq2ohDf+/PJO9TkBw2FFXL6bQVqUzlq7XubEU6HLo3qppc+XqILc/O1GspiTohKER1XS7bpnCfx6PfszO02+NRI6dLN4QfOn9mTo5eSEmQ+VfzfVHVFHGw6tHlYRFampWh6Rlp6hgcqjNDCrYBh+/86s7QRs+Bz9OOg9WqFrsztP7gtibOIHVyHQjZmYDVD+50G4A6Nyg87xw1HS6dHxSur7LT9Epmok5wBtvP2T+eLO2TR6c5Q9TiYJWsY7muCXx9mpUiE+G6Kjgy7zPaJyhc67OyNNOdrubOYDVy8jta4RaE3r8mAPi6AlaLOlE+mwsAAAAAAKg6uCN9mCZNmqhx48batGmTNmzYoJycHDmOcNd47dq1eesNGjTw4iwBAEBlYsJX777/YYFtppVg/naCuQGs4ox5ZbTatT1BY995V/97/U1FRUXaKlZPP/aImjdrWmj8gP5XqVZsrJ4ZOUrjJ31g/03T8eT2enj4fbbCVa59+/ZrwM2DFR4erg8njLPBq1ytW7XU6Bee1aA779agu+7RJ++9W4Y/CZQnE76alVmw0s/K7Cyt1KGqVr11IIB1JBeERui3rEytyMpUYo7Hlset7XTpktAIXR4eqVrOgg0FTfDq/NAIe+31mVlKzslRuMOhRq4g9Q2N1IVhEQrL929nU/lqoztb14VHqU3Qoc+V+SwOi6qmOxN26+WUBLVyBat2CVsdomKZENRvnsyC23LcdsmVG4QqzhmuMNWQU3PdGfrTk2mro8U5XOruiijy+NJc97PsVCUpx7YdNGGvXMEOh64KitLrWYn6OCtFQ0JiFEoCCACqnMIVsAhgAQAAAACAiufIMQmjAGZCVE2bHvhC8oYbbtCECROOesywYcP00ksv2fXvv/9e5557bpHjzjnnHP3000923QS28rckLIstW7bknWvz5s1HbYUIAEDASk3w9QwQgL5p1MbXU0AA+iMlw9dTQAAxrRufz0wo8++E+X+3XNC6qeoFF6w8VtG2Z2Wpyz/r7Tq/2wKViz/cmzKV5+Pj4+167dq15SpBWDvb7dHxj36nLPeh252f3tZFpx5Xs0LniqrjWD6XQEXiMwl/xOcS/obPJPyRv38u/eF3QqAyOtADBAUMHTpUYWFheWGsxMTEQmPee++9vPDVhRdeWG7hKwAAAAAAAAClt2lvaoHwlUEFLAAAAAAA4A0B14Jw3rx5WrNmTd7Pu3fvzls32w+vgDVw4MBC5zAtCJ944gkNHz5cy5Yt02mnnab7779fJ510kg1jff7553rjjTfs2JiYmLxqWQAAAAAAAAB8Y218SoGfa0aGqEbkoTbIAAAAAAAAFSXgAlhvv/223n333SL3zZ8/3y5HC2AZ9913n/bu3avnn39e//zzj2666aZCY+rUqaMvvvhCLVu2LKfZAwAAAABQ/hyOA4u3rwkA3rRmV3KBn1tQ/QoAAAAAAHgJLQiL8eyzz9rA1nXXXafjjjtOoaGhqlatmjp16qQnn3xSq1atUpcuXXw9TQAAAAAAAKDKWxtfMIDVvE6kz+YCAAAAAACqloCrgGVaDB7eZrAsTMCKkBUAAAAAoDJzmP94uSSVuSYA+LICVnMqYAEAAAAAAC+hAhYAAAAAAACASi0nJ6eIClgEsAAAAAAAgHcEXAUsAAAAAABQkCl+5eUCWF6/HoCqLT45Q0np2QW2taACFgAAAAAA8BIqYAEAAAAAAAAIqPaDYcFONage7rP5AAAAAACAqoUAFgAAAAAAAIBKbW18SoGfm9WKktNJKT4AAAAAAOAdtCAEAAAAACDQ+aAFobkmAHjL2sMqYDWvQ/tBAAAAAADgPVTAAgAAAAAAAFCprY0vGMBqUZsAFgAAAAAA8B4qYAEAAAAAEOAcToddvH1NAPCWNYUqYEX6bC4AAAAAAKDqoQIWAAAAAAAAgEorOSNb2xPSC2xrQQtCAAAAAADgRQSwAAAAAAAAAFRa6w5rP2gK8B0XSwUsAAAAAADgPbQgBAAAAAAgwDkcBxZvXxMAvGHtYQGsRjUjFBbs8tl8AAAAAABA1UMFLAAAAAAAAACV1ppdBQNYzWvTfhAAAAAAAHgXFbAAAAAAAAhwTofDLt6+JgB4w9pdKQV+blGHABYAAAAAAPAuKmABAAAAAAAACJgWhM1rR/psLgAAAAAAoGoigAUAAAAAAACgUsp2e7RhDxWwAAAAAACAb9GCEAAAAACAAGe6AXq7IyAdCAF4w6a9qcpy5xTY1rw2ASwAAAAAAOBdVMACAAAAAAAAUCmt2VWw/WCtqBBVjwjx2XwAAAAAAEDVRAUsAAAAAAACnMPhsIu3rwkAFW1tfMH2g82ofgUAAAAAAHyAClgAAAAAAAAAAqICVos6BLAAAAAAAID3EcACAAAAAAAAUCmtjS8YwGpOBSwAAAAAAOADtCAEAAAAACDAmWaA3u4ISANCABUtJydHaw+rgNW8dqTP5gMAAAAAAKouKmABAAAAAAAAqHTikzKUlJFdYBstCAEAAAAAgC9QAQsAAAAAgADncDjs4u1rAkBFSUrP0k//7CqwLTzYpfrVwn02JwAAAAAAUHURwAIAAAAAAABQKVoOLli3R5MWbNSMlTvl9uQU2B/scmjh+j3q0iyWECgAAAAAAPAqAlgAAAAAAAAA/NryrQkaNvl3rdqZfMQxienZuuatX9QqLkr/7ddBJzao5tU5AgAAAACAqsvp6wkAAAAAAIAK5jAtAb27mGtWpF27dumrr77So48+qj59+qhWrVp5rRYHDhxYsReXtH37dtWoUSPvmt27d6/wawJV1bw1u9VvzIJiw1f5mXFm/NzV8RU+NwAAAAAAAIMKWAAAAAAAoNKJi4vz6fWHDBmi/fv3+3QOQFXw965U3fHpKqVmukt1nBk/eNISTR7chUpYAAAAAACgwhHAAgAAAAAgwOVWafL2Nb2lcePGatOmjWbMmOGV602bNk2fffaZ6tSpYytxlYdNmzapov5sgMoqJydHT0xfX+rwVS5z3L8n/6Hvhp7l9f8NBAAAAAAAVQsBLAAAAAAAUOmY1oOdOnWyi6mGtWHDBjVt2rTCr5ucnKw777zTro8cOVLXX399uZy3IuZuAifZ2dnlfl7AW37bkqx1e9LLdI5/diZp4bq96tI8ttzmBQAAAAAAcDhnoS0AAAAAAAB+7vHHH9dFF13k9VaE//nPf7R582adc845uu6668q10k9FLEBl9tmf5VNh7r2FG8vlPAAAAAAAAEdCBSwAAAAAAAKcw3lg8fY1A82iRYv02muvKSQkRG+88Ua5nnv8+PHlej6gsktKz9bsNfvL5VzfrdihpPQsRYcFl8v5AAAAAAAADkcACwAAAAAA4ChMK79BgwbJ4/Ho/vvvV+vWrcv1/DfccEO5ng+o7HYkpstdTkXc3J4c7UxMJ4AFAAAAAAAqDAEsAAAAAAACnMPhsIu3rxlIRo4cqT///FMtWrSwbQgBVKzUjOxyPV9yhrtczwcAAAAAAJAfASwAAAAAAFChtm/fftQxDRs2lL9au3atnnjiCbtuWhCGhYX5ekpAwIsILd/bllGhrnI9HwAAAAAAQH4EsAAAAAAAQIU67bTTjjomJ6eceo1VgNtuu01paWm66qqr1KtXL19PB6gS6saEyeVQubQhDHI6FBdDcBIAAAAAAFQcAlgAAAAAAAQ6p1kc3r9mAJg4caJmzpypmJgYvfTSSz6diwmp/f777/rjjz+0e/duGwo7WnDt0Ucf9dr8gPIUHRaks1tU1w+r95f5XL3b1lV0WHC5zAsAAAAAAKAoBLAAAAAAAECFWrRokerVq6fKxoSc/v3vf9v1p59+2qfv4d1339Xjjz+ujRs3luo4AliozK44qU65BLAGdG5SLvMBAAAAAAA4EgJYAAAAAAAEPIfkcHj/mgeZ4FLDhg1V2QwbNsyGsE499VTdcccdPpvHQw89pOeee65EbRodDodft3MESuOUhlFqFhumdXvSj/kcreOi1blZzXKdFwAAAAAAwOEIYAEAAAAAABxm27ZtmjRpkl3v0aOHJk+eXOz4Xbt26aOPPrLrTZs21emnn14u8/jll1/07LPP2mDVeeedpxdffFEej0ennHKK3Zadna29e/dq8eLFeuONN/Tll1+qa9eu+uSTTxQXF1cucwB8xXzGH+3dVHd8ukqpme5SHx8R4tKofu3teQAAAAAAACoSASwAAAAAAAKcCR94O4BQ2QMPmZmZeesvvPDCUcf/9ddf6t+/v12/4YYbyi2AZUJVRpMmTfT1118rKChIK1asKPDnHBsbq969e9vFjL/zzjt1/vnn2/BWSEhIucwDx2bTpk0aN26c/bsz7SOTkpJUu3ZtHXfccTrnnHPUr18/nXjiiUc8/ttvv9XYsWP166+/Kj4+3h7bqVMn3XrrrerTp4+qgjZ1IvTGtSfr9veXliqEZcJXY67rqBMbVKvQ+QEAAAAAABgEsAAAAAAAAPzUzz//bENWd999tw1fHc3tt9+uH374QZ9//rlef/11DR061CvzRGGvvPKKHnzwQaWkpBTYvmXLFrvMmzdPiYmJGj16dKFjTZUzE7Iy4a38tm7dapcvvvhCt9xyi8aMGSOn06lA17VFLU0e3EXDJv+uVTuTS9R20FS+InwFAAAAAAAqZQArISFBn376qRYsWKAdO3YoNTVV48ePt09p5i/hv3//foWFhalZs2bleXkAAAAAAIByYSoU5eTklLjS19lnn62ffvqp3Oexfft2+9q2bdu8bfkDN1lZWQoODi5wzHXXXafPPvtMH3/8MQEsH3nqqaf0yCOP2PVWrVpp0KBBtnJVtWrVtGfPHi1dulRTpkw5YnjqoYceygtfnXzyyRo+fLiaN2+utWvX2ops5vi3337bVsR65plnVBWYMNX0od20cN1eTVq4QdNX7JTbc+i/o0FOh3q3rasBnZuoc7Oalb4KHwAAAAAAqKIBrFdffdXeHEpOPvAUmrlJaW50HP6Un7kZOWDAABvAMk/71axZs7ymAAAAAAAAiuJ0HFi8fU0/N2HCBN144412/bHHHtOIESPkb0zAyqhTp07etqioqLx105aufv36BY5p2LChfV2zZo3X5olDZs2alRe+uv76621Q6vCQXM+ePXXvvfcWaHWZa9WqVRo5cqRdP/XUUzVnzhyFh4fbn02Iq2/fvjbwt3jxYr344ou66aab1KJFC1UF5l5jl+axdklKz9LOxHQlZ7gVFepSXEyYosMK/jkDAAAAAABUqgCWuUlpnuwzoavQ0FC1a9fO3gQqytVXX21vMO3cudM+jWmeAAQAAAAAACgN074tf8Bo9+7deetmuwlX5Tdw4EBVRqbCkakmblrV5YqLi5PL5bJt6v76669CAazcqllJSUlen29VZ/5OTBtIo3379raKVXGtI0NCQgptMy0Js7Oz89oY5oavckVERNjtXbp0seNeeuklvfbaa6pqTNiKwBUAAAAAAPAXRdc5L4UlS5bY8JVhKluZ1oOLFi068gWdTv3rX/+yYa3vv/++rJcHAAAAAABHY1px+WKpQKaqkKlelbvcd999efvmz59fYF9ulavKKLf14N9//10gtJO73bQZPNykSZPs6+HBLFS8GTNmaPXq1Xb9/vvvLzZ8VRRzv2zq1Kl2vU2bNurcuXOR48z21q1b23UzviTtMgEAAAAAAODHASzTetDc5DFP3U2cOFHVqlU76jFmrLFs2bKyXh4AAAAAACBgnXXWWfa+y48//lhg+1VXXWW3v/POO7Yy+YoVK+wDcXfccYcmT55sW7X16dPHZ/Ouqj755BP7av78L7roorzte/futcEs81qc9evX24pnhmkzWJzc/Vu3btWGDRvKYfYAAAAAAADwWQvCOXPm2JtKd911V4mPOe644/JuEAEAAAAAAJSWaTF4eJvB0jJtCcvamrCiKw9deumleuSRR/TVV1/ZNoQxMTF2+z333KO33nrLBm9MZfLc6uS5atSooQcffFD+bO3atZo9e7atrr5u3TpbVT0lJUXBwcGqXr26GjdubCt9nX766erWrZtCQ0Pl7xYuXJh37ys6OloffPCBnn32WS1fvjxvTKtWrTRo0CANGTKk0HtauXJl3rqpgFWc/PtNK8qmTZuW4zsBAAAAAACAVwNY27dvt6+5Zc9LIiwszL5mZGSU9fIAAAAAAOAoHE6HXbx9TZSdCSCZ6lfZ2dl2yRUREWG3DxgwwLZczO/EE0+0bQgbNmwof2MCY+PHj9dHH32kNWvWHDHMZh72yw0z5d5L6t27t32/l1xyiVwul/yNx+PJaxVZq1YtG5J7+eWXC41btWqVbZk5ZcoUff311zZslmvLli1560f7+2vUqFHe+ubNm0s11/zXKe5+n+F2u+3ibeaa5s80dx3wB3wu4W/4TMIf8bmEv+EzCX/k759Lf5wTUCUCWCEhITZItX///hIfs3PnTvua/wYTAAAAAAAACjtSK7omTZpo7ty5+ueff2wLQhPQatmypU4++WT5m8WLF9sqXSZwZG4y5w9bmYpXNWvWtIup3JWWlmZb9e3bt89W/TLMtqlTp9qlfv36uvvuu3XnnXfaIJq/SEhIyLuBvmzZMv3666+qV6+eXnzxRV1wwQU2RGa23X///TZc9vPPP+umm27S559/nneOpKSkvPWoqKhirxcZGZm3npycXKq55g9vHc2ePXt8Un3M/FmaP9NcTqfT63MADsfnEv6GzyT8EZ9L+Bs+k/BH/v65NL8HAvBBAMuUgzc3+VavXq1zzjmnRMf88MMPpa6aBQDwY6mH/pEIlKf9vbr6egoIQMdVD/f1FBCAvtxbui++geIk60CAo1w5HAcWb/L29aowc3/FX++xmCpX9957r6ZNm5YXuoqNjdXFF1+szp0767TTTlO7du2OWNFq165dNrS0aNEizZo1SwsWLNDWrVv1wAMPaOTIkXriiSd066232opZvmbaJ+ZKT0/Pq1KW/+/GtFI098W6dOmiP/74w1bB+uWXX2ybxdzj8j/0WJz8oSgTUAMAAAAAAEAlDmD17NlTy5cv15tvvmlveB2NuUk2duxYe2OsV69eZb08AAAAAAAA/JRph5iZmWmrXF1xxRW65pprdP755ysoqGS3pOrUqaMLL7zQLo8//rg2btyoDz74QO+++65t5XfHHXfYSlkmkOVrpsJVfrfcckuRwbjw8HA9/fTTuuiii+zPH3/8cV4AK/85zJ9bcUxF+vznLI2jtSw0LQhNOC43MFe7dm35suWFaenoj20nUfXwuYS/4TMJf8TnEv6GzyT8kb9/LvP/vgnAiwGsu+66S6+//rp9au/JJ5/UI488csSxpiT+lVdeacvpmTLpgwcPLuvlAQAAAAAA4KdM1Stz/+fBBx+0VdTLyrRdNOcygauPPvpIzzzzzFGDSt4SHR1d4OfiHjw0DzSaEJppG2kqfBV1jqO1Fcxfceto7QoP17BhwxKPNV8E+OrLgNw2HL6cA3A4PpfwN3wm4Y/4XMLf8JmEP/Lnz6W/zQeoMgGs5s2b26f2hg8frhEjRujrr7/W5Zdfnrf/k08+sU85zp8/XzNmzLD9TE31q9GjR/vk6TkAAAAAAKoa83u4w+ndFm3+0BKuMpk4cWLe+vXXX1/k9mOR/1y+sG7dOjVo0KBCPl/9+/e3i6nW5A9MS0Bzrys+Pt7+3KhRoyOONZWuzFPOO3bsyBt/eDBqy5YtJa5iVdy1AAAAAAAAUAkCWMa9995rn2h8+OGHtWjRIvvkXu6N1ieeeCJvnBlj0pIjR47UzTffXB6XBgAAAAAAqPQGDhx4ICjncBQITeVuPxaHn8sXKiJ8dbh69erJX7Rt21Y//fRToZYSRcndn78d4wknnJC3/vfffxd7fP79xx9//DHPGQAAAAAAAGV3oK5dObjvvvv0+++/68Ybb7RP8JmwVf4lJibGPpW4dOlS3XPPPeV1WQAAAAAAcDQmwOOLBaWSew/lSNuPZYF3devWrUD1ryNJTEzU7t27C4XUmjZtqvr169v12bNnF3utOXPm5B1/3HHHlXnuAAAAAAAA8HEFrPxP240bN86ub9q0Sbt27bJP88XGxqpZs2Z5fUwBAAAAAABwyPr160u1Hf7piiuuyKsGP2XKFPtzUcy+3IDcWWedVaBq2SWXXKI33njDVrhauHChOnfuXOh4sz23ApYZT8tPAAAAAACAAApg5de4cWO7AAAAAAAAoHhNmjQp1fZA9sEHH2jChAm20npCQoKtqt6hQwfdcMMNGjBggPzZSSedpD59+ujbb7/Vhx9+aCvF9+zZs8CYHTt26OGHH7brISEhdkx+Q4cO1dixY+1DjUOGDLGVrsLDw/P2p6Wl2e257QvNeAAAAAAAAPgWJakAAAAAAKgKv/07HV5efP2mUdlkZWXp0ksv1XXXXaeZM2faFn1m2549ezRr1iwbwOrbt6/d5s9Gjx6t6tWry+Px6KKLLtKDDz6ouXPnavHixXr99dfVqVMnbdmyxY598sknC7QgNFq1aqX77rvPrptjzjzzTH388cd23byan826Yca1bNnSB+8SAAAAAAAA+ZX5dqjL5bKLaTG4bNmyEh2zYsUK247QPKUHAAAAAACAot100026+eabtX379hIfEx8fn3dcZfLiiy/qyy+/VJ06dTRy5EgtWLBAf/31l2bMmGHDV6Zl39dff60XXnhB/swEqKZNm6a4uDilp6frueeeU7du3Wzw6s4777ThK9My0FTBGj58eJHnePrpp+3fobF06VJdffXV9njzan42zN/vU0895dX3BgAAAAAAgAoKYJmbX2bZsGGDfQJv6tSppToWAAAAAABULBP28MWCsjOt+Myyb9++Eh+TmJiYd1xl8u6779qH9X766ScNGzZMp59+ulq3bq1zzz1X48ePt9WezL2kiRMnyt917drVPoD42GOPqX379raNYlhYmJo2bWpbDi5ZssRWvzoS8+DiuHHjbODskksuUf369W27QvNqfv7mm2/09ttv23EAAAAAAADwvXK5S2NuqgYHBys5OVlXXHGFnnnmmfI4LQAAAAAAACo5E0LKyMg46riNGzfadnomdFUU054wd1xlEBsbqxEjRuj3339XQkKC0tLStG7dOr3zzjs6+eSTS3SOCy64QF988YW2bt1q/wzNq/m5T58+FT5/AAAAAAAAlFy5PSb30Ucf2ZtkHo9HjzzyiK699toS3VwDAAAAAABA+TFt74zQ0FD5A1PpqW3btvrqq6+OGlgy4aqUlJQi9//555/2tWbNmhUyTwAAAAAAAMDnASzzdOKiRYvUs2dPWw7eBLLOPvtsbd++vbwuAQAAAAAAjoXT4ZsFPjF//nz7GhcXJ3/wr3/9y1Z+Mq3z+vbta9ePVO0pNTVVF154of7444+87VlZWZo0aZJtQWiqsF988cVenD0AAAAAAABwdEEqR9WqVdN3332ne+65R6+//rp+/fVXnXbaaZo6dapOOeWU8rwUAAAAAABAwHniiSeK3G7us9SpU6fYY00l8rVr1+rLL7+0QaUzzzxT/uDjjz/WoEGDNGTIEFsFa+bMmRo+fLgefPDBAlW6nnrqKX3//feaM2eOvY8UHh6umJgYxcfH24rr5oG/44477oh/RgAAAAAAAEBABLAMl8ulV199VSeeeKLuvvtubd26VWeddZbGjx+vfv36lfflAAAAAADA0TgcBxZvXxOlNmLECBueys8Ej954440Sn8OMDwsLsxWj/MW5556rZcuWaeTIkXr66adtW0JT1Wr06NF5Fa1MxS5TXf3++++3oS1TDcsshnk/V199tZ577rmjBtEAAAAAAACAStuC8HC33Xabpk+frpo1ayotLU39+/fXo48+WlGXAwAAAAAACAgmQJW7mDCWWfJvO9JiqkmZClHXXnutFixYoPbt28ufBAUF6YEHHtBff/2lyy67TOvXr9ell15qA1i5bQlNuMo8xJeQkKA///xTc+fOta/m53feeYfwFQAAAAAAAKpWAMs455xztHDhQrVu3dreCDRPOF555ZVKSUmpyMsCAAAAAABUSqbVXv7F3E8xli9fXmjf4YupFmVaEJrKUv4WvsqvYcOG+vTTT/Xdd9+pRYsW+vrrr20ldVP9y7RRNIKDg+0200bRvJqfAQAAAAAAgCoZwDLMjbRffvlFvXv3tjcNp0yZossvv7yiLwsAAAAAAPJ3IHR6eaEDYblo3LixXUJCQhRoevXqZYNlTz31lJxOp21LeMIJJ2jatGm+nhoAAAAAAADgXwEsIyYmxj7NePfdd9sQ1vbt271xWQAAAAAAgEptw4YNtlWfecAtEJnKVv/5z39sW8JLLrkkry3hRRddlNeWEAAAAAAAAAj4AFZJn8Q0TzKOHj1aY8aMUVBQUFkvCwAAAAAASlUCywcLUISUlBT7cJ55zdWoUSN9/vnn+uabb9SsWTP7aloPPvbYY3ltCQEAAAAAAICADWCV9knMQYMGadmyZfrxxx/1ww8/lPXyAAAAAAAA8HNZWVl69tln1apVK1spvWHDhvbV/PzMM88oMzPTjjv//PO1YsUKPf7443I4HLY9oWlL+OWXX/r6LQAAAAAAAABH5JNSVObmmlkAAAAAAIAXOB1yOL1ckcrb16vkevToYV9N6GjWrFmFth+Lw8/lK6mpqTrvvPO0cOFC5eTkFNi3Zs0aPfLII5o2bZqda0REhK2ybrZdf/31uvvuu+2+yy67TH369NHLL79sK2QBAAAAAAAA/oRegAAAAAAAAD72008/5YWmDt9uth0eXCpO7vjDz+UrTz/9tBYsWKDg4GBb2ap///6qW7euduzYoQ8//FAjRozQokWL7Diz5GrSpImmTp1q2xGaIJZ5NdXU77vvPnseAAAAAAAAwF8QwAIAAAAAAPCxbt26FRmYOtL2yuTjjz+27+GJJ57Q/fffXyBg9cADD8jpdNrXjz76qEAAK9cFF1ygnj176rnnnrOLaUtIAAsAAAAAAACVMoCVW97d3DBbu3Ztoe3H4vBzAQAAAACACmACPN4O8VTy0JCvKmCVdHtlsmXLFvvavXv3IvefffbZ9nXr1q1HPEdoaKgee+wx25bwnnvuqaCZAgAAAAAAABUcwNqwYYN9Pfypy9ztx6KyP8EJAAAAAACA4tWqVUvbt2/XH3/8odNPP73Q/j///NO+xsbGHvVcTZs21Zdfflkh8wQAAAAAAAAqPIB1ww03lGo7AAAAAADwE07HgcXb1wQkXXTRRRo7dqyGDx+u6tWr68orr7RtB3NycjRlyhTbltA8pHfxxRf7eqoAAAAAAABAxQawxo8fX6rtAAAAAAAAwJNPPqkZM2bYKur9+/fXddddZ6ti7d69W9nZ2TaI1bhxYz3++OO+nioAAAAAAABQsQEsAAAAAAAA+FZSUpLWr19vX91u91HHd+vWTb5Wu3ZtLVq0yFa6+uijj5SWlmZbEhphYWHq16+fnn/+ecXFxfl6qgAAAAAAAMAxIYAFAAAAAECAM+3dzOLta6L8vPXWW3r99de1bNkyWzGqpH8HpsKUPzAVr8aNG6c333xT//zzjxISElStWjW1atVKISEhvp4eAAAAAAAA4P8BrIyMDM2bN8+Wlm/atKlOO+00b1wWAAAAAACgUjNVrq644gpNmzbN/lzS8JW/Cg4O1oknnujraQAAAAAAAAD+FcDauHGjXnvtNbv+n//8R9WrVy+wf+HChbryyivzSssbJ598sj777DM1adKkrJcHAAAAAABH4zSLw/vXRJmZilFffvmlXTct+m688UZ17NhRNWvWlNPJHzIAAAAAAAAQEAGszz//XCNHjlSHDh30wgsvFNiXmJioSy+9VPHx8QWe0Pztt9904YUXaunSpfbJRwAAAAAAABQ2ceJE+3rCCSdo7ty5qlGjhq+nBAAAAAAAAOAwZX5U8vvvv5fD4dAll1xSaN/YsWO1a9cuu3733Xdr6tSpuuOOO+zPf/31l959992yXh4AAAAAACBgmfsn5r7LI488UinDV+3bt7cP71WErVu36q677ir0QCAAAAAAAABQ6QJY69ats6+nnnpqoX2TJ0+2Nwkvv/xyjR49WhdffLFeffVV/etf/7IVsUwbQgAAAAAAUNEcksPLi7kmyk3r1q1VGS1btszeBzrppJM0fvx4Wy29rBYtWqTBgwerRYsWeuONN5Senl4ucwUAAAAAAAB8FsAy7QWNevXqFdiekJBgWw0aAwcOLLDv6quvtq9//PFHWS8PAAAAAAAQsFq2bGlf9+7dq8ro7bffVu3atbV8+XLdcsstqlu3rvr166ePPvpIGzZsKNE5UlJSNHv2bD366KP2z6NLly72vFlZWbr22mt18803V/j7AAAAAAAAAIoTpDJKSkqyr263u8D2n3/+WR6PR0FBQerevXuBfY0aNarUNw8BAAAAAKhMTHVqs3j7mig78xDb0qVL9dVXX6lHjx6qbG666SZdddVV+t///qeXXnpJe/bssRXRc6uix8bGqkOHDqpTp45tsWiWtLQ0e89o3759WrVqlf755x97j8kwFdWNPn366Nlnn7WVtQAAAAAAAIBKH8CqXr26vXm2bdu2Att/+ukn+2puokVGRhZ5bFhYWFkvDwAAAAAAELDuvvtuffDBB7bV3mWXXaazzjpLlY25L/Sf//xHw4YN06RJk/TOO+/ol19+sft2796tWbNmHfHY3MCVYSppXX/99Ro0aJBatWrllbkDAAAAAAAAXmlB2LZtW/s6ZcqUvG2mGtbkyZPt066HV78ytm7dal/j4uLKenkAAAAAAICAFRoaqunTp6tjx44677zzNHz4cP3+++9KT09XZWMexDPhqQULFtj2gxMmTLDtA9u0aaOoqCgbtspdXC6XvW9k3vMTTzyhH3/8UVu2bNGLL75I+AoAAAAAAACBVwHLPH05e/Zs+wSjuTFmnsQ06xs3brQBrH79+hU6ZvHixQVaEQIAAAAAgArkdBxYvH1NlJkJIuUywaRRo0bZpSTMfZns7Gz5o8aNG9tqVmbJlZmZaVsPmqCWqbgOAAAAAAAAVJkKWIMHD9bxxx9vbwKOHDlSl1xyiT799FO77+KLL9app55a6BhTLcvcBOzcuXNZLw8AAAAAABCw8leFOvznkiyVSUhIiOrWrUv4CgAAAAAAAFWvApYphT9r1izdddddmjZtmrKysuwNs6uuukqvvvpqofFz5szRypUrbQCrd+/eZb08AAAAAAA4CvM7uFm8fU2U3WOPPebrKQAAAAAAAACo6ACWYZ5ONFWvMjIybKn42NhYG8Iqimk7+OOPP9r1rl27lsflAQAAAAAAAhIBLAAAAAAAAKCKBLDyV8OqV69esWOaNm1qlyOJj4/XG2+8YdcfffTR8pweAAAAAAAAAAAAAAAAAPhvAKs87Nq1SyNGjLCtCghgAQAAAABQDpyOA4u3rwkAAAAAAAAAVYDT1xMAAAAAAAAAAAAAAAAAgMrK7ypgAQAAAACAcuZwHFi8fU2U2MSJE/PWr7/++iK3H4v85wIAAAAAAABQMQhgAQAAAAAA+NjAgQPlcDjskj80lbv9WBx+LgAAAAAAAAAVgxaExcjMzNTbb7+t3r17q169egoNDVVUVJRat26tG2+8UT///LOvpwgAAAAAAAJETk6OXY60/VgWAAAAAAAAABWPClhHsHHjRl144YVasWJFoVDWqlWr7DJhwgQNGTJE//vf/475aVQAAAAAACqarazk9O7vrfyeXDrr168v1XYAAAAAAAAA/oMAVhGysrIKhK9OOukkDRs2zFa+SkpK0rx58zRq1CilpKTolVdeUf369fXAAw/4etoAgHLw3ocfa+7PC7Rk6e9atmKlDd6Of/M1Dbzu2lKdx+Px6LUxb2nsO+9qzbp1ioqK1Lndu+vpEY+oWdPjijxm+vez9MzIUfrt9z/tF5YdT26vh4ffp57nnF1O7w6+8vGu/VqQmKI/ktO0MjVDmTk5eq1FA10TV+OYz5np8ajnn+u0PCVdLcNDtOiUVkWO+y0pVc9u3qVFianKzsnRCRFhuqNBLV1Wq1oZ3hH8wbSkZC1JT9fKjAytysxUlqSnatfSZdHRx3xO89m8eus2/ZOZqabBwfqqUcMjjp2ZkqKPEhO1MiNTaTk5qu1y6aTQUP07tqbqBfFrRmW1SlnaIbfi5dFeeeSR1F2haq3gUp8rUzn6Q5laL7eS5LHll2PkVBMF6VSFFBj7vlKUrKIr9dSTU30VcczvCagsmjRpUqrtAAAAAAAAAPwH34wUYerUqXnhqy5dumju3LlyuVx5+8877zz17dvX7jNhreeff1733nuvgviiCQAqvYefeEobN21WrVqxqlc3zq4fi8FDhurtCRPV9vjjdfftg7Vt+3ZN/vwLzfjhBy38caZatmheKPh13S2DVbtWLQ0c0N9u+/jTKTrv4ks1edIEXXnZJeXy/uAbT2/aqc0ZWYoNcikuJMiul9Xzm+O1Pi2z2DFz9yfripUbFeZ06PJa1RTlcurLPYm66Z/N2pqRpbsa1CrzPOA7L+/bp23Z2arhdKp2UJBdL6s39u3TpqziP5+mndXju/fok6QkNQoKUp+oSEU6nIp3u/VrepqdBwGsyutXZdogVJikCDmOGIo6GhO4+kppSlSOGsqlxgqWW1KiPFqv7EIBLMNsaVdE0CvaRrdQZqYalbcrUlEBCwAAAAAAAEAVwTcjRfj555/z1h988MEC4atcHTt21EUXXaQpU6Zo//79+uuvv9SuXTsvzxQAUN7efu0VtWzRTE0aN9ZzI1/Sg489Xupz/Dh7jg1fdet6hr6f9oVCQg58yXxNv3/pgsv/pbuG3afpX36eN37fvv0acu9wG/r67efZatiggd1+/7ChOvmMbrp96DD1PreHostQ1Qa+9XKLBmoWFqLGYSF6aUu8nti4s0znW5KUqv9tidezzepp+LrtRY4x1a7uWbvNxha+PrGp2kWF2+33Naqjc/9Yqyc37lTf2Bg7J1ROT9SqpSbBQaofHKy39u/X6L37ynS+P9MzNG5/gh6IjdXTe/Yccdx7iYk2fHV1TLT+Exsr12EBC/PZQ+V1tkJVTU4belqqTC1S8UHPoniUo++VrlTl6CKFqcFhv3aa/UUJkUOnKvSY5w4AAAAAAAAAgK/wKHERTLupXM2aNTviuObNmxd5DACg8jq3R3cbviqLt8ZPtK9PPvJQXvjK6NP7PHXv1lUzZv2gTZsPVdb6ZMoX2r8/QUNuuzUvfGWY9bsGD9Lu3Xs05cuv8rbfdvf/yRFZ3QbEDpe77/lRo8v0HlC+ulePKregU7rHoztWb1XnmAjdUrfmEcfN2Z+s9emZurJ2tbzwlVEtyKVhjWrbVnMf7dqft90Ew2rMX67/W7O10Lly9w1bu61c3gPKR5eIcBu+Kg8ZHo8eio/XKWFh6h8TXezn7/V9+23lqweLCF8ZQfm2fZOcrLbr1uu27Tts5az8itsH32mooDJXnFqnbNvC8CQFFwpfGU6VrSqSaZE4Vsn6VKlyHxbmKm4fAN8wD7WV90IFcgAAAAAAAPgbAlhFaN26dd76unXrjjhu7dq19tXhcKhly5ZemRsAwP/9NHeeIiMjdWaXzoX29e7Z077Onjv/0Pg58+xrr549Co8/9+D4eYfGv/T8Mzq+TWs9+tQz+nXJb3nbp3w5TWPGjVePs7vpvv+7u5zfFfyFqVy1JSNTr7RoYP8NciTzElPs6znVowrt63Fw2/yDY4x7GtRSt2qRmrBzn77ek1ig2tazm3apTXionj6ubjm/G/iL0fv2aXt2tp6oXavYz9XPaWlK9HjUIzJCHknfp6TY6lsfJyZqYxGtCy+IitIlUVGam5amSYmHPldbs7L0xO49inW59HSd2sVeE5XPWh1oh9lMQUqWRyuVZatpme1ZxYSizGfqH2XpN2VquTK10zYtLKyuXDpFwdojjxbmq9CVoRzNUrpM/eKeCpOrjEGvgPzt3+nw8uLrNw1/YEK2FbEAAAAAAAAA/oRHBovQv39/Pfzww0pMTNTzzz+vCy64oFAbwqVLl+rrr7+269dcc41iYmJ8NFsAgD9JSUnR9h07dOIJJxTZwta0NzRWHwzx5l9vma+yYt74g9vyjw8PD9eH49/W6d3PVf+BN+v3BXO1PyFBt9x5t2Jja2rSuDFyOvnGMxDNT0jRm9v26OmmddU0vPg2XevSDoQSmhcxLi4kWFFOp9YeHGM4HQ690bKhzvp9jYas2aqTo8IV7XJq0Kot9vvzt1o3UriLz1UgWpyWpvcSEjU8tqYaH6Wi1oqMzLwKRpdt2aoN+UJX5tNxfbUY3RcbW+CYh2rFaml6ul7au0+dwsLUKiREw3fFK9nj0Zt142wIC4Flt41SSdvltgGp/DGqMDl0nkJVv4hfRU3Lwp+UUWBbbTltmMq0RczvFIVoq9xariw1kkuNFaQ5ylCycnSWQlWD5A/gNx577DFfTwEAAAAAAACocASwilCrVi1NmjTJBrHmz5+vTp06aejQoWrVqpWSk5PttlGjRtm2g6eccopdL40tW7YUu3/79u1lfAcAAF9JOFjhpVq1ooO5MdEHtickJJbomJiDrcDyjzfan9ROzz85QkOHP6jb7xmmLdu2ae/efZo6+QPVr1evHN8R/EWK26O71mxRp+gI3VqvYMClKInuA5GHmCOEpqKDnHljctUPDbaVta79e5MGr9qi+qFBto3hc03r6cTIsHJ6J/AnqR6PHo7frfahobq2BA8U7D34mZmYkKDjQ0P0Uf36ahYSrL8zMjVi925NSEhUo+BgXZ3vXJFOp16Mq6Nrt26zwauzIyL0e0aGDWt1jYio0PcH30g7WOXqZ2WqvYLVVsG2GtVaZWmBMjVd6eqnCEXmC0m1VrDqyamacipIDiXIoz+VpdXK1ldK078UoZB8Fa1MCLCHwmyrQRPaaiePbX3YVC6doPJpzRloTKU5b1ebo7odDAJYAAAAAAAAqAr8LoAVEhKixo0b+7xyR9++fbVkyRIbrho3bpxuuOGGAvvj4uL05JNPatCgQYoo5RdHjRo1KufZAgCqorvvuE3TZ/6g9z6abH++fdDN6nvhBb6eFirIIxt2aEdmtj454ThbraqiXBAboxvr1tT4HXvtz+fViNLg+kcPfKFyGrlnr3a53Xqzbt0Sfa4O1DWSgh0OvRIXpzpBB36d6Bgepv/G1dHlW7Zqwv6EAgEs48TQUA2pWcNWwVqXkKA2ISH6v5o1K+Q9wfdyG4M1kUun61AVvhMVYitU/aEs/aNsW8Uq16n51o1acqmHbSaYbkNYfytLJx02JlpOW+1qljK0SJmKlEPdRFgUAAAAAAAAAOB9fteXoWXLltqwYYPWrVvn03mY6lYTJ07U1KlTlZOT+xXCITt37tR7772nmTNn+mR+AAD/VO1g6ODwilW5EpMKV7sq7pjExKRC4/NXlbj04gvzfh5y261lnj/807yEZBuI+k/jOLU4SuvBXDEH27olunMjMwUlZXvyxhzuopoHKq8Zg0pQbQuV06K0NH2clKQhNWrouJCSVQyKPviQRNvQkLzwVa6WISFqGBSkzdnZhaqrGT0iIvJ++fhXTLRCqIwTsHJjUk2KeN7nuIPb4gs0Jjyy3GpWO44wvoGC8q7XQkG2xSGOwOnwzQIAAAAAAAAAVYDfBbD8QUpKis4991w9++yz2rt3r4YPH66//vpLGRkZSkhI0IwZM9S1a1ctXrxYl156qf773/+W6vybN28udlm0aFGFvTcAQMWKjIxUvbp1tX7jRrmLCCCsXnMgYNyyefO8bbnrq9euLTz+4Lb843Ot37BB9z30qGrWrGHDWLfceXeR10Tltywl3b4+umGHasxfXmAxVqdl2vUmC1fmHdMs/EAkYW1aRqHz7czMUrLHo+YHx+SXkO3WPWu32bZxYU6H7l+3XUnZfK4C0d+ZmfZ15N69artufYHFWJ+VZdc7b9iYd8xxwQfCMNHOosN70QdbXmYc9gBDVk6OHtgVb9djnE69vHefdmRnV9A7g69VP/hrZv6Wgbly/1enpH/7uYGqrCPsn610mU+yqXu1TFnaXcJgFwAAAAAAAAAAftmC0ASUxo4dq7lz59rqVUlJSfJ4iq64kMt8WZzth1+8jBgxwr4P4/D2g6ZF4nnnnadzzjlHvXr10o8//qj77rtPPXv2VPv27Ut0/oYNG1bY3AEAvnd21zP10aefaf6CherW9cwC+6bPmmVfu3U949D4s87Uh598qhmzflDn0zoVHD9zVt458zP///Pam261//92xpdT9N33MzXq5Vf1+DPP6YlHHqrAdwdfOD4iTNfVqVHkvkm79inG5dQlsdUU7joUdjgzJlIvabd+3J+sK2pXL3DMD/uT88YcbuiardqSkaWXW9RXmifHBrDuW7ddb7bi3y+BpmVwiK6Ijipy32dJybbaVa/ICIU5Dj2zcVr4gfZu6w6Gtw4PWW3Oyla4w6Eah1VX+9/efVqRmanB1avrpNBQ3blzpw1kvVOvZK0PUbnUl0s75NH+vKaVh+w72KAwuoSVqnYdDFQVNX65MrVRbrVUkNopWF8oTbOUrssVoWAqYaGS+uOPP0p8b6GymDNnToWct1u3bhVyXgAAAAAAAMBnASxTAerBBx+0XwYX1a6vMjHzf+edd+x6q1atCoSv8gsKCtKTTz5pK2GZoNmECRP00ksveXm2AABf2r17j3bv2aNasbGqVetQm7Zbb7rBBrAeefJpfT/tCxveNb6d/r1+mjNPvXr2UJPGjfPG97v8Mt3/yGN65c2xuun6AWrYoIHdvmXrVr065i177sv6XlTg2iZoteCXRbr3niE6t0d3G+j6cc5cPfPif3Vej3N01pmHAl6oXPZkZWtPlluxwS7FBh/4p1r36lF2OVIAKy4kSC+3PPC5yXV29SgdFxasT+MTNLherNpFhedVuPrv5njb/u3qOgWDWZN27tUXexJ1aWyMrourabf9sC9ZH8fvV88aUfrXYUEuVB773G67mGBUbjiqS0S4XY4UwKrlcumJ2rULbG8cHKwzwsP1c1qaPk1M0pUxh9pVvr1/vxI9Hl0cFamgfKGqn1PTNCEhQe1DQ3VHjep2X/+YaH2YmKS39yfo1hp8riqrNOUoXTm2SlV4vsBTawXrD2VpubLUWkGKPFgRK1M5WmrrVUnN8v0quk8eRclRKDRltv9ycHyLg60Ic+2VWwuVqRg51FWhttrWaQqx235Whs62NbFQgPnvpbcDjwQsS+2UU05Ro0aNdOGFF+riiy9Wjx498v4tWVl1797dPoBXnvz1gT4AAAAAAABUXWUOYH333Xe69957826Ade7cWR07dlTNmjXldFa+Doc7d+60bQeNk08+udix5n3m+vvvvyt8bgCAivf2hIma9/MCu75sxYF2bm+/O0k/zZ1n17ue0UW3DLzerr86Zqwef+Z5Pfaf+zXioQfzznHO2d3sGHOuU844Wxee30vbd+zQx59Nse0CXxn1QoFr1qhRXa+OelHX3TLYjr/qysvs9o8/naI9e/bq44njFR19KOQwZ958G7Q6pUN7PT3iEbvNfDH3wfi31bFrdw24+Vb9sXCeqlcn1OAvJu7Yq4VJqXZ95cF2ghN37tO8xBS73jk6QtfXPRB4emv7Hj2/OV73N6qtBxrHHfM1Tcjl5eYNdMXKjbpw+XpdXquaolxOfbknUZszsvTkcXXVOOzQF7pr0jL04LodahASrNEtDoW5Xm3ZQF2XrtG/127TadERapLvGPiWCUD9ln7g87T6YEWqzxKT9GvagW2nhIXlBaQ+SEjU6/v3647q1XVnzaKrqZXUI7ViNWDbNj22e7d+SE1R0+Bg/ZWRqV/S01U/KEj/rnngs2yY0Nd/4uMV6XDohTq184JZ99WsqcVp6Xpt3z51Dg/TSWGEZfzFX8rSjoNVp/YerGD1t7K07eC2unLp+INhqBXK1BJlqaOCdapC884RI6c6K0TzlalPlarjFCSXHNqkbCUpR8crSA3z/Sq6Vln6U1mqJ5ei5LRnT5BHm+S2M+igYFtVK1e2cjRLGbaWVg+F5bU6PEnB2iK3/la2Gim7QMgLqEwPhW3atElvvvmmXSIiInTuuefaMJYJZcXFHfu/DXypsj+sBwAAAAAAABxNme9Ijx492r7WqFFDX375pc48s2CLpMrGVLbKdbSnKbOysoo8DgBQeZnw1bvvf1hgm2klaJZcuQGs4ox5ZbTatT1BY995V/97/U1FRUXaKlZPP/aImjdrWmj8gP5X2Upaz4wcpfGTPrCh5o4nt9fDw++zFa5y7du3XwNuHqzw8HB9OGFcgYoIrVu11OgXntWgO+/WoLvu0SfvvVuGPwmUJxO++nDX/gLbfklKtUuu3ABWeTqrepS+bddUz27apc93Jyg7J0cnRIRpRJO6urx2tbxxmR6Pbvlns9I8Hn3cqomqBR0KOtQKDtIbrRrqihUbNGjVZn3TrlmB6kbwHRO+mpp8oJ1krqUZGXbJlb9CVXkxVbA+btBAr+7dp3lpaZqfmmarZZmqVrfXqKHYfO0HH4qPV7zbredr11bD4EMVjEKdTr0YV0dXbd2m4bvi9VnDBoqshA9vBCITvlqlgr8HmXaCZsmVG8AqzokKsWGqP5Sptcq2R9eQUycrpNDx9RVkWxPukdte31zdVNVqLJdOULAaHfZrq6lyZcJhnRSiuHzBLIcc6q5QG/qao3TVUYSdAw6iAlalsGXLFn311VeaNm2aZs2apZSUFE2dOtXeb7H/PuzY0YaxzFJZWhX++OOPvp4CAAAAAAAAUOEcOWV8DLFWrVrat2+fbUN4zz33qLIz7QRNmCwxMVH169fXxo0bjxiuMjdFzU1PY8iQIXr55ZfL7YaraTlgbN68WQ0bNiyX8wJAhUlN8PUMEKD29+rq6ykgAG3bfqDyGFCeXl4X7+spIIAky6P3lVrm3wnz/265/sZz1fBgO1pv2ZKcpqbjZ9p1frctvbS0NM2cOdPeezDL9u3b7fbcdn7mzzO3VWHPnj0rfatC+Bd/uDfldrsVH3/g/7/Wrl1brnwhb8BX+FzC3/CZhD/icwl/w2cS/sjfP5f+8DshUBmV+XHg1NQDN4W7dg2ML0hN20RzA9PYtm2bnn766SLHmdDZ/fffn/fzRRdd5LU5AgAAAACAwGYqnppw1ZgxY7R161b9+uuvevTRR3XyySfbln7mBqjZZ+5HxMbG6rLLLtM777yjnTt3+nrqAAAAAAAAQJVT5gBWgwYN7GtmZqYChbmhGRERYddHjBihvn376rPPPtPSpUu1YMECvfTSS+rQoYNWrlxpx5gnTXv16uXjWQMAAAAAcCQHWxB6czHXRLkx7QfNPYrFixfbJ1HffPNNXXDBBQoLC8trVTho0CB7n+b000/XU089pT/++MPX0wYAAAAAAACqhDIHsHJb8M2fP1+Bok2bNvbGpWmvaEybNk1XXnmlTjnlFJ1xxhkaNmyYNm3aZPf16NFDn3zyiY9nDAAAAAAAqor69evr1ltvtfcr9uzZoy+//NKGr+rWrSuPx2OrZT322GP2Pkbjxo115513atmyZb6eNgAAAAAAABCwgsp6gnvvvVeTJk3SqFGjNGDAAHuzLxCce+65+vvvvzVu3Dh9++23WrFihfbv36+goCD7Hjt16qRrrrnGVsdy2Cd7AQAAAADwU07ngcXb10SFMxWwTBtCsxhLlizRV199ZcNZv/32W161rLi4/2fvPsC7qs4GgL8ZBELYBBAEFBH3XnUVFanWLbZ1r6p11DrqV7XWqlir1dZVrbOouPeoq3UrgnvWUReyhxA2YYSM77k3Ehlhhez8fs9zn3ty77n3nH84grl57/t2iU033TTqo1mzZsWLL76YZuwqKCiIuXPnpmUWlyV5DpM8rwEAAACARhOAlbx1mWSLOvDAA9PsUP/4xz/SFPiNQceOHeOcc85JNwAAAICGUKow2ZIMWOPHj08DsZ555plo2bJl1DdJtq5LLrkkfakvKaO4MpLALAFYAAAAADTYAKyk1N7ydOjQIb766qu0JGG7du2iT58+K3y4lzwwe+mll1Z+tgAAAACs9EtzJ510UrrVR8cee2zce++9aVBVVlZW+iLcpEmT0udF3bt3j2nTpsXs2bPTvsmx/Pz8ehlIBgAAAAArHYD16quvpg+7lpUCfmEZvuR88oDsnXfeWea9Ft5H6T4AAACoBcnP37X9M7if+VmO5557Lu6555702VASiJVkwRo3blxsttlm6flRo0al+y+//DJuuummuOGGG6J9+/bxxBNPxAYbbFDHswcAAACAKgZg9e3bV8AUAAAAUC8kmZKSl7+S7d133023KVOmpOeOOeaYGDx4cLWM895778Vrr72W3v/zzz+PyZMnx9SpUyMnJyfNMLX99tunAUS77bZbtYzXVNxxxx3pfuONN47bb789bSclE5e0/vrrx7XXXhu77757HHTQQbH33nvHhx9+GG3btq31OQMAAABAtWTAAgAAABqg5H2qWs+AVbO379KlS9SGM888M4YNG7bU8aKiovjqq6/S7a677opf/OIX6b5Fixa1Mq+G7q233kpf9Dv11FNXqv9+++2XBtYlgVvXXXddXHDBBTU+RwAAAABYWZkr3RMAAACgHurZs2fsscceNXLv5s2bxy677BLnnXdeGmD1wgsvxPvvvx//+c9/4oorrohevXql/R5++OE0ExYrn8Essd5661Ucy8rKqmjPnz9/qWt+/vOfR1lZWTz++OO1NEsAAAAAqOYMWAAAAAD1xYUXXhjbbrttuiXZsEaOHFkRDFWdnnvuucjOrvzxyZ577hmnnXZa9OvXL83o9OCDD8Yf/vCH2Gyzzap9Ho1Vhw4dKtqtW7deLECrR48ei/Xt3Llzuk/+rAEAAACgPpEBCwAAABq7pPxgXWw16OKLL4599923xksRLiv4aqHc3Nw444wzKr5+/fXXa3Q+jcXCP7epU6cudiwnJydt//e//13qmlGjRqX7efPm1do8AQAAAKBWArDeeOONNEV88sBx3LhxK+yf9GnRokX6ADNJ2Q8AAADQkC2auUlw0MrZdNNN0/3nn39ecSx5VrTlllum7TvuuGOpa2666aZ0v9Zaa9XaPAEAAACgVgKwHnjggSgrK0vfOl1zzTVX2D/ps99++0VpaWncd999qzs8AAAAsCKZmXWzNRHJs5GFNthggzqdS0Ox6667ps+TXnzxxcWOH3nkkenxxx9/PI455ph45pln4qGHHop99tkn7ZuRkREHHHBAnc0bAAAAACqz2k9Dhw4dmj782muvvVb6muShWWLIkCGrOzwAAABArUpeKvvuu+/i5ZdfjgEDBsQ999xTEXy155571vX0GoTk+5b4z3/+k34vFzrppJNiq622SoOwku/r/vvvH4cddljaL9GzZ88499xz62zeAAAAAFCZ7FhNw4cPT/cbbbTRSl+z8G3Qb775ZnWHBwAAAOq5CRMmrLBP9+7do75be+21Y9SoUZWeW2eddeKxxx5Ly+ixYr169Ypvv/02SkpKok2bNhXHk+/fCy+8EKeffnqa+WrBggXp8eTlv+SFvqQMYfv27etw5gAAAACwtNV+Kjhv3rx036JFi5W+pnnz5um+sLBwdYcHAAAAViQjo3yr7TG/t912262we5LxqCFKAoYGDhyYBgy1bt26yvf505/+FDXhwgsvjPoc0FaZJMDq7rvvjhtvvDG+/vrrKC4ujnXXXTc6dOhQ63MEAAAAgFoJwEoefk2aNClGjx4dW2yxxUpdM3bs2HTfrl271R0eAAAAoFY8//zzUVRUlJYgnDJlSgwbNizNyJQET3355ZdpwFCrVq2qdO8kiCvJ8tSUArBWJAloS8oRAgAAAECjD8BKSg8mAVhPPvlk7L///it1zRNPPJHu119//dUdHgAAAFihOsiAlYz5vXfeeSe6du0aDd1666232Ne77bZbnHrqqbHnnnumGZs+/vjjNCirqkFYDTULGAAAAAA0dZmre4O99947fUB41113xeuvv77C/kOGDEkfSiZvde67776rOzwAAABQzyXBV927d1/u1lAl5fLuvPPOtP3f//43LrvssirdJ8mqVRNbfTV37tz0WVKyTZ48eYX9kz4L+y9YsKBW5ggAAAAAtRaAddJJJ0V+fn6UlJSkwVj/+Mc/Yt68eUv1S45dd911sc8++0RxcXH6gPKUU05Z3eEBAAAA6tSGG24Yffr0SduPPPJIXU+nQXjooYfi2GOPjfPPPz99RrQiSZ+k7y9/+ct49NFHa2WOAAAAAFBrAVhJWv377rsvsrKyYs6cOXHGGWdE586d0zT8hx9+eLol7U6dOsVvf/vbKCwsjOzs7Lj//vujTZs2qzs8AAAAsCJJ+cG62JqQ5LlHYtSoUXU9lQbhqaeeSveHHHJI+pxoRZI+hx56aJqF/YknnqiFGQIAAADAylvxE66V0L9//3juuefiqKOOivHjx8fs2bPTUoOLSh6QJdZcc820BOGuu+5aHUMDAAAA1Llx48ZVvKjGin3wwQeRkZERffv2Xelrkr5XXXVVvP/++zU6NwAAAACokwCsRJLlavjw4XHXXXfF008/HR9++GEUFBSk55IShVtttVXst99+ceSRR0bz5s2ra1gAAABgRTIzy7faHrOJePfddysyX2266aZ1PZ0GYcKECem+R48eK31N9+7d033y8h8AAAAANMoArEQSWPWrX/0q3QAAAADqs8GDB8cvf/nLtH3RRRfFwIEDFzv/zjvvpKXvkpfKlpf56phjjqn4+uijj66x+b7yyitp+b2PP/44felt7ty5FRnHK5NkmEpelquPsrKy0v38+fNX+pqioqJ0v7zPDAAAAAANPgALAAAAqIcyMsq32h6zBg0dOjS++eabiq8XZuFOJMeT4KpFHXvssas8xueff54GaO24445pVu8tttgiOnXqVBF4lQRE3XHHHTFjxoz0WP/+/as0zopMmjQpDj300HjttdeWG4CUBFwtei75ur7q0qVLjBw5Mj799NPYfvvtV+qaTz75JN0v/DMAAAAAgEYTgNWrV6/IzMyM5557LtZdd92Vumb06NGx66671us3MQEAAID6a9CgQXHnnXdWem7YsGHptqjVCYx644030m15kvvfcMMN6TOS6rRgwYLYa6+94qOPPkqDq5IgsDXXXDOeeeaZ9LnKkUceGVOnTo0PPvggLeuXHEsydm2yySZRnyVBbSNGjIh//vOfccIJJ6zUNbfcckv6+VY2YAsAAAAAGkwA1qhRo9KHXwvTwK/sw8PkLcf6/CYmAAAA0LQdcsgh0b59+3j55ZfTAKfx48fHd999lz7XaNu2bfoi2k477RRHHXVUbLbZZjUyhyST14cffpg+Q0mybSXlDj/77LM0ACuxaBBaUp7wN7/5TZq56/e//3387Gc/i/rq8MMPj3vvvTfee++9OOOMM+Laa69d5nOiJPDszDPPjPfffz/tk1wLAAAAAPWJEoQAAADQ2CVxLbVegrBmb58EJi1ZZnBVJVmrlpcZKzc3Nw444IB0qyuPPvpouv/pT3+aBl8tz4EHHhibbrppbLPNNunnSoLC+vTpE/VRktWrX79+aXDbP/7xj3jzzTfj9NNPjx//+MfRtWvXtE+S0WvIkCFx/fXXVwRf9e3bt07/PAAAAACgMtWbF38lzZgxI923bNmyLoYHAAAAaBA+/vjjilKDy8oOtajevXunGaUKCwvj73//e9RnDz30UFoqMfkMSYBVEmC2zjrrpIFvyZa0k0Cy5FzSJ+m7MCANAAAAAKKpB2Ddc8896X6ttdaqi+EBAACgaUmyX9XFxmqbOnVquu/Vq1fFsZycnIr2nDlzlrpm9913T/cvvPBC1GcdOnSIt99+Oy0vmARcJUFWlW3JC3xnnXVWvPXWW+k1AAAAANDgSxAm6eEr88tf/jLy8vKWe+38+fPj22+/jUmTJqVvb+6xxx6rOjwAAABAk5EEWxUXFy8WdNWmTZuK9rhx42K99dZb7JoWLVpUnKvvksCrq6++Oi666KK0HOGHH34YBQUF6bn8/PzYaqutYrfddou2bdvW9VQBAAAAoPoCsF599dU0eGrRFPdJ+913312l+yRp5M8777xVHR4AAACgyejZs2d88cUX8d1331Uc69KlS7Ru3Tpmz56dZpBaMgDr008/TffJ85uGIgmwGjBgQLoBAAAAQKMPwOrbt+9iD/Bee+219Outt956uRmwkj7JG5hdu3aNHXfcMQ499NAVZswCAAAAVl9GZma61faYrL4kA1QSgJVkhtprr70Wez7zzDPPxN///vc4+OCDo3nz5unx6dOnxxVXXJE+h9loo43qcOYAAAAA0HRUKQPWojK/f6A6ePBgD/YAAAAAqtHuu+8e9957bxps9Yc//KHi+Mknn5weSwKzNttss9h///2jsLAwnnrqqbT0YBKAdfTRR0dDMXfu3Hj//fdj4sSJMWfOnDjwwAMXK7UIAAAAAI0qAGtJycO85KFe+/btq2dGAAAAQDXLSFJT1/6YrLYkEGngwIExduzYGD58ePTu3Ts9vs8++8Rxxx0Xt99+e3z99ddx9dVXp8fLysrS/R577BGnnHJK1HdjxoxJA8sefvjhWLBgQcXxbbbZZrEX/W677ba45ZZb0lKFzz//fIMqrwgAAABA47faAVhJ5isAAAAAql+7du1i5MiRlZ4bNGhQ7LDDDun+s88+i+Li4ujTp0/6stwZZ5xRkbW8vnr77bfTQLJp06ZVBI4lKguu2m+//eLUU09Ng7SSAKw999yzlmcLAAAAAMtWv5/EAQAAALBMxx9/fLz55psxc+bMtHTfxx9/HP/3f/8X2dmr/c5djZo+fXoccMABMXXq1FhjjTXixhtvjE8++WSZ/Tt37hx77bVX2k5KLwIAAABAfVIjT+NKSkrStxfnzp272BuMlenZs2dNTAEAAABYKMkoVNsl25SIYzmuu+66mDRpUuTn56cBZCvzfKh///7xr3/9K955551amSMAAAAA1HoAVkFBQVx//fXxxBNPxOeffx6lpaUrvCZJKZ+kxwcAAACg6XjqqafS50JnnXXWSr+ct/HGG6f74cOH1/DsAAAAAKAOArDeeOONOOigg2Ly5MkrzHgFAAAA1DIZsKhnvvnmm3Tft2/flb6mffv26T4ptwgAAAAAjSoAa8qUKXHAAQek+1atWsUJJ5wQ7dq1i4EDB6ZvMg4aNCimTp0a7733Xjz55JMxb9682GmnneL444+vnk8AAAAA0Mj973//i1tvvTVef/31+Pbbb2PWrFkrzD5enzOPJ8+HEs2aNVvpawoLC9N9bm5ujc0LAAAAAOokAOsf//hHGnzVvHnzePPNN9N08J999lkagJX45S9/WdF3woQJcfjhh8eQIUNihx12iCuuuGJ1hwcAAABo1K6++uo477zz0mCqxpJ5vHPnzjF27NgYMWJEbLvttit1zUcffZTuu3XrVsOzAwAAAIBaDsD697//nb5Redxxx6XBV8vTtWvXePbZZ2PzzTePK6+8Mvbcc8/o16/f6k4BAAAAWJ7MzPKttsdktf3nP/+J3/3ud2k7ef6y/fbbx9Zbbx0dOnSIzAb8Pf7Rj36UBmAlz5UOPvjgFfZPAs/++c9/pt+DH//4x7UyRwAAAACotQCsb775Jt3379+/4ljyMGyhkpKSyMrKqvg6SRP/29/+Nk499dS4+eabBWABAAAALMO1116b7tu3bx9PPvlk7LTTTtEYHHHEEfHII4/EvffeG2eccUZsscUWy+3/f//3f/Hxxx+nz5yOOeaYWpsnAAAAAKyM1X5VcubMmel+rbXWqjjWokWLivasWbOWumabbbZJ92+//fbqDg8AAACsSPKeVPKyVK1udf2hG4f33nsvDTq68MILG03wVeKAAw6I3XbbLS2ruPvuu8dNN90UkyZNqjifHB8/fnw8/PDDacarv//97+n34aCDDoodd9yxTucOAAAAANUegNWqVauKB2MLJWnwFxo5cuRS18ybNy/dL/pgDQAAAIDFzZkzJ93vvPPO0dg8+uijseWWW8a0adPiN7/5TXTt2rUiq3pyvEePHnHooYfGG2+8kZYgTMoWDh48uK6nDQAAAADVH4C17rrrpvvRo0dXHGvXrl2sscYaafuVV15Z6pqhQ4em+7y8vNUdHgAAAKDRWnPNNdN9UVFRNDbJ86M333wzzjvvvGjTpk0aZFXZlpubG+ecc068+uqrniUBAAAA0DgDsJK3DxPvvvvuYsd/+tOfpg/J/vrXv8bXX39dcfytt96Kv/3tb+kbjdtuu+3qDg8AAACsSK2XH/x+Y7Xtt99+6X7YsGHRGOXk5MSll14aY8eOjaeffjoGDhwYv/71r+Okk06KP/zhD2kJwnHjxsXll1+e9gUAAACA+ih7dW+w5557xg033BCPPfZYXHHFFRXHzzrrrLjnnnvSMoMbb7xxbL755lFYWJgGY5WUlKQBWGecccbqDg8AAADQaP3ud7+Lu+++O6666qo48sgjKzKON3R33XVXul9//fXTl/uSzFZ77713ugEAAABAk8uAlQRgHX300bH99tvHiBEjKo5vsskmcdNNN0VWVlYUFxfH+++/H1988UUafJVI3mhMsmQBAAAANUwGrAarW7du8a9//St9nrLjjjvGs88+G43BscceG7/85S9j1KhRdT0VAAAAAKj7DFjNmjWLwYMHV3ru+OOPj5133jk9/9lnn6WBWH369Imjjjoqttlmm9UdGgAAAKBR69evX7rv0KFDfPXVV2lJwnbt2qXPV1q2bLnca5Ps4y+99FLUR23bto2ZM2emnwMAAAAAoqkHYK1Ikkr+L3/5S00PAwAAANDovPrqq2kg1UJlZWUxbdq0eOedd5Z5TdI/6bfodfVNr1694uOPP04/CwAAAAA0dDUWgJVku1r4EK19+/aRnV3jsV7Aypgzo65nQCM0fucf1fUUaKRmzCyq6ynQCJUUl9b1FGiE1mrerK6nQCMyo6w0orr/CczIjMjMrOabrsSYrLa+ffvW60CqqhowYEB89NFH8dRTT1Vk+QIAAACAhqpao6I+//zzuPnmm+PFF19M0+Inb1smkgeFSUr5/v37x0knnRSbbLJJdQ4LAAAA0CglGbAaozPOOCNuv/32uOmmm2LfffeN3Xffva6nBAAAAABVVi2vo5aWlsb//d//xeabbx433HBDfPHFF+mxJAAr2ZL2l19+GTfeeGNsueWW8dvf/jY9BgAAANSCJINSXWywDG3atIkXXnghNthgg/jpT38aJ554YhpsNnXq1IoX+gAAAACgSWXAOvzww+Phhx+ueEC28cYbx3bbbRddunRJv/7uu+/i3XffjU8//TRKSkriuuuui/Hjx8eDDz5YHcMDAAAA0IBkZWVVtJPnSbfddlu6rYwk03pxcXENzg4AAAAAajkA64EHHoiHHnooffiVZMC69dZbY9ttt620bxKEdfLJJ8eHH34YjzzySHrtoYceurpTAAAAAKABWTLLlaxXAAAAADTpAKwk4Cqx3nrrxdChQyMvL2+ZfZPArCFDhsQ222yTliS85ZZbBGABAABATauLkoBKEK6S0aNHV7R79uxZ6fGqWPRe9clFF11U11MAAAAAgPoTgPXxxx+n2a/OPffc5QZfLZT0Sfoed9xx6bUAAAAATV2vXr0qLa+38HhV1OdSfQKwAAAAAGhMVjsAq6ioKN1vttlmK33Nwr4LFixY3eEBAACAFcnMLN9qe0xW2rJK8CnNBwAAAABNIABrrbXWiv/9738xY8aMlb5m5syZFdcCAAAANHV33HHHKh0HAAAAABpRANbPfvazuOSSS+LRRx+N3XbbbaWueeSRR9I0+AMGDFjd4QEAAIAVyUjr0dX+mKy0Y445ZpWOAwAAAAD1x2rXAzjrrLNinXXWiVtuuSUeeuihlQq+Svr26tUrfve7363u8AAAAACNwl133ZVuCzOHAwAAAABNJACrbdu28eKLL8ZWW20Vhx12WBx44IHxxBNPxLhx42LBggVRXFyctpNjScarQw45JO370ksvpdcCAAAAEHHsscfGL3/5yxg7dmyl5ydPnhx/+tOf0g0AAAAAaIAlCLOyslbYp6ysLJ566ql0W16f9957L82alZQhTAK0AAAAgBqUlB+s9RKEahBWt0mTJsXAgQPT5ykXXnhhXU8HAAAAAFjVAKwkcKq6+q3svQAAAAAAAAAAABpFANZFF11UszMBAAAAaoYMWAAAAAAANUYAFgAAAAAAAAAAQBVlVvVCAAAAAAAAAACApm6lM2ABAAAADVRGZkRmZu2PCQAAAADQBHgaCgAAAAAAAAAAUEUyYAEAAEBjl5FRvtX2mFTJjTfeGJ07d17q+KRJkyraf/rTn1bqXhdeeGG1zg0AAAAAWJoALAAAAIB65KabblrmuYzvA9suvvjilbqXACwAAAAAqHkCsAAAAADqibKysmq718JgLQAAAACgZgnAAgAAgMZOCcIG4ZVXXqnrKQAAAAAAVSAACwAAAKAe2GWXXep6CgAAAABAFQjAAgAAgMYuI7N8q+0xAQAAAACaAE9DAQAAAAAAAAAAqkgAFgAAAAAAAAAAQBUpQQgAAABN4fWrzIzaHxMAAAAAoAnwOBQAAAAAAAAAAKCKZMACAACAxi4js3yr7TEBAAAAAJoAT0MBAAAAoIade+65kZGRUbG9+uqrK7zm3//+dwwYMCC6d+8ezZs3T/fJ18lxAAAAAOoPGbAAAAAAoAZ99NFHcfXVV690/9LS0jjxxBPjtttuW+z4uHHj0u2JJ56IE044IW655ZbIzPR+JQAAAEBd84QGAAAAGruMjLrZgIpgquLi4ujcufNKXXP++edXBF9tueWWcf/998c777yT7pOvE4MGDYo//vGPNTp3AAAAAFaOACwAAAAAqCHXXXddvPvuu7HBBhvE8ccfv8L+X331VVx55ZVpe5tttolhw4bFoYceGttuu226Hzp0aHo88be//S2++eabGv8MAAAAACyfACwAAABo7DIyIzJreUvGhCZu9OjRccEFF6Ttm2++OXJyclZ4zbXXXptmy0pcf/31kZubu9j5li1bpscTSb9rrrmmRuYOAAAAwMrzNBQAAAAAasCpp54as2fPjmOOOSZ22WWXFfYvKyuLf/3rX2k7yZi1/fbbV9ovOb7++uun7aR/ch0AAAAAdUcAFgAAAABUs4ceeiiefvrp6NChQ0VJwRUZMWJEjB8/Pm2vKGBr4flx48bFyJEjq2HGAAAAAFSVACwAAABo7DIy6maDJmr69OlxxhlnpO0rrrgi8vPzV+q6zz//vKKdZMBankXP/+9//6vyXAEAAABYfdnVcA8AAAAA4HvnnHNOTJw4MXbaaac4/vjjV/q6sWPHVrS7d+++3L49evSoaI8ZM2aV5rfoOJWZMGFCRbukpCTdalsyZmlpaUUb6gPrkvrGmqQ+si6pb6xJ6qP6vi7r45ygIRCABQAAAI1dRmb5VttjQhP0+uuvx6BBgyI7OztuvvnmyFiFbHCzZs2qaLdq1Wq5ffPy8iras2fPXqU5Lhq8tSJTpkyJ5s2bR21LfhkxY8aMiq8zM/2dQt2zLqlvrEnqI+uS+saapD6q7+sy+TkQWHX1679kAAAAAGigioqK4sQTT4yysrL47W9/G5tssskqXT9v3ryKdk5OznL7LhoUNXfu3CrMFgAAAIDqIgMWAAAANHZJAp5VyMJTbWNCE3PZZZfFF198ET179oyLLrpola9v0aLFYsFcyzN//vyKdm5u7iqNs6KShUkJwu222y5td+zYMTp16hR1WfIiPz8/srKyan0OsCTrkvrGmqQ+si6pb6xJ6qP6vi4X/XkTWHkCsAAAAABgNSWBV3/5y1/S9vXXX79YicCV1bp165UuK1hYWLjS5QqX1L1795Xum/wioK5+GbCwDEddzgGWZF1S31iT1EfWJfWNNUl9VJ/XZX2bDzQUArAAAAAAYDVdc801adaqddZZJ+bMmRMPPPDAUn0+/fTTivbLL78cEydOTNv77bdfGrC1aGDU2LFjVzqLVY8eParpUwAAAABQFQKwAAAAoLFL3qr8/s3KWh0TmpCFJRq+/fbbOOyww1bY/5JLLqlojxgxIg3A2mijjRbLqLU8i57fcMMNqzhrAAAAAKqDp6EAAAAAUA/06tUrunXrlrZfe+215fYdMmRIul9zzTVj7bXXrpX5AQAAAFA5AVgAAADQ2GVk1M0GTcjgwYOjrKxsudtFF11U0f+VV16pOL4wgCojIyMOOOCAigxXb731VqVjJccXZsBK+ifXAQAAAFB3BGABAAAAQD1x5plnRlZWVto+7bTTYu7cuYudT75Ojieys7PT/gAAAADULQFYAAAAAFBPrLfeenH22Wen7ffeey922mmnePDBB9N2sk++TtqJpF+fPn3qeMYAAAAAZNf1BBqac889N/76178uli5+1113rdM5AQAAwHJlZJZvtT0mUCWXXnppTJo0KW6//fb48MMP49BDD12qz/HHHx9//vOf62R+AAAAACzO09BV8NFHH8XVV19d19MAAAAAoBHLzMyM2267LZ555pk44IADolu3bpGTk5Puk6+fffbZGDRoUNoPAAAAgLonA9ZKKi0tjRNPPDGKi4ujc+fO6VuIQN255/4H4/U33oz3P/woPvns8ygqKoo7br4hjj3qiFX+b/uGW/4Zt95+Z3zz7bfRqlVe9N9117h04AWxTq+1K73muRdeisuuvCo++Oi/kZGREVtvuXn88ZyzY/fddqmmT0ddeXTqjHh79tz4ZM68+GJeURSVlcXVPdeIQzq2rfI9i0rLYp+vRsXnc+dH7+Y5MWSjXoudn1daGpePL4j/zpkXI+cXxfSS0miTlRlrNW8Wh3dsFwd1aBPNMjKq4dNRl56cNTvenzcvPp8/P76aXxQLkqwGnfJjQJvWVb5nsj4PGTs+viwqil7NmsUzPbsvs++Lswvj/pkz4/P5RTG3rCw6ZWXF5i2ax/917BBds/3vYEP1dOHs+GD+/Pi8qCi+LipfV5d06BgHtGpV5XsuKCuLwydOiC8XLIi1s7PjyW5rLnb+X7NnxwVTpyz3Hts1bxGDunSp8hyoWx+WzI+RpcUxvqwkJpaVRElE/Cy7ZWyd1XyV7zW/rCxeL5kXn5YWxbSy0siKjOiQkRkbZjaL3bNza2xcliH5/4nMWv5/Cv8PA0sZOHBguq2svffeO90AAAAAqN/8xm0lXXfddfHuu+/GBhtsEAMGDIi//OUvdT0laNL++Kc/x6jRYyI/v2N0XaNL2q6Kk047MwYNvis23nDDOP2Uk2L8hAnx0GNPxPMvvxxvvfJi9Fm391KBX0edcFJ0ys+PY488LD324COPx0/2OzAeuntw/HzAAdXy+agbf51QEGOLiqNDdlZ0bpaVtlfX1RML0sCqZZlTWhp3F0yPLfJaxO5tW6VjzygpiVdmFsZZoyfGv6bNjHt6d49Mv8Bs0K6bOi3GFxdH+8zM6JSdnbZX141Tp8XoBUnIzbKVlZXFwIIp8fDMWdEjOzv2bpUXeZmZMam4JN6dNzfGLygWgNWA/WP69BhfUlK+rrKy0vbqumnG9Bi9nPW5fk5OnNym8qDUF+bOieELFsSOuS1Wex7UnReK58X0KI2WkRGtIzNtV8X0stIYVDQrpkVp9M7Ijg2ymkWysqaUlcZnpQti98itkXFpWpIXo9555510S35eT7YpU8qDRI855pgYPHhwtYwzY8aMePrpp+PFF1+MDz74IEaOHBlz5syJdu3axSabbBL77rtvWgou+RoAAAAAaJr8xm0ljB49Oi644IK0ffPNN8crr7xS11OCJm/QDddHn3XXibV69ozLr7wmzrvo4lW+xyuvDUmDr/ruvGO88NQTaTmHxOEH/yL2PugX8Zuzzo7nnnysov+0adPjtN+dkwZ9ffDGa9F9zfKsIOeedWZsuWPfOOXMs2LP/v2ideuqZ7Shbv2txxqxTouc6J7TLP4xcUr8ZULBat3vw8K5ceN3U+NP3TvH+WMrz5zYLisr/rdZn8hZIiNFcVlZHPrNmHht1px4eWZh9G9b9Yw21L0/dcqPtZplx5rNmsU/p02Pa6ZOW637/Xfe/Lht+ow4L79j/Llg2dmI7pkxMw2+OqxN6/hDfsfIylh6ndFwDezYMXpmN4tu2dlx24wZ8fcZ01frfp/Mnx93zJwZ57bvEJdNm1ppnw1yctKtssxZD8yelf5wcUCev68asoOatYyOGZnRPiMrXiueF8+VzF3le5SUlcW9C2bHrCiN45q1it6ZzZY6XxPj0vR0qYVse//+97/Tl7Dmz5+/1LmCgoJ49dVX0+3KK6+M++67L3bbbbcanxMAAAAAUP9k1vUEGoJTTz01Zs+enb5Bu8suSoxBfdC/365p8NXq+Ocdd6X7Sy44vyL4KrHXnj+JXfvuHM+/9HKMHvNDZq2HH38ipk+fEaedfGJF8FUiaf/mpF9FQcGUePzJpyuOn3z6byMjr10aILakheeuuOra1foMVK++bfLS4KvqkJQWPHPUxNiuVW4ck7/sbAhJZqslg68S2RkZsVfb8mC+kfN/yHKUZMRa88Mv46jhY9PsRota3jnq1o4tc9Pgq+owv7Q0/jBpcmzVokUaWLW8NXjDtOlp5qvzKgm+WrjOFnp21uzYaPiIOGnCxKXWz/LOUXe2b5GbBl9Vh6RU3B+nFMSWzZvHIVUoYfjynDkxvbQ0+ubmRsesrIrj/y4sjM1Gj4pfT/puqbWzvHPUnXUzm6VBUKvj09IFMa6sJHbOarFU8FWisr+PVmXcj0uK4g/zp8XgBbOWWjvLO9fkZWTWzVZLevbsGXvssUe13zfJqJUEX2VmZsaee+4Z11xzTbz88stpJqwnn3wyDjnkkLTfxIkT00xYH330UbXPAQAAAACo/wRgrcBDDz2Ulhro0KFD+kYr0Hi8+vrQyMvLi5122H6pc3vuvnu6f+31YT/0HzI03e+xe7+l+/f/vv/QH/pfc8VlseEG68eFf74s3n3/g4rjjz/5VNxy2x3Rb5e+cfZvT6/mT0V9cfn4ghi3YEFc2XONyKhC+cDSsrJ4dVZh2l4/94cAwQPat4lfdGiTZsUaNPmHLEpj5i+I34/5LjplZ8U1VRyThuHaqdNiQnFxXNI5f7l/zsPmzo2ZpaXRL69lWsjrhdmFafatB2bMjFGVlC7cu3WrOLB1q3h9zty4e8bMiuPJOr64YEoaVHNZp07WViN13fRpMaGkJC7u0LFKf8aPFc5O9wctEby1V15e7J+XF0PnzYt7Zs2qOD6uuDj+PHVKdMzMjEs6Ln8t0/B8UlpeenfTzJy0FOHbJfPTrFaflBSlwX6ra/OsnNgqMye+Ki2ON0p+yEo0rawk/lU8J1pFRvw8O8+6agIuvPDCeOqpp9Lgp1GjRsUtt9xS7WM0a9YsTjrppBgxYkT85z//iTPPPDPNcrXlllvGfvvtFw888EBcd911ad+kLOFZZ51V7XMAAAAAAOo/JQiXY/r06XHGGWek7SuuuCLy8/PrekpANSksLIwJEyfGJhttFFmLZOpYKClvmPh6+PCKYwvbfXr3Xrr/98cW7Z+bmxv33zEofrRr/zjs2OPjozdfj+kzZsQJp54eHTt2iLtvuyV9k57G563Zc+K2ydPiojU7x9rNly7VVZmi0rK4/rspkfxaelpxSQydNSe+mV8Uh3RoEz9unbdY30u7d4l3C+fGX8YXxA6tWsaGuc3jN6PGx6yS0ripd/fIb+af98bqvbnlwVHnduwQPVeQUevz+UUVmWYOHDMuRi4SdJX8zXN02zZxTn7Hxa45PymxOm9eXD11Wmyb2yLWy8mJcyZNjtmlpXFL1y7RMXv1suJQP703b17cO2tW/K5d++hRhUxt44uL4+1586JLVlbs1CJ3qfN/aN8hPpo/P/4+fVps26JF9GnWLM4rKIjZZWVxY36nxTJm0TiMKy1O9yPKFsS/F8yN8q/K5UVGHNYsL9apJDPWqtgvu2WMWlCclirslZkda2RkxYMLCmN+lMWhzVpFq1rMvNRgJPFotR2UVsPDXXzxqpchX1VJhquFWa6W5bTTTou77ror3nvvvXjttdfS0oSeHwAAAABA0+I3tMtxzjnnpG/S7rTTTnH88cdX233Hjh273PMTJkyotrGAys2YWZ7dpW3bNpWeb9O6/PiMRbLALO+aNt+XAVu0f2LzzTaNKy4ZGGeec16ccsZZMXb8+Jg6dVr866H7olvXrtX4iagv5pSUxlmjJsbWeblxXKdllx5c0oKysrh64pTFfl95cuf2cV63Tkv1zcvKjBvX7hYHfDUqTh05Ifq3zYv3CufFrzq1j13bLB6sReMxp7Q0zp9UEFu0aB5HLOPvrkVNKSlJ93dOnxEbNc+JB9fsFuvkNIv/zS+KgZMLYvCMmWkQ16GL3CsvMzOu7Nw5Dh83Ps7+bnLs0rJlfDhvfhzTtk3s3LJljX4+6m5dXTh1SmzevHkc3nrZJS2X54nZs9Msawfktaq0tFzLzMy4omN+HPXdxDi3YHL0zW0ZHxXNj6Nat46dcpcO2KLhK0zDiSOeKZ4bO2c1jx2yWqQ/eH5cWhT/Lp4b9ywojDNz2kSb1QiSap6REYdk58UtC2bFg8WFsUFmsxhdVhI7ZTWP9VYzuAuqYtddd00DsEpLS9NsWQKwAAAAAKBpEYC1DK+//noMGjQosrOz4+abb67W8hU9evSotnsB9d/pvz45nnvx5bjngYfSr0/51fGx/z571/W0qCF/Gj8pvltQHHf37h6Zq/BvRxJUNW7L9dPSgxMXFMcLM2bHFRMK4v3CeXF37zWj9RIZYjZv2SLO7pofl40viG8mFcXGuc3jD5UEa9F4/G3K1JhUUhK3dF1jpdbWwipfzTIy4vo1ukTn7PL/7dsmt0Vc06VzDBg7Lu6YPmOxAKzEJi2ax+kd2qdZsL6dMSM2yMmJ33bsUDMfijp31fRpMbmkJG7s1HmV/s5aKPk761+Fs9Og0QNbLTsAdOPmzeM37drFtdOnx4hZM2ODZs3izHbtV3P21FcLiwyun9ksfpr9Q/DmjlktYmZZaQwpmR/vlcyPftmrF4DXPTM7+mflplmwJpfMj64ZWbFnlqA+6sb8+T+Uw6wswy4AAAAA0Lipy1CJoqKiOPHEE6OsrCx++9vfxiabbFLXUwKqWds2S2e4WtTMWUtnu1reNTNnzlqq/0JJAOeB++1T8fVpJ5+42vOnfnpj1py4u2BGGhjVu8XKlR5cUhIA0S2nWRzTqX1c0WONtNTgdROnVtp3z7atKv4hP6Jj28jJrOWyQtSad+bOjQdnzorTOrSPtXNWLrNLq+9LnG7cPKci+GqhPs1zonuz7BhTXBwzv8+Utah+eS0r1tbBbVpHTm2XrKJWvDtvXjw8e3ac2rZtrF2F0oOJt+bNiwklJbFd8xbRPXv599gt94d19bNWrdPgQBqn5t/XnduwkkxUG2aW//s4rmzpv3uqIhlj4UraNqt5ZFtXy5ZkHKuLrYlISg8mmjVrFuuuu25dTwcAAAAAqGUyYFXisssuiy+++CJ69uwZF110UbXff8yYMSssQbjddttV+7jAD/Ly8qLrGmvEiFGjoqSkZKm31L/+5tt036d374pjSfu9Dz6Mr4cPj45LZINJji3Zf6ERI0fG2edfGB06tI9p06bHCaeeHkOef9ab8Y3QZ3PnpftLxk9OtyUNn18Ua374ZbTJyoz/bdZnhffbpU151pA3Z8+ptGThaSPLS9a2zcqMv04oiJ+0bZUGb9H4fDG/KN1fOWVqui1pxIIFsdHwEdE6MzPe7rVWeqzX92uhTWblf9e0+T5Aa/7CVFmLrK1zJ02u6PP3qdNi17yWscYSQVw0fF8Ula+rq6dPT7cljSwujs1Gj4rWGRkxrEfPSu/xWOHsdH9Qq1bLHStZV+dNKUjbrTMy4x8zpscuubnWVSPVKSMzRpWVRIuK0KgfLDxWvMTfPVVRUlYWDxcXVtz3heK5aUBW2yYU9NOQJD/nrkj37t2jIXrmmWfiv//9b9rec889o833L24AAAAAAE2H33gsIQm8+stf/pK2r7/++jRIo7o11IfK0NjssvNO8cAjj8awN9+KvjvvtNi55156Kd333XnHH/r/eKe4/+FH4vmXXo7tt9t28f4vvlRxz0UVFxfHEcedGLNmzYrnn3w8/vPCi3HVdf+Iiy+7PP50wfk1+OmoC+u3aB6HdWxb6bn7p8xIA6/2adc6clcyU1VSyjBRWTaPy8dPjv/OnR9ndOkYW+a1iGO/HRenj5oQD63bo0plxKjf1s3JiZ+1rjzA5dFZs9PAqz3yWkaL74OqEtvltkj3wxeUB9ksGQwzekFx5GZkRPslgkGvnTItPptfFCe3bxebNW8ev574Xfz+u8lxe7eVK31Iw9Enp1kMyKt8XT1eODsNvOrfMi9dJ5WZXlISr8yZE20zM2P3lj+UmavMddOnx+dJltk2bWPT5jlx2uTJcf6Ugvhn5y7WVSO0TmazGFVSEpMqyXK18Fi7agiSer5kbppJa7esFtEjIyvuKi6MhxYUxvHNWllXlUn+/6O2s2UuMt7KvGSUZKFuaKZOnRqnnnpq2k5esPjTn/5U11MCAAAAAOqAAKwlXHPNNWkJwnXWWSfmzJkTDzzwwFJ9Pv3004r2yy+/HBMnTkzb++23X40EbAGrp6BgShRMmRL5HTtGfn7HiuMnHndMGoB1wSWXxgtPPRE5OeUlcf793Avx6pChscfu/WKtnj9k/Dj4oAFx7gUXxfU33xrHHX1kdF9zzfT42HHj4h+3/DO994D9911s7CTQ6s2334nfnXFa9O+3axrQ9cqQ1+Oyv10dP+m3W/x4px8CvGhYphYXx9TikuiQnRUdvs/g0rdNXrotKwCrU3Z2XNlzjcWOfzV3fvRo3ixyFwmcScwtLY2Lx5ZnIeq3xD2HzCyMWyZNi61atoizunZMA7SOzW8Xgwumxz++mxqnr/HDOqfhmVZSkm5JYNTC4KgdW+am27ICsPKzsuKSzp0WO96zWbPYKTc3hs2dG4/MnBU/b9O64tygadNjZmlp7Ncqb7EAvzfmzI3BM2bE5kngVft26bnD27SO+2bOin9OnxEntW9XY5+bmpWsqemlpdEuM7NiXW3fIjfdlhWA1TErKy7uuOy/T54qLIwFEbFPy7zllql8c+7cuGvWzNgsJydObts2XVeHtmodD8yeFbfNnBm/alt54Cr1X2FZaRSWlUVeRkbkLRJQtXVWTrxeMi/eLJkfW2c1r8hIlWTce7WkPFvkpllVK9W70NelC2Joyfw08KpfVovIysiI7UuL463S+TGkZF7sml352obqlGTSPeKII2LUqFHp13/84x9jyy23rOtpAQAAAAB1QADWEubPn5/uv/322zjssMNW2P+SSy6paI8YMUIAFtSSQYPviqFvvJm2P/ns8/Jjd94dr74+NG3vvOMOccKxR6ftf9xya1x82RVx0R/OjYHnn1dxj9126Zv2Se611Y67xD4/3SMmTJwYDz76eFou8Pqr/rrYmO3bt4t/XPW3OOqEk9L+h/x8QHr8wUcejylTpsaDd90RrVv/EOAwZOiwNNBqqy02j0sHXpAeS4K87rtjUGy9865x5PEnxsdvDY127QQ01Bf3FUyPdwrnpu0v5s6vCJxaWAJwu7zcODy//M/rjsnT4+qJU+KsNTrG/3XNr/KYT02fFbdOmhbbtcqN7jnN0kxGExYUxyszC9OAiR/l5cavOrdfLPDrzFETolVmZtywdteK4JkL1uwUb82eE1dNKIidW7eMrfL84rk+SQKgPphXHnTw1fflBB+dNSve/f7YVi1aVARI3TtjZtw4bXoaAPWbDj/82VfFBZ06xhHjxseFkwvipcLC6NWsWfyvqCjenjsvumVnx+8WKaearLfzJk2OvMyM+FuXThVr6+yOHdJ53jB1Wmyf2yI2b1GeWYu69+jsWfHh9//v+nXRgoqSgO/OL19XWzZvHj9rVb6u7p81K26eOSNObtM2fl1N/+4kQVorKj+YrKs/Tp2SBuhcnp9fsa7+r337eG/+vLhpxvT4UYsWabY16od3S+bHqNLyDIwTv89W9V7J/Bjx/bG1MrNj26zyP68kwOrlknlpAFT/RQKeOmRkxU+zc+Pp4rlxfdHM2CizWWRHRnxZuiCmRWlsl5kT62Y2q/K4SeDXIwsKIwnhOqRZXhp8ldgrOzctyfpiybzondksemT6cbc+eeedd6Jr167RmPz617+O//znP2l73333jQsuKP9/fgAAAACg6fFEGmiQkuCrO++9f7FjSSnBZFtoYQDW8txy/bWx6cYbxa233xl/v/HmaNUqL81idelFF0TvdXot1f/Iww5JM2ldduVVccfd90VGRkZsveXm8cdzzk4zXC00bdr0OPL4kyI3NzfuH3xbRXatxPrr9Ylr//qX+NWpp8evfnNGPHzPnavxnaA6JcFXD0+dudixdwvnpttCCwOwqkv/tq3SUoPvFc6N9wvnRmFJabTOyooNc5vHAe1bx6Edy7PFLPTbURPju+KSuH6trtGz+Q/rKik9d8Pa3WKfL0fFb0ZOiOc3WDtaZa1+eSeqRxJ89cSs2Uscm59uCy2aoaq6JFmwHuq+Zlw/dVoMnTM3hs2ZG/nZWWlWq1Pat4+O2T+UHzx/0uSYXFISV3TuFN2b/RAY0TwzM67s3DkOHjc+zvlucjzWY83IWyJjG3UjCb56srBwqWMLg7ISCwOwqtsn8+fHNwsWxCY5ObHeIv/GLemCKVPSdfWXjh2je/Yi6yojI67omB+Hfzcxfj+lIB5eo6t1VU8kQVAflC5eunRUWUm6LbQwEGp5dsxqEe0jM14vmR//LS2K0ojokpEVu2a1rPT6VRn30eI5MSvK4uDslmmw10LNMjLikOxWceOCmfHggsI4LadNutb4XvK9qO3vxyLjJcFX3bt3j8bivPPOi1tvvTVt//jHP46HHnooLUEIAAAAADRNGWVlZWV1PYmGZuDAgXHxxRen7VdeeSV23fWHoIvqMHbs2OjRo0faHjNmTKN6SE09MGdGXc+ARmj8zj+q6ynQSM2Yufgv46E6FC9IQkGgej393eIBvLA6ZpSVxhVFM1b7Z8JFf7YcedMF0b1j7WZeHTtleqx9yiW19rPtyJEjo1ev8pcojjnmmBg8eHCNjHPFFVfE73//+7S91VZbpc8F2rRpUyNjQV2pD8+mkjKfkyeXl2Xv1KmTIEfqBeuS+saapD6yLqlvrEnqo/q+LuvDz4TQEMmABQAAAI1dRmb5VttjNjI33nhjRfDVhhtuGM8995zgKwAAAAAgGt/TUAAAAIBqdvfdd8dvfvObtL3OOuvEiy++GPn5+XU9LQAAAACgHhCABQAAALAcjz32WPzyl7+MsrKyNO3+Sy+9FN26davraQEAAAAA9YQALAAAAGjsMjPqZqvnBg8eHBkZGek2cODASvs8//zzcdhhh0VJSUl07tw5zXy19tpr1/pcAQAAAID6K7uuJ9AQJQ9ll/VgFgAAAKh5Q4cOjW+++abi64KCgop2cjwJrlrUscceu8pjvPXWWzFgwIAoKiqKZs2axTXXXBMLFiyITz/9dJnXJBmy2rVrt8pjAQAAAAANlwAsAAAAaPQyIjJqOwl2zWbAGjRoUNx5552Vnhs2bFi6rW4A1n/+85+YM2dO2k4Cr4444ogVXnPHHXdUaSwAAAAAoOFSghAAAAAAAAAAAKCKBGABAABAY5eRUTdbDUpKDJaVla30VpkkU9XC8wMHDlzqfHJsVcZINtmvAAAAAKDpEYAFAAAAAAAAAABQRQKwAAAAAAAAAAAAqii7qhcCAAAADURGZvlW22MCAAAAADQBnoYCAAAAAAAAAABUkQxYAAAA0NhlZpRvtT0mAAAAAEATIAMWAAAAAAAAAABAFQnAAgAAAAAAAAAAqCIlCAEAAKCxy8gs32p7TAAAAACAJsDTUAAAAAAAAAAAgCqSAQsAAAAau4yM8q22xwQAAAAAaAJkwAIAAAAAAAAAAKgiAVgAAAAAAAAAAABVpAQhAAAANHaZGRGZmbU/JgAAAABAEyADFgAAAAAAAAAAQBXJgAUAAACNXkZERm1npJIBCwAAAABoGmTAAgAAAAAAAAAAqCIBWAAAAAAAAAAAAFWkBCEAAAA0dhmZ5VttjwkAAAAA0AR4GgoAAAAAAAAAAFBFMmABAABAY5eRUb7V9pgAAAAAAE2ADFgAAAAAAAAAAABVJAALAAAAAAAAAACgipQgBAAAgMYuM7N8q+0xAQAAAACaAE9DAQAAAAAAAAAAqkgGLAAAAGjsMjLKt9oeEwAAAACgCZABCwAAAAAAAAAAoIoEYAEAAAAAAAAAAFSREoQAAADQJEoQ1vI7WEoQAgAAAABNhAxYAAAAAAAAAAAAVSQDFgAAADSJDFi1nJFKBiwAAAAAoImQAQsAAAAAAAAAAKCKBGABAAAAAAAAAABUkRKEAAAA0NhlZJZvtT0mAAAAAEAT4GkoAAAAAAAAAABAFcmABQAAAI1dRkZEZkbtjwkAAAAA0ATIgAUAAAAAAAAAAFBFMmABAABAY5eRWb7V9pgAAAAAAE2Ap6EAAAAAAAAAAABVJAALAAAAAAAAAACgipQgBAAAgMYuI6N8q+0xAQAAAACaABmwAAAAAAAAAAAAqkgGLAAAAGjsMjLLt9oeEwAAAACgCfA0FAAAAAAAAAAAoIoEYAEAAAAAAAAAAFSREoQAAADQyGVkJFtGrY8JAAAAANAUCMCq7+bOjJgzo65nQSNS8vD1dT0FGqHOh/ev6ynQSLV766O6ngKNUOHYaXU9BRqh/USaUI0mFhfHFeP8HAgAAAAA0FAIwAIAAIDGLiOzfKvtMQEAAAAAmgBPQwEAAAAAAAAAAKpIABYAAAAAAAAAAEAVKUEIAAAAjZ0ShAAAAAAANcbTUAAAAAAAAAAAgCqSAQsAAAAau4yMiMyM2h8TAAAAAKAJkAELAAAAAAAAAACgigRgAQAAAAAAAAAAVJEShAAAANDYZWSWb7U9JgAAAABAE+BpKAAAAAAAAAAAQBXJgAUAAACNXUZG+VbbYwIAAAAANAEyYAEAAAAAAAAAAFSRACwAAAAAAAAAAIAqUoIQAAAAmkQJwlp+B0sJQgAAAACgiZABCwAAAAAAAAAAoIpkwAIAAIAmkQGrljNSyYAFAAAAADQRMmABAAAAAAAAAABUkQAsAAAAAAAAAACAKlKCEAAAABq7jMzyrbbHBAAAAABoAjwNBQAAAAAAAAAAqCIZsAAAAKCxy8wo32p7TAAAAACAJkAGLAAAAAAAAAAAgCqSAQsAAAAau4zM8q22xwQAAAAAaAI8DQUAAAAAAAAAAKgiAVgAAAAAAAAAAABVpAQhAAAANHoZERkZtT8mAAAAAEATIAMWAAAAAAAAAABAFcmABQAAAI1dkv0qo5bfwar1jFsAAAAAAHVDBiwAAAAAAAAAAIAqEoAFAAAANDiTJk2Kp59+Oi688MLYa6+9Ij8/PzIyMtLt2GOPrbZxiouL48MPP4xbbrklTjjhhNhss80iOzu7YqyRI0dW21gAAAAAQMOkBCEAAAA0iRKEtVwSsIbH69KlS9SGSy+9NAYOHFgrYwEAAAAADZMMWAAAAECD1rNnz9hjjz1q5N5lZWUV7RYtWsT2228fvXv3rpGxAAAAAICGSQYsAAAAaOwyMsu32h6zBiWlB7fddtt0S7JhJaUAe/XqVe3j7LDDDnHzzTfHdtttF5tuumlafjApcTh8+PBqHwsAAAAAaJgEYAEAAAANzsUXX1wr4+y55561Mg4AAAAA0HApQQgAAAAAAAAAAFBFMmABAABAY5eZWb7V9pgAAAAAAE2Ap6EAAAAAAAAAAABVJAMWAAAANHIZGRnpVttjLjRhwoQV9u/evXsNzwgAAAAAoGYIwAIAAABq1HbbbbfCPmVlZbUyFwAAAACA6qYEIQAAAAAAAAAAQBXJgAUAAACNXVIOMKOW38FapAThO++8E127dq3d8QEAAAAAaokALAAAAKBGJcFX3bt3r+tpAAAAAADUCAFYAAAA0CQyYGXU/pgAAAAAAE1ALdcfAAAAAAAAAAAAaDwEYAEAAAAAAAAAAFSREoQAAADQ6GVGZNT2O1je+QIAAAAAmgZPQwEAAIAmafDgwZGRkZFuAwcOrOvpAAAAAAANlAxYAAAA0NhlZJRvtT1mDRo6dGh88803FV8XFBRUtJPjSXDVoo499tgqjTN79ux45JFHFju26LjJufz8/Iqvt9hii3QDAAAAAJoOAVgAAABAgzNo0KC48847Kz03bNiwdKuOAKwksOuXv/zlMs+fffbZi3190UUXCcACAAAAgCZGCcJKvPfee/GnP/0p9thjj+jevXs0b948WrVqFeutt1760DV5yxYAAAAAAAAAAEAGrCX07ds3Xn/99aWOFxUVxddff51uSRmDo48+Ov75z39GTk5OncyzIbnn/gfj9TfejPc//Cg++ezz9Ht5x803xLFHHbFK9yktLY0bbvln3Hr7nfHNt99Gq1Z50X/XXePSgRfEOr3WrvSa5154KS678qr44KP/RkZGRmy95ebxx3POjt1326WaPh115d43PoqhX42KD0aOj0/GfhdFxSVx2/ED4pgfb7XS90iuf+L9z2PIFyNjZMG0KJy/INbObxf7bbVB/H6fvtEuL7dGxqX+uvf9L2PoiPHxwbjJ8emEKVFUUhqDDu4Xx2y74UrfI7n+X59+G68NHx+jps2MwqLiWLt969hv415xbr+to11u82Ve+8Qn38bNb34SH46bnF7XtXXL+NFaa8Rf9tkherRrXU2fkrpw/+hJ8UbBzPhw2uz4bOacKCoti5u3XjeOWrvLSt/j3amz4tbhE+LD6YUxcW5RzCkpiTVzm8eW7fPizPXWjK3aL3uNPDluStz67YT4eHphFBaXxBotcmLbDq3j0k3Xju4tl70mqd8eLpgeb82aE/8tnBf/mzM/isrK4rp1usWhndpV+Z7J2tzzs2/jsznzY90WOfHG5uvWyrjUH0/Nnh0fzJ8Xnyc//xQVxYKIuKRjxziwVdX/HVpQVhaHTRgfXy5YEGtnZ8dTa3Zf7PwTs2fFBVOmLPceP2rRIgZ1WaPKcyB5/SqzfKvtMWtQ8rP5kmUGV1WSFWtFmbHWXnvtKCsrW61xAAAAAIDGTQDWEsaPH5/uu3XrFr/4xS/ixz/+cfTs2TNKSkrizTffjKuuuirGjRsXd911VyxYsCDuu+++up5yvffHP/05Ro0eE/n5HaPrGl3SdlWcdNqZMWjwXbHxhhvG6aecFOMnTIiHHnsinn/55XjrlRejz7q9lwr8OuqEk6JTfn4ce+Rh6bEHH3k8frLfgfHQ3YPj5wMOqJbPR9248NGXYtSU6ZHfumV0bds6ba+qQ/7xQBTMnhM79ekZR+60RRqkN+SLEXHls0PjsXc/i9f/eGJ0aduq2sel/rroubdj1LRZkZ/XIrq2yUvbq+rQu/4TBXPmxU5rd40jt94gMiLitW/HxZWvfhiP/Xd4DPnNz6JL65aLXZP8Qu/Xj74ag97+PHp3bBMHb94nWrfIifEzCuP1b8el8xCA1bD96bPRMXrO/MjPyU6Dn5L2qhpWMDNenjQ9tuvQOnbt1DZyszJjZOG8eGb8tHhs7JS4dZs+cfhanZdaW6d/ODxuH/FdrJPXIn7ePT9aZWfFhHlFMbRgZjoPAVgN1+VjJseYogXRMTsrujTLTtur68pxk2PEvKJaH5f64x/Tp8X4kpJon5kZnbKy0vbqumn69BhdXLzM8xvk5MQpbdtWeu6FOXPimwULYscWSwfGAwAAAABAfSEAawkbbLBBXHbZZfGzn/0ssrKyFju3/fbbx1FHHRU77bRTfPXVV3H//ffHySefnGbNYtkG3XB99Fl3nVirZ8+4/Mpr4ryLLl7le7zy2pA0+KrvzjvGC089UZF57PCDfxF7H/SL+M1ZZ8dzTz5W0X/atOlx2u/OSYO+Pnjjtei+5prp8XPPOjO23LFvnHLmWbFn/37RurWAhobqluMOjD5dOsZa+e3iiqeHxPmPvLDK9zhjzx3iyB23iG7t2ywWrHDa3U/HzS+/E3/+1ytx/dH7Vfu41F+3/Hy3WLdT21irfZv468vvx/n/fmuV73FG3y3iiK3Wj25t8xZfV48PiVve/DT+/MK7cf1Bi2fhu37of9Pgq5N32CSuPfDHkbVEtojiktLV+FTUBzdstW6s26pF9MxrEVd+OTYu+nTUKt/j5N5d00xXS/psRmH0ffm/8YdPRsZhPTulwaQL3fjNhDT46sR11ogrt1gnshY5lygulc2jIbt6na6xTouc6NE8J64bXxB/HjNpte73wey5cX1yn7XWiPNGTay1calfBnbMj7WaNYtu2dkxaMb0+Pv01Qs2/2T+/Lh95ow4t0OHuGzq1Er7bJDTPN0qy5x1/6xZ6Q+t+7daPCieKkj+DVji34FaGRMAAAAAoAmo5foD9d/TTz8dBx988FLBVwvl5+enWbAWeuSRR2pxdg1T/367psFXq+Ofd9yV7i+54PzFyj7utedPYte+O8fzL70co8f8kFnr4cefiOnTZ8RpJ59YEXyVSNq/OelXUVAwJR5/8umK4yef/tvIyGuXBogtaeG5K666drU+A9Wr/8a90yCo1XHOPn0XC75KJIEL5++/a9oe8uXI1Rr3wbf+G9nHXhD7Xn3XUiVLlneOurP7ej3S4KvVcfZuWy0WfFWxrvpvk7Zf/7Y80+JCcxcUp0FZ63RoE9ccsHTwVSI764djD370dTQ7+4bY77anll5XyzlH3erXpV0afLU6WiyyDha1cdu8WL9NbkyevyBmFv+QqWZuSUn85X9joldei/jb5ksHXyWyM3849vCYyZH36LAYMPTzpdbP8s5Rd3Zp2yoNgqoO80pL47Th4+JHrVvGcV3aV9u4j0+ZEZ3f/jwO+2L0UmtneeeoOzvk5qbBV9VhfllpnF9QEFs2bx6HVqGE4Utz5sT00tLom9sy8hf5+ezfhbNj01Ej45Tvvltq7SzvHAAAAAAA1BQBWFWw2267VbSHDx9ep3NpKl59fWjk5eXFTjtsv9S5PXffPd2/9vqwH/oPGZru99i939L9+3/ff+gP/a+54rLYcIP148I/Xxbvvv9BxfHHn3wqbrntjui3S984+7enV/Onor5q9n2QQ3YlgTCr4pDtN4ujd9oy/vPfr+O659+sOD5y8rT49Z1PRZc2reL2Ew5aLFsNjX9dZS0S8JJ44cvRMW3u/Nh/k15RUlYWj38yPM2+lWTL+qZg6awjh2zRJ47aeoP4zxej47qh/604PnLqzDj10VejS6vcuO2Q3a2rJuTb2XPj61lzo3tuTrRt9kPQxEvfTY9pC4pj324d0rX1r3FT0uxbg76dEMNnz13qPr/o0SmOWKtzPP/dtLjhmwkVx0cVzoszPhwenZs3i1u2WdfaaqQuHTMpxhUtiGvW6Vatf8YDOraNQ/LbxkszZsetE3/IfjR6flGcPWJCdGqWFdf1rt4xqT/+Pm16TCwpjj91zK/Sn/Fjs8tLAf9siexXe+W1iv3z8mLovLlxz6yZFcfHFS+IS6ZMiY6ZmfHn/KqNCQAAAAAAVaEEYRXMnz+/or2sTFlUn8LCwpgwcWJsstFGlX6/k/KGia8XCYZb2O7Tu/fS/b8/tmj/3NzcuP+OQfGjXfvHYcceHx+9+XpMnzEjTjj19OjYsUPcfdstkbmawTg0HHe8Xh6E13+TdVf7XtcdtU+88c2o+MPDL8QuG/SKTXt0iaNueSRmzpsf9/364OjcRjmdpmLwO/9L9z9Zb/GMgB+Mm5zuszIyY6urH4ivJv8QdJWZkRFn/Hjz+Ot+Oy12zXUDfhxvjpoQ5z/7ZuyyTrfYtGvHOPq+F2Lm/KK478j9onOrlrXymagb702dFc9NnBYLSsti9Jz58eyE8qCWv2+5+L95H06bne6TzFc/evHD+Hr2vIpzyb9ov+nTLf6yWa/Frrl6i3XirYKZceGnI+PHndrEJm3z4rh3v4qZC0ri8Z3Wj84tqifbEvXLmzML458Tp8af1uoSvWrgz/gva3eNd2bNTUsV7tgmLzZq2TxO+WZczCopjVvX7RmdFgkcpPF4b968uHfWzDi7fYfo0azZKl8/vrg43p43L7pkZcVOublLnT+/Q8f4aP78uHbatNi2RYvo0ywnfl9QELPLyuKmTp2jo5/TllGCsJZ/phEEBwAAAAA0ESJKquC1116raG+44YZ1OpemYMbM8rfa27atvCxYm9blx2fMmLlS17Rp03qp/onNN9s0rrhkYAz/dkSccsZZcdQJJ8XUqdPi9pv+Ed26dq3GT0R99tGoCXHJE69E5zZ5cfbeO6/2/Vq1aB73nHxwlJaVxZE3PxTnPfR8vPnN6Dh9jx1iz037VMucqf8+Gjc5Lnnh3ejcKjd+t9uWi52b9H0momtf/yjatMiJN07/eUz786/ilVMGxHqd2sU1Qz6Km9/4dLFrWjXPibsP3yNdV0fd90L84dk3481RE+P0nTePPdZfvZKv1H/vTZ0dl/1vTPzty7Hx4JjJkZuVGffvsEH8tGuHxfolJQkT1389Lto0y44hu20W3x2wfTy/yybRp3VuXPf1+Pjn8B8yXSVaZWfF4B+tF6VlEb9856u44JOR8daUWXHqut3iJ2ssvywdDVNhSWmc/u342KZVbpzQZfE1VF1aZWXGLeuuGaVRFid/MzYuGTMp3p09N05co0P0aycQuTGaU1oaF0wpiM2bN4/DW6966cHEE7NnRWlEHNCqVaUlVFtmZsZf8zulfc6ZXBDXTp+WBmQd2bpNpQFbAAAAAABQk7xuvopKS0vj8ssvr/j64IMPXuV7jB07drnnJ0xY/Jeh1J7Tf31yPPfiy3HPAw+lX5/yq+Nj/332rutpUUu+nTQ19r/m7igpLYt7Tzk48lvnVct9t+m1Zlx8UL80C9YXEwpii55rxF9+8ZNquTf137dTZsQBtz+TloC794g9Ij9v8V8KJ0FUiZysrHj0mL2jW9vydbfzOt3i/qP2jK2vfjCuHfJhnLzjJotdt02PznHxnj9Kg6++mDQtNu+WH5ftvUMtfjLqysnrdk23uSUl8c3seXH91+NjwNDP45JN144z11uzol8SRJXIycyMB3fYILrmNk+/3im/bdz9o/Vj+xc/SoOwftV78SDjrdq3jgs27hkXfjoqvpw1NzZrmxeXbLpW7X5Ias3A0d/Fd0XF8cD6PdOsezVli1a5cW73zmkWrK8nTIlNWraIC3p0qbHxqFtXTZsWk0tK4qbOXaq0rpJ/G5+YPTuSKwfkLTtIb+PmzeM37dqnwVcjZi6IDZrlxG/bCxZdfgasWs5IJQMWAAAAANBEyIC1iq655pp455130vZBBx0UW2+99Srfo0ePHsvdtttuuxqYecPVts3SGa4WNXPW0tmulnfNzJmzluq/UEZGRhy43z4VX5928omrPX8ahhGTp0X/K26Pgtlz4sHfHBq7bVhe2rK67L/lhhW/gDxh120jJ1v8a1MwYurM+MnNT0RB4dx48Kifxq7rdl+qT9vvy31t3b1TRfDVQpus0THW6dgmhk+ZGdPn/lD+dqH9Nu71w7r60caRk63cUlOSm5UVm7bNi1u36ZNmp0qyVX02o7DifJtm5ethq/atKoKvFtq4bV70ymsR3xbOi+lFxUvde9+uHSr+J/G4Xl3SIC4an2EzC+POSdPi3B6dovcSa6Qm7NW+dcW6Oqpzu8jJFJjRGL07b248NHtW/KZtu1i7CqUHE2/NmxcTSkpiuxYtovsK7rFby9yKdfXz1q2imYAfAAAAAADqgN+mrWLpwd///vdpu3PnznHTTTfV9ZSahLy8vOi6xhoxYtSoKCkpWer81998m+779O5dcWxh++vhw5fu//2xRfsvNGLkyDj7/AujQ4f2aTDWCaeeXumYNL7MV7tffltMmD47Hvj1IbHvFutX6/0XFJfEMbc+krbbtWwRFz76YoydOqNax6B+Zr7qf9PjMWHWnLj/yD1jn43WrrTfep3KM3W0W0bwQ9sW5cfnLlg8SGZBSUkcc/8LFdde9NxbMXb67Gr+FDQUu3dul5bheqPgh8Dj9VqXZ1tr+30g1pLa5pQHgs4tSa78wYLS0jj+3a/SdrtmWfGnz0fHuDlLBwDS8H1aOC/dXzx6UnR++/PFtsQ384rS9rrvfbHaYy0oLYtfDx+XtttmZcblYyfH+O/LZNK4fFFUlO6vmj4tNh01crEtMbK4OG3vOHrUMu/x6OzyFyZ+1mr5JSoXlJXFeQUFabt1ZmZcP316TCxeOqiUhTLqaAMAAAAAaPwEYK2kzz77LAYMGBDFxcXRokWLePjhh9MgrKoYM2bMcreFGbb4wS477xSFhYUx7M23ljr33Esvpfu+O+/4Q/8f75Tun3/p5aX7v/hSxT0XlfzZHnHciTFr1qx48M474qzTTo033no7Lr7sh5KTNM7gqyTzVRJ8df+vD479t9qw2sc4/5EX4v2R4+P3+/aNwSf+PKYWzo1jbn00LWlK4w2+SjJfJcFX9x2xZ+y/ybIzqu3au7xkXFJGcElJkNXwKTMiLyc7Oi1RuvCP/34rPhg7OX7fb+sYfGj/mDpnfhz7wItRurDuHE3KhHnlAQ/NFsko1LdT23T/5cy5S/VPgqy+nT038rIyo1PzxbPLXPTpqPhwemGcvUH3GLTtejG1qDhOeO+rinKZNB4btGweR3RqV+mWaJOVmbYPzi//enVcOnZSfFw4L87slh839F4zphWXxKnDx1lXjdC6zXLioFatKt0SrTMy0vZ+ywiuml5SEq/MmRNtMzNj95bLLwd93fRp8XlRUZzQtm38pWN+zCgtjT8UFFhXAAAAAADUOjWwVsKIESNijz32iGnTpkVWVlY88MAD0bdv3yrfr3v3pUtQUa6gYEoUTJkS+R07Rn5+x4rjJx53TDzwyKNxwSWXxgtPPRE5OeUlu/793Avx6pChscfu/WKtnj0r+h980IA494KL4vqbb43jjj4yuq9ZHuAwdty4+Mct/0zvPWD/fRcbOwm0evPtd+J3Z5wW/fvtmgZ0vTLk9bjsb1fHT/rtFj/e6YcALxqWglmFUTBrTuS3bhn5rfOWKjs4fvqsuP+Ug+PArTeq9rFf+PSbuOa5N+JHvXvEhQfuFtlZWfHr3X8UN770dlzxzOtx3n67VPuY1I6krGBB4bzIz2sR+YsERy0sOzh+5py478g94sBNl1/Osnd+2/jJej3iha/GxG1vfx7H/+iHdfjXlz9ISw8evtV6kZ31Q8z0i1+NiWuGfBQ/6tklLvjJtum5U3bcNG5645P46yvvx+9336aGPjW1oWD+gpgyf0F0bN4s8hcJjvpg2qzYqn3rpfp/PH123PbtxLTs1m6dfwiUWadVbpoZ66VJ02PwiIlxbK81Ks5d9eW4mL6gJA7t2SmyFwnaeum76XHd1+Njuw6t4w8b9kzPnbTOGnHLtxPjqi/Hxtkb9KjRz07NmbKgOKYWl0SH7Kzo2Kz8R4Bd2rZKt8rcO3l6dG6WHdes0221x351xuy4acKU2LpVbvyue6fIzsiI47q0j9u/mxbXjS+IM9fstNpjUDemlZTEtNKSaJ+ZFe2zyrPt7ZCbm26VeWz27OiYlRUXd8xf5j2fKpwdSW60ffPyImc55QTfmDs37pw5MzbLaR6ntG2XrqtDW7eOB2bNittmzohftV39wEEAAAAAAFhZArBWYPz48dG/f/90n5Sku/322+OAAw6o62k1KIMG3xVD33gzbX/yWXlJm0F33h2vvj40be+84w5xwrFHp+1/3HJrXHzZFXHRH86NgeefV3GP3Xbpm/ZJ7rXVjrvEPj/dIyZMnBgPPvp4Wi7w+qv+utiY7du3i39c9bc46oST0v6H/HxAevzBRx6PKVOmxoN33RGtW//wS+whQ4elgVZbbbF5XDrwgvRYEuR13x2DYuudd40jjz8xPn5raLRr5xc59cVtr70Xw74anbY/Hftd+bEh78drX5SXt9lpvZ5x/C7lQSg3vPh2XPKvV+KCA3aLiwb0q7hH/8tvj9FTZqTBUf8d8126LWnR/qs6bhL4ddygx6J1i5y45+RfpMFXib8esmcM+XJEXPzEy9Fvo3XS8akfkgCoYSMmpO1PJ05J97e/8794bfj4tL1Tr64VAVI3DvskLnnh3TQA6sI9tqu4RxJ8NXr67DQ46pMJU9JtSYv2T1w/YJfoe8OjcfIjr8STn30b63dqHx+NnxyvfDMu1mrfOq7YZ8fFAr+Oe/DFaN08J+4+Yo+KwKy/7rtjDPl2XFz8/LuxW5/u8aOePwTbUPeSAKg3ppSX1PpsRmG6v3Pkd/H69yUDd+zYuiJA6pbhE+Ky/42JP2zYI87f6Ifg4iPe+jINMNiyfV50z20eRaVl8fXsufHyd9MjyfXyt817xVp5LRYb99ot14l+r34Sp34wPJ4aPzUtS/jx9MJ4bfKM6NmyeVy66dqLBX6d+N5X0To7K+7Ybr2KwKzLNuuVzvPPn4+JXTu3i207LB0ERt24Z9K0eHvWnLT9v+/LRCbHhs0sX2M/at0yjuxcXub0tu+mxpXjCuJ3a+bHOd0719q4SeDXacPHR6uszLi595rpGk4M7Nkl3pw5J/46bnL8uG1ebN2q5WrNierz6KxZ8cH88vKUXy9YUBE49e688mNbNW8RP/v+/6PvnzUzbpoxI05p2zZ+3a78z3x1JWMlDmrVermBX3+cUhB5GRlxRX5+xbr6Xfv28d68eXHj9Onxoxa5sVnzysv7NlnJ92k5QW01NiYAAAAAQBMgAGs5CgoK4ic/+Ul8++236dfXX399HH10eaAQKy8Jvrrz3vsXO5aUEly0nODCAKzlueX6a2PTjTeKW2+/M/5+483RqlVemsXq0osuiN7r9Fqq/5GHHZJm0rrsyqvijrvvSwPott5y8/jjOWenGa4WmjZtehx5/EmRm5sb9w++rSK7VmL99frEtX/9S/zq1NPjV785Ix6+587V+E5QnZIgqLuGfbjYsTe+Hp1uCy0MhFqWUVOmp/u3h49Jt8osGYC1KuMeP+jxmDB9Vtx14s+jV6cffinZIqdZ3HPywbH9xTfHUTc/HO//6dRonesXhPVBEnx19/tfLHbsjZET0m2hRTNUVWbUtPIgm7dHf5dulVkyACvJgvXWGb+Igc+9E89/OTrNhrVG65ZpVqs//mSb6LxIYMIJD74cE2bOiTsP6x+9OrSpON6iWXbcc8QescPfH46j730h3vvtIWnwH/VDEnx176hJix17c8qsdFto0QxVlTl7/e7x74lT452ps+PZ+dPSEltrtMiJg3t2ipN7d600MCrJgjW03+Zxyeej44XvpqUZrrq0aJZmtfr9hj2i8yJr5OT3vo6J8xbEbdv2ibUXCeRqkZUZg7dbL/q+/N/45TtfxZu7bx6tv8+gRN1KgqAeLJix2LF3Zs9Nt4UWBkLV1bhnfDs+vltQHDf2XjPWWmS9tcjMjJvXXTP2/HREnPzNuHhl03Wi1feBytStJPjqycLyYLqFPpw/P90WWhiAVd0+mT8/vlmwIDbNyYn1Fvl/8iVdMKUgJpeUpGUHuzf7dB5vAAAASiRJREFUIVNg84zM+Gt+pzhs4oQ4t2ByPNK1W+Rl/pBBEgAAAAAAakpGWVlZkjSBJcyYMSP69esXH3zwQfr15ZdfHueee26tjD127Njo0aM8I86Yrz6rKJ8H1aHk4evrego0QmWTJ9b1FGikit76qK6nQCNUOHZaXU+BRui7ieVZwaA6TCwujp+MG5u2x4wZU+Uy9ov+bDn6nZeje9fazZA5dsLE6Lldv9X+HEDtW+zZVB3991tSUhKTJ09O2506dYoswdrUA9Yl9Y01SX1kXVLfWJPUR/V9XdaHnwmhIfI6cCXmzJkT++yzT0Xw1fnnn19rwVcAAAAAAAAAAEDDIQBrCUVFRTFgwIAYNmxY+vUZZ5wRf/7zn+t6WgAAAAAAAAAAQD2UXdcTqG8OO+yweP7559N2UoLw+OOPj08//XSZ/XNycmK99darxRkCAADAqsr4fqvtMQEAAAAAGj8BWEt47LHHKtovv/xybLbZZsvtv9Zaa8XIkSNrYWYAAAAA1HfvvfdePPvsszF06ND4/PPPY/LkydGsWbPo1q1b7LTTTunLfjvvvPNK3+/f//533HrrrfHuu++m9+rUqVNsu+22ceKJJ8Zee+1Vo58FAAAAgJUjAAsAAAAavYyIDBmwoKb17ds3Xn/99aWOFxUVxddff51ugwcPjqOPPjr++c9/ppnVl6W0tDQNsrrtttsWOz5u3Lh0e+KJJ+KEE06IW265JTIzM2vk8wAAAACwcgRgLaGsrKyupwAAAABAAzR+/Ph0n2S7+sUvfhE//vGPo2fPnlFSUhJvvvlmXHXVVWnw1F133RULFiyI++67b5n3Ov/88yuCr7bccss455xzonfv3jF8+PD461//Gh9++GEMGjQozYh12WWX1dpnBAAAAGBpArAAAAAAoBpssMEGaTDUz372s8jKylrs3Pbbbx9HHXVUWobwq6++ivvvvz9OPvnkNGvWkpLzV155ZdreZpttYsiQIZGbm5t+nZQf3H///WOXXXZJyx3+7W9/i+OOOy7WXXfdWvqUAAAAACxJfnIAAABo7DLqaIMm5umnn46DDz54qeCrhfLz89MsWAs98sgjlfa79tpro7i4OG1ff/31FcFXC7Vs2TI9nkj6XXPNNdX4KQAAAABYVQKwAAAAAKCW7LbbbhXtpJzgksrKyuJf//pXRUatJHNWZZLj66+/ftpO+ifXAQAAAFA3BGABAABAoycFFtQX8+fPr2hXlilrxIgRMX78+LSdlBlcnoXnx40bFyNHjqz2uQIAAACwcgRgAQAAAEAtee211yraG2644VLnP//884p2kgFreRY9/7///a/a5ggAAADAqslexf4AAAAAQBWUlpbG5ZdfXvH1wQcfvFSfsWPHVrS7d+++3Pv16NGjoj1mzJiVnseiY1RmwoQJFe2SkpJ0q23JmMn3a2Eb6gPrkvrGmqQ+si6pb6xJ6qP6vi7r45ygIRCABQAAAI1dRkb5VttjAou55ppr4p133knbBx10UGy99dZL9Zk1a1ZFu1WrVsu9X15eXkV79uzZKz2PRQO3VmTKlCnRvHnzqG3JLyNmzJhR8XVmpkT+1D3rkvrGmqQ+si6pb6xJ6qP6vi6TnwOBVVe//ksGAAAAgEZaevD3v/992u7cuXPcdNNNlfabN29eRTsnJ2e591w0MGru3LnVNlcAAAAAVo0MWAAAANDYJcmoaj0DVu0OB/XZZ599FgMGDIji4uJo0aJFPPzww2kQVmWS8wsVFRUt977z58+vaOfm5q70fFZUrjApQbjddtul7Y4dO0anTp2iLkte5OfnR1ZWVq3PAZZkXVLfWJPUR9Yl9Y01SX1U39floj9rAitPABYAAAAA1JARI0bEHnvsEdOmTUsfqj/wwAPRt2/fZfZv3br1SpcVLCwsXOlyhYvq3r37SvdN5lxXvwxYWIajLucAS7IuqW+sSeoj65L6xpqkPqrP67K+zQcaCiUIAQAAAKAGjB8/Pvr375/uMzIy4vbbb48DDjhgpYOjxo4du9KZrHr06FENMwYAAACgKmTAAgAAgKZRg7AOxoSmq6CgIH7yk5/Et99+m359/fXXx9FHH73C6zbaaKOK9hdffLHcvoue33DDDVdrvgAAAABUnQxYAAAAAFCNZsyYEXvuuWd8/vnn6deXX355nHrqqSt1ba9evaJbt25p+7XXXltu3yFDhqT7NddcM9Zee+3VnjcAAAAAVSMACwAAABq7jIy62aAJmjNnTuyzzz7xwQcfpF+ff/75ce6556709UmpwoVlCpMMV2+99Val/ZLjCzNgJf2T6wAAAACoGwKwAAAAAKAaFBUVxYABA2LYsGHp12eccUb8+c9/XuX7nHnmmZGVlZW2TzvttJg7d+5i55Ovk+OJ7OzstD8AAAAAdSe7DscGAAAAgEbjsMMOi+effz5t9+vXL44//vj49NNPl9k/Jycn1ltvvaWOJ8fOPvvstHThe++9FzvttFOaRat3794xfPjwuOKKK+LDDz9M+yb9+vTpU4OfCgAAAIAVEYAFAAAAjV5Smqy2y5Mph0bT89hjj1W0X3755dhss82W23+ttdaKkSNHVnru0ksvjUmTJsXtt9+eBlsdeuihS/VJAryqkmELAAAAgOqlBCEAAAAA1DOZmZlx2223xTPPPBMHHHBAdOvWLc2YleyTr5999tkYNGhQ2g8AAACAuiUDFgAAADR2GRnlW22PCU1MWVlZtd9z7733TjcAAAAA6i+vyAEAAAAAAAAAAFSRDFgAAADQ2MmABQAAAABQY2TAAgAAAAAAAAAAqCIBWAAAAAAAAAAAAFWkBCEAAAA0ekk5wNouCagEIQAAAADQNMiABQAAAAAAAAAAUEUyYAEAAEAjl5GRkW61PSYAAAAAQFMgAxYAAAAAAAAAAEAVCcACAAAAAAAAAACoIiUIAQAAoLFLygHWdklAJQgBAAAAgCZCBiwAAAAAAAAAAIAqkgELAAAAmgQZqQAAAAAAaoIMWAAAAAAAAAAAAFUkAAsAAAAAAAAAAKCKlCAEAACARi8jIqO2SxAqeQgAAAAANA0yYAEAAAAAAAAAAFSRDFgAAADQ2GXUQQasWs+4BQAAAABQN2TAAgAAAAAAAAAAqCIBWAAAAAAAAAAAAFWkBCEAAAA0ekk5wNouCagEIQAAAADQNMiABQAAAAAAAAAAUEUyYAEAAEBjl5FRvtX2mAAAAAAATYAMWAAAAAAAAAAAAFUkAAsAAAAAAAAAAKCKlCAEAACAxi6pBljbFQFVIAQAAAAAmggZsAAAAAAAAAAAAKpIBiwAAABo9KTAAgAAAACoKTJgAQAAAAAAAAAAVJEMWNDEZP3itLqeAsBKy/51Xc+AxqhlXU+ARqlTXU+ARqXduHER621c19MAAAAAAGAlCcACAACAxi4jo3yr7TEBAAAAAJoAJQgBAAAAAAAAAACqSAYsAAAAaOxkwAIAAAAAqDEyYAEAAAAAAAAAAFSRACwAAAAAAAAAAIAqUoIQAAAAGr2kHGBtlwRUghAAAAAAaBpkwAIAAAAAAAAAAKgiAVgAAADQJBJgZdTyVrMfadKkSfH000/HhRdeGHvttVfk5+dHRkZGuh177LE1Mub9998fe+yxR6yxxhrRokWLWGutteLII4+MN998s0bGAwAAAAAaBiUIAQAAgAanS5cutTbW3Llz4+c//3k8++yzix0fPXp03HvvvWlgVhIIdtFFF9XanAAAAACA+kMGLAAAAGjsaj371fdbLenZs2eamaqmHHfccRXBV7vttls88cQT8c4778Rtt90WvXv3jtLS0hg4cGDceuutNTYHAAAAAKD+kgELAAAAaHCSjFPbbrttuiXZsEaOHBm9evWq9nFefvnleOCBB9L2fvvtF48//nhkZWWlXydj77///rH11lun2bDOPffc+MUvfhHt27ev9nkAAAAAAPWXDFgAAABAg3PxxRfHvvvuW+OlCK+88sp0n52dHTfeeGNF8NVC+fn5ccUVV6Tt6dOnx6BBg2p0PgAAAABA/SMACwAAABq9jDraGrZZs2bFSy+9lLb79+8f3bt3r7TfQQcdFG3atEnbSYYsAAAAAKBpEYAFAAAAUIl33303ioqK0vYuu+yyzH45OTmx/fbbV1yzYMGCWpsjAAAAAFD3BGABAABAY5eRUTdbA/f5559XtDfYYIPl9l14vri4OL7++usanxsAAAAAUH9k1/UEAAAAgJo1YeJ3dTrmhAkTVth/WeX96tLYsWNXen49evSoaI8ZMyY22mijGp0bAAAAAFB/CMACAACARm67vv3qdvzttlthn7KysqhvZs2aVdFu1arVcvvm5eVVtGfPnl2j8wIAAAAA6hclCAEAAAAqMW/evIp2Tk7Ocvs2b968oj137twanRcAAAAAUL/IgAUAAACN0BprrJGWwqtrSfnBTp06RXZ2w3sE0aJFi4p2UVHRcvvOnz+/op2bm1uj8wIAAAAA6peG9/QTAAAAWKEk4Kl79+51PY16MYeqat269UqXFSwsLFzpcoUAAAAAQOOiBCEAAADACoLHxo4du9y+i2Yb69GjR43OCwAAAACoXwRgAQAAAFRio402qmh/8cUXy+278HySeaxPnz41PjcAAAAAoP4QgAUAAABQiW233TZycnLS9muvvbbMfkVFRfHWW29VXNOsWbNamyMAAAAAUPcEYAEAAABUonXr1rH77run7RdffHGZZQgfe+yxmDlzZtoeMGBArc4RAAAAAKh7ArAAAACAJmnw4MGRkZGRbgMHDqy0z+9+97t0X1xcHKeeemqUlJQsdr6goCDOPffctN2uXbs44YQTamHmAAAAAEB9kl3XEwAAAABYVUOHDo1vvvlmsUCohZLjSXDVoo499tgqjdOvX7849NBD44EHHognn3wyfvKTn8SZZ54Z3bp1i08++SQuvfTSGD16dNr3iiuuiPbt21f5MwEAAAAADZMALAAAAKDBGTRoUNx5552Vnhs2bFi6VUcAVuL2229PSww+++yz8corr6TbojIzM+OCCy6IE088scpjAAAAAAANlxKEAAAAAMuRm5sbzzzzTNx7771pBqzOnTtHTk5O9OjRIw4//PA0G9eyShgCAAAAAI2fDFgAAABAg5OUGFyyzOCqSrJirUpmrCTYKtkAAAAAABYlAxYAAAAAAAAAAEAVCcACAAAAAAAAAACoIgFYAAAAAAAAAAAAVSQACwAAAAAAAAAAoIoEYAEAAAAAAAAAAFSRACwAAAAAAAAAAIAqEoAFAAAAAAAAAABQRQKwAAAAAAAAAAAAqkgAFgAAAAAAAAAAQBUJwAIAAAAAAAAAAKgiAVgAAAAAAAAAAABVJAALAAAAAAAAAACgigRgAQAAAAAAAAAAVJEALAAAAAAAAAAAgCoSgAUAAAAAAAAAAFBFArAAAAAAAAAAAACqSAAWAAAAAAAAAABAFQnAAgAAAAAAAAAAqCIBWAAAAAAAAAAAAFUkAAsAAAAAAAAAAKCKBGBVYtKkSfH000/HhRdeGHvttVfk5+dHRkZGuh177LF1PT0AAAAAAAAAAKCeEIBViS5dusR+++0Xl1xySfznP/+JKVOm1PWUGrR77n8wTjrtzNhm512jefvOkZHXLgbffe8q36e0tDSuv+mW2HTbHSO34xrRaa3ecdgxx8e3I0Yu85rnXngpdtlz72jdpXu0WaNH7LbXvvHSK6+t5ieiPrCuqCnWFjXBuqImWFfUBOsKAAAAAABWnQCsFejZs2fssccedT2NBu2Pf/pz3Hr74Bg1Zkx0XaNLle+T/CLo9N+dG2VlZXH6KSfFT/vvHo89+VRs23e3+Pqb4ZX+8uinB/4s/vfFV3HskYfFMUccGp99/kX8ZL8D45HH/7Wan4q6Zl1RU6wtaoJ1RU2wrqgJ1hUAAAAAAKy6jLLkiTiLueiii2LbbbdNtyQb1siRI6NXr17puWOOOSYGDx5co+OPHTs2evTokbbHfPVZdF9zzWjIXnz51eiz7jqxVs+ecfmV18R5F10cd9x8Qxx71BErfY9XXhsS/fbeP/ruvGO88NQTkZOTkx7/93MvxN4H/SL22L1fPPfkYxX9p02bHutssnlkZ2fHh28Mqfgejh03LrbcsW/a/vbTj6J169bV/nmpHdYVNcXaoiZYV9QE64qaYF3VD8ln77Hexml7zJgx0b1797qeEtDELPZsqo7+HiopKYnJkyen7U6dOkVWVlatzwGWZF1S31iT1EfWJfWNNUl9VN/XZX34mRAaIhmwKnHxxRfHvvvumwZfsfr699s1/QXO6vjnHXel+0suOL/iFziJvfb8Sezad+d4/qWXY/SYMRXHH378iZg+fUacdvKJiwWwJe3fnPSrKCiYEo8/+XTF8ZNP/21aXiX5JdOSFp674qprV+szUL2sK2qKtUVNsK6oCdYVNcG6AgAAAACAVScAiwbh1deHRl5eXuy0w/ZLndtz993T/WuvD/uh/5Ch6T55u36p/v2/7z/0h/7XXHFZbLjB+nHhny+Ld9//oOL4408+Fbfcdkf026VvnP3b06v5U1HXrCtqirVFTbCuqAnWFTXBugIAAAAAoKkRgEW9V1hYGBMmToxea61VafrFpERK4uvhwyuOLWz36d176f7fH1u0f25ubtx/x6DIzMyMw449PmbPnp2W/Tjh1NOjY8cOcfdtt6TnaDysK2qKtUVNsK6oCdYVNcG6AgAAAACgKcqu6wnAisyYOTPdt23bptLzbVqXH58xY+ZKXdOmTeul+ic232zTuOKSgXHmOefFKWecFWPHj4+pU6fFvx66L7p17VqNn4j6wLqiplhb1ATrippgXVETrCsAAAAAAJoiAVh1YOzYscs9P2HChFqbC4s7/dcnx3Mvvhz3PPBQ+vUpvzo+9t9n77qeFg2cdUVNsbaoCdYVNcG6oiZYVwAAAAAA1BfqMtSBHj16LHfbbrvt6nqK9UrbNku/Jb+ombOWfmN+edfMnDlrqf4LZWRkxIH77VPx9Wknn7ja86d+sq6oKdYWNcG6oiZYV9QE6woAAAAAgKZIABb1Xl5eXnRdY40YMWpUlJSULHX+62++Tfd9eveuOLaw/fXw4Uv3//7Yov0XGjFyZJx9/oXRoUP79Bc6J5x6eqVj0vBZV9QUa4uaYF1RE6wraoJ1BQAAAABAUyQAqw6MGTNmuds777xT11Osd3bZeacoLCyMYW++tdS55156Kd333XnHH/r/eKd0//xLLy/d/8WXKu65qOLi4jjiuBNj1qxZ8eCdd8RZp50ab7z1dlx82eXV/nmoH6wraoq1RU2wrqgJ1hU1wboCAAAAAKCpEYBVB7p3777crWvXrtFUFRRMiS++/CrdL+rE445J9xdccmkUFRVVHP/3cy/Eq0OGxh6794u1evasOH7wQQPSMiXX33xrjB03ruJ40v7HLf+M/PyOMWD/fRcbI/llzZtvvxP/d/pvon+/XeOyiy+MrbbYPC7729Xx+rA3avBTU9OsK2qKtUVNsK6oCdYVNcG6AgAAAACAchllZWVl37dZhpEjR0avXr3S9jHHHBODBw+u0fHGjh0bPXr0SNtjvvosuq+5ZjRkgwbfFUPfeDNtf/LZ5/HBRx/HTjtsH+uuU/493XnHHeKEY49O2wMv/UtcfNkVcdEfzo2B55+32H1+derp6b023nDD2Oene8SEiRPjwUcfj1at8uLNl1+I9fqsu1j/e+5/MI464aTolJ8fh/x8QHrswUcej4IpU+LBu+6IXxx0YEXfIUOHxW577RdbbLZpvPnKC5GTk5Me//Krr2PrnXeNjh3ax8dvDY127drV8HeLlWVdUVOsLWqCdUVNsK6oCdZV/ZAEn/VYb+O0nWRJTl7UAahNiz2bqqO/h5KyspMnT07bnTp1iqysrFqfAyzJuqS+sSapj6xL6htrkvqovq/L+vAzITRE2XU9ARq/5Bc4d957/2LHknIki5YkWfhLnOW55fprY9ONN4pbb78z/n7jzekvb5I34S+96ILo/f0vhBZ15GGHRH7HjnHZlVfFHXffFxkZGbH1lpvHH885O31LfqFp06bHkcefFLm5uXH/4NsqfoGTWH+9PnHtX/+S/gLpV785Ix6+587V+E5Qnawraoq1RU2wrqgJ1hU1wboCAAAAAIBVJwPWSpABCwAAgNoiAxZQ1+rD2871/Y1wmibrkvrGmqQ+si6pb6xJ6qP6vi7rw8+E0BBl1vUEAAAAAAAAAAAAGioBWAAAAAAAAAAAAFWUXdULG7OhQ4fGN998U/F1QUFBRTs5vmQJwmOPPbZW5wcAAAAAAAAAANQPArAqMWjQoLjzzjsrPTds2LB0W5QALAAAAAAAAAAAaJqUIAQAAAAAAAAAAKgiAViVSEoMlpWVrfQGAAAAAAAAAAA0TQKwAAAAAAAAAAAAqkgAFgAAAAAAAAAAQBUJwAIAAAAAAAAAAKgiAVgAAAAAAAAAAABVJAALAAAAAAAAAACgigRgAQAAAAAAAAAAVJEALAAAAAAAAAAAgCoSgAUAAAAAAAAAAFBFArAAAAAAAAAAAACqSAAWAAAAAAAAAABAFQnAAgAAAAAAAAAAqCIBWAAAAAAAAAAAAFUkAAsAAAAAAAAAAKCKBGABAAAAAAAAAABUkQAsAAAAAAAAAACAKhKABQAAAAAAAAAAUEUCsAAA/r+9OwGXczwfx/+QSEQkQmJPrBFBLUEQqokgpaH2KhWktq/iG6SoNVFFVUksRS1fLaq22reGNlIEIU1rrV2INdYEkRDnf91PfzP/c07OlslZ5px8Ptc117znzDtznonHO+97z33fTwIAAAAAAAAojQQsAAAAAAAAAACAEknAAgAAAAAAAAAAKJEELAAAAAAAAAAAgBJJwAIAAAAAAAAAACiRBCwAAAAAAAAAAIASScACAAAAAAAAAAAokQQsAAAAAAAAAACAEknAAgAAAAAAAAAAKJEELAAAAAAAAAAAgBJJwAIAAAAAAAAAACiRBCwAAAAAAAAAAIASScACAAAAAAAAAAAokQQsAAAAAAAAAACAEknAAgAAAAAAAAAAKJEELAAAAAAAAAAAgBJJwAIAAAAAAAAAACiRBCwAAAAAAAAAAIASScACAAAAAAAAAAAokQQsAAAAAAAAAACAEknAAgAAAAAAAAAAKJEELAAAAAAoU1OnTk0jR45Mffv2TZ07d07LLLNM6t+/fzr33HPTl19+2dLDAwAAACCl1L6lBwAAAAAAzOuuu+5K++23X5oxY0bxd5F09dRTT+XblVdeme65557Uu3fvFh0nAAAAwMJOBywAAAAAKDNTpkxJe++9d06+WnLJJdOZZ56ZJk6cmP72t7+lQw45JO/z0ksvpaFDh6aZM2e29HABAAAAFmo6YAEAAABAmRkxYkSaNWtWat++fRo3blwaMGBA8bHBgwentdZaKx1//PE5Ceu8885Lo0ePbtHxAgAAACzMdMACAAAAgDIyadKk9PDDD+ftgw46qEryVcHIkSPTOuusk7cvuOCC9PXXXzf7OAEAAAD4LwlYAAAAAFBGbr/99uL28OHDa9xn0UUXTfvvv3/e/vTTT9P48eObbXwAAAAAVCUBCwAAAADKyCOPPJLvO3funDbZZJNa9xs4cGBx+9FHH22WsQEAAAAwLwlYAAAAAFBGXnjhhXzfu3fv1L59+1r369u37zzPAQAAAKD51R7BocV88803xe1333uvRccCAABA86p8HVj5+hBYOHz11Vfpww8/zNs9e/asc9+ll146d8n64osv0ltvvdXgvzFt2rQ6H6/8WrHv3LlzU3OLv/nxxx/n7S+//DK1a9eu2ccA1ZmXlBtzknJkXlJuzEnKUbnPy3fffbe4LTYFDScBqwxNnz69uL3Z97Zt0bEAAADQcuL6cLXVVmvpYQDNaObMmcXtJZdcst79CwlYn3/+eYP/Rq9evRq874ABAxq8LwAAAG2L2BQ0nCUIAQAAAKCMOmAVdOjQod79O3bsmO9nzZrVpOMCAAAAoHY6YJWh9ddfP02aNClvL7vssql9e/+Z6mp/uNlmm+Xt+DdbccUVW3pItBHmFk3BvKIpmFc0BfOKpmBeNVy0di90Ro7rQ2Dhsvjiixe358yZU+/+s2fPzvedOnVq8N+ob7nCSAL7z3/+k5ZffvkWi0353KAcmZeUG3OScmReUm7MScpRuc9LsSkojcyeMg209e/fv6WH0erEB1PPnj1behi0QeYWTcG8oimYVzQF84qmYF7VT2t3WHh16dKluN2QZQVj+cGGLldY0JBjcO/evVO58LlBOTIvKTfmJOXIvKTcmJOUo3Kdl2JTMP8sQQgAAAAAZVSY171797w9bdq0Ovf95JNPiglYvXr1apbxAQAAADAvCVgAAAAAUEbWXXfdfP/KK6/kpR9qE8sEFqyzzjrNMjYAAAAA5iUBCwAAAADKyHe/+918H92tJk+eXOt+EyZMKG5vtdVWzTI2AAAAAOYlAQsAAAAAysiuu+5a3L766qtr3Ofbb79N11xzTd7u1q1b2mabbZptfAAAAABUJQELAAAAAMrIZpttlrbeeuu8fdVVV6XHHntsnn3OO++89MILL+TtESNGpMUWW6zZxwkAAADAf7X/f/cAAAAAQJm44IIL8rKCs2bNSkOGDEknnXRS7nIVP99www3p8ssvz/v16dMnjRw5sqWHCwAAALBQk4AFAAAAAGWmX79+6cYbb0z77bdfmjFjRk7Aqi6Sr+65557UpUuXFhkjAAAAAP+1SEVFRcX/2wYAAAAAysjUqVNzN6xItJo2bVrq0KFD6t27d9prr73SkUcemZZYYomWHiIAAADAQk8CFgAAAAAAAAAAQIkWLfWJAAAAAAAAAAAACzsJWAAAAAAAAAAAACWSgAUAAAAAAAAAAFAiCVgAAAAAAAAAAAAlkoAFAAAAAAAAAABQIglYAAAAAAAAAAAAJZKABQAAAAAAAAAAUCIJWAAAAAAAAAAAACWSgAUAAAAAAAAAAFAiCVi0Ok899VT65S9/mYYMGZJ69uyZOnbsmJZccsnUp0+fNHz48PTII4+09BBpQ0444YS0yCKLFG8PPfRQSw+JVmjOnDnpyiuvTN///vfTiiuuWDxurb322vm4NXHixJYeImXigw8+SHfffXc67bTT0o477ph69OhRPP4ceOCBJb3mgw8+mJ/bu3fv1Llz57TUUkvlz8w999wzXXrppenzzz9v9PdBeZkxY0a64YYb0siRI9PAgQPzXIh50KFDh7TccsulQYMGpd/85jfpo48+qvU1vv7663T//fenY445Jm255ZZ5bi622GKpW7duaeONN07HHXdceu2115r1fVF+3nzzzTRq1Ki06aabpmWXXTYtvvjiqVevXmnrrbfOx7Vnn322wa/15ZdfpjXWWKN4DFxttdWadOwAlJepU6fmc5e+ffvmc9hlllkm9e/fP5177rn5MwLKMcZ43333pd122634WnEfP8fvoSVilOYk5XjdZ15SbjF3c5Lmjtk3xpz75ptv0mWXXZaPvXEs7tSpU1pzzTXTYYcdlp577rn5HhPQiCqgFdl6660rYtrWd9t///0rZs+e3dLDpZWbMmVKRfv27avMrfHjx7f0sGhl3njjjYr11luv3uPWUUcdVfHtt9+29HBpYXXNkQMOOGC+Xuvjjz+u2GWXXeqde3Gso2174IEHGnT+1KNHj4r7779/nud/8MEHFd27d6/3+R06dKgYO3Zsi7xHWt6FF15Y0blz5zrnyIgRIxr8eiNHjqzy3FVXXbVJxw9A+bjzzjsrunbtWuvnSZ8+fSpefvnllh4mrVxjxhjnzp1bcdBBB9X5OgcffHDeD5ojRmlOUo7XfeYl5RZzNydp7ph9Y8256dOnV/Tv37/W1+jYsWPFFVdc0QjvHChF+8ZM5oKm9s477+T7lVZaKe211145s3eVVVZJc+fOTY899lg677zz0ttvv52uueaa3Knh+uuvb+kh00p9++236dBDD81Z5NEdJDLcYX7FcWjo0KHFioMNNtggHXvssbkKZ+bMmbmaNo5bX3zxRbrooovyse0Xv/hFSw+bMhGfb1HxP27cuPl+7meffZa23377NHny5PxzVNBEx6uogmnXrl1666230oQJE9Jf/vKXJhg55SiqUbfZZpu0ySab5O2oDIzPumnTpqVbbrkl3XrrrenDDz9MP/zhD9OkSZPShhtuWHzu7Nmzi92xNtpoo7TLLrukzTffPC2//PJ5rkV1VhzDvvrqq3T00Ufniqv4DGXh8atf/SqdeuqpeTs6RhxyyCG5S0l0Wou5M2XKlHTbbbelRRdtWAPm2H/s2LG5kjo6rcVnJgALh/gM2HvvvdOsWbNyB4MTTzwxn8PEz9HR84orrkgvvfRSvs6K7kVdunRp6SHTSjVmjPHkk09OV111Vd7u169fOv744/O116uvvpo7zca8jg4d0Z3grLPOarb3yMIbozQnKcfrPvOScou5m5M0d8y+MeZcnKtGrP/JJ5/MP+++++75eBwdg5944ol8rI5zheiEtfLKK+eOXUAzKyltC1rI0KFDK2688caKb775ptas36iELGT5TpgwodnHSNswZsyYPIf69u1bceKJJzaougyqu/nmm4tzZ8CAATUeu5566qmKxRZbLO/TrVu3iq+//rpFxkp5OO200yruuuuuivfeey///Prrr5dUTTNs2LBitcsdd9xR635RAWbOtX21nTdVdttttxXn2m677VblsWnTplVsv/32FY899litz3/88ccrOnXqlJ+/1FJLVcyYMaNRxk75e/DBB6t0iJgzZ06t+zakQ23M10022SS/3i9/+cvc+UoHLICFrytRdHqZOHHiPI//5je/KX7ujBo1qkXGSNvQWDHGF198sdiZaNNNN6348ssvqzz+xRdf5N8X5rXubTR1jNKcpByv+8xLyi3mbk7S3DH7xppzV111VfFv/+xnP5vn8XheoZtw7969xf6hBTSsBBnKRKyx+6Mf/Sh376hJrLsbme0F0dEBSlnHvlDNE2sod+jQoaWHRCtVeZ35qNyu6dgV3Wh22mmnvP3pp5+mF154oVnHSHk5/fTT83yIzkKliiqva6+9Nm9HxUt0NKpNrFPfvr2GqG1dbedNle266665UjA8/PDDVR6Laqmo6tpiiy1qfX50xPrZz36Wt6Mr1gMPPLDA46Z1VOMffvjheTu6pkUVX3Ssqk1DzqkuuOCC3L0v5uMJJ5zQqOMFoLxFF87CechBBx2UBgwYMM8+I0eOTOuss07xMyM6IEBLxhija2d0JgrRZSO6wVa2xBJL5N+H2G/MmDGN+C5o60qJUZqTlON1n3lJucXczUmaO2bfWHPut7/9bb6PjlfnnnvuPI/37t07/38RXnnlldyZEGheErBoc6I1fUG0bYT5dcQRR6TPP/88HXDAAWngwIEtPRxasTlz5hS311hjjVr3izazNT0HSnHxxRfn+2gBf+SRR7b0cGhFCkv4xFKCpXAOtvCJxLyXX345b0ey1IImdE6dOjWddtppeVsSPMDC5/bbby9uDx8+vMZ9Ylmj/fffv/hl2vjx45ttfCx86ju/raioSHfccUfejqVoaitYiN8Xih1i/3geNEWM0pykHK/7zEvKLeZuTtLcGmvOxVLshWTCKCSIpK2aHHjggcVtCVjQ/CRg0ebMnj17vjo+QGU33XRTroKM7PFCJjmUqnCyHF577bVa9ysEcqMb0VprrdUsY6NtimBC4WJu++23T4svvnhxbfi33norvfHGGyUn19C2vfjii+lf//pXMRBQCudgC5+bb765+PlVqCwNH3/8cQ7Qx/38iC5qX3zxRRo2bFgaNGhQo48XgPIWnVxD586dc9eC2lROQnj00UebZWwsnOo7v3399dfTO++8k7frS44pPP7222/n6zJoihilOUk5XveZl5RbzN2cpLk11pwrXC/V9zorrLBC6tOnT952vQTNTwIWbc6ECROK24W29NAQUT07YsSIvH3OOefkdvOwIPbZZ5/UtWvX4pyKJJjqpkyZku655568ve+++xb3h1L8+9//LiZYrb/++mnGjBnp6KOPzsezVVZZJa2++uq5M1YkZz300EMtPVxa2JdffpmDpeeff36+aC+0wY45UwrnYAufxx9/PN+vttpquYPa9ddfn4893bt3z4GeuI/AaHxhVPkLzJrccMMN6d57701LL710leV+AFh4FKq5Y9mMurprVE4Wt4Q7Tam+89vnn3++uF1fEYN5S3PEKM1JyvG6z7yk3GLu5iTNrbHmXCmvE0XZUewINB8JWLS59ch//etfF3+OFozQUMcff3x677330lZbbZUOOuiglh4ObUAEyK699trcCjYqDfr375+uueaaHLh48MEH89rhkfQQXYs23nhjXzizwCpfhMVn4qabbpouuOCCHLwtiPkW82/w4ME5SMHC5Q9/+EOu/ItbdJeIYOnIkSPT+++/nx//xS9+kQNT8+vdd99NV199dd5edtllqyzXQtsUx5j//Oc/xc+7+ILoJz/5SXr22WfnaY9+3HHH5WNO5WNRZZ988kkx8S/O5WMOAbBwiSKCDz/8MG/37Nmzzn0jWTfOYwpfKEBLxRinTZtW3K5v3vbq1au4bd7SVDFKc5JyvO4zLym3mLs5SXNrrDlXyuvEMoaVnwc0PQlYtCljxoxJkyZNytu77757nS3robKHH344XXnllbnK9rLLLstfTENj+OEPf5gmT56cDj744Ly81wEHHJAGDBiQOxCNHj06XyiOHTs2z8Hll1++pYdLK1e57XskV0V3ox122CF/NsaXWh988EG69NJLcxesuPiKZJvCkoUs3DbaaKM8T84+++z5/gyMuXTYYYelmTNn5p9PPfXU4vKXtF2fffZZDsaHZ555Jl144YVpxRVXTNddd10+FkWHtegascUWW+R9Jk6cmH7605/W+FoRqI8kwPh8POSQQ5r1fQBQHgrnEWHJJZesd/9CAtbnn3/epONi4dWQGOP8zNvCnA3mLU0VozQnKcfrPvOScou5m5M0t8aac+YutA4SsGgz4kQ/vkgOyy23XP6CGRoiKiEOPfTQ/AXyMccck77zne+09JBoY/MrKnAiySXmWHXxhXMELaI6BxZU5XbCkXAVQYe77747V4J17Ngxd5X5n//5n/y7RRf972ngiSeeWOPcpG3addddc9A0bvGF0p///Oe022675WBVtHCPuTG/zjrrrHTXXXfl7eh8dcQRRzTByCn3400EN8ePH5+roaMzSadOndL3vve99Pe//z1tuOGGeb/bbrstPfHEE1Ve5x//+Ef6v//7P0nwAAu5wjLaoUOHDvXuH+e2YdasWU06LhZODY0xzs+8LczZYN7SVDFKc5JyvO4zLym3mLs5SXNrrDln7kLrIAGLNuG5557LXx5+8803uePCzTffnAMk0NAvjqOV8iqrrJJGjRrV0sOhjQUptttuu9xRJqrCooV8rNs9e/bsXEE2bty49N3vfjc99dRTOSni/PPPb+kh08pV7zoUXbDatWs3z34x76KKO8ScjGQcFg7dunXLQfy4RWLej3/843TrrbfmoNVrr72Wdtlll7xMYUP96U9/yh2vwuqrr56uv/76YnIfC9fxJqpO11577Xn2i4D8mWeeWfz5xhtvLG7H52HhC6ZYymKDDTZo4lED0Bo+V+ILtfrEZ0jhcwZaKsY4P/O2MGeDeUtTxSjNScrxus+8pNxi7uYkza2x5py5C62Db0do9V5//fU0ZMiQ9Mknn+QvmW+44YZcdQENEUGNOFEPF110UZW2nLCgot1xtDkOV111VU6G6du3b65O6Nq1a+5OFFVj0TEmvnyOJZj+/e9/t/SwacW6dOlS3I5uV/369at13+9///vF7SeffLLJx0Z5GzZsWNprr73y0gJHHnlkleUsa3PPPfek4cOH5+PXCiuskB544IF8z8J3vAlxPl6bbbfdNne4qn68iQD9iy++mHr16pVOP/30JhwtAOWu8udKQ5bIKHTkaMhyhdBUMcb5mbeVu8iYtzRVjNKcpByv+8xLyi3mbk7S3Bprzpm70Dr892wIWql33nknZ7rHfSxXEsuXROcGaKgxY8bkTPE11lgjr1kfwbXqnn322eJ2tFN+77338vbOO+8sYYtaxcVdHJNCnz598jr0NYnAxBlnnJGrciLxITrPxLyEUkQSQ0HPnj0bvO/06dObdFy0DnEOddNNN+UL9Pvvvz/tu+++te770EMPpT333DN9/fXXedmBv/71r2nNNdds1vHSsgrLmhaOH5WPKdVFhV6PHj3yOVTl400ESUOczxeWsawtYBT3hfO06EIxePDgRn0/ALSs+Kzo3r17+uijj9K0adPq3DeSYwqfD3V9/kBTxxgrX3PVN2/feuut4rZ5S1PFKM1JyvG6z7yk3GLu5iTNrbHmXPXXiWNufa8T57X1fU8ANC4JWLRaH374Yc5kj+VyCpVB+++/f0sPi1am0IYz5tE+++xT7/5x0l65MlICFrWJdeYLHWTq6kIUNtlkkyoVj1Cq9dZbr7g9d+7cOvet/HihQpGFWwRVC6ZOnVrrfpMmTcoB/q+++ipXUN13332WjluIjzmRjDc/x5zKx5tCu/Srr7463+o79y+cqw0cOFACFkAbtO666+ZuBq+88kpe/q22c9TK10zrrLNOM46QtqrUGGPM2YZey5u3NEeM0pykHK/7zEvKLeZuTtLcGmvOVX+djTbaqN7XiSQu32NC87IEIa1SrOMcSyc9//zz+edf//rX6YgjjmjpYQEUVQ40xJcHdYkOMjU9D+bXqquumlZZZZW8/cYbb+SqsNq8+uqrxe2VV165WcZHeXv77bfrbU399NNPpx122CG3uY7q1uhatPnmmzfjKCknlZfkKXxhWZMZM2bkLzaD4w0AtYkOBSG6W02ePLnW/SZMmFDc3mqrrZplbLRdCxJjXH311dNKK600z7ysyT/+8Y/iudBqq622wOOGmpiTlON1n3lJucXczUmaW2PNucL1Un2vE50IX3rppbztegmanwQsWp1owTx06ND0z3/+M/988sknpxNOOKGlh0UrFa1nI0GhrtuoUaOK+8fa4YXfO+GmLssss0xecz489thjdV4QVj5ZjpNxWBB77LFHMfD1t7/9rdb9br311hov3lh43XzzzcXt9ddff57H48J9yJAhedmfxRZbLP3lL39JgwYNauZRUo7Hm3DbbbfVul88VkgI3XrrrYu/r+8cLG6RWBrivvC7QvU1AG3LrrvuWtyurTNiLCFzzTXX5O1u3bqlbbbZptnGR9uzoDHGWNKlsExhdBl4/PHHa9wvfl/oQhD7x/OgKWKU5iTleN1nXlJuMXdzkubWWHMult0sdMW66aab8rlsbecUBbvttlujvQ+gYSRg0arEMiXxYfHoo4/mn0eMGJF+9atftfSwAOax6KKL5kBueOedd9KZZ55Z436RyFA5wLvTTjs12xhpm44++ujcmSgce+yxORGruuuuu66YwBDztPp68rQtcdEdywXWZcyYMenee+8tBqUqB0vDm2++mbbbbrvc6r1du3bp+uuvTz/4wQ+adNyUv1h6cscdd8zbf/7zn2tM+oyqu1NOOSVvd+jQIQ0fPrzZxwlA67DZZpsVz0Guuuqq/KVadeedd1564YUXijGhSAqHlowxxvVXnB+Ho446Ks2aNavK4/Fz/L7QfSP2h6ZkTlKO133mJeUWczcnaW6NNed+/vOf5/tYivP444+vcdWLs88+O2/37t1bAha0gEUq6lqbBsqw2qLQsWPw4MFp7NixdWadx8l+ZATDghg9enQ6/fTTi9Vlun3QUFGtEGvNFyoRdt5553TAAQekNdZYIydDREVDHMcisSFsu+226cEHH2zhUdOSHnnkkfTKK68Uf47W7ccdd1yxXfDBBx9cZf8DDzywxtc599xzixdga6+9dg44RMAskrHic/TSSy9Nc+fOzRVjTz31VFprrbWa9H3RsqIaeubMmfk8KrqdrbnmmnmJwfjdM888k/70pz8Vv3iKc6d77rknJ1sVfPTRR2nAgAHp5Zdfzj/H3Bo2bFidf3PppZe21NxCIjqjxTKUn376aU7+jABRJOd16tQpTZo0KQd9pk2blvc955xzagwO1Td/p06dmjtgxdKqALRtU6ZMyee98QVEnK+cdNJJuctV/HzDDTekyy+/PO8XsZ44j+3SpUtLD5lWqjFjjCeeeGJeujD069cvX3/FOXd8ARbnPzGvC/udddZZTfJ+WDg0NEZpTlKO133mJeUWczcnae6YfWPMuYjpDxw4sBjLjXPaQw45JMdi43h8xhlnpA8++CAnK959993FBFqgGUUCFrQWMWXn57bqqqu29JBpA0aNGlWcU+PHj2/p4dDKPPDAAxU9evSo93g1ePDgio8//rilh0sLO+CAA+brc64uv/jFLyoWWWSRWp+73HLLVUycOLHZ3hstJ86HGjKfevbsWTFu3Lh5nh+fffN7DhZzmYXHww8/XLH88svXOh/iWHTKKacs0Px1Xg+w8LjzzjsrunbtWuvnSp8+fSpefvnllh4mrVxjxhjnzp1b8dOf/rTO5x900EF5P2iOGKU5STle95mXlFvM3ZykuWP2jTXnpk+fXtG/f/9aX6Njx44VV1xxRRP8SwANYQlCAGhC0UUmqnKigiEqE5dddtm8TEZUiMUyXz/60Y/S7bffnqtwokoBGktUH0YlTHQqig4yHTt2TEsttVTq379/roSJ6sXoakTb99e//jUv17P77rvnTmjLL798bmUdHSOiyioqpa6++ur04osvpu23376lh0srFJ3VnnvuuTRq1Ki04YYb5u56URUdn3Ox9MTkyZPzcQcAGiK6GDz99NPpmGOOyR2HllhiidStW7e06aabFivDYzkNKBfRYSCWzYxOsrvssktaaaWVcsesuI+fY6nvK6+8Mu8HzcGcpByv+8xLyi3mbk7S3BprzvXo0SNNnDgxXXLJJfnY3L1793w8ji5w0Q0rjsfVu3IBzccShAAAAAAAAAAAACWStgsAAAAAAAAAAFAiCVgAAAAAAAAAAAAlkoAFAAAAAAAAAABQIglYAAAAAAAAAAAAJZKABQAAAAAAAAAAUCIJWAAAAAAAAAAAACWSgAUAAAAAAAAAAFAiCVgAAAAAAAAAAAAlkoAFAAAAAAAAAABQIglYAAAAAAAAAAAAJZKABQAAAAAAAAAAUCIJWAAAAAAAAAAAACWSgAUAAAAAAAAAAFAiCVgAAAAAAAAAAAAlkoAFAAAAAAAAAABQIglYAAAAAAAAAAAAJZKABQAAAAAAAC1k0KBBaZFFFsn3AAC0ThKwAACaWATQ4jZ69OiWHgoAAAAAAADQyCRgAQAAAAAAAAAAlEgCFgAAAAAAAAAAQIkkYAEAAAAAAAAAAJRIAhYAtKDRo0enRRZZJN/CV199lc4999y08cYbpy5duuTbZpttli6++OL0zTff1PgahefHa9Vl0KBBeb+4r+6hhx4qvk5sV1RUpKuuuip997vfTd27d09du3bN47j22murPG/OnDnpsssuS1tssUVaZpll8ni32mqrdNNNN6XGVn2M3377bbriiivSlltumf92586d04YbbpjOPvvs/O9Yl8cffzydcsop+d9ihRVWSB06dMjvcd11102HH354ev755+t8/oEHHpjHsdpqq+Wf33333XTCCSek9dZbL/8bFMYYjxf+24bTTz+9+B4Kt3itymLsF154YR7bsssumxZbbLH8/tZee+204447pvPPPz+98cYbC/RvCQAAAAAAADSe9o34WgDAAnj//ffTDjvskP71r39V+f2TTz6Zb+PGjUu33357WnTRps2f/vrrr9Muu+yS7rrrrnnGsf/++6ennnoqXXDBBemTTz5Ju+66a/rHP/5RZb+JEyfm2yuvvJJOOumkJhljJH4NHTo03X///VV+//TTT+fbddddl/72t7/l5Krq/vCHP6Thw4fX+L5feOGFfIvErkiC+tnPflbvWCKZa+edd04ffvjhAr6r/yZybbfddvMkgMW/ddxeeuml/J7feeed9Nvf/naB/x4AAABAuRg/fnyO2zz88MPpvffeS+3bt0+rrrpqjpcdc8wxaaWVVprnOVGQGAVvIQoKP/300zRmzJh0yy23pKlTp+aiuyjYO/TQQ9M+++xT7xii6C3iXhGHe/PNN9PcuXPTyiuvnAYPHpyOPPLItP7669f7GjNnzkyXX355uueee3KM5+OPP06LL754WnPNNXOx449//ONcwFiXt99+O5133nnpzjvvzNtLLLFE2nTTTdPRRx+dC/QAACg/ErAAoEzsvvvuOSjzv//7vzmhJ7oevfjii+mMM87ISUGREBWJQYcddliTjuPUU09NTzzxRPrJT36S9t1335zEFIk/EdCK8URiUozvoosuyolW0TFqt912y52yInksnh8JQqeddlpO5IquUI0tuldFQtiQIUPy3+/Vq1d666230iWXXJIeeOCB/O8YY4zkqHbt2lV5bnQSW3rppfPYvve976W11lord8+KMf/zn//M7y+SqSKo1rdv3xxgq83nn3+e9thjj9y16uSTT07bb799Dog988wzacUVV8zBukgWKwTnYqzVk7piLAVHHXVUMflqv/32y3MigovxHiI5K5Lf7rjjjkb+1wQAAABoORFXiWK5G264YZ7Hnn322Xy79NJL05///Occ76nN66+/nmMzr776avF3X3zxRe5SHrcobPzTn/6UE7tqcs011+RErdmzZ1f5fRQZxi26xUec7sQTT6x1DA8++GBO9KpeqBeFfxE3i1t0uo9ksdo8+uijueix8mvEv1HEmeIW3fN//vOf1/p8AABaxiIVdZ3lAQBNqnKVXiw1F0GU6ksERpVcLI0XHbI22GCD9O9//7vK44Ul7kaNGlXnMoTxuhMmTEgDBw7MQafK4udtttmm+PPYsWPTiBEjquwTlYd9+vTJVXyxNF4EgW699dYcEKosOlD169cvLxEYyWRRNdgYqo8xAmK///3v59nv4IMPzgGx8Lvf/W6ehKeoGoykp0iUqslnn32WE7PifURVYlRdVhfLBv7xj3/M20suuWR65JFHcjVlbRry3ygCabEMYgTkRo4cWWeHq5gTkaAHAAAA0JrFV1SRVBXdokJs/+hHP0prrLFG7gI/adKk3AkqulFFN6tITopOUDXF1vr3758mT56cY0Z77rlnWmqppXJ855xzzsnFhSE6SEWHrOri78ffjvFErCdiM9GlPJK1ogDx7LPPLiZERQFgFNnV1MErigWj+C+K6YYNG5YLAFdZZZUc94miu/vuuy8XWUbBXk1xu4i9Rdwn3vuxxx6bY1PxviP29Mtf/jJ3+IoxRSJXUxQ9AgBQuqZdwwgAaLDoflQ9+SpEok1hybzorBQJQk1p8803nyf5KkQnrOh0FaZPn56DYdWTr0IkiUVwKNSUvNQYll9++RqDZYXksUgQKwTEqou28bUlX4UIzkVAK0Rw66OPPqpzLMcff3ydyVcNFcG1SL4KkQBWF8lXAAAAQFtw5ZVX5uSnKEyM5KRYci+6gm+55ZZpiy22yMV9hWSjSFqKBKraRLf06667LnfL2nbbbXOi1k9/+tPcUbwQu4nO59FRq7KIx0TSViH5KuJZkdgV8a0YQyRCxWtEt/MQ3aeqd7iKBKsYdyRfRdwpOmFdffXVOXa28cYb5/cTRYN/+ctfqnToqi4SxaJTe3RpP+GEE/JShZFYFkswRuJWFPnF34glDgEAKC8SsACgTMSSf7XZZJNN8n0EgqKdelP68Y9/XOtjlRONGrLfa6+9lppCJH/VlkQVgbJ4PDz33HO5c1ddohX9G2+8kfcttLWPoF9B9Y5j8/PfbX7EEo5R0RiuvfbaHEwDAAAAaKsizhXdqUIkWu2www417hedzGPZvRAdsF5++eUa99tpp53y8n/VdenSpZiwFB3bL7vssiqP33bbbemdd97J26ecckraaKON5nmNVVddtTiGL7/8MidXVV++sPAaZ511Vo1FlgW9evVKdbnoootyAWF1kRAWhZNNWfQIAEDpJGABQJno27dvgzoexRKATSlandemW7du87VfU401Kv/qstlmmxW3o2tYdVGleNJJJ6W11147B+FWX3319J3vfCetv/76+TZ06NAq+9Ymkr2iJX5j6NixY9p7773z9i233JJ69+6du2vde++9ub08AAAAQFsSS/IVukHFkoF1qdwt/LHHHqtxn0IH+dpiRYUl+6I7VWWFn6O7VHTMqs1ee+2VO6fX9Bp33313vo/uVYccckgqVcTUKselaivSbKqiRwAASicBCwDKRF3L4i266P//kT137tyyGEdD9ouqwqaw3HLL1btEYeWl/SqbPHlyTnY7++yzc1v3qLasy6xZsxqUkNYYLr744rTzzjvn7alTp+bKygi6RXesSDqLn5t6CUoAAACA5hDL+hUMGDAgJ0DVdosiuILaup03tGAv4kGxnGFBYUnCKNBbdtlla31+dC7v169flecUTJkypZggVVfMrD5rrbVWlfhbbUWaTV2gCQDA/JOABQC0OhF4K0UE12J5wo8++igvM3jsscemCRMmpHfffTd99dVXORkrboXqy1BXgla7du1SY+ratWu688470xNPPJFGjhyZg3bxNyKRLYKS0RErOo/VVukJAAAA0Fp88MEHJT0vlgBckIK9iPV88skn8xTv1ff8sMIKK1R5TvUO6iuuuGJaEPUlbzV10SMAAKVrvwDPBQDKJBkpAkf1BV6++OKL1Fa8//77DX688vKNf//734st2i+55JJ08MEH1/j86kG05hYVmYWqzKhofOihh9If/vCHdOutt+bg5B577JGTxDp16tSi4wQAAAAoVeUu73fddVdabbXVGvS82hKlSi3Ya6znAwCwcJOABQCtXJcuXdKMGTOqVO5VFwlar7zySmornnzyyTRs2LA6Hy/4zne+U9x+7rnnitt77713g1rgl8N/31iWMG4jRoxIF154Ye7Y9cgjj6Ttt9++pYcHAAAAUJLu3bsXt7t161YlhlOKKMjr1atXnY8XEq2WXnrpeYr36iv4q7z8YeWCv9CjR480bdq0HLMBAGDhZAlCAGjlVl999XqThu6777706aefprbi5ptvTrNmzaq109dNN92Ut9ddd90qrd+/+eabKvvVJDqJXXHFFY063sUXXzzfz549e4FeZ9ttt52ntT0AAABAa9SvX7/i9qOPPrrAr1e5IK+ux9daa63UoUOH4u8LiV+vv/56mj59eq3P//rrr9OUKVOqPKdg4403LsbnalsiEQCAtk0CFgC0cgMHDsz3TzzxRI3BqqjMO+qoo1JbEu9p5MiRNT527LHH5mX6wuGHH17lsQiwFcSSfjU58cQT0z//+c9GHW8hCSyWDaxNLI04YcKEOl9n3Lhx8yTeAQAAALRGkbTUs2fPvH355Zenr776aoFe749//GOdyVfPPvts3t5uu+2qPFb4OTrIX3311bW+xi233JI+++yzGl8jOpeHSL6K9wIAwMJHAhYAtHKHHnpoat++fQ4SRbBn7Nixudpu4sSJ6dxzz83VhBEcqpx81Nptuumm6dJLL0077rhjuuOOO3LCVNzvsMMOxSBXvO//+Z//qfK873//+2m55ZbL26ecckp+/K9//WuaPHlyuvHGG3Pw7De/+U3aaqutGnW8W265Zb6/88470+9///sc8IslIeNWSBZ7880306BBg9J6662Xx3b77bfn4GDcbr311rxk4u9+97u870YbbZQ233zzRh0jAAAAQHNadNFF00knnVQsTNt///3r7B4+Y8aMdPHFF9f6eMRdCl3RK/v888/TYYcdVvybhe2CXXfdNa200kp5+8wzz0zPPPPMPK/x1ltvpZ///Od5e4kllkjDhw+v8vh+++2XVl555bx98skn11lkF0sVAgDQ9rRv6QEAAAsmEnYiaSg6P33yySfpmGOOqfL4Msssk5N5Tj311PTyyy+ntiCCYeedd166//778626vn37prvvvjsnplXWuXPndM011+TAWlRVRjJU3CqLJKgI5lVvJb8gIkAXVZIRRKyeFHbAAQdU6cb1/PPP51tt4r1FQtYiiyzSaOMDAAAAaAkRJ3nggQfSbbfdlm6++eZcZBcJUptttllaaqmlctLVf/7zn/TQQw/lBKvFF188HXnkkbUW7O277745+WnPPfdMXbt2TU8//XQ655xz0osvvpj3OeKII9IGG2xQ5XmxHGEU9EVhY/y9KMw77rjj0rbbbpvatWuXixx//etfF4vofvvb36YePXpUeY0Y17XXXpuGDBmSu2BFkd+wYcNyDCq6fEVMKN7Hvffem99HXYlmAAC0ThKwAKANiKSrddddN40ZMyZNmjQpB3qicu8HP/hBOv7449Mqq6yS2pIIjEXAKoJjkVAVAaw5c+akNddcM3eKimS0Tp061fjc6IIVHcIicPb3v/89TZ8+PXXr1i3/+/3kJz9JBx10UO5G1ZiiY9Vjjz2WO5LFMpHvv//+PIG2rbfeOgcToyPX448/nisrY79IFIskug033DDtvvvu6cADD0wdO3Zs1PEBAAAAtIQoMIuu5CNGjEiXXXZZevXVV3MsqzaFzuY1ie5XkTR1ySWX5Ft1e+yxRzr//PNrfO7QoUPz8oOR/DVz5sx02mmn5VtlkYx1xhlnpMMPP7zG19hmm21yQeA+++yTiyTj9epa0hAAgLZlkYpYrwgAoMxFclIEssL48eNzpyoAAAAA2oZY+u+KK67IMaAojoulA5dccsm0+uqrp0022STtuOOOaaeddqpSmDZ69Oh0+umn5+34uisSn6JDVXTUmjp1alpsscVyUduhhx6aC+/q88Ybb6SxY8emcePG5TF8++23uchx8ODB6aijjkrrr79+va/x6aefpksvvTQnY0Xnrfg5urL37t07fe9738tduvr371/lORHnis5dAwcOzO+/NtXfLwAA5UMCFgDQKkjAAgAAAKAyCUkAAJSLRVt6AAAAAAAAAAAAAK2VBCwAAAAAAAAAAIAStS/1iQAA8+Oll15Kc+bMme/nLbfccvkGAAAAAAAAUI4kYAEAzWLIkCFp6tSp8/28UaNGpdGjRzfJmAAAAAAAAAAWlAQsAKBVGDRoUKqoqGjpYQAAAAAAAABUsUiFbzIBAAAAAAAAAABKsmhpTwMAAAAAAAAAAEACFgAAAAAAAAAAQIkkYAEAAAAAAAAAAJRIAhYAAAAAAAAAAECJJGABAAAAAAAAAACUSAIWAAAAAAAAAABAiSRgAQAAAAAAAAAAlOj/A5VDNJOTFr2IAAAAAElFTkSuQmCC)![cells_dim1.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "e9e1ff0a-b6ba-45f1-875d-7e39ed03e371", + "metadata": { + "id": "e9e1ff0a-b6ba-45f1-875d-7e39ed03e371" + }, + "source": [ + "These experiments show that, although partitioning the graph inevitably breaks some global higher-order structures, batch-level liftings combined with randomized Cluster-GCN batching recover the vast majority of them over multiple epochs.\n", + "\n", + "Even when the graph is heavily partitioned, the model gradually encounters different combinations of clusters across epochs. As a result:\n", + "\n", + "- recall after a single epoch already captures a substantial portion of the global structures,\n", + "- cumulative recall over many epochs approaches the golden lifting,\n", + "- and the improvement (final / initial recall) can be significant in higher dimensions.\n", + "\n", + "This confirms that our design choice to perform liftings on the collated batch rather than inside each cluster, preserves global topology.\n", + "\n", + "### Further Use and Reproducibility\n", + "\n", + "All results shown in this section were generated using four utility scripts:\n", + "\n", + "- `sweep_cells.py`\n", + "- `sweep_hypergraphs.py`\n", + "- `sweep_over_epochs_cells.py`\n", + "- `sweep_over_epochs_hypergraphs.py`\n", + "\n", + "Each script produces heatmaps or epoch-wise recall plots for a chosen dataset.\n", + "\n", + "These scripts can be easily adapted to your own experiments by modifying:\n", + "\n", + "- the dataset name (e.g., Cora, PubMed, Reddit),\n", + "- the list of `num_parts` values (number of METIS partitions),\n", + "- the list of `batch_size` values (number of partitions per batch),\n", + "- and, for the epoch-based sweeps, the number of epochs to run.\n", + "\n", + "the scripts automatically regenerate the necessary lifted structures and overwrite cached results when parameters change." + ] + }, + { + "cell_type": "markdown", + "id": "500a2b01-c5e4-43d9-bacc-657f19eec177", + "metadata": { + "id": "500a2b01-c5e4-43d9-bacc-657f19eec177" + }, + "source": [ + "## Bonus: memory usage comparisons accross different models\n", + "\n", + "For another cocitation dataset, PubMed, we evaluated three pipelines using four different model domains: graph, hypergraph, cell complexes, and simplicial complexes.\n", + "\n", + "1. **cocitation\\_pubmed (in-memory)**: Standard PyG `InMemoryDataset` \n", + "\n", + "2. **cocitation\\_pubmed\\_cluster (partitioning pipeline)**: Produced with Pipeline 2 (`on_disk_cluster`) \n", + "\n", + "3. **cocitation\\_pubmed\\_cluster\\_2 (fully on-disk pipeline)**: Produced with Pipeline 3 (`on_disk`)\n", + "\n", + "### `graph/gcn` model\n", + "\n", + "![graph_gcn.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "XmnsfOw1LCRw", + "metadata": { + "id": "XmnsfOw1LCRw" + }, + "source": [ + "### `hypergraph/edgnn` model\n", + "\n", + "![hypergraph_edgnn.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAJYCAYAAADxHswlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAx9VJREFUeJzs3QWcVFUbBvCHhaW7Q7q7kZBGUkJAQiQURSVEMNBPwEBUFMSkEQRFFBUJlUa6u7tbaunYne/3nOsdZpdd2IXZnXr+/saZuRP3zL13lnnvec974jkcDgdERERERERExKOCPLt6ERERERERESEF6CIiIiIiIiJeQAG6iIiIiIiIiBdQgC4iIiIiIiLiBRSgi4iIiIiIiHgBBegiIiIiIiIiXkABuoiIiIiIiIgXUIAuIiIiIiIi4gUUoIuIiIiIiIh4AQXoIiIiIiIiIl5AAbqIiIiIiIiIF1CALiIiIiIiIuIFFKCLiIiIiIiIeAEF6CIiIh4UL148vPfee/BWn332GfLkyYP48eOjVKlS8Gfjx483++PgwYMxfi33IV/7oPja7t27P/Dr5W7//POP2a6//vqrx9qQK1cudOrUyWPrFxHfowBdRLzmRzEvS5cuvetxh8OB7Nmzm8efeOIJj7RRJBDNmTMHb775JqpUqYJx48bho48+8nSTRGLVli1bzL81q1ev9nRTRCRAJfB0A0REbIkTJ8akSZPw2GOPhVu+aNEiHD16FIkSJfJY20Riy7Vr15AggXf+c7xgwQIEBQVh7NixSJgwoaebIxLr/vzzT2TMmBHly5f3dFNEJECpB11EvEbDhg0xZcoU3L59O9xyBu1ly5ZF5syZ4YuuXLni6SaIlwkLC8P169edJ6a8NUA/ffo0kiRJ4rbgnNkwPCEh/sFd+/Pq1avwFn/99RcaNGjwUMMVREQehgJ0EfEabdu2xdmzZzF37lznsps3b5rxg08//XSUgc4XX3yBokWLmkAnU6ZMePHFF3H+/Pm7xgEyPZ5jEsuVK2eCjuLFi5v79Pvvv5v7fA+eDNiwYUOkvYlVq1ZFsmTJkDp1ajRt2hQ7duyIdBzq9u3bTZvTpEljMgKYHszlkb0v04Y5vvfYsWNRbhuOYeRniM64V24/rpNtTJ48OQoWLIj//e9/4bZp//79zedMlSqV+Tz8XAsXLrzr/bk/2rdvj5QpU5r369ixIzZt2mTWyaEJrnbu3ImWLVsibdq0ZjtyO0+fPh3Rwf345ZdfOvdBhgwZUL9+faxdu9b5HJ64GTBgAPLmzWuyKbg9+Llu3Ljh1n3Nbc3ttn//ftSrV89sn6xZs+KDDz4wAYmrwYMHo3LlykiXLp1ZD98vsvGu9vjiH3/80RyrbP+sWbMiHYN+6dIlvPrqq+Zz8HnszXv88cexfv36cO/Jk1lcH9ebPn16PPPMM3cdQ/Zn4fJmzZqZ29y2r7/+OkJDQ++5T9guHrc8wWQPQbH3eUz3xezZs537YuTIkVGus0aNGihWrBg2b96M6tWrI2nSpMiXL59zmzKb5tFHHzXvw+N63rx5d70H9ycDLB6z/Ly1a9fGypUr73retm3bUKtWLfNejzzyCD788ENzHEbm77//dn73U6RIgUaNGpnX38+///5rvhcxCUD/+OMPsw24XXms2McJ8TvK/TB16tS7XscTmXxsxYoVMT6OY/p3NLL9eejQITRp0sSsh8dsr169zPPYJvu757qP161bh2rVqpl9bP99mjZtmtm2bCc/P48vHmcRj1XX9+D3j+3InTs3RowYEek25ecbOHCg2c/8fDwm9u7de9fzLly4gOXLl5s2xHTbcJvyGOI6+Jlq1qwZ5TFiH9+ux579b4Rr/QN7e3PoV4UKFcz6WQ9iwoQJkQ4TW7ZsGXr37m2+49wPTz75JM6cORNpG0TEizlERDxs3Lhx/LXoWLNmjaNy5cqO9u3bOx/7448/HEFBQY5jx445cubM6WjUqFG41z7//POOBAkSOF544QXHiBEjHH369HEkS5bMUb58ecfNmzedz+NrCxYs6MiSJYvjvffecwwdOtSRLVs2R/LkyR0//PCDI0eOHI5PPvnEXFKlSuXIly+fIzQ01Pn6uXPnmvUUKFDA8emnnzref/99R/r06R1p0qRxHDhwwPm8d99913yWIkWKOJo2beoYNmyY49tvv3WEhIQ4kiRJ4njttdfu+vx8bq1ate65jTp27Gg+Q0T2+mxbt251JEyY0FGuXDnHl19+abbJ66+/7qhWrZrzOWfOnDHboXfv3o7hw4ebz8NtExwc7NiwYYPzefz8lSpVcsSPH9/RvXt3xzfffON4/PHHHSVLljTr5H5zXS+3Gz/LoEGDzHO5znjx4jl+//13x/106tTJvGeDBg0cX3zxhWPw4MFm+3399dfhtgGf07JlS7NNO3ToYO43a9Ys3Hs97L7mehInTuzInz+/ORb5WZ544gmzrn79+oVb1yOPPOLo2rWrec7nn3/uqFChgnnezJkzwz2PywoXLuzIkCGDOXbYfntb8zHuR9vTTz9t9iH3z5gxY8z2bNy4sWl7xO8Mj3N+vrfeesscX7ly5XKcP3/+rs9StGhRx3PPPWf2d4sWLcxreWzey8SJEx1Vq1Z1JEqUyNzmZd++fTHeF9y+/J6wjTweFy5cGOU6q1ev7siaNasje/bsjjfeeMPsfx5TPAYnT57syJw5s9mnPEa4T7n/+N1yPQ75/ee+HzBggNnHuXPnNp9h5cqVzuedOHHC7Au2i+/32Wefmf1dokQJ8zlcv9MTJkwwx3H9+vVNe7g/uJ1Tp04d6Xfflb3sXp/Zxufxu2W3nZ8xT548jqRJkzr+/fdf85ywsDCzbbgPI2rYsKEjb968D3Qcx+TvaGT78/Lly6atPAa5nG3nd8H+W+H6+bmPuR+5/Xv06OEYOXKk+TtPPH5atWpl9geP1aeeesq8nn/DIjtOMmbMaP42ffXVV47HHnvMPHfs2LHO53G9XFa6dGlH2bJlzXeF+5vblO2LiMcYt8OFCxdivG369u1r1sX9wG3N7xvbyH8nuC9sR48edaRNm9aRLl0687eAf+sKFSrk3Faux5T9tyxTpkyO//3vf+Z9y5QpY45HHusR/x7wc/LfEh6n/LeG3xtuTxHxLQrQRcSrAnT+AEmRIoXj6tWr5jH+QKtZs6a5HTFAX7JkiXndjz/+GO79Zs2adddyvpbLli9f7lw2e/Zss4w/Kg8dOuRczh+MEX9UlipVyvwYPHv2rHPZpk2bzMkDBicRf5C3bdv2rs/JZfzB5hoMrl+//q5g92ECdP4A5X0G4VG5ffu248aNG+GWMajjj0D+qLT99ttv5r34Y9vGtvMHYMQ2165d21G8eHHH9evXncsYTPCECwOEe1mwYIF5v1deeeWux/getHHjRvMc/lh2xR/uXM73cNe+toNPBg+u7eCxx8DZddvax6mNP9iLFSt21wkXvh+PlW3btt31GSMG6Aw6u3XrFuX24jp4LHI9165dcy7nSQG+V//+/e/6LB988EG497ADlvvh6xmMuHqQfcHvZHQw8OLzJ02a5Fy2c+dO5/ZzDbLtfep6HDLA4z6yTyTQ8ePHzd8U15NUr776qnntqlWrnMtOnz5ttr1rkHTp0iUTiDM4c3Xy5EnzXNfl7gjQ2fa9e/eG+xvD5a4nqt5++21zwsE1iGTbGUS6HkfRPY4f5O9oxP05ZMgQs9wOtInHJgPPyAJ0LmOwG1HE7xO9+OKLJqB2/dtivwfXa+PfNPvvtB042wE6T465/s3jyUsu37JlS7h18UQG39sW3W3D7c9tym1r/80iBtV8nmuAzv3BANv1ZCj/XWHQHlmAzmWLFy92LuO6uP9dT/ba/4bWqVMn3Pp79eplgnTXY0VEvJ9S3EXEq7Rq1cqMaZw5c6ZJ9eV1VOntTPFlijbTf5lKal+Y9svUzogp20WKFEGlSpWc95kqS0xzzZEjx13LmRpKJ06cwMaNG03KKNO3bSVKlDDr5pjFiF566aW7lnXo0AHHjx8P1y6mPDPNsUWLFnAHpqHbqaJRpesynd4eU8znnDt3zqQsM2XVNY2aqbXBwcF44YUXnMtYMKxbt27h3o+vZ/o/9x33mb0fmB7P1No9e/bcM33/t99+M+mZ77777l2P2en79jZm+qar1157zVnYyR372pXrlFd2ijqHB7imVXPf2ZjyevHiRZMKHTEdnZjSynZFZx+uWrXKHCuRYdo/x4Z37drVpLzamJZbqFChu7ZFZMcj2xjZZ46OmO4Lph7zOIgufnfbtGnjvM9Udm6TwoULO/dXZPuOadCsOs9UfqYB27JkyWL+hjBNOCQkxPkZKlasaNKGbUwLbteu3V3DRZj2zOE3rn9j+B3i+iMbFuKKQxcYezMlOzrq1Klj0rpd/8YwVd91X/HvCIcSuA6l+Pnnn813mMMcYnocx/TvaGT7k38rsmXLZlLcbTw2Xf92uGL6+rPPPnvXctfvk/23hMcqhwhwqIAr1m1gqrmNf9N4n98Npr674rpc6yjwPcl1u/JvIT+Ha3p7dLcNtyW3aY8ePcINOeJQlYi4Dv5tcp2ykP+uRDz2bPybYbfXPk75nYjs+9ulS5dw6+fr+L3g8AMR8R0K0EXEq/DHB3+kcjwlxwrzxwXHNUeGgR8DIo535OtcL5cvXzY/1Fy5BmbEH17EKdwiW26PMbR/3PBHUUQMGviDLWIhOP6IjYg/8hgsMCi3fxD+9NNPZiw7x7W6Q+vWrc2UWM8//7wZK8lA55dffrkrWP/+++/Nj3/+iOb4aW4zBlbcnjZ+braX4yldcUywK47lZBDSr1+/u/aDHXRH3Beu9u3bZ8acup78iIht4cmBiOtm4UAGbxF/gD7ovrZxXa5BHhUoUMBcu44R5QkkBnrcjmw/P/Pw4cPDbcd7HROR+fTTT7F161bTVgaQDPJcf4zf63hkgB5xW9hj+l2xNkLEzxxdMd0X0f3cNo7JjVhXgfvpfvuOY20ZyEX1PeV34MiRI87PkD9//rueF/G1/Btjn9iJeGzzZMC9jusHEfG4jWxfcR+zwrj9d4R4m8dhxH0SneM4pn9HI9uf3J48sRBxv0Vsj43BfGSFBzlmm+OmuW95YoJtsE86RPxO8W8Gx1nf67NFtV25Tcl1u65Zs8YcQ64BenS3jX3MRzym+Dx7Xa7bKrLtEtW2is4xEZPPKSLezzvLxopIQGNvF3teTp48aYo92b3CEfEHN384uf5QdRUxKGGvV2SiWh6xkFJMuPYEua6Hn2306NEYNmyYKejDXtLIer0iiqqicMTiSVzv4sWLTc8OA2721rB3jQEGAwq24YcffjDZAOxpfOONN8w25PKPP/7YBMsxZQf/LDwWVU9pVD8+Yyq6lZXjYl8vWbLE9Biy0BX3J09mMOOAxZ54gik6x0RkmInAni8WAuM+++yzzzBo0CBzworfh5iK6jPH1b6I7uf2xPc0usf2xIkTI51Fwt3V96P7GdmL3rNnTzP9JHvTWQTvm2++eaB1xvTvaEz3Z2Qiew9mKjDLhIE5C9kx4OfJJWaj9OnTJ8qMIHdtV2ZVsCiba5ZLTLdNbIjJce+J74iIuJ8CdBHxOuxBYaoif3QyuIwKf8AxtZA9xu740RiVnDlzmutdu3bd9RjTLllBO2JPTlT4w3rIkCGYMWOGqQzNH3jRSf9lTwh/wEYUWeoie81YpZiXzz//3FSJf+edd0zQzuwEpsayV40Bn2uQFTHFnJ+br2GvpGsvesTqx3YPHYNTvn9McT+y2jNT5aPqRWdb+GOZPVrsDbWdOnXKbBd7H7kL18Vea7tHjnbv3m2u7Wr6TM1nAMG2M2XXxgD9YTHYZwo7L+ylK1OmjKlCzQDd9XjkiRdXXObubeHpfRFd/C7xOI3qe8rvhd0LzzbaveOuIr7WTjdnkPYgx3ZsYWYMhxgwA4dDgvjdY/bMgxzH7vg7yu3JmSsYCLr+TYmsUnpUWOmdw2L4d4knvWwHDhyI9Pk8ucnMJde/vRE/W0zwhCan+nQV3W1jH/M8plwzFtgjH7H3ms+NbLvEZFuJiH9TiruIeB2O7WOaMFN7GzdufM+eRvYgcxqeiDgeM7KA9kGDJY4XZFq463syDZk9nBF/1N0L08p5GTNmjAnw+EM7Or1w/KHIVEtOz2Pj2PiI0y0xyI3IHutoT4Fl97K49qpwzLM9PZONJw5u3bplevxdf/B/++234Z7H4IVjbDndEtsU0f2m+eH4e7bl/fffv+sxu432NuZ0R654AoJc01LdxbVHku3gfQZCPPFhb0cGI65ZDEyt5TRZD4rvFTGVl9uX6bz2/mOtAC7jlFKu05rxhA+n/YuNbeHKE/siOrg/6tata+ovuKY488QBMxo49SB7Z+3PwBOAq1evDnecRuwp5XeAr+FJLn4XYnpsP8g0a9HBk4I8WcNsGLaZUxJy2YMcx+74O8rtxDoTrtMqXr9+PdzfjvuJ7O8Sx3UzOyUybJvrlH18Lu/zRA3HiMcEjxH21Ec8dqO7bXjyhtv066+/Dtf+iN8Re1vxby3rmrj+3Y6ql15EAo960EXEK3G+7fthOiR72pmazR87/HHOH0nsxWBxH86rHdX49ZhimjF/ELO4T+fOnU2vFX+Mcayk6xzW0e1FZzo4RSe9nRjIM82T2QWvvPKK+cHPkxjsGXMtSMbUUKa484cme2rY+8ofuBzXywCFOK8ue6n4Xnwee6gY7DG1k+MqbUyB5xhoFv9i7w7HvvIHuH0SwLWnjEE735/zi3N4AnuR+KOXP0SZhsu506PC+YI51/pXX31l9h2DDZ4IYAo5H2NRq5IlS5pjYtSoUc5UWAZXPGnCdvJ57sSecQ4P4DpZDIzBL3vYOF+zndbKbceglO3l0AVua24HpvO7nkiJCRbG4r7iccvPzJNV7MHj+FhmXhCPcaa8s/AVtwMLmHFb83hnzyHnn45Ncb0vYoLzSbOwG49FZh/w5BeDNp7I4Nh+25tvvmnS1rnvmCrOXlh+Hn5nXPcdg3N+z3h8MouB30Pu/8OHD5vjgT2r90ot52M88cRMlOgWiovJ3xH771tkAWR0j2N3/B3l6/lZeSxye9q1NuwihtEZDsH5zJkpxLbybxxfw30UVXo2T1rxe8CTMfw7yGwrtp/7ke2PCaa3s60Rj93obhtuS/5N5/P495UngDZs2GC2d8QTJzz2eGKFNUlYVI7HHk/Ycvw4/7ZGd+iIiPgxT5eRFxFxnWbtXiKbB51GjRplpoziFFqcTonTfb355ptmeqX7vZbrjTilFae54XLOxetq3rx5jipVqpj1pEyZ0sxNvX379kinVbrXNGecg5lT33BO9ZiYM2eOmVqL0/lwblzOix1xaqf58+eb+cM5nRufx2tO77Z7927nczgNz0cffWS2Cafr4ZRbnKIrsqnc+Dk4Lze3K6eV4nzly5YtM+vknMGuOLUVp5zjHMecU53zVHPe5V9//fW+n41Tv3F7c1omtptzJHNO9HXr1jmfc+vWLTNvMOe15vtzPmhOOeU6/ZI79rU9tRg/T926dc0UT5yCjtvadYo84pzLnEaO25Ft57Ec2XRbka3b9TF7eixOBcX5vzknMrc528Hbkc1Z/vPPP5t9x3VziqZ27dqZOZbvN00aRdbGyET1+ofdF1HhFFecsz2imOxTTl1Yr149M+899x2naXSdcs+2efNmsz7OFc5jlXOPc39GnOrKnq6L78nvAJ/P+cb5XVi7dq1bp1mL7BjhZ3edpsvGY4XzkbNNrtPtPchx/LB/R2n//v3mMb6e319OA2ZP1eg6PV5U+5j4t6VixYrmPfi3i+u3p9OLOFUb34Pbv1KlSmafsG2cptOVPc3alClTIv3e21P0tWzZ0sxfHpXobBtuU34nOI89n1ejRg0zV3lk+49TrFWtWtV8dx955BHHxx9/bOZyZ5s4hd/9tjc/v+t0cFH9G2p//ugcfyLiPeLxf54+SSAiEkiY9soepv79+5vK576GKdzsfee0VexB9DcsoMdx+q7ZBCLehinW7EXmMKCxY8d65XHMFG9mdDCLhpXb3YXZCPw7ymFG7tiOnMmCvd/MuvAUTsnGbA/ur9gq7CgivkFj0EVE4tj48ePNuEamzXo7pvK7YruZ2s/UX6b8iojnTpRxDDxT3b3xbwXHoDPg5NRj7gzO3Y1p5TyJwJOOntpWLI7HdH4OzVBwLiIagy4iEkcWLFhgKh2zGjfH6j5IpeG4xjGS/DHJsfccx8ux68uXLzdFs2Kzcr6IRI4FHTlOnuPOS5cubcZJe4PmzZubcdQsSslChxxnzQJ53l78jAUXY1pH5GHx7ymzADgLAutHMAMiJCTEJzOqRMT9FKCLiMQRFnBjcMu0cPZC+wJO48XiZDNnzjQ9YiyAxrazcJuIxD0WrWPwy0CY2TjegtXJWeyMATkzbVh0cvLkyZFO/xboWESOww9Y0I5F4ZiNxCDddXo5EQlcGoMuIiIiIiIi4gU0Bl1ERERERETECyhAFxEREREREfECGoP+EMLCwnD8+HGkSJHCjCESERERERER/+JwOHDp0iUzvWVQUOz2cStAfwgMzrNnz+7pZoiIiIiIiEgsO3LkCB555JFYXYcC9IfAnnN7R3FOYBEREREREfEvISEhpmPWjv9ikwL0h2CntTM4V4AuIiIiIiLiv+LFwbBmFYkTERERERER8QIK0EVERERERES8gAJ0ERERERERES+gMehxMBXbzZs3Pd0MEYlFCRMmjPUpN0RERETE/ylAj0UMzA8cOGCCdBHxXwzOc+fObQJ1EREREZEHpQA9FiezP3HiBOLHj29K8qt3TcQ/8QTc8ePHzfc9R44ccVLdU0RERET8kwL0WHL79m1cvXoVWbNmRdKkST3dHBGJRRkyZDBBOr/3wcHBnm6OiIiIiPgodevGktDQUHOtlFcR/2d/z+3vvYiIiIjIg1CAHsuU7iri//Q9FxERERF3UIAuIiIiIiIi4gUUoEuc9zT+8ccfsfLe7733HkqVKgVfU6NGDbz66qvwFrly5cIXX3zh6WaIiIiIiAQcBegSp1jpukGDBub2wYMHTcC+ceNGtwT6r7/+OubPn++2toqIiIiIiMQlVXGXOJU5c+ZYe+/kyZObi4iIiIiIiC9SD7pEOq/zp59+inz58iFRokRmbueBAweax7Zs2YJatWohSZIkSJcuHbp06YLLly+He/13332HokWLmtdmyZIF3bt3j7TnO3fu3Oa6dOnSZjlTvWnNmjV4/PHHkT59eqRKlQrVq1fH+vXrw6Vg05NPPmleZ9+PmOLOz/HBBx/gkUceMW3hY7NmzXI+bvfg//7776hZs6aZDq9kyZJYsWJFtLbT+PHjkTp1avN58ufPj8SJE6NevXo4cuSI8zmdOnVCs2bNwr2O6ez2Z7Vxei5uJ35efu5+/frB4XCE+8wffvghOnToYE5C5MyZE9OnT8eZM2fQtGlTs6xEiRJYu3ZtuPddunQpqlatavZX9uzZ8corr+DKlSvOx0+fPo3GjRubx7k/fvzxx2h9dhERERERcT8F6HGEsRbjIk9cXOK8aHn77bfxySefmCBx+/btmDRpEjJlymQCOwagadKkMUH0lClTMG/evHAB+PDhw9GtWzcTuDOYZxDJQD8yq1evNtd8D6a+M1CmS5cuoWPHjia4XLlypQl+GzZsaJYT103jxo0zr7PvR/Tll19iyJAhGDx4MDZv3mza3qRJE+zZsyfc89555x2THs9U+wIFCqBt27YmYI4OznXPkxcTJkzAsmXLcOHCBbRp0wYx9f333yNBggRmm7Ddn3/+OcaMGRPuOUOHDkWVKlWwYcMGNGrUCO3btzcB+zPPPGNOYOTNm9fctwP7ffv2oX79+mjRooX5/D///LPZpq77iycQeEJh4cKF+PXXXzFs2DATtIuIiIiIiAc45IFdvHiRkZC5jujatWuO7du3m2u6fJlRk2cuXHd0hYSEOBIlSuQYPXr0XY+NGjXKkSZNGsdllzf8888/HUFBQY6TJ0+a+1mzZnW88847Ub4/t9fUqVPN7QMHDpj7GzZsuGebQkNDHSlSpHDMmDEj0vexvfvuu46SJUs677MtAwcODPec8uXLO7p27Rpu/WPGjHE+vm3bNrNsx44djvsZN26cee7KlSudy/g6Llu1apW537FjR0fTpk3Dva5nz56O6tWrO+/zduHChR1hYWHOZX369DHLbDlz5nQ888wzzvsnTpww6+nXr59z2YoVK8wyPkadO3d2dOnSJdy6lyxZYvYXj8tdu3aZ569evfqu9g8dOvS+n1+i/r6LiIiISGDEfe6mHnQJZ8eOHbhx4wZq164d6WNMAU+WLJlzGXt0mUq+a9cu0/N6/PjxSF8bE6dOncILL7xges6Z8p0yZUqTRn/48OFov0dISIhpC9vnivf5OVwxNdzGlHyKbi8ye73Lly/vvF+oUCGT9h5xHfdTsWLFcHNpV6pUyfT0h4aGRtpOZjRQ8eLF71pmt33Tpk0mDd8em88Lswi4vw4cOGDayPaXLVv2rvaLiIiIiEjcU5G4OJI0KRBhqHacrju6OBb5QT3Ma10xvf3s2bMm1ZtjrTl+nAHrzZs3ERuCg4Odt+0gmUGsOwQFBYUbS063bt1yWzvv1Xae1HjxxRfNuPOIWFdg9+7dD9QOERERERGJHepBjyOMndjx7ImLS8fsfbHXmoF2ZNOVFS5c2PTKuhYZ47hrBqEFCxZEihQpTDGz6E51ljBhQnPt2ktsvyeDSo47t4vN/fvvv+Gew8A04utcsdc9a9as5r0ivneRIkXgLhyr7lqYjZkEHIfObUUZMmQw4+RdRTat3KpVq8Ldt8fex48f/4HbVqZMGVNDgDUAIl647dlbzvavW7furvaLiIiIiEjcU4Au4bASeZ8+ffDmm2+awmcsNMZgcezYsWjXrp15nD3cW7duNYXFevToYYqV2enVrKTOwmxfffWVSdFm8bKvv/460nVlzJjRnAxgZXWmtV+8eNEsZ2A6ceJEk4LNwJXrjdg7b58IOHnyJM6fPx/p+7/xxhsYNGiQKY7GwPOtt94ywXHPnj3dtr14ooDbgO1koMuia0xXr1ChgnmcFe8ZwHNbcnu8++67ZttFxPT93r17m3b+9NNPZps9bDu5H5cvX26KwvFzc/3Tpk1zFonjSRUWkWMvu93+559/3m2ZECIiIiIiEjMK0OUurN7+2muvoX///qYnuHXr1mZcM6chmz17Ns6dO2fGXbds2dKMN//mm2+cr2Xw/sUXX5hq4Oz9fuKJJ+6qmm7j+GcG8iNHjjS93ZwujHgygEE3e4AZ/LM3ncG8K54EmDt3rpk6jNO0RYavY9DLz8Kx2jwRwKryPAHgLtwmDISffvppM76d47x5QsDGMd/cnjzhwW3GSvSstB4Rl127ds0E9qyCz+CclfAfBsesL1q0yKSyc6o1bifuU25rGyvh8z6nsmvevLlZZ8RtLSIi3mHlSp4IZ/aWp1siIiKxJR4rxcXau/s5FiJjETP2/DKl2tX169dNIS7OLc1eZ/E/LMDGOc2VEi76votIbOOvtYIFAZ7znjIFaNnS0y0SEQkcIfeI+9xNPegiIiIiXo6Tg9gJadu2ebo1IiISWxSgi0ShQYMG4aYoc7189NFHnm6eiIgEkD/+uHN71y5PtkREJLxRo4AePVj42dMt8Q+aZk0kCmPGjDHjwiOTNm1ac2FROBERkdimAF1EvBGD8l69gKtXraE31at7ukW+TwG6SBSyZcvm6SaIiIjg2DFgzZo793fvtsakx2QaVRGR2LB/vxWc04YNCtDdQSnuIiIiIl5s+nTrulw5IH584PJl4PhxT7dKRATYvPnO7fXrPdkS/6EAXURERMQH0ttbtQJy57ZuK81dRLwtQGcPujw8BegiIiIiXoozeS5YYN1u2tSaao0UoIuItwXo27ffSXeXB6cAXURERMRL/f03cPs2ULgwUKCAAnQR8d4APSwM2LLFk63xDwrQRURERLzU/PnWdZMm1rUCdBHxFqyHwSJxdo0MUpr7w1OALnEqXrx4+MN1rhg3eu+991CqVCn4mho1auDVV1+Ft8iVKxe++OKLh36f8ePHI3Xq1G5pk4hIoLJ//BYvbl0rQBcRb7F1q3WdNSvw+OPWbRWK88MAffHixWjcuDGyZs0aaTDncDjQv39/ZMmSBUmSJEGdOnWwZ8+ecM85d+4c2rVrh5QpU5oAoXPnzrjMUzwuNm/ejKpVqyJx4sTInj07Pv300zj5fIHuxIkTaNCggbl98OBBs483btwY4/eJ7Nh4/fXXMd/uahC/wznnmzVr5ulmiIjEqYMHreucOcMH6Fx+/brn2iUiYqe3lygBlC5t3VYPuh8G6FeuXEHJkiXx7bffRvo4A+mvvvoKI0aMwKpVq5AsWTLUq1cP113+lWJwvm3bNsydOxczZ840QX+XLl2cj4eEhKBu3brImTMn1q1bh88++8z0vo4aNSpOPmMgy5w5MxIlShQr7508eXKkS5cuVt5b/MfNmzc93QQRkWgJDQWOHLFu58plXWfKBKRMac2DvnevR5snIgHONUAvU+bOslu3PNosn+d1ATp7Vz/88EM8+eSTdz3G3nOm3vbt2xdNmzZFiRIlMGHCBBw/ftzZm7pjxw7MmjULY8aMwaOPPorHHnsMX3/9NSZPnmyeRz/++KP5kf7dd9+haNGiaNOmDV555RV8/vnncf55vVFYWJg5EZIvXz4TTOfIkQMDBw40j23ZsgW1atUy2QsMhnniI2J2gr1d+VpmOnTv3j3Snu/c/80VU7p0abOcqd60Zs0aPP7440ifPj1SpUqF6tWrY71LvgxTsInHCF9n34+Y4s7P8cEHH+CRRx4xbeFjPDZsdg/+77//jpo1ayJp0qTm5NCKFStilMLNz5M/f36TjcGTRUfsX1NR9Poynd3+rLbbt2+b7cTPy8/dr18/c7y7fmZ+Lzp06GBORPDk0vTp03HmzBnzXeAyfh/Wrl0b7n2XLl1qMkW4v5gpwuOcJ8Fsp0+fNhkrfJz7g9+NmLhw4QJefPFFZMqUyXz+YsWKmZNikYnOtvj1119RvHhx5/HFDBm2l/v2+++/x7Rp08w+4+Wff/4xr+H2btWqldkXadOmNduD+zbienkMMzOnoN39JCLi5fizhQXiEiQAsmSxlsWLpzR3EfG+AD1PHiBVKnaEMB7zdMt8m9cF6Pdy4MABnDx50vxotzGgYSBuB1W85g/1cnalAsA8PygoyPS428+pVq0aEiZM6HwOA6tdu3bh/PnzUa7/xo0bpvfd9RJtDLYYGHni4hLoRcfbb7+NTz75xASJ27dvx6RJk0wAxkCJ2ylNmjQmiJ4yZQrmzZsXLgAfPnw4unXrZgJ3BvMMIhnoR2b16tXmmu/B1HcGynTp0iV07NjRBJcrV640wW/Dhg3NcuK6ady4ceZ19v2IvvzySwwZMgSDBw82QxrY9iZNmtw1JOKdd94x6fFMtS9QoADatm1rAubouHr1qgn8eKJo2bJlJmDlCZ+YYvCZIEECs03Ybp4s4kkmV0OHDkWVKlWwYcMGNGrUCO3btzcB+zPPPGNOYOTNm9fctwP7ffv2oX79+mjRooX5/D///LPZpq77i8ErA9yFCxea4HjYsGEmaI8OngDhCTV+7h9++MEcKzxu4sePjwfBfclt/9xzz5kTbQzAmzdvbj4P9w+DcH4ePo+XypUr49atW2a/pkiRAkuWLDFt4ckKPs+1p5xDH/j9trNqRER8waFD1nWOHIDrn1YF6CLiafy5aQforJHBk4d2P5nGoT8khxdj86ZOneq8v2zZMrPs+PHj4Z731FNPOVq1amVuDxw40FGgQIG73itDhgyOYcOGmduPP/64o0uXLuEe37Ztm3nv7du3R9med9991zwn4uXixYt3PffatWvmvXhtXL7MD+SZC9cdTSEhIY5EiRI5Ro8efddjo0aNcqRJk8Zx2eX9/vzzT0dQUJDj5MmT5n7WrFkd77zzTrT26YEDB8z9DRs23LNNoaGhjhQpUjhmzJgR6fu47p+SJUs677MtPB5clS9f3tG1a9dw6x8zZsxdx8GOHTsc9zNu3Djz3JUrVzqX8XVctmrVKnO/Y8eOjqZNm4Z7Xc+ePR3Vq1d33uftwoULO8LCwpzL+vTpY5bZcubM6XjmmWec90+cOGHW069fP+eyFStWmGV8jDp37nzXcb5kyRKzv3hc7tq1yzx/9erVd7V/6NCh9/38s2fPNu/F94lq+6RKlcp5/37bYt26dWbdBw8ejPT9Inv9xIkTHQULFgy37W7cuOFIkiSJaZ/9ukyZMpnlseWu77uIiBtMnGj9M16zZvjlAwZYyzt08FTLRCTQHTpk/R1KkIC/vaxlvXpZy3r0cPidixcvRhn3uZtP9aB7GnuWL1686Ly4pjL7C/ZcMlOgdu3akT7GFHCO+7exR5c9qeydZM8rhxFE9tqYOHXqFF544QXTc84MCRb7Yxr94cOHo/0ezG5gW9g+V7zPz+GKqeE2puRTdHuR2etdvnx55/1ChQqZDI6I67ifihUrmrRtW6VKlUxPfygHIEbSTmY0ENPBIy6z275p0yaThs8eZfvC3mbuL2ajsI1sf9myZe9qf3Qw44DDB5h14A48tnjs8DM99dRTGD169D0zWuzPuHfvXtODbn9GprmzJgUzCGx8T9eMGRERX+pBt8ef2woVsq7Vgy4inmL3nhcuDNg/sVQozj0SwMcKjNkBnB1I2fftscd8TsTgiunKrOxuv57XfI0r+779nMhwHPMDFzhLmtSaLNATuO5o4tjfB/Uwr3XF9PazZ8+aVG+OteY2Z8AaW8W9goODnbftIJlBrDtwaIXrWHJiWra72nmvtvOkBseHc9x5RKwrsHv3bjyMmO7v+20LpsYzBX358uWYM2eOqR3B4QccmmLXK4iIn5EnGCIbO58hQwbnbdeTSiIivlrBPbIUd/5ZdTm/K36M+5ojOsePBzgqkHVxW7WyLhGPkcheG5uPx8U6vKENcbEOb2hDdJ6zdKl17dJ/5CwUt3w50Lgx0L49O2Cifo97/e2KF8ljrMfBE5b+/jfPpwJ0/khnAM3xpHZAzp5S/oB/+eWXzX0GchwHzOrsds/gggULTNDCser2c/jDn8GBHeAwMGDxKI6vjhU8knwgSGCvNQMvbuPnn38+3GOFCxc2PbIci24HPBzzy8CL2469mCxmxtey6Nr92D2arr3E9ntyLDTHnRMzFf79999wz+F+i/g6V+x1Z0EwvheLzLm+d4UKFeAuPPnDwmz2ezKTgMcft5UdJG61J4l06Xl2DazJro9gs8feP+h4bipTpowZFx5VDQD2lrP9/K7YWQB2+6ODPfpHjx41gX50etGjsy14koFZDrxwOkWeoJk6dSp69+5tjpeI+5yfkWPrM2bMaPa5iEgg9KDzzzp/VvDPNfsNPPVj1ZM/kgNx3Tz/fuPGnftnzwIffmhdRDzFNUDnz1/Opvz33wBL/sRG2Z+XXmLNK/g1rwvQ2SPGlFUbU3H5I55pq+z1Y9VnVrNm8MKAnYXMGIjZ1aEZGLFAFFOkORUbg3AWxWLhLj6Pnn76abz//vtmfvQ+ffqYoIG9tSzCFehYiZvb5M033zQBEQMlVgrntHWcvu7dd981Pdysqs3lPXr0MMXK7PRqLn/ppZdMwMQCYizsxqCYz4uIz+HJAFZWZ6o0182Udu7biRMnmkJ/PAHzxhtv3NVba58IYPvYwx7ZiRW+ju1l8TSe0GFROR5LMa1Ufi8MLvnZOPUf08V5rDFd3Q7YWfGe0/ixiBxPDLGYGo83Vq53xfR9BqHs8WbBN/Yes8Ddw+B+ZFvYJp5s4UkVBuw8GfXNN9+Ykyr8rnCdLO7H9vP7Fd2ecZ74YLFFFqFjUTueCNi5c6cJsvm+Ed1vW/AkBfcpp0DkscH7PMbskx3c57NnzzYnEVjhnccKj0m+Jyu32xX7Dx06ZAoO8hjmfRERXw/QI/aO8s80R5PNm6fpjAIN+0datrR6JpkwOnkywAlqNIOoe0+w3O85D/u4v6wjfXrAdYKeoCDgr7+AnTuBiROBX36xTiTFpIfeEcVy/q27epWdbfB7XhegszfStfeVQQsxKGTvLX90sweXVcLZ08dp1BjgMbizMQBjUMLxrOzdZQDBAMrGH/ZMoWW1cfayc1or9ta5zpUeyHjSg8EatwnHcXM4AYNuTkPGAKlnz56mx5X37eDMxv3E8b882cHK29y2LfkvSSS4Du4XBlZcF6cDY+XusWPHmn3B3lFODfbRRx+Z93LF4JXHBscpZ8uWLdy0WjamdrNWwGuvvWaGPRQpUsRUlecJAHfhNmAgzJM+x44dM5+B7bdxzDe3J49bbhdWKGeldVa4d8Vl165dM4E9e825jR/2eGQP96JFi0y2CNvF9HKerGjdurXzOTxpweCdwTZPsvDkF9sbXb/99pvZN6y+zu8lg3RWco/M/bYFe8AXL15splLkiRn2nnM/80QP8aQbjw+euOGJPFae5xRtfA33ASu+84QQjwd+9wOhR/3cOesfwubNYzSSRUR8AHtLo+pBp9mzgWPH4PViOJGMx/hCO9lG9oe4nkdv29aaiu8eSYV+FRBG9zniWayTwRma/5ul2S3WrweYHB0hqdYvxWOlOE83wlcxiGCwzyAwYjDAAIS9/+zldz15IP6DJ4zY4xzdlHDxX576vr/2GsDzY7z06hVnqxWROHDypDX3OXukrl9nxpanWyQi4jmHD1vZRPxbyKEecX2i5l5xn7upiruIiI+ye9dULVXE/9iJYdmyKTgXEUmf/k6qu6fqbscVBegiUWBqtesUZa4Xpt37Ow4VierzFy1a1NPNEwD2LHQxnNVPRHzAvdLbRUQCTdKkd4Z3+Huau9eNQRfxFmPGjDHjwiPDooW8dOrUCf6qSZMmzpkPIopYhV48G6CzGIumWhIJjCnWREQCuRf9yBErQI9iBl6/oABdJAosNhbIOG0eL+LdReKIqV7Hj1upsCLiH9SDLiISXrp0dwJ0f6YUdxERH+9BJ6W5i/gX9aCLiEQ+Dl0BuoiIeB1OqxMScuc+09xFxH+oB11EJPIAPaq51f2FAnQRER8UcXY/9aCL+A/WlFAPuohIeOpBFxERn0hvJ/Wgi/gP9g5dvWrdzpHD060REfGeMeikAF1ERLy2QJxNPegi/pfeniULkCiRp1sjIuId0gdID7qquEucihcvHqZOnYpmzZq5/b3fe+89/PHHH9i4cSN8SY0aNVCqVCl88cUX8Aa5cuXCq6++ai4PY/z48eY9LkTMxRa39qBzmpEDB4ATJ4CLF4FUqTzdMomNegPz5t2dNWGnQkcmsuVRPTeuxNU0gHGxnthex/r11rXGn4uIBN4YdAXoEqdOnDiBNGnSmNsHDx5E7ty5sWHDBhOgPmyg//rrr6NHjx5ub7N4B845z2CfJ2Fi061bt9C3b1/89ddf2L9/P1KlSoU6dergk08+QdasWeEt7GCNP+Bv3LCmWWOaexRT14sPYorzuHHA4MF3xiNLYFGALiJyh3rQRWJB5syZY+29kydPbi4i93Lz5k0kTJgwysevXr2K9evXo1+/fihZsiTOnz+Pnj17okmTJli7di28LcU9bVqgUCEF6P6GPz4qVLCyIyhDBqBEiZj15ka2PK56sT3Ve+9P62Fqe+/esb8eERFfkT5AAnQ45IFdvHiR/0Sb64iuXbvm2L59u7n2NaGhoY5BgwY58ubN60iYMKEje/bsjg8//NA8tnnzZkfNmjUdiRMndqRNm9bxwgsvOC5duhTu9WPHjnUUKVLEvDZz5syObt26OR/j9po6darztuulevXqZvnq1asdderUcaRLl86RMmVKR7Vq1Rzr1q1zvkfOnDnDvY736d1333WULFky3Od4//33HdmyZTNt4WN///238/EDBw6Y1//222+OGjVqOJIkSeIoUaKEY/ny5dHaTuPGjXOkSpXKfJ58+fI5EiVK5Khbt67j8OHDzud07NjR0bRp03Cv69mzp/OzEm9zG/HCz8vP3bdvX0dYWFi4zzxgwABH+/btHcmSJXPkyJHDMW3aNMfp06cdTZo0McuKFy/uWLNmTbh1LVmyxPHYY4+Z/fXII484evTo4bh8+bLz8VOnTjmeeOIJ83iuXLkcP/zwg1nX0KFDo7UNzp8/7+jSpYsjY8aM5vMXLVrUMWPGjHDbJybbYsqUKY5ixYo5j6/atWub9nLfRjxeFi5caF7D7f3UU0+ZdaVJk8ZsD+7biOvlMZwlSxbzOWOKxyTXeejQoUgf98T3fcAAfoccjuefdzi6drVu9+kTZ6uXWPb669Y+zZLF4fj2W4fj6lVPt0hERMSzDh+2/m1MkMDhcPmZ7PG4z91UJC6OMB69cvOKRy5WLBx9b7/9tknnZQ/i9u3bMWnSJGTKlAlXrlxBvXr1TIr6mjVrMGXKFMybNw/du3d3vnb48OHo1q0bunTpgi1btmD69OnIly9fpOtZvXq1ueZ7MPX9999/N/cvXbqEjh07YunSpVi5ciXy58+Phg0bmuXEddO4cePM6+z7EX355ZcYMmQIBg8ejM2bN5u2sxd0z5494Z73zjvvmPR4jl0vUKAA2rZti9sc9BkN7G0dOHAgJkyYgGXLlpkU7DZt2iCmvv/+eyRIkMBsE7b7888/x5gxY8I9Z+jQoahSpYoZEtCoUSO0b98eHTp0wDPPPGN6fPPmzWvu2/t73759qF+/Plq0aGE+/88//2y2qev+Ytr4kSNHsHDhQvz6668YNmwYTp8+Ha02h4WFoUGDBuZz//DDD+ZY4XETP358PAjuS2775557Djt27MA///yD5s2bm8/D/dOqVSvzefg8XipXrmzS0blfU6RIgSVLlpi2MIuCz2NPuW3+/PnYtWsX5s6di5kzZ8a4bRcvXjTDKlKnTg1vS3HniJHCha3bquTuH06eBL791ro9dizQtSuQJImnWyUiIuIdVdxv3wZCQuC3lOIeR67euorkH3sm/fry25eRLGGyaD2XQTADxG+++cYEycTA77HHHsPo0aNx/fp1E4wmS2a9H5/XuHFjDBo0yATxH374IV577TWTEmwrX758pOvKwJxN82VLFy71vVatWuGeN2rUKBMYLVq0CE888YTzdVx2r5R5BuZ9+vRxBsxsIwNRFmP71v71+9/YdQa89P7776No0aLYu3cvCjFv+D4YIHIbPPpfXjED7cKFC5tAuwLzU6Mpe/bsJgBnEFiwYEFzcoP3X3jhBedzeJLixRdfNLf79+9vToZw2z711FNmGT9rpUqVcOrUKbNdPv74Y7Rr185Z7I0nOr766itUr17dvPbw4cP4+++/TVvtfTR27FjT/ujgiRW+lsE0T2xQnjx58KAYdPPECIPynP9N/Fu8eHHn40mSJMGNGzfC7XOeGOCJAp7M4LazT9zw2GCAX7duXbOMxyufc6/U9qjwmOe25cmDlClTwltT3EmV3P3Dxx8D164BFSsC9et7ujUiIiLeIWlS68IaLSwU56+FcdWDLuEw2GIQVLt27Ugf45hcOzgn9ugyQGLvJHtejx8/HulrY4IBJgNTBpQs0MWg6PLlyyagjK6QkBDTFrbPFe/zc7gq4TKwMwvntAGi3YvMXm/XExAM6hkcRlzH/VSsWNEZYBIDbfb0h4aGRtpOngyJGMDay+y2b9q0yVRSt8fm88LeZu6vAwcOmDay/WXLlr2r/dHBjINHHnnEGZw/LB5bPHb4mXjSgSeEOP77XvgZeTKFPej2Z0ybNq0JqplBYON7PkhwzhMw7LlnLz5PaniTyHrQ+ZFdEgfEBx09CowYYd0eMMBzY8ZFRES8UfoAGIeuHvQ4kjQ4qenJ9tS6o4u9lA/qYV7rij33Z8+eNT357ElNlCiRCVhdU5bdKTg42HnbDpIZxLpDUFDQXUMMGPS5q533ajtParDH/ZVXXrnrvXLkyIHdu3fjYcR0f99vWzA1ninoy5cvx5w5c/D111+b4QerVq0y1f4jw8/IEww//vjjXY/ZmRbkelIppsH5oUOHsGDBAq/qPY8YoLO4fIoUzIBhFojVq+7P/Dlo5XRq/FNXrRrwkOc6RURE/DLN/fBhBejiBgyeoptm7knstWbgxTG7zz//fLjHmPrMHlmORbcDHo75ZeDFtGz2YnIObb62Zs2a912X3aPp2ktsvyfHQjOlmzhG+t8I30IGphFf54rBFKfE4nsxpdv1vWOSen4/TMlmZW/7PZlJwHHodpo4g8StW7fe1fPsGlgTg1BX9tj7Bx3PTWXKlDHjwqOqAcDecrZ/3bp1ziwAu/3RwR79o0ePmkA/Or3o0dkW/J4wy4EXpvHzBA2n0+vdu7c5XiLuc35Gjq3PmDGjWwNoOzhnFgOHRXAYhrdxTXFnwFq0KI8b4KOPPN0ycQf1nouIiNxNPegScBInTmzG27755psmIGKgdObMGWzbts2MZ3733XdND/d7771nlnPecRYrs9Orufyll14yARMLiHFMO4PiyOYn53N4MmDWrFkmVZrrZko7A9OJEyeiXLlyJlX9jTfeuKu31j4RwPaxh92eW90VX8f2cgw951nn2GQGhJH1tj4oBpf8bBzbzXRxFmBjurodsHM8/WeffWbG7TMLgGOmGaSWLl063PswfZ9BKHu8WfCNvccscPcwuB/ZFraJJ1t4UoUBO3upOW6eJ1VYTI3rZPo228/x6tHtGeeJj2rVqpkidCxqxxMBO3fuNEE23zei+20LnqTgPuW4cR4bvM9jzD7ZwX0+e/ZscxKBATOPFR6TfM+mTZvigw8+MMcRe7xZcJDHMO8/SHDesmVLsx9YUI4nBU6yapcJhtM+UKp8bPegEw+XUaN4wgt+La6m0fIkni9jD7qIiIhEHqBzDLrfivU68X7Mn6dZ45RUnG4rODjYTOn10UcfRXuatREjRjgKFixoXstprTi1V2TTrNHo0aPNNG5BQUHO6bbWr1/vKFeunFlH/vz5zdRbEaf+mj59upnaLEGCBPecZu29994z06yxLVFNs7Zhw4Zw04a5TuF1L/Y0YpymLU+ePGaaMU4PF3Eqrv79+zsyZcpknturVy9H9+7d75pmrWvXro6XXnrJTLPGqcL+97//3TXNWsSpzyJuy8g+D6cHe/zxxx3Jkyc3U7FxGrmBAwc6Hz9x4oSjUaNGpu3czxMmTIjRNGtnz551PPvss2ZqOO4vTpE2c+bMcNsnutuC35d69eo5MmTIYNpToEABx9dff+18LaeUsz+L6z7iZ+jQoYMjffr05nXcFzwu7e9lZNO73Yu9HSO7RHVceOL7njSpNdXIvn1xtkoRERERj+rRw/r987//+e80a/H4P0+fJPBV7N1lLx6nYIqYXssiVSzExbGz7BkW/8N0f/Y4RzclXPxXXH/fb9xgtsudnnQvmv1NREREJNZ88AHw7rtAly7AyJHeEfe5m6q4i4j4GDu9nWOUvax2nYiIiEisSZfO/8egK0AXiQLH0LtOUeZ6+SgAKnFxrH5Un59zxfuqJUuWRPm5ePGlAJ0950H6Ky4iIiIBIr2KxIkErjFjxuDatWuRPsZiYbx06tQJ/qpJkyZ49NFHI30sYhV6X8LigywW6MtcK7iLiIiIBIr0AVAkTgG6SBSyZcuGQMZp83jxN6xSH9XUc74iYgV3ERERkUCQPgB60JUcKSLiYxSgi4iISKCPQXf4aalzBeixTEXyRfxfXH/PleIuIiIigRygh4YCFy/CLylAjyXx48c31zdv3vR0U0Qkltnfc/t7H9vUgy4iIiKBKEkSIFky/x6HrjHosSRBggRImjQpzpw5YwpqBanUsohfCgsLM99zft/5vY8LCtBFREQkkMehX7lipbnnzQu/owA9lsSLFw9ZsmTBgQMHcOjQIU83R0RiEU/A5ciRw3zv44JS3EVERCSQA/RDh/y3UJwC9FiUMGFC5M+fX2nuIgHwXY/LLBn1oIuIiEigSudSKM4fKUCPZfzRnjhxYk83Q0T8iB2gqwddREREAk16D0y1ZmcvxgUF6CIiPsb+R0I96CIiIhKoAfqaNcBff92Zbo3XrrcjXsf0MV727AH+/htYuRJxRgG6iIiPUYq7iIiIBKoMGazrn3+2Lv5GAbqIiA/h2VyluIuIiEigatMG+Ocf4MIF6z5r9Np1eiO7ju6yyB7jePe6dYHHHgOKFImTj6cAXUTEl1y9ynnXrdvqQRcREZFAky8fMG9e3K4zJCTu1qXJuUVEfIjde84p15Ml83RrRERERMSdFKCLiPgQ1/T2OJp2XURERETiiAJ0EREfogruIiIiIv5LAbqIiA9RBXcRERER/6UAXUTEh6iCu4iIiIj/UoAuIuKDAXrq1J5uiYiIiIi4mwJ0EREfcumSdZ0ypadbIiIiIiLupgBdRMQHA/QUKTzdEhERERFxNwXoIiI+5PJl6zp5ck+3RERERETcTQG6iIgPUYAuIiIi4r8UoIuI+BCluIuIiIj4LwXoIiI+RD3oIiIiIv5LAbqIiA9RgC4iIiLivxSgi4j4YICuFHcRERER/6MAXUTEB8egqwddRERExP8oQBcR8SFKcRcRERHxXwrQRUR8iFLcRURERPyXAnQRER9x4wZw65Z1Wz3oIiIiIv5HAbqIiI/1nlOyZJ5siYiIiIjEBgXoIiI+FqAnTgwkSODp1oiIiIiIuylAFxHxsQruGn8uIiIi4p8UoIuI+AhVcBcRERHxbwrQRUR8hAJ0EREREf+mAF1ExEcoxV1ERETEvylAFxHxEepBFxEREfFvCtBFRHyEAnQRERER/6YAXUTERyjFXURERMS/KUAXEfER6kEXERER8W8K0EVEfIQCdBERERH/pgBdRMRHKMVdRERExL8pQBcR8RHqQRcRERHxbwrQRUR8hAJ0EREREf+mAF1ExMdS3BWgi4iIiPgnBegiIj7Wg64x6CIiIiL+SQG6iIiPUIq7iIiIiH9TgC4i4iOU4i4iIiLi3xSgi4j4CKW4i4iIiPg3BegiIj7A4VCKu4iIiIi/U4AuIuIDrl8HwsKs2wrQRURERPyTAnQRER8af07JknmyJSIiIiISWxSgi4j4ADu9ncF5kP5yi4iIiPgl/cwTEfEBGn8uIiIi4v8UoIuI+FCKuyq4i4iIiPgvBegiIj5APegiIiIi/k8BuoiID1CALiIiIuL/FKCLiPhQirsCdBERERH/5ZMBemhoKPr164fcuXMjSZIkyJs3LwYMGACHw+F8Dm/3798fWbJkMc+pU6cO9uzZE+59zp07h3bt2iFlypRInTo1OnfujMt2N5WIiBex/zRpDLqIiIiI//LJAH3QoEEYPnw4vvnmG+zYscPc//TTT/H11187n8P7X331FUaMGIFVq1YhWbJkqFevHq5fv+58DoPzbdu2Ye7cuZg5cyYWL16MLl26eOhTiYhETSnuIiIiIv4vAXzQ8uXL0bRpUzRq1Mjcz5UrF3766SesXr3a2Xv+xRdfoG/fvuZ5NGHCBGTKlAl//PEH2rRpYwL7WbNmYc2aNShXrpx5DgP8hg0bYvDgwciaNasHP6GISHhKcRcRERHxfz7Zg165cmXMnz8fu3fvNvc3bdqEpUuXokGDBub+gQMHcPLkSZPWbkuVKhUeffRRrFixwtznNdPa7eCc+PygoCDT4x6ZGzduICQkJNxFRCQuKMVdRERExP/5ZA/6W2+9ZYLjQoUKIX78+GZM+sCBA03KOjE4J/aYu+J9+zFeZ8yYMdzjCRIkQNq0aZ3Piejjjz/G+++/H0ufSkQkakpxFxEREfF/PtmD/ssvv+DHH3/EpEmTsH79enz//fcmLZ3Xsentt9/GxYsXnZcjR47E6vpERGxKcRcRERHxfz7Zg/7GG2+YXnSOJafixYvj0KFDpoe7Y8eOyJw5s1l+6tQpU8XdxvulSpUyt/mc06dPh3vf27dvm8ru9usjSpQokbmIiMQ1pbiLiIiI+D+f7EG/evWqGSvuiqnuYWFh5janX2OQzXHqNqbEc2x5pUqVzH1eX7hwAevWrXM+Z8GCBeY9OFZdRMSbKMVdRERExP/5ZA9648aNzZjzHDlyoGjRotiwYQM+//xzPPfcc+bxePHi4dVXX8WHH36I/Pnzm4Cd86azMnuzZs3McwoXLoz69evjhRdeMFOx3bp1C927dze98qrgLiLeRinuIiIiIv7PJwN0TofGgLtr164mTZ0B9Ysvvoj+/fs7n/Pmm2/iypUrZl5z9pQ/9thjZlq1xIkTO5/DcewMymvXrm165Fu0aGHmThcR8TZKcRcRERHxf/EcnDRcHgjT5jl9GwvGpUyZ0tPNERE/xnIanGBi40agZElPt0ZEREQkcITEYdznk2PQRUQCjVLcRURERPyfAnQRES/H+pdXrli3FaCLiIiI+C8F6CIiXu7q1Tu3NQZdRERExH8pQBcR8ZECcfHiAUmSeLo1IiIiIhJbFKCLiPjQ+HMG6SIiIiLinxSgi4h4OU2xJiIiIhIYFKCLiPhIgK4CcSIiIiL+TQG6iIiXO3LEulaALiIiIuLfEni6ASIiErXQUODjj63bdet6ujUiIiJi5j/l2fNdu4Ddu4EzZ6yCMSEh4S+uyzhO7e+/gaJFPd168XIK0EVEvNjEicDWrUDq1MCbb3q6NSIiIgGEATaDcNfLzp3Anj3AtWsxe68LF4A2bYDVqzUli9yTAnQRES/Ff/v79bNu/+9/QJo0nm6RiIifcjiAEyeAbdusoOzmzbsvN27cuX379t2v9xV58wLPPgskUBjgxH3KwHvLFuvCM+O8Pnw46tcEBwP58gEFCwJZsgApU4a/sMfcvh0UBDRqZL0vz7Z//XVcfjrxMfpmioh4qW+/BY4eBR55BOje3dOtERHxE9evAzt2AJs2WZfNm63rs2cRMNavB4YNC7y5O3liZd8+Kxi3g3Bes2c84kkXW6ZMVhDueilUCMiVK2YnOcaPBxo0AL75BqhXD3jiCbd9LPEvCtBFfBh/T9SqBZw75+mWSGwaMEDZcCIiD+TkSesfy40b7wTjDM5Y4CMi9nLmzw+kTw8kTBj5JVEi6zp+/LuDW18Idq9eBUaNAkaMAHLmBN56C37pyhUr6OaJGF64z3nN1PRbtyJ/TapUQPHiQLFi1rV9213pa/XrA716AUOHWhkMPBbZ8y4SgQJ0ER82d66Cc39XsSLQvr2nWyEi4uXY+8mAzA7E7aD89OnIn8+gq2RJoEQJ65qXIkUC42xo4cLAq68Cb78N5MgBPP00fHoe0u3braEJrteHDkX9mqRJrR5wbgc7EOeF6WqxfZKFVV8XLrSOzQ4dgNmzrRNDIi4UoIv4sH//ta67dLF6WcX/sCNH/3aLiLhg0M3eR6Yn85oXBmYcIx4RA64CBe4E4fYlWzbf6PGODT17WgEse3I7dQKyZgVq1IDPBeK83GuMOP8BZRBuB+P2JXt2z/3DygyMn34CypQB5s0DPv8ceP11z7RFvJYCdBEfZg+X4781GTN6ujUiIiJuxICbQVjEYDyqXvHkye/0iJcqZV0zRTlZsrhuufcbPNgKbn/7DWjWDFi2zDum/2J1VHt8uB2E8/bBg1G/hmPE2XZmQNjXvDBA90Y8YfDll1bvCivA1qwJlC3r6VaJF1GALuIHPeje+m+QiIhItKtoMxhbu9a6rFtnBeORjRdmzzcrkTMY54XpybzOk0cpR9HF7cR5PFm5fvlyoGFDYOXKuBsTzUJ9HJLg2hvOCwu4cY7xewXiEYPxdOngc55/Hpg1C/j9d6BtW6toH08wiShAF/GPAN0X/20SEZEAZfeSbthwJyBnMB5ZinratFZPuB2E85qBmXrFHx7H20+bBlSubBVP4zRgixZZ04O5C/cpA3E7ALcD8r17ow7Euc+Z+cD9bF/z4k+9ETzJNHq0NSc6tz2HHYwd6+lWiZdQgC7iBynu/vRvloiI+FHhNgZiTFG2L0xVjyo4S50aKFfOSvflNS+sNB6oY8XjAn9A/P03UKmSdcKkVStgxoyYz5Fu72s7Jd2+MPiMrGK+vb9de8TtYJw95YGwz3ki4ocfrBT3776zpl7j9peAF8/hcDg83QhfFRISglSpUuHixYtImTKlp5sjAYjjzs+csYrVsmNBRETEYynq/MeIadLsFWQgzmmtuDwyds+4HYgzKGeKeiAEZt6I+4yF4pjdwPRrTsUW2b7giZUDB8KnpTMQv9e+5vRldiDuGpAznV77G+jbFxg40NpO/A7xpJQEdNynAP0hKEAXT+K/kZyKlSemjx2zirCKiIjEOv50PHLECsbtC8fQRpaizlR0O1XZvjBNPVB6SX3J9OnAk09aPzA4Ncwzz4QPxO0UdQbxUU1f5rqv7dv8gaJ9HTXWWahWzfoeVakC/PNPzDMYJNYpQPcRCtDFk86ftzog7FornLlDREQkVjBd69dfgblzrUCCxcUi4j9KFSsCjz5qVVFncJYrlwq3+ZJvvwW6d7/3c/iDg5XI7d5wnnDhvmbPr/b1g9m/3/rOXLpknbxiD4w3iSxcjLiM9+0LT/LwYt92Xeau9UWXa7uiukRDiMOBVECcxH06PSPi4+PPWfRTwbmIiLgdg4U//rDmbZ4zJ/xY4vjxrRR1BuT2JV8+9ZT6um7dgKNHgU8+AYKDgYIF7wTidq84hyKoh9e9uE1HjgSefho4dcrTrREPUw/6Q1APungSOzBY04WdExwOJiIi8tCYps6iYZMmWcXCmKJl4zjxli2tNFzeZkqz+CdmSLCAHIN0iTucZu7CBXilyE6+RVzG+8yi4MW+HXFZdE/ixYvG+mLS9vtd7iPk0iWkyp9fPegiEjVNsSYiIg+F6aZMxzp5Ejh0CJg6FfjtN+Zw3nlOgQJWrx7nauZtCQxxNR+6hJc3r6dbIPealjCOKEAX8VGaYk1ERO6LVUQZdB8/bgXiTJ+1r0+fjnwKrGzZgDZtrMC8dGmlrYuIxCEF6CI+Sj3oIiJyTytWAE2a3PkHIyo808vCVExdZ1BetaqKfYmIeIgCdBEfpR50ERGJ0pQpQPv21phyFveqXRvInNkKxF2vM2TQOGMRES+iAF3ER9kdIgrQRUTEibV/P/sM6NPHut+4sVXwjVN+iIiI11P+koiP96ArxV1ERIzbt4GXX74TnPfoYRV+U3AuIuIz1IMu4qPUgy4iIuHmLG/VCpg1yyrqNnQo0LOnp1slIiIxpABdxEepSJyIiBhHjwJPPAFs2mRNBfTTT0DTpp5ulYiIPAAF6CI+SkXiREQEGzcCjRpZ06ix8NuMGUD58p5ulYiIPCCNQRfx0RpAGoMuIhLg/v7bmhKNwXmRIsDKlQrORUR8nAJ0ER8UEmLVAiIF6CIiAWjOHGuO88uXgVq1gGXLgFy5PN0qERF5SArQRXx4/HmyZNZwQxERCSCbNwMtW1pnalu3tnrSU6f2dKtERMQNFKCL+CAViBMRCVDHjlljzlm1vUYNYMIEIGFCT7dKRETcRAG6iA9SgTgRkQDEoJzV2lm1vXBh4PffFZyLiPgZBegiPkg96CIiAcZOZ2fV9owZgb/+AtKk8XSrRETEzRSgi/gg9aCLiATY1B3du1tjzVl4ZOZMFYQTEfFTCtBFfLgHXQG6iEgA+OwzYORIIF484KefNJWaiIgfU4Au4oM0B7qISID45RegTx/r9hdfAE2berpFIiISixSgi/gg9aCLiAQAzm3eoYN1+9VXgVde8XSLREQklilAF/FBKhInIuLn9uyxestv3ACaNQMGD/Z0i0REJA4oQBfxQSoSJyLi52dhGza0/thzvPmPPwLx43u6VSIiEgcUoIv4IPWgi4j4sf/9D9i7F8idG5gxA0ia1NMtEhGROJLgQV/Yu3fvGL+mb9++SJs27YOuUkT+m21HPegiIn7qwgWrx5zGjQMyZfJ0i0RExBcC9C+++AKVKlVCwoQJo/X8pUuXonv37grQRR7SpUvArVvWbfWgi4j4mYkTgatXgaJFgWrVPN0aERHxlQCdpk6diowZM0bruSlSpHiYVYlIhPT2JEmU9Sgi4ncpUsOHW7dfftma91xERALKAwfo48aNQ6pUqaL9/JEjRyKT0rREYuTUKZ4IAxYtAhYvBk6ftn6/kdLbRUT8zJIlwI4dQLJkQPv2nm6NiIj4UoDesWPHGD3/6aefftBViQSsWrWA7dsjf6xmzbhujYiIxCq795y/mVKm9HRrRETE11Lco7J//35cu3YNhQsXRlCQCsWLPIgrV+4E5/36AbVrA/nyWRmP/FopIUVExI8wReq33+6kt4uISEB6qOj51q1bePfdd9G4cWMMHDgQoaGhaNu2LfLnz48SJUqgWLFiOHjwoPtaKxJAOMMOsa7iBx8A1asD2bIBWbMCmTNraKKIiF/57jurAmiFCkDp0p5ujYiI+GKA/tZbb2H48OHInDkzvvvuOzRv3hwbNmzApEmTMHnyZCRIkADvvPOO+1orEkD27LGuCxTwdEtERCRWhYayWI91W73nIiIB7aFS3H/99VeMHz8eDRs2xO7du1GoUCH8+eefaNCggXmcFd7btWvnrraKBJTdu63r/Pk93RIREYlVc+YAzDhMnRpo3drTrREREV/tQT9+/DhKlixpbhcoUACJEiVCPg6S/Q+XnTx58uFbKRLAPegK0EVEAqQ4XKdO1hyaIiISsB4qQOeY8+DgYOd9prTHjx//zpsHBcFhzwklIjGiAF1EJAAcPgz8+ad1+6WXPN0aERHx9Srus2fPds6HHhYWhvnz52Pr1q3m/oULFx6+hSIBSmPQRUQCwOjR/AFlzatZsKCnWyMiIh4Wz/EQXdzRmUItXrx4pqfdH4WEhJiTExcvXkRKzVcqbnTxojUUkUJCgBQpPN0iERFxO1Ztz5ED4HDAX34BnnrK0y0SEREPx30P1YPOHnMRib3ec851ruBcRMRPTZtmBeecO7NZM0+3RkREfH0MuojEDo0/FxEJoOJwnTsDLjV9REQkcD1UD/rixYuj9bxq1ao9zGpEAo7Gn4uI+Lldu4AFCzheEOjSxdOtERERfwjQa9SoYcaYU1RD2f15DLpIbNEc6CIifm7kSOu6USNrHLqIiMjDBuhp0qRBihQp0KlTJ7Rv3x7p06d3X8tEAphS3EVE/Ni1a8D48dZtTa0mIiLuGoN+4sQJDBo0CCtWrEDx4sXRuXNnLF++3FS2Y5U7+yIiMaMAXUTEj/38M3D+PJArF1CvnqdbIyIi/hKgJ0yYEK1btzZzoe/cuRMlSpRA9+7dkT17drzzzju4ffu2+1oqEiDOnrV+t1G+fJ5ujYiIuN2IEdb1iy8C8eN7ujUiIuIv86BH5sCBA6YnfdGiRThz5gzSpk0Lf6V50CU2rFwJVKoEPPIIcOSIp1sjIiJutWEDUKaMVbX96FEgY0ZPt0hERLwo7nPLNGs3btzApEmTUKdOHRQrVsyMRf/zzz/9OjgXiS0qECciEgBTq7VooeBcRETcWyRu9erVGDduHCZPnoxcuXLh2WefxS+//KLAXOQhaPy5iIifOn0a+PFH67aKw4mIiLsD9IoVKyJHjhx45ZVXULZsWbNs6dKldz2vSZMmD7MakYCiAF1ExE8NGgRcvQqUKwdUq+bp1oiIiL8F6HT48GEMGDAgysc1D7rIgwXoBQp4uiUiIuI2x48Dw4ZZt/m7KV48T7dIRET8LUAPCwtzX0tEBCzZqDHoIiJ+6KOPgOvXgSpVNLWaiIjEbpE4EXGPU6eAy5eBoCAgTx5Pt0ZERNzi0CFg1Cjr9ocfqvdcRETcH6BPnz4dt27divbz//rrL1y7du1BVycSUOntOXIAiRJ5ujUiIuIWDMr5m6lWLaBGDU+3RkRE/DFAf/LJJ3HhwoVoP79NmzY4ceLEg65OJCBo/LmIiJ/ZuxcYN866fY+aPSIiIg81Bt3hcKBTp05IFM1uvuscdyUi96Tx5yIifuaDDwAWy23QAKhc2dOtERERfw3QO3bsGKPnt2vXDilTpnzQ1YkEBE2xJiLiR7ZvB374wbqt3nMREYnNAH2cna4lIm6jAF1ExI+89541PceTTwJly3q6NSIi4gNUxV3ES3DWQg5VJAXoIiI+btMmYMoUq2L7++97ujUiIuIjFKCLeInjxwFOdJAgAZArl6dbIyIiD6V/f+u6dWugeHFPt0ZERHyEAnQRLysQlzs3EBzs6daIiMgDW72a89ECQUFWmruIiEg0KUAX8RIafy4i4me95+3bAwULero1IiISyAF6XE2nduzYMTzzzDNIly4dkiRJguLFi2Pt2rXhpoHr378/smTJYh6vU6cO9tgR0H/OnTvnrC6fOnVqdO7cGZcvX46T9otEpABdRMQPLF0KzJ5tjVeyA3UREZG4DNDDwsIwYMAAZMuWDcmTJ8f+/fvN8n79+mHs2LFwt/Pnz6NKlSoIDg7G33//je3bt2PIkCFIkyaN8zmffvopvvrqK4wYMQKrVq1CsmTJUK9evXAnEBicb9u2DXPnzsXMmTOxePFidOnSxe3tFYlJgF6ggKdbIiIiD4QV2/v2tW4/9xyQJ4+nWyQiIoEYoH/44YcYP368CYoTJkzoXF6sWDGMGTMG7jZo0CBkz57dTPVWoUIF5M6dG3Xr1kXevHmdvedffPEF+vbti6ZNm6JEiRKYMGECjh8/jj/++MM8Z8eOHZg1a5Zp36OPPorHHnsMX3/9NSZPnmyeJ+KpMejqQRcR8VELFgCLFgH8LWQH6iIiInEdoDP4HTVqlOmRjh8/vnN5yZIlsXPnTrjb9OnTUa5cOTz11FPImDEjSpcujdGjRzsfP3DgAE6ePGnS2m2pUqUygfiKFSvMfV4zrZ3vY+Pzg4KCTI+7SFwKDQX+SzxRgC4i4uu95y+9BGTP7ukWiYiID0rgrvHg+fLlizT1/datW3A3ptAPHz4cvXv3xv/+9z+sWbMGr7zyium979ixownOKVOmTOFex/v2Y7xmcO8qQYIESJs2rfM5Ed24ccNcbCEhIW7/bBKYDh8Gbt60Ol30m05ExMvdvm2NS9qy5c5l82b2EABJkgBvv+3pFoqISCAH6EWKFMGSJUuQM2fOcMt//fVX07vtbgz82fP90Ucfmftcx9atW814cwboseXjjz/G+++/H2vvL4HLHn/O81wuSSgiIoHXC80stnPn+I+9dZ+XyG5H9/0ie4+IyyN7XURnz94Jxnfs4Fn7u58TLx5/LACZMz/AhxcREXFTgM5q6QyM2ZPO4Pn333/Hrl27TOo7i6+5Gyuz86SAq8KFC+O3334ztzP/9w/jqVOnzHNtvF+qVCnnc06fPh3uPW7fvm0qu9uvj+jtt982vfauPegcCy/ysFTBXUQCHoNipoaPGgWfkCwZi+0AxYuHv6RP7+mWiYhIoAfoLMQ2Y8YMfPDBB6ZaOgP2MmXKmGWPP/443I0V3HkCwNXu3budPfgsGscge/78+c6AnME0x5a//PLL5n6lSpVw4cIFrFu3DmXLljXLFixYYE4wcKx6ZBIlSmQuIu6mAF1EAt7IkVZwHhQE8N9uXvPCXmleXG/bl+iI+LrI3ofL7id5cqBoUSsIL1ECyJUreq8TERGJ6wCdqlataqYriwu9evVC5cqVTYp7q1atsHr1alOkjheKFy8eXn31VVNdPn/+/CZg55RvWbNmRbNmzZw97vXr18cLL7xgUuM5Vr579+5o06aNeZ5IXDp1yrrWoSciATt3+CuvWLc5fK1PH0+3SERExLcD9LhUvnx5TJ061aScs9eeATinVWMVedubb76JK1eumHnN2VPOadQ4rVrixImdz/nxxx9NUF67dm1Tvb1FixZm7nSRuHbxonWdJo2nWyIiEseOHgVatgRYVLZVK/4D7ukWiYiIeEw8BycNf0hp0qQxvdZ3vXm8eCYgZoX3Tp064dlnn4U/Ydo8p2+7ePEiUqZM6enmiA+rXJlT/wFTpwL/JXmIiPi/69eB6tWB1auttPHly62x3SIiIgEa97mtSNzAgQPRoEEDVKhQwSxj2jl7rLt162bmJefYbxZhY0q5iIR34YJ1nSqVp1siIhJH2D/QrZsVnDN9iGcoFZyLiEiAc0uAvnTpUjPe+yVWX3UxcuRIzJkzx1RXL1GihEkfV4AuEnWAnjq1p1siIhJHhg8HvvvOKrT2889AnjyebpGIiIjHuaX86OzZs1GnTp27lnNsNx+jhg0bYv/+/e5YnYjfscegK0AXkYCwZAnQs6d1+5NPgFiY8UVERCRgA/S0adOaKdUi4jI+RizYliJFCnesTsSv3LwJXL1q3VaALiIBUxTu9m2gTRvg9dc93SIRERH/SnHnFGYcY75w4ULnGPQ1a9bgr7/+MlOYEadgq85CMCISae85qdagiPh9UbjmzYHTp62icGPGRH8+cxERkQDglirutGzZMnzzzTfYtWuXuV+wYEH06NHDzFfur1TFXdxhzx6gQAGACSYhIZ5ujYhILOHPjeeeA8aPZ+odsHYtkDu3p1slIiLif1XcqUqVKuYiIjGj8eciEjBF4Ric20XhFJyLiIjEXoBuu379Om5yUK0L9S6LRE0V3EXE74WGcjycdXvQICCSwrIiIiLipiJxV69eRffu3ZExY0YkS5YMadKkCXcRkahpDnQR8XsbNgDnzlmFNl591dOtERER8e8A/Y033sCCBQswfPhwJEqUCGPGjMH777+PrFmzYsKECe5YhYjfUg+6iPi9+fOt6xo1gARuT94TERHxG275V5LTqTEQr1GjBp599llUrVoV+fLlQ86cOfHjjz+iXbt27liNiF/SGHQRCZgAvXZtT7dERETE/3vQz507hzx58jjHm/M+PfbYY1i8eLE7ViHit9SDLiJ+7cYNYOlS67YCdBERkdgP0BmcHzhwwNwuVKgQfvnlF2fPempFHSL3pDHoIuLXVq4Erl0DMmcGihTxdGtERET8P0BnWvumTZvM7bfeegvffvstEidOjF69epnx6SISNfWgi0hApLfXqgXEi+fp1oiIiPj/GHQG4rY6depg586dWLdunRmHXqJECXesQsRvaQy6iARMgC4iIiL3FCulVFkcLlWqVEpvF4kG9aCLiN+6dAlYvdq6rfHnIiIicZPiPmjQIPz888/O+61atUK6dOmQLVs2Z+q7iEROY9BFxG+xUOzt2yxWA+TK5enWiIiIBEaAPmLECGTPnt3cnjt3rrn8/fffaNCggcagi9yHetBFxG9pejUREZG4T3E/efKkM0CfOXOm6UGvW7cucuXKhUcffdQdqxDxWxqDLiJ+SwG6iIhI3AfoadKkwZEjR0yQPmvWLHz44YdmucPhQGhoqDtWIeKX+PUICbFuK0AXEb9y5gywebN1u2ZNT7dGRMQtGN+cuXoGBy8cdF4u3bgUrdcWy1gMrYq2QjzNaCGxHaA3b94cTz/9NPLnz4+zZ8+a1HbasGGDqeQuIpGzg3PSGHQR8SsLF1rXxYsDGTN6ujUiItF24foF7Dm7BwcuHAgXiNuXa7evPfB7Hwk5gtcrv+7W9op/cUuAPnToUJPOzl70Tz/9FMmTJzfLT5w4ga5du7pjFSJ+Pf48SRIgYUJPt0ZExI2U3i5+2ntqruGI8rEHet9ovl/8oPgIiueWElIBj73ee87tMYG4uXa5/e/Vf+/52niIh2wpsyFX6lzmkjpR6vv2irPXffLWyegzrw/KZS2HGrlquPkTib9wS4AeHByM119//Z7zo4vI3TT+XET8lgJ0cQMGqaevnA7Xe3no4iFzffjiYVy/fR2hjlCEhoWa69tht523eW3uO0JjtD7z33/Xrsu8QZrEaTCmyRg0L9zc003xmZ7wvef2Yt+5feZ67/m95pqB+Kkrp+752szJMyNvmrzOINz1kiNVDiSMH7OeFR5HwUHBmLh5Ilr/2hrru6w3Qb5IrAToEyZMuOfjHTp0cMdqRPyOKriLiF86dAjYtw+IHx+oVs3TrREfCcK3ndmGbae3Yce/O8KlFjMIF8v56+fR5tc2+KPNH2iYv6Gnm+MVzl07h91nd5uLCcT/C8J5++y1s/d8bYakGZA/XX7kT/vf5b/b+dLmQ4pEKdzaTvawj3hiBDad2oTNpzaj1a+tsLDjwhgH+uL/3BKg9+zZM9z9W7du4erVq0iYMCGSJk2qAF0kCpoDXUT8uve8QgUgZUpPt0a8yNmrZ00gvvX0VhOMm6D8zLZ7phRHTCfOlepOL2ayhMkQP158k/rN6wRBCSK9HZOiXFwfn29f32uZO0XWRtd1sBe/21/dTJp085+b4692f6FW7loIBFduXjFBtx2IMw3dvn2/IJw94Qy42RtuX9uBeKrEcfsDLGlwUvzW6jeUG1UOy48sxxtz3sCXDb6M0zZIgATo58+fv2vZnj178PLLL2sedJF7UA+6iPglpbcj0HvEj106hh1ndpje8J3/7jTXvB9VWjED0Txp8qBoxqIomqGoCaQYhOdMlRPZU2VXL+N/JjSbgGu3rmHarmlo8lMTzGk/B5WzV4Y/uHzzsun13nf+v3T0/y4Mxo+GHL3nax9J+Yiz59v1wmMqeUKrNpa3YLsmPjkRTSY3wVerv0LFRyqibfG2nm6W+FuAHhlWdP/kk0/wzDPPYOfOnbG1GhGfpjHoIuJ3WNhqwQLrdq3A6N0LVBzjzWCKveF2EM5rXhhsRYVBNwPxYhmKOQPywhkKm95Fubfg+MH4ueXPJribs28OGvzYAAs6LEDZrGU93bRo4ckFBty7/t1ler/tdHReTl4+ed/x9wXTF0SBdAVQIG0B6zpdARPwMpPClzQu2Bj/e+x/+GjpR3h+xvMonqm4mYJNJFYDdPPmCRLg+PHj2tIiUVAPuoj4nR07gJMngcSJgUqVPN0aceM43y2ntpixs+ZyerMJzK/euhrp85lWzsCpUPpCKJy+sHWdobC57e6xvYEmUYJEmNp6qgnOFx9ajLo/1MWiTou8JsBjBgWD7V1ndzlP2Ni3D104dM+Ce+mSpLPS0NPmRb40d3rCGYinS5oO/uSDmh9g9fHVmLd/Hlr80gJrXliDlIk0JEjcFKBPnz79ri8mp1j75ptvUKVKFXesQsQvaQy6iPhtevtjj1lBuviUG7dvmGCKwbcJyE9bAXlUKcZJEiRBkQxFnMG3HZAzwFJaeuxhtsHMtjNRZ2IdrD62GnUm1MHiZxebQDau3Aq9ZTIoTPbEmR3YedYKxnkJuRES5etSJ05tjhO21TUtnWPD0yRJg0DB+giTmk9C2VFlTTbBs9Oexa9P/Rqjegnin9wSoDdr1izcfR5YGTJkQK1atTBkyBB3rELEL6kHXUT8jsaf+wROP8bxvgzEzeWMdc3pp6Kalix36twokalEuAuDKgYaEveYiTCr3SzU/L6mqQxee0JtLHl2iRm7707nr503ael28G0PZWBaOo+jyHCudh4vDMQLpitoXae3rlk5XUGoJUOyDJjy1BRUHVcVv+/4HYOXD8YbVVS/K9C5JUAPCwtzx9uIBByNQRcRv3L7NvDPP9ZtBehegz2d7AVfdWyVuWw6uckEWDdCb0TZw8l0aY4RL5m5pAnEeV/pt96HPc4sFFd9fHWzTxmkL+60OMbza3MIgz0/uF2Yzb7mY1FJFpzMBN2uQxl4YY84U/Hl/h595FF81eArvPzny3hr/lsol7Ucauau6elmib+OQReRe1MPuoj4lfXrrTOPHLdTpoynWxOQOMzwSMgRrDq6CiuPrjQB+boT6yKdS5zBFdPTTTDucsmSPIt6OH1IxmQZMa/9PFQbXw37z+83ae8ck87lrsfFmatnnPODm8JsLgXa7hWEU9YUWZ094a6BOKun61h5eC+WfRErjq7AhE0T0Oa3NljfZX2MT7KI/1CALuJBGoMuIn6Z3l6jBhBfac9x5dTlU/hh8w9YemSpCcojq4bNCtjsqXs026Mok6UMimcsjpypc5pUZPF9DObmd5iPauOqmZ70xyc+job5Gpog3A7IL928dN8g3B4T7rxOl98MY/C1Kum+hic5hjcajo0nN5pslyd/fhLtS7SP83bcq4BfRGGOMDOTA4fE3Os2Tw65e93RwfXa72nfjmqZ8zUuj0VcdvPqTcQVBegiHqQedBHxKxp/HqfWHFtj5lH+eevPuBV2y7k8QVAClMxU0gTjnGOZgTkDLvV0+jeOPZ/XYZ4J0u1q+xHnmuec8nZBNvtaQbj3FP77vdXvpmjcmuNrzEW8yN1JSLFGAbqIB2kMuoj4jevXgWXLrNsK0GPNzdCbmLJtCr5e/bVJX7cxEG9ZuKW5Zg95kuAkHm2neAYroy/ouAADFg9wTllmB+K50+RG4gSaWcGbcfaDue3nmu93VDUiYhtP5Ny1LJKTe3weC0RySkVm4jivXZcFxY/0/aJcdxTreVB8P/v19u2olkW1TvuxG1du4BN88sBtiVG7HdHNO5C7hISEIFWqVLh48SJSplThFIkZfvMSJGCRReD4cSBLFk+3SETkISxcCNSqZf0xO3aMv2o83SK/cuLSCYxcN9Jc7BR2TmPWumhr9KjQA+Wzlfd0E0VE/FZIHMZ9bulBz5UrF5577jl06tQJOXLkcMdbivi9y5et4Jw0Bl1E/Ca9nUG6gnO3YB8Ke8nZm8ZeczuNnUXcXi73MrqU7YJMyTN5upkiIuJtAfqrr76K8ePH44MPPkDNmjXRuXNnPPnkk0iUSNMriNxv/HlwMJBEmYgi4us0/twtzl49i3n752H2vtmYs28Ojl065nyscvbKpre8eeHmpvdcRET8j1tT3NevX28C9Z9++gmhoaF4+umnTc96GT+dakUp7vIwtm4FihcHMmQATp/2dGtERB5CSAiQNi0QGgocPAjkzOnpFvnUHOXsJZ+9d7YJytceXxuumjHHDNtp7GWzlvVoW0VEAlVIHMZ9sTIG/datWxg2bBj69OljbhcvXhyvvPIKnn32Wb+qIKoAXR7G0qVA1apA/vzA7t2ebo2IyEOYMQNo0gTImxfYu9fTrfF6Ry4ewZ97/jQ95PMPzEfIjZBwj3Mu8np566Fu3rqomqOqCr6JiHiYz41BtzEYnzp1KsaNG4e5c+eiYsWKJt396NGj+N///od58+Zh0qRJ7lyliM/SHOgi4jeU3n5PnAt4/Yn1mLFrBqbvnm7mOnbFatuP530cdfPUNUE557QWEZHAlMBdqe0MypnaHhQUhA4dOmDo0KEoVKiQ8zkck16+vCqMitg0B7qI+A0F6He5fvs6FhxYgOm7pmPG7hk4fum48zFOP1TpkUqon6++6SnntGicjkhERMQtAToD78cffxzDhw9Hs2bNEMyqVxHkzp0bbdq0ccfqRPyC5kAXEb9w8qRVVINq1kQgO3ftHKbtnGZ6yZm+fvXWVedjyYKTmYC8cYHGaJi/ITIky+DRtoqIiJ8G6CwG991336FJkyZIkyZNlM9LliyZ6WUXEcvff1vXqqUkIj5r+XKgUyfrdqlSVtXLALTv3D4MXTkU3234DtduX3Muz5YiG5oUbGIuNXLVMAXfREREYjVAjx8/Pl588UVUq1btngG6iNzBzqY//7SmCu7SxdOtERGJoWvXgH79gM8/52TdQNaswLBhCDTLjyzHkBVDMHXHVGfldRZ4a1m4pQnKS2Uu5VfFcUVExEdS3IsVK4b9+/ebNHYRub9PP7WuW7QAChTwdGtERGJg5Uqr13zXLut+x47A0KFAgJykDw0LxbRd0zB4+WCsOLrCubxBvgZ4rdJrqJW7loJyERHxbID+4Ycf4vXXX8eAAQNQtmxZk87uSlOQidxx6BDw00/W7T59PN0aEZFoun4d6N8fGDIECAsDsmQBRo0CnngCgeDKzSsYv3G8SWXfd36fWZYwfkI8U/wZ9K7UG0UzFvV0E0VExA+4JUBv2LChueY4dNezxpxinfc5Tl1ELMwIvX0bqFULKFfO060REYmGVausXvOdO6377dsDX3wBpE0Lf3Yr9JZJY2cV9nEbx5kicJQ2SVp0LdcV3Sp0Q+bkmT3dTBER8SNuCdAXLlzojrcR8XsHDgBjxli333rL060REYlGr/n771vjcthrnjkzMHIkz8jDX528fBJ/7/kbf+39y1RiD7kR4nwsb5q8pre8Y8mOSJYwfLagiIiI1wTo1atXd8fbiPi1FSuAZs2Aq1c5NSFQp46nWyQiEoWbN4Hx44GBA4HDh61l7doBX33ld73mHFO+5vga/LXnL3NZd2JduMczJM2ABvkboHmh5niiwBOar1xERLw/QKcLFy5g7Nix2LFjh7lftGhRPPfcc0iVKpW7ViHisyZPtrJDb9wASpcGpk61KriLiHiVW7eACRNYXAY4eNBaxgrt335rnWH0o/Hks/fNxtSdU01v+dlrZ8M9Xj5reTNXOS/lspZDULwgj7VVREQCSzwHB4o/pLVr16JevXpIkiQJKlSoYJatWbMG165dw5w5c1CmTBn4o5CQEHMC4uLFiyqEJ1H69VegVStrJqKmTYEffgCSJ/d0q0REXLAwxo8/Ah98AOzfby3LlMkai/Pii0CSJPB156+dx8zdM01QPmvvrHDzladKlAr18tVDw3wNUT9ffWRKnsmjbRURkcCN+9wSoFetWhX58uXD6NGjkSCB1Sl/+/ZtPP/882b6tcWLF8MfKUCX+1m61EplZ885f+OyEyq+siNFxFuwiCunlWBgvmePtSxDBiswf+klIGlS+Pp48mk7p+H3nb9jwYEFuB122/lY7tS50bxwczNfeeXslZEgyG1JhSIi4mdCfC1AZ8/5hg0bUKhQoXDLt2/fjnLlyuEqB936IQXoci8sdly5MnD+vNVz/ttvCs5FJI7wrOCVK9aF/wa7Xtu3//0XGDHiznzm6dMDb74JdO0KRJgu1Vsx4GbPOKurn79uXfNyNOSo6S1nBXYH7vzMKZaxGJ4s9KQJzEtmKqn5ykVExOviPrecLmYjDx8+fFeAfuTIEaRIkcIdqxDxWixsvGYNcPIkcO6c9Vv3n3849MPqnKpYEZg0ScG5iDwEnks/dAjYsoX/uFp/bHj2z/Xa9Tarr0cXi7698QbQvXucj785dOEQlhxegh1nduBm6E1zuRV2y0xvdjPsprnmfbM89BZuhN4IF5C7VliPSoVsFUyBtycLP4kC6QrEyecSERHxaIDeunVrdO7cGYMHD0ZldhkCWLZsGd544w20bdvWHasQ8UqXLgFPPgnMnx/54yzJMH26z2eJikhcYs82A/GtW61rXrZts/7gxFRwsNUbzj9CkV3zDCJ7zOMgC4wJezv/3YnFhxaboJzXR0KOuOW9OYY8TZI0Zn5y+/JY9sfQrFAzZE+V3S3rEBER8ZkAnYE508Q6dOhgxp5TcHAwXn75ZXzyySfuWIWI12EnVYMGwOrVVv2k4sWBdOmAbNlYl4HTDwI5c3q6lSLiNdXRz561gm9ezpy5c9u+f+oUx4ZZ6ThRBdvMVMub1/pjw57vNGnCX9u3eWEAztd4QJgjzFRK33V2F5YcWmICcl7+vfpvuOfFjxcfZbOWRbks5ZA0OCmC4wcjYfyECA4KjvQ2L2kS3wnEGZSnTpxa48dFRMRvuGUMuo1jzfft22du582bF0n9vNtQY9ADF4scc1w5O7j4e3jWLGtucxGRcDje5b33gEWLYva63Lmts368FCtmXRco4LGA23bx+kUMWzMMm09vNgH45ZuXceXWlbtuu1ZId5U4QWJUeqQSquaoimo5q6HiIxWRLKFvjHcXEZHAFeJrY9BtDMiL80eEiB93gg0ZArz/vjXEk9MDz5kDFC3q6ZaJiFdZvhzo1w9YsODOMhYkY883i7Hxwmrp9m37UrAgUKQI4GX1W67euopvV3+LT5Z9YsZ/xyT1/LEcjzkDcvaWsxdcREREYjFAv379Or7++mssXLgQp0+fRhirZrlYv369O1Yj4lEHDwKNG1u95lSrFvDdd0pjFxEXrBjZv7+VVkPs8X7hBeD114EcOXyuWiSLs41dPxYDFg/AicsnzLJC6Quhc+nOJrU8WXAy0wOePGFy521em/sJkyFJgiSqlC4iIhLXAToLxM2ZMwctW7ZEhQoV9I+x+B0OCeV85hzBwU6uzz8HnnnG6hATEcGmTVZgzqqQxED82WeBvn198ixeaFgoJm2ZhHf/eRcHLhwwy3Kmyon3a7yPZ0o8g/hBvnWiQUREJKAC9JkzZ+Kvv/5ClSpV3PF2Il6FsxbVrWsF57lyAUuXWoXgRCTAca5xVlgfNAj49VdrWVAQ0L69ld7OYm4+hmVp/tj5B/ou7IvtZ7abZZmSZUK/av3wfJnnkShBIk83UURExK+5JUDPli2b5jsXv7R7t/Vbm7/BM2cG5s1TcC4SUC5csM7ORXY5etSan5yYTtOmDfDuu9Y4ch8Lyo9fOo41x9dg4JKBWHt8rVnOaul9qvRB9wrdVchNRETElwL0IUOGoE+fPhgxYgRy+mAqn0hkv8kHDAC+/toqDMcZi+bO9ckOMRGJqWPHAE4ROnmyNQXavSRPbs23yPR2Vlv38rR1pqvvOLPD9I7v+HeHuXBu8pAbIc7ncQx5r4q98Frl18w4cxEREfGxAL1cuXKmUFyePHlMJXfOge7qHCeMFvERly8DFSoAe/ZY9xs2BL74Asif39MtE5FYdfy4FZiPGmWlr9syZbLOzkV2YSV2Ly1GwZ7xefvn4ftN32Pzqc3YfXY3boS6fC4XQfGCkDdNXjxR4Am89dhbyJgsY5y3V0RERNwUoLdt2xbHjh3DRx99hEyZMqlInPi0//3PCs45hdqYMVbnmIj4eRVIBuYjR1rzJ9Jjj1njyCtXtnrJfQinRJu4aSK+Wv2Vcxy56zzkBdMVROEMhVE4/X+XDIWRP21+jS8XERHxlwB9+fLlWLFiBUqWLOmOtxPxmGXLgG++sW5//71VuV1E/NSpU1aBt+HD7wTmDMjffx+oXdtre8ajcvjiYTNX+ej1o3H++nmzjNOddSrZCfXz1TeBOCuxqwK7iIiInwfohQoVwrVr19zxViIew9/nnTtbNZ+ee07BuYhf4hf88GGrwMSwYYD9b1elSlZgzi++DwXmTGNfdmQZvlz1JX7f8TvCHGFmeZ40edCjQg88W+pZpEqcytPNFBERkbgM0D/55BO89tprGDhwIIoXL37XGPSUKVO6YzUisfqbvU8fYNcuq1r74MGebpGIPNQXmuPJ9+61LhyzYt/m5cqVO8999FErMOdcij4UmF+4fgHTdk4zaezrT6x3Lq+duzZ6PtoTDfM3VE+5iIhIoAbo9evXN9e1mRIY4cw+x6OHhoa6YzUisVYU7tln70xjzE41Vm0XER8SEmIVjZg40TrTdq+sLs5VzsCcY8z575cPBObXbl0zPeXz98/H/APzse7EOmdvOceVty/RHq88+gqKZfTuSvIiIiISBwH6woUL3fE2InHu4EGgSRNrnnMmfnD8+ZNPerpVIhJtR44AX31lVV5nkG6LHx/IlQvIl8+agoHX9m0uT5gQ3ux22G0zH7kdkC8/svyuCuws9tapVCe8UOYFpEuazmNtFRERES8L0KtXr+6OtxGJU7dvA82bW8E5Z1H67TegShVPt0pEomXDBmDIEODnn60vMxUqBPTqBdSsaQXhEYZbebsbt29gyvYp+Hnbz1h0cBEu3bwU7vFsKbKhdp7aJo2dl2wps3msrSIiIuLFATotWbIEI0eOxP79+zFlyhRky5YNEydORO7cufEYp6sR8TLsdONv/NSpgdWrgRw5PN0iEbmnsDBg1iwrMF+w4M5yBuSvvWbNicj0dR9zLOQYRqwdgVHrR+H0ldPO5WkSp0HN3DWdAXmBdAU0jamIiIifc0uA/ttvv6F9+/Zo164d1q9fjxs3rDS8ixcvmrnR//rrL3esRsRtDh2yhp/SZ58pOBfx+i/s9OnAiBHA9u13Uthbt7YC8zJl4Gvs6utfr/7aVF9nSjtlTZEVXcp0wRMFnkCpzKVU6E1ERCTAuCVA//DDDzFixAh06NABkydPdi6vUqWKeUzE2wo8d+sGXL0KVK1qTakmIl7WU75unRWU87J5853HUqQAunQBXnnFJ8+ssdjbpC2T8M2ab7Dx5Ebn8qo5qppp0ZoVaobg+L6Vmi8iIiJeFqDv2rUL1apVu2t5qlSpcOHCBXesQsQttm4FvvgC+PNPa3jqyJE+mREr4n9YdZ1p6wzIZ8wATpy48xi/pBwqxaIRnTrxHxd4Y484i7hdv33dBOHXbl9zXtvL5u2fhzEbxuDctXPmNUkSJEG74u3QvUJ3lMxc0tMfQURERPwlQM+cOTP27t2LXCzK42Lp0qXIkyePO1Yh8lBOngTatQs/bPXdd4HChT3ZKpEAduaM1UvOy6pVwPz5VlqLLXlyawo0TrPQsCGQzruqlDPo/nHzj6YnfNe/u8x9BxzRem2u1LnQtVxXdC7TGWmTpI31toqIiEiABegvvPACevbsie+++84UsDl+/DhWrFiB119/Hf3sgb4iHtS9uxWcc9hqs2ZA165WXSkRiQP//msF4mvX3gnKDx+++3nZswONG1tBeY0aQKJE8DYs4jZ8zXB8u+ZbnLl6JtLnBMULMr3jSYKTmGvOU87bOVLlMFOiNcrfSGPLRUREJPYC9LfeegthYWGoXbs2rl69atLdEyVKZAL0Hj16uGMVIg9s9mxrCjUG56zW7oP1pER8D6c++/RTa35yFnmLTMGCQNmy1oVnzEqVAry0Svn2M9sxdMVQTNw80TkfOQPuno/2NOPGkwUncwbiwUHBqrYuIiIiDySegwPn3OTmzZsm1f3y5csoUqQIkjNF0Y+FhISYcfasVp8yZUpPN0ciwQkFihcH9uwBXn0VGDrU0y0SCQDsHeeYkqVL7ywrUMAKxMuVs65Llwa8/O8m/3nkuPHPV36OWXtnOZeXz1oer1V6DS2KtECCILfNVioiIiJeKi7jPrf+skiYMKEJzEW8BadQY3CeOTPw/vuebo1IAPj1V457AlgglBXXWZWxRQuvLOwWlTBHGH7Y/AMGLx+MLae3mGXxEA9PFn4SvSv2RuXsldVDLiIiIt4XoD8XzfmpODZdJK4dOwYMHGjdHjLE6zvrRHzblStWmsqYMdb9ChWASZOAvHnhSzaf2owuM7pg1bFV5j5T158r/ZxJZc+b1rc+i4iIiARYgD5+/HjkzJkTpUuXNqmAIt5k+HDg+nWgcmWgbVtPt0bEj23caH3Jdu60xpC/9ZaVssK5DH3E1VtX8cGiDzBkxRDcDruNFAlT4O3H3sZL5V5CmiRpPN08ERERCRAPNQP0yy+/bPLwDxw4gJo1a2Ls2LGYOnXqXZfY9Mknn5hUw1fZc/Of69evo1u3bkiXLp0ZB9+iRQucOnUq3OsOHz6MRo0aIWnSpMiYMSPeeOMN3GZRI/GbseejR1u3e/Xy2rpTIr6NJ2aZwv7oo1ZwnjUrMG8e8NFHPhWcz9k3B8WHF8egZYNMcP5koSexo9sOvF31bQXnIiIi4jsB+rfffosTJ07gzTffxIwZM5A9e3a0atUKs2fPjpMe9TVr1mDkyJEoUaJEuOW9evUy7ZkyZQoWLVpkpn1r3ry58/HQ0FATnLOo3fLly/H999+bbID+/fvHepslbrBq++nTVrzQtKmnWyPih/gFa9TIOgN286Y1NdqmTUCtWvAVnDKt3e/tUO+Heth/fj8eSfkI/mj9B35v/Tuypczm6eaJiIhIAHqoAJ04nVrbtm0xd+5cbN++HUWLFkXXrl2RK1cuU809tvC927Vrh9GjRyNNmjs9HOzRZ0/+559/jlq1aqFs2bIYN26cCcRXrlxpnjNnzhzT1h9++AGlSpVCgwYNMGDAAHPCgUG7+L5vvrGuX3zRpzryRHznDBinR/j7byBxYp6tBf74A0ifHr6AJ5C/2/AdCn1TCJO2TDLzlnOM+fau29G0kM7oiYiIiA8H6OHeLCjIpJvzxw97qWMTU9jZC16nTp1wy9etW4dbt26FW16oUCHkyJEDK1asMPd5Xbx4cWTKlMn5nHr16pny+du2bYtynTdu3DDPcb2I99mwgfvYCsy7dPF0a0T8yMmTVkX2li2tHvRixZjKBHTt6jPjSHb9uws1v6+JztM74/z18yiVuRRWPb8KX9T/AikSpfB080RERCTAPXSAzqD1p59+wuOPP44CBQpgy5Yt+Oabb8wY79iaB33y5MlYv349Pv7447seO3nypJnuLXXq1OGWMxjnY/ZzXINz+3H7sahwfZz/zr4wpV+8DzvziHEEp1cTkYfEIUvjxwOcRvP334EECYC+fYG1a60g3cvxpPE/B/8x6ewca77o0CIkDU6KwY8PxpoX1qBc1nKebqKIiIjIw1dxZyo7g2UGqpxyjYF6+lhOcTxy5Ah69uxpUuoTM7UyDr399tvo3bu38z570BWke5eDB4Eff7Rud+vm6daI+IFDh6yxIrNnW/fLlgXGjgVKloS3O3X5FL7f9D3GrB+DPef2OJc3zN8Q3zb8FrlS5/Jo+0RERETcGqCPGDHCpI7nyZPHFGPjJTK/s8fFTZjCfvr0aZQpU8a5jOn0ixcvNj33LFDHceQXLlwI14vOKu6Z/+tO5fXq1avDva9d5d1+TlTj7XkR7/XKK9bUatWrA1WqeLo1Ij4sLAwYNsyaMo1znPNv3wcfADxJyR50LxXmCMPcfXMxev1oTNs1zVRlp+QJk+PpYk/j+TLPmx5zDscSERER8TYP9SurQ4cOcf4jp3bt2iaN3tWzzz5rxpn36dPH9GgHBwdj/vz5Zno12rVrl0m5r1SpkrnP64EDB5pAn1OsEXvkU6ZMiSJM4RSfNG0aMGOGFTswrtDvb5EHtGsX0LkzsGyZdb9qVWDMGKBAAXiroyFHMW7DOIzdMBaHLh5yLn8026N4ocwLaF2stQnSRURERPw2QOfUZHEtRYoUKBZhzGOyZMnMnOf28s6dO5tU9LRp05qgu0ePHiYor1ixonm8bt26JhBv3749Pv30UzPuvG/fvqbwnHrIfRMnDOjRw7r9+uvWUFkReYCx5pwC4Y03WGAEYB2RQYOAl15iFVB46/jy9/55Dx8u+dD0nlPqxKnRvkR701teIlP4aThFREREvJn35ik+hKFDh5qK8uxBZxE7Vmgfxi7V/8SPHx8zZ87Eyy+/bAJ3BvgdO3bEB0zfFJ80YADrEwA5cwL9+nm6NSI+epaL0x789JN1v149YORI60vlpULDQvHyny+bdHaqlrOa6S1vUbgFkgQn8XTzRERERGIsnoPdD/JAWCSO1dw59zp76sUzrl5lFX4rvuBUzE01jbFIzOzcaU17sH27NUbks8+Anj29epzI9dvX8fRvT2PqzqlmHvNhDYfhxXIverpZIiIi4odC4jDu88sedAksf/1lBefs6GvSxNOtEfExv/7KQh7WlyhLFuCXX4DHHoM3u3j9IppObmqmS0sYPyEmNZ+EFkWsmiMiIiIivkwBuvi8n3+2rlu18uoOPxHvcusW544Ehgyx7teoAUyebKWjePnUafV/rI+NJzciRcIUmNZmGmrmrunpZomIiIi4hQJ08Wns9PvzT+t269aebo2IjzhxwvrCLFli3X/zTWDgQK+ePo32n9+PuhPrYt/5fciYLCNmtZuF0llKe7pZIiIiIm7j3b/GRO6D06pduwbkzQuUKePp1oj4gMWLreD85ElOiwF8/z3w5JPwduwxr/9DfZy6cgq5U+fGnPZzkC9tPk83S0RERMStvHPeHJEYprcz3lB6u8g9sB4o09lr1bKCc05LuXatTwTniw4uQvXx1U1wzmnTlj23TMG5iIiI+CX1oIvPungR+Ptv67bS20Xu4fx5oFMnYPp06367dtYUasmSwdv9sfMPtPm1DW6E3kDVHFUxve10M8+5iIiIiD9SD7r4rGnTgJs3gcKFgeLFPd0aES+1ahVQurQVnCdMCAwbBkyc6PXB+a3QWxi8fDBa/NLCBOdNCzbF7GdmKzgXERERv6YedPFZEyZY10pvF4kipf3LL60CcKzYzkINU6ZYwboXczgcmL5rOt6c9yZ2n91tlj1X6jmMbDwSCYL0T5aIiIj4N/3aEZ+0dSswfz4QFAR06ODp1oh4YUo75zZnmgk99RQwejSQKhW82foT6/HanNfwz8F/zP0MSTNgQM0B6FK2C+LpLJyIiIgEAAXo4pO++MK6Zn2r3Lk93RoRL7J6NdCqFXDokJXSPnQo8PLLXp1mcizkGN5Z8A4mbJoABxxIFD8RelXshbervo2UiVJ6unkiIiIicUYBuvic06eBH36wbvfq5enWiHhRSvtXXwFvvGGltOfJY6W0e/H8g5dvXsZnyz7DZ8s/w7Xb18yytsXa4uPaHyNn6pyebp6IiIhInFOALj5nxAjgxg2gfHmgcmVPt0bEC+zfD7z+OjB1qnW/RQtg7FivTWkPDQvF95u+R98FfXHi8gmzrEr2KhhSdwgefeRRTzdPRERExGMUoItPYWDOItR277kXZ+2KxK7QUGDWLOsLwfkG2YPOlHbOdd6tm1d+OY5cPIKJmydi3MZx2Htur1mWJ00eDKozCC0Kt9A4cxEREQl4CtDFp3zzDXDqFJAtG9CypadbI+IB//4LfPedlUpy4MCd5fXqAQMHAmXLwptcu3XNzGXOoHze/nlmjDlxurS+Vfuie4XuSJQgkaebKSIiIuIVFKCLz/jsM2vGKHrtNSA42NMtEokj7B1n8bdvvwV++cVKJaE0aYDnngNeegnIlw/eNFXayqMrMX7jeEzeNhkhN0Kcj1XPWR2dSnUyPeYpEqXwaDtFREREvI0CdPGJ2ISB+eDB1n3WwHr1VU+3SiSWnT0LrF8PrFtnFXvjbRt7yZnG3ro1kDQpvCUo339+P6Zsn2IC811ndzkfy5kqJzqW7IiOpTqalHYRERERiZwCdPH64JzBOItT06efWgG6iF85c8YKxO2AnBdOk+YqUSIrIGdgzgqJHhyvff7aeWw5vQVbTm2xrv+7fenmJedzkiRIgpZFWuLZUs+ieq7qCIoX5LH2ioiIiPgKBeji1cH522/fCc7HjAE6d/Z0q0TcICQEmDHDqrq+ahVw9Gjkz2PaOqdJ43QF7doB6dPHaTPDHGGmmNva42ux6eQmZzB+NCTy9gYHBaPiIxVNCjuDc81hLiIiIhIzCtDFa334ITBokHV7+HAF5+LjLl2ygnKOIWf1dXscObE3vEABKxhn+jqvS5cGUqeO0xT1Y5eOYc2xNVhzfA1WH1ttAvOLNy5G+vwcqXKgRKYSKJ6xuHXJVBwF0xVEcHwVhxARERF5UArQxSs7F5nF+8MP1v3PP7dqYIn4nMuXgZkzraD8r7/CB+UFCwKtWgF16ljBeIq4LZh2/fZ1LD60GKuOrjIBOS8nL5+863mJ4idC6SylUTpzaROIMygvlrEYUiX2zjnWRURERHyZAnTxKmvWAG3bAvv2AfHjW2POOd+5iE84fx7YvNm6/POPFZRfv37ncfaSMyh/6imgePE4H0d+8fpF/LnnT0zdORV/7/kbV25dCfd4/HjxUTRjUZTPWh4VslUw1wzG1SsuIiIiEjcUoItXYMfigAHAJ58AoaFAjhzApElAlSqebplIJHiQ7t1rBeKbNlkX3j58+O7n5s9/JygvUSLOg/ITl05g2q5pJihfeGAhboXdcj6WLUU2VMtZzRmMs6c8abB3VIUXERERCUQK0MXjWLC6Y0dg2zbrPmOZESOsKZ5FPF6pkAXceHDysnXrndtXr0b+mpw5gZIlrXHkTZtat+MwKGdht33n9uGPnX+YoJzzkTvgcD5eOH1hPFnoSTQr1AzlspZDPA9WgxcRERGR8BSgi0exZhYDcmYBZ8gADBsGtGzp6VZJwPaKL1li9Ya7BuMsihCZJEmAYsWsAJwX9o7zEkuF3S7fvIyNJzfi9JXT5nLmyhmcuWpdXO//e/Vf3A67He617CFnUM5LwfQFY6V9IiIiIvLwFKCLx4wfDzz/vBUXNWwIfP99nM8iJQJcuwZMmAAMHmylrUfEYggcO160qHVhUM4LU9f5WCw7dfkUvlz1JYatGRZlRfWIEgQlQI1cNUxA3rRgU2RLmS3W2ykiIiIiD08BungEe8pZqZ06dQJGjwYS6GiUuHTunDV/31dfAadPW8s4rqJ6dSsAtwNyBueJEsV585imPnj5YIzbOA43Qq3q71lTZEXOVDmRIVkGZEya0VxnSJoBGZPduW1fJ0oQ920WERERkYejkEjiHLOGX33Vuv3661aldg2DlTjDQm5Dh1pnha78V8WcVQl79wY6dwaSJ/do85jGPmjZIPyy7RcznpwezfYo3nrsLTQp2ARB8YI82j4RERERiT0K0CVOMZ2dMdCtW0DjxgrOJQ5xbPlnnwGTJ1sHInHs+JtvWhXWgz03lZjD4cA/B/8xgfnsfbOdy+vnq4+3qrxlKq2rmJuIiIiI/1OALnHqyy+BVauAlCmt7GLFHBLrVdgXL7bm75s1687y2rWtwPzxxz16EN4MvYlpO6dh8IrBWH1stVnGHvLWRVvjzSpvolTmUh5rm4iIiIjEPQXoEmdYf6tvX+s263FlU90qiS1hYcD06cCgQcDKldayoCCrp/yNN4CyZT3avG2nt2HshrGYuHmiqbpOiRMkxnOlnsNrlV9DnjR5PNo+EREREfEMBegSJ27fBp591iqYXauWVb1dxO1u3gQmTbIC8507rWUs8Pbcc8BrrwF583qsaZduXMLP2342gTnnJrdlSZ4FnUt3RvcK3ZEpeSaPtU9EREREPE8BusQJZhgvXQqkSAGMGaPUdnGzy5etA2vIEODoUWsZx1FwqoCePYFMmTw2tnzF0RUYu36sCc6v3LKK0sWPFx+NCzY2gTnHmXNaNBERERER/SqUWLd6NfDee3emV8ud29MtEr9x7BgwciTw7bfWtGmUOTPQqxfw4otAqlQeadaJSyfw45YfTW/5zn//68kHUCBdAROUdyjZAZmTZ/ZI20RERETEeylAl1jv2Hz6aatodps2QLt2nm6R+MX48nnzgBEjrHHmdkX2fPmswm/t2wOJE8d5s67duobpu6bj+03fm0rs9hRpSYOTolXRViYwr5K9iqqxi4iIiEiUFKBLrBbQfuklYN8+a5ppVW2Xh/Lvv8C4cVaPOQ8qW9WqQI8eQPPmQPz4cZ7CvvzIchOUc97yizcuOh+rnL0yOpXshNbFWiNlopRx2i4RERER8U0K0CXWjBoF/PijFTPxOnVqT7dIfPIsz7JlVm/5lClWETh7fHnHjlYae9Gicd6sgxcOYsKmCeay7/ydkwU5UuVAhxIdTAp7/nT547xdIiIiIuLbFKBLrFi3DnjllTsF4h57zNMtEp/CtHWe1fnsM2Dr1jvLOT3ayy9b4yWSJYvz3vK/9vxl5iz/5+A/zuXJEyZHyyIt0bFkR1TLWc3MYy4iIiIi8iAUoIvbXbgAtGxpdXY2bWrNbiUS7fHlv/0G9O9/Z5q0JEmsQgYcL1GuXNw3yRGGaTun4cMlH2L9ifVmWTzEQ+08tU1Q/mShJ5EsYdyeLBARERER/6QAXdyOPecHD1rV2seP17hziWYq+19/Af36ARs2WMvSprWKvjGN3QPjI0LDQvHr9l9NYL71tNWLnyw4GbqW74oeFXoge6rscd4mEREREfFvCtDFraZNAyZOBIKCNO5coumff4B33gGWL7fup0gB9O5tTZXmgWnSbofdxk9bfsLAJQOx6+wus4xF3hiUv1rxVaRPmj7O2yQiIiIigUEBurjN2bNWZye9/jpQqZKnWyRebdUqoG9fa8o0O5W9e3er1zx93AfBN0NvYuKmifh46cfOwm9pEqcxQfkrj76C1Il1tklEREREYpcCdHEbxlanTgFFigDvv+/p1ohXOnECmDED+PVXYO5ca1lwMNCli9WLniVLnDbn+u3rWHZ4mZm3/OdtP+PwxcNmOXvJX6v0mkln1xRpIiIiIhJXFKCLWzCdffJka0o1jjtPnNjTLRKvGVvOYm9//GGNf2CvuY3jIDhVGgvC5coVR81xYMe/OzBn3xwTlC86uAjXbl9zPp45eWa8UfkNvFj2RRV+ExEREZE4pwBdHtq+fVaBbWKNr/LlPd0i8fgUaStWWAE5L3v2hH+8QgWgWTOgVSsgb95Yb87Zq2cxb/88E5TP2T8HR0OOhns8S/IsqJu3LurlrYdmhZohSXCSWG+TiIiIiEhkFKDLQ+FUapyS+vJloFo1a0ixBGhQvmgR8MsvwO+/A2fO3HksYUKgdm1rzr3GjYGsWWO1KWeunMGSw0uw+NBic9l4ciMccDgfT5wgsZmvvG6euiYwL5axGOJpqgERERER8QIK0OWh/O9/wNq1QJo0wA8/WCnuEkBB+dKlVlDOMeWnT995jOX7GzWygvL69a3K7LHk+KXjJhBnuvriw4ux/cz2u57DIJwBeb189VA1R1X1kouIiIiIV1KALg88tPiDD4AhQ6z7330HZNe00P4vLMyaDs0Oyln0zcZ5y5s3B556CqhZ0yr+Fgtuhd7CjN0z8OfuP7Ho0CJnxXVXRTMUNb3k1XNWR9WcVZE1Rez22ouIiIiIuIMCdHmg4LxPH+Czz6z7H31kDSkWP59Db+hQqwLgsWN3lnOe8iefBFq3ttLYYykopwPnD2DM+jH4buN3OHn5pHN5ULwglMpcCtVyVDNBOQNyzVUuIiIiIr5IAbrE2Ntv3wnOGbO9+qqnWySxGph//jnw1VdWoQFiujrPyDAof/xxa4x5LLF7y0etG2WKvNljyTMly4R2xduhdp7aqJK9ClIlThVrbRARERERiSsK0CVGtmwBPv3Uuj1ypDV9tQRIYF6qlFV0gIXeYnkevYMXDpre8rEbxobrLX88z+NmCrQmBZsgOH7s9daLiIiIiHiCAnSJkTfftFLcW7ZUcO6Xzp27E5hfunQnMH/3XavgWyxWO+cc5X/u+RPfrvkWs/fOdvaWZ0yWEc+Veg4vlH0BedLkibX1i4iIiIh4mgJ0ibZ584BZs4AECYCPP/Z0ayTWA/OSJYH33ouTwHz2vtnot7Af1h5f61xeJ08dZ295wvixl0YvIiIiIuItFKBLtIt3s/ecXn4ZyJfP0y0St7h2DfjiC+uMS8TAvEkTICgoVlfPqdH6LuyLpYeXmvvJgpPh5XIv48VyLyJfWh1kIiIiIhJYFKBLtEyaBGzYAKRMCfTv7+nWiFvOuHCnckz5kSNxHpivOrrK9JjP3T/X3E+cIDG6le+GPlX6IEOyDLG6bhERERERb6UAXe7r9m1rCDK99RaQXjNY+bbFi4HXXgPW/pdOzgns2YPetm2sB+YbT25E/4X9TWV2Cg4KxgtlXsD/qv4P2VJmi9V1i4iIiIh4OwXocl+TJwP791uB+SuveLo18sB277YmsP/jjzvTpXHOPM6TlyRJrK5657878e4/7+KXbb845y7vWLIj+lfvj1ypc8XqukVEREREfIUCdLmn0FBg4EDrdu/eQLJknm6RxNi//wIffAAMH26lQ8SPb5XgZzp7xoyxumrOYz5g8QB8tOQjhDpCzbI2xdrgvervoWD6grG6bhERERERX6MAXe7p99+BnTuB1KmBbt083RqJ8TjzESOsceYXL1rLGjWyJrIvUiTWV7/t9DZ0+KMD1p9Yb+43LtAYH9b6ECUylYj1dYuIiIiI+CIF6HLP+O7DD63bPXtaBeLERxw7Bjz7LDB37p0CcIMHA3XqxPqqQ8NCMXTlUPRd0Bc3Qm8gbZK0GN5oOFoVbRXr6xYRERER8WUK0CVKM2cCmzcDyZNr7LnPFQ3o2hU4fx5InBgYNMhKf2Bqeyzbf34/Ov3RCUsOLzH3G+ZviDGNxyBLiiyxvm4REREREV+nAF0i5XAAAwZYt7t3B9Km9XSL5L7OnbMCcQboVK4cMHEiUKhQrK/a4XBg9PrR6D27N67cuoLkCZNjaL2h6Fy6M+LFixfr6xcRERER8QcK0CVSc+ZYs3CxuHevXp5ujdwXU9k7dQKOH7d6yvv2Bd55BwgOjvVVH790HM9Pfx5/7/3b3K+WsxrGNx2P3Glyx/q6RURERET8iQJ0uWfv+UsvxXqhb3kYV69aU6d98411v0ABq9e8QoU46TX/edvP6PpnV5y/fh6J4ifCR7U/wqsVXzXTqImIiIiISMwoQJe7LFoELFsGJEoEvP66p1sjUVq9GujQAdi1y7rP9HZWaE+aNNanTvt1+6/4fOXnWHt8rVlWJksZTHxyIopkiP3q8CIiIiIi/koButzF7j3v3BnImtXTrZFwrl8Hpk4FRo60zqRQlizAuHFAvXqxuuoL1y9gzPox+GrVVzgScsQsS5wgMfpU6YN3qr6D4Pixn04vIiIiIuLPFKDLXWPPFywAEiSwMqfFS3Ay+tGjge+/B86etZYFBQFt2wJffRWrVfwOnD+AL1d9ibEbxuLyzctmWcZkGdG9fHe8VO4lZEiWIdbWLSIiIiISSBSgi9Pu3UCbNtbtF14AcuTwdIsCHHvLf/sNGDUKWLz4zvJHHgGefx547jkge/ZYW/2KIytMGvvvO35HmCPMLCuaoSh6V+qNp4s/bXrPRURERETEfRSgi8FO2UaNrKmzK1YEhgzxdIsC2I4dd3rLOXWa3Vv+xBNAly5A/fqxMqf57bDb2HBiAxYdWoTfdvyGlUdXOh+rm7cuelfsba41bZqIiIiISOxQgC64eRNo3hzYuxfImRP44w9rejWJ497yX3+1esuXLLmznGkM7C1/9lmr59yNbty+YYq8MSBffGgxlh1Z5kxhp4TxE+KZ4s+gV6VeKJaxmFvXLSIiIiIid1OALujd28qgTpECmDkTyJTJ0y0KsN5yBuXsLWf6ArF3nOkML75oFX5zU2/5lZtXsPrYahOMMyhfcXQFrt++Hu45qROnRtUcVVE9Z3W0K9EOmZNndsu6RURERETk/hSgBzhOmf3tt9btSZOAYuoo9XxvOceWZ8v20HOU7zm3x6Sp25fNpzYj1BEa7nkZkmZAtZzVTEDO6+KZimsOcxERERERD1GAHsA2bLCGNFP//tYQZ4klFy8CCxcCs2cDP/8cvrecG5695XXrPnBv+cXrF03vuAnGj1kB+blr/41fd5EtRTZUz1Ud1XJUMwF5ofSFNKZcRERERMRLKEAPUBcuAC1aWJ25DRsC777r6Rb5mdu3gTVrrHnr5s4FVq4EQkPd3lu+9fRW9JrdC/P3z4cDjnCPJYqfCOWylkPFRyo6L4+kdO84dhERERERcR8F6AHI4bB6zg8cAHLnBn74wSoSLg/p4EFg1iwrIJ8/3+o1d5U/v9VLzh7zxx9/qLHl7DF/75/38PXqr51p63nS5LEC8WwVUSl7JZTIVMIUehMREREREd+gAD0AjRkDTJkCJEgATJ4MpEnj6Rb5QW/5O+8An34afjk3bO3aVlDOgDxXrodeFceWT9w8EW/OfROnrpwyy5oXbo7PHv/MBOgiIiIiIuK7FKAHmG3bgJ49rdsDBwIVKni6RT7uzBmgbVurx5yqVrUCcl7KlnXrfOUbT25E97+6m+nQqEC6Avi6wddmbnIREREREfF9CtADDKfTvnbNih9ff93TrfFxa9daE8gfOQIkSwZ89x3QqpXbV3P+2nn0W9gPw9cOR5gjDMmCk6FftX5mfnKlsIuIiIiI+A8F6AFk716rbhlT28eP17jzh8JgvGtX4MYNa2z51KlA0aJuXQWD8XEbxuGt+W/h36v/mmWti7bG4LqDVexNRERERMQPKUAPIDNmWNfVqgFZsni6NT6KAfkrr1hzmFOTJsCECUCqVG5dzYlLJ/DUlKec6exFMhQx6ey1ctdy63pERERERMR7KEAPwAC9cWNPt8RHMZW9ZUtg9WqAc4cPGAC8/bbbUxE2ndyExj81xpGQI0iRMAXeq/EeelTogeD4wW5dj4iIiIiIeBcF6AHi/Hlg8WLrtgL0B7BwIdC6tVUUjtXZJ00C6td3+2pm7p6Jtr+1xeWbl1EwXUHMfHom8qXN5/b1iIiIiIiI99Eo5ADB6blDQ4EiRYC8eT3dGh+bNP6LL6xp0hiclyplFYdzc3DO6dOGrhiKJj81McF57dy1saLzCgXnIiIiIiIBxCcD9I8//hjly5dHihQpkDFjRjRr1gy7du0K95zr16+jW7duSJcuHZInT44WLVrg1Clr3mjb4cOH0ahRIyRNmtS8zxtvvIHbnNPaj9PbOWRaoonHQrduQK9e1tmN9u2BZcuAPO6db/xW6C28NPMl9J7TGw440KVMF/zd7m+kSaIJ6kVEREREAolPBuiLFi0ywffKlSsxd+5c3Lp1C3Xr1sWVK1ecz+nVqxdmzJiBKVOmmOcfP34czTkl1n9CQ0NNcH7z5k0sX74c33//PcaPH4/+/fvD39y6Bfz1l3Vb6e3RFBJibazhw63x5kOGAN9/DyRN6tbVXLh+AQ0nNcSo9aMQD/Hwed3PMeKJERpvLiIiIiISgOI5mFvr486cOWN6wBmIV6tWDRcvXkSGDBkwadIktGRRLwA7d+5E4cKFsWLFClSsWBF///03nnjiCRO4Z8qUyTxnxIgR6NOnj3m/hAnvP790SEgIUqVKZdaXMmVKePPw6Vq1gAwZgBMngPjxPd0iHygG16gRsGULkCSJNd68WTO3r2bfuX144qcnsPPfnWZu859a/ITGBXUGRURERETEm8Rl3OeTPegRcUNR2rRpzfW6detMr3qdOnWczylUqBBy5MhhAnTidfHixZ3BOdWrV89s/G3btkW6nhs3bpjHXS++lN7OmFPB+X2sWwc8+qgVnGfObFXWi4XgfMmhJXh0zKMmOOec5sueW6bgXEREREQkwPl8gB4WFoZXX30VVapUQbFixcyykydPmh7w1KlTh3sug3E+Zj/HNTi3H7cfi2rsO8+c2Jfs2bPD2/EcAjOzqWlTT7fGy02fbk0SzzQDHksrVwLlyrl1FUxYGb9xPGpPqI2z186ifNbyWP38apTMXNKt6xEREREREd/j8wE6x6Jv3boVkydPjvV1vf3226a33r4cYSq0l/v6a+DcOaBAAeCJJzzdGi/FUR5ffmn1lF+9CtStCyxdCuTM6bZVXLx+EV+v+hpFhxXFs9Oexa2wW2hZpCX+6fQPsqTI4rb1iIiIiIiI7/LpedC7d++OmTNnYvHixXjkkUecyzNnzmyKv124cCFcLzqruPMx+zmrV68O9352lXf7ORElSpTIXHwFM/8HD7Zuv/cekMCn93YsVmpnlfZvvrHud+li3Q52T5G2TSc3YdiaYfhxy4+4cssqYsjx5m9WeRN9q/VFUDyfP0cmIiIiIiJu4pMhG9OEe/TogalTp+Kff/5B7ty5wz1etmxZBAcHY/78+WZ6NeI0bJxWrVKlSuY+rwcOHIjTp0+bAnPEivAc9F+Ek4X7gaFDgQsXrLnPW7XydGu80KFDwMsvA3//bd3/7DPgtdesqu0P4cbtG/htx28mMF92ZJlzeZEMRdC1XFe0L9keKRN5b1FBERERERHxjAS+mtbOCu3Tpk0zc6HbY8Y5LjxJkiTmunPnzujdu7cpHMegmwE9g3JWcCdOy8ZAvH379vj000/Ne/Tt29e8ty/1kkeFae0M0O3ecxWHc3H0KDBwIDB2rDUHXeLEwA8/AP+dzHlQBy8cxMi1IzF2w1icuXrGLEsQlADNCzdHt/LdUDVHVcR7yOBfRERERET8l08G6MM5NzWAGjVqhFs+btw4dOrUydweOnQogoKCTA86q6+zQvuwYcOcz40fP75Jj3/55ZdN4J4sWTJ07NgRH3zwAfzB559bBeJKlHjouNN/sPjbxx8DI0cCN29ay1jp/9NPgdKlHyowf3/R+5iwaQLCHGFmGSuzv1j2RXQu3VljzEVEREREJHDmQfcUb50H/d9/AWb9X74MTJ0aK7OE+ZbTp4FBgwCeoLl+3VrGau08GVO9+gO/7fFLxzFw8UCMXj/aFH2jOnnqmN7yJwo8YXrPRURERETEt4XEYdynCMIPsTAcg3N2Cgf01Gpnz1obg6Xsr1gF2sAaBAMGALVqPfBY87NXz2LQskH4evXXuH7bCvgfz/M4Pqz1ISpkq+DOTyAiIiIiIgFEAbqfYSF6xqPEDuKAHPJ8/Djw1VdWj/mlS9YyzmfOwLxevQfeKCE3QvD5is/N5dJN630rZ6+MgbUGokau8MMtREREREREYkoBup/hcGpO5V2hAtCoEQLLli3AkCHApElW8TcqWdI6U9G48QMH5ldvXcW3q7/FJ8s+wblr58yyUplLmcC8Qb4GKvwmIiIiIiJuoQDdz2qg2XXwAqb3nCUUFiywpkibPfvO8qpVrSnTGJgHxXyucZZm2HhyI6Zsn4JxG8fh5GVrpoBC6QvhgxofoEWRFprDXERERERE3EoBup+4fRvo2NGqgVa5MqeRg39jD/kvv1hjzDdutJYxEGfJegbmjz76UEE5L3vP7XU+lit1LrxX/T20K9FOxd9ERERERCRWKNLwE2+8AcydCyRNymno/Lj3nMXeRo2yJnk/csRaxg/93HNAr15AnjwxDso3ndqEX7b9cldQnjhBYjTM3xCtirTCk4WfRML4Cd39aURERERERJwUoPuB774DvvjCuj1hgjX3ud/hpO7ffGNN8M7q7JQpE9CjB/DSS0C6dDF6u62nt+KnLT/hl+2/RBmUNyrQCMkTJnf3JxEREREREYmUAnQft2SJFZ/Se+9ZGd5+5dw54MsvrarsFy5Yy/LmBd56C3jmGSBx4mi/1bGQY/hp60/4YfMPptc8YlD+VJGnzPzlCspFRERERMQTFKD7sJ07rXnOORybgXm/fvAfp09bveXffmtN6k6FCwPvvAO0bg0kiN6he+nGJfy+43f8sOUHzN8/Hw44zPLgoGATlLcp1gaN8jdCikQpYvPTiIiIiIiI3JcCdB+e77xBA+D8eaBiRWDixAcqVu6dc5iz8NuIEcC1a3emSuvbF2jePFof8lboLczZN8cE5dN2TsO12/+9D4DHcjyGZ4o/g6eKPoW0SdLG5icRERERERGJEQXoPog95k2aAAcPWtne06cDSZLAt128CAwcaKWy37hhLStf3koLeOKJaFW943zlny37DN+u+X979wEeRbW/cfxNJQRDk94FpDdB6UWlWVAQlShcLgIKCChKFUWaUuTSRPEPKCigUhWkCShFUFAsqHjpSFW6IJ2EZP7POXMTCSZIyG6yG76f59mbndnZ2bN4buCdc+Z3xuvouaPx+0vcXEKtK7RWy/ItVTRb8orIAQAAAEBqIaD7oalTpQ0bpGzZpE8/lXLmlH+vDzd5shvEj/4vVNeu7W43bHhNwdxUYjf3lvf5vI8OnDpg9+UMz6nHyz2u1hVbq0reKgpIt2XtAQAAAKQXBHQ/YwaXX3nFfW5mfd96q/yXWReue3fpl1/c7VKlpFGj3Ln71xiov/3tW3Vb2k3rD6y324WzFNbwBsP1cOmHFRIU4s3WAwAAAIBHEdD9jBls3rdPyptXevpp+adt26SePaVFi9xtMxVg0CC3HH3ItYXq30//rr4r+mraT9PsdqaQTOpbu6+61+iujCH+Pt8fAAAAwI2IgO5HTM00c5u2YYqZ+91956ai3eDB7nrmZmq7qcTepYvUv7+U/doKtl24dEGj14/W0LVDdTb6rN3374r/1rD6w5QvIp+XvwAAAAAAeA8B3Y9MnOgWOS9YUHrySfkPx5EmTZJefNFd19wwhd9MtfaSJa/xFI4+2vKRen3WS3tO7rH7qheortfveV1V81f1ZusBAAAAIFUQ0P3I2LHuT1M/LUMG+c96cO3aSUuWuNvlyrnrm5sCcNfoUuwlPTL7EX2y7RO7nT8iv15r8Jqtyk7xNwAAAADpBQHdTxw5Iu3d69ZOe+wx+YfFi6W2bd3q7OaKwvDhUteu7tT2ZOi/qr8N5xmCMqhPrT7qXau3MoVm8lqzAQAAACAtEND9xMaN7k9TtT0iQr5/s3yvXtL48e52+fLShx+6o+fJtHj7Yg37cph9PrXZVEWWi/R0awEAAADAJwSmdQOQvIB+223ybT/+KFWp8lc4f/55d9H26wjne0/uVet5re3zLnd0IZwDAAAASNcI6H7C5F6jUiX5pthYt+hb1arSli1SnjzSsmXu/eZhYck+XVRMlCLnRurEhRO6I98dGtVolFeaDQAAAAC+ginufsKnR9B/+01q00ZascLdbtpUeucdKUeO6z5lr+W99M1v3yhbWDbNfnS2MgT7S1U8AAAAALg+BHQ/cOaMtGOHjwZ0c+WgQQN3+bTwcLfUvFkDLgXV1ef8d47GbRhnn097aJqKZC3iwQYDAAAAgG8ioPuBn35ylxLPl0/KlUu+48QJ6eGH3XBeubJbCO4a1zVPyvbj29V+QXv7vHfN3mpSoomHGgsAAAAAvo2A7kfT233q/nNzxeCJJ6Tdu6UiRaTPP5eyZUvRKc9Hn9ejcx7V6ajTqlOojobUH+Kx5gIAAACAr6NInB8ViPOp6e2mINyCBVJoqDR3borDufHMp8/o58M/K1emXJr5yEwFB3L9CAAAAMCNg4DuB3yuQNzatVLfvu7z1193l1VLoak/TtXkjZMVoAB92PxD5YvIl/J2AgAAAIAfIaD7uOho6ZdffCigHzkiPfaYFBMjtWwpdeyY4lNuOrxJTy9+2j4fdOcg1S9a3wMNBQAAAAD/QkD3cZs3S1FRUubM0i23pHFj4kL5779LpUtLEyemqFq7cfriaXvf+flL59WoWCO9VPcljzUXAAAAAPwJAd2PCsSlMAun3KBB7lrnZjk1c9/5TTel6HQnL5xU20/aatvxbcofkV/vP/S+AgPokgAAAABuTFTh8nE+c//5smXSq6+6zydNksqUue5T7Tm5R2O/HmvvOT8TdcYWg5v96GzlzJTTc+0FAAAAAD9DQPdxGzb4QEDfv19q1cpdWs3cc26eX4cNv23QqPWjNHfzXMU6sXZfuVzlNKz+MNUsWNPDjQYAAAAA/0JA92GmHts337jP69dPwyp1kZHS8eNS5crS2LHJersJ4gu3LbTBfO2+tfH7GxZtqB41etj7zgPSfO4+AAAAAKQ9AroPW7LEHbQ2o+cFCqRRI/r0kdavl7JkkebMkcLCrult56LPadpP0zR6/Wjt+GOH3RcSGKKW5Vuqe43uqpC7gpcbDgAAAAD+hYDuwxYtcn82aZJGDfjgA2nMGPf51KlS0aLXFMzHbxivEetG6Ni5Y3Zf1rCs6lSlk56p9gzrmwMAAABAEgjoPuriRbcum/HAA6n84YcPS889J82c6W736iU1bXrVt1y8dFFv//C2hqwdokNnDtl9t2S9Rc9Vf07tbmunm0JTVvEdAAAAANI7ArqP+uIL6cwZKU8eqUqVVPrQ2FhpyhQ3kJ88KQUGukF96NAk3xIdE62pP03V4C8Ga/+p/XZfkaxFNLDeQLWq0MpWaAcAAAAA/DPSk49auPCv6e0mJ3vd1q1uhfY1a9xtUxDOLKeWxNWBmNgYzfxlpgZ+MVA7/9hp95np6y/XfdmOmIcGhaZCowEAAAAg/SCg+yBTGC4uoHt9eruZSz9smPuIipLCw931zp95RgoOTrQq+7wt89R/dX9tPrrZ7ssZnlMv1nlRHat0VMaQjF5uMAAAAACkTwR0H/TLL9LevW7B9AYNvDyP3oyab9vmbt9/vzR+vFS4cKKH7zi+Q4999Jh+OPhDfPG33jV72+Jv3GMOAAAAAClDQPdBcaPnZu1zM6DtcZcuSV27ShMnutu5c0vjxkmPPiolsSb5xoMbdc8H9+jI2SM2jD9f/Xm7XJoJ6QAAAACAlCOg+yCvT28fMeKvcG5G0IcPl7ImHbTX7l2rJjOa6NTFU6qUp5KWtFyivBF5vdQ4AAAAALgxEdB9zJEj0jffeHH9882bpUGD3OemYnvbtlc9fNH2RXp0zqO6cOmC6hSqo4WPL1SWsCxeaBgAAAAA3NhSoz44kmHxYrdInCminj+/h08eEyO1a+cWgzP3mz/xxFUPf//n99VsZjMbzpuUaKJl/1pGOAcAAAAALyGg30jT28eOdYfnM2eWJkxI8n5zY9w349R6XmvFODH6V4V/6eMWH1OhHQAAAAC8iIDuQy5ckJYv91JA37FD6tfPfT5qlFSgQKKHOY6jAasGqNvSbna7W7VumtpsqkKCQjzcIAAAAADA5bgH3YesXi2dPSvly+dOcfeY2FipfXv3CoBZt808T+wwJ1bdPu2mN799024PvnOw+tXtp4CrjLQDAAAAADyDgO6D09tNcTiPZuK33pLWrpUyZZLefjvRk0fHRKvN/Daa8csMBShAb9z7hrpU7eLBRgAAAAAAroaA7iNMYTiv3H++e7f0wgvu89dek4oU+dsh56LP2UrtS3YsUXBgsKY1m6bHyz/uwUYAAAAAAP4JAd1H/PyztH+/FBYm3X23B1P/U0+58+br1pWefvpvh0TFROmhWQ9p+a7lyhicUR+1+Ej33nqvhxoAAAAAALhWBHQfsWiR+9PcIh4e7qGTvvOOtGKFlDGjNHmyFJiwJmBMbIyt1G7CeXhIuF1GrXah2h76cAAAAABAclDF3Ud4fHq7GY7v0cN9/uqrUvHif6vW3mVJF83+72yFBIZoXuQ8wjkAAAAApCECug84fFjasOGvAnEemdreqZN0+rRUrZrUzV0y7XL9VvbTxO8n2oJw7zd/X42KNfLABwMAAAAArhcB3QcsXuxm6ipV3CXWUmz6dGnJEik0VJoyRQoKSvDy6PWjNfTLofb5hCYT1KJsCw98KAAAAAAgJQjo6W16+8GDf42YDxwolSmT4OV3N76rHsvdqe9D7x6qDlU6eOBDAQAAAAApRUBPYxcuSMuXeyigHz0qPfigdPKkVLmy1LNngpfnb52vJxc+aZ/3qNFDL9T+3/JrAAAAAIA0RxX3NLZqlXTunJQ/v3TbbSk40Z49UuPG0vbt0s03S9OmSSEhf33O7lWKnBupWCdWbSu11X8a/kcBAQEe+Q4AAAAAgJRjBN1Hpreb4nDXnZc3bZJq1XLDeaFC0pdfSmXLxr/83e/f6cGZD9o1z5uVaqZJD0winAMAAACAjyGgpyFTGC5u/fPrnt5uwnjdutLvv7uhfN06qVSp+Je3Htuqez+4V2eizujuW+7WjIdnKDiQiRMAAAAA4GsI6GkYzt9+212uPGNG6e67r+MkCxZIDRu695zXrCmtWePOlf+f3Sd2q+H0hjp27phuz3e75kfOV1hwmEe/BwAAAADAMwjoaeDPP6VWraSOHd3tNm3ckJ4s774rNW/uVpkz8+M/+0zKnt2+ZO4zn/jdRFWcUFEHTh1QqRyl9GmrTxWRIcLzXwYAAAAA4BEE9FS2dKlUqZI0Y4a7PPmQIdKbbyZz6P2116R27aSYGDfdf/yxFB5uX971xy7Vn1ZfnRZ30umo06pRoIY+a/2ZcoTn8Np3AgAAAACkHDcjp5JDh6TnnpNmzXK3ixRxQ3r16sk4SWysu3TamDHudu/e0vDhtrpcTGyMxn0zTi+tfEnnL51XeEi4Xee8a9WuCgoM8sp3AgAAAAB4DgE9FezYIdWrJx08KAUGukF90CDpppuScRLz5m7dpDlz3O1Ro6Tu3e3TLUe3qN2Cdvr6wNd22xSDe/uBt1U0W1FvfB0AAAAAgBcQ0L1s9263AJzJ16VLS++/L1WunIwTnDkjjRzpPs6elYKDpSlTpNatFR0Trf+s+48GfTHILqEWERqhUY1G6cnKT7KMGgAAAAD4GQK6F+3bJ911l3TggLvy2erVUq5c1/jmS5ekyZOlAQOkw4fdfdWqSaNH24rtPx76UW0/aWt/Gvffer8mNJmgApkLeO8LAQAAAAC8hoDuJX/8ITVqJO3dK916q7Ry5TWGc1MEbuFCqU8faetWd1+xYtKwYbrY7AGt2LNSH33SXtN+nqZLsZeUPWN2jbtnnFqWb8moOQAAAAD4MQK6F1y86K6Atm2bVLCgtGKFlDfvNbxxwwapVy93PXPj5pt15uU++vTOAvp458daPLK9rcwe59Eyj+qNe99Q7ptye+/LAAAAAABSBQHdw8wA+FNPSV98IUVESIsXuyH9qvbscUfMZ8+2m8eyZdDCzvU1r2Sslu99WRfnX4w/NF9EPjUr2UwtyrZQvSL1vPxtAAAAAACphYDuYeYW8enT3TXO586Vype/ysHnzrlrmo8YoeioC5p+m/R+ozxaE35UMc4S6Vf3sOLZi6t5qeZ6qPRDqpq/qgIDWL4eAAAAANIbAroHHT8uDR7sPh83zr0HPclhdpPee/RQ7IH9mlNGevn+jNoRft6smC45UqU8lfRQqYfUvHRzlc1ZlvvLAQAAACCdI6B70PDh0qlTUqVKUqdOSRy0aZP07LNyVq/WsuLSi11CtDFHtKTzyhGeQz1q9FBk2Ujdku2WVG49AAAAACAtEdA95LffpDffdJ8PGSIFBiZS1t0smfbWW1qXP1Z92wVoTSFHUrRdv7xnzZ56vvrzisgQkRbNBwAAAACkMQK6h5ip7RcuSLVrS/fee9kLMTHSO+9IL72kTUHH9VKktLCkecFRhqAM6lq1q16o/YIdPQcAAAAA3LgI6B6wa5c0ebL7fNgwKf52cbPe2n336deNKzXgTumDCpITIAUFBKltpbbqX6+/Cmb5pxLvAAAAAIAbAQHdA0zVdjNQfs897gh6fCG4zp21cvdKNeksnQ/5a+3yV+56RSVz2GF0AAAAAAAsAroHrFnj/nz88ct2vv66vvpsih5s7YbzOoXqaEzjMaqSr0paNRMAAAAA4MMI6B6wcaP78847/7dj2TJ9N7K77mstnQ2VGhVrpAWPLVCG4Axp2UwAAAAAgA+7stY4rkNsrFS0qFSokKRt2/Rzl0fU6F+OToVJ9QrX07zIeYRzAAAAAMBVEdA95K67JJ04oa3/ukcNmp/RiYxS9XzVtPDxhQoPCU/r5gEAAAAAfBwB3UPurntJu9o8qPp19+hoJum2HOX1aeulrGsOAAAAALgmBHQPuW1dR9Uv9qV+zyyViyiu5W1XKmtY1rRuFgAAAADAT9zwAX38+PEqUqSIwsLCVK1aNW3YsCHZ5+hQ+A09GDpFe7NKJULz6rMOa5UjPIdX2gsAAAAASJ9u6IA+a9Ysde/eXQMGDNAPP/ygihUrqnHjxjpy5EiyzrO6UT/tvFm6xcmqFV02KM9NebzWZgAAAABA+nRDB/TRo0frqaeeUtu2bVWmTBlNmDBB4eHhmjJlSrLOs/1mKX90Rq145jsVyFzAa+0FAAAAAKRfN2xAj4qK0vfff68GDRrE7wsMDLTb69evT9a5cl4M0sqO63TLzcW80FIAAAAAwI0gWDeoY8eOKSYmRrlz506w32xv3bo10fdcvHjRPuL8+eef9ueMe6YpT5aiOnXqlJdbDQAAAABITXE5z3Ecr3/WDRvQr8ewYcM0aNCgv+1v0LhVmrQHAAAAAJA6jh8/rixZsnj1M27YgJ4jRw4FBQXp8OHDCfab7Tx5Ei/y1rdvX1tULs7JkydVuHBh7du3z+v/oQBvXxUsWLCg9u/fr8yZM6d1c4DrQj9GekFfRnpBX0Z68eeff6pQoULKnj271z/rhg3ooaGhqlKlilasWKFmzZrZfbGxsXa7a9euib4nQ4YM9nElE875pYP0wPRj+jL8Hf0Y6QV9GekFfRnpRWCg90u43bAB3TCj4W3atNHtt9+uqlWrauzYsTp79qyt6g4AAAAAQGq6oQN6ZGSkjh49qv79++vQoUOqVKmSli5d+rfCcQAAAAAAeNsNHdANM509qSnt/8RMdx8wYECi094Bf0JfRnpAP0Z6QV9GekFfRnqRIRX7coCTGrXiAQAAAADAVXn/LncAAAAAAPCPCOgAAAAAAPgAAjoAAAAAAD6AgP4Pxo8fryJFiigsLEzVqlXThg0brnr8nDlzVKpUKXt8+fLltWTJklRrK+CJfvz222+rTp06ypYtm300aNDgH/s94Ku/k+PMnDlTAQEBatasmdfbCHijL588eVJdunRR3rx5bZGiEiVK8G8M+GVfNssalyxZUhkzZlTBggX1/PPP68KFC6nWXuBKa9as0QMPPKB8+fLZfyvMnz9f/2T16tWqXLmy/X1cvHhxvffee/IUAvpVzJo1y66Vbir2/fDDD6pYsaIaN26sI0eOJHr8unXr9Pjjj6t9+/bauHGj/Yegefzyyy+p3nbgevux+YVj+vGqVau0fv16+5dno0aN9Ntvv6V624GU9OU4e/bsUc+ePe2FJ8Af+3JUVJQaNmxo+/LcuXO1bds2ezE1f/78qd52ICV9+cMPP9QLL7xgj9+yZYsmT55sz/Hiiy+metuBOGfPnrV911xsuha7d+/W/fffr7vuuks//vijnnvuOT355JNatmyZPMJUcUfiqlat6nTp0iV+OyYmxsmXL58zbNiwRI9v0aKFc//99yfYV61aNadjx45ebyvgqX58pUuXLjkRERHO1KlTvdhKwDt92fTfmjVrOu+8847Tpk0bp2nTpqnUWsBzffn//u//nKJFizpRUVGp2ErA833ZHHv33Xcn2Ne9e3enVq1aXm8rcC1MPJ43b95Vj+ndu7dTtmzZBPsiIyOdxo0bO57ACHoSzNXq77//3k7vjRMYGGi3zahiYsz+y483zFXEpI4HfLEfX+ncuXOKjo5W9uzZvdhSwDt9efDgwcqVK5ed2QT4a19esGCBatSoYae4586dW+XKldPQoUMVExOTii0HUt6Xa9asad8TNw3+119/tbdq3HfffanWbiClvJ35gj1ylnTo2LFj9i8+8xfh5cz21q1bE33PoUOHEj3e7Af8pR9fqU+fPvaenCt/EQG+3pe//PJLO33STD8D/LkvmxCzcuVKtWrVyoaZnTt3qnPnzvbiqZkqDPhLX27ZsqV9X+3atc0sXl26dEmdOnViijv8yqEkMt+pU6d0/vx5W18hJRhBB5Ck4cOH2+Ja8+bNs8VfAH9x+vRptW7d2t6nmyNHjrRuDpAisbGxdibIpEmTVKVKFUVGRuqll17ShAkT0rppQLKYOjdm9sdbb71l71n/+OOPtXjxYr3yyitp3TTAZzCCngTzD7qgoCAdPnw4wX6znSdPnkTfY/Yn53jAF/txnJEjR9qA/vnnn6tChQpebing2b68a9cuW1DLVGW9POQYwcHBtshWsWLFUqHlQMp/L5vK7SEhIfZ9cUqXLm1Hccw049DQUK+3G/BEX3755ZftxVNTUMswKx6ZAl0dOnSwF53MFHnA1yWV+TJnzpzi0XOD/xckwfxlZ65Sr1ixIsE/7sy2uQ8sMWb/5ccbn332WZLHA77Yj40RI0bYq9lLly7V7bffnkqtBTzXl81yl5s2bbLT2+MeDz74YHzFVbM6AeAvv5dr1aplp7XHXWQytm/fboM74Rz+1JdNXZsrQ3jchSe3Phfg+7ye+TxSai6dmjlzppMhQwbnvffeczZv3ux06NDByZo1q3Po0CH7euvWrZ0XXngh/vivvvrKCQ4OdkaOHOls2bLFGTBggBMSEuJs2rQpDb8FbnTJ7cfDhw93QkNDnblz5zoHDx6Mf5w+fToNvwWQ/L58Jaq4w1/78r59++xqGl27dnW2bdvmLFq0yMmVK5fz6quvpuG3AJLfl82/jU1fnjFjhvPrr786y5cvd4oVK2ZXQgLSyunTp52NGzfah4nHo0ePts/37t1rXzd92PTlOKbvhoeHO7169bKZb/z48U5QUJCzdOlSj7SHgP4P3njjDadQoUI2sJilJL7++uv41+rVq2f/wXe52bNnOyVKlLDHm/L7ixcvToNWA9ffjwsXLmx/OV35MH+pAv72O/lyBHT4c19et26dXbrVhCGz5NqQIUPsMoKAP/Xl6OhoZ+DAgTaUh4WFOQULFnQ6d+7snDhxIo1aDzjOqlWrEv23b1zfNT9NX77yPZUqVbL93vxOfvfddz3WngDzP54ZiwcAAAAAANeLe9ABAAAAAPABBHQAAAAAAHwAAR0AAAAAAB9AQAcAAAAAwAcQ0AEAAAAA8AEEdAAAAAAAfAABHQAAAAAAH0BABwAAAADABxDQAQCAVq9erYCAAJ08edJuv/fee8qaNatXP/OJJ55Qs2bNkv2+IkWKaOzYsV5pEwAAaYmADgCAh0OnCbrDhw9PsH/+/Pl2v7+IjIzU9u3b07QNSV0k+Pbbb9WhQ4c0aRMAAN5EQAcAwMPCwsL02muv6cSJEx49b1RUlFJLxowZlStXLvminDlzKjw8PK2bAQCAxxHQAQDwsAYNGihPnjwaNmzYVY/76KOPVLZsWWXIkMFO2x41alSC182+V155Rf/+97+VOXNmO2ocN6q8aNEilSxZ0gbVRx55ROfOndPUqVPte7Jly6Znn31WMTEx8eeaPn26br/9dkVERNi2tWzZUkeOHLnm0WtzXjMD4MpHnP3796tFixb2PdmzZ1fTpk21Z8+e+NdNW7p3725fv/nmm9W7d285jnPVKfdt27bVn3/+Gf9ZAwcOTHSKu3lt4sSJatKkif3zKF26tNavX6+dO3fqzjvvVKZMmVSzZk3t2rUrwWd88sknqly5sr2gUrRoUQ0aNEiXLl266n8zAAC8iYAOAICHBQUFaejQoXrjjTd04MCBRI/5/vvvbaB97LHHtGnTJhs+X375ZRuMLzdy5EhVrFhRGzdutK8bJoyPGzdOM2fO1NKlS22Yfeihh7RkyRL7MGHcBNa5c+fGnyc6OtqG/Z9++slOtzfh2UzHv1ZmWvnBgwftw3yn6tWrq06dOvHnbty4sQ3/a9eu1VdffaWbbrpJ99xzT/yov7n4YL7blClT9OWXX+qPP/7QvHnzkvw8E6hNCDcXJuI+t2fPnkkeH3ch48cff1SpUqXsBYiOHTuqb9+++u677+zFgK5du8Yfb9ppju/WrZs2b95s/7xM+4YMGXLNfyYAAHicAwAAPKZNmzZO06ZN7fPq1as77dq1s8/nzZtnhovjj2vZsqXTsGHDBO/t1auXU6ZMmfjtwoULO82aNUtwzLvvvmvPs3Pnzvh9HTt2dMLDw53Tp0/H72vcuLHdn5Rvv/3WnifuPatWrbLbJ06ciP+cLFmyJPreZ5991rbtyJEjdnv69OlOyZIlndjY2PhjLl686GTMmNFZtmyZ3c6bN68zYsSI+Nejo6OdAgUKxP9ZJSapNpjPHjNmTPy2aXe/fv3it9evX2/3TZ48OX7fjBkznLCwsPjt+vXrO0OHDk1wXvM9TDsBAEgrjKADAOAl5j50M+18y5Ytf3vN7KtVq1aCfWZ7x44dCaamm2npVzLTuIsVKxa/nTt3bjvt24xaX77v8insZsT+gQceUKFChexId7169ez+ffv2Jes7TZo0SZMnT9aCBQvsveCGGZU308nNeU0bzMNMc79w4YKdVm6mqZsR8GrVqsWfJzg4ONHvdr0qVKiQ4Lsb5cuXT7DPtOfUqVPxbR48eHB8e83jqaeesu00MxQAAEgLwWnyqQAA3ADq1q1rp36badbJmU5+OXP/9JVCQkISbJt7sBPbFxsba5+fPXvWtsM8PvjgAxusTTA328kpPLdq1So988wzmjFjRoJAfObMGVWpUsWe+0pxId7bLv/+cffGJ7Yv7s/EtNncc968efO/ncvckw4AQFogoAMA4EVmubVKlSrZgm6XM4XMzL3alzPbJUqUsPewe9LWrVt1/Phx25aCBQvafea+7OQwI+SmGN2LL774t1BrCq3NmjXLVn0394wnJm/evPrmm2/sRQvDFGMzo/rmvUkJDQ1NMJvAk8znbtu2TcWLF/fK+QEAuB5McQcAwIvMNOtWrVrZom6X69Gjh1asWGGLm5n1xs1U+DfffPOqhdCul5nWbsKuKVr366+/2unp5nOv1fnz5+30+Ntuu81Wkj906FD8wzDfL0eOHLZyuym+tnv3blu4zlSSjyuSZ4qxmQsEpkCduWDQuXNnnTx58qqfa6btm5Fu8+d07Ngxj04979+/v6ZNm2ZH0f/73//aWw5M0b1+/fp57DMAAEguAjoAAF5m7nWOm1p9+Qju7NmzbSgsV66cDYzmuOudCn81Zpq5qVA+Z84clSlTxgZlUx3+Wh0+fNiGahOU8+XLZ0fD4x5x98SvWbPGXggwo+tmdkD79u3tPd9xI+rmgkTr1q3Vpk0b1ahRw96vbirPX42p5N6pUydFRkba7zBixAh5ipneb5aqW758ue644w5blX7MmDEqXLiwxz4DAIDkCjCV4pL9LgAAAAAA4FGMoAMAAAAA4AMI6AAAAAAA+AACOgAAAAAAPoCADgAAAACADyCgAwAAAADgAwjoAAAAAAD4AAI6AAAAAAA+gIAOAAAAAIAPIKADAAAAAOADCOgAAAAAAPgAAjoAAAAAAD6AgA4AAAAAgA8goAMAAAAA4AMI6AAAAAAA+AACOgAAAAAAPoCADgAAAACADyCgAwAAAACgtPf/DowXNH9kEOEAAAAASUVORK5CYII=)" + ] + }, + { + "cell_type": "markdown", + "id": "7ZcXIc5GLD9L", + "metadata": { + "id": "7ZcXIc5GLD9L" + }, + "source": [ + "### `cell/topotune` model\n", + "\n", + "![cell_topotune.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "lJcWmOpyLEJQ", + "metadata": { + "id": "lJcWmOpyLEJQ" + }, + "source": [ + "### `simplicial/topotune` model\n", + "\n", + "![simplicial_topotune.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAJYCAYAAADxHswlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtpRJREFUeJzs3Qd4U+UXx/FTyt57b0SGCIIDEVkiQ0QEnKCCiuLEiVtx4sAB7i3+VVRcOMABCCKyZYgCojJEZYrsUUbzf37v5ZY0tNDSpEnT7+d5LtnJzc1NybnnvOdNCAQCAQMAAAAAAFGVJ7ovDwAAAAAAhAAdAAAAAIAYQIAOAAAAAEAMIEAHAAAAACAGEKADAAAAABADCNABAAAAAIgBBOgAAAAAAMQAAnQAAAAAAGIAAToAAAAAADGAAB0AAAAAgBhAgA4AAAAAQAwgQAcAAAAAIAYQoAMAAAAAEAMI0AEAiIKEhAS77777LFY9/vjjVrt2bUtMTLRjjjnG4tmbb77pPo/ly5dn+rH6DPXYSNE66fm1jtHQtm1bt2R1fbKyjS+++GKrWbNmph8HADkRATqAqPF/sGn54YcfDrg9EAhYtWrV3O1du3aNyjoCudHYsWPt1ltvtZYtW9rw4cPt4YcfjvYqAWm6+eabrWHDhu781KlT3QGTjRs3WqxYuXKlW6d58+ZFe1UA5BB5o70CAFCwYEF799137eSTT051/aRJk+zvv/+2AgUKRG3dgEjZsWOH5c0bm/8NT5gwwfLkyWOvv/665c+fP9qrk6vVqFHD7Sv58uWznLw+F110kZ1//vlh/3s+ZswYO+OMM1IC9Pvvv99l3EuWLGmxEqBrnVQBEO+VKADCgww6gKjr0qWLffjhh7Znz55U1ytoP/bYY61ixYqWE23bti3aq4AYk5ycbDt37kw5MBWrAfratWutUKFCYQvOVQ2joA6Zpwoi7SsaapCT10f31+PCORxg6dKltnjxYjv99NPD9pwAEG0E6ACirlevXrZ+/XobN25cynW7du2yjz76yHr37p1uoDNs2DA76qij3I++ChUq2BVXXGEbNmxIdT9lLVQe/91339lxxx3ngo6jjz7aXZZPPvnEXdZz6GDA3Llz08wmtmrVyooUKeKyMmeeeaYtWrQozXGoCxcudOtcqlQpVxGg8mBdn9bzqmxYP1r/+eefTI+9TGvcq7afXlPrWLRoUatXr57deeedqbbpoEGD3PssUaKEez96XxMnTjzg+fV5KONVvHhx93x9+/a1n376Kc2xp7/++qudffbZVrp0abcdtZ0///xzywh9jk8//XTKZ1CuXDnr3Lmz/fjjjyn30YGbBx980OrUqeOyb9oeel9JSUlh/ay1rbXd9KO/U6dObvtUrlzZHnjgARdgBnviiSfspJNOsjJlyrjX0fNpfw2l7XXttdfaiBEj3L6q9f/666/THIO+ZcsWu+GGG9z70P3Kly9vHTp0sDlz5qR6Th3M0uvpdcuWLWsXXnjhAfuQ/150fffu3d15bduBAwfa3r17D/qZaL203+oAkz8Exf/MM/tZfPPNNymfxcsvv5zua2qMc6NGjWz+/PnWpk0bK1y4sB1xxBEp21TVNM2bN3fPo/16/PjxBzyHPs/TTjvN7bN6v+3bt7fp06cfcL8FCxbYKaec4p6ratWq9tBDD7n9MC1fffVVyne/WLFiLhDU4w/l33//dd+L7du3H/K+h/repjXm2/98V6xY4bazzlepUsWef/55d/vPP//s3qPWWxlvHexMa3jR999/7/5uaj/WduvTp88Bf0NDpTcGXe/33HPPdfuZ/zndddddBx2D/tlnn7ltqu+Z9iftV9q/DrWPBmfP9bdM20/fpVtuucVdX6tWrZR913+9zO67GuahjLf+XqiEXn8/QulvxTnnnOP+9mmfPfHEE906+fS35/jjj3fnL7nkkgO+T3otfZaHGvev59HjPvjgAxs8eLDbb7Ve2sf/+OOPAx4/Y8YM93dU20brpe/UlClTMrRNAUQfATqAqNOPlBYtWth7772X6ofxpk2bXElkWvSjUj/GNEZWAZ5+/CgIUmC1e/fuVPfVDxgFzSqDfOSRR9wPUJ3X/W+88UYX4KgEccmSJe4HZvCPdQUCek5lFPUD8KabbnJllHrdtJod6ceafpQr+L788std4Kofq3qtULpOP8L0wzqrFDToR6V+bCqgfPLJJ61bt26pfpRt3rzZXnvtNfeajz32mHs/69atc+8veHyk3r+2jz4PBeb6Qbhq1Sp3Pq3X1Y9SHbC4/fbb3esqKFBQOGrUqEOud79+/VxQql4DWic9h354BgdWl112mTuw0KxZMxs6dKj7sanPMa19IyuftSgw0A9bHfAZMmSIC4TvvfdetwTTPte0aVO3rfVZKxOuzz74x3nwAR699nnnnecel16zqyuvvNJefPFFO+uss+yFF15wwbT2neCDQfphr/XWgR29P+1jChwUoISOu9V70Wer4EsHFLTd9Pm88sorB/1M3n77bReUKojReS2tW7fO9GehzKYOvukgg973ocp79VlpH1Ygrm2v19fzjhw50p2q0ubRRx91Bw70vdIBjeD9UOusg0gaO3/PPffYsmXL3L6uYMW3evVqa9eundvfta9p33vrrbfc+qW1HRQ8KvjVvqnn1AE4betDNTp77rnnrEGDBjZz5swsf2/To89XByT03dH20n6lg0HaR7QP68CI1lsHFhR4a3uE0v21f+lvge6j74m+u6EHpA5FB1b0uWlf1z6p7ann+eKLLw76OK2rtq/+ruox+r5p/9JnkxFffvml27/0/evZs6fb30T7pr/v6oBBZvfd33//3X1ftX11H//7HXwQec2aNe4gnQ5CXX311e7vpKpj9Pn5f/u0D+hzlf79+x/wfcos7f96bv1tuOOOO9zfyQsuuCDVffQZ6Pn1915/t/T3SX8bdMDmUPsjgBgRAIAoGT58uH4FBmbNmhV47rnnAsWKFQts377d3XbOOecE2rVr587XqFEjcPrpp6c8bvLkye5xI0aMSPV8X3/99QHX67G6burUqSnXffPNN+66QoUKBf7888+U619++WV3/cSJE1OuO+aYYwLly5cPrF+/PuW6n376KZAnT55Anz59Uq6799573WN79ep1wPvUdZUrVw7s3bs35bo5c+a4+2sbHEzfvn3dewjlv55v6NCh7vK6devSfa49e/YEkpKSUl23YcOGQIUKFQKXXnppynUff/yxe65hw4alXKd1P+WUUw5Y5/bt2weOPvrowM6dO1OuS05ODpx00kmBunXrHvS9TZgwwT3fddddd8Bteg6ZN2+eu89ll12W6vaBAwe66/Uc4fqsta113YABA1Kth/a9/Pnzp9q2/n7q27VrV6BRo0ZuGwXT82lfWbBgwQHvUbfpc/SVKFEicM0116S7vfQa2hf1Ojt27Ei5fvTo0e65Bg0adMB7eeCBB1I9R9OmTQPHHntsuq8R/PgiRYqkuu5wPgt9JzOiTZs27v7vvvtuynW//vpryvabPn36AZ9p8H7YvXt39xktWbIk5bqVK1e6vymtW7dOue6GG25wj50xY0bKdWvXrnXbXtcvW7bMXbdly5ZAyZIlA5dffnmq9Vy9erW7b/D1od/F4OuC96+0ZOR7q3UKfb/+5/vwww+n+i5rP09ISAi8//77B2zH4H3N/9urfUH7lW/IkCHu+s8++yzVZ6PlYOujbaxtHfwdC/4eB7+mv43T+h7JFVdcEShcuHCqvylp/R3ctm1boGDBgqnW4/HHHz/gNQ5339XfQd+mTZsClSpVct+f0H1J/x/5tN/UqlUrULNmzZS/9/r/Lb2/9XotvbdQodtc+5Geo0GDBqn+hj/99NPu+p9//jlle+vvbqdOnVJte21nrVeHDh0OeC0AsYcMOoCYoKygxqiOHj3aZcZ0ml55u0p8VbqnzIlKSf1F2RdlY0JLtlWeqAy9T5keUUahevXqB1yvskVR1liZNpUgqoTR17hxY/fayt6klQUNpcyUGgUFr5cyVcqOKlsaDn5DJJWMpleuq6yrP6ZY9/nvv/9c2acybcFl1CrBVgMoZcJ8ahh2zTXXpHo+PV7ZGn12+sz8z0Hl8crcKgt1sPL9jz/+2JVthmanxS/f97exMmyhnZslNGN9uJ91aFYxeD10WcMDgsuq9dkFZ35V7aEMbmg5uihT53eZPtRnqGyv9pW0qOxflRzK1qnKwKcsb/369dPM3ofuj1rHtN5zRmT2s1CZsfaDjNJ3NzibqRJpbRNlIf3PK63PTplklSMrY6tp4XyVKlVyf0M0Q4Syif57UMXHCSeckHI/ZVhDs5DKlCrrqIxs8N8YfYf0+mkNCwmmjLSOwQSXKR/u9/ZglBUOfi5tM1Ww6DsZuh3T+tyV1Q1u9nbVVVe5bHFaf9vSoyoclcpfeumlqb5jcqjx5sHfI/9viPZRVSGpZP5g9LdHlQfKcod731XJfY8ePVIu++X/GkahKgz/ObUfBTc31T6sbaoKC1VbhJsqxYL7Qmhbif/Z6v8r/d3Vfq+/w/5+q6oTlcPrczqc/QxA9iJABxAT9CP51FNPdWMlVbKrH90qY02LfoAoINIYXT0ueNm6dasLYoKF/mhUcC8qDU3ren8M5p9//pnyAzeUggb/h09oUBJKwbyCBb/MXT+QVD6usewqPw0HlWOq7F4/2FWerUBH4xVDf4z973//cwcYFOCp9FnbTD9OtT19et9aX41dDKYxwaHl5ApCVPob+jn4QXfoZxFMZeb6IRx88COU1kUHB0JfW40DFXT4n1FWP2ufXis4yJMjjzzSnQaXNesAkgI9bUetv96zytODt+PB9om0qEz5l19+ceuqH/4K8oKDqoPtjwrQQ7eFP6Y/mHojHGqMcbg+i4y+b5/G1YYGdPqcDvXZKUBUQJfe91Tfgb/++ivlPdStW/eA+4U+Vn9j/AM7ofu2DgYcbL+OxPc2LWl9vto26W3HtD730G2hAFPf/czMVe7vo+ohkFkq8VcgrPVTEKz3o2EoktZ3KZj+bungorZbuPdd3S90G4b+HdBj0tvn/NvDLfTvm77P4n+2/n6r4Uih+62GN+mAxqG2K4Doi832sQByJR31V9ZWGQplRdKbJkc/XhWcpzWuW0J/tKbXbTi96zM7/jK9jFDw6+i9vfrqq25sscaXKkvq/xA9mPQyUKFNlPS6yo4os6cfrsqCa+yuAgwFFFqHd955x1UDKNOo8fvahv5YZgXLmeUHERoPmV6mNPQH8eHKaOfn7PisJ0+e7MaZapynPk8FNMpCqrFaaDOu9PaJtCjrqYyYxpjqM3v88cfdGGIdsMpIljBUpLp+Z/SzyOj7jsb3NKP7tsYLpzWLRLi672fke5sTttfhUIWCqksUmGuctpq36aCDqlBuu+22Qx6kUAZbGeXMCGcH+XA42N/3tD7HQ322/jbT3470ej7oIAyA2EaADiBmKJOi5m9qfKMfqenRDzmVGyvzlNkgIDPU/dhvdhVK5ZfqoK1y0oxQeaQaQKlpkhrg6SBCRsp/lSEJbf6VXnZGGSKVMWp56qmnXHMgdVHWj39VJ6gjtrLDCviCfxiGlpjrfesxykoGZ9FDuwX7mWYFp3r+zNLnqAZLKpVPL4uuddGPTmWG/MyU36BJ28X/jMJFr6WMoJ8tk99++82d+s3dVJqvQELrHjynswL0rFKwrxJ2LcrSqqGVmk8pQA/eHxXABdN14d4W0f4sMkrfJe2n6X1P9b3ws/BaRz/LGCz0sdo3RQexDmffzoxDfW8jSdtCTfN8qkDS0B415Mso/++Aqj8yQ53JVYatv0fBTdPSamYXSq+lDvah06ulF/Bmdt/1q4OCny/074Aek94+599+sHU61N/30EqejPD3Wx30iPS+AyByKHEHEDN0ZF9lwirtVeftg2UalWHQlDmhNKY6rR88hxssKQuhsvDg59SPQ2W3MvMjVmXlWlRmqABPpawZycLpB5dKEtUl2acf0KEd0hXkhvIzKP40Qn72JTiTpjHP06ZNS/U4vxO+Mv4+/bj1p3DyKXjRGFtNn6V1CqXS44PR+Huti7qqh/LX0d/GmlIvmAIZicT8x+rAHbweuqyDEAqg/O2oH93BVQwqe/30008P+zX1XKGlp9q+GgLgf34q59V1L730UqqpoXTAR524Iz0XdDQ+i4zQ59GxY0c3jju4NFvBlyoaNEZYAYv/HnQAMLibtfbT0GocfQf0GAXLobNC+I8JxzRrGfneRpI6+ge/P/391d/QzFRs6ACJAuw33njDBc0Zzdqn9fdIvR5UlXIoyp6rtF3fiWD+AdPQ/wMyu++qwin4b6x6GKjbvz4bv6JCz6n9KPjvp4Y8aZsqiPf7TqS3Tv7fd+2Pet/Bw2f8IRmZpT4sek7N2qCDLZndbwHEBjLoAGJKWlN5hVJZpDLtKs1WUxz9OFcApeyIGshpup70xq9nlkoF9WNVjcc0JZga2T377LNuzGTwHNYZzaKrHFwyUt4uCuRV7qnqguuuu8794NePaGV4gxuSqURUpbL6oanMjbKv+qGr8ah+EyNN56RslZ5L91OmSsGefkgG/5hTCbzGQKuBkjJJGt+sec39YCI4I6SgXc+v+cU1PEFZHwVG+tH6999/u2mv0qPMneZaf+aZZ9xnp6mhdCBAJeS6Tc3ZmjRp4vYJ/ej1S2L1o1gHTbSewdm/cFBmXGXGek01A1Pwq9JjzZfsD53QttMPe62vhi5oW2s7qJw/+EBKZqhBlj4r7bd6zzpYpSqRWbNmucoL0T6ukneV9Wo7qIGZtrU/dZumcouk7P4sMkNzmfvziav6QAe/dOBIQa7G9vs0BZvK1vXZXX/99S540vvRdyb4s1Nwru+Z9k9VMeh7qM9fAaj2B1XvBB/ICaXbdOBJWfCDNYrLyPc2khQY6sCTDnoqG6zX1utqCEdm6Dusx2lbqUma+g/oYIm2VfAUjsE0RZkyyNqn9LdNf1f02WSkFF/Pq7/LodlpBaiiCgR9ZvrO6GBvZvdd/X3V33t9/3QgQAcf9F0LrpLRVHDqJaL10PqrCkjPp7+rOgiryghRwKzhWvpbq54j2uf0t0XbSL0HVNmk/VGfgYYaaSiSnwnPLL2mDgJrnY466ij3t0LTeKpZp/ZF7deHmvoOQAyIdht5ALlX8DRrBxM6zZrvlVdecdMEaWohTfGj6b5uvfVWN73SoR6r1w2d0sqfPkhT9QQbP358oGXLlu51ihcvHjjjjDMCCxcuTHNapYNNl7Rq1apAYmJi4MgjjwxkxtixY93UWppGql69eoF33nnngKmdvv3228CZZ57ppnPT/XSq6d1+++23lPto2h1Ny6RtUqBAATdlkKboSmsKI72P3r17u+2qaaUuvvjiwJQpU9xrBk/hJJraSlPOVaxYMZAvX75AlSpVAl27dg189NFHh3xvmvpN27t+/fpuvcuVKxc47bTTArNnz065z+7duwP333+/myZIz1+tWrXAHXfckWoapnB81v7UYno/HTt2dFM9aQo6bevgKfLk9ddfd9MZaTtq3bUvpzXdVlqvHXybP/WVpk665ZZbAk2aNHHbXOuh8y+88MIBjxs5cqT77PTapUuXDlxwwQWBv//++5DTpEla65iW9B6f1c8iPZpS6qijjjrg+sx8ppq6UNNLFS1a1H12mqYxeMo93/z5893raYou7asPPvig+zzTmp5L01vpOfUd0P3r1Knjvgs//vhjWKZZy8j3Nr1p1tL6fDK6Hf2/vZMmTQr0798/UKpUKbfdtC8FTymZ0WnW5Jdffgn06NHDTU+nbaW/Vffcc88Brxm8jfU35cQTT3R/W/Xe9ffbn0YvdApE/2/Uxo0bA3nz5g188MEHaW5TfZ76XDU9X/DrZXbf1Xo0btw45Tv+4YcfHvBa+ltx9tlnp7znE044wf1NDaVp6xo2bOjWO3TbPfnkk2599Tr6f0b7VnrTrIWuQ3qfxdy5cwM9e/YMlClTxj2v3tO5557r9jcAsS9B/0T7IAEA5AYqe1XZ/KBBg1zn85xGJdzKvmvaKmUQ440a6CmblVZpKBBP3nzzTZddVYY4tEw81qnLvabF099Tv6N/OKkaRR3pVWoOANHAGHQAyMYfxRprrLLZWKdS/mBab5X2q0RSZawAEA0qF1dJfSSCcwCIBYxBB4AImzBhgi1cuNB149Z4R78LcCwbMGCAC9I19l7jeDV2ferUqa5pViQ75wPAwajnCADEMwJ0AIgwNYJScKuycGWhcwJN46XmZCrz3Llzp2uApnVX4zYAAABEBmPQAQAAAACIAYxBBwAAAAAgBhCgAwAAAAAQAxiDngXJycm2cuVKK1asmCUkJER7dQAAAAAAYaZR4Vu2bLHKlStbnjyRzXEToGeBgvNq1apFezUAAAAAABH2119/WdWqVSP6GgToWaDMuf9BaW5gAAAAAEB82bx5s0vM+vFfJBGgZ4Ff1q7gnAAdAAAAAOJXQjYMa6ZJHAAAAAAAMYAAHQAAAACAGECADgAAAABADGAMejZMxbZr165orwaACMqfP3/Ep9wAAABA/CNAjyAF5suWLXNBOoD4peC8Vq1aLlAHAAAADhcBegQns1+1apUlJia6lvxk14D4pANwK1eudN/36tWrZ0t3TwAAAMQnAvQI2bNnj23fvt0qV65shQsXjvbqAIigcuXKuSBd3/t8+fJFe3UAAACQQ5HWjZC9e/e6U0pegfjnf8/97z0AAABwOAjQI4xyVyD+8T0HAABAOBCgAwAAAAAQA2IuQH/kkUfs+OOPt2LFiln58uWte/futnjx4lT32blzp11zzTVWpkwZK1q0qJ111lm2Zs2aVPdZsWKFnX766W78t57nlltuceNDg3333XfWrFkzK1CggB1xxBH25ptvZst7zO2Zxk8//TQiz33ffffZMcccYzlN27Zt7YYbbrBYUbNmTRs2bFi0VwMAAADIdWIuQJ80aZILvqdPn27jxo2z3bt3W8eOHW3btm0p97nxxhvtiy++sA8//NDdX82ZevbsmXK7xoEqONc0Z1OnTrX//e9/LvgeNGhQyn00/Znu065dO5s3b54LkC677DL75ptvsv095ybqdH3aaae588uXL3cBu7Z/OAL9gQMH2rfffhu2dQUAAACAXN3F/euvv051WYG1MuCzZ8+21q1b26ZNm+z111+3d99910455RR3n+HDh1uDBg1cUH/iiSfa2LFjbeHChTZ+/HirUKGCy6o++OCDdtttt7ksqxo6vfTSS27e4ieffNI9hx7/ww8/2NChQ61Tp05Ree+5QcWKFSP23Kqm0AIAAAAAOVHMZdBDKSCX0qVLu1MF6sqqn3rqqSn3qV+/vpt/eNq0ae6yTo8++mgXnPsUdG/evNkWLFiQcp/g5/Dv4z9HWpKSktxzBC/xOq/zkCFDXNm/yv+1bQcPHuxu+/nnn92BkUKFCrkhBv3797etW7emevwbb7xhRx11lHtspUqV7Nprr00z860DJNK0aVN3vUq9ZdasWdahQwcrW7aslShRwtq0aWNz5sxJVYItPXr0cI/zL4eWuOt9PPDAA1a1alW3Lrot+ACQn8H/5JNPXCWFhkM0adLkoPtA6MGjkiVLuvdTt25dK1iwoNuH/vrrr5T7XHzxxW6YRjBVa/jv1afhF9pOer963/fcc48FAoFU7/mhhx6yPn36uIMQNWrUsM8//9zWrVtnZ555pruucePG9uOPP6Z6Xh10atWqlfu8qlWrZtddd12qapS1a9faGWec4W7X5zFixIgMvXcAAAAAuSxAV4ClYKZly5bWqFEjd93q1atdBlyBUTAF47rNv09wcO7f7t92sPso6N6xY0e64+MVQPmLAp6MUqyluCgaS1CclyF33HGHPfrooy5IVCWCqhW0bRTYKQAtVaqUC6I1xEBVCsEB+IsvvuiGKChwVzCvIFKBflpmzpzpTvUcKn1XoCxbtmyxvn37uuBSVREKfrt06eKuF722Xzmhx/mXQz399NOuQuKJJ56w+fPnu3Xv1q2b/f7776nud9ddd7nyeJXaH3nkkdarV68D+hWkR3Pd6+DFW2+9ZVOmTLGNGzfa+eefb5mlYRh58+Z120Tr/dRTT9lrr72W6j6q7tB3Ye7cuW54xkUXXeQC9gsvvNAdwKhTp4677Af2S5Yssc6dO7seDXr/I0eOdNs0+PPSAQQdUJg4caJ99NFH9sILL7igHQAAAEAUBGLYlVdeGahRo0bgr7/+SrluxIgRgfz58x9w3+OPPz5w6623uvOXX355oGPHjqlu37Ztm6KWwJdffuku161bN/Dwww+nus+YMWPcfbZv357m+uzcuTOwadOmlEXrpfvrfKgdO3YEFi5c6E5l61ZFTdFZ9NoZtXnz5kCBAgUCr7766gG3vfLKK4FSpUoFtgY9obZZnjx5AqtXr3aXK1euHLjrrrvSfX5tr1GjRrnzy5Ytc5fnzp170HXau3dvoFixYoEvvvgizefx3XvvvYEmTZqkXNa6DB48+ID95Oqrr071+q+99lrK7QsWLHDXLVq0KHAow4cPd/edPn16ynV6nK6bMWOGu9y3b9/AmWeemepx119/faBNmzYpl3W+QYMGgeTk5JTrbrvtNnedT9+DCy+8MOXyqlWr3Ovcc889KddNmzbNXafbpF+/foH+/funeu3Jkye7z0v75eLFi939Z86cecD6Dx069JDvH+l/3wEAABA/Nm3alG7cF24xm0FXlm/06NEus6cS5eAxzGr+pkxlMHVx98c36zS0q7t/+VD3KV68uCv3TYvKpHV78BJvFi1a5Er527dvn+ZtKgEvUqRIynXK6KrSQZ32lXlVw760HpsZ+hwuv/xylzlXpYK2s8ro1Zk/o1QJoXXR+gXTZb2PYCoN96kkXzKaRVbWW7MOBA+3UHVH6GscinonBM+l3aJFC5fpV8PDtNbTr/7QUI7Q6/x1/+mnn1wZvj82X4uqCPR5qUmi1lHrf+yxxx6w/gAAAACyX8w1iVNydMCAATZq1Cg3DZo/TtmnYCJfvnyuW7dKd0XBoYI3BTWiU5UdK1BRgzlRR3gFeg0bNky5z5dffpnquXUf/znCrXBhs5Ch2tlGr51R6R2ciPRjg6m8ff369a7UW2OtdWBEn4sOzESC9iefHyQriA2HPHnypBpLLuqhEK71PNi666DGFVdc4cadh1Jfgd9+++2w1gMAAABAZMRcBl3jl9955x037llzoWusuBZ/XLgyqv369bObbrrJZdfVNO6SSy5xAZyykKJp2RSIa4yusoiaOu3uu+92z61gT6688kpbunSp3Xrrrfbrr7+6sbcffPCBm8ItEhQ7KfEcjSUoMXtIylor0E5rujJ1utf2DG4ypnHXCkLr1avnPi81M8voVGfqJSDBWWL/ORVUaty532zu33//TXUfBaahjwumgzGVK1d2zxX63P5BmnDQWPXgxmw6WKTqDm0rKVeunBsnHyytaeVmzJiR6rI/9j4xMfGw161Zs2auh4B6AIQu2vbKlmv99R0KXX8AAAAA2S/mAnQ1GVPndnW5Vrmxv6jBVXCzrK5du7oMuqZeU7m632BMFNSoPF6nCtzVREvNs9TR26fM/JgxY1zWXGXbaiamply5fYo1dSLXdHQ6cKHGZ2o0pmBRU9tdcMEF7nZluH/55Rd3gETVDjoQ4pdXq5O6tuUzzzzjSrTVvOzZZ59N87VU3aCDAeqsrrJ2v2O/AtO3337blWArcNXrhmbn/QMBOnizYcOGNJ//lltusccee8ztOwo8b7/9dhccX3/99WHbXjpQoG2g9VSgq6ZrOlB0wgknuNvV8V4BvLaltse9997rtl0oVYDooJPW87333nPbLKvrqc9x6tSpbriI3rde/7PPPktpEqeDKmoipyy7v/6XXXZZ2CohAAAAAMRBifuhKEh8/vnn3ZIelUaHlrCH0kEAdcRGaurerrHJgwYNcuO4dYBEFQeahkzVCAocNe5al3WQRB3HfQred+7c6Q6iqDO6pgw7++yz03wdvYYCeR040WtpOjANa9DBAHWBVwZYnfIffvhh91zBdBBAAe2rr75qVapUcVOmhVIWXkH/zTff7IY7KHOurvI6ABAu2gYKhHv37m3//POPew9af58O+Gh76oCHtsull17qDhapw30wXacqEQX2OrCkbaxtkBUasz5p0iTXpV7rpe+WOr2fd955KfdRJ3wF5ZrKTgdZNJWb1hcAEPv0k0kTmSiHofYjwS1iRQVjd96p4VbRXlMAQEYlqFNchu+NAxqRqeReQWBowzgFY2rEpUy9Digg/qgBm6YBpCQcfN8BZJedO82mTdMUpWYqHvz114Pf/4svzLp2za61A4DcF/fFfQYdAAAAB1JgrpF4W7bsv06jknr0UN8Rr+eMv0ycaPb556o4I0AHgJyEAB1Ix2mnnWaTJ09O87Y777zTNaEDACC7fPaZF5yXKWPWubOa4pp1767GqAfeVxPdaKTfd9+ZqRdo0IyaAIAYRoAOpENNA/3ZA0KVLl3aLWoKBwBAdvDL2e+7z2xfv890VatmppYjI0Z4WfR3382WVQQAZBEBOpAONZ8DACBWLF7sndavn7H733yzF6B/8IHZo4+aVa8e0dUDAIQBfT0BAABi3O7dZn/84Z2vVy9jj2naVNN9mu3da5bOjKcAgBhDgA4AABDjli4127PHrEgRVXhl/HFXXOGdqmkcACD2EaADAADkkPJ2Zc8zM695zZreqeZJBwDEPgJ0AACAHNIgLqPl7b5y5bzTdevMAoHwrxcAILwI0AEAAHJIgJ7RBnG+8uW90507zbZtC/96AQDCiwAd2SohIcE+/fTTiDz3fffdZ8ccc4zlNG3btrUbbrjBYkXNmjVt2LBhWX6eN99800qWLBmWdQKA3C6zHdx9GrNeqND+LDoAILYRoCNbrVq1yk477TR3fvny5S5gnzdvXlgC/YEDB9q3334btnVFbNGc8927d4/2agBAtlNp+qJFh1fiHlrmDgCIbQToyFYVK1a0AgUKROS5ixYtamXKlInIcyN+7Nq1K9qrAACZ8u+/Zhs26OC0Wd26mX88AToA5BwE6DhAcnKyDRkyxI444ggXTFevXt0GDx7sbvv555/tlFNOsUKFCrlguH///rZ169ZUj3/jjTfsqKOOco+tVKmSXXvttWlmvmvVquVOmzZt6q5XqbfMmjXLOnToYGXLlrUSJUpYmzZtbM6cOalKsKVHjx7ucf7l0BJ3vY8HHnjAqlat6tZFt3399dcpt/sZ/E8++cTatWtnhQsXtiZNmti0adMyVcKt91O3bl0rWLCgderUyf7666+DZn1Vzu6/V9+ePXvcdtL71fu+5557LBDUzUfv8aGHHrI+ffq4AxE1atSwzz//3NatW2dnnnmmu65x48b2448/pnreH374wVq1auU+r2rVqtl1111n24IGIa5du9bOOOMMd7s+jxEjRlhmbNy40a644gqrUKGCe/+NGjWy0aNHp3nfjGyLjz76yI4++uiU/evUU09166vP9n//+5999tln7jPT8t1337nHaHufe+657rMoXbq02x76bENfV/tw5cqVrd7hpJ8AIAbK26tXNytcOPOPJ0AHgJyDAD27KNhSYBSNJZNtW++44w579NFHXZC4cOFCe/fdd10ApkBJAWipUqVcEP3hhx/a+PHjUwXgL774ol1zzTUucFcwryBSgX5aZs6c6U71HCp9V6AsW7Zssb59+7rgcvr06S747dKli7te9NoyfPhw9zj/cqinn37annzySXviiSds/vz5bt27detmv//+e6r73XXXXa48XqX2Rx55pPXq1csFzBmxfft2F/i99dZbNmXKFBewnn/++ZZZCj7z5s3rtonW+6mnnrLXXnst1X2GDh1qLVu2tLlz59rpp59uF110kQvYL7zwQncAo06dOu6yH9gvWbLEOnfubGeddZZ7/yNHjnTbNPjzUvCqAHfixIkuOH7hhRdc0J4ROgCi4Qp63++8847bV7TfJCYm2uHQZ6ltf+mll9qiRYtcAN6zZ0/3fvT5KAjX+9H9tJx00km2e/du97kWK1bMJk+e7NZFByt0v+BMuYY+LF682MaNG5fuAQQAiLcGcaEBOlOtAUAOEMBh27RpkyIhdxpqx44dgYULF7pTZ+tWhU3RWfTaGbR58+ZAgQIFAq+++uoBt73yyiuBUqVKBbYGPd+YMWMCefLkCaxevdpdrly5cuCuu+5K9/m1vUaNGuXOL1u2zF2eO3fuQddp7969gWLFigW++OKLNJ/Hd++99waaNGmSclnrMnjw4FT3Of744wNXX311qtd/7bXXUm5fsGCBu27RokWBQxk+fLi77/Tp01Ou0+N03YwZM9zlvn37Bs4888xUj7v++usDbdq0Sbms8w0aNAgkJyenXHfbbbe563w1atQIXHjhhSmXV61a5V7nnnvuSblu2rRp7jrdJv369Qv0798/1WtPnjzZfV7aLxcvXuzuP3PmzAPWf+jQoYd8/9988417Lj1PetunRIkSKZcPtS1mz57tXnv58uVpPl9aj3/77bcD9erVS7XtkpKSAoUKFXLr5z+uQoUK7vpIOeD7DgBhdPPN3n/n119/eI+/6Sbv8QMHhnvNACB32HSQuC/cyKAjFWUuk5KSrH379mnephLwImoJu48yusqkKjupzOvKlSvTfGxmrFmzxi6//HKXOVfJd/HixV0Z/YoVKzL8HJs3b3brovULpst6H8FUGu5TSb5kNIusrPfxxx+fcrl+/fqu1Dr0NQ7lxBNPdGXbvhYtWrhM/969e9NcT1U0iMrBQ6/z1/2nn35yZfjKKPuLss36vJYtW+bWUet/7LHHHrD+GaGKAw0fUNVBOGjf0r6j93TOOefYq6++ahs06PIg9B7/+OMPl0H336PK3Hfu3OkqCHx6zvz584dlPQEgWiXuhztChxJ3AMg58kZ7BXINDRoLGaudra+dQRr7e7iy8thgKm9fv369K/XWWGuNH1fAGqnmXvny5Us57wfJCmLDIU+ePKnGkovKssO1ngdbdx3U0PhwjTsPpb4Cv/32m2VFZj/vQ20LlcarBH3q1Kk2duxYe/bZZ93wgxkzZqT0Kwil96gDDGmNnS/n/yJ10wztP6gEALm1xJ0AHQBiHxn07KLgSUFCNJagzOyhKGutwCut6coaNGjgMpbBTcY05leBlxpvKYupZmYZnerMz2gGZ4n951RQqXHnfrO5f9XCNogC09DHBVPWXQ3B9Fyhz92wYUMLF41VD27MpkoCjUPXtvKDRI2XDpbWtHIKQoP5Y+8Pdzy3NGvWzI0LVw+A0EXbXtlyrf/s2bMPWP+MUEb/77//znCgn5FtoYMMqnK4//773Vh7reeoUaPcbTof+pnrParSoHz58ge8R1VfAEBOp2PTy5Z558mgA0D8I0BHKurEfdttt9mtt97qGp+pTFjB4uuvv24XXHCBu10Z7l9++cU1FhswYIBrVuaXV6vbthqzPfPMMy5wUvMyZULToqBKBwPUWV1l7Zs2bXLXKzB9++23XQm2Ale9bmi21j8QsHr16nTLoG+55RZ77LHHXHM0BZ633367Cwivv/76sG0vHSjQNtB6KtBV0zWVq59wwgnudnW8VwCvbantce+997ptF0rl+zfddJNbz/fee89ts6yupz5HZaPVFE7vW6+vLuh+kzgdVFEzNWXZ/fW/7LLLMpwZV3f91q1buyZ0ynyrbP6rr75K1Sk/2KG2hdbh4YcfdvfR9lDTQHWp9w926DNXszttIx2wUfZd+4a63qtzu5rEaR3UXE4HeHTwAAByOh3X1LFJHdPeNwor08qX904J0AEg9hGg4wDq3n7zzTfboEGDXHB03nnnuXHNmobsm2++sf/++8+Nuz777LPdmOHnnnsu5bEK3ocNG+a6gSv73bVr1wO6pvs0/lmB/Msvv+yy3QqyRAcDFHQrO6rgX8GWgvlgOgigoFBTh2matrTocQp69V40BlmBo7rK6wBAuGibKBDu3bu3y/xqDLQOCPg05lvbUwc8tM3UiV6d1kPpuh07drjAXl3wFZyrE35WKMM9adIkl+HWVGvaTvpMta196oSvywq21TFdrxm6rQ/m448/du9L3ddVmaD3mV5lw6G2haoevv/+e1c5oXHtd999t/uc1Sle1JdABxWOO+44l41XNYS2vx6jkn2tv/bXfv36uTHoej4AyOlWrvRO9ac7EwVxqZBBB4CcI0Gd4qK9EjmVGpGpjFaZ39BgQAGCsnkaO6usM+KPGrBpHu+MloQjfvF9BxApH39sdvbZZiedpGFah/ccmzeb+aN+NErtcOZSB4DcbPNB4r5wI4MOAACQAzLoh6tYMa9EXsiiA0BsI0AH0qHS6uApyoIXjZWOd+qMnt771/AFAEDOCNBVGk+ZOwDkDEyzBqTjtddec+PC06K5trWoKVy86tatmzVv3jzN24KndwMAxHaALgrQ//mHAB0AYh0BOpCOKlWqWG6mafO0AADiI0AXAnQAiG2UuAMAAMQoAnQAyF0I0AEAAGIUAToA5C4E6AAAADFo+3YzfybPcAXoa9dmfb0AAJFDgA4AABCDVq3yTjVveVan3SWDDgA5AwE6AABAjJe3a6q0rChf3jslQAeA2EaAjmyVkJBgn376aUSe+7777rNjjjnGcpq2bdvaDTfcYLGiZs2aNmzYsCw/z5tvvmklS5YMyzoBQG4UrvHnQgYdAHIGAnRkq1WrVtlpp53mzi9fvtwF7PPmzQtLoD9w4ED79ttvw7auiC2ac7579+4Rf53du3fbbbfdZkcffbQVKVLEKleubH369LGV/i9lAMgmBOgAkPsQoCNbVaxY0QoUKBCR5y5atKiVKVMmIs+N+LFr166D3r59+3abM2eO3XPPPe70k08+scWLF1u3bt2ybR0BIFIB+pYtZklJWX8+AEBkEKDjAMnJyTZkyBA74ogjXDBdvXp1Gzx4sLvt559/tlNOOcUKFSrkguH+/fvb1q1bUz3+jTfesKOOOso9tlKlSnbttdemmfmuVauWO23atKm7XqXeMmvWLOvQoYOVLVvWSpQoYW3atHGBUnAJtvTo0cM9zr8cWuKu9/HAAw9Y1apV3brotq+//jrldj+DrwCsXbt2VrhwYWvSpIlNmzYtUyXcej9169a1ggULWqdOneyvv/46aNZX5ez+e/Xt2bPHbSe9X71vBYeBQCDVe37ooYdcJlcHImrUqGGff/65rVu3zs4880x3XePGje3HH39M9bw//PCDtWrVyn1e1apVs+uuu862bduWcvvatWvtjDPOcLfr8xgxYoRlxsaNG+2KK66wChUquPffqFEjGz16dJr3zci2+Oijj1zm2t+/Tj31VLe++mz/97//2WeffeY+My3fffede4y297nnnus+i9KlS7vtoc829HW1DysbXq9evYO+J30G48aNc8+p+5544on23HPP2ezZs23FihWZ2j4AECsBukYc5c3rnSeLDgCxa9+fakSagq3tu7dH5bUL5yvsApqMuuOOO+zVV1+1oUOH2sknn+zK0n/99VcXKCkAbdGihQuiFdxddtllLrBUsCovvvii3XTTTfboo4+6UvZNmzbZlClT0nydmTNn2gknnGDjx493AX3+/Pnd9Vu2bLG+ffvas88+67bbk08+aV26dLHff//dihUr5l67fPnyNnz4cOvcubMlJiam+fxPP/20e+zLL7/sDgLowIGyoAsWLHABte+uu+6yJ554wl2n87169bI//vjD8vq/ZA6RbVXg99Zbb7n1v/rqq+38889P9z2nR8Fnv3793DZRkK0DHzowcvnll6fcR5/Hww8/7IJ3nb/ooovspJNOsksvvdQef/xxV5atAF7vT5/3kiVL3PZRYK/3rmBen5UWbTs/eFXp9sSJEy1fvnwugNfnmhE6AKLPWJ/XO++8Y3Xq1LGFCxem+3kcivYzbXsdHNLBFz3v5MmT3T6g4QuLFi2yzZs3p6y7gnGVo/v7pO6rz0zvV+97/vz5KfuUhj4UL17cBd6HQ/uxtilj6gHk1ABdPwPKljVbvdqbaq1q1aw/J2KLjuvr54fyBP4xfv+0ShWz1q3N8pCaQ4RoX5sxw+y337wZKP79V78VvduUS7v0UrMiRaK9ljkDAXo2UXBe9JGiUXntrXdstSL5M/aNUFCkwFYZQwXJosBLgbqC9p07d7pgVGNzRfdTBvaxxx5zWVQFRzfffLNdf/31Kc95/PHHp/la5fbV2ylTqtJ3nzL0wV555RUXGE2aNMm6du2a8jhdF/y4UAq6FbQqYBatowJRNUB7/vnnU+6n4O/000935++//353sEABev369Q+5vRQgahs0b948JdBu0KBBysGHjFJ2W0G3gkBlbVWpoMvBAboOUihbLYMGDXIHQ7RtzznnHHed3qsC1TVr1rjt8sgjj9gFF1yQ0oBOByCeeeYZV5Ggxyob/NVXX7l19T+j119/3a1/RujAih6rwPnII49019WuXdsOlwJ0VRL07NnTVQiIsuk+ZdWTkpJSfeY6MKADBa+99lrKQSgF8No3lGHv2LGju077q+7jB+yZoX1e21YHDxTkA0BODNBF/30qQCeDHn8UmN9xh9nkyenfR/9F9+9v1qaNF7Crs/9hHlNPJaszDOzZowPhqsrT76qsrw+yPzBX8ekzz5j98kv691Mx7j33ePtfOPapWrW8KSjjEQE6UlGwpSCoffv2ad6mEnA/OJeWLVu6AEljdBUgKRub1mMzQwHm3Xff7QIsZXP37t3rMtWZKS9WplXrovULpss//fRTqutUGu5TSb7odTMSoCtjG3wAQo9RcKhtlZkAXWXUwVUOCrSV/dd79zPSweupgyGhAax/ndZdQazep7LIwWXrykbr81q2bJn99ttvbv2PPfbYA9Y/I9TcT8MH/OA8q7Rvad/Re1JWXMH12WefbaVKlUr3MXqPOpiiyorQoFoVBD495+EE5zoAo1J3bTcd1ACA7PzR+88/4Q/QRcekwxGYIXb47VUKFtRvCC9THhzkzJpltnSp2e23R20VkQsoYNZPb/2c1t8bFaPu3Wv28cdmy5aZBY16zbKqVc30U+8wft7FPAL0bCwzVyY7Wq+dUcpSHq6sPDaYMvfr1693mXxlUjV+XAHroZp7HS6Vdvv8IFlBbDjkyZMn1VhyP+gL13oebN3VG0AZd5Wth1L5vAL0rMjs532obaEDESpBnzp1qo0dO9YNcdCQgxkzZqT0Kwil96gDDGmNnfcrLST4oFJmg/M///zTJkyYQPYcQLZSMze/Zci+Y8dZpgK1CRO8H8xaED8UkKuE+N570x6+sH272ciRqjwz++MPrzpDmetYov9mI9RHGBGmn1z9+nn7YFp5HmXP33jDTLP4bthw8OcKpP6pmCZVAf39d/wO1yFAzyYKnjJaZh5NKoNW4KUxuxpfHkylzxprrrHofsCjsdYKvFSWrSymmpnpsWq6dih+RlNZ4mB6zhdeeMGVdPtNwP7VQJYgCkxDHxdMwZQagum5VNId/NyZyWwfikqyNWbcf05VEqhxml8mriDxl5B6H2WegwNrURAabPr06e6zONzx3NKsWTM3JlzN/tKibLnWX83P/CoAf/0zQhn9v//+2wX6GcmiZ2Rb6HuiKgctKuPXAZpRo0a5vgbaX0I/c73HkSNHup4E4Qyg/eBcfQ80LILZAQBEq7xdf9qKhmmE3F13mWnkVISOd8ecjPzQjxcqJDtYAZwym5dc4i2iY/kqK4+FbayDC1p/qjril37yX3mlt4RDmTJm//2nilmLSwToSEWduDXe9tZbb3UBkQIlNRdT4zGNZ7733ntdhltdtXX9gAEDXLMyv7xa11955ZUuYPIbiCko1v1C6T46GKDO6iqV1murg7YC07ffftuOO+44V6p+yy23HJCt9Q8EaP2UYU+rDFqP0/pqDL06uGtssgLCzHYqPxgFl3pvGtutcnE1YFO5uh+wazy9Grhp3L6qADRmWkGqmtYFU/m+glBlvNWxXtljlbhnhT5HrYvWSQdbdFBFAbuy1Bo3r4Mqaqam11T5ttZf49UzmhnXgY/WrVvbWWedZU899ZQ7EKBmggqy9byhDrUtdJBCn6lK27Vv6LL2Mf9ghz7zb775xh1EUMCsfUX7pJ5Tndv9jv3KeKszv/ZhXT6c4Fyl9foc1JFeBwVWa9DmvsZ0h1MqDwDRHn/u07hjQEHxQUaQATGtePH4DtDp5YgDqEu4Gr0pg6ng6LzzznPjmjUNmQKk//77z2VcFcRozLCCPZ+CdzVhUwZczdbU1E1ZyLQoIFRgqy7rynYryPIblW3YsMFlRxX8q0RbAVswBa8KNNVcLTTY9elxCnr1XjQGWQcCNDVZcAf3rNI2USDcu3dvd7BA050po+vTWGptTwWL2mY6YKFO66F03Y4dO1xgf80117gme+rknhXKcKuxnjLcmmpN20mfqba1TwctdFnBtpqz6TVDt/XBfPzxx+59qYFaw4YN3ftMr7LhUNtCGfDvv//eVU4oI68+BPqcdaBH1DBPBxV04EbZeB340fbXY1Syr/XX/qpu+BqDfrgZ9X/++cftJ6oO0IEd9SXwF5XfA0BODtABIKcrvu8nXrwG6AmB0EGhyDBld5XF0xRMocGAAgQ14tLYWWWGEX9U7q+Mc0ZLwhG/+L4DCLchQ1QJZXbhhWZvvx3ttQGA2NGqldkPP5h99JHZWWdFP+4LNzLoAAAAMYYMOgDkzgw6ATqQDpVWq2Q9reXhhx+2eKex+um9fw1fyKkmT56c7vvSAgCxYNWq8HZwB4B4UTzOA3SaxAHpeO2119y48LSoWZiWiy++2OJVt27drHnz5mneFtqFPifRGHY1CwSAWLZ+vXcaNGMkAMAI0IFcq0qVKpabado8LfFGXerTm3ouVm3darZ8uTctTt68ZvXqMR0NEO/UoVhKl472mgBAbClWLL4DdErcASCGqQFKtWpmRx9t1qSJmUYXDBwY7bUCkF0ZdAJ0AMhdGXQC9AijST4Q/yLxPd++3eyKK8zOOcdMEwXoPyN/BryXXjJbuzbsLwkghpBBB4CDB+hbtlhcIkCPkMR99ae7du2K9qoAiDD/e+5/78PhjjvMXnnFLCHBO//vv2arV5udcIKmdTN74YWwvRSAGKM/KRraImXKRHttACC2FI/zDHrMjUH//vvv7fHHH7fZs2fbqlWrbNSoUda9e/eU2xP0azUNQ4YMsVtuucWdr1mzpv3555+pbn/kkUfs9ttvT7k8f/58u+aaa2zWrFlWrlw5GzBggN16661hex958+a1woUL27p161xDrTx5OBYCxKPk5GT3Pdf3Xd/7cPnmG+/0jTfMgnsRqrz93HPNnn/eTH+yChcO20sCiBEbNnin+slTokS01wYAYktxAvTstW3bNmvSpIldeuml1rNnzwNuV9Ae7KuvvrJ+/frZWSGz1D/wwAN2+eWXp1wObnalieY7duxop556qr300kv2888/u9crWbKk9e/fPyzvQwcSKlWqZMuWLTvgYAGA+KIDcNWrV0/3AGJm6T+cxYu986efnvq2Hj3MatUyW7bM7K23zK68MiwvCSAGy9tLlqQhJACEIkCPwtzTWtJTsWLFVJc/++wza9eundWuXTvV9QrIQ+8bPL+zSlLfeOMNy58/v5vTWdMuPfXUU2EL0EXPXbduXcrcgTin73o4q2TmzvVOq1c/cIolJelvvNHsuuvMnnrKTMch+QEPxBfGnwNA7u3iHnMBemasWbPGxowZY//73/8OuO3RRx+1Bx980GW1evfubTfeeGNK+em0adOsdevW7ke1r1OnTvbYY4/Zhg0brFSpUmm+XlJSkluCM/GHoh/tBQsWPMx3CCA3mj3bOz322LRvv+QSs0GDzH7/3WzKFLPWrbN19QBEGAE6AOTeDHqOHhitwFyZ8tBS+Ouuu87ef/99mzhxol1xxRX28MMPpxpfvnr1aqtQoUKqx/iXdVt6NI69RIkSKUs1zX0EAGH244/e6XHHpX170aJmzZp551esyL71ApA9CNABIPd2cc/RGXSVqF9wwQUHZKhvuummlPONGzd2mXIF6gqwCxQocNivd8cdd6R6bmXQCdIBZHcGXfwp19aty551ApB9mAMdAA4doGsUsYqbsxDexaQcG6BPnjzZFi9ebCNHjjzkfZs3b2579uyx5cuXW7169dzYdJXHB/MvpzduXRTcZyXAB4BD2bTJ7LffDh2g+2PTCdCB+M2gM8UaAKRdSehTmXtov56cLseWuL/++ut27LHHuo7vh6IGcBoLXn5fyqlFixZuOrfdu3en3GfcuHEueE9v/DkAZAe/QVyNGmZly6Z/P/8/o7Vrs2e9AGQfStwBIH1qjusH6fE4Dj3mAvStW7e6gFqLaJoynV8RNNBSpeUffvihXXbZZQc8Xg3ghg0bZj/99JMtXbrUdWxXg7gLL7wwJfhW0ziVvWt6tgULFrgs/NNPP52qfB0AYrW8XShxB+IXAToA5N5O7jFX4v7jjz+6adN8ftDct29fe/PNN915NYALBALWq1evAx6vEnTdft9997mO67Vq1XIBenDwrQZvY8eOtWuuucZl4cuWLWuDBg0K6xRrAJCVBnGHCtApcQfiFwE6ABx6HPqqVQTo2aJt27Yu+D4YBdLpBdPNmjWz6dOnH/J11DxO49gBIBYz6Ol1cPdR4g7ELwJ0AMi9ndxjrsQdAHJzgzjNbS6UuAO5FwE6AOTeudAJ0AEgRuxrveEaxB2qe7OfQdd/TJpiBED8TbNGF3cASBsBOgAg4vzZH2vWPPR9S5b0upgKWXQgfmiCGf8HJxl0AEgbAToAIOL8cVR+Z9KDyZOHRnFAPNq4MfWBOABA7uriToAOADkwQBcCdCB+x5+XKGGWN+Za+QJAbChOBh0AEGkE6ABoEAcAh0YXdwBAxG3d6p0WLZqx+/ud3JlqDYgfBOgAcGhk0AEAEUcGHYAfoNPBHQDSR4AOAIg4AnQAZNAB4NAI0AEAMRegU+IOxO8c6AToAJA+AnQAQLYF6Bkdg04GHYg/ZNAB4NCYZg0AkG1N4ihxB3IvAnQAODQy6ACAiKPEHQABOgBkPEBXciM52eIKAToA5PAmcTp6nJQUufUCkH3o4g4AGQ/QgysQ4wUBOgDk0DHoJUuaJSZ65//9N3LrBSD7kEEHgEMrUMAsX774LHMnQAeAGBAIZH4Mep48+7PolLkD8YEAHQAOLSEhfsehE6ADQAzYudNs797MBehCozggfuhvwMaN3nkCdADInZ3cCdABIIbK26VIkYw/jgA991ZcTJtmtmFDtNcE4aTgXJ+tlCoV7bUBgNhWnAw6ACDSAbqCc5WuZxSd3HOfPXvMLr/c7KSTzBo2NPv++2ivEcJd3q6skD+2EgBw8AA9OMkRD/JGewUAAJkff+4jg567bN9udv75Zl984V1evdrslFPMbr/drH59yxVjDuPZsmXeKR3cASC2Mui//WbZhgAdAHLgFGs+AvT4tmOH2X33mb32mnde2fPdu80KFjQbPtzsyy/N3n7bbPDgaK8pwqls2WivAQDEvuLZFKDr+U8/3bINAToA5MAp1nyUuMevH34w69fvwKP2OigzapRZy5Zm551n1r692ciR+5sMxjN/fHY80xCXa6+N9loAQOwrnk0B+v33Z+/vLAJ0AIgBZNDh+/VXs7vvNvv4Y+9y5cpmzz5r1qyZV+JdoYKXQRdd7tvXWwAAyE2KZUMX9wULzJ5+2rIVAToAxMEY9Nmzc8cY5Nzg99/NkpO94PvSS82eeMKsZMlorxUAALkrgx4ImA0Y4FWoqcR9zBjLFgToAJCDM+gKygsUMEtKMlu8OCKrhijo3t3swQfNGjWK9poAABDbAfqkSWbXX3/gUKjQYVHp3ZbeeU1lOnGiV7X2yCME6ACQqxzuGHRl0JcsMVu6NCKrhShQCfuRR0Z7LQAAiG2VKnmnSlBEMkmhmVJq1LBsQ4AOADHgcDPoUqWKtwAAAOSmarOhQ1P34QmejjMc5zXtZf/+3kwq2YUAHQBy8Bh0AACA3KhAAbMbbsie18rOAD1P9r0UACASGXQAAADEBwJ0AMjBY9ABAAAQPwjQASAGkEEHAAAAAToAxADGoAMAAIAAHQBiACXuAAAAIEAHgBhAiTsAAAAI0AEgBhCgAwAAgAAdAKIsEGAMOgAAAAjQASDqkpLM9uzxzjMGHQAAIPciQAeAGClvFwJ0AACA3IsAHQBiJEAvXNgsMTHaawMAAIBoIUAHgChj/DkAAACEAB0Aoow50AEAACAE6AAQZUyxBgAAACFAB4AoI0AHAACAEKADQJQxBh0AAABCgA4AUcYYdAAAAAgBOgBEGSXuAAAAEAJ0AIgyAnQAAAAIAToAxMgYdErcAQAAcjcCdACIMjLoAAAAEAJ0AIgyAnQAAADEZID+/fff2xlnnGGVK1e2hIQE+/TTT1PdfvHFF7vrg5fOnTunus9///1nF1xwgRUvXtxKlixp/fr1s61+Dek+8+fPt1atWlnBggWtWrVqNmTIkGx5fwAQigAdAAAAMRmgb9u2zZo0aWLPP/98uvdRQL5q1aqU5b333kt1u4LzBQsW2Lhx42z06NEu6O/fv3/K7Zs3b7aOHTtajRo1bPbs2fb444/bfffdZ6+88kpE3xsApIUx6AAAAJC8sbYZTjvtNLccTIECBaxixYpp3rZo0SL7+uuvbdasWXbccce565599lnr0qWLPfHEEy4zP2LECNu1a5e98cYblj9/fjvqqKNs3rx59tRTT6UK5AEgO5BBBwAAQExm0DPiu+++s/Lly1u9evXsqquusvXr16fcNm3aNFfW7gfncuqpp1qePHlsxowZKfdp3bq1C859nTp1ssWLF9uGDRvSfd2kpCSXfQ9eACCrCNABAACQIwN0lbe/9dZb9u2339pjjz1mkyZNchn3vXv3uttXr17tgvdgefPmtdKlS7vb/PtUqFAh1X38y/590vLII49YiRIlUhaNXQeArKLEHQAAADFZ4n4o559/fsr5o48+2ho3bmx16tRxWfX27dtH9LXvuOMOu+mmm1IuK4NOkA4gqwjQAQAAkCMz6KFq165tZcuWtT/++MNd1tj0tWvXprrPnj17XGd3f9y6TtesWZPqPv7l9Ma2+2Pf1Rk+eAGArNi922zXLu98kSLRXhsAAABEU44P0P/++283Br1SpUrucosWLWzjxo2uO7tvwoQJlpycbM2bN0+5jzq779Yv433U8V1j2kuVKhWFdwEgt9q2bf95MugAAAC5W8wF6JqvXB3VtciyZcvc+RUrVrjbbrnlFps+fbotX77cjUM/88wz7YgjjnBN3qRBgwZunPrll19uM2fOtClTpti1117rSuPVwV169+7tGsRpfnRNxzZy5Eh7+umnU5WvA0B2BuiJiWZBfSsBAACQCyUEAoGAxRCNJW/Xrt0B1/ft29defPFF6969u82dO9dlyRVwaz7zBx98MFXTN5WzKyj/4osvXPf2s846y5555hkrGpSemj9/vl1zzTVuOjaVyA8YMMBuu+22TK2rxqCrWdymTZsodwdwWH77zaxePTP9Cdm0KdprAwAAgGjGfTEXoOckBOgAsmruXLNmzcw0SmflymivDQAAAKIZ98VciTsA5CZ0cAcAAICPAB0AYmAMOh3cAQAAQIAOAFFEgA4AAAAfAToAxECATok7AAAACNABIAbGoJNBBwAAAAE6AEQRJe4AAADwEaADQBQRoAMAAMBHgA4AUcQYdAAAAPgI0AEgihiDDgAAAB8BOgBEESXuAAAA8BGgA0AUEaADAADAR4AOAFHEGHQAAAD4CNABIIoYgw4AAAAfAToARBEl7gAAAPARoANAFBGgAwAAwEeADgAxUOLOGHQAAAAQoANAFJFBBwAAgI8AHQCiJBAgQAcAAMB+BOgAECW7dpnt3eudp8QdAAAABOgAEOXx50IGHQAAAAToABAlfnl7/vxmefNGe20AAAAQbQToABAljD8HAABAMAJ0AIhygM74cwAAAAgBOgBEeQw6GXQAAAAIAToARAkl7gAAAAhGgA4AUUKADgAAgGAE6AAQJYxBBwAAQDACdACIEsagAwAAIBgBOgBECSXuAAAACEaADgBRQoAOAACAYAToABAljEEHAABAMAJ0AIgSxqADAAAgGAE6AEQJJe4AAAAIRoAOAFFCiTsAAACCEaADQJRQ4g4AAIBgBOgAECWUuAMAACAYAToARAkBOgAAAIIRoANAlDAGHQAAAMEI0AEgShiDDgAAgGB57TDddNNNmX7M3XffbaVLlz7clwSAuEKJOwAAAIIlBAKBgB2GPHnyWIsWLSx//vwZuv8PP/xgixcvttq1a1u82Lx5s5UoUcI2bdpkxYsXj/bqAMhB9Jc3MdE7XbXKrGLFaK8RAAAAoh33HXYGXUaNGmXly5fP0H2LFSuWlZcCgLiyY4cXnAtj0AEAAJClMejDhw93RxEy6uWXX7YKFSqw1QEgaPy5FC4czTUBAABAji9xByXuAA7fsmVmGvFTqJDZ9u3RXhsAAADEQtwXkS7uS5cutQULFlhycnIknh4AcjwaxAEAACCsAfru3bvt3nvvtTPOOMMGDx5se/futV69elndunWtcePG1qhRI1u+fHlWXgIA4hJzoAMAACCsAfrtt99uL774olWsWNHeeOMN69mzp82dO9feffdde//99y1v3rx21113ZeUlACAuMQc6AAAAwtrF/aOPPrI333zTunTpYr/99pvVr1/fxowZY6eddpq7XR3eL7jggqy8BADEJUrcAQAAENYM+sqVK61Jkybu/JFHHmkFChSwI444IuV2Xbd69eqsvAQAxCVK3AEAABDWAF1jzvPly5dyWSXtiYmJ+588Tx6jSTwAHIgMOgAAAMLexf2bb76xzz//3C3q2v7tt9+mXNZtmfX999+7pnOVK1e2hIQE+/TTT1M1pbvtttvs6KOPtiJFirj79OnTx2Xyg9WsWdM9Nnh59NFHU91n/vz51qpVKytYsKBVq1bNhgwZkoWtAACZwxh0AAAAhHUMuvTt2zfV5SuuuCLVZQXHmbFt2zZXNn/ppZe6pnPBtm/fbnPmzLF77rnH3WfDhg12/fXXW7du3ezHH39Mdd8HHnjALr/88pTLxYoVSzWPXceOHe3UU0+1l156yX7++Wf3eiVLlrT+/ftnan0B4HCQQQcAAEBYA/RIzHOuBnN+k7lQmhx+3Lhxqa577rnn7IQTTrAVK1ZY9erVUwXk6i6flhEjRtiuXbtc5/n8+fPbUUcdZfPmzbOnnnqKAB1AtiBABwAAQNhL3KNt06ZNLkuv7HcwlbSXKVPGmjZtao8//rjt2bMn5bZp06ZZ69atXXDu69Spky1evNhl5dOTlJTksu/BCwAcju3bvVMCdAAAAIQlg67x4hmhYDgSdu7c6cak9+rVy4oXL55y/XXXXWfNmjWz0qVL29SpU+2OO+6wVatWuQy5qLN8rVq1Uj1XhQoVUm4rVapUmq/3yCOP2P333x+R9wIgdwbohQtHe00AAAAQFwF627ZtU8aYp9etXber23u4qWHcueee6173xRdfTHXbTTfdlHK+cePGLlOusfEKsDUV3OFSoB/83Mqgq8EcAGTWjh3eaaFC0V4TAAAAxEWArkyzxnpffPHFdtFFF1nZsmUtO/jB+Z9//mkTJkxIlT1PS/PmzV2J+/Lly61evXpubPqaNWtS3ce/nN64dVFwn5UAHwB8ZNABAAAQ1jHoKht/7LHH3JhuTX3Wr18/V1KugFkN3fwlEsH577//buPHj3fjzA9FDeA0J3v58uXd5RYtWrjyfD2XT83nFLynV94OAOFEgA4AAICwBugqHT/vvPPcfOe//vqrKye/9tprXdn3XXfdlaoxW0Zt3brVBdRaZNmyZe68urQroD777LPdlGrqxK7SeY0Z16Ku7KKDBcOGDbOffvrJli5d6u5344032oUXXpgSfPfu3dutuw4oLFiwwEaOHGlPP/10qvJ1AIgkStwBAAAQKiGQ3uDxw6SAWoHvpEmTbN26da5RW2Z899131q5duzTnW7/vvvsOaO7mmzhxohsTr3nSr776anfAQF3XdX+V3yv4Di5Pnz9/vl1zzTU2a9YsV5o/YMAA13AuMzQGXRUC6iR/qDJ7AAh2wglms2aZffGFWdeu0V4bAAAAxELcl6Ux6D4Fwh9//LGbV1wZ7NNPP93GjBmT6eBcFGQf7JjBoY4nqHv79OnTD/k6yvZPnjw50+sHAOFAiTsAAADCGqDPnDnThg8fbu+//77VrFnTLrnkEvvggw8OKzAHgNyEEncAAACENUA/8cQTrXr16m7e8WOPPdZd98MPPxxwv27dumXlZQAg7pBBBwAAQNhL3NW87cEHH0z39kjNgw4AORkBOgAAAMIaoCcnJ2fl4QCQa1HiDgAAgLBOswYAyLzdu71FyKADAAAgywH6559/7uYlz6gvv/zSdvgpIwDIxYL/FBKgAwAAIMsBeo8ePWzjxo0Zvv/5559vq1atOtyXA4C4C9ATEswKFIj22gAAACDHj0HXfOQXX3yxFcjgr8udO3ce7ksBQFw2iNP4cwXpAAAAQJYC9L59+2bq/hdccIEVL16crQ4g16ODOwAAAMIaoA8fPvxwHwoAuRod3AEAAJAWurgDQDYjgw4AAIC0EKADQDYjQAcAAEBaCNABIJtR4g4AAIC0EKADQDYjgw4AAIBsCdCZTg0ADo4AHQAAABEL0JOTk+3BBx+0KlWqWNGiRW3p0qXu+nvuucdef/31cLwEAMQNStwBAAAQsQD9oYcesjfffNOGDBli+fPnT7m+UaNG9tprr4XjJQAgbpBBBwAAQMQC9LfeesteeeUVu+CCCywxMTHl+iZNmtivv/4ajpcAgLgL0MmgAwAAIOwB+j///GNHHHFEmqXvu3fvDsdLAEDclbiTQQcAAEDYA/SGDRva5MmTD7j+o48+sqZNm4bjJQAgblDiDgAAgLTktTAYNGiQ9e3b12XSlTX/5JNPbPHixa70ffTo0eF4CQCIGzSJAwAAQMQy6GeeeaZ98cUXNn78eCtSpIgL2BctWuSu69ChQzheAgDiBhl0AAAARCyDLq1atbJx48aF6+kAIG4RoAMAACBiGXQAQMZR4g4AAICIZdBLlSplCQkJB1yv6woWLOg6vF988cV2ySWXhOPlACBHI4MOAACAiDaJGzx4sJ122ml2wgknuOtmzpxpX3/9tV1zzTW2bNkyu+qqq2zPnj12+eWXh+MlASDHIkAHAABAxAL0H374wR566CG78sorU13/8ssv29ixY+3jjz+2xo0b2zPPPEOADiDXo8QdAAAAERuD/s0339ipp556wPXt27d3t0mXLl1s6dKl4Xg5AMjRyKADAAAgYgF66dKl3ZRqoXSdbpNt27ZZsWLFwvFyAJCjEaADAAAgYiXu99xzjxtjPnHixJQx6LNmzbIvv/zSXnrpJXdZU7C1adMmHC8HADkaJe4AAABIS0IgEAhYGEyZMsWee+45W7x4sbtcr149GzBggJ100kkWrzZv3mwlSpSwTZs2WfHixaO9OgByAP3FzbOvdmn1arMKFaK9RgAAAIiVuC8sGXRp2bKlWwAA6du5c/95StwBAAAQkQDdt3PnTtu1a1eq68guA0Dq8nahxB0AAABhbxK3fft2u/baa618+fJWpEgRK1WqVKoFAJC6QVy+fGZ5w36IFAAAAJbbA/RbbrnFJkyYYC+++KIVKFDAXnvtNbv//vutcuXK9tZbb4XjJQAgLtDBHQAAAOkJS/5G06kpEG/btq1dcskl1qpVKzviiCOsRo0aNmLECLvgggvC8TIAkOPRwR0AAAARzaD/999/Vrt27ZTx5rosJ598sn3//ffheAkAiAtk0AEAABDRAF3B+bJly9z5+vXr2wcffJCSWS9ZsmQ4XgIA4gIBOgAAACIaoKus/aeffnLnb7/9dnv++eetYMGCduONN7rx6QAADyXuAAAAiOgYdAXivlNPPdV+/fVXmz17thuH3rhx43C8BADEBTLoAAAASE9EJvlRc7gSJUpQ3g4AIQjQAQAAENES98cee8xGjhyZcvncc8+1MmXKWJUqVVJK3wEAlLgDAAAgwgH6Sy+9ZNWqVXPnx40b55avvvrKTjvtNMagA0AQMugAAACIaIn76tWrUwL00aNHuwx6x44drWbNmta8efNwvAQAxAUCdAAAAEQ0g16qVCn766+/3Pmvv/7aNYqTQCBge/fuDcdLAEBcoMQdAAAAEc2g9+zZ03r37m1169a19evXu9J2mTt3ruvkDgDwkEEHAABARAP0oUOHunJ2ZdGHDBliRYsWddevWrXKrr766nC8BADEBQJ0AAAARDRAz5cvnw0cOPCg86MDAChxBwAAQIQD9Lfeeuugt/fp0yccLwMAOR4ZdAAAAEQ0QL/++utTXd69e7dt377d8ufPb4ULFyZAB4B9CNABAAAQ0S7uGzZsSLVs3brVFi9ebCeffLK99957mXqu77//3s444wyrXLmyJSQk2KeffprqdnWGHzRokFWqVMkKFSrkOsb//vvvqe7z33//2QUXXGDFixe3kiVLWr9+/dw6BZs/f761atXKChYs6KaI09h5AIg0StwBAAAQ0QA9Lero/uijjx6QXT+Ubdu2WZMmTez5559P83YF0s8884y99NJLNmPGDCtSpIh16tTJdu7cmXIfBecLFiywcePGuXnZFfT3798/5fbNmze7edpr1Khhs2fPtscff9zuu+8+e+WVV7LwjgHg0MigAwAAIKIl7uk+ed68tnLlykw9RlO0+dO0hVL2fNiwYXb33XfbmWeemTL+vUKFCi7Tfv7559uiRYvcXOyzZs2y4447zt3n2WeftS5dutgTTzzhMvMjRoywXbt22RtvvOHK8I866iibN2+ePfXUU6kCeQAINwJ0AAAARDRA//zzzw8IpDXF2nPPPWctW7a0cFm2bJmtXr3albX7SpQoYc2bN7dp06a5AF2nKmv3g3PR/fPkyeMy7j169HD3ad26tQvOfcrCP/bYY65Ev1SpUmm+flJSkluCM/EAkBmUuAMAACCiAXr37t1TXdbY8XLlytkpp5xiTz75pIWLgnNRxjyYLvu36bR8+fIHZPJLly6d6j61atU64Dn829IL0B955BG7//77w/Z+AOQ+ZNABAAAQ0QA9OTnZcoM77rjDbrrpplQZdDWYA4DMZtAJ0AEAAJBtTeIioWLFiu50zZo1qa7XZf82na5duzbV7Xv27HGd3YPvk9ZzBL9GWgoUKOA6wwcvAHA4GXRK3AEAAJCjA3SVpSuA/vbbb1NlsTW2vEWLFu6yTjdu3Oi6s/smTJjgsvwaq+7fR53dNV+7Tx3f69Wrl255OwBk1Z49Zv6fHTLoAAAAiPkAXfOVq6O6Fr8xnM6vWLHCjW2/4YYb7KGHHnKN6X7++Wfr06eP68zuj4Nv0KCBde7c2S6//HKbOXOmTZkyxa699lrXQE73k969e7sGcZofXdOxjRw50p5++ulU5esAEKnydiFABwAAQLZOs3Y4fvzxR2vXrl3KZT9o7tu3r7355pt26623urnSNR2aMuUnn3yym1atYMGCKY/RNGoKytu3b++6t5911llu7vTgzu9jx461a665xo499lgrW7asDRo0iCnWAGRLeXtCgobMRHttAAAAEGsSApoTDYdF5fUK9jdt2sR4dGSLsWPNPvhAUxlGe01wOLZu9T4/Zc+3bYv22gAAACDW4r6wZNBr1qxpl156qV188cVWvXr1cDwlgDRceaWGfUR7LZBVB+lFCQAAgFwsLAG6xoWr/PyBBx5w5eka292jRw/X9RxA+Kxb553ecosZ/Qxzrs6do70GAAAAiPsS9zlz5rhA/b333rO9e/e6ZmzKrDdr1sziESXuyE5795rl3XdITTMJlisX7TUCAAAA4t/mbIz7wtrFXYG4mrGtXLnS7r33Xnvttdfs+OOPt2OOOcbeeOMNY7g7kLXxy75ixaK5JgAAAABivou75hUfNWqUDR8+3M0rfuKJJ7py97///tvuvPNOGz9+vL377rvhfEkg19iyxTvNl48O4AAAAEA8yhuu0nYF5Spt17Rmmpt86NChVr9+/ZT7aEy6sukADs/mzd6pqmo0TRcAAACA+BKWAF2Bd4cOHezFF1+07t27Wz6l+ELUqlXLzj///HC8HGC5PUAHAAAAEH+yHKCrGZzGl3fr1s1KHaStdJEiRVyWHUDWAnTGnwMAAADxKctN4hITE+2KK66wjRs3hmeNAKSJDDoAAAAQ38LSxb1Ro0a2dOnScDwVgEM0iSNABwAAAOJTWAL0hx56yAYOHGijR4+2VatWuXnighcAWUcGHQAAAIhvYWkS16VLF3eqcegJQe2lNe+5LmucOoCsIUAHAAAA4ltYAvSJEyeG42kAHARN4gAAAID4FpYAvU2bNuF4GgAHwRh0AAAAIL6FJUAXdXF//fXXbdGiRe7yUUcdZZdeeqmVKFEiXC8B5GqUuAMAAADxLSxN4n788UerU6eODR061P777z+3PPXUU+66OXPmhOMlgFyPAB0AAACIb2HJoN94442uQdyrr75qefN6T7lnzx677LLL7IYbbrDvv/8+HC8D5GoE6AAAAEB8yxuuDHpwcO6eOG9eu/XWW+24444Lx0sAuR5N4gAAAID4FpYS9+LFi9uKFSsOuP6vv/6yYkQTQFjQJA4AAACIb2EJ0M877zzr16+fjRw50gXlWt5//31X4t6rV69wvASQ61HiDgAAAMS3sJS4P/HEE5aQkGB9+vRxY88lX758dtVVV9mjjz4ajpcAcj0CdAAAACC+JQQCgUC4nmz79u22ZMkSd14d3AsXLmzxbPPmzW4auU2bNrkyfyBSkpLMChb0zm/YYFayZLTXCAAAAMgdNmdj3Be2edBFAfnRRx8dzqcEEJQ9F9o6AAAAAPEpLAH6zp077dlnn7WJEyfa2rVrLTk5OdXtzIUOhKdBXJEiZomJ0V4bAAAAADEboKtB3NixY+3ss8+2E044wY1HBxA+jD8HAAAA4l9YAvTRo0fbl19+aS1btgzH0wEIQYAOAAAAxL+wTLNWpUoV5jsHsiFA52sGAAAAxK+wBOhPPvmk3Xbbbfbnn3+G4+kApDMGnQw6AAAAEL/CUuJ+3HHHuUZxtWvXdp3cNQd6sP/++y8cLwPkWpS4AwAAAPEvLAF6r1697J9//rGHH37YKlSoQJM4IMwI0AEAAID4F5YAferUqTZt2jRr0qRJOJ4OQAjGoAMAAADxLyxj0OvXr287duwIx1MBSAMZdAAAACD+hSVAf/TRR+3mm2+27777ztavX2+bN29OtQDIGprEAQAAAPEvLCXunTt3dqft27dPdX0gEHDj0ffu3RuOlwFyLTLoAAAAQPwLS4A+ceLEcDwNgHQQoAMAAADxLywBeps2bcLxNADSQZM4AAAAIP6FZQy6TJ482S688EI76aST3JRr8vbbb9sPP/wQrpcAci3GoAMAAADxLywB+scff2ydOnWyQoUK2Zw5cywpKcldv2nTJjc3OoCsocQdAAAAiH9hCdAfeughe+mll+zVV1+1fPnypVzfsmVLF7ADyBoCdAAAACD+hSVAX7x4sbVu3fqA60uUKGEbN24Mx0sAuVZyMiXuAAAAQG4QlgC9YsWK9scffxxwvcaf165dOxwvAeRa27ZpykLvPE3iAAAAgPgVlgD98ssvt+uvv95mzJjh5j1fuXKljRgxwgYOHGhXXXVVOF4CyLX87HliolmhQtFeGwAAAAAxPc3a7bffbsnJyda+fXvbvn27K3cvUKCAC9AHDBgQjpcAcq3g8ecJCdFeGwAAAACRkhAI+MWzWbdr1y5X6r5161Zr2LChFS1a1OLZ5s2b3Th7dasvzuBgRMjMmWbNm5vVqGG2fHm01wYAAADIXTZnY9wXlgy6L3/+/C4wBxD+DDrjzwEAAID4lqUA/dJLL83Q/d54442svAyQq9HBHQAAAMgdshSgv/nmm1ajRg1r2rSphbFSHkAQ5kAHAAAAcocsBejq0P7ee+/ZsmXL7JJLLrELL7zQSpcuHb61A0CADgAAAOQSWW4Sl5SUZJ988okrY586daqdfvrp1q9fP+vYsaObci2e0SQO4Zzr/PPPzd5912zWLLM9e8z27jVLTjbbuVMNGM0uu8zs1VejvaYAAACIKQrn9GNSWR2d6gdkcIjnn8+f36x2baYFivcmcZpOrVevXm75888/Xdn71VdfbXv27LEFCxbEfSd3IKvmzzdr1Wp/pjw9J56YXWsEAACAiFL2ZdMmr9mQFv0QDD7VsnVr6sW/LvgxWnSdgvKMOO00s48+MitcONLvELHQxT1Pnjwua66k/F6l/yKkZs2a7mBAKB0YeP75561t27Y2adKkVLddccUV9tJLL6VcXrFihSvRnzhxojuI0LdvX3vkkUcsb96wbhLgkCZO9P62li9v1r+/2RlnmOm4Vp48ZomJ3lKkiFmFCtFeUwBAzFOmbMcOs40bvR//OtV/Mrpu+3ZvCT6vMi2VbfmlW1qCzx/sdfzT0CX49tDzwY8JfR7/1H/9tNbJzwyGnh6qIDS91/PPp/e8ftCT1vtJ672HbodwU1A1cKB+9JIFjRbti8FBcmhw7S/+ZX0Hgxf/e6nvYbjpx6N+ROrHo/j7iH+q1/7qKy9IHz2aKYJiVJaj0eAS9x9++MG6du1qzz33nHXu3NkF7JEwa9asVAcAfvnlF+vQoYOdc845Kdddfvnl9sADD6RcLhx0lEiPVSl+xYoVXVn+qlWrrE+fPpYvXz57+OGHI7LOQHrWrfNOzz7b7MEHo702AICoU9CsH/AbNuxfQn/kp/ejX8vu3dF+B4ika681mzzZG/dGgJX5g1fpBdL6DoV+1/zLwZnucAfWysLoc9Si0mn/vALt4POhS4kS+x/jL4UKHfzAzZQpZl26mH3/vVmHDl6wXqpUeN9PvFq8OGcE6MpYv//++1atWjU35ZoaxpUtW9YirVy5cqkuP/roo1anTh1r06ZNqoBcAXhaxo4dawsXLrTx48dbhQoV7JhjjrEHH3zQbrvtNrvvvvvcfO5AdgfoIbs1ACAnUsZV2TX9oE9vCQ2oQwMCBehZpSSJfsCXLOn9iFcQoGSFfsAHnxYsaJYvn5dxUxVh8KmWg/3YD87OhS7Bt4eeD35M6PNI6HoEr4/elxbd1z8Nfd2MrG/oOqX1nMHn03s/ab33jK7P4Rg71uz2281GjjSbN88rVW7UyOKWDjYFZ6pDy7413jr0VN8tP+AOPQ1nha/iheDA2g+uQ8/rOxi8+N9Lnep2P9udHVq2NPv2W7NOncxmzDA75RRvn+JHaPr++cfs3ns1b7jliCZxypBXr17dTbN2sIZwyrBHyq5du6xy5cp200032Z133umuU4m7xr/rrSlIP+OMM+yee+5JyaIPGjTIPv/8c5unP2z7qBN97dq1bc6cOe79pFctoCW4WYAOTtAkDlnRs6fZqFFmzz/vVawBAGIkwF6/PvXy77/7zwdn1EKDh3DQ7yr9iFd2S4t/3v9xH/qDX4t/Py3KsFECHZ+mTjU791wvcNCBlpdfNrvoIosJ+p0cnJ0+2OIH1BpqodPg834JedDv7rDR9yI4Wx2cgQ7+vvmLLgcH3f6SkxN6P//sZdDXrDFr2NBs/HizSpWivVaxZeNGs8ceMxs2zB00VauoEm6UQIw3iVNZeLQ7tX/66ae2ceNGu/jii1Ou6927t5ufXYH7/PnzXWZ88eLFKQcKVq9e7TLnwfzLui09GqN+//33R+y9IHcigw4AYQ4OgjNmh1r8YME/r6AgHJSV9gNnf9GPutBAOjTQ9gMEBQARGiqIHO6kk8zmzjW78EIv+9mnj1fy/swzXkVERilHp0ZlfkAc2ogsvaZkaR2Y8r9Her5IKFAg7XJvVYaEngZ/14JP/fO6T27/bh19tJn6dbVvb7ZwoVnr1l5mvXr1aK9Z9KmCSVmzwYO9iia/8kBZ9I4dc8Y0a9HWqVMnV5L+xRdfpHufCRMmWPv27e2PP/5wpfD9+/d3Tea++eablPts377dihQpYl9++aWdpsYJaSCDjkioX98b1qJmcW3bRnttACDKVILqBwTB40OVtdYRzbVrvdPg8//9590nnNk2lVWXLm2moXtlyuw/9Rc/iE5vUaBEBhuR/q489JCZkkf6OX/MMWZ9+6Y/xlqnfqbaD8oj1dTZ/x6kNU7az0T7AbU//CL4fPD4ay064IXwW7bMC9J1quD8iSfCXxkQqVAzcJjPG9qkMvi8/k95/HF1E/eua9BAY6ldB+fNW7bknGnWoklBtsaRH6qEvnnz5u7UD9BV9j5z5sxU91mjEg+zdMet+1PKaQHCiQw6gFxDwcDff3s/BoOXpUv1n7pXUqjAIav04z40gxY87jOtzHbwouv0/z0BNmKZxi4rq6eMeu/e3pj0oOGbmaIAODRDHXo+vSX0OxTcRRyxrVYtr2GcgvTffvOGTsCsShUzNRtXdUoUZvjK0QH68OHDrXz58q4j+8H4Y80r7Rtb0aJFCxs8eLCtXbvWPV7GjRvnjoY01DgMIBtn6lDiRwjQAcTtUchPPzX7+GOvVCijJbB+wOBn25TN1v/Z+mOpJfi8bvODbd2X4AC5icYS67eupoLRUI30GpYFl4UHl4RrIUOde1Wt6gXpN93kHTCNhFg72JkQ0vzRP6//Ozp39mZKiOI88Tm2xD05Odlq1aplvXr1cl3cfUuWLLF3333XunTpYmXKlHFj0G+88UarWrVqytzommZNnds1Rn3IkCFu3PlFF11kl112WaamWVOJe3aVOiA+qXBDRRv6u6BGpfymBBAXVq3yul+qw7T+7/XnkhYFAjVqmNWu7WVvgheVjvtBBRVrAIAYkZ1xX47NoKu0fcWKFW56t2Aaj67bhg0bZtu2bXNjxM866yy7++67U+6TmJhoo0ePtquuuspl0zX2vG/fvqnmTQeys7xdyR+CcwAxRcfvNUZVzVP9RUcVdarrFXQHL7q/Tn/91ZtrN/j4f7NmZmefbda9u9mRR/IHDwCAeMugxwIy6MgqVXtqCko1ilu0KNprAyDXU/faESPMXnzR6+y7Y8fhP9eJJ5qddZa3KDsOAEAOtZkMOpA70CAOQExQVvyFF8xeemn/HyafxqlqLE7w4jeB0lRFoYtKgtQbplq1aL0bAAByLAJ0IIoI0AFElRpLDRtm9t57+5u3aaqdAQO8cnQ1V1UDKQAAkC0I0IEoIkAHEBVLlpj17282YcL+61q0MLvxRrMePaIyrQwAACBAB6KKAB1Atps+3axbN+8PkMrUzznH7IYbzJo3j/aaAQCQ6xGgA1FEgA4gW2nqs969vWZw6qyuuclr1oz2WgEAgH3y+GcAZD8CdADZRmPN1VFdwbmauGl+coJzAABiCgE6EEUE6AAibu9es+uv98aXa2bVq64y+/RTrxM7AACIKZS4A1FEgA4gorZv90raP/vMuzxkiNnAgWYJCdFeMwAAkAYCdCBKkpPN1q/3zhOgAwi7tWvNunY1mzXLrEABs7feMjv33GivFQAAOAgCdCBKNmzwKk+lbNlorw2AuKJS9gsu8ILzMmW8DHrLltFeKwAAcAgE6ECUy9tLlDDLnz/aawMgrihbPn68WcGCXjO4o46K9hoBAIAMoEkcECWMPwcQEWvWeA3h5L77CM4BAMhBCNCBKCFABxARN9zgjaE55hizm26K9toAAIBMIEAHooQAHUDYjR5t9v77ZnnymL32mlm+fNFeIwAAkAkE6ECUEKADCKstW7w5zkWZ82OPjfYaAQCATCJAB6KEAB1AWN15p9nff5vVrm12//3RXhsAAHAYCNCBKCFABxA2U6eaPf+8d/7ll80KF472GgEAgMNAgA5Eydq13ikBOoAsSUoyu+wyb+7zSy4xO/XUaK8RAAA4TAToQJSQQQcQFo8+arZokVn58mZPPBHttQEAAFlAgA5ECQE6gCxbuNBs8GDv/LPPmpUuHe01AgAAWUCADkSBKlH//dc7T4AO4LD89ZfZOeeY7d5tdsYZ3nkAAJCjEaADUfDbb95v6gIFzCpWjPbaAMhx5s83a9HCy6BXqmT2wgtmCQnRXisAAJBFBOhAFEye7J02b26WP3+01wZAjjJunNnJJ5v9849Zw4Zm06aZVa0a7bUCAABhQIAORDFA129sAMiw//3PrEsXsy1bzNq0MfvhB7MaNaK9VgAAIEwI0IEoBuitWkV7TQDkmMYVDz5odvHFZnv2mPXqZfbNN2alSkV7zQAAQBgRoAPZTFWpy5aZ5cljdtJJ0V4bADFPDSv69zcbNMi7fNttZu+84zWxAAAAcSVvtFcAyG1UkSpNmpgVLx7ttQEQ0376yezGG80mTvSO6mkqtauvjvZaAQCACCFAB7IZ5e0ADunXX83uvdfsgw+8y4UKmb3/vlm3btFeMwAAEEGUuAPZjAZxANK1dKk3zvyoo/YH5+efbzZvHsE5AAC5ABl0IBtt3Gj288/eeTLoQA6RnGy2d6/XnE2nWoKbtwXzL+s0+HxG/jg8+aTZa695ryMKyNUYrnHjsL0VAAAQ2wjQgWw0dar3W/2II8wqVoz22gA4wOzZXkO2hQv3B+UZCbDDqWNHLzA/4YTsfV0AABB1lLgDUWgQR/YciMEsuTLYLVqYzZljtnOn1z09O4Pz1q3NJk3ypk8jOAcAIFcigw5ko0WLvNNmzaK9JgBSrF5t1rev2dix3uUePcwefdSsSBGzxESzvHm9U/+8uqknJOx/fPD54Ms6DT5/KHpeAACQqxGgA9no77+90+rVo70mAJyvvvKasq1da1awoNmwYV6Je0YCagAAgDAjQAey0T//eKdVqkR7TYBcLinJ7PbbvYBcjj7a7L33vO7pAAAAUUKADmQTDWdVJa1UrRrttQFysQ0bzNq3N5s717t87bVmjz/uZdABAACiiAAdyCarVnn9pvLlMytXLtprA+RiL77oBedlypgNH252xhnRXiMAAACHjjRANo8/r1yZXlBA1Ogo2YgR3vnHHiM4BwAAMYUMOpDN488pbweiaP58b47z/PnNzjor2msDAMBBBQIB27lnp23dtdW27NriTrXs2L3DduzZYdt3b085r1Nd3pO856DP2apGKzul1inZ9h6QOQToQDZn0AnQgSjys+ddu5qVLBnttQEAxGFArSA5OKDekrTloOfd4p9P2ndb0H32BvaGfT0fPuVhu/3k2y2BWUtiDgE6kM0BOh3cgShJTvY6tcsFF0R7bYCI25u812XekvYmWdKeJEsOJKfcFrDAAUFF8PUHu3yw8wc7PRjdR0GI1jF00fvQbcoK+svuvbtTXdbteg7/MXq94OcIXpe01veg67bvPv7z+o/zn7daiWp2UeOLLF9ivkx+QogF+hz9QHhz0ma3BAfK23ZvS8lab9u17/zuoOA65FS3B3/XwqlwvsJWLH8xK5K/iBXKW8hdLpSvkDvvn+q6fHnS3xdXb1ttn/76qd054U5bsWmFPdvlWcubh5AwlvBpANmEEncgyr7/3jtSVqKEWZcu0V4bxDkFjRt3brT/dvxnG3ZssA07N7hTXbcpaZNt2rnJO913Xtf7P+xDg0s/EPRvk+Cg1z+v11Qg7gfkkci6IW3Pz3re3jzzTTu6wtHRXpW4p++BMtRpZqKDss+pzqeTvfaD8Ugpmr+oC6jdaYFiqS/nL+auO9hp8OOK5CtiiXkSw7JeT09/2m785kZ7afZL9s+Wf+y9s95zQT9iAwE6kE0ocQdipLz97LOZUg0HpUBXP9xdML0vkPbP+xm2lGXX/vN+oK2gPJI/+g9HgiUckCULLW3VfYKvP5zLOn+w03TXLyHBEhMSLU9CnpRFwYh/XuseuihLqFPdL/ixeq6U8/teO/h88HpnZN0k9PH+qQ6MfLzoY5uzao4d+8qxNqjNILut5W1xn03XQaHdybtddUO697GAO1DkxkjvGysdvCgbnWZ2el+G2j8fWvKt+x2qIuNwaB8qXqC4WxQU61RBsYLj0EXXBwfcaQXWCni138Si60+83qoWr2oXjrrQvvjtCzvlrVPsi15fWPki5aO9atDfpsCh6nqQrs2bN1uJEiVs06ZNVrx48WivDmJczZpmf/5pNnWqWYsW0V4bIJdJSjKrWNFs40azCRPM2rWL9hohG5oquaA5KXVQrSy2Auj1O9annK7fvv+8blfQEC76kV+qYCkrVaiUOy1ZsKSVKFjCShTYtxQs4V1XoIT7UR8clAYHmX7g6QeHEnpewWqBvAWsQGKBVKcF8xakhDWCVm9dbVeOvtI+W/yZu9ysUjP7X/f/WaPyjSyWx0jrYJIqO/7d/m+qRd+Hf3d453XQKbj5mH9ep5Eq484o7fOhmeYDss/7LqeXyfYDci36nuS28dhTVkyxbu93c3//6pSqY19d8JXVLVM32qtluT3uI0DPAgJ0ZGboqxJ2u3d7QXr16tFeIyCXGTXKrGdPrwnEihXMdRijNK7Yz1z7JeHBpeE6r1MF0H4GLiUbt+86Zdj0HIfqYpwRGs+ZKqDeF0wXz7//R33o4gfiOtV9CYxzB/2cfvfnd23AVwPcfqrs/r1t7rXbTr7tsPcBPaf2az8g1kEnnXenQZf9LHRwRto/r6yzX9nhLzpoFY7vR2Yy08oma2y0v/hjpYMz0gdkqfMXSb88vEAx9xy5LaCOhMX/LrbOIzrb8o3LrWzhsi6TfmLVE6O9WjGHAD2HIEBHRq1Z4yXv9P+IEnn54rvyDYg9Kmv/+GOzgQPNHn882msTN/QTwi9dDQ6W/SDZH9/pToPGe/qZbb9k3D+v54pEhk3BtR9AK8guU6iMW0oXKu2WMoW987pOQbUflOdPzB/W9UH8W7VllV055kr7fPHn7vKxlY61m1vcbLv27ko7kFYQHdJkzP++6PZIlHL7dOBA+7qCMi3a//3z/mXdnl4jMp0/1MEHVXHEe7l/vFSBdH23q81eNdt9vmfWPzNi5flZCT0DWfw+hDa/DF2fgz3/7u277bOLPyNAj3UE6Mio2bPNjjvOrFIls5Uro702QC6zaZNZhQre0bG5c82OOSbaaxQTVJ6qbFpoeasWN4ZaAUIa40BTxovuy1hHgrJpCgyCs9F+ebgWP+PmZ+P87Jx/nYJrBeO6X6yOAUX80k/rET+PsOu+us5l08NBB4v8AFml2DqvUy1+tjk4E61T/zr/e+MPpfDP67tCBho+/V0/76Pz7Mvfv4z2qsSmnWb2qGVL3EfdFZCNHdyZYg2IAmXOFZw3aGDWpInFM2XmlAnRsnbb2tTL9v3n121b58Zbh3MMqTJlwYFycNm3a7iU3ztViaofQPuZ7eDLug+Za+RkCnovbHyhta/V3k1lteS/Je67kVbw7F/nf0/SajimoJwDTYg07Yefnf+ZfbjgQ/d/SCRl5cBQwiEaOmb0tQ/V9DLUjq07bOCjAy07EKAD2YAO7kAMdG/X3Oc5OFukEvAlG5a4H/tLNyx1U+P4wfiqravcqTIgmaUAILisVYvKvf0MdPC4T3/spx9gBGexwzX9DxAvKhWrZMPPHB7t1QAyTEMWeh3dK9qrEbOV0wONAB2IGwToQJRoTMnEid753r0tJ9BYVZUYatomPyD/478/XMY7IxQsVyxa0SoUqeCmzNFSrnC5lPPucpFy7jqNvSZbDQBA7MiRAfp9991n999/f6rr6tWrZ7/++qs7v3PnTrv55pvt/ffft6SkJOvUqZO98MILVkFjEPdZsWKFXXXVVTZx4kQrWrSo9e3b1x555BHLmzdHbhLkkBJ3AnQgm73/vgaEmp10klmtWhbLfl//u7025zUbPm+4rdu+Ls37KLjWVDh1StexasWruUBcS6WilVLOK8vNuFIAAHKmHBuNHnXUUTZ+/PiUy8GB9Y033mhjxoyxDz/80DVxu/baa61nz542ZcoUd/vevXvt9NNPt4oVK9rUqVNt1apV1qdPH8uXL589/PDDUXk/yB0ZdMagA1Esb49BSXuSbNSvo+yV2a/YxOUT95fGFq1kp9c93c1H6wfkOlV5OQAAiF85NkBXQK4AO5Q6673++uv27rvv2imnnOKuGz58uDVo0MCmT59uJ554oo0dO9YWLlzoAnxl1Y855hh78MEH7bbbbnPZ+fz5KfdDeFHiDkSBqqrmzNF/GGbnnmuxMs+3xo7/ufFP++K3L+zNeW+mlK6rQc1pdU+zy5td7oJzpiYCACD3ybEB+u+//26VK1e2ggULWosWLVx5evXq1W327Nm2e/duO/XUU1PuW79+fXfbtGnTXICu06OPPjpVybvK4FXyvmDBAmvatGmU3hXikaprKXEHopg979TJrGzZiHRM15zFOvWnHQue31hTlf216S9bsXmFrdjkLZojOXSe1SrFqli/pv3s0qaXWo2SNcK+ngAAIOfIkQF68+bN7c0333TjzlWervHorVq1sl9++cVWr17tMuAlS5ZM9RgF47pNdBocnPu3+7elR+PZtQR38wMyMgXztm3eeUrcgWw8Mvbuu2Etb9ec4d8t/86+XfqtfbvsW1v076LDeh41ZdP48cYVGrugvPMRnV3nXAAAgBz5i+C0005LOd+4cWMXsNeoUcM++OADK1SoUMReV1n60OZ0wKEsX+6dli5tFsHdE0CwcePMli41K1LErFu3w3qKHbt32NS/prpgXMuPK388YN5wlaX7042lmuc4fxE3p3f1EtXdooDcP68O6sxpDAAA4iZAD6Vs+ZFHHml//PGHdejQwXbt2mUbN25MlUVfs2ZNyph1nc6cOTPVc+h2/7b03HHHHXbTTTelyqBXq1YtAu8I8WLZMrPzz/fOH3VUtNcGiGN795pNm2b2xRdmn3/ujT+XHj28ID0TU5x99ftXNuLnEW6M+M49O1PdfmSZI619rfZuaV2jtZsznI7pAAAgXOIiQN+6dastWbLELrroIjv22GNdN/Zvv/3WzjrrLHf74sWL3bRqGqsuOh08eLCtXbvWypcv764bN26cFS9e3Bo2bJju6xQoUMAtQEaqa7/7zqxXLx38Mate3ezll6O9VkCc2bLFbOxYLyD/8kuzf//df5saw7VrZzZo0CGfRlnxKSumuKD8gwUf2IadG1Juq1ysckpA3r52e6tanEYSAAAgcnJkgD5w4EA744wzXFn7ypUr7d5777XExETr1auXm1atX79+LtNdunRpF3QPGDDABeVqECcdO3Z0gbgC+iFDhrhx53fffbddc801BODIkg0bzIYO9XpTqbpWmjTxYofKlaO9dkCcjBlRlnz0aO8o2K5d+28rVcqsSxevpF2N4UqUOGhQ/svaX+z9X963d39+1/7c9GeqKc56NeplFzS+wJpWbEqGHAAAZJscGaD//fffLhhfv369lStXzk4++WQ3hZrOy9ChQy1Pnjwug66mburQ/sILL6Q8XsH86NGjXdd2Be5FihSxvn372gMPPBDFd4WcTrM5qWjDH3NeuLDZeeeZDRtmVrx4tNcOyMGl6xqSpKBcyy+/pL79iCPMzjzT7IwzzFq29DLnadi+e7vN+meWTflrihtXriU4U14sfzE7q+FZduHRF1rbmm0tMU9ipN8ZAADAARICARXj4nBoDLoy9pp7XZl65C5K3K1fb7ZkiTf09Z571OnfrHZtswcf9GKGTAx9BXIHfUlUmr51q3fqLxoLsnKlNyehTv3zq1aZ7dnjHronj9mOAnls+0kn2PaO7WxH25a2o2pFS9qb5MaOJ+1Jcud1qssaP64suYLyuavn2p5k73l8hfIWsg51OrigvOuRXa1QPro4AgCA6MZ9OTKDDkTDunVmzzxj9vrr3vl9MUMqXbuavfWWV2kLxKXt272gOXhRMK1TfTF27PCC8J079y+6rOsVlO/ebesKm82sYjajqtmismY78pklJZol5d13Wt4sqZJZUnOznXm927fnz2O78qiDupbpZjumm32VuVXXePKW1Vq65aRqJ9kxFY+xfIn5IrWlAAAAMo0AHUiHakt+/tls+nSzqVPNPvjAizGC5cnjNYBTla0qbK+91rsOiKsSc30J1IgtuDt6Bu3Iaza3ktmMevuD8mWHdQAr+YDsd+F8ha1g3oJWIG8BN7d4gcQC7rxO3eW8BaxGiRpeUF69pTvPeHIAABDLCNCBNCgR2Lev2VchGbpjjzW7/XbNBOCNMS9a1CwfCTjEm23b9ndHVzO24O7oUqiQ1/WwUiVv8c+XL29r8u+yKXuW2Q87f7Mp2xbZnK2/257A3gNeon7Z+ta8SnOXxdb4bz+w9k/9wFvnFYj7i8rQdRvziAMAgHhEgA6E+P57s969veGvauqvvlPNm5t16GDWtq0ZCTjEBZWd//WX2Z9/pl6WLTObMcO73VeypNcdXY0V2rc3K13afRH2Ju+1xesXuynKNM77hxWv2pINSw54qQpFKljzqs1dQH5ClRPs+MrHW4mC6XdYBwAAyK0I0AEz+/Zbs/feM5swwYtPpH59sw8/NGvUKNprB4RhvIZK0ydN8o5ATZniBecH6xFaq5YXkGvKspNPtuS8ifbHf3/Y7JVj7ccff7QfV/1oc1bNsa27tqZ6WIIlWKPyjezk6idTWg4AAJBJBOjI1f74w+ymm7zZm3yapenCC82efdYrYQdynORkr4GCH5Br0biNUCpVr1HjwOWYY2xznao25a+pNunPb2zmuw/a7FWzbXPS5gOfIm8hlxX3A/IW1VpYyYIls+d9AgAAxBkCdORKmtVp8GCzoUO96dIUlF92WUqy0IoVi/YaApmgTLiONqkURMvEid4cgMEKFvSaJ7RpY9aqldnRR5uVLZsyZkPB9w8rfrDvln9n30192mZ/PNuSA6kbs2nst8aMH1vpWDuu8nFu0VjyvHn4rwQAACAc+FWFXEXB+IgRZnfeabZ6tXdd585eoK6SdiDHUJMEjcnQoqBcJevBihTxjjYpIG/d2uy447ymCma2cedGW7huoS2Y86ktWLfApv411WXIQwPy2qVqW9sabV1WXOPGG5ZryLRkAAAAEUSAjlxBTahVsv7yy2Zr1njXaWo0Beann07jN+QA2nG/+87Ljmv57bfUt+fP72XI1cRNy/HHu3Hj81bPsx9X/mgLJ37ognEF5iu3rEzzJeqUqmNta7Z1S5sabaxaiWrZ894AAADgEKAj7qnpW7t2XoNq0YxQN95oNmBASkIRiD3//eeNIfez5AsXpr49Tx6zZs32B+SabqBwYVu6YamNXzrexn86zCYsm2Drd4SUuu9TrXg1lxE/qtxR1rRSUxeUVy1eNXveGwAAANJEgI64s3Wr2apVZrVrmy1fbnbKKWYrVniXH3nErEcP5i5HjM49/sMPXrm6AvI5cw7sst6kiXe06ZRTbE/LFvZfgWRbt22dy4qP//ZGG79svAvQg2mOcZWoNyrXyI4qf5QLyrUUL1A8e98fAAAADokAHXFFcU337l4TOA3BVfO3TZvM6tXzblP2HIhKNlwl6hs3HrjoNs07Pn262e7dqR62umld+/KUqja1eh5bWyKv/btns/27fYz9u/B/tmHOhjRfSg3bWlRtYafWPtUtGjvOuHEAAICcgQAdceOTT8x69fIawan6VwlJadDAC84rVoz2GiJXUfZbO96wYWZjxhx8zvF9kqtXsx9Pa2JjGuazMYlLbPa/883sdzPF4mnH41a6UGlXrt6uZjvrUKeDta7R2ormZ35AAACAnIgAHXFh5Eiz3r296Z979jR7+21vzPnixWZt25qVZFpmZJcdO7ypAp5+2uyXX/ZfX7q0tyOGLEklitjoGkk2uvS/9uWaH2ztttGpgnFNZdaxdkerUbKGlS1cNmUpV7iclSpUiinOAAAA4gi/7JDjqXL4yiu94LxfP69Te2KilznXAmTbtGcvvODtgP4c5BpnccklXkfCI49MdXfNO/7K7Fds6PShtnLjSrON+8eMd6zT0U6ve7qdVvc0q1iU0g8AAIDcggAdOd7Agd5QXjW0fuklLzgHss0ff5g9/LBXtrFnj3ddjRpm111ndumlB5RvrNm6xp6e8bS9MOsF25S0yV1XuVhlO++o86zrkV3t5OonW/7E/NF4JwAAAIgyAnTkaBri+8473jzmCs7VFA7IFpqHfPBgr5x9717vulatzG64waxbtwN2xiX/LbEnpj5hw+cNt6S9Se66emXq2a0tb7ULjr7ACuRlzj8AAIDcjnAGOXo6tauu8s5ffbXZ8cdHe42QKyxa5AXm773njauQLl3M7rnH7MQTU+62a+8um79mvs36Z5ab/uzTXz+15IB3/xOrnmi3tbzNutXrZnkS8kTrnQAAACDGEKAjR1LvrXPO8ZKY6s6ueAmICHVfX73a7KefzP73P68jod+R/YwzXGCefNyx9tv632zWT2/bzH9m2qyVs2zu6rkuSA/WpW4XF5i3qt7KElT2AQAAAAQhQEeOo8SlmsGpWbbmNdf0aiVKRHutEBeSksx+/tls/nxv8c//+2/q+3Xv7gLzQNOm9u7P79qtQ7vbyi0r05wC7YQqJ7i5yM9ueLY1rtA4+94LAAAAchwCdOS4zHnfvma7d5t17OiNPy9XLtprhbgwbpy3c61adeBtefJ4XdibNze78UazJk3s9/W/29XvdLTxS8e7uxTKW8iaVWrmAnI/KK9dqjaZcgAAAGQYATpyDDXIVlNsBeeqLP70Uy9uArJEO9Tdd5sNGbJ/vvKmTc2OPtqscWNvadjQrFAhd3PSniQbMulBGzx5sGv2ViCxgN3T+h4beNJAGr0BAAAgSwjQkWMMG2Y2a5ZXzq6O7QTnyLIlS8x69fJ2LLnySrMnnzQrXDjNu09aPsmuHHOl/frvr+5yh9od7IXTX7AjSh+RnWsNAACAOEWAjhzh99+9Jtny1FPe2HMgSzQ9mqYB2LLFm6v89dfNevZM867/bv/Xbh13q5siTcoXKW/DOg2z8xudTwk7AAAAwoYAHTFv506z88/3Tjt0MLvkkmivEXI0BeTXXmv21lv75y5XM4Pq1Q+469INS+3ZGc/aG/PesM1Jm911Vxx7hT3S/hErVahUdq85AAAA4hwBOmLe9debzZljVqaMl+QkYYnD8scfZh98YPbqq2bLl3tjJAYNMrvrLrO8+/8UBgIBm7Bsgj0z8xn7YvEXFjBvSjV1YH/x9BftpGonRfFNAAAAIJ4RoCOmKcn5yiteUP7uu2bVqkV7jZCjLFvmBeVadJTHpx1JJe7Knu+zffd2GzF/hAvMf1n7S8r1nY/obNc3v9461uloeRJofAAAAIDIIUBHTEpONnvhBbNbbvEu33uvN60acFCBgNmiRWZffeUF5TNn7r8tMdHslFPMzjvP7JxzzIoXt382/2OTV0y27//83kYuGGn/7fjP3bVIviLWt0lfG9B8gNUvWz967wcAAAC5CgE6Ys5vv3m9uyZM8C537+7NggWkaelSb2fxlzVr9t+mMva2bc3OPdcCPXrY74kbXTA+ecIAm/znZFu2cVmqp6pZsqYNOGGAXdr0UitZsGT2vxcAAADkagToiAl795qNGuVNn/btt951mnZaU1NffTVTqmHffOV//um19Nd48nnzvIBc48n30Wjx9aUL2tI2jW3ZyY1sWYOKtnTPOlu28SP7+a17bc22oOBd8XtCHmtSoYm1qt7KOtTpYKcdcZol5kmMwpsDAAAACNARA37+2ax/f7Pp073LGm9+2mnevOd160Z77ZBtdu0yW7XK7J9/zP7+21sUfPsBuc7v2WPJCWb/FDP7o/S+5cgE+71OKVtSPp8tzbvZtu7dYWYzzbbMdCfBCiQWsBOqnOAC8lY1WrmGb8ULFI/WOwYAAABSIUBHVIYJq4x91iyzyZPN3njDxV1WrJjZddeZXXaZWc2a0V5LRHQHWLzY7LvvzCZN8gJwBeNr13q3+Xczs3+Km82pZDa3itm8Y81+L5tgS0qb7Uzcfz/vnt7YcdvrnVQuVtlqlaxltUvVdqe1StWyI8scac0qNbOCeQtm8xsGAAAAMoYAHdlm2jSvb9cnn5itWJH6th49zJ591qxKlWitHSJGQbeCcAXkEyd6p6tXp7rLtnxmf5Uxm1850ebULWpzKyfYnBI77N+8SaFP5v7NmyevC7yPKH2E1S1d153WKV3H6pSqYzVK1iAIBwAAQI5EgI6IU8WyMuMKzH0FC5o1a2Z23HFmXbqYdeoUzTVElmzfbvbDD155urLg/qJmbTr9+2/b++86m1XF7NeyZn8fafZX8zz2d/WS9leZfPZ34jbbsHer7U+Bb0p56sSERGtYrqE1rdTUmlZsag3KNnDBuIJwBekAAABAPOEXLiJq+HCz668327LFm+WqVy+zs8/2pkxTEzjk4Kz47Nlmr7/uTVC/efMBd9lQ0OybI8zGnGz2VV2z9YWDb00+oCy9WP5i1qBcAxeIqxRdp43KN7JC+dhRAAAAkDsQoCNiRowwu/RS7/yJJ5q9/LJZ48bRXitkyfr13gerwHz+/P3XV6tmgYYN7NcqBW1M+Y02uvDf9kPyctvrAnGPpi07vvLxVq14NatWoppVLV7VnXenJarRrA0AAAC5HgE6IkJTpV1yiXdeGfSnnmKqtBxr3TqvmdtHH3lz4anbuhQoYOvPPt0mnHGUjSu0ysYtG2/LN+6b8mxfXK7y9NPrnm5dj+zqOqZTlg4AAACkj1/LCLupU8169vSmrT73XILzHOfff72A3G/qtmBByk1JiWZTTq1j4zvUtnHF/rXZa0dZ4Nf9zQXyJ+a3djXbuYBcgbm6pwMAAADIGAJ0hM22bWZ332329NPeEOXWrc3+9z+C85inOe7U5O3zz83Gj/cmpt9nV6LZj9XMvmtewSbVK2CTC6yxHclLzHZo8e5zVLmjrEPtDtahTgdrXaO1Fc1fNHrvBQAAAMjBCNARFprXXN3YlyzxLvfpY/bMM163dsSgrVvNxo41++wzs9Gjzf77LyUgn+UC8vI26cgCNqXAWtse0FRna7zHJZtVLFrRC8hrd7BTa59qlYpViu57AQAAAOIEATqyTM28O3f2KqOrVTN75RXvMmLMsmVm48btz5QneXOMLy9pNqZtYfvyhFL2XZF/9wXka73HBMzKFi5rbWq0sbY127pFGfOEhITovhcAAAAgDhGgI0vGjDE7/3wvIat5zb/6yqx8+WivFRwdMZkwwevYp4B86VJ39e48ZlOqm405voR9WT/RFiYqe77dW/YF5C4Yr+EF5Jr6LE8C4xQAAACASCNAx2H5/Xezm282++IL73K7dmaffmpWnJmyokfd1adM8Y6SKCCfO9ddHdDnVcZs4gl5bPyxpWxsha222ZQl3+RuT0xItJbVW1qXI7pYl7pd3NzjZMgBAACA7EeAjkz3E3vsMbP77/e6tOfNa3bttWaPPMJ486hYudILyL/80itf37LFBeR/lDb7rpnZxGNK2HdV99iqPNv2zX223j1MWfLTjjjNdVrvWKejlSpUKtrvBAAAAMj1CNCRYYsWmfXtazZrlndZ48yHDjWrXz/aa5ZLqDX+33+bzZ9vNm2aF5TPnWsbCprNq2g27yiz2bUL2He1E+2fvCpZt5QsuaY/a1G1hZsCrfMRne24ysdZYp7EqL4dAAAAAKkRoOOQ1OD7wQfNnn/ey5qXLGn23HNmvXubUQkdIWrg9tNP3qKAfN/yz96NNruy2VwF5EeazW1j9mfJVA90/+bLk89OrHqiC8g1jlznC+UrFK13AwAAACADCNBxUGr4ffHFZhs2eJe7djV76SWzKlWivWZxSEc/1NTt/ffNPvnEbPNmV66+qJzZJw3MRp1rNqdy2g+tWbKmNa3Y1I6peIy1rNbSWlRrYYXzFc7udwAAAAAgCwjQkS5VUZ97rpfMbdTI7MknzTp2jPZaxZnkZLMffvCC8g8/dJ3XkxPMZlU2G9WmkI1qmGC/FfLL1c11U1cTNz8Y12mTik2sZMFUaXQAAAAAORABOtK0ZIlZt25ecH7GGV5CVw3hECYLFpgNH+4F5v/8465aVNbs5R6F7KNGeeyfRDV125EyfrxD7Q7Wo34P61avm5UrUi7KKw8AAAAgEgi5cIAVK8xOP92bRltzm7/7LsF5WGzaZDZypNnrr5vNnOmu2pPH7Itmhe35jiXs24KrUoLyYvmLuSnPejbo6bqtFytQLMorDwAAACDS8lgO9Mgjj9jxxx9vxYoVs/Lly1v37t1t8eLFqe7Ttm1bN5dz8HLllVemus+KFSvs9NNPt8KFC7vnueWWW2yP5hHLxb7+2gvKtTmrVvXmOS9aNNprlcNL2L/7zqxPH7NKlcyuuMIF52uLJ9rDVzS02g+WtZ7dtrvgXOXr3et3t9G9Rtu6W9bZ+2e/b+cedS7BOQAAAJBL5Mi86KRJk+yaa65xQboC6jvvvNM6duxoCxcutCJFiqTc7/LLL7cHHngg5bICcd/evXtdcF6xYkWbOnWqrVq1yvr06WP58uWzhx9+2HKjRx81u/NObzavY4/1hkRXTqcpGQ5B5QcqYX/5ZW+8gGZJM7MZJ9e05zuXsQ+Sf7ZdyQvNdntzkl/W9DK78rgrrUbJGtFecwAAAABRkhAIKBzL2datW+cy4ArcW7dunZJBP+aYY2zYsGFpPuarr76yrl272sqVK61ChQruupdeesluu+0293z58+c/5Otu3rzZSpQoYZs2bbLixYtbTqZY8tJLvfNXXWX21FNmBQtGe61yGH2VVLr+wgteKbsG8JvZ1tJF7d0+Te3Famts3pbfUu5+QpUT7Jrjr3FZ8oJ52dgAAABALMrOuC9HlriH0oaS0qVLp7p+xIgRVrZsWWvUqJHdcccdtn37/m7Y06ZNs6OPPjolOJdOnTq5jb9ADbxykUmTvMpruftuL74kOM8E7VdvvGF2/PFmJ55o9tZbLjhf0KaBXfvEKVZ5YIJdUXKyC84LJBawPk362IzLZrhF5wnOAQAAAOTYEvdgycnJdsMNN1jLli1dIO7r3bu31ahRwypXrmzz5893mXGNU/9E7cjNbPXq1amCc/Ev67a0JCUlucWnYD6n07GInj29KbjPOcfs/vujvUY5hDqvjxvnLV9+abZxo7t6R5H89mmf5vZi/S02ecM8s62L3PVHlD7Crjz2Srv4mIutTOEyUV55AAAAALEoxwfoGov+yy+/2A+aSzpI//79U84rU16pUiVr3769LVmyxOrUqXPYzenuj5MIVtXYaiZ+3XVmO3Z4yd833zTLExc1FRGwbZvZ99+bjR3rBeULFrgx5X+UNptR3Wx652I2o2EJm2erbU/yZLMNZokJiW5atKuOu8ra127vmsABAAAAQFwG6Ndee62NHj3avv/+e6uqluMH0bx5c3f6xx9/uABdzeFm7pvqyrdmzRp3qtvSojL5m266KVUGvVq1apbTKNmrkvYPPvAud+ig4QBqohftNYsRqpJQacGcOfuXuXNtZ/Ium17V7PsaZtMvMJtZI6+tz+93/d9ilrzFnatavKr1a9rPLm92uVUpXiWqbwUAAABAzpEjA3T1tRswYICNGjXKvvvuO6tVq9YhHzNv3jx3qky6tGjRwgYPHmxr1651DeZk3LhxbtB/w4YN03yOAgUKuCUnmzZN5f9my5d7c5sPHmw2cGAuzJyrhECd1v/8c//iB+U63b3bzVE+u5LZhFpm355vNqV6gu3MG9xTcY8bU96sUjNrXqW5nVj1RGtetbnVKFHDTesHAAAAAHEfoKus/d1337XPPvvMzYXujxlXZ71ChQq5Mnbd3qVLFytTpowbg37jjTe6Du+NGzd299W0bArEL7roIhsyZIh7jrvvvts9d04PwtPy119mamj/9NOaYs5MxzTee0+VBZY7KOhWIzed+gG5avuDbM1v9lMFs1nHmk04Mp9Nqp5sm/PuDbpHwCoVrWTtarWzFlVbuIC8cYXGlj/x0B3/AQAAACAup1lLLzs5fPhwu/jii+2vv/6yCy+80I1N37ZtmytD79GjhwvAg9vi//nnn3bVVVe5LLzmT+/bt689+uijllep5QzICdOsbdhgNmCA2fvve4G5nH++ppTTAQ2Lb+p8N2qU15Zerer30Q6/uqjZvIpmc48sZvOq5bN5pXfZH/m3WiBk1ypZsKS1q9nO2tdqb6fUOsXql61PdhwAAADIRTZnY9yXIwP0WBHrAbo+2TPPNPviC+9yu3ZmN99s1qWLDnJY/Fq50uyVV7xl1SrvusRES+re1V5oVdCe3P6t/bPr3zQfWrlYZWtasam1rtHaBeXHVDzGEvMkZu/6AwAAAMiVcV+OLHFHxrz4ohec589vNn68WatWFt9+/tnswQe9rPmefc3bKlSwQP/L7aMOVez2uY/b0g1L3dXqqF6vTD0XgCsg12mTik2sfBGvHwEAAAAAZDcC9DilodbKlstjj8V5cK45yQcN8uaJS072rjv5ZDUrsOnNq9jNE2+3qROmuqsrFq1oD7Z70Hof3dsK56NtPQAAAIDYQYAeh3bt8jq179xp1rmzN9d5XNq82WzIELOnntrf8O2cc8zuvtuWVStmt397u33wljeXnILxW066xQaeNNCK5i8a3fUGAAAAgDQQoMchTZ02f75Z2bJeUjnuplBT8zeNL7//frN167zrWrY0e+IJ+7fxEfboD4/as58/a7v27rIES7BLjrnEHmj3AHOSAwAAAIhpBOhxRtO9P/ywd/75590Q7PihYPyjj8yGDjX7/XfvuiOPdDX86zucbE9Of8qeffpZ27prq7vp1Nqn2hMdnnBjywEAAAAg1hGgx1li+ZJLvP5oZ53lVXvHRRn7p596k7aPG7d/rrjy5c3uu882XHCWPfXjs/b0M31sy64t7iY1fRt8ymDrfERnpkQDAAAAkGMQoMcJ9Ua78UYvg16mjJc9z7GxqcaTf/mlF5SPGeMNpvc1a+YG2G/sc64NW/C6DX2hrm1O2uxualKhid3f9n7rVq8bgTkAAACAHIcAPU6awl18sRfPygsv5LDSdmXF5871MuSaD27KFLOkpP2316tn1quXBc4/3+YV324fL/rYnn+jsW3cudHd3Kh8IxeYd6/f3U2fBgAAAAA5EQF6Drdli1nPnl5cmzev1xTu3HMt9i1dajZ2rLfiEyaYbdiQ+vYaNczOO8+2n9Pdvi26zkb/PsbGjGlv/2z5J+UuDcs1tPva3GdnNTyLwBwAAABAjkeAnoOtWWPWpYvZnDlmRYqYffKJWceOFrsWLTL7+GNvUS1+sOLFzU45xezUU+3PFg3sq72LXVD+7TfP2M49+0vcNV1ah9odrFejXnZ2w7MtMU9i9r8PAAAAAIgAAvQc6o8/zDp18hLR5cp5Q7aPO85iSyDgzffmB+ULF+6/LTHRmxqtQwf7t/VxNqHkBvv2z+/s22VDbckXS1I9TfUS1e2MI8+wrkd2tbY121rBvAWz/70AAAAAQIQRoOdAs2d7mfO1a81q1zb75huzI46w2AnKZ83yAnKl9HUkwZcvn8uQb+3Z1SY3LW3frv/Rvl32sc2beE+qp0hMSLTmVZtb17pdXVCuMeY0fQMAAAAQ7wjQcxj1UdOY861bzZo29TLnFSvGQJM3NXbzg/K//95/W8GCtrtTB5vV9RgbX22PjV/5g037+3rb88+eVE+hILx9rfZuaVOzjRUvUDz73wcAAAAARBEBeg7q1D50qNk993jznbdv78XCGrodtaD8u+/MPvjAm6dc6fx9AkWL2KIerWz8SRVtfJE19t3f39mWf74w29/fzWqUqGGn1j7VBeSn1DrFKhTNSW3nAQAAACD8CNBzgMmTza68cv8Q7vPOM/vf/8wKFIjCZOvTppm9/77Zhx96Xep8pUrZsp7t7J0TCto7SbPst/++Ngu6uXSh0i4Y94Py2qVqU7YOAAAAAEEI0GPcjz96zc337PGawT3xhNlFF5llW2yrMeUa9K6gXNnyv/7af1vp0rbx7K72YavS9vauH23yX5+YrfJuUiO3VtVbuYBcyzEVj2EqNAAAAAA4CAL0GJaUZHbxxV5wrqZw77zjEtXZY+VKs7ffNhs+3Gzx4v3XFy9ue7t3szGdatvbib/YF7+PtKQlSe6mBEuw9rXb20WNL7Ie9XtYsQLFsmllAQAAACDnI0CPYQ8+aLZggVn58l5Je8SDcx0R+PxzLyhXa3iVtEuhQmbdupmdf77NbFzGrhx3vc39/Z1UDd4UlPc+urdVLV41wisJAAAAAPGJAD2GS9sffdQ7/+KLZmXLRvDFlCF/7jmzd981+++//deffLLZJZeYnXOObci7x+789k57+e2XLWABK1mwpF16zKV2UZOLrEmFJownBwAAAIAsIkCPUbfc4jVKV0M4TasWMerE3rWr2bZt3uUqVcz69vVq6+vWtUAgYCN+HmE3j73Z1m7zOrUrW/54h8fpvA4AAAAAYUSAHoPUh01xs5LSQ4ZE8IXGj/dK13fsMGvVyuyuu8xOPdUsMdHd/Ou/v9rVY662icsnusv1y9a3F09/0drWbBvBlQIAAACA3IkAPQapYbq0bm1WvXqEXuSrr8x69PDGnasD3ccfmxUs6G7auWenPfT9QzZkyhDbnbzbdWQf1HqQ3XzSzZY/MX+EVggAAAAAcjcC9BikoeDSq1eEXkCN4M45x2zXLrMzzzQbOTJlUvUZf8+wiz+72GXP5fS6p9uzpz1rtUrVitDKAAAAAACEAD3GLFpkNm+eWd68ZmefHYEXUKb8/PO9udsUpI8YYZYvnyXtSbL7J91vj015zJIDyVaxaEV7vsvzbro0GsABAAAAQOQRoMeY997zTjt3NitTJgK18xde6HWf693bm7stb16bs2qO9f20r/2y9hd3N02Xpqx56UKlw7wCAAAAAID0EKDHkEBgf3m74ueweustb8o0zW3ep4/ZG2/YLttrgyfea4MnD7a9gb1WrnA5e6nrS9azQSTbxgMAAAAA0kKAHkMmTTJbssSscGGvuXpYaF7zm27ysuVy2WVmL79s89f94rLm81bPc1ef3fBse6HLC1auSLkwvTAAAAAAIDMI0GNoajW/KZyGiBcpEoYnHTXK7OqrzVav9uZsu/VW23LvHfbQt3fY0OlDXYd2lbErMD+v0XlheEEAAAAAwOEiQI8BW7d6GXPF0Y0amQ0dmsUnXLvW7NprzT780Ltcv74FXnvN3iv+pw18oYGt2rrKXX1mvTNdSbsawgEAAAAAoosAPQbGnfft63VuL1/e7IsvzIoXz+Ig9uuvN1u/3iwx0WXN51/Zw6799mabvGKyu1udUnVsWOdh1vXIrmF9LwAAAACAw0eAHmWa9eyTT8zy5zf79FOzmjUP84k2bjS76CKz0aO9y02a2IaXhtmg/z62F9480U2dVihvIbur1V1280k3W8G8BcP5NgAAAAAAWUSAHkVbtpjdcIN3/vbbzVq0OMwn2rzZm5dtxgwX6QfuuceGd65gt008x/7d/q+7yzkNz7EnOj5h1UtUD98bAAAAAACEDQF6FN13n9k//5jVqeMF6Ic9gL1LFy84L13aNn35ifX781n7eMzH7uYGZRu4Oc3b124f1nUHAAAAAIQXAXqUzJ9v9vTT3vnnnjMrVOgwnmT7drOuXc2mTDErWdJ+/PBpO3f6JbZs4zLLlyefPdjuQbupxU2WLzFfuFcfAAAAABBmBOhRcuedZnv3mp19tlednmk7dpideaabPD1QrKg98/IldsuUS93UaTVL1rSRZ4+0E6qcEIE1BwAAAABEAgF6FCxcaDZmjDc1+cMPH8YTJCWZ9expNn68bShTxC59oJl9usibm61H/R72xplvWMmCJcO+3gAAAACAyCFAj4InnvBOe/Qwq1s3kw/etcvsnHPMvv7aZtYuYOf1L2bL133vStrVBG7ACQMsQZE/AAAAACBHIUDPZitXmr3zjnf+llsy+eDdu83OP992j/nChrbJa3edssf27FxttUrWsg/O+cCOq3xcJFYZAAAAAJANCNCz2TPPeHH2ySebnXhiJh64aJHZJZfYpNUz7JqrEmxBuT1mAbOzGvy/vTuBqqpcGzj+MCPmjKAYYuJ1nhIVlbw2aHgzg7p9knqNzEKvU2Vqas6mqMvUlUNpjrkKp8L81Aua4TWV0lBbllNOaS2RNCYnxv2t96VzPiBQ0XM4B/j/1trpfs8e3oNPh/Ps99nv/qeseG4FJe0AAAAAUMY52roDFcnlyyIffVTC0XM1k9zcuXL5sbbyr3rfyeMDRX6qbUitSrVkRe8Vsul/NpGcAwAAAEA5wAh6KTl1SiQ4WCQ1VaRFi7yno93VyZOSPTBcFstBmTxYJN1NxEEcJCIgQmY+OVNqedQqhZ4DAAAAAEoDCXop2Lcv74lof/wh0qiRyNatIo6Odxk1nz9f9i5/V4b1yJIfvfOaO/h0kKW9lnKvOQAAAACUQyToVpSeLjJxosjixSK5uSIdOuQ9Xq127WJ2yMmRtL27ZMvi4fKZx1mJ/Vdecy23GhLZY44MajdIHB24KwEAAAAAyiMSdCvZuVPktddELl3KW+/fX2TZMpHKlQttmJEht776j2yPXSxRKftku1+GZLTOeymvnP11mfnkLMrZAQAAAKCcI0G3sBs3RMaOFVm6NG/9kUdEPvww7/5zs+vXJWvH/8quXcskKu2AbPHPkusq//4zB2+aWU36Bg6SvkFD5G+1SvqgdAAAAABAWUSCbkFXrog88UTeE9GUkSNFIiNFPDz+3ODYMflx+Xuy5kK0rGuaJUkP//++fjlV5KX6z8hLPd+WNvXai4ODg03eAwAAAADANkjQLUTNzt6zZ15y7uMjsnatSPfueSXsyes+kagdc2R1lbPyfT0R8czbx8vwkDC/XtL3qTekk28XknIAAAAAqMBI0C3g1i2RPn1Ejh4V8fIS+e9/RfydzkvshHdk9cWtsuWRDMlomrets+EgvT2DZGD3MdLzb/8QFycXW3cfAAAAAGAHSNAtYPx4kb17RapWFYmNFan21XzptX+0/KeRIfLnLeRtpI4M7Pxv6Rf0b6ldubhp3AEAAAAAFRUJugWsW5f35+dRmZK86p/yjOs2udxIxD3HUV73/ocMDJkijz7cwdbdBAAAAADYsQr/UO0lS5ZIgwYNxN3dXQIDA+XgwYMlPkZ2tkhI50uyd72/PFVzm1yuItJcvOTQsKPywbBtJOcAAAAAgLuq0An6hg0bZNSoUTJlyhQ5fPiwtGnTRoKDgyUpKalEx2lVZYdcbdlIZvj/KoaDyKDaT8uhCeelpXcrq/UdAAAAAFC+OBiGYUgFpUbMO3ToIIsXL9brubm54uvrKyNGjJBx48bddf+0tDSpVq2a1HhDJLmGSJUsR1nWbZ707fFWKfQeAAAAAGBtprwvNTVVqqqJx6yowo6gZ2ZmSkJCgnTXz0LL4+joqNfj4+NLdKzkSiIBN6vL4YgEknMAAAAAwH2psJPEXb16VXJycsTb27tAu1o/efJkkftkZGToxURdQVFezQiQOe/uEFcXd311BQAAAABQPqT9meOVRvF5hU3Q70dkZKRMmzbtL+2rFiTIqgUFE30AAAAAQPlx7do1XepuTRU2Qff09BQnJye5cuVKgXa1XqdOnSL3GT9+vJ5UziQlJUX8/Pzk4sWLVv+HAqx9VVDNv3Dp0iWr31cDWAtxjPKCWEZ5QSyjvEhNTZX69etLzZo1rX6uCpugu7q6SkBAgOzevVtCQ0PNk8Sp9eHDhxe5j5ubm14KU8k5HzooD1QcE8so64hjlBfEMsoLYhnlhaOj9adwq7AJuqJGw8PDw6V9+/bSsWNHWbhwody4cUMGDhxo664BAAAAACqYCp2gh4WFye+//y6TJ0+WxMREadu2rcTExPxl4jgAAAAAAKytQifoiipnL66k/W5UufuUKVOKLHsHyhJiGeUBcYzyglhGeUEso7xwK8VYdjBKY654AAAAAABwR9a/yx0AAAAAANwVCToAAAAAAHaABB0AAAAAADtAgn4XS5YskQYNGoi7u7sEBgbKwYMH77j9pk2bpGnTpnr7Vq1ayY4dO0qtr4Al4vjjjz+Wrl27So0aNfTSvXv3u8Y9YK+fySbr168XBwcHCQ0NtXofAWvEckpKigwbNkzq1q2rJylq3Lgx3zFQJmNZPda4SZMmUqlSJfH19ZW33npLbt++XWr9BQrbu3ev9O7dW3x8fPR3hS1btsjd7NmzR9q1a6c/jxs1aiRr1qwRSyFBv4MNGzboZ6WrGfsOHz4sbdq0keDgYElKSipy+wMHDkjfvn1l0KBBcuTIEf1FUC0//vhjqfcduN84Vh84Ko7j4uIkPj5e//J8+umn5bfffiv1vgMPEssmFy5ckNGjR+sLT0BZjOXMzEzp0aOHjuXNmzfLqVOn9MXUevXqlXrfgQeJ5c8++0zGjRuntz9x4oSsXLlSH2PChAml3nfA5MaNGzp21cWme3H+/Hnp1auXPPHEE3L06FF588035bXXXpPY2FixCDWLO4rWsWNHY9iwYeb1nJwcw8fHx4iMjCxy+z59+hi9evUq0BYYGGgMHjzY6n0FLBXHhWVnZxtVqlQx1q5da8VeAtaJZRW/Xbp0MVasWGGEh4cbISEhpdRbwHKx/OGHHxoNGzY0MjMzS7GXgOVjWW375JNPFmgbNWqUERQUZPW+AvdCpcfR0dF33Gbs2LFGixYtCrSFhYUZwcHBhiUwgl4MdbU6ISFBl/eaODo66nU1qlgU1Z5/e0VdRSxue8Ae47iwmzdvSlZWltSsWdOKPQWsE8vTp08XLy8vXdkElNVY3rp1q3Tu3FmXuHt7e0vLli1l1qxZkpOTU4o9Bx48lrt06aL3MZXBnzt3Tt+q8cwzz5Rav4EHZe2cz9kiRymHrl69qn/xqV+E+an1kydPFrlPYmJikdurdqCsxHFh77zzjr4np/AHEWDvsbxv3z5dPqnKz4CyHMsqifn666+lf//+Opk5c+aMDB06VF88VaXCQFmJ5X79+un9HnvsMVXFK9nZ2TJkyBBK3FGmJBaT86WlpcmtW7f0/AoPghF0AMWaPXu2nlwrOjpaT/4ClBXp6ekyYMAAfZ+up6enrbsDPJDc3FxdCbJ8+XIJCAiQsLAweffdd+Wjjz6yddeAElHz3Kjqj6VLl+p71r/44gvZvn27zJgxw9ZdA+wGI+jFUF/onJyc5MqVKwXa1XqdOnWK3Ee1l2R7wB7j2GTevHk6Qf/qq6+kdevWVu4pYNlYPnv2rJ5QS83Kmj/JUZydnfUkW/7+/qXQc+DBP5fVzO0uLi56P5NmzZrpURxVZuzq6mr1fgOWiOVJkybpi6dqQi1FPfFITdAVERGhLzqpEnnA3hWX81WtWvWBR88V/i8ohvplp65S7969u8CXO7Wu7gMrimrPv72ya9euYrcH7DGOlblz5+qr2TExMdK+fftS6i1guVhWj7s8duyYLm83Lc8995x5xlX1dAKgrHwuBwUF6bJ200Um5fTp0zpxJzlHWYplNa9N4STcdOEpb34uwP5ZPeezyFRz5dT69esNNzc3Y82aNcbx48eNiIgIo3r16kZiYqJ+fcCAAca4cePM2+/fv99wdnY25s2bZ5w4ccKYMmWK4eLiYhw7dsyG7wIVXUnjePbs2Yarq6uxefNm4/Lly+YlPT3dhu8CKHksF8Ys7iirsXzx4kX9NI3hw4cbp06dMrZt22Z4eXkZ7733ng3fBVDyWFbfjVUsR0VFGefOnTN27txp+Pv76ychAbaSnp5uHDlyRC8qPZ4/f77++y+//KJfVzGsYtlExa6Hh4cxZswYnfMtWbLEcHJyMmJiYizSHxL0u1i0aJFRv359nbCoR0l8++235te6deumv/Dlt3HjRqNx48Z6ezX9/vbt223Qa+D+49jPz09/OBVe1C9VoKx9JudHgo6yHMsHDhzQj25VyZB65NrMmTP1YwSBshTLWVlZxtSpU3VS7u7ubvj6+hpDhw41kpOTbdR7wDDi4uKK/O5ril31p4rlwvu0bdtWx736TF69erXF+uOg/mOZsXgAAAAAAHC/uAcdAAAAAAA7QIIOAAAAAIAdIEEHAAAAAMAOkKADAAAAAGAHSNABAAAAALADJOgAAAAAANgBEnQAAAAAAOwACToAAAAAAHaABB0AAMiePXvEwcFBUlJS9PqaNWukevXqVj3nK6+8IqGhoSXer0GDBrJw4UKr9AkAAFsiQQcAwMJJp0p0Z8+eXaB9y5Ytur2sCAsLk9OnT9u0D8VdJDh06JBERETYpE8AAFgTCToAABbm7u4uc+bMkeTkZIseNzMzU0pLpUqVxMvLS+xR7dq1xcPDw9bdAADA4kjQAQCwsO7du0udOnUkMjLyjtt9/vnn0qJFC3Fzc9Nl2++//36B11XbjBkz5OWXX5aqVavqUWPTqPK2bdukSZMmOlF98cUX5ebNm7J27Vq9T40aNWTkyJGSk5NjPta6deukffv2UqVKFd23fv36SVJS0j2PXqvjqgqAwovJpUuXpE+fPnqfmjVrSkhIiFy4cMH8uurLqFGj9Ou1atWSsWPHimEYdyy5HzhwoKSmpprPNXXq1CJL3NVry5Ytk2effVb/PJo1aybx8fFy5swZefzxx6Vy5crSpUsXOXv2bIFzfPnll9KuXTt9QaVhw4Yybdo0yc7OvuO/GQAA1kSCDgCAhTk5OcmsWbNk0aJF8uuvvxa5TUJCgk5oX3rpJTl27JhOPidNmqQT4/zmzZsnbdq0kSNHjujXFZWMf/DBB7J+/XqJiYnRyezzzz8vO3bs0ItKxlXCunnzZvNxsrKydLL/ww8/6HJ7lTyrcvx7pcrKL1++rBf1njp16iRdu3Y1Hzs4OFgn/998843s379fHnroIenZs6d51F9dfFDvbdWqVbJv3z75448/JDo6utjzqYRaJeHqwoTpvKNHjy52e9OFjKNHj0rTpk31BYjBgwfL+PHj5fvvv9cXA4YPH27eXvVTbf/GG2/I8ePH9c9L9W/mzJn3/DMBAMDiDAAAYDHh4eFGSEiI/nunTp2MV199Vf89OjpaDRebt+vXr5/Ro0ePAvuOGTPGaN68uXndz8/PCA0NLbDN6tWr9XHOnDljbhs8eLDh4eFhpKenm9uCg4N1e3EOHTqkj2PaJy4uTq8nJyebz1OtWrUi9x05cqTuW1JSkl5ft26d0aRJEyM3N9e8TUZGhlGpUiUjNjZWr9etW9eYO3eu+fWsrCzj4YcfNv+silJcH9S5FyxYYF5X/Z44caJ5PT4+XretXLnS3BYVFWW4u7ub15966ilj1qxZBY6r3ofqJwAAtsIIOgAAVqLuQ1dl5ydOnPjLa6otKCioQJta//nnnwuUpquy9MJUGbe/v7953dvbW5d9q1Hr/G35S9jViH3v3r2lfv36eqS7W7duuv3ixYslek/Lly+XlStXytatW/W94IoalVfl5Oq4qg9qUWXut2/f1mXlqkxdjYAHBgaaj+Ps7Fzke7tfrVu3LvDelVatWhVoU/1JS0sz93n69Onm/qrl9ddf1/1UFQoAANiCs03OCgBABfD3v/9dl36rMuuSlJPnp+6fLszFxaXAuroHu6i23Nxc/fcbN27ofqjl008/1Ym1SszVekkmnouLi5MRI0ZIVFRUgYT4+vXrEhAQoI9dmCmJt7b87990b3xRbaafieqzuuf8hRde+Mux1D3pAADYAgk6AABWpB631rZtWz2hW35qIjN1r3Z+ar1x48b6HnZLOnnypFy7dk33xdfXV7ep+7JLQo2Qq8noJkyY8JekVk20tmHDBj3ru7pnvCh169aV7777Tl+0UNRkbGpUX+1bHFdX1wLVBJakznvq1Clp1KiRVY4PAMD9oMQdAAArUmXW/fv315O65ff222/L7t279eRm6nnjqhR+8eLFd5wI7X6psnaV7KpJ686dO6fL09V579WtW7d0efyjjz6qZ5JPTEw0L4p6f56ennrmdjX52vnz5/XEdWomedMkeWoyNnWBQE1Qpy4YDB06VFJSUu54XlW2r0a61c/p6tWrFi09nzx5snzyySd6FP2nn37StxyoSfcmTpxosXMAAFBSJOgAAFiZutfZVFqdfwR348aNOils2bKlThjVdvdbCn8nqsxczVC+adMmad68uU6U1ezw9+rKlSs6qVaJso+Pjx4NNy2me+L37t2rLwSo0XVVHTBo0CB9z7dpRF1dkBgwYICEh4dL586d9f3qaub5O1EzuQ8ZMkTCwsL0e5g7d65YiirvV4+q27lzp3To0EHPSr9gwQLx8/Oz2DkAACgpBzVTXIn3AgAAAAAAFsUIOgAAAAAAdoAEHQAAAAAAO0CCDgAAAACAHSBBBwAAAADADpCgAwAAAABgB0jQAQAAAACwAyToAAAAAADYARJ0AAAAAADsAAk6AAAAAAB2gAQdAAAAAAA7QIIOAAAAAIAdIEEHAAAAAMAOkKADAAAAAGAHSNABAAAAALADJOgAAAAAANgBEnQAAAAAAOwACToAAAAAAGJ7/wdMZJCM9onInAAAAABJRU5ErkJggg==)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From ce9d911f42acd096487ed9942bbd37aed9b9de23 Mon Sep 17 00:00:00 2001 From: David Leko Date: Thu, 20 Nov 2025 13:07:04 +0100 Subject: [PATCH 09/11] Added some test; fixed some issues. --- test/data/dataload/test_Dataloaders.py | 14 +- test/data/preprocess/test_preprocessor.py | 775 ++++++-- test/data/utils/test_data_utils.py | 33 +- topobench/data/preprocessor/preprocessor.py | 51 +- .../tutorial_on_disk_inductive_pipeline.ipynb | 1650 ----------------- 5 files changed, 666 insertions(+), 1857 deletions(-) delete mode 100644 tutorials/tutorial_on_disk_inductive_pipeline.ipynb diff --git a/test/data/dataload/test_Dataloaders.py b/test/data/dataload/test_Dataloaders.py index 886e27647..bc16470db 100644 --- a/test/data/dataload/test_Dataloaders.py +++ b/test/data/dataload/test_Dataloaders.py @@ -1,13 +1,17 @@ """Test the Dataloader class.""" - import hydra +import rootutils import torch from topobench.data.preprocessor import PreProcessor from topobench.dataloader import TBDataloader from topobench.dataloader.utils import to_data_list +from omegaconf import OmegaConf +import os +from topobench.run import initialize_hydra + # rootutils.setup_root("./", indicator=".project-root", pythonpath=True) @@ -43,7 +47,7 @@ def setup_method(self): def test_lift_features(self): """Test the collate funciton. - To test the collate function we use the TBDataloader class to create a dataloader that uses the collate function. + To test the collate function we use the TBDataloader class to create a dataloader that uses the collate function. We then first check that the batched data has the expected shape. We then convert the batched data back to a list and check that the data in the list is the same as the original data. """ @@ -120,11 +124,11 @@ def check_values(matrix, m1, m2): elems = [self.val_dataset.data_lst[i] for i in range(self.batch_size)] # Check shape - for key, _val in batch: + for key, val in batch: check_shape(batch, elems, key) # Check that the batched data is separated correctly and the values are correct - for key, _val in batch: + for key, val in batch: if "incidence_" in key: i = int(key.split("_")[1]) if i == 0: @@ -164,4 +168,4 @@ def check_values(matrix, m1, m2): if __name__ == "__main__": t = TestCollateFunction() t.setup_method() - t.test_lift_features() + t.test_lift_features() \ No newline at end of file diff --git a/test/data/preprocess/test_preprocessor.py b/test/data/preprocess/test_preprocessor.py index 7e1d0fefb..946681e2a 100644 --- a/test/data/preprocess/test_preprocessor.py +++ b/test/data/preprocess/test_preprocessor.py @@ -1,19 +1,22 @@ -""" Test the PreProcessor class.""" +"""Comprehensive unit tests for the PreProcessor class. +This test file provides extensive coverage of the PreProcessor class functionality, +including initialization, data transformations, split loading, and edge cases. +""" + +import json import os import os.path as osp -from unittest.mock import ANY, MagicMock, PropertyMock, patch - -import numpy as np +import tempfile import pytest +from unittest.mock import MagicMock, patch, mock_open +import numpy as np import torch import torch_geometric.data from omegaconf import DictConfig -import topobench.data.preprocessor.preprocessor as preproc_mod from topobench.data.preprocessor.preprocessor import PreProcessor - -from ..._utils.flow_mocker import FlowMocker +import topobench.data.preprocessor.preprocessor as preproc_mod class MockTorchDataset(torch.utils.data.Dataset): @@ -52,114 +55,60 @@ def __getitem__(self, idx): """ return self.data[idx] -@pytest.mark.usefixtures("mocker_fixture") -class TestPreProcessor: - """Test the PreProcessor class.""" - @pytest.fixture(autouse=True) - def setup_method(self, mocker_fixture): - """Test setup. - - Parameters - ---------- - mocker_fixture : MockerFixture - A fixture that provides a mocker object. - """ - mocker = mocker_fixture - - # Setup test parameters - self.dataset = MagicMock(spec=torch_geometric.data.Dataset) - self.data_dir = "fake/path" - self.transforms_config = DictConfig( - {"transform": {"transform_name": "CellCycleLifting"}} - ) - - params = [ - { - "mock_inmemory_init": "torch_geometric.data.InMemoryDataset.__init__" - }, - { - "mock_save_transform": ( - PreProcessor, - "save_transform_parameters", - ) - }, - {"mock_load": (PreProcessor, "load")}, - { - "mock_len": (PreProcessor, "__len__"), - "init_args": {"return_value": 3}, - }, - { - "mock_getitem": (PreProcessor, "get"), - "init_args": {"return_value": "0"}, - }, - ] - self.flow_mocker = FlowMocker(mocker, params) +class TestPreProcessorBasic: + """Test basic PreProcessor functionality.""" - # Initialize PreProcessor - self.preprocessor = PreProcessor(self.dataset, self.data_dir, None) + def test_init_without_transforms(self): + """Test PreProcessor initialization without transforms.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([ + torch_geometric.data.Data(x=torch.randn(3, 4)), + torch_geometric.data.Data(x=torch.randn(5, 4)), + ])) - def teardown_method(self): - """Test teardown.""" - del self.preprocessor - del self.flow_mocker - - def test_init(self): - """Test the initialization of the PreProcessor class.""" - self.flow_mocker.get("mock_inmemory_init").assert_called_once_with( - self.data_dir, None, None - ) - self.flow_mocker.get("mock_load").assert_called_once_with( - self.data_dir + "/processed/data.pt" - ) - assert not self.preprocessor.transforms_applied - assert self.preprocessor.data_list == ["0", "0", "0"] - - def test_init_with_transform(self, mocker_fixture): - """Test the initialization of the PreProcessor class with transforms. + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + assert preprocessor.transforms_applied == False + assert hasattr(preprocessor, 'data_list') + + def test_init_preserves_split_idx(self): + """Test that split_idx is preserved from dataset.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.split_idx = {"train": [0, 1], "val": [2], "test": [3]} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) - Parameters - ---------- - mocker_fixture : MockerFixture - A fixture that provides a mocker object. - """ - mocker = mocker_fixture - val_processed_paths = ["/some/path"] - params = [ - {"assert_args": ("created_property", "processed_data_dir")}, - {"assert_args": ("created_property", "processed_data_dir")}, - { - "mock_inmemory_init": "torch_geometric.data.InMemoryDataset.__init__", - "assert_args": ("called_once_with", ANY, None, ANY), - }, - { - "mock_processed_paths": (PreProcessor, "processed_paths"), - "init_args": {"property_val": val_processed_paths}, - }, - { - "mock_save_transform": ( - PreProcessor, - "save_transform_parameters", - ), - "assert_args": ("created_property", "processed_paths"), - }, - { - "mock_load": (PreProcessor, "load"), - "assert_args": ("called_once_with", val_processed_paths[0]), - }, - {"mock_len": (PreProcessor, "__len__")}, - {"mock_getitem": (PreProcessor, "get")}, - ] - self.flow_mocker = FlowMocker(mocker, params) - self.preprocessor_with_tranform = PreProcessor( - self.dataset, self.data_dir, self.transforms_config - ) - self.flow_mocker.assert_all(self.preprocessor_with_tranform) + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + assert hasattr(preprocessor, "split_idx") + assert preprocessor.split_idx == mock_dataset.split_idx + + def test_processed_file_names(self): + """Test the processed_file_names property.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) - transforms_config_liftings = DictConfig( - {"liftings": {"transform": {"transform_name": "CellCycleLifting"}}} - ) - _ = self.preprocessor.instantiate_pre_transform(self.data_dir, transforms_config_liftings) + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + assert preprocessor.processed_file_names == "data.pt" @patch("topobench.data.preprocessor.preprocessor.load_inductive_splits") def test_load_dataset_splits_inductive(self, mock_load_inductive_splits): @@ -168,74 +117,566 @@ def test_load_dataset_splits_inductive(self, mock_load_inductive_splits): Parameters ---------- mock_load_inductive_splits : MagicMock - A mock of the load_inductive_splits function. + Mock of the load_inductive_splits function. """ - split_params = DictConfig({"learning_setting": "inductive"}) - self.preprocessor.load_dataset_splits(split_params) - mock_load_inductive_splits.assert_called_once_with( - self.preprocessor, split_params - ) - - @patch( - "topobench.data.preprocessor.preprocessor.load_transductive_splits" - ) - def test_load_dataset_splits_transductive( - self, mock_load_transductive_splits - ): + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + split_params = DictConfig({"learning_setting": "inductive"}) + preprocessor.load_dataset_splits(split_params) + + mock_load_inductive_splits.assert_called_once_with( + preprocessor, split_params + ) + + @patch("topobench.data.preprocessor.preprocessor.load_transductive_splits") + def test_load_dataset_splits_transductive(self, mock_load_transductive_splits): """Test loading dataset splits for transductive learning. Parameters ---------- mock_load_transductive_splits : MagicMock - A mock of the load_transductive_splits function. + Mock of the load_transductive_splits function. """ - split_params = DictConfig({"learning_setting": "transductive"}) - self.preprocessor.load_dataset_splits(split_params) - mock_load_transductive_splits.assert_called_once_with( - self.preprocessor, split_params - ) + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + split_params = DictConfig({"learning_setting": "transductive"}) + preprocessor.load_dataset_splits(split_params) + + mock_load_transductive_splits.assert_called_once_with( + preprocessor, split_params + ) def test_invalid_learning_setting(self): - """Test an invalid learning setting.""" - split_params = DictConfig({"learning_setting": "invalid"}) - with pytest.raises(ValueError): - self.preprocessor.load_dataset_splits(split_params) - - def test_process_torch_utils_dataset(self): - """Test the process method with torch.utils.data.Dataset.""" - mock_data = [1, 2, 3] + """Test error with invalid learning setting.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + split_params = DictConfig({"learning_setting": "invalid"}) + with pytest.raises(ValueError, match="Invalid.*learning setting"): + preprocessor.load_dataset_splits(split_params) + + def test_no_learning_setting_error(self): + """Test error when no learning setting is specified.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + mock_dataset.__iter__ = MagicMock(return_value=iter([])) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch("torch_geometric.data.InMemoryDataset.__init__"): + with patch.object(PreProcessor, "load"): + preprocessor = PreProcessor(mock_dataset, tmpdir, None) + + # Test with no learning_setting key + split_params = DictConfig({}) + with pytest.raises(ValueError, match="No learning setting specified"): + preprocessor.load_dataset_splits(split_params) + + # Test with learning_setting = False + split_params = DictConfig({"learning_setting": False}) + with pytest.raises(ValueError, match="No learning setting specified"): + preprocessor.load_dataset_splits(split_params) + + +class TestPreProcessorProcessing: + """Test PreProcessor data processing methods.""" + + def test_process_with_torch_utils_dataset(self): + """Test process method with torch.utils.data.Dataset.""" + mock_data = [ + torch_geometric.data.Data(x=torch.randn(3, 4)), + torch_geometric.data.Data(x=torch.randn(5, 4)), + ] + mock_dataset = MockTorchDataset(mock_data) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.dataset = mock_dataset + preprocessor.pre_transform = None + preprocessor.collate = MagicMock( + return_value=(torch_geometric.data.Data(), {}) + ) + preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): + preprocessor.process() + + assert len(preprocessor.data_list) == len(mock_data) + preprocessor.collate.assert_called_once() + preprocessor.save.assert_called_once() + + def test_process_with_torch_geometric_data(self): + """Test process method with torch_geometric.data.Data.""" + mock_data = torch_geometric.data.Data(x=torch.randn(3, 4)) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.dataset = mock_data + preprocessor.pre_transform = None + preprocessor.collate = MagicMock( + return_value=(torch_geometric.data.Data(), {}) + ) + preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): + preprocessor.process() + + assert preprocessor.data_list == [mock_data] + preprocessor.collate.assert_called_once_with([mock_data]) + + def test_process_with_pre_transform(self): + """Test process method with a pre_transform applied.""" + mock_data = [ + torch_geometric.data.Data(x=torch.randn(3, 4)), + torch_geometric.data.Data(x=torch.randn(5, 4)) + ] mock_dataset = MockTorchDataset(mock_data) - self.preprocessor.dataset = mock_dataset - self.preprocessor.pre_transform = None - self.preprocessor.collate = MagicMock(return_value=(torch_geometric.data.Data(), MagicMock())) # Corrected line - self.preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(PreProcessor, "processed_paths", new_callable=PropertyMock) as mock_processed_paths: - mock_processed_paths.return_value = ["/fake/path"] - self.preprocessor.process() - - assert self.preprocessor.data_list == mock_data - self.preprocessor.collate.assert_called_once_with(mock_data) - self.preprocessor.save.assert_called_once() - - def test_process_torch_geometric_data_data(self): - """Test the process method with torch_geometric.data.Data.""" + mock_pre_transform = MagicMock(side_effect=lambda x: x) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.dataset = mock_dataset + preprocessor.pre_transform = mock_pre_transform + preprocessor.collate = MagicMock( + return_value=(torch_geometric.data.Data(), {}) + ) + preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): + preprocessor.process() + + # Verify pre_transform was called for each data item + assert mock_pre_transform.call_count == len(mock_data) + + +class TestPreProcessorLoad: + """Test PreProcessor load method.""" + + @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") + def test_load_backward_compatibility_2_elements(self, mock_torch_load): + """Test load method with 2 elements (backward compatibility). + + Parameters + ---------- + mock_torch_load : MagicMock + Mock of the torch_load function. + """ + mock_data = torch_geometric.data.Data() + mock_slices = {"x": torch.tensor([0, 3])} + mock_torch_load.return_value = (mock_data, mock_slices) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.load("/fake/path") + + # Use _data as that's what the actual code uses + assert preprocessor._data == mock_data + assert preprocessor.slices == mock_slices + + @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") + def test_load_backward_compatibility_3_elements(self, mock_torch_load): + """Test load method with 3 elements (backward compatibility). + + Parameters + ---------- + mock_torch_load : MagicMock + Mock of the torch_load function. + """ mock_data = torch_geometric.data.Data() - self.preprocessor.dataset = mock_data - self.preprocessor.pre_transform = None - self.preprocessor.collate = MagicMock(return_value=(torch_geometric.data.Data(), MagicMock())) # Corrected line - self.preprocessor.save = MagicMock() - - # Mock the processed_paths property - with patch.object(PreProcessor, "processed_paths", new_callable=PropertyMock) as mock_processed_paths: - mock_processed_paths.return_value = ["/fake/path"] - self.preprocessor.process() - - assert self.preprocessor.data_list == [mock_data] - self.preprocessor.collate.assert_called_once_with([mock_data]) - self.preprocessor.save.assert_called_once() + mock_slices = {"x": torch.tensor([0, 3])} + mock_data_cls = torch_geometric.data.Data + mock_torch_load.return_value = (mock_data, mock_slices, mock_data_cls) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.load("/fake/path") + + assert preprocessor._data == mock_data + assert preprocessor.slices == mock_slices + + @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") + def test_load_with_4_elements(self, mock_torch_load): + """Test load method with 4 elements (TU Datasets format). + + Parameters + ---------- + mock_torch_load : MagicMock + Mock of the torch_load function. + """ + mock_data = torch_geometric.data.Data() + mock_slices = {"x": torch.tensor([0, 3])} + mock_sizes = {"x": 3} + mock_data_cls = torch_geometric.data.Data + mock_torch_load.return_value = (mock_data, mock_slices, mock_sizes, mock_data_cls) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.load("/fake/path") + + assert preprocessor._data == mock_data + assert preprocessor.slices == mock_slices + + @patch("topobench.data.preprocessor.preprocessor.fs.torch_load") + def test_load_with_dict_data(self, mock_torch_load): + """Test load method when data is a dictionary. + + Parameters + ---------- + mock_torch_load : MagicMock + Mock of the torch_load function. + """ + mock_data_dict = { + "x": torch.randn(3, 4), + "edge_index": torch.tensor([[0, 1], [1, 2]]) + } + mock_slices = {"x": torch.tensor([0, 3])} + mock_data_cls = MagicMock() + mock_reconstructed_data = torch_geometric.data.Data() + mock_data_cls.from_dict.return_value = mock_reconstructed_data + mock_torch_load.return_value = (mock_data_dict, mock_slices, mock_data_cls) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.load("/fake/path") + + mock_data_cls.from_dict.assert_called_once_with(mock_data_dict) + assert preprocessor._data == mock_reconstructed_data + assert preprocessor.slices == mock_slices + + +class TestPreProcessorTransforms: + """Test PreProcessor with transforms.""" + + def test_save_transform_parameters_new_file(self): + """Test saving transform parameters when file doesn't exist.""" + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.processed_data_dir = tmpdir + preprocessor.transforms_parameters = { + "transform1": {"param": "value"} + } + + preprocessor.save_transform_parameters() + + # Check if file was created + param_file = os.path.join( + tmpdir, "path_transform_parameters_dict.json" + ) + assert os.path.exists(param_file) + + # Check file contents + with open(param_file, 'r') as f: + saved_params = json.load(f) + assert saved_params == preprocessor.transforms_parameters + + def test_save_transform_parameters_existing_same(self, capsys): + """Test saving transform parameters when file exists with same params. + + Parameters + ---------- + capsys : pytest.CaptureFixture + Pytest fixture to capture stdout/stderr output. + """ + with tempfile.TemporaryDirectory() as tmpdir: + # Create existing params file + params = {"transform1": {"param": "value"}} + param_file = os.path.join( + tmpdir, "path_transform_parameters_dict.json" + ) + with open(param_file, 'w') as f: + json.dump(params, f) + + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.processed_data_dir = tmpdir + preprocessor.transforms_parameters = params + + preprocessor.save_transform_parameters() + + # Check that message was printed + captured = capsys.readouterr() + assert "Transform parameters are the same" in captured.out + + def test_save_transform_parameters_existing_different(self): + """Test error when saving different transform parameters to same path.""" + with tempfile.TemporaryDirectory() as tmpdir: + # Create existing params file with different params + existing_params = {"transform1": {"param": "old_value"}} + param_file = os.path.join( + tmpdir, "path_transform_parameters_dict.json" + ) + with open(param_file, 'w') as f: + json.dump(existing_params, f) + + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.processed_data_dir = tmpdir + preprocessor.transforms_parameters = { + "transform1": {"param": "new_value"} + } + + with pytest.raises(ValueError, match="Different transform parameters"): + preprocessor.save_transform_parameters() + + def test_instantiate_pre_transform_with_liftings(self): + """Test instantiate_pre_transform with liftings config.""" + mock_dataset = MagicMock(spec=torch_geometric.data.Dataset) + mock_dataset.transform = None + mock_dataset._data = torch_geometric.data.Data() + mock_dataset.slices = {} + + transforms_config = DictConfig({ + "liftings": { + "transform1": {"transform_name": "DummyTransform", "param1": "value1"} + } + }) + + with tempfile.TemporaryDirectory() as tmpdir: + # Create preprocessor instance + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + + # Mock DataTransform to avoid needing real transforms + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + mock_dt.return_value = MagicMock() + preprocessor.set_processed_data_dir = MagicMock() + + pre_transform = preprocessor.instantiate_pre_transform( + tmpdir, transforms_config + ) + + # Check that a Compose object was created + assert hasattr(pre_transform, '__call__') + + def test_instantiate_pre_transform_multiple_transforms(self): + """Test instantiate_pre_transform with multiple transforms (else branch).""" + transforms_config = DictConfig({ + "transform1": {"transform_name": "Transform1", "param1": "value1"}, + "transform2": {"transform_name": "Transform2", "param2": "value2"} + }) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + + # Mock DataTransform + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + mock_dt.return_value = MagicMock() + + # Mock set_processed_data_dir + preprocessor.set_processed_data_dir = MagicMock() + + pre_transform = preprocessor.instantiate_pre_transform( + tmpdir, transforms_config + ) + + # DataTransform should be called for each transform + assert mock_dt.call_count == 2 + assert hasattr(pre_transform, '__call__') + + def test_instantiate_pre_transform_single_transform(self): + """Test instantiate_pre_transform with single transform (if branch).""" + transforms_config = DictConfig({ + "transform_name": "SingleTransform", + "param1": "value1", + "param2": 42 + }) + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + + # Mock DataTransform + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + # Mock DataTransform to return a mock object + mock_transform = MagicMock() + mock_dt.return_value = mock_transform + + # Mock set_processed_data_dir + preprocessor.set_processed_data_dir = MagicMock() + + pre_transform = preprocessor.instantiate_pre_transform( + tmpdir, transforms_config + ) + + # DataTransform should be called once with the entire config + assert mock_dt.call_count == 1 + # Should be called with all the config parameters + mock_dt.assert_called_once_with(**transforms_config) + + # Verify the pre_transform is a Compose object + assert isinstance( + pre_transform, + torch_geometric.transforms.Compose + ) + + def test_instantiate_pre_transform_calls_set_processed_data_dir(self): + """Test that instantiate_pre_transform calls set_processed_data_dir.""" + transforms_config = DictConfig({ + "transform1": {"transform_name": "Transform1", "param1": "value1"} + }) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + mock_dt.return_value = MagicMock() + # Mock set_processed_data_dir + preprocessor.set_processed_data_dir = MagicMock() + + pre_transform = preprocessor.instantiate_pre_transform( + tmpdir, transforms_config + ) + + # Verify set_processed_data_dir was called + preprocessor.set_processed_data_dir.assert_called_once() + call_args = preprocessor.set_processed_data_dir.call_args + assert call_args[0][1] == tmpdir + assert call_args[0][2] == transforms_config + + def test_instantiate_pre_transform_returns_compose(self): + """Test that instantiate_pre_transform returns a Compose object.""" + transforms_config = DictConfig({ + "transform1": {"transform_name": "Transform1", "param1": "value1"} + }) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + mock_dt.return_value = MagicMock() + preprocessor.set_processed_data_dir = MagicMock() + + pre_transform = preprocessor.instantiate_pre_transform( + tmpdir, transforms_config + ) + + # Check it's a Compose instance + assert isinstance( + pre_transform, + torch_geometric.transforms.Compose + ) + + def test_instantiate_pre_transform_single_vs_multiple(self): + """Test that the method correctly distinguishes between single and multiple transforms.""" + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.set_processed_data_dir = MagicMock() + + with patch("topobench.data.preprocessor.preprocessor.DataTransform") as mock_dt: + mock_dt.return_value = MagicMock() + + # Test single transform (has transform_name key) + single_config = DictConfig({ + "transform_name": "SingleTransform", + "param1": "value1" + }) + + preprocessor.instantiate_pre_transform(tmpdir, single_config) + + # Should be called once with all parameters + assert mock_dt.call_count == 1 + mock_dt.assert_called_with(**single_config) + + # Reset mock + mock_dt.reset_mock() + + # Test multiple transforms (no transform_name key at top level) + multiple_config = DictConfig({ + "transform1": {"transform_name": "Transform1", "param1": "value1"}, + "transform2": {"transform_name": "Transform2", "param2": "value2"} + }) + + preprocessor.instantiate_pre_transform(tmpdir, multiple_config) + + # Should be called twice, once for each transform + assert mock_dt.call_count == 2 + + +class TestPreProcessorEdgeCases: + """Test edge cases and error handling.""" + + def test_process_with_empty_dataset(self): + """Test process method with an empty dataset.""" + mock_dataset = MockTorchDataset([]) + + with tempfile.TemporaryDirectory() as tmpdir: + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.dataset = mock_dataset + preprocessor.pre_transform = None + # For empty list, collate should return a single empty Data object + preprocessor.collate = MagicMock( + return_value=(torch_geometric.data.Data(), {}) + ) + preprocessor.save = MagicMock() + + # Mock the processed_paths property + with patch.object(type(preprocessor), 'processed_paths', new_callable=lambda: property(lambda self: [f"{tmpdir}/data.pt"])): + preprocessor.process() + + assert preprocessor.data_list == [] + + def test_processed_dir_property(self): + """Test the processed_dir property returns correct paths.""" + with tempfile.TemporaryDirectory() as tmpdir: + # Without transforms + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.root = tmpdir + preprocessor.transforms_applied = False + + assert preprocessor.processed_dir == tmpdir + + # With transforms + with patch.object(PreProcessor, '__init__', lambda self, *args, **kwargs: None): + preprocessor = PreProcessor(None, tmpdir, None) + preprocessor.root = tmpdir + preprocessor.transforms_applied = True + + assert preprocessor.processed_dir == tmpdir + "/processed" + def test_pack_global_partition(tmp_path, monkeypatch): """ Test pack_global_partition builds a valid handle and memmaps. @@ -384,4 +825,4 @@ def __init__(self, data): assert handle2["config_hash"] == handle["config_hash"] # No extra split loading on cached path - assert call_count_after == call_count_before + assert call_count_after == call_count_before \ No newline at end of file diff --git a/test/data/utils/test_data_utils.py b/test/data/utils/test_data_utils.py index aff1c5aa7..dded1a955 100644 --- a/test/data/utils/test_data_utils.py +++ b/test/data/utils/test_data_utils.py @@ -2,12 +2,11 @@ import omegaconf import pytest -import torch import torch_geometric -from toponetx.classes import CellComplex - +import torch from topobench.data.utils import * - +import toponetx as tnx +from toponetx.classes import CellComplex class TestDataUtils: """Test data utils functions.""" @@ -18,29 +17,29 @@ def setup_method(self): self.complex.add_cell([1, 2, 3],rank=2) self.complex.add_cell([3, 4, 5],rank=2) self.complex.add_cell([5, 6, 7],rank=2) - self.neighborhoods1 = ["up_adjacency-0","2-up_adjacency-0","2-down_laplacian-2","2-down_adjacency-2","2-up_incidence-0","2-down_incidence-2"] - self.neighborhoods2 = ["down_incidence-1", "up_laplacian-0", "down_laplacian-1", "up_adjacency-0", "hodge_laplacian-1"] + self.neighborhoods1 = ['up_adjacency-0','2-up_adjacency-0','2-down_laplacian-2','2-down_adjacency-2','2-up_incidence-0','2-down_incidence-2'] + self.neighborhoods2 = ['down_incidence-1', 'up_laplacian-0', 'down_laplacian-1', 'up_adjacency-0', 'hodge_laplacian-1'] def test_get_complex_connectivity(self): """Test get_complex_connectivity.""" out = get_complex_connectivity(self.complex, 3, neighborhoods=self.neighborhoods2) - assert "up_laplacian-0" in out + assert 'up_laplacian-0' in out.keys() def test_get_combinatorial_complex_connectivity(self): """Test get_complex_connectivity.""" out = get_combinatorial_complex_connectivity(self.complex, 3) - assert "adjacency_0" in out + assert 'adjacency_0' in out.keys() def test_select_neighborhoods_of_interest(self): """Test select_neighborhoods_of_interest.""" connectivity = get_complex_connectivity(self.complex, 2) out = select_neighborhoods_of_interest(connectivity, self.neighborhoods1) - assert "2-down_laplacian-2" in out - assert "incidence_1" in out + assert '2-down_laplacian-2' in out.keys() + assert 'incidence_1' in out.keys() - with pytest.raises(ValueError): - select_neighborhoods_of_interest(connectivity, ["invalid_neighborhood"]) + with pytest.raises(ValueError) as e: + select_neighborhoods_of_interest(connectivity, ['invalid_neighborhood']) def test_generate_zero_sparse_connectivity(self): """Test generate_zero_sparse_connectivity.""" @@ -50,12 +49,12 @@ def test_generate_zero_sparse_connectivity(self): def test_load_cell_complex_dataset(self): """Test load_cell_complex_dataset.""" - with pytest.raises(NotImplementedError): + with pytest.raises(NotImplementedError) as e: load_cell_complex_dataset({}) def test_load_simplicial_dataset(self): """Test load_simplicial_dataset.""" - with pytest.raises(NotImplementedError): + with pytest.raises(NotImplementedError) as e: load_simplicial_dataset({}) def test_load_manual_graph(self): @@ -65,11 +64,11 @@ def test_load_manual_graph(self): def test_make_hash(self): """Test make_hash.""" - out = make_hash("test") + out = make_hash('test') assert isinstance(out, int) def test_ensure_serializable(self): """Test ensure_serializable.""" - objects = ["test", 1, 1.0, [1, 2, 3], {"a": 1, "b": 2}, set([1, 2, 3]), omegaconf.dictconfig.DictConfig({"a": 1, "b": 2}), torch_geometric.data.Data()] + objects = ['test', 1, 1.0, [1, 2, 3], {'a': 1, 'b': 2}, set([1, 2, 3]), omegaconf.dictconfig.DictConfig({'a': 1, 'b': 2}), torch_geometric.data.Data()] for obj in objects: - out = ensure_serializable(obj) + out = ensure_serializable(obj) \ No newline at end of file diff --git a/topobench/data/preprocessor/preprocessor.py b/topobench/data/preprocessor/preprocessor.py index 57410d949..e75ed7e0c 100644 --- a/topobench/data/preprocessor/preprocessor.py +++ b/topobench/data/preprocessor/preprocessor.py @@ -6,7 +6,6 @@ import shutil from typing import Any -import hydra import numpy as np import torch import torch_geometric @@ -50,14 +49,21 @@ def __init__(self, dataset, data_dir, transforms_config=None, **kwargs): super().__init__( self.processed_data_dir, None, pre_transform, **kwargs ) + self.transform = ( + dataset.transform if hasattr(dataset, "transform") else None + ) self.save_transform_parameters() self.load(self.processed_paths[0]) + self.data_list = [data for data in self] else: self.transforms_applied = False - super().__init__(str(data_dir), None, None, **kwargs) - self.load(data_dir + "/processed/data.pt") + super().__init__(data_dir, None, None, **kwargs) + self.transform = ( + dataset.transform if hasattr(dataset, "transform") else None + ) + self.data, self.slices = dataset._data, dataset.slices + self.data_list = [data for data in dataset] - self.data_list = [self.get(idx) for idx in range(len(self))] # Some datasets have fixed splits, and those are stored as split_idx during loading # We need to store this information to be able to reproduce the splits afterwards if hasattr(dataset, "split_idx"): @@ -72,11 +78,11 @@ def processed_dir(self) -> str: str Path to the processed directory. """ - if self.transforms_applied: + if not self.transforms_applied: return self.root else: return self.root + "/processed" - + @property def processed_file_names(self) -> str: """Return the name of the processed file. @@ -107,11 +113,21 @@ def instantiate_pre_transform( """ if transforms_config.keys() == {"liftings"}: transforms_config = transforms_config.liftings - pre_transforms_dict = hydra.utils.instantiate(transforms_config) - pre_transforms_dict = { - key: DataTransform(**value) - for key, value in transforms_config.items() - } + # Check if this is a single transform config (has transform_name key) + # or multiple transforms config (each value is a dict with transform_name) + if "transform_name" in transforms_config: + # Single transform configuration + pre_transforms_dict = { + transforms_config.transform_name: DataTransform( + **transforms_config + ) + } + else: + # Multiple transforms configuration + pre_transforms_dict = { + key: DataTransform(**value) + for key, value in transforms_config.items() + } pre_transforms = torch_geometric.transforms.Compose( list(pre_transforms_dict.values()) ) @@ -171,12 +187,11 @@ def save_transform_parameters(self) -> None: def process(self) -> None: """Method that processes the data.""" - if isinstance(self.dataset, torch_geometric.data.Dataset): - data_list = [ - self.dataset.get(idx) for idx in range(len(self.dataset)) - ] - elif isinstance(self.dataset, torch.utils.data.Dataset): - data_list = [self.dataset[idx] for idx in range(len(self.dataset))] + if isinstance( + self.dataset, + (torch_geometric.data.Dataset, torch.utils.data.Dataset), + ): + data_list = [data for data in self.dataset] elif isinstance(self.dataset, torch_geometric.data.Data): data_list = [self.dataset] @@ -244,7 +259,7 @@ def load_dataset_splits( f"Invalid '{split_params.learning_setting}' learning setting.\ Please define either 'inductive' or 'transductive'." ) - + def pack_global_partition( self, *, diff --git a/tutorials/tutorial_on_disk_inductive_pipeline.ipynb b/tutorials/tutorial_on_disk_inductive_pipeline.ipynb deleted file mode 100644 index 27d2380b1..000000000 --- a/tutorials/tutorial_on_disk_inductive_pipeline.ipynb +++ /dev/null @@ -1,1650 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "779c9d47-4d89-4e80-a532-a5c48bd03f51", - "metadata": {}, - "source": [ - "# Inductive `OnDiskDataset` Pipeline\n", - "\n", - "## Tutorial Overview\n", - "\n", - "In this tutorial, we demonstrate how to **implement, configure, run, and test** an inductive on-disk dataset using the `OnDiskDataset` interface from `torch_geometric`.\n", - "\n", - "The tutorial is divided into three main steps:\n", - "\n", - "1. **Implementing an On-Disk Dataset** \n", - " - Implement data loading and preprocessing logic \n", - " - Define the key dataset parameters and structure \n", - "\n", - "2. **Building the Inductive `OnDiskDataset` Pipeline** \n", - " - Integrate the new dataset into the existing TopoBench pipeline \n", - " - Ensure smooth interaction with the rest of the framework \n", - "\n", - "3. **Testing and Memory Tracking** \n", - " - Compare the performance of `OnDiskDataset` and `InMemoryDataset` pipelines \n", - " - Measure and visualize memory usage using the `memory_plotting` script" - ] - }, - { - "cell_type": "markdown", - "id": "6a1c1781-3e1e-4350-afc4-615b1b522aaf", - "metadata": {}, - "source": [ - "## Implementing an On-Disk Dataset\n", - "\n", - "When working with large datasets, storing all graphs in memory can become inefficient. To address this, PyTorch Geometric provides the `OnDiskDataset` class, which lets us store graphs directly on disk and load them as needed.\n", - "\n", - "Here we show how to implement the core functionality using our own example, `FakeOnDiskDataset`. This dataset generates synthetic graphs (like PyG’s `FakeDataset`) but saves them to disk instead of keeping everything in memory.\n", - "\n", - "To implement your dataset, you **must** override at least two methods from `torch_geometric.data.OnDiskDataset`:\n", - "\n", - "- `download()`: Prepares or fetches the raw data \n", - "- `process()`: Generates and writes processed data to disk in batches \n", - "\n", - "In addition, override these if your data differs from the defaults or needs special handling (custom fields, optional attributes, non-standard types):\n", - "\n", - "- `serialize()`: How each graph is stored on disk \n", - "- `deserialize()`: How stored graphs are reconstructed when loaded\n", - "\n", - "---\n", - "\n", - "### `download()`\n", - "\n", - "The `download()` method is responsible for fetching or preparing raw data. In our case, since the dataset is generated locally, this method simply ensures that the necessary directories exist.\n", - "\n", - "For real datasets, this is where you would download files, unzip archives, or copy raw data into the `raw/` folder.\n", - "\n", - "---\n", - "\n", - "### `process()`\n", - "\n", - "The `process()` method defines how the dataset is **generated or preprocessed** and then **saved to disk**. Unlike `InMemoryDataset`, which collates all data into memory, `OnDiskDataset` writes data incrementally using the `extend()` method. \n", - "\n", - "In our example, the method generates random graphs and writes them to disk in small batches:\n", - "\n", - "```python\n", - "def process(self) -> None:\n", - " \"\"\"Generate synthetic graphs and write them to disk in small batches.\"\"\"\n", - " os.makedirs(self.processed_dir, exist_ok=True)\n", - "\n", - " batch_size = 1000\n", - " buffer = []\n", - "\n", - " for i in range(self.num_graphs):\n", - " data = self.generate_data() # create one graph\n", - " buffer.append(data)\n", - "\n", - " # Flush to disk every batch or at the very end\n", - " if (i + 1) % batch_size == 0 or (i + 1) == self.num_graphs:\n", - " self.extend(buffer) # append this batch to the on-disk store\n", - " buffer = []\n", - "\n", - " print(\"Processing complete.\")" - ] - }, - { - "cell_type": "markdown", - "id": "f8d03a93-21d5-485d-9d26-10211b0c2eba", - "metadata": {}, - "source": [ - "---\n", - "\n", - "### `serialize()` and `deserialize()`\n", - "\n", - "The `serialize()` and `deserialize()` methods define how individual `Data` objects are written to and read from disk. They convert between PyTorch Geometric’s in-memory `Data` format and the dictionary format used for on-disk storage.\n", - "\n", - "You need to override these methods if your dataset includes custom fields or non-standard data types. For simple datasets (`x`, `edge_index`, `y`), the default implementations are already sufficient.\n", - "\n", - "Below is a minimal example from our `FakeOnDiskDataset`:\n", - "\n", - "```python\n", - "def serialize(self, data: Data) -> dict[str, object]:\n", - " \"\"\"Convert a Data object into a dictionary for storage.\"\"\"\n", - " return {\n", - " \"edge_index\": data.edge_index,\n", - " \"num_nodes\": torch.tensor([data.num_nodes]),\n", - " \"x\": getattr(data, \"x\", None),\n", - " \"edge_attr\": getattr(data, \"edge_attr\", None),\n", - " \"edge_weight\": getattr(data, \"edge_weight\", None),\n", - " \"y\": getattr(data, \"y\", None),\n", - " }" - ] - }, - { - "cell_type": "markdown", - "id": "2f9b2c9f-c403-475b-9603-6ed52fa2e0b3", - "metadata": {}, - "source": [ - "When loading data back, `deserialize()` reverses this process: it reconstructs each graph from the stored dictionary:\n", - "\n", - "```python\n", - "def deserialize(self, row: dict[str, object]) -> Data:\n", - " \"\"\"Recreate a Data object from stored tensors.\"\"\"\n", - " data = Data()\n", - " data.edge_index = row[\"edge_index\"]\n", - " data.num_nodes = int(row[\"num_nodes\"][0])\n", - "\n", - " # Restore optional attributes\n", - " for key in (\"x\", \"edge_attr\", \"edge_weight\", \"y\"):\n", - " value = row.get(key)\n", - " if value is not None:\n", - " setattr(data, key, value)\n", - "\n", - " return data" - ] - }, - { - "cell_type": "markdown", - "id": "cd338572-973d-486f-800c-563862197007", - "metadata": {}, - "source": [ - "---\n", - "\n", - "### Configuration Setup\n", - "\n", - "Now that we’ve implemented our on-disk dataset class, we need to define its configuration parameters. The configuration structure is almost identical to the one used for `InMemoryDataset`, but includes a few **on-disk–specific fields** related to how data is stored and accessed.\n", - "\n", - "Below is an example configuration for our `FakeOnDiskDataset`:\n", - "\n", - "```yaml\n", - "# Dataset loader configuration\n", - "loader:\n", - " _target_: topobench.data.loaders.graph.FakeOnDiskDatasetLoader\n", - " parameters:\n", - " # Framework-specific data organization\n", - " data_domain: graph\n", - " data_type: FakeOnDiskDataset\n", - " data_name: FakeOnDiskDataset\n", - " data_dir: ${paths.data_dir}/${dataset.loader.parameters.data_domain}/${dataset.loader.parameters.data_type}\n", - " memory_type: on_disk # Key parameter: specifies on-disk data handling\n", - " backend: sqlite # Storage backend: 'sqlite'\n", - " ...\n", - " \n", - "# Dataset parameters\n", - "parameters:\n", - " num_features: 64 # Node feature dimension\n", - " num_classes: 5 # Number of label classes\n", - " task: classification\n", - " loss_type: cross_entropy\n", - " monitor_metric: accuracy\n", - " task_level: graph\n", - " ..." - ] - }, - { - "cell_type": "markdown", - "id": "038e5283-e49c-476b-8350-7700caf184a5", - "metadata": {}, - "source": [ - "The `memory_type` and backend `backend` fields are specific to the on-disk implementation and determine how data is stored and accessed." - ] - }, - { - "cell_type": "markdown", - "id": "4769f308-97f0-48bc-89d5-81f099777f61", - "metadata": {}, - "source": [ - "## Building the Inductive `OnDiskDataset` Pipeline\n", - "\n", - "With the dataset and configuration in place, the next step is to integrate it into the existing TopoBench pipeline. To keep the framework consistent, we introduce minimal changes that allow seamless switching between **in-memory** and **on-disk** datasets.\n", - "\n", - "In the original pipeline, the preprocessing step is handled by a class called `PreProcessor`. For on-disk datasets, we add a new class`OnDiskPreProcessor` that manages data stored on disk instead of memory.\n", - "\n", - "Inside the main `run` function, the correct preprocessor is chosen dynamically based on the dataset configuration:\n", - "\n", - "```python\n", - "def run(cfg: DictConfig) -> DictConfig:\n", - " \"\"\"Run pipeline with given configuration.\n", - " \n", - " Parameters\n", - " ----------\n", - " cfg : DictConfig\n", - " Configuration.\n", - " \"\"\"\n", - " # Instantiate and load dataset\n", - " dataset_loader = hydra.utils.instantiate(cfg.dataset.loader)\n", - " dataset, dataset_dir = dataset_loader.load()\n", - " # Preprocess dataset and load the splits\n", - " transform_config = cfg.get(\"transforms\", None)\n", - " memory_type = cfg.dataset.loader.parameters.get(\"memory_type\", \"in_memory\")\n", - " preprocessor_cls = OnDiskPreProcessor if memory_type == \"on_disk\" else PreProcessor\n", - " preprocessor = preprocessor_cls(dataset, dataset_dir, transform_config)" - ] - }, - { - "cell_type": "markdown", - "id": "4691e613-54c7-419d-953f-3569d4de7d8f", - "metadata": {}, - "source": [ - "The new `OnDiskPreProcessor` reuses the same structure and logic as the standard `PreProcessor`, but adapts data loading and transformation for on-disk storage. It handles datasets that use lazy loading, meaning graphs are loaded from disk only when accessed." - ] - }, - { - "cell_type": "markdown", - "id": "ddd6bf2b-ff84-4965-bf76-723f160dd1a1", - "metadata": {}, - "source": [ - "## Testing and Memory Tracking\n", - "\n", - "In this section, we demonstrate how to track and visualize memory usage for the inductive on-disk dataset pipeline using the `memory_plotting` script.\n", - "\n", - "Here’s what happens:\n", - "1. The script updates a test template with the selected dataset and model. \n", - "2. It runs the test while tracking memory consumption in real time. \n", - "3. The recorded data is saved to CSV files and converted into a normalized time plot (memory vs. relative progress).\n", - "\n", - "We showcase this on a practical example comparing `graph/fake` and `graph/fake_inmem` across three models:\n", - "- `graph/gcn` \n", - "- `cell/topotune` \n", - "- `simplicial/topotune`" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "bf50b3a1-42f8-436e-b521-c47fc39f306b", - "metadata": {}, - "outputs": [], - "source": [ - "# Imports and Utils are handled here.\n", - "\n", - "from pathlib import Path\n", - "from contextlib import contextmanager\n", - "from IPython.display import Image\n", - "import os, sys\n", - "\n", - "sys.path.insert(0, str(Path.cwd().parents[0] / 'tools' / 'memory_usage_tracking'))\n", - "import memory_plotting as mp\n", - "\n", - "@contextmanager\n", - "def pushd(path: Path):\n", - " prev = Path.cwd()\n", - " os.chdir(path)\n", - " try:\n", - " yield\n", - " finally:\n", - " os.chdir(prev)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "30cfaba6-0e38-4411-98f5-f3648e3c8da3", - "metadata": {}, - "outputs": [], - "source": [ - "def run_memory_tracking_demo(\n", - " models=(\"graph/gcn\",),\n", - " datasets=(\"graph/fake_inmem\", \"graph/fake\"),\n", - " interval=0.05\n", - "):\n", - " \"\"\"\n", - " Runs the memory tracking and returns a plot.\n", - " \"\"\"\n", - " project_root = Path.cwd().parents[0]\n", - " script_path = project_root / \"test\" / \"pipeline\" / \"memory_checks_template.py\"\n", - " output_root = project_root / \"test\" / \"memory_usage_tracking\" / \"outputs\"\n", - " output_root.mkdir(parents=True, exist_ok=True)\n", - "\n", - " ds1, ds2 = datasets\n", - " ds1_disp = mp.dataset_short(ds1)\n", - " ds2_disp = mp.dataset_short(ds2)\n", - "\n", - " with pushd(project_root):\n", - " for model in models:\n", - " model_label = model\n", - " model_part = mp.model_fs(model_label)\n", - "\n", - " cfg_folder = f\"{ds1_disp}__{ds2_disp}__{model_part}\"\n", - " config_dir = output_root / cfg_folder\n", - " config_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - " csv_outputs_for_model = []\n", - " return_codes = []\n", - "\n", - " for dataset_disp in (ds1_disp, ds2_disp):\n", - " original_dataset_arg = ds1 if dataset_disp == ds1_disp else ds2\n", - " output_csv = config_dir / f\"{model_part}__{dataset_disp}.csv\"\n", - "\n", - " _, rc = mp.monitor_script(\n", - " script_path=str(script_path),\n", - " dataset_to_inject=original_dataset_arg,\n", - " model_to_inject=model_label,\n", - " output_csv=str(output_csv),\n", - " interval=interval\n", - " )\n", - " csv_outputs_for_model.append(str(output_csv))\n", - " return_codes.append(rc)\n", - " \n", - " labels = [\"InMemoryDataset\", \"OnDiskDataset\"]\n", - " norm_plot_path = str(config_dir / \"memory_plot_normalized.png\")\n", - " \n", - " mp.plot_normalized_memory(\n", - " model_label,\n", - " csv_outputs_for_model,\n", - " labels=labels,\n", - " plot_path=norm_plot_path,\n", - " colors=(\"blue\", \"red\")\n", - " )\n", - " \n", - " return Image(filename=norm_plot_path)" - ] - }, - { - "cell_type": "markdown", - "id": "3f878c3a-8b69-4a62-b316-51c878370d32", - "metadata": {}, - "source": [ - "### `graph/gcn` model\n", - "\n", - "For the `graph/gcn` model, we run tests on two synthetic datasets `graph/fake` and `graph/fake_inmem`. Both datasets contain **20,000 graphs** with an average of **100 nodes per graph**, but differ in how they are stored and accessed: \n", - "one uses the on-disk format, while the other is kept entirely in memory. \n", - "\n", - "The plot below shows the memory usage comparison between these two pipelines during execution." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "78d639dc-dde6-450f-8a01-a534eaebe8f7", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running for model 'graph/gcn' on dataset 'graph/fake_inmem'\n", - "\u001b[1m============================= test session starts ==============================\u001b[0m\n", - "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", - "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", - "configfile: pyproject.toml\n", - "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", - "collected 1 item\n", - "\n", - "test/pipeline/tmpwshvgyjw.py " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (mps), used: False\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "\n", - " | Name | Type | Params | Mode \n", - "------------------------------------------------------------------\n", - "0 | feature_encoder | AllCellFeatureEncoder | 8.5 K | train\n", - "1 | backbone | GNNWrapper | 8.4 K | train\n", - "2 | readout | NoReadOut | 325 | train\n", - "3 | val_acc_best | MeanMetric | 0 | train\n", - "------------------------------------------------------------------\n", - "17.3 K Trainable params\n", - "0 Non-trainable params\n", - "17.3 K Total params\n", - "0.069 Total estimated model params size (MB)\n", - "26 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20000\n", - "tensor([3])\n", - "[3 0 3 ... 4 4 4] (20000,)\n", - "Epoch 0: 100%|██████████| 500/500 [00:12<00:00, 38.62it/s]\n", - "Validation: | | 0/? [00:00" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot" - ] - }, - { - "cell_type": "markdown", - "id": "c84b76e5-59d4-4d38-aa2f-1a6cf4b4dfd2", - "metadata": {}, - "source": [ - "### `cell/topotune` model\n", - "\n", - "For the `cell/topotune` model, we test the pipeline using datasets that contain **5,000 graphs** with an average of **100 nodes per graph**. In this case, the `OnDiskPreProcessor` performs computationally intensive topology liftings as an initial step.\n", - "\n", - "This setup demonstrates how the on-disk pipeline handles heavier preprocessing workloads." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "20541a95-ef95-4f39-9e11-13f2e54a88b7", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running for model 'cell/topotune' on dataset 'graph/fake_inmem'\n", - "\u001b[1m============================= test session starts ==============================\u001b[0m\n", - "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", - "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", - "configfile: pyproject.toml\n", - "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", - "collected 1 item\n", - "\n", - "test/pipeline/tmp5o2iftqu.py " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (mps), used: False\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "\n", - " | Name | Type | Params | Mode \n", - "------------------------------------------------------------------\n", - "0 | feature_encoder | AllCellFeatureEncoder | 9.7 K | train\n", - "1 | backbone | TuneWrapper | 17.6 K | train\n", - "2 | readout | PropagateSignalDown | 6.5 K | train\n", - "3 | val_acc_best | MeanMetric | 0 | train\n", - "------------------------------------------------------------------\n", - "33.8 K Trainable params\n", - "0 Non-trainable params\n", - "33.8 K Total params\n", - "0.135 Total estimated model params size (MB)\n", - "156 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5000\n", - "tensor([3])\n", - "[3 4 4 ... 3 3 0] (5000,)\n", - "Epoch 0: 100%|██████████| 125/125 [00:53<00:00, 2.35it/s]\n", - "Validation: | | 0/? [00:00" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot" - ] - }, - { - "cell_type": "markdown", - "id": "39e44a31-5285-44f2-90fb-b658e62aae83", - "metadata": {}, - "source": [ - "### `simplicial/topotune` model\n", - "\n", - "For the `simplicial/topotune` model, we use the same dataset configuration: **5,000 graphs** with an average of **100 nodes per graph**." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "69a5cd38-17fd-4807-b26e-9333b457fa54", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running for model 'simplicial/topotune' on dataset 'graph/fake_inmem'\n", - "\u001b[1m============================= test session starts ==============================\u001b[0m\n", - "platform darwin -- Python 3.11.3, pytest-8.4.2, pluggy-1.6.0\n", - "rootdir: /Users/davidleko/Desktop/Projects/TopoBench\n", - "configfile: pyproject.toml\n", - "plugins: mock-3.15.1, anyio-4.11.0, hydra-core-1.3.2, cov-7.0.0\n", - "collected 1 item\n", - "\n", - "test/pipeline/tmp7sd2ronn.py " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (mps), used: False\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "\n", - " | Name | Type | Params | Mode \n", - "------------------------------------------------------------------\n", - "0 | feature_encoder | AllCellFeatureEncoder | 9.7 K | train\n", - "1 | backbone | TuneWrapper | 35.5 K | train\n", - "2 | readout | PropagateSignalDown | 6.5 K | train\n", - "3 | val_acc_best | MeanMetric | 0 | train\n", - "------------------------------------------------------------------\n", - "51.7 K Trainable params\n", - "0 Non-trainable params\n", - "51.7 K Total params\n", - "0.207 Total estimated model params size (MB)\n", - "252 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5000\n", - "tensor([3])\n", - "[3 4 1 ... 3 3 3] (5000,)\n", - "Epoch 0: 100%|██████████| 125/125 [00:26<00:00, 4.69it/s]\n", - "Validation: | | 0/? [00:00" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot" - ] - }, - { - "cell_type": "markdown", - "id": "e9e1ff0a-b6ba-45f1-875d-7e39ed03e371", - "metadata": {}, - "source": [ - "## Cleanup and Further Use\n", - "\n", - "Before running new experiments or regenerating datasets, we recommend removing previously created folders to ensure a clean setup. This prevents conflicts with cached data, outdated splits, or previously processed files.\n", - "\n", - "You can safely remove the old datasets and data split directories using:\n", - "\n", - "```bash\n", - "rm -rf datasets/graph/dataset_name\n", - "rm -rf datasets/data_splits/dataset_name" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 1941aeda4a8525577441074e96cbd72f4f88c0a0 Mon Sep 17 00:00:00 2001 From: David Leko Date: Fri, 21 Nov 2025 12:58:53 +0100 Subject: [PATCH 10/11] Added additional models to the tutorial. --- ...torial_on_disk_transductive_pipeline.ipynb | 46 ++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/tutorials/tutorial_on_disk_transductive_pipeline.ipynb b/tutorials/tutorial_on_disk_transductive_pipeline.ipynb index d587e2383..3be92b1b0 100644 --- a/tutorials/tutorial_on_disk_transductive_pipeline.ipynb +++ b/tutorials/tutorial_on_disk_transductive_pipeline.ipynb @@ -456,7 +456,7 @@ "id": "c50dc4f6-3bcd-44ac-a04c-91ee593a8153" }, "source": [ - "### `graph/gcn` model\n", + "### `graph/gcn` model: (num_parts, batch_size) = (1024, 8)\n", "\n", "![memory_plot_raw.png](data:image/png;base64,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)\n", "\n", @@ -465,6 +465,50 @@ "These plots show memory and time savings produced by our pipelines for a large transductive datasets." ] }, + { + "cell_type": "markdown", + "id": "bLavEsyoONUY", + "metadata": { + "id": "bLavEsyoONUY" + }, + "source": [ + "### `hypergraph/edgnn` model: (num_parts, batch_size) = (1024, 8)\n", + "\n", + "![hyper_raw.jpg](data:image/jpeg;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "y8K8FfrzObFR", + "metadata": { + "id": "y8K8FfrzObFR" + }, + "source": [ + "![hyper_norm.jpg](data:image/jpeg;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "tYUWJa65OpkZ", + "metadata": { + "id": "tYUWJa65OpkZ" + }, + "source": [ + "### `cell/topotune` model: (num_parts, batch_size) = (4096, 4)\n", + "\n", + "![cell_raw.jpg](data:image/jpeg;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "cpTlfjebPFFF", + "metadata": { + "id": "cpTlfjebPFFF" + }, + "source": [ + "![cell_norm.jpg](data:image/jpeg;base64,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)" + ] + }, { "cell_type": "markdown", "id": "73466984-78a5-4271-967e-c9882e6c6649", From b55b876a3bb227fdc5a79b776b6e8d337ff5fe02 Mon Sep 17 00:00:00 2001 From: David Leko Date: Fri, 21 Nov 2025 14:32:41 +0100 Subject: [PATCH 11/11] Fixed minor path issues. --- configs/dataset/graph/reddit.yaml | 2 +- .../loaders/graph/reddit_dataset_loader.py | 46 ++++++++++++------- 2 files changed, 30 insertions(+), 18 deletions(-) diff --git a/configs/dataset/graph/reddit.yaml b/configs/dataset/graph/reddit.yaml index 7e43d26ea..42a3d1fb9 100755 --- a/configs/dataset/graph/reddit.yaml +++ b/configs/dataset/graph/reddit.yaml @@ -3,7 +3,7 @@ loader: _target_: topobench.data.loaders.RedditDatasetLoader parameters: data_domain: graph - data_type: graph + data_type: reddit data_name: reddit subsample_nodes: 2000 subsample_seed: 42 diff --git a/topobench/data/loaders/graph/reddit_dataset_loader.py b/topobench/data/loaders/graph/reddit_dataset_loader.py index a6a2646f9..4bc500c30 100644 --- a/topobench/data/loaders/graph/reddit_dataset_loader.py +++ b/topobench/data/loaders/graph/reddit_dataset_loader.py @@ -1,32 +1,44 @@ """Loaders for Reddit dataset.""" -from pathlib import Path - from omegaconf import DictConfig -from torch_geometric.data import Dataset from torch_geometric.datasets import Reddit from topobench.data.loaders.base import AbstractLoader class RedditDatasetLoader(AbstractLoader): + """Loader for the Reddit graph dataset. + + Parameters + ---------- + parameters : DictConfig + Configuration with data directory and dataset name. + """ + def __init__(self, parameters: DictConfig) -> None: + """Initialize the Reddit dataset loader.""" super().__init__(parameters) - def load_dataset(self) -> Dataset: + def load_dataset(self) -> Reddit: + """Load the Reddit dataset. + + Returns + ------- + Reddit + Loaded Reddit dataset instance. + """ dataset = self._initialize_dataset() - self.data_dir = self._redefine_data_dir(dataset) + self.data_dir = self.get_data_dir() return dataset - def _initialize_dataset(self) -> Dataset: - return Reddit( - root=str(self.root_data_dir), - ) - - def _redefine_data_dir(self, dataset: Dataset) -> Path: - return str(Path(dataset.processed_dir)) - - - - - + def _initialize_dataset(self) -> Reddit: + """Initialize the Reddit dataset instance. + + Returns + ------- + Reddit + Initialized Reddit dataset. + """ + # root = / + root = str(self.root_data_dir / self.parameters.data_name) + return Reddit(root=root)