From bbea159d4151bf4ecb09bdc47ea0a5887ade89aa Mon Sep 17 00:00:00 2001 From: Lovro Rabuzin Date: Thu, 13 Aug 2026 14:35:45 +0200 Subject: [PATCH 1/9] Remove dead code, declare hard deps, and enforce the lint rules Cleanup found while auditing the repo after the package consolidation. Dead code, none of it referenced anywhere in src/, tests/ or docs/: - UnifiedPredictPayload, a 24-field dataclass that reads like the predict_step contract but is not: predict_step returns a plain dict. - embedding_payload_to_table, whose docstring claimed it was used by downstream analysis and tests. It was used by neither. - Registry.register_many and SupervisedModule.collect_graph_embeddings. - A `reduced` local in the interpretability pipeline, assigned twice and never read. Left over from the refactor that decoupled clustering from the reduced space; reduction_result still carries it downstream, so behaviour is unchanged. Dependencies: joblib and lightning-utilities were hard module-level imports but undeclared, working only because scikit-learn and lightning happen to pull them in. Added an `sce` extra for rpy2, since SingleCellExperiment/rds input is documented as supported but had no install path. Lint: ruff ignored F401, F841 and E203 globally, hiding 16 unused imports and a dead local. All are fixed, so those three rules are now enforced and cannot regress. E402 and E501 stay ignored, with a comment on why: the E402s are the required rootutils.setup_root()-before-import pattern. ruff target-version was py312 while the package supports >=3.11, so 3.12-only syntax could pass lint and break on the supported floor. environment.yaml was still the Lightning template: it pinned python=3.10, which requires-python = ">=3.11" refuses to install on, so following it produced an env the package could not be installed into. It also pulled torchvision and hydra-optuna-sweeper (neither imported anywhere) and omitted PyG entirely. scripts/schedule.sh still invoked `python src/train.py`, a path that stopped existing when the package moved under src/grass_mil. Also renames a user-facing `cluster_count` column to `niche_count`, and corrects two false claims in repository_map.md: the test workflow is multi-OS but single-Python, and pre-commit has no notebook or docs hooks. Co-Authored-By: Claude Opus 5 (1M context) --- docs/repository_map.md | 7 +-- environment.ci-spatial.yaml | 38 ------------ environment.yaml | 58 +++++++++++-------- pyproject.toml | 18 +++++- scripts/schedule.sh | 6 +- src/grass_mil/data/__init__.py | 2 + src/grass_mil/data/components/__init__.py | 26 +++++++++ src/grass_mil/inference/embeddings.py | 5 -- src/grass_mil/inference/schemas.py | 27 --------- src/grass_mil/interpretability/core/niches.py | 2 +- src/grass_mil/interpretability/pipeline.py | 2 - .../interpretability/plugins/builtin.py | 2 +- .../interpretability/plugins/registry.py | 6 -- .../interpretability/tier2/autocorrelation.py | 2 +- src/grass_mil/models/supervised_module.py | 43 -------------- .../models/training/augmentations.py | 2 +- src/grass_mil/models/training/loss_utils.py | 3 +- src/grass_mil/utils/__init__.py | 14 +++++ tests/configs/test_task_preset_composition.py | 6 +- 19 files changed, 106 insertions(+), 163 deletions(-) delete mode 100644 environment.ci-spatial.yaml diff --git a/docs/repository_map.md b/docs/repository_map.md index 3034797..5de44e4 100644 --- a/docs/repository_map.md +++ b/docs/repository_map.md @@ -13,15 +13,14 @@ Scope rules used here: - `.project-root`: Root marker used by `rootutils.setup_root(...)`. - `.gitignore`: Ignore rules for generated artifacts, envs, logs, and data outputs. - `.env.example`: Example environment variable file loaded by Hydra/OmegaConf env references. -- `.pre-commit-config.yaml`: Code quality hooks (format/lint/notebook cleanup/docs checks). +- `.pre-commit-config.yaml`: Code quality hooks (ruff lint + format, plus basic file hygiene checks). - `LICENSE`: Project license text. - `README.md`: Primary entrypoint documentation and navigation index. - `Makefile`: Convenience targets for clean, format, tests, and default training. - `pyproject.toml`: Package metadata, dependencies, optional extras, console entry points (`grass-mil-train`, `-eval`, `-loocv`, `-predict`, `-report`), and pytest/coverage/ruff configuration. -- `environment.yaml`: Conda environment alternative with pinned major versions. -- `environment.ci-spatial.yaml`: Fully pinned environment used by CI. +- `environment.yaml`: Conda environment alternative for local development, pinned to major versions. CI does not use it; the CI stack is pinned inline in `.github/workflows/test.yml`. ## CI/DevOps And Contribution Files @@ -32,7 +31,7 @@ Scope rules used here: - `.github/workflows/code-quality-main.yaml`: Pre-commit quality checks on pushes to `main`. - `.github/workflows/code-quality-pr.yaml`: Pre-commit quality checks on changed PR files. - `.github/workflows/release-drafter.yml`: Automated draft release workflow. -- `.github/workflows/test.yml`: Multi-OS, multi-Python automated test workflow. +- `.github/workflows/test.yml`: Multi-OS (Linux/macOS) test workflow, plus coverage and a from-source packaging job. ## Rules And Contracts diff --git a/environment.ci-spatial.yaml b/environment.ci-spatial.yaml deleted file mode 100644 index 2373596..0000000 --- a/environment.ci-spatial.yaml +++ /dev/null @@ -1,38 +0,0 @@ -name: spatial -channels: - - pyg - - pytorch - - conda-forge - - defaults -dependencies: - - python=3.12 - - pip=24.2 - - setuptools=72.1.0 - - wheel=0.43.0 - - numpy=1.26.4 - - pandas=2.2.3 - - scipy=1.14.1 - - scikit-learn=1.5.2 - - anndata=0.10.9 - - pytest=9.0.2 - - rich=13.9.2 - - pytorch=2.4.1 - - pyg=2.6.1 - - pytorch-scatter=2.1.2 - # Prebuilt from the pyg channel. Do NOT move this to the pip section: - # pip has no macOS-arm64 wheel, so it builds from source, and PyTorch's - # own c10/util/strong_type.h specializes std::is_arithmetic, which newer - # libc++ (Xcode 26) rejects outright. Any pip-built torch C++ extension - # fails on the macOS runner for that reason. - - pytorch-sparse=0.6.18 - - pip: - - lightning==2.5.6 - - pytorch-lightning==2.5.6 - - torchmetrics==1.8.2 - - hydra-core==1.3.2 - - hydra-colorlog==1.2.0 - - omegaconf==2.3.0 - - plotly==5.24.1 - - rootutils==1.0.7 - - shapely==2.0.6 - - sh==2.2.2 diff --git a/environment.yaml b/environment.yaml index c01f649..d73d90f 100644 --- a/environment.yaml +++ b/environment.yaml @@ -1,41 +1,53 @@ -# reasons you might want to use `environment.yaml` instead of `requirements.txt`: -# - pip installs packages in a loop, without ensuring dependencies across all packages -# are fulfilled simultaneously, but conda achieves proper dependency control across -# all packages -# - conda allows for installing packages without requiring certain compilers or -# libraries to be available in the system, since it installs precompiled binaries +# Conda environment for local development. +# +# This is an alternative to `pip install -e ".[interpretability,report,io]"`. +# It exists because conda resolves the compiled stack (PyTorch, PyG, scipy) +# across all packages simultaneously, and installs precompiled binaries without +# requiring system compilers. +# +# Keep the versions here consistent with `pyproject.toml` (`requires-python` and +# `dependencies`). CI does not use this file: it installs with pip and pins the +# stack inline in `.github/workflows/test.yml`. -name: myenv +name: grass-mil channels: + - pyg - pytorch - conda-forge - defaults -# it is strongly recommended to specify versions of packages installed through conda -# to avoid situation when version-unspecified packages install their latest major -# versions which can sometimes break things - -# current approach below keeps the dependencies in the same major versions across all -# users, but allows for different minor and patch versions of packages where backwards -# compatibility is usually guaranteed - +# Major versions are pinned so all users share the same majors, while minor and +# patch versions stay free. dependencies: - - python=3.10 + # Must satisfy pyproject's `requires-python = ">=3.11"`. + - python=3.12 - pytorch=2.* - - torchvision=0.* - lightning=2.* - - torchmetrics=0.* + - torchmetrics=1.* - hydra-core=1.* - rich=13.* - - pre-commit=3.* - - pytest=7.* - numpy - pandas - scipy - scikit-learn + - joblib + - lightning-utilities - shapely - anndata + # PyG and its compiled extensions resolve far more reliably from conda than + # from pip; torch-sparse in particular has no macOS-arm64 wheel. + - pyg=2.* + - pytorch-scatter + - pytorch-sparse + + # --------- interpretability --------- # + - plotly + - jinja2 + + # --------- dev --------- # + - pre-commit=4.* + - pytest=9.* # --------- loggers --------- # # - wandb @@ -46,9 +58,9 @@ dependencies: - pip>=23 - pip: - - hydra-optuna-sweeper - hydra-colorlog - rootutils - - torch-geometric - # optional: required only for SingleCellExperiment/rds loading + - umap-learn + # optional: required only for SingleCellExperiment/rds loading, and also + # needs an R runtime with Bioconductor # - rpy2 diff --git a/pyproject.toml b/pyproject.toml index 95b20ff..6ba27a4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,6 +12,9 @@ license = { file = "LICENSE" } dependencies = [ "torch>=2.0", "lightning>=2.0", + # Imported directly by utils/{pylogger,rich_utils,logging_utils}.py rather + # than relied on transitively through lightning. + "lightning-utilities>=0.10", "torchmetrics>=0.11.4", "torch-geometric>=2.5", "hydra-core==1.3.2", @@ -21,6 +24,9 @@ dependencies = [ "pandas", "scipy>=1.11", "scikit-learn", + # Imported directly by interpretability/core/transfer.py to persist niche + # transfer bundles; not relied on transitively through scikit-learn. + "joblib", "rich", "rootutils", ] @@ -30,6 +36,9 @@ interpretability = ["plotly", "umap-learn", "jinja2"] report = ["kaleido", "playwright"] spatial-stats = ["squidpy", "scanpy", "anndata"] io = ["anndata", "shapely"] +# SingleCellExperiment / .rds inputs. Also needs an R runtime with Bioconductor; +# rpy2 alone is not sufficient. +sce = ["rpy2"] [project.scripts] grass-mil-train = "grass_mil.train:main" @@ -67,8 +76,13 @@ exclude_lines = [ [tool.ruff] line-length = 99 -target-version = "py312" +target-version = "py311" # matches requires-python floor exclude = ["logs", "data"] [tool.ruff.lint] -ignore = ["E203", "E402", "E501", "F401", "F841"] +# E402: train.py/eval.py must call rootutils.setup_root() before importing the +# package, so module-level imports legitimately follow executable code. +# E501: a handful of long string literals the formatter will not wrap. +# F401/F841/E203 were previously ignored too. They are now clean and enforced, +# so unused imports and dead locals cannot creep back in. +ignore = ["E402", "E501"] diff --git a/scripts/schedule.sh b/scripts/schedule.sh index 44b3da1..3af09df 100644 --- a/scripts/schedule.sh +++ b/scripts/schedule.sh @@ -1,7 +1,7 @@ #!/bin/bash # Schedule execution of many runs -# Run from root folder with: bash scripts/schedule.sh +# Run from the repository root with: bash scripts/schedule.sh -python src/train.py trainer.max_epochs=5 logger=csv +grass-mil-train trainer.max_epochs=5 logger=csv -python src/train.py trainer.max_epochs=10 logger=csv +grass-mil-train trainer.max_epochs=10 logger=csv diff --git a/src/grass_mil/data/__init__.py b/src/grass_mil/data/__init__.py index 970a1bf..332dfa3 100644 --- a/src/grass_mil/data/__init__.py +++ b/src/grass_mil/data/__init__.py @@ -1 +1,3 @@ from .spatial_omics_datamodule import SpatialOmicsDataModule + +__all__ = ["SpatialOmicsDataModule"] diff --git a/src/grass_mil/data/components/__init__.py b/src/grass_mil/data/components/__init__.py index c9c31bf..d1d0558 100644 --- a/src/grass_mil/data/components/__init__.py +++ b/src/grass_mil/data/components/__init__.py @@ -15,3 +15,29 @@ from .samplers import SamplerConfig, get_sampler_strategy, register_sampler_strategy from .spatial_types import SpatialOmicsTable from .transforms import CompositionVector, instantiate_transforms + +__all__ = [ + "CompositionVector", + "CsvConfig", + "FeatureReducerConfig", + "GraphBuilderConfig", + "H5adConfig", + "SamplerConfig", + "SceConfig", + "SpatialOmicsGraphDataset", + "SpatialOmicsPreprocessor", + "SpatialOmicsTable", + "TileConfig", + "TransformDataset", + "build_grid_tiles", + "build_patches_from_polygons", + "get_feature_reducer", + "get_graph_builder", + "get_sampler_strategy", + "instantiate_transforms", + "load_csv_table", + "load_h5ad_table", + "load_polygons_from_path", + "load_sce_table", + "register_sampler_strategy", +] diff --git a/src/grass_mil/inference/embeddings.py b/src/grass_mil/inference/embeddings.py index 6910e34..b007159 100644 --- a/src/grass_mil/inference/embeddings.py +++ b/src/grass_mil/inference/embeddings.py @@ -9,11 +9,6 @@ from grass_mil.inference.schemas import EmbeddingPayload -def embedding_payload_to_table(payload: EmbeddingPayload) -> pd.DataFrame: - """Public wrapper used by downstream analysis and tests.""" - return _embeddings_to_dataframe(payload) - - def embeddings_to_dataframe(payload: EmbeddingPayload) -> pd.DataFrame: """Backwards-friendly alias for table conversion.""" return _embeddings_to_dataframe(payload) diff --git a/src/grass_mil/inference/schemas.py b/src/grass_mil/inference/schemas.py index f2f2b97..feed766 100644 --- a/src/grass_mil/inference/schemas.py +++ b/src/grass_mil/inference/schemas.py @@ -64,33 +64,6 @@ class PreforwardSubsamplingDecision: runtime_enabled: Optional[bool] = None -@dataclass(frozen=True) -class UnifiedPredictPayload: - """Raw, per-chunk payload emitted by predict_step for unified collection.""" - - bag_ids: List[str] - bag_logits: torch.Tensor - bag_targets: Optional[torch.Tensor] - bag_attention: Optional[Dict[str, torch.Tensor]] - row_region_ids: Optional[List[Optional[str]]] = None - row_sample_ids: Optional[List[Optional[str]]] = None - instance_logits: Optional[torch.Tensor] = None - instance_attention_logits: Optional[torch.Tensor] = None - instance_patch_ids: Optional[List[str]] = None - instance_bag_ids: Optional[List[str]] = None - instance_region_ids: Optional[List[Optional[str]]] = None - instance_sample_ids: Optional[List[Optional[str]]] = None - instance_embeddings: Optional[torch.Tensor] = None - instance_composition: Optional[torch.Tensor] = None - instance_centroids: Optional[torch.Tensor] = None - instance_graphs: Optional[List[Any]] = None - embedding_bag_ids: Optional[List[str]] = None - graph_embeddings: Optional[torch.Tensor] = None - embedding_bag_counts: Optional[List[float]] = None - node_embeddings: Optional[torch.Tensor] = None - node_bag_ids: Optional[List[str]] = None - - @dataclass(frozen=True) class CollectedInferencePayload: """Normalized payloads gathered from a single trainer.predict pass.""" diff --git a/src/grass_mil/interpretability/core/niches.py b/src/grass_mil/interpretability/core/niches.py index 9933ed8..d9ed4fb 100644 --- a/src/grass_mil/interpretability/core/niches.py +++ b/src/grass_mil/interpretability/core/niches.py @@ -18,7 +18,7 @@ from __future__ import annotations -from typing import Iterable, List, Optional, Sequence +from typing import Iterable, List import numpy as np import pandas as pd diff --git a/src/grass_mil/interpretability/pipeline.py b/src/grass_mil/interpretability/pipeline.py index 0e6e31e..4eb9f01 100644 --- a/src/grass_mil/interpretability/pipeline.py +++ b/src/grass_mil/interpretability/pipeline.py @@ -113,7 +113,6 @@ def run_interpretability_pipeline( reduction_enabled = bool(reduction_cfg.get("enabled", True)) reduction_result = None combo_pca_result = None - reduced = emb_set.matrix if reduction_enabled: method = str(reduction_cfg.get("method", "pca")) params = dict(reduction_cfg.get("params", {})) @@ -127,7 +126,6 @@ def run_interpretability_pipeline( ) reduction_input = combo_pca_result.embedding reduction_result = run_reduction(method, reduction_input, **params) - reduced = reduction_result.embedding clustering_result = None labels: Optional[np.ndarray] = None diff --git a/src/grass_mil/interpretability/plugins/builtin.py b/src/grass_mil/interpretability/plugins/builtin.py index 335cc78..aecce5d 100644 --- a/src/grass_mil/interpretability/plugins/builtin.py +++ b/src/grass_mil/interpretability/plugins/builtin.py @@ -274,7 +274,7 @@ def run(self, dataset, context: PluginContext, **params: Any) -> PluginResult: "sample_value": meta.get("sample_value"), "node_count": meta.get("node_count"), "edge_count": meta.get("edge_count"), - "cluster_count": len(niche_counts) if isinstance(niche_counts, dict) else 0, + "niche_count": len(niche_counts) if isinstance(niche_counts, dict) else 0, } ] ) diff --git a/src/grass_mil/interpretability/plugins/registry.py b/src/grass_mil/interpretability/plugins/registry.py index 656cc09..0020a58 100644 --- a/src/grass_mil/interpretability/plugins/registry.py +++ b/src/grass_mil/interpretability/plugins/registry.py @@ -24,12 +24,6 @@ def register(self, plugin: InterpretabilityPlugin, *, replace: bool = False) -> ) self._plugins[name] = plugin - def register_many( - self, plugins: Iterable[InterpretabilityPlugin], *, replace: bool = False - ) -> None: - for plugin in plugins: - self.register(plugin, replace=replace) - def get(self, name: str) -> InterpretabilityPlugin: key = str(name).strip() if key not in self._plugins: diff --git a/src/grass_mil/interpretability/tier2/autocorrelation.py b/src/grass_mil/interpretability/tier2/autocorrelation.py index 296dd7c..0f1914b 100644 --- a/src/grass_mil/interpretability/tier2/autocorrelation.py +++ b/src/grass_mil/interpretability/tier2/autocorrelation.py @@ -21,7 +21,7 @@ from __future__ import annotations from dataclasses import dataclass -from typing import Dict, List, Optional, Sequence +from typing import Dict, List, Sequence import numpy as np import pandas as pd diff --git a/src/grass_mil/models/supervised_module.py b/src/grass_mil/models/supervised_module.py index be447c5..9510f37 100644 --- a/src/grass_mil/models/supervised_module.py +++ b/src/grass_mil/models/supervised_module.py @@ -512,49 +512,6 @@ def _build_predict_embedding_payload( payload["node_bag_ids"] = node_bag_ids return payload - def collect_graph_embeddings( - self, batch, *, return_node_embeddings: bool = False - ) -> Dict[str, Any]: - node_emb, graph_emb = self.encoder( - batch.x, - batch.edge_index, - edge_attr=getattr(batch, "edge_attr", None), - batch=getattr(batch, "batch", None), - categorical_codes=getattr(batch, "categorical_codes", None), - return_graph_embedding=True, - ) - bag_ids = extract_bag_ids( - batch, - bag_key=self.task_cfg.get("bag_key", "region_id"), - bag_fallback_key=self.task_cfg.get("bag_fallback_key", "sample_id"), - ) - bag_groups = group_instance_indices_by_bag(bag_ids) - ordered_bag_ids = sorted(bag_groups.keys()) - bag_graph_embeddings = [] - bag_counts: list[int] = [] - for bag_id in ordered_bag_ids: - idx = torch.tensor(bag_groups[bag_id], dtype=torch.long, device=graph_emb.device) - bag_graph_embeddings.append(graph_emb.index_select(0, idx).mean(dim=0, keepdim=True)) - bag_counts.append(int(idx.numel())) - - payload: Dict[str, Any] = { - "bag_ids": ordered_bag_ids, - "graph_embeddings": torch.cat(bag_graph_embeddings, dim=0), - "bag_counts": bag_counts, - } - if return_node_embeddings: - batch_index = getattr(batch, "batch", None) - if batch_index is None: - batch_index = torch.zeros( - node_emb.shape[0], dtype=torch.long, device=node_emb.device - ) - node_bag_ids = [ - str(bag_ids[int(graph_idx)]) for graph_idx in batch_index.detach().cpu() - ] - payload["node_embeddings"] = node_emb - payload["node_bag_ids"] = node_bag_ids - return payload - def _forward_bags(self, batch, *, allow_missing_targets: bool = False): patch_logits, graph_emb, node_emb = self._forward_instances(batch) diff --git a/src/grass_mil/models/training/augmentations.py b/src/grass_mil/models/training/augmentations.py index 15b7650..1cde83b 100644 --- a/src/grass_mil/models/training/augmentations.py +++ b/src/grass_mil/models/training/augmentations.py @@ -16,7 +16,7 @@ from __future__ import annotations -from typing import Any, Callable, Dict, Mapping, Optional, Sequence +from typing import Any, Callable, Mapping, Optional, Sequence import torch diff --git a/src/grass_mil/models/training/loss_utils.py b/src/grass_mil/models/training/loss_utils.py index b78882d..8d50aef 100644 --- a/src/grass_mil/models/training/loss_utils.py +++ b/src/grass_mil/models/training/loss_utils.py @@ -1,9 +1,8 @@ from __future__ import annotations -from typing import Any, Dict, List, Optional, Sequence +from typing import Any, Dict, Optional import torch -import torch.nn.functional as F def compute_supervised_loss( diff --git a/src/grass_mil/utils/__init__.py b/src/grass_mil/utils/__init__.py index 78c7e75..4e8148f 100644 --- a/src/grass_mil/utils/__init__.py +++ b/src/grass_mil/utils/__init__.py @@ -3,3 +3,17 @@ from grass_mil.utils.pylogger import RankedLogger from grass_mil.utils.rich_utils import enforce_tags, print_config_tree from grass_mil.utils.utils import extras, get_metric_value, task_wrapper + +# Declared so these read as a deliberate re-export surface rather than unused +# imports, and so `from grass_mil.utils import *` stays well defined. +__all__ = [ + "instantiate_callbacks", + "instantiate_loggers", + "log_hyperparameters", + "RankedLogger", + "enforce_tags", + "print_config_tree", + "extras", + "get_metric_value", + "task_wrapper", +] diff --git a/tests/configs/test_task_preset_composition.py b/tests/configs/test_task_preset_composition.py index 6ce7902..0c07407 100644 --- a/tests/configs/test_task_preset_composition.py +++ b/tests/configs/test_task_preset_composition.py @@ -37,9 +37,7 @@ def test_supervised_task_presets_compose(config_name: str, task_name: str) -> No @pytest.mark.parametrize("config_name", ROOT_CONFIGS) @pytest.mark.parametrize("task_name", SUPERVISED_TASKS) -def test_attention_width_matches_head_width_as_composed( - config_name: str, task_name: str -) -> None: +def test_attention_width_matches_head_width_as_composed(config_name: str, task_name: str) -> None: """The contract must hold on the *composed* config, not just in code. ``validate_attention_width`` runs at build time, but it can only see what @@ -67,7 +65,7 @@ def test_finetune_mil_composes_per_class_widths(config_name: str) -> None: channels. If ``model`` is merged after ``task`` in the defaults list, the module preset overwrites both and the published MIL head is not what runs. """ - cfg = _compose(config_name, [f"task=finetune_mil"]) + cfg = _compose(config_name, ["task=finetune_mil"]) assert int(cfg.model.graph_head.output_dim) == 2 assert int(cfg.model.attention.n_classes) == 2 assert cfg.task.target_type == "categorical" From ae89157c59a428c10bcc17ac3c3f7d4aa283e896 Mon Sep 17 00:00:00 2001 From: Lovro Rabuzin Date: Thu, 13 Aug 2026 14:36:01 +0200 Subject: [PATCH 2/9] Modernise the CI stack and fix the package on torch>=2.6 CI pinned torch 2.4.1 / numpy 1.26 / pandas 2.2 while a plain `pip install .` resolved torch 2.12 / numpy 2.5 / pandas 3.0, so users ran a stack CI never exercised. It did not work: torch 2.6 flipped the default of `torch.load(weights_only=...)` from False to True, and 11 tests fail on any modern torch. CI could not see it, because it pinned 2.4.1. Two fixes were needed: - Our own loaders (precomputed PyG graphs, first-party checkpoints) now pass weights_only=False explicitly. These read artifacts this pipeline wrote; weights_only=True cannot unpickle PyG Data without allowlisting internals that change between releases. - Lightning's checkpoint loader is not ours to change, and it fails on any checkpoint whose hyper_parameters hold an OmegaConf container -- which is every checkpoint this package writes. grass_mil._compat allowlists the ten OmegaConf/container types involved, all inert types whose construction cannot execute code, so the protection still applies to the rest of the file. The workflow moves from conda to pip. The conda pyg channel stopped publishing pytorch-sparse and pytorch-scatter at torch 2.4.0, so staying on conda meant staying on 2.4.0 forever. data.pyg.org publishes prebuilt wheels through torch 2.12, including macosx_11_0_universal2 -- which also removes the source build that broke the macOS runner. `--only-binary :all:` makes a source build fail loudly rather than silently start compiling. Verified locally on the exact CI configuration: 390 passed, 3 skipped, with the only skips being the two GPU tests and one pre-existing fixture limit. The torch-sparse-dependent sampler tests all run, so nothing is dropped. The old pinned stack still passes too. environment.ci-spatial.yaml is deleted; the CI stack is now pinned inline in the workflow via TORCH_VERSION, with a note on why it cannot be raised past 2.12. The packaging job deliberately stays unpinned so a break on the newest release surfaces there first. Co-Authored-By: Claude Opus 5 (1M context) --- .github/workflows/test.yml | 93 +++++++++++++------ src/grass_mil/__init__.py | 5 + src/grass_mil/_compat.py | 56 +++++++++++ src/grass_mil/data/components/datasets.py | 7 +- .../models/training/checkpoint_init.py | 6 +- 5 files changed, 138 insertions(+), 29 deletions(-) create mode 100644 src/grass_mil/_compat.py diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 6e2b78a..d48477e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -6,6 +6,16 @@ on: pull_request: branches: [main, "release/*", "dev"] +env: + # Bump these together. torch-scatter/torch-sparse are only published for a + # subset of torch releases: https://data.pyg.org/whl/ has no wheels beyond + # torch 2.12, so raising TORCH_VERSION past it means those extensions would + # have to build from source, which fails on macOS (PyTorch's own + # c10/util/strong_type.h specializes std::is_arithmetic, which recent libc++ + # rejects). Check the index before changing this. + TORCH_VERSION: "2.12.0" + PYTHON_VERSION: "3.12" + jobs: run-tests: name: Pytest (${{ matrix.os }}) @@ -20,18 +30,36 @@ jobs: - name: Checkout uses: actions/checkout@v5 - - name: Set up conda env (spatial-pinned) - uses: conda-incubator/setup-miniconda@v3 + - name: Set up Python + uses: actions/setup-python@v6 with: - activate-environment: spatial - environment-file: environment.ci-spatial.yaml - auto-activate: false - mamba-version: "*" - channels: pyg,pytorch,conda-forge,defaults - channel-priority: flexible - - - name: Show Python and key package versions - shell: bash -el {0} + python-version: ${{ env.PYTHON_VERSION }} + cache: pip + + # Linux resolves CUDA builds by default, which are ~3GB and useless on a + # CPU runner. macOS wheels on PyPI are already CPU/MPS only, and the + # download.pytorch.org cpu index does not publish macOS builds. + - name: Install PyTorch (CPU) + run: | + python -m pip install --upgrade pip + if [ "$RUNNER_OS" = "Linux" ]; then + pip install "torch==${TORCH_VERSION}" --index-url https://download.pytorch.org/whl/cpu + else + pip install "torch==${TORCH_VERSION}" + fi + + # Prebuilt binaries. Never let these build from source; see the note on + # TORCH_VERSION above. + - name: Install PyG compiled extensions + run: | + pip install torch-scatter torch-sparse \ + --only-binary :all: \ + -f "https://data.pyg.org/whl/torch-${TORCH_VERSION}+cpu.html" + + - name: Install the package + run: pip install ".[interpretability,io]" pytest + + - name: Show key package versions run: | python --version python - <<'PY' @@ -39,12 +67,19 @@ jobs: checks = [ "torch", + "torch_geometric", + "torch_scatter", + "torch_sparse", "lightning", "pytorch_lightning", + "torchmetrics", "omegaconf", "hydra", + "numpy", + "pandas", + "scipy", + "sklearn", "plotly", - "torch_geometric", ] for name in checks: mod = importlib.import_module(name) @@ -52,7 +87,6 @@ jobs: PY - name: Run pytest - shell: bash -el {0} run: pytest -v code-coverage: @@ -63,20 +97,23 @@ jobs: - name: Checkout uses: actions/checkout@v5 - - name: Set up conda env (spatial-pinned) - uses: conda-incubator/setup-miniconda@v3 + - name: Set up Python + uses: actions/setup-python@v6 with: - activate-environment: spatial - environment-file: environment.ci-spatial.yaml - auto-activate: false - mamba-version: "*" - channels: pyg,pytorch,conda-forge,defaults - channel-priority: flexible + python-version: ${{ env.PYTHON_VERSION }} + cache: pip + + - name: Install PyTorch (CPU) and PyG extensions + run: | + python -m pip install --upgrade pip + pip install "torch==${TORCH_VERSION}" --index-url https://download.pytorch.org/whl/cpu + pip install torch-scatter torch-sparse \ + --only-binary :all: \ + -f "https://data.pyg.org/whl/torch-${TORCH_VERSION}+cpu.html" - name: Run tests and collect coverage - shell: bash -el {0} run: | - pip install pytest-cov[toml] + pip install ".[interpretability,io]" pytest "pytest-cov[toml]" pytest --cov grass_mil - name: Upload coverage to Codecov @@ -91,14 +128,18 @@ jobs: - name: Checkout uses: actions/checkout@v5 + # Deliberately the oldest supported Python, so `requires-python` is + # exercised at its floor rather than only at the version CI happens to use. - name: Set up Python uses: actions/setup-python@v6 with: python-version: "3.11" + cache: pip - # A plain pip install, deliberately outside conda: this is the path a - # downstream user takes, and it is the one that silently rots when the - # package layout or the config tree moves. + # A plain, unpinned pip install: this is the path a downstream user takes, + # and it is the one that silently rots when the package layout or the + # config tree moves. It deliberately does NOT pin torch, so a dependency + # that breaks on the latest release shows up here first. - name: Install the package run: pip install . diff --git a/src/grass_mil/__init__.py b/src/grass_mil/__init__.py index e69de29..56ad939 100644 --- a/src/grass_mil/__init__.py +++ b/src/grass_mil/__init__.py @@ -0,0 +1,5 @@ +from grass_mil._compat import allow_omegaconf_in_checkpoints + +# Applied at import so every entrypoint and any user code that loads a +# checkpoint gets it. See _compat for why this is needed under torch>=2.6. +allow_omegaconf_in_checkpoints() diff --git a/src/grass_mil/_compat.py b/src/grass_mil/_compat.py new file mode 100644 index 0000000..9409419 --- /dev/null +++ b/src/grass_mil/_compat.py @@ -0,0 +1,56 @@ +"""Cross-version compatibility shims applied at package import. + +Currently only one: allowlisting the OmegaConf types that appear inside +Lightning checkpoints. + +PyTorch 2.6 flipped the default of ``torch.load(weights_only=...)`` from False +to True. Our own loaders pass ``weights_only=False`` explicitly, because they +read first-party artifacts. Lightning's checkpoint loader +(``lightning.fabric.utilities.cloud_io._load``) is not ours to change, and it +fails on any checkpoint whose ``hyper_parameters`` hold an OmegaConf container +-- which is every checkpoint this package writes, since the modules save their +Hydra config. + +Allowlisting is preferable to disabling the check: the entries below are inert +container and metadata types whose construction cannot execute arbitrary code, +so the protection still applies to everything else in the file. +""" + +from __future__ import annotations + +import collections +import typing + + +def allow_omegaconf_in_checkpoints() -> None: + """Register OmegaConf container types as safe for ``torch.load``. + + A no-op on torch versions without ``add_safe_globals`` (< 2.4) and on any + OmegaConf layout that no longer exposes these names, so an upstream rename + degrades to the previous behaviour rather than breaking package import. + """ + try: + import torch.serialization as ts + except Exception: # torch missing or partially initialised + return + + add = getattr(ts, "add_safe_globals", None) + if add is None: + return + + safe: list = [dict, list, int, typing.Any, collections.defaultdict] + try: + from omegaconf.base import ContainerMetadata, Metadata + from omegaconf.dictconfig import DictConfig + from omegaconf.listconfig import ListConfig + from omegaconf.nodes import AnyNode + + safe += [DictConfig, ListConfig, ContainerMetadata, Metadata, AnyNode] + except Exception: + return + + try: + add(safe) + except Exception: + # Never let a compatibility shim break importing the package. + return diff --git a/src/grass_mil/data/components/datasets.py b/src/grass_mil/data/components/datasets.py index ced8651..d6c5f23 100644 --- a/src/grass_mil/data/components/datasets.py +++ b/src/grass_mil/data/components/datasets.py @@ -60,7 +60,12 @@ def __len__(self) -> int: def __getitem__(self, idx: int) -> torch.nn.Module: entry = self.entries[idx] - data = torch.load(entry.path) + # weights_only=False is required: these are PyG `Data` objects written + # by our own precompute step, not bare tensors. torch>=2.6 defaults the + # flag to True, which cannot unpickle `DataEdgeAttr`/`GlobalStorage` + # without allowlisting a set of PyG internals that changes between + # releases. The file is first-party, produced by this pipeline. + data = torch.load(entry.path, weights_only=False) return _migrate_legacy_attributes(data) diff --git a/src/grass_mil/models/training/checkpoint_init.py b/src/grass_mil/models/training/checkpoint_init.py index e555018..a99715d 100644 --- a/src/grass_mil/models/training/checkpoint_init.py +++ b/src/grass_mil/models/training/checkpoint_init.py @@ -18,7 +18,9 @@ def load_state_dict_with_optional_mapping( ckpt_path = Path(init_from_ckpt) if not ckpt_path.exists(): raise FileNotFoundError(f"Checkpoint not found: {init_from_ckpt}") - raw = torch.load(str(ckpt_path), map_location="cpu") + # First-party Lightning checkpoint; see the note in data/components/datasets.py + # on why weights_only must be set explicitly under torch>=2.6. + raw = torch.load(str(ckpt_path), map_location="cpu", weights_only=False) state_dict = raw["state_dict"] if isinstance(raw, dict) and "state_dict" in raw else raw if not isinstance(state_dict, dict): raise ValueError("Checkpoint must resolve to a state_dict dictionary.") @@ -67,7 +69,7 @@ def read_graph_head_bias( import torch - payload = torch.load(checkpoint_path, map_location="cpu") + payload = torch.load(checkpoint_path, map_location="cpu", weights_only=False) state = payload.get("state_dict", payload) if isinstance(payload, dict) else payload if not isinstance(state, dict): raise ValueError(f"Checkpoint {checkpoint_path!r} holds no state dict.") From 8d4e7f928a830023d702dc1264d0375e0c9af3d7 Mon Sep 17 00:00:00 2001 From: Lovro Rabuzin Date: Thu, 13 Aug 2026 14:55:58 +0200 Subject: [PATCH 3/9] Replace the smoke notebooks with runnable vignettes, and add predict_dataloader The three notebooks were internal smoke tests, and they had stopped working: all of them still imported `from src.*`, two hardcoded an absolute config path from another machine, and one pointed at a `configs/` directory that moved into the package. Nothing referenced them except the docs. They are replaced by `vignettes/`, two worked examples on a public dataset: - 01: squidpy's mibitof (MIBI-TOF colorectal carcinoma, 3 images, 36 markers, 8 cell types) -> manifest + per-sample h5ad -> cellular graphs, with the coord_scale_um and tiling settings explained because getting them wrong silently rescales every downstream distance. - 02: BGRL pretraining (no labels), embedding export, and niche discovery through the interpretability report. Both were executed end to end via nbclient against the modernised stack before committing; they are stored without outputs. The vignettes are explicit about what three images can and cannot support: a correct sample-level split leaves one image per fold and the only genuine bag-level variable is single-class in training, so the supervised step is plumbing rather than a result. The weight is on graph construction, SSL and unsupervised niche discovery, which do stand on their own. Writing them surfaced a bug: SpatialOmicsDataModule implemented train/val/test dataloaders but not predict_dataloader, so `grass-mil-predict` -- a shipped console script -- failed with a Lightning MisconfigurationException against the real datamodule. The predict tests missed it because they use a stub datamodule. It now delegates to the test split, matching how exported tables line up with test metrics. Also removes the three notebook_* experiment configs, whose only consumers were the deleted notebooks. Known limitation, documented inline in vignette 2 rather than worked around: `interpretability.spatial.enabled=true` still fails under the ShaDow sampler. The sampler builds batches without Batch.from_data_list(), so to_data_list() raises inside a bare except, instance_graphs are never collected, and the error surfaces as "payload is missing instance_graphs" -- which points at the payload rather than the cause. The niche analysis does not depend on it. Co-Authored-By: Claude Opus 5 (1M context) --- .gitignore | 3 + README.md | 1 + docs/capabilities_and_modes.md | 7 +- docs/repository_map.md | 14 +- notebooks/.gitkeep | 0 notebooks/data_loading_testing.ipynb | 472 ------------ notebooks/model_components_testing.ipynb | 685 ------------------ notebooks/training_logic_testing.ipynb | 541 -------------- .../notebook_data_shadow_custom.yaml | 35 - .../experiment/notebook_model_components.yaml | 37 - .../experiment/notebook_training_logic.yaml | 44 -- .../data/spatial_omics_datamodule.py | 11 + vignettes/01_anndata_to_spatial_graphs.ipynb | 337 +++++++++ vignettes/02_pretraining_and_niches.ipynb | 415 +++++++++++ vignettes/README.md | 46 ++ vignettes/data/anndata/mibitof.h5ad | Bin 0 -> 20272897 bytes 16 files changed, 822 insertions(+), 1826 deletions(-) delete mode 100644 notebooks/.gitkeep delete mode 100644 notebooks/data_loading_testing.ipynb delete mode 100644 notebooks/model_components_testing.ipynb delete mode 100644 notebooks/training_logic_testing.ipynb delete mode 100644 src/grass_mil/configs/experiment/notebook_data_shadow_custom.yaml delete mode 100644 src/grass_mil/configs/experiment/notebook_model_components.yaml delete mode 100644 src/grass_mil/configs/experiment/notebook_training_logic.yaml create mode 100644 vignettes/01_anndata_to_spatial_graphs.ipynb create mode 100644 vignettes/02_pretraining_and_niches.ipynb create mode 100644 vignettes/README.md create mode 100644 vignettes/data/anndata/mibitof.h5ad diff --git a/.gitignore b/.gitignore index 74e0a5c..58302a1 100644 --- a/.gitignore +++ b/.gitignore @@ -151,3 +151,6 @@ configs/local/default.yaml # Aim logging .aim + +# Vignette scratch space (downloaded data, graphs, runs) +vignettes/vignette_work/ diff --git a/README.md b/README.md index 323d3f5..2737e44 100644 --- a/README.md +++ b/README.md @@ -102,6 +102,7 @@ grass-mil-eval \ ## Documentation Index +- Worked examples on a public dataset: [`vignettes/`](vignettes/README.md) - Full tracked-file map: [`docs/repository_map.md`](docs/repository_map.md) - Dataset onboarding and preparation checklist: [`docs/dataset_preparation.md`](docs/dataset_preparation.md) - End-to-end workflows (new data, SSL pretrain->finetune, model adjustments, inference): [`docs/workflows_train_infer.md`](docs/workflows_train_infer.md) diff --git a/docs/capabilities_and_modes.md b/docs/capabilities_and_modes.md index 9d384b4..7bb7ba9 100644 --- a/docs/capabilities_and_modes.md +++ b/docs/capabilities_and_modes.md @@ -167,9 +167,10 @@ Validation (during `src/grass_mil/train.py`) includes: Notebooks support interactive smoke validation of: -- data loading and graph construction (`notebooks/data_loading_testing.ipynb`) -- component compatibility matrix (`notebooks/model_components_testing.ipynb`) -- training regime smoke behavior (`notebooks/training_logic_testing.ipynb`) +- ingesting a public AnnData cohort and building cellular graphs + (`vignettes/01_anndata_to_spatial_graphs.ipynb`) +- self-supervised pretraining and spatial-niche discovery + (`vignettes/02_pretraining_and_niches.ipynb`) ## 12) CI And Quality Modes diff --git a/docs/repository_map.md b/docs/repository_map.md index 5de44e4..e6c3bef 100644 --- a/docs/repository_map.md +++ b/docs/repository_map.md @@ -83,9 +83,6 @@ Sampler subgroup: ### Experiment Config Group - `configs/experiment/debug.yaml`: Dummy-data composition for notebook/debug experiments. -- `configs/experiment/notebook_data_shadow_custom.yaml`: Notebook data-loading scenario with shadow sampler. -- `configs/experiment/notebook_model_components.yaml`: Notebook scenario for component-combination checks. -- `configs/experiment/notebook_training_logic.yaml`: Notebook scenario for training-regime smoke tests. ### Extras/Hydra/Paths Groups @@ -111,7 +108,7 @@ Root model module configs: - `configs/model/supervised_module.yaml`: Unified supervised module defaults (mean/MIL via task config). - `configs/model/bgrl_module.yaml`: BGRL pretraining module defaults. -- `configs/model/components.yaml`: Component-instantiation playground config used in notebooks/tests. +- `configs/model/components.yaml`: Component-instantiation config used by the component tests. Encoder presets: @@ -411,12 +408,11 @@ Reporting: - `docs/interpretability_suite.md`: Interpretability architecture, contracts and plugin catalog. - `docs/interpretability_extension_guide.md`: How to add a new analysis plugin. -### Notebooks +### Vignettes -- `notebooks/.gitkeep`: Placeholder to keep notebook directory tracked. -- `notebooks/data_loading_testing.ipynb`: Interactive data-loading and graph-construction smoke notebook. -- `notebooks/model_components_testing.ipynb`: Interactive model-component combinatorial smoke notebook. -- `notebooks/training_logic_testing.ipynb`: Interactive training-regime smoke notebook. +- `vignettes/README.md`: Index, dataset description and honest scope notes. +- `vignettes/01_anndata_to_spatial_graphs.ipynb`: squidpy AnnData to manifest to cellular graphs. +- `vignettes/02_pretraining_and_niches.ipynb`: BGRL pretraining, embedding export and niche discovery. ### Data/Logs Placeholders diff --git a/notebooks/.gitkeep b/notebooks/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/notebooks/data_loading_testing.ipynb b/notebooks/data_loading_testing.ipynb deleted file mode 100644 index 2688e06..0000000 --- a/notebooks/data_loading_testing.ipynb +++ /dev/null @@ -1,472 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "cd8633b7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1.50M/1.50M [00:00<00:00, 5.24MB/s]\n" - ] - } - ], - "source": [ - "import squidpy as sq\n", - "\n", - "adata = sq.datasets.imc(\"data/dummy/imc_data.h5ad\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "212a2cc0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['1021522Tm169Di EGFR', '1031747Er167Di ECadhe', '112475Gd156Di Estroge',\n", - " '117792Dy163Di GATA3', '1261726In113Di Histone', '1441101Er168Di Ki67',\n", - " '174864Nd148Di SMA', '1921755Sm149Di Vimenti', '198883Yb176Di cleaved',\n", - " '201487Eu151Di cerbB', '207736Tb159Di p53', '234832Lu175Di panCyto',\n", - " '3111576Nd143Di Cytoker', 'Nd145Di Twist', '312878Gd158Di Progest',\n", - " '322787Nd150Di cMyc', '3281668Nd142Di Fibrone', '346876Sm147Di Keratin',\n", - " '3521227Gd155Di Slug', '361077Dy164Di CD20', '378871Yb172Di vWF',\n", - " '473968La139Di Histone', '651779Pr141Di Cytoker', '6967Gd160Di CD44',\n", - " '71790Dy162Di CD45', '77877Nd146Di CD68', '8001752Sm152Di CD3epsi',\n", - " '92964Er166Di Carboni', '971099Nd144Di Cytoker', '98922Yb174Di Cytoker',\n", - " 'phospho Histone', 'phospho S6', 'phospho mTOR', 'Area'],\n", - " dtype='object')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "adata.var_names" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "26efb64c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1.70909091, 15.32727273],\n", - " [ 3.84946237, 42.07526882],\n", - " [ 0.86666667, 50.33333333],\n", - " ...,\n", - " [730.14285714, 636.96428571],\n", - " [730.375 , 658.04166667],\n", - " [729.87628866, 679.63917526]])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "adata.obsm[\"spatial\"]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e9cf6596", - "metadata": {}, - "outputs": [], - "source": [ - "adata.write_h5ad(\n", - " \"/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/data/dummy/imc_data.h5ad\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e2a988d2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING: Please specify a valid `library_id` or set it permanently in `adata.uns['spatial']`\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/squidpy/pl/_spatial_utils.py:946: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", - " _cax = scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sq.pl.spatial_scatter(adata, shape=None, color=\"cell type\", size=10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5a3f56ff", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "task_name: train\n", - "tags:\n", - "- dev\n", - "train: true\n", - "test: true\n", - "ckpt_path: null\n", - "seed: null\n", - "data:\n", - " _target_: src.data.spatial_omics_datamodule.SpatialOmicsDataModule\n", - " data_dir: ${paths.data_dir}\n", - " raw_manifest_path: ${paths.data_dir}/dummy/manifest.csv\n", - " processed_dir: ${paths.data_dir}/dummy/processed\n", - " batch_size: 1\n", - " num_workers: 0\n", - " pin_memory: false\n", - " coord_scale_um: 1.0\n", - " sample_unit: tile\n", - " reducer_scope: sample\n", - " keep_raw_molecular: false\n", - " force_precompute: false\n", - " min_cells: 10\n", - " use_molecular_features: true\n", - " categorical_features:\n", - " include_labels:\n", - " - cell type\n", - " split:\n", - " train_val_test_split:\n", - " - 1.0\n", - " - 0.0\n", - " - 0.0\n", - " split_by: sample\n", - " manifest:\n", - " sample_id: sample_id\n", - " input_path: input_path\n", - " input_type: input_type\n", - " region_id: region_id\n", - " polygons_path: polygons_path\n", - " csv:\n", - " sep: ','\n", - " coord_columns:\n", - " - x\n", - " - 'y'\n", - " cell_id_column: cell_id\n", - " categorical_label_columns: []\n", - " molecular_columns: null\n", - " h5ad:\n", - " coord_source: obsm\n", - " coord_key: spatial\n", - " coord_columns:\n", - " - x\n", - " - 'y'\n", - " cell_id_column: null\n", - " categorical_label_columns:\n", - " - cell type\n", - " molecular_layer: null\n", - " molecular_features: null\n", - " sce:\n", - " assay_name: null\n", - " coord_source: colData\n", - " coord_key: null\n", - " coord_columns:\n", - " - x\n", - " - 'y'\n", - " cell_id_column: null\n", - " categorical_label_columns: []\n", - " transpose_assay: true\n", - " molecular_features: null\n", - " graph_builder:\n", - " name: delaunay\n", - " kwargs:\n", - " edge_features:\n", - " - distance\n", - " - neighbor\n", - " neighbor_cutoff_um: 20.0\n", - " feature_reducer:\n", - " name: identity\n", - " kwargs: {}\n", - " tiling:\n", - " tile_size_um: 300.0\n", - " stride_um: 300.0\n", - " min_cells: 10\n", - " graph_labels:\n", - " label_file: null\n", - " id_column: id\n", - " tasks: null\n", - " scope: region\n", - " transforms: []\n", - "callbacks:\n", - " model_checkpoint:\n", - " _target_: lightning.pytorch.callbacks.ModelCheckpoint\n", - " dirpath: ${paths.output_dir}/checkpoints\n", - " filename: epoch_{epoch:03d}\n", - " monitor: val/acc\n", - " verbose: false\n", - " save_last: true\n", - " save_top_k: 1\n", - " mode: max\n", - " auto_insert_metric_name: false\n", - " save_weights_only: false\n", - " every_n_train_steps: null\n", - " train_time_interval: null\n", - " every_n_epochs: null\n", - " save_on_train_epoch_end: null\n", - " early_stopping:\n", - " _target_: lightning.pytorch.callbacks.EarlyStopping\n", - " monitor: val/acc\n", - " min_delta: 0.0\n", - " patience: 100\n", - " verbose: false\n", - " mode: max\n", - " strict: true\n", - " check_finite: true\n", - " stopping_threshold: null\n", - " divergence_threshold: null\n", - " check_on_train_epoch_end: null\n", - " model_summary:\n", - " _target_: lightning.pytorch.callbacks.RichModelSummary\n", - " max_depth: -1\n", - " rich_progress_bar:\n", - " _target_: lightning.pytorch.callbacks.RichProgressBar\n", - "trainer:\n", - " _target_: lightning.pytorch.trainer.Trainer\n", - " default_root_dir: ${paths.output_dir}\n", - " min_epochs: 1\n", - " max_epochs: 10\n", - " accelerator: cpu\n", - " devices: 1\n", - " check_val_every_n_epoch: 1\n", - " deterministic: false\n", - "paths:\n", - " root_dir: ${oc.env:PROJECT_ROOT}\n", - " data_dir: ${paths.root_dir}/data/\n", - " log_dir: ${paths.root_dir}/logs/\n", - " output_dir: ${hydra:runtime.output_dir}\n", - " work_dir: ${hydra:runtime.cwd}\n", - "extras:\n", - " ignore_warnings: false\n", - " enforce_tags: true\n", - " print_config: true\n", - "\n", - "Num graphs: 9\n", - "Data(\n", - " x=[762, 34],\n", - " edge_index=[2, 4536],\n", - " pos=[762, 2],\n", - " edge_attr=[4536, 2],\n", - " edge_attr_names=[2],\n", - " categorical_index=[762, 1],\n", - " categorical_labels=[1],\n", - " categorical_slices={ cell type=0 },\n", - " sample_id='s1',\n", - " region_id='r1',\n", - " patch_id='s1_r1_patch_0'\n", - ")\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/src/data/components/datasets.py:43: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " data = torch.load(entry.path)\n" - ] - } - ], - "source": [ - "import hydra\n", - "import rootutils\n", - "from omegaconf import OmegaConf\n", - "\n", - "rootutils.setup_root(\"..\", indicator=\".project-root\", pythonpath=True)\n", - "\n", - "from src.data.spatial_omics_datamodule import SpatialOmicsDataModule\n", - "\n", - "with hydra.initialize_config_dir(\n", - " config_dir=\"/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/configs\",\n", - " version_base=\"1.3\",\n", - "):\n", - " cfg = hydra.compose(\n", - " config_name=\"train\",\n", - " overrides=[\n", - " \"experiment=debug\",\n", - " \"hydra/job_logging=stdout\",\n", - " \"hydra/hydra_logging=none\",\n", - " ],\n", - " )\n", - "\n", - "print(OmegaConf.to_yaml(cfg))\n", - "\n", - "dm: SpatialOmicsDataModule = hydra.utils.instantiate(cfg.data)\n", - "dm.prepare_data()\n", - "dm.setup()\n", - "\n", - "dataset = dm.train_dataloader().dataset\n", - "print(f\"Num graphs: {len(dataset)}\")\n", - "print(dataset[0])" - ] - }, - { - "cell_type": "markdown", - "id": "0d282963", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "fb61b0b9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Data(\n", - " x=[762, 34],\n", - " edge_index=[2, 4536],\n", - " pos=[762, 2],\n", - " edge_attr=[4536, 2],\n", - " edge_attr_names=[2],\n", - " categorical_index=[762, 1],\n", - " categorical_labels=[1],\n", - " categorical_slices={ cell type=0 },\n", - " sample_id='s1',\n", - " region_id='r1',\n", - " patch_id='s1_r1_patch_0'\n", - ")" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ab2f2d37", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArQAAAK7CAYAAAADaBwPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3xkdb3//5ozvWYyM5mZTMpk0nt2s50FFliqgIqA7SsiooBi4V4VLNd+r15RUe+9KioiNkARQUB6L0vZlmTT22SSSTKZTKb3cj6/P8I5zCRTk12W9Xeej0cemXL6nPP5vD7vz7vwCCEEHBwcHBwcHBwcHKco1Mk+AA4ODg4ODg4ODo7NwAlaDg4ODg4ODg6OUxpO0HJwcHBwcHBwcJzScIKWg4ODg4ODg4PjlIYTtBwcHBwcHBwcHKc0nKDl4ODg4ODg4OA4peEELQcHBwcHBwcHxykNJ2g5ODg4ODg4ODhOaThBy8HBwcHBwcHBcUrDCVoOjncQd911F3g8HvsnEAhQXV2Na665BvPz8xve7sDAAK699lo0NDRAKpVCKpWiqakJ119/PQ4dOnQcz+DtZWZmBjweDz/60Y+O63bPOuusjN9h7Z/D4chYPhQK4Rvf+Aaam5shFouh1Wpx9tlnY2Jigl3m8OHDuPHGG9HV1QWlUgmDwYBzzz0Xzz777HE99uNBXV0dPvaxj53sw1jHRz7yEfB4PFxyySXrvqurq8v6W91www0Zy/X19eHiiy9GbW0tpFIpNBoN9uzZgz/96U9Z95lIJHDbbbehq6sLUqkUarUap512Gg4cOHBCzjGds846C2edddYJ3w8Hx78CgpN9ABwcHOv53e9+h9bWVkQiEbz44ov4/ve/jxdeeAHHjh2DXC4vaVu/+tWv8JnPfAYtLS34/Oc/j46ODvB4PIyMjOCee+7Bjh07MDk5iYaGhhN0Nqcev/jFL+D3+zM+C4fDuPDCC7Ft2zYYjUb282AwiLPPPhsLCwv48pe/jO7ubvh8Phw4cADhcJhd7p577sEbb7yBj3/84+jp6UEoFMLtt9+O/fv34/e//z0++tGPvm3ndyryz3/+Ew8++CBUKlXOZfbu3btucGMwGDLee71e1NTU4EMf+hCqqqoQCoXw5z//GVdddRVmZmbwH//xH+yyqVQKl112GV5++WXcfPPNOO200xAKhXD48GGEQqHje4IcHBybg3BwcLxj+N3vfkcAkIMHD2Z8/vWvf50AIH/6059K2t7LL79MKIoil156KYnFYlmX+etf/0rm5+c3fMzFEA6HT8h2rVYrAUB++MMfnpDtp3PXXXcRAOSOO+7I+Pzzn/88kcvlZGpqKu/6S0tL6z5LJpOku7ubNDQ0HNdj3Sxms5lcffXVJ/swWLxeL6mqqiK33XYbMZvN5OKLL163TK7Pi2XXrl2kpqYm47Of/OQnhKIo8uqrr254u5th3759ZN++fSdl3xwcpxqcywEHxynA7t27AQA2mw0zMzMQCAT4/ve/v265F198ETweD/fddx8A4Hvf+x74fD5+9atfQSQSZd32lVdeCZPJVPAYXn75ZezZswcSiQRVVVX4+te/jjvuuAM8Hg8zMzPscnV1dbjkkkvw97//HVu3boVEIsG3v/1tAMDPf/5znHnmmdDr9ZDL5ejq6sKtt96KRCKRsa+zzjoLnZ2deOmll7B7925IpVJ2n6lUKuvx3XbbbbBYLFAoFNizZw9ee+21gudUCr/97W+hUCjwgQ98gP0sHA7jjjvuwJVXXon6+vq86+v1+nWf8fl8bNu2DXNzcwX3/61vfQs8Hg9DQ0P40Ic+hLKyMhgMBnz84x+Hz+fLWDYajeIrX/kKLBYLRCIRqqqqcOONN8Lr9WYsl0gkcPPNN8NoNEImk+H000/HG2+8kXX/DocD119/PaqrqyESiWCxWPDtb38byWQyY7lf/vKX6OnpgUKhgFKpRGtrK7761a8WPL98fOELX0BlZSU+97nPbWo7+dDpdBAIMictf/azn+HMM89kn79SIYTgF7/4BbZs2QKpVIry8nJcccUVmJ6eXrfcrbfeCrPZDIlEgt7eXjz22GNZtzk0NITzzz8fMpkMFRUVuPHGG/HPf/4TPB4Pzz//fMayTz/9NPbv3w+VSgWZTIa9e/fimWeeyVhmeXkZ1113HWpqaiAWi1FRUYG9e/fi6aef3tA5c3CcNE62oubg4HiLXBban/3sZwQA+fWvf00IIeSyyy4jtbW1JJlMZix35ZVXEpPJRBKJBEkmk0QqlZI9e/Zs+rj6+/uJRCIh3d3d5N577yUPPfQQede73kXq6uoIAGK1WtllzWYzqaysJPX19eTOO+8kzz33HHnjjTcIIYT827/9G/nlL39JHn/8cfLss8+Sn/zkJ0Sn05FrrrkmY3/79u0jWq2WmEwm8j//8z/kiSeeIJ/73OcIAHLjjTeyyzEW2rq6OnLhhReSBx98kDz44IOkq6uLlJeXE6/Xu27ZjVgex8fHCQDyiU98IuPzF198kQAg//Vf/0VuuOEGolariVAoJNu2bSOPPPJIwe0mEgnS2NhItm7dWnDZb37zmwQAaWlpId/4xjfIU089RW677TYiFoszrh9N0+SCCy4gAoGAfP3rXydPPvkk+dGPfkTkcjnZunUriUaj7LJXX3014fF45Etf+hJ58sknyW233UaqqqqISqXKuE6Li4ukpqaGmM1m8qtf/Yo8/fTT5Lvf/S4Ri8XkYx/7GLvcPffcQwCQz372s+TJJ58kTz/9NLn99tvJ5z73uYLnl4unnnqKCIVC0tfXRwjJbYk1m81EqVQShUJBBAIBaWtrIz/60Y/WPSMMqVSKJBIJ4nQ6yc9//nMiEAjI7bffzn4/OzvLnstXvvIVotfrCZ/PJ+3t7eSuu+4q6tg/+clPEqFQSL7whS+Qxx9/nNx9992ktbWVGAwG4nA42OWY3/baa68ljz32GPn1r39NqqqqiNFozLDQLiwsEK1WS2pra8ldd91FHn30UXLVVVexz+Fzzz3HLvvHP/6R8Hg88t73vpf8/e9/Jw8//DC55JJLCJ/PJ08//TS73AUXXEAqKirIr3/9a/L888+TBx98kHzjG98g9957b1HnyMHxToETtBwc7yAYQfvaa6+RRCJBAoEAeeSRR0hFRQVRKpVsJ/jcc88RAOSBBx5g152fnycCgYB8+9vfJoQQ4nA4CADywQ9+cN1+kskkSSQS7B9N03mP68orryRyuZwsLy+zn6VSKdLe3p5V0PL5fDI2NpZ3m4yg+MMf/kD4fD5xu93sd/v27SMAyD/+8Y+MdT75yU8SiqKIzWYjhLwlUru6ujKEyxtvvEEAkHvuuYf9bGZmhvD5fPLxj38873Fl45ZbbiEA1k09MwJOpVKRvXv3koceeog88sgj5OyzzyY8Ho88/vjjebf7ta99jQAgDz74YMFjYETPrbfemvH5pz/9aSKRSNjf8PHHH8+63F/+8peMQdHIyAgBQP7t3/4tY7k///nP64T/9ddfTxQKBXvdGX70ox8RAGRoaIgQQshnPvMZolarC55LsQQCAVJXV0e+8pWvsJ/lErSf/vSnyZ133kleeOEF8uCDD5L/9//+HwFAPvKRj2Td9vXXX08AEABEJBKRX/ziFxnfv/rqq+xv297eTv7617+SJ554glxxxRUZ1zEXzPo//vGPMz6fm5sjUqmU3HzzzYQQQjweD5FIJOSyyy7LWO6VV14hADIE7Ze+9CXC4/HY681wwQUXZAjaUChENBoNufTSSzOWS6VSpKenh+zcuZP9TKFQkJtuuinvuXBwnApwgpaD4x0EI2jX/nV1dZGXX345Y9menh5y7rnnsu+//vWvE6FQSBYXFwkh+QVtT09PxvYL+aDq9fp1nSMhhHzrW9/KKmhzWRyPHDlCLr30UqLRaNad42uvvcYut2/fPqJUKtetzwj5P/7xj4SQtwTtl7/85YzlotEoAUD++7//O+95FUMikSBGo5F0dHSs+44Rfzqdjvj9fvbzUChETCYT2bt3b87t/uY3vyEAyBe+8IWijoMRtKOjoxmf33777QQAO9i5+eabCQDidDozlqNpmsjlcvKBD3yAEELIL37xCwKAHDp0aN35CgSCDEFbVVVFLr300oxBUCKRIENDQwQAKwb/8Ic/sPfcgw8+mDEA2gg33ngjaWpqIpFIhP2sFF/Zz3zmMwQAOXLkyLrvbDYbOXjwIPnnP/9JbrjhBkJRVMZzwAhKkUhEZmZm2M9pmia9vb2kuro6776/9rWvER6PR5aWltZdt927d7Oi8tFHHyUAyN/+9rd12zCbzRmCdufOnaSrq2vdcox/NyNon3rqKXaba/d9yy23EB6PR4LBICGEkHPOOYeo1Wry3e9+l7z66qskHo/nPS8OjncqnA8tB8c7kD/84Q84ePAgjh49ioWFBQwMDGDv3r0Zy3zuc5/DM888g7GxMSQSCfzmN7/BFVdcwUbg63Q6SKVS2Gy2ddu/++67cfDgQTz00ENFHc/Kysq6aHFgfQQ5Q2Vl5brPZmdnccYZZ2B+fh4/+9nP8NJLL+HgwYP4+c9/DgCIRCIFt82c28rKSsbnWq02471YLM66zY3w6KOPwuFw4BOf+MS675j9nnbaaVAqleznMpkM+/btw5EjR7Ju83e/+x2uv/56XHfddfjhD39Y0vEUOteVlRUIBAJUVFRkLMfj8WA0Gtlrx/xPz9gAAAKBYN0+lpaW8PDDD0MoFGb8dXR0AABcLhcA4KqrrsKdd94Jm82Gyy+/HHq9Hrt27cJTTz1V0jkCwBtvvIFf/OIXuPXWWxGNRuH1euH1ekHTNJLJJLxeL2KxWN5tfOQjHwGArP7UtbW12L59O971rnfhl7/8Ja677jp85StfwfLyMoC3rnNrayvMZjO7Ho/HwwUXXAC73Q6n05lz30tLSyCEwGAwrLtur732GnvNcv0O2T4r9jlcWloCAFxxxRXr9v2DH/wAhBC43W4AwF/+8hdcffXVuOOOO7Bnzx5oNBp89KMfXZeajoPjnQ6XtouD4x1IW1sbtm/fnneZD3/4w7jlllvw85//HLt374bD4cCNN97Ifs/n83HOOefgySefxOLiYobIbG9vB4CMYK58aLVatpNMJ1enx+Px1n324IMPIhQK4e9//3uGQOjr68u6jXz7Wyu4TiS//e1vIRKJcNVVV637rru7O+d6hBBQ1Hqbwe9+9zt84hOfwNVXX43bb78967XaDFqtFslkEsvLyxmilhACh8OBHTt2sMsBq9e0qqqKXS6ZTK4bMOh0OnR3d+O//uu/su4zPajwmmuuwTXXXINQKIQXX3wR3/zmN3HJJZdgfHw843cvxPDwMAghuOyyy9Z9Nzc3h/LycvzkJz/BTTfdlHMbhBAAyPo7rGXnzp24/fbbMT09jYqKCjQ0NEAmk214uzqdDjweDy+99BI76EiH+Sz9d1iLw+FAXV0d+77Y51Cn0wEA/vd//zdnQBsjgnU6HX7605/ipz/9KWZnZ/HQQw/hy1/+MpxOJx5//PGc58fB8U6Ds9BycJyiSCQSXHfddfj973+P2267DVu2bFlnxf3KV76CVCqFG264YV0mgVLYt28fnn32WdaqBAA0TbPZFIqBEW7pnTshBL/5zW+yLh8IBNZZkO+++25QFIUzzzyzlMPfMA6HA48++ije+973ZhXRlZWV2LNnD1555ZWMvLXhcBgvvPDCOjFx11134ROf+AQ+8pGPsBkijjf79+8HgHWFAu6//36EQiH2eyZh/5///OeM5f7617+uy1xwySWXYHBwEA0NDdi+ffu6v2xZMuRyOS666CJ87WtfQzwex9DQUEnnceGFF+K5555b92cwGLB7924899xzuOKKK/Ju4w9/+AMAFJWl4LnnngNFUWy2CoFAgPe85z0YGRnJGPgRQvD444+joaGBFY7ZuOSSS0AIwfz8fNZr1tXVxR6bRCJZ9zscOHBg3ezKvn37MDg4iOHh4YzP77333oz3e/fuhVqtxvDwcNZ9b9++PWvWk9raWnzmM5/Beeedl3N2gYPjnQpnoeXgOIX59Kc/jVtvvRWHDx/GHXfcse77vXv34uc//zk++9nPore3F9dddx06OjpAURQWFxdx//33A0DeZPUA8LWvfQ0PP/ww9u/fj6997WuQSqW4/fbb2eTyxVjAzjvvPIhEInzoQx/CzTffjGg0il/+8pfweDxZl9dqtfjUpz6F2dlZNDc349FHH8VvfvMbfOpTn0JtbW3B/a3FZrOhoaEBV199NX77298Wtc7vf/97JJPJrO4GDD/60Y9w9tln44ILLsAtt9wCHo+HH//4x3C5XPjud7/LLnfffffh2muvxZYtW3D99devS4+1devWrJa8UjnvvPPYY/H7/di7dy8GBgbwzW9+E1u3bmUtzW1tbfjIRz6Cn/70pxAKhTj33HMxODiIH/3oR+vuh+985zt46qmncNppp+Fzn/scWlpaEI1GMTMzg0cffRS33347qqur8clPfhJSqRR79+5FZWUlHA4Hvv/976OsrIy1DANgrY75ZgiMRmPWaXiJRAKtVptRQevuu+/G3//+d1x88cUwm83wer247777cO+99+JjH/sYenp62GWvu+46qFQq7Ny5EwaDAS6XC/fddx/+8pe/4Etf+lKGVfu73/0uHnvsMVx44YX41re+BZVKhTvuuAP9/f3461//mvd32Lt3L6677jpcc801OHToEM4880zI5XIsLi7i5ZdfRldXFz71qU+hvLwcX/ziF/Gf//mf+MQnPoErr7wSc3Nz+Na3vrXu/G+66SbceeeduOiii/Cd73wHBoMBd999N0ZHRwG89RwqFAr87//+L66++mq43W5cccUV0Ov1WF5eRn9/P5aXl/HLX/4SPp8PZ599Nj784Q+jtbUVSqUSBw8exOOPP473ve99ec+Pg+Mdx8ly3uXg4FhPrrRd+TjrrLOIRqPJW7ygr6+PXHPNNcRisRCxWEwkEglpbGwkH/3oR8kzzzxT1H5eeuklsmvXLiIWi4nRaCRf+tKXyA9+8AMCICM9Vr6gnYcffpj09PQQiURCqqqqyJe+9CXy2GOPrUs5tG/fPtLR0UGef/55sn37diIWi0llZSX56le/ShKJBLtcvsIKAMg3v/nNdcuWkrarubmZ1NXVFcwC8dJLL5F9+/YRmUxGZDIZOeecc8grr7ySsczVV1+dNeCP+UsPrMsGExS2NtCKuWfS149EIuSWW24hZrOZCIVCUllZST71qU8Rj8eTsW4sFiNf+MIXiF6vJxKJhOzevZu8+uqrWQsrLC8vk8997nPEYrEQoVBINBoN2bZtG/na177GBhj9/ve/J2effTYxGAxEJBIRk8lE3v/+95OBgYGMbel0OrJ79+6855uLbPfXq6++Svbv30+MRiMRCoVEJpORHTt2kF/84hcklUplLHvnnXeSM844g+h0OiIQCIharSb79u1jAw3XcuzYMXLxxRcTpVLJXqOHH3646OO98847ya5du4hcLidSqZQ0NDSQj370oxnBeDRNk+9///ukpqaGiEQi0t3dTR5++OGshRUGBwfJueeeSyQSCdFoNOTaa68lv//97wkA0t/fn7HsCy+8QC6++GKi0WiIUCgkVVVV5OKLLyb33XcfIWQ1ePKGG24g3d3dRKVSEalUSlpaWsg3v/lNEgqFij5HDo53AjxC3nQG4uDgOOVwOp0wm8347Gc/i1tvvfVt3//555+PmZkZjI+PH9ftnnXWWXC5XBgcHDyu2+U4+QwPD6OjowOPPPIILr744pN9OP8SXHfddbjnnnuwsrKSs4AKB8e/OpzLAQfHKYjdbsf09DR++MMfgqIofP7znz/h+/z3f/93bN26FTU1NXC73fjzn/+Mp556qujpew4OYNVXdc+ePZyY3SDf+c53YDKZUF9fj2AwiEceeQR33HEH/uM//oMTsxz/v4YTtBwcpyB33HEHvvOd76Curg5//vOfM6LUTxSpVArf+MY34HA4wOPx0N7ejj/+8Y9saiQOjmK48cYbM7JxcJSGUCjED3/4Q9jtdiSTSTQ1NeG22257Wwa1HBzvZDiXAw4ODg4ODg4OjlMaLm0XBwcHBwcHBwfHKQ0naDk4ODg4ODg4OE5pOEHLwcHBwcHBwcFxSsMFhWG14tHCwgKUSuUJqdzDwcHBwcHBwcFROoQQBAIBmEymvEV8OEELYGFhATU1NSf7MDg4ODg4ODg4OLIwNzeH6urqnN9zghaAUqkEsHqxCpUA5eDg4ODg4ODgeHvw+/2oqalhtVouOEELsG4GKpWKE7QcHBwcHBwcHO8wCrmEckFhHBwcHBwcHBwcpzScoOXg4ODg4ODg4Dil4QQtBwcHBwcHBwfHKQ0naDk4ODg4ODg4OE5pOEHLwcHBwcHBwcFxSsMJWg4ODg4ODg4OjlMaTtBycHBwcHBwcHCc0nCCloODg4ODg4OD45SGE7QcHBwcHBwcHBynNJyg5eDg4ODg4ODgOKXhBC0HBwcHBwcHB8cpDSdoOTg4ODg4ODg4Tmk4QcvBwcHBwcHBwXFKwwlaDg4ODg4ODg6OUxpO0HJwcHBwcHBwcJzScIKWg4ODg4ODg4PjlIYTtBwcHBwcHBwcHKc0nKDl4ODg4ODg4OA4peEELQcHBwcHBwcHxykNJ2g5ODg4ODg4ODhOaU6qoP3lL3+J7u5uqFQqqFQq7NmzB4899hj7PSEE3/rWt2AymSCVSnHWWWdhaGgoYxuxWAyf/exnodPpIJfL8e53vxt2u/3tPhUODg4ODg4ODo6TxEkVtNXV1fjv//5vHDp0CIcOHcI555yD97znPaxovfXWW3Hbbbfh//7v/3Dw4EEYjUacd955CAQC7DZuuukmPPDAA7j33nvx8ssvIxgM4pJLLkEqlTpZp/UvA00IVqIh+OKRk30oHBynLIQQpGj6ZB8GBwcHx780PEIIOdkHkY5Go8EPf/hDfPzjH4fJZMJNN92EW265BcCqNdZgMOAHP/gBrr/+evh8PlRUVOCPf/wjPvCBDwAAFhYWUFNTg0cffRQXXHBBUfv0+/0oKyuDz+eDSqU6Yed2KuGNhfG/Q8/DHvICALbpanFNyx4IKf7JPTAOjlOIVxxTuG/6CCKpBMwKDa5rOx06ieJkH9YJh/iWQRamwBNLAXMHeHxB8esmE6Bf/Csw1QeIJODtvBhU2+4Td7Ac/1Ik6RSOuObgi0dgUWrRWKY/2YfEsUmK1WjFtzInmFQqhfvuuw+hUAh79uyB1WqFw+HA+eefzy4jFouxb98+HDhwANdffz0OHz6MRCKRsYzJZEJnZycOHDiQU9DGYjHEYjH2vd/vP3EndpIghOA1pxUDK/MQ8vk429QMi1JX9Pp3jr2KhZCPfX/ENQuDVIn31PWciMP9lyOWSoKAQMIXnuxDOSHEYjGMjIwgEAhALpejra0NUqn0ZB/WO4oRjwN/mHidfT8X9OB/Bp/DN7ddDD7vXzd8gViPgX7o/4BUEgQAjBZQV34JPKG4qPXpp34PjL4GvGlrIY/9BkQsBa/+xLc9STqFB6x9eH3ZBgGPwv6qFpxb1Qoej3fC9/2vAIlHQD//F2B2BJAqQJ1+OXjm9rdt/wk6hZ8MPIOpgAs8AATA+yxbcEH123cMhXCE/Rj3LUHCF6JHWw1xCYM9jvyc9Ct57Ngx7NmzB9FoFAqFAg888ADa29tx4MABAIDBYMhY3mAwwGazAQAcDgdEIhHKy8vXLeNwOHLu8/vf/z6+/e1vH+cz2RyTvmU8vziOeCqJHm01TjPUb6oRfdI+gr/P9IEHgAceDi7b8MXuc9GgqshYLh6PI5lMIhwOIxgMIhQKIRqN4sUDzyMWjWHs8RcQ9YehNGgxoFTjlZpmiMViiEQiSCQS8Pl88Pl8CIVCCIVC9jVFUeDxeKAoKuNPKFwVeBRFQSAQgKJWO3bmXJn3a19n+2ztuumfpS+X7ftgMgZnNAClQIJKhTrvvkv5HZKExgMzfRhyLwIAWsr0eF/9Voip4/+oZbs+bwepVAqHDx9GJBIBIQQ8Hg9Hjx7Fzp07IRDkPs+Tdbxrod+c/qdpOuN1+v9sr5n3zKTW2s/SXyeTSTxpPYZpxww8TheWBybQeuHpsEnEeMBJoEmz0jLXhc9/a/Yj3/OQ7X5mrnuu+3bt9tKXS//N1n6f7TfL9zwQQkD+9GMgHsWqnADgHQTvkT+Ct+18UBTFXrdUKsW+Zv6SiThSTz8CmhC8bnVALhTBoJaC98c7INl3OduOCAQC8Hg88Pl8th2hKIq9hrmuQ7ZzTX/90Ew/Xlu2MUeOPyzY4XOt4ExTc8ayhe7lYu/1YpY7Hsscr/3kW44QAvzj56tiltCAdxn0334M6kNfBc9o2dC+SuWAYxrTAdfq8bz52QPWPuzRW6ASnfwBd/+KHb8aeQmpN9sQg1SJW3ougFwoOslH9q/BSRe0LS0t6Ovrg9frxf3334+rr74aL7zwAvv92saT6UDzUWiZr3zlK/j3f/939r3f70dNTc0Gz2DzTPicuG3gGRAABAT97nn4E1FcVNNRcF2appFMJllhGo/HEYvFcPeBpxCKRRFa8QI8gJei8eO+GZxX1Yp4PI5EIgEAbIcgEokgl8shkUigUCig0esRE/BgPm8P+JQAcW8YjWo9zurciUgkwgrfZDKJVCrFdk48Hg+xWIwVrzwej+2sGJHLkN6RE0JYccx0SkynxePxWMFAURQIIes6I+aztR0Z81n6OmP+JTw+N4IUTYOieNiiq8F+Uwv4fH6GEKc34Pf49PwojqZ1iMcCISAcw0W1newyxXj55BMv6Z9TFIVAIAC73Q5CCMrLy1FdXb1uHeY/cw3znVu6YGOWTV9naWkJi4uLIIRgcnIS7e3tEIvFWF5eRlVVVcay6aIvmUxmFYPp/3N9X8w1y3dOcTqFBJ2ClC+EgM/PuH7p1yib8GOE0tr7NxaLIR6PIx6PIxqNIhaLscfA5/MhFPCRiEQhkUogM5SD8IBkOAoRX8AGsa499myCOtt1SL8e+QR6eixBPvGeft0ZmHVLeg5iEcRsdrgCUdw/MI39jdVorSwHjg2AJ61eN8BlRCl7v4MAKRp8EDhDMUgFKURJCjptFHG/nxXCiURi1Tc5lWIHENmuEXPvpp8H8xumty1Mm/OPyUOIExoe+zyEIiGkKiX+eHgMgYbeddc9fX/MdnLBtIP+WARROgWVUAyJQJhxP2Vbf+121/4W2dqEfP0f0xbmGuysbSfWLpP+msfjsW0/IQR0JIDEs38DDaB/1oVzGvRQlalA//528LrPWh3spA38mGvHfLb2u/RzLvYePOSaxYR7AfFEAktD46g/fQckWjVeIAdQKSvLayTJNihKN7qk36drv0t/nes7QgjuGn+NFbMAsBwJ4rG5IVxRv7Wo8zsRuKJBvO60IkHT6NFWlTST+07jpAtakUiExsZGAMD27dtx8OBB/OxnP2P9Zh0OByorK9nlnU4na7U1Go2Ix+PweDwZVlqn04nTTjst5z7FYjHE4uKmv94Onp4fBQFBxO9HYMkNgVCAP07NQd3iRzKZRDQaRTQaZUVrunWDEX0CgYD9EwqFcC8tA3wKyyPTkOnUqNzSCpPejP29+yESiSASifKOkq83leHOsVeh8VRA31oPHgE+pu8Czx+BTqdDTU1NhrWDOUamY2f+x+PxjO0KBAJWRKe/BoBEIoFkMsmKZEasr4VpbCmKwoRvGYdcs6B5BN3aaux80xKwtoFhGilfJITf9Q1BbtCCpGgQQmMs5Uc3P4lWtTbDWsR0lOnvmeNa+5o5ruEFG6KRMJbGrSDJBEydLRiNzWGfrp79nZiONN3KlO23KCQ4aJpGMBhEX18f+9nCwgI8Hg9qa2vXbSe9M2OOP5VKIRaLZVzvRCIBmqbZQU8qlWLX4fF4CAaDWFpags/nw8jICCQSCWiahsfjQVVVFeRyOeRyOTugAVafOcZ6LxaL2fuUeS2RSCASidj7gjnefJbCYiCE4EFbP56YGwbBqkXkxo59MEjz+8rTNI1oNIpwOIxwOIxIJIJIJMLejxRFQS6Xo6KiAmKxGDKZDDKZDAKBAPF4HFarFQq3Bi6TEtFYDMaORoAGLtpzJs40dmBxcRFutxsKhQIGgwFqtfodY8HeCDRNw+l0YnFhAUFVGUB4uOnMTmgVMpTJxKg7dz+o0y4salupwHsR738RfD4fW6q0cAWjmN2yH5qODlgsluNynZh7fa2F+OWnonDM2RH2BaBrqoNIIkSlSIGqqip2XZFIBLFYDKlUCqFQCKlUColEkve4CCH4u7UP/U4rACFElABXN+9Gs3pj/p35ZhKyvWbaVpqmEY/HM/6nvyaEIB6Ps20Ds04u0mfjeBIREjIp7N4QvPEEIikCLUWhplIPzY4d64Tj2ve5Xpfye7c5Z3DH2AHQySQqmi2QacoQc3lgrjCitaEJItF6S+jae6DYv2g0yorwbH9rvwvHohh79TAS4TBWJmehba6HyqDBocUA6typdX3i2tfZ/jb7LCyEvPhB/5OIp1IAD3h8bgg3tJ2BLbqTZ+DbDCdd0K6FEIJYLAaLxQKj0YinnnoKW7eujl7i8TheeOEF/OAHPwAAbNu2DUKhEE899RTe//73AwAWFxcxODiIW2+99aSdQ6nE3vQ1CzjdmD1wFJU9rRBJRJDJZGxjyfwxnX6hB32iWoJX+g6h7V37AIqH0LIbO3e1FB30tktvgTBO4/mwEOaqRuw1NMAoW13X4XDg6NGjUKvVMJvNrPuBRCLJu810cc4I3kgkkmHZoiiKtRaLxeKMc08X0DRN45DDiidX+kAreKBpgqcDNgiVMpyur2cb42QyiUgkwgqTGbcTyxPTSCWSsB8ZRtN5p0Esl2He50K97K1BEXN9xWJxhoVu7ZQn85rhgCSIGY8DsVAYiXAEApkY1XX1aGlpyRiIpA9MmGuTy/rC/N5rGzc+n4+RkRFUV1cjkUggEolAqVQilUqhpqaG7aiYzmztthlRyVjo018z91m2DiAcDuN3v/sd5HI5du7cCY1GA6VSidNPPx2xWAyBQAA+nw/JZBIikQhKpRJyuRwymWzdjEIqlUIkEkEgEEA0GsXCwgKi0Sjkcjm0Wi0riEUiUcZsQvrr9P9rG/nXnFY8PjfMvl+OBPHzoRfwza3vQiwWyxCs6QMwiqLYZ08qlUKtVrOCNRc0TWNqagoejwd1dXVoaWlBR7gbfzjwJJLlBqijwHv1bVCr1VCr1QDADg6mp6chEomg1+uh1+tPGXHr9XoxPz+PcDgMnU6HSpMJs2dcjnMmn8HQwjK6q7SYIEqMq+rRWuQ2qf1XYdEThlEwClTooL/kEhiat8PhcODw4cPQ6/WoqanZ1DVi2hkGt9uNmZkZbFdX4YVYBGqTAcrKVfesj7echp36OnbZeDyOcDiMaDTKti1er5d9fgUCQca9I5FIcCy4hIGUBzKtGgDAA3C/ewy3NrVn+FAybRbznKx9nd5+rH2fS3imt1l8Ph8KhSLjPfM6/flJf18sNpsNS7MHYZyfwvu3WuCOJFCnUWDe0o3Z2VmYTCYYjcYTem9vrzBj1LuE52dHQAn4KKvQ4hNnvBtGWoyBgQHI5XJYLJaMvqpU0VwKfr8fKysr8Hg8kIrEqK4zIykXwdTThlgoAnWVAafVdGJ7XXfG77r2LxqNZvRp6YON9N89fUYtmyBe+/6+idcRDkdA8wjw5jr3Th3mBO1G+OpXv4qLLroINTU1CAQCuPfee/H888/j8ccfB4/Hw0033YTvfe97aGpqQlNTE773ve9BJpPhwx/+MACgrKwM1157Lb7whS9Aq9VCo9Hgi1/8Irq6unDuueeezFMriW5NFUa8DgjFYtTt7YVEqcBpbd3o6dh4EMTF5Q2wy6fh1UrA5/Gwv6YN5c4wklXJohspbUqAD/ecAaPRmPG50WiE0WiEy+XK2UhkQyAQQKFQQKHIHeXNiDBG9IZCIaysrKyz9opEItxvPYxILICwPwRCxyFXl+OpqWPoFGnWLWswGCAWi2HmNeHVsigEEhGUlRWgREJIypTYuWMnthsbirou+fig4HR86+93onHfDnhmFiCrKEevuAI6nQ4ymWxD21zb0K19H41GMTExAZfLhV27dkEkEkGhUEAqlWaIveNBOBzG0NAQLr74YszOzmJ2dhaEEOzevRtKpRJKpRI63VtTVvF4HH6/Hz6fDwsLC6zILSsrQ1lZGVQqFSiKQiqVwquvvgpCCCQSCZLJJGQyGTo6Vt1umHNNd61JJpMIhULsa0agMu+TySQetw1ixrWAcDCE8LIb5l09WALwSkoHrULFDhrVajU7YNzI72O327G0tISamho0NLx1HxlkKryrsg0WiwUCgQADAwPQajTs9+nPQzQaxdLSEo4cOQKBYNUtQa/Xb+iYTiTRaBTz8/Nwu91QqVQwm81QKBSw2+1wOBzovfT94IfOA+/JR0Bt60WLuQNz8wsYGBhAZ2dnQfHAEwjhbtyN3vd/OmNZpt2x2+04fPgwKisrM9xrNgIjZKVSKdrb29HO60DyqX/Ab1KC/2ZQWLqYBcAO+HLBPJOM6PV4PDgwcRgrDit8yyuwvzaAhnN2QSST4pnUS9BLlQDWC890Ycm8XztwS399sgZBfr8f4+PjqKioQM2HboLnyT/DRLxYXPRD9cHPoszShWQyifn5eRw+fBhqtRo1NTUF+4uNwOPx8JGmndhRZsKE0oozt+5A2Zu+s3q9Hl6vF6OjoxAIBKirq8vbF22EaDQKl8sFt9uNeDwOpVIJrVYLs9kMiqJwc2MN/nfoeYQTcQQcLtQrdbiwZjVgjfl9j8fznk8cx+NxdrbJap2GfdaG2YP94FMC7Pn0hxBIRDe9/5PFSRW0S0tLuOqqq7C4uIiysjJ0d3fj8ccfx3nnnQcAuPnmmxGJRPDpT38aHo8Hu3btwpNPPgmlUslu4yc/+QkEAgHe//73IxKJYP/+/bjrrrsyAize6ZxtaoY/EcXdE7PQWKqgdkbwgdqN+9REo1GsLDjw/fd8DCkQ8Hk8UDwKXq8XR48eRU9PT1EPjcfjQXt77uhQnU4HnU4Ht9uN4eFhiMViWCyWDQs3YPWhLsba6/f7ER0/AO/cIgKOJURDUbReeCYkEhlaW1vznt+VZDf+YRsAXyCArtmCcm8CCmcItJ7efKew4MbN+6/EWMqH2YgQl+46A83KCgwPD6O6unrd4KAY8jV0XV1dsNlsaGpqQnd3N1ZWVtDR0bEumPJ44Ha7MTU1hY6ODshkMtTV1SEajWJ8fHxdYCaDSCRi7xOGaDQKv9+P5eVlTE9Pg6ZpuN1uzM/PQy6Xs53z0NAQVCoVhEIh6wqRbnFea3UWCATs8ozFebacB49TCdeUDbIyJcrrayEUCbB7+w6IjkN08cLCAubn52EwGLBt27as908kEmGfCa1Wi4WFBZhMpnXLSSQSmM1mmM1mxONxOJ1ODA8Pg6ZpaLVaGAyGEyICiiGZTMLhcLCBuCaTKUO4j4yMgKIobNmyZfWDsgrwLF1sZoLa2lqIRCL09fWhu7s77wArGAzmncKvrq6GyWTC3NwcDh48CLPZDL2+tKn7tUKWua5DQ0P4yGnnQpM26CiVbAP3xqQXry1OQ2upgdKoQ8IfAg9Aa30D6qtqc2/sHUwymcTExAQSiQQ7UOnv78e2a78KiqKgnZqCp6wcGqxeE+bedrlcGB0dBUVRqK6u3tS1zgaPx4NJWga+ppIVswxqtRpbtmxBMBjEzMwMkskk6urq2BmTUmHaruXlZYRCIYhEImg0mpx9UGOZHt/d/m5YAy5M88bwro4zjks7tJZC4tjtdsNut8MkUWOlgUbI4wVSNCjwTmkf2ndcHtqTwTslD+3BgwfRu30bIqEwJicn3+ocSoCmaRw5cgStra1ZR59+vx9jY2Po6uoq2DkeOnQI27dvL3rffr8f09PToCgK9fX1J2T0u7i4iJWVFYhEIoymfHjKb0PcH4RndgGKCi3etXUPPtK0s+C2Rt2LeO7ga9je24tebQ1WXC7YbLairksupqam2IYbAGZnZyESiWA0GkHTNMbGxkDTNNra2o6bNWV6ehpTU1PsNFQsFkNHRwdaW4ud4C2O2dlZuN1udHZ2rhMjpd4n2Th27Bj6+vrgcrnw4osv4pxzzoFAIMCOHTtYK2W6O0QhH3CGlWgIn//br8BXyUDx+Qh5vLjqjAtwqbl7U8frdDphs9mg0+lY60su0q8PTdM4fPhwTvGbjWQyCZfLBafTiXg8jvLychgMhuP+fK2Fpmm4XC44HA4kk0no9XoYjcaM3z+ZTGJwcBA6nS7DWhqPxzE6Ooru7szrzAyK8g2qJyYm2Bm3Qqxamazw+Xyor69n13HHQhj1LkHAo9ClqYJUIGT3zwjZtbNKfr8fMzMz6455M4TDq215nKTwUHgGS8kIKB4PSyNT+PBp+7FVoofb7YbBYEB1dfUp42rCDOQsFgs7WB0YGEBtbW2GO43NZmNnWdYSDocxNzcHv9+PyspKmEym43b+brcbHo8nY9CVjWg0CqvVilAohNraWuj1ehxatuEvU4cRSsZQp9Ti2pa90EreCuBMdyMAgPLycmi12pK1Q3r/8HYQj8cxPz8Pl8sFlUq1GgcjFuHHrz+G5198DmGXD2d/8L24qfMcaNLO953AKZeH9v/vxOPx1bRXPAoKhQJyuTynJScfU1NTMBqNOTs7lUqFtrY2HDt2jLW0ZSMYDGZEYReDSqViR7+M5a2+vn5Tg4RwOIylpSVWxBqNRlZAdBICyWwZHhk6CI3BAAslx6WVbUVtt1qkxFm1rWirWBWfer0eCoUCx44dy2iki8XhcCASiaCz861sBjqdDlarlfUba2trg9PpxOHDh9HW1rZpQWK32xEOh3Heeeex0cIURaGvrw9ut/u4WD5omsbIyAgEAkHOAZZAIEAyWbwrSzYMBgPKysqwvLyM8847j52q6+7u3tQUXHDJhZu2nocZaRLhZByYXca5+qYNb8/r9WJychJlZWXYunVrwXNeGy1OURRqampgtVoLdrYMAoGAnW5nLEI2mw3hcBgqlYoNKjte+P1+zM/PIxgMQqfTobm5Oesgj3E/aWhoWHevRaPRrIG3Go0GIpEI/f39Odsfr9eLpqbifiOBQICmpibE43FMTU1hZmYGlL4Mv7UdRpxeteBrxHJcV7sdnoWldRbZdMbHxzOe382QTCYxNTWFUCiE5uZmKBQKdKe68JrTikAiClPDHiTty7C0WWCxWLCwsIDDhw9Do9GgpqbmHedmwhAOhzE6OgqlUpkxKHM6nRAKhRn3oUKhQDgczrktmUzGxhYw58+4sGx2JqLY9kgikaCtrQ3xeBxzc3N4abAPD/omINGsZkSw+ldw25EncIN5Jzwrq24ETDBooYFsIfR6PSYnJ0+4oHW5XLDb7QBW8/SvPe53yWuxZ//78dqBV/Cl3ovBP0UGVdngBO07BGYEwtDQ0IDDhw9Dp9MV3bi5XC7EYrGCnYFCoUBHRweGhoZyCiu3251zGrkQCoUC3d3dCIfDsFqtiMViqKurYzs9VzSIN5w20ITGVl0NquTqjPXD4TAbBS6VSqHX67M2HhSPh3ebu3Ga3IRQKISKitWp/WKshdFodF2jKZPJsHXrVgwPDyMQCMBiseRYOxO/3w+73Y7e3t5124tEMssG6/V6qFQqDA4OwmQylTxgYXA6nXC5XKzIZDInAEBnZyeOHj0KmUy2qY4hHo9jcHAQRqMx73EqlUp4vd6SBwHp6PV6CAQCVFRUQKlUYmZmBueff/6mOnaXywWfz4ft3d1g7gi/0Y+pqamShUswGMTk5CSEQmFJIjscDq8rOGE0GnHo0KGs92AhKIrKcOHwer1YWlrCxMQEZDIZDAYDNBrNumeFEAJrYAWBRBS1Cg3KxZlCkpn9cLlcUChWo/rTB6KEEMQTKYiEqynP1rqfrCXfuSkUCnR1deHYsWNoamrKEEFer3dDA2CRSIS2tjZEo1F8/sHfwB0JQmEygE4mMeGYwT0rEfz72e/NeUx2ux1arXbTQoqmaczNzcHpdMJisaClpeWtY+QLcGblW22zgyfB2NgY2traUF1djerqajidTgwODh4X963jCU3TrCW8tbU147iSySRsNhu2bdu2bj21Wl1wcM24HlRXV8PtdmN8fBw0TaO6unrDbQpN0yW5HYpEIjQ0NOAofKCPjGL20DE4ByZQs7MTyzIpXBWtaMsxsNsoEolkXf9wvEj3c2dcILIdO5OpwawzYFgoPaXFLMAJ2ncMgUAgwzeYoig0NTUVbTVgUgUxGSEKIZPJ2E6lpWV99gO3253Xf7bYfXR0dLDTOtPT0xDq1Pjt/BEk6NXo/n/ODeKzHWehVqjE0tISK2KNRmPJKXpkMhn0ej1sNhs77Z+LXBYkgUCA7u5uWK1WDAwMoL29Pe9IPx6PY2xsDD09PVmPVSQSIR6PZwggiUSC3t5eTExMYHBwEO3t7SWdp9frxezs7DoBnX4ObW1tGBwcRG9v74asCMFgECMjI+sERzaYqaDNCFq3243a2lqcffbZiEajaGpq2pQfPDOYWvs8qFQqNt1ZMRbycDjMzjY0NzeXLDDC4XDWdZqbmzE5Oblpi2C2jAkzMzNsxgSdTgeKT+HXIy/j6MqqlYbPo3Bd2+noLDPC4XDA6XSyVuBsA8epOS8ef9mKWDwFmVSAbU0S8Ek4r4U61/PFIJFIsHXrVvT19a1O9crHgdABLE76UdVyVcnXgclWEQ6H4U/GEQ1HYP3bY9BaalG9swt8nSanGEkmk1hcXMwqyErB4XBgbm4OlZWV2LFjR8HlmcBal8vFPjtMlgu/34/JyUkAyJjGPxm4XC5YrVZUVVVlnVUYHR1FQ0ND1namsrISc3NzRc8WaTQaaDQaRKNRzM3NwWq1wmAwwGQylTQDlEwmS273aJpGYHkFUW8AlIAPvkgAkUKOVCyGSGi18FCxrk7FolAo4Pf7j4urI+MitLCwAGDV17zQLJDNZkNtbS18Pl9Rub7f6XCC9h1CIBDIyHUIrHZWjM9LIbEwODiIlpaWkh56iUSCnp4e9Pf3rxMuTDT68SB9Wue7T92L+YU5yCrKQfMppAIh3DZ1D/5t+wUwGAxFT8Pmora2FocOHUJFRUVe8RGLxaDVanN+b7FY4Ha7cfTo0ZxWbJqmMTAwgJaWlpzXSqPRwOVyrbNwUhSFlpYWuFyuklwQgsEgJiYmsHXr1rwNq0KhgMlkwsTERIaVqBicTidmZ2eL9idWq9XslNZGYKZnGYEklUohl8sxMDCwIZFM0zSGhobQ0dGR9Xmor6/H9PR0Xl9JZgo7Fottym0mFAplDFQZmO15vd7jJlayZUwYGBjAEdccXgrMQqIug0AkQMjjxX8/cjc+17YP1cbKvEFabl8UDz83BfrNzs46PYW5GeCrn3133rYmFosVvGYCgQC9vb0YePlWxPEHmPQSBBfCUOlfAJT3AKK3fHJpms5Iscb8Z1w6mFzAcrkcFnMtVug4ykwGEJqGSCxeNwuUzsTExKby25bqhpJOe3s7O9We3oaoVCp2lstms2FycpL18Xy7YPyghUJhzvNyuVzg8Xg5BatCoUAwGCx53xKJBE1NTaBpGg6HA319fZDL5TCbzUUNKlOpVNH9VzAYxNzcHILBIHq11TjSsowlqx3Cnlbo6mvQpalCR3UTXC4XZmZmjmsGkoqKCiwvL2/aLY/xRdbpdGhvby/quGiaht/vR0tLC/x+P1v841Tx484GJ2jfIay14jG0tLTg6NGjWacRGaampqDT6TY8VcdYSqrNtTgUXsKMywHiDaIj2cMGU5RKes7ZcDiMWCyGWCwGp9uNVCqBgb8+hngsju0fuwwKrTZn4MBGaG9vL+h6EIlECoo1jUYDmUyGwcFB1NbWoqKiAkOeRaxEQ6iSqxGdW0J1dXXe667RaDA9PZ1zyl6n00GhULBT+/nSEIXDYYyMjKCnp6eoTtNkMmFoaAgOh6NoPy2r1YpAIFCSZZfxod0ojIUn/ZyYXMQbEXyDg4N5p2uZPJwLCwsQCoVsijMgd5DRRkgRGisBX04R0tjYiMHBwU0H1GUjPWPC8FgcvEEbbK8exdxrR2HesxUStRKBeAROpxNOpzNnYvuxmRXM25dAUikcee1JbNt7EbSV9XAsh9BQq865/1gsVtRgiOIBWyr/jqHxFKZtyygrk8K57EXIfRvC8mvZKVkmLzCTZq2ioiJnJoQbZPvxk2PPIioSIhYIQS9V4r112VMgBoNBxGKxDQ2cmAwfFEWhs7NzQ9PRzMCWmU1Zi0wmy/DxtNlsb0sA2ezsLJxOJ5qbm9e1b8RhBXEvIqXQwLoUKDgrqFKpNjxwoyiKdc1iBg7JZBLV1dV5xT1TdCjf9w6HAwsLC5BIJKiurmaP7xajEb9cuh9xlRZby+twZdsuCCk+6xLIZCAZHR1FPB5HWVkZDAbDhvpfjUaDmZmZktdjjt/hcEAgEKC6urpkw8XCwgJbtIqiVit7xuPxk5ZJ5XjACdp3APlGRUzUPONrtRav14tAILChjAjp++jq6cbNf7sDHjmFVDwOvkAI78BT+PKWCyCkMqd+GWvJ2gIJTLUZZpuM1UQsFkOlUkEikeAMcRhPDh1G0/l7EfH4EF5awZbq+g0fezYY1wOr1ZrTD7bYB5dxDxgeHsZvjjyLWfnq+QUWl3GGvh6fKjBlLJPJEI3mz+snkUiwfft2TExMZLg5EEIQTsYhFYiQTCRYq2MpVoG2tjbWApTPskHTNIaHhyGXyzcU5S2RSDbkE+pwOMDn87MKR4vFgtHR0ZLubavVui4XbjZSqRT++te/orGxETweDx0dHSCEwOVywWw2Fx2UlItn58dwv/UoFkcm0RHrwac7zkSlrCxjGYlEgvLy8g0Ff5aCJE4jvOKFodUCRUU5DO2N4PN4OHP33owBa3rZUeZ1ku/CkDUBx4IVlTWNoMDD7PQQFpsFqNTlcMFIeREPWSES5J9toWkaXvciVqx+RGIE9z0eQmNdAueeVgaDOQLDBn1IaxUafHf7JTjmmMXS3DzetTV3aqTx8fGSM4KkB3w1NjZuerpYpVJBq9Xmba8YH88THUCWnlM220CLPvAgyGsPAwBGFz2oPe0CCAq4V1RWVmJ+fn7TMxGMe026uM9WtdIfj2B0ZQHVwtVS4Olle9OtmXq9Hlu2bFknfAWhGK7beR6b+3dt/ycSiVifX5qm4fV6sbi4iPHxcUgkEtbHvRijAzOALDaILd2arNfr0dnZueHfP93NhhDCCVqO44Pf7886Lcmg1+vhcDjWjXLj8Tg7/bxZpoNuhE0qBCdn4JqaQ822Loxap/Bo6gAaZZqMal6MWJVIJBCLxWwwRTEPwgUVjXgj/AbElmqQFI1aUzV6QtKcFuqNUltbiyNHjsBgMGTtFIutDQ6sNjqpSjWGR52IzAcgVZchFgihrzKAxbBvnVBZi0gkKkrsNTU1sW4OPEMZ7pk/hmAyBjHhYVdMiUt3nVlyB09RFOsrnStVVDQaZa3QG53SZKwwpUTsMh1TLt9FpjpcsT5mTqcTgUCgoCB3uVyYm5uDWCyG3+9HPB7HAw88gHe/+91F+T4WYtC9gL9MH35rf9Eg/mfwOfzn9nevC7qwWCw4fPjwCamgFAwGVwWbVI1tvdsxG/Ei4vGDB+BDDTvWzb5kKzNsKOcjGVmGuaENS/NSGKstqKxQoLlBu5qOKh5n03mJRCJg5VfAyu2g50OgtJVA1c8A6RYAb01xrkt5pG9GQ+0cKsoF4FOA25eCw1eD5k1kzVAIJdhV1Yi+5WBOMetwOKBUKot+ptILaJjN5pItYvkwm804cuRIwfRP6QFUTqeTLWxT7FR8LtbmlM3WVhHnLCtm3eEoaBDorG+A2M8Crzr3tVCpVBgbG9vwsa0lXdw7nU709fVBKpXCbDbDlvDjl8MvwWmdhXxFi9MCC7imeTdcy6u+pQKBALW1tXl/O4fDgdbWVsTjcSwuLuY9FoqiWL9fYFUwLy8vY2BgAADYFHv5fhutVguXy5Wz7WSyQDgcjnXW5I3CFEVhnnWapiEWixGNRk9q6tLNwgnadwA+ny8jw0E2Wltb0d/fj4bONngTUeilCkwOj6KpqankdElMHepgMIhIJIJgMIj+JRtWpmZAA1g4NAhDawPESjlEChkaLA3HxRk+mUxiZmIKt17+SbiTEdiNdhikKpSr1ejv799UDthstLa2Fp31oBDL0SDkWjUi3gAO3nEveq+6bNUJPxosKGgZP9piqhppNBokhRQ++7dfQqCUQ1ahgX3ShmClHucKgY00NRKJBBaLBcPDw2htbUUoFGIHI0xe4s2mEVOr1VhcXCxJ0A4PD6OlpSXvfVVfX4/JycmCIpXxNSwmsMfv9yOZTILH4+G3v/0t9u7dC7VazZatTWdtyq1Cr3k8Hp6cG4Z32Q7figdzLx+BtrkO7lgYy9EgWz46fd2qqqqS0ngVghnoplIpNiK9lW5B/8o8DgUluGjrWahVFHalsNls8Pl8+PJnL8ehYScO0yvY1V2JHZ1GCAV86PUV7NTn4OAgqOhRGMnPoNeutkd00gf/yKexovw1fIHV2ZuysjJotdpMn9X4/wHzN0IomAJNgO6dH4JXfD0GBgZQXl6+Yf9WpgxoNphsBMUGgjF5h/MV0NgsnZ2d6O/vL9oPlwkgY6biAaCurq5kQZItp+xaaJqG1zYBrzuAlVAU9x6ZwhfPXn0miWcpr6AFNud2kAuKoth0dn6/HxPTU7j18GMQlKtAaAI6lcTTR14HbV3ChR3bi7JmMpUYmaqBoVCopGOSyWSsqw8TpGW1WhEOh6FQKFBRUZHhPkgTGm+EHXjywOuobLLgbFMzzqpsBo/Hg9/vx9zcHCKRSE5r8kaZnZ1dNzPBWGhPZThB+w4gEAgUrOwkEokwjiB+/I/foKzKgJBjBZfXbcGWHA1ENtHKWFmz+aMZ6804IA4gHAyh64oLQVIpqCo06DU3HTeROTAwgKamJkjEYpjEYugsMgwPD8NcW1tUbtxSyeV6UGrO1GQyicTiCpYnZqAwVqD9vedDIJVgZWwaEW0XkipD3u3pdDpMTk4WXabTHgtA3WiGa9KGN+68H62Xno1YOII3pkZwRnUL29iW0qnqdDpMTEzgz3/+MxsMx5R7LbZyXD4UCgUCgUDRy8/OzkKpVBbsfJl7IVe2AGD19xkaGkJXV1fBa+L1emGz2TAzM4Py8nJcccUVUKlUKCsrw+7du7Mez1pRlD41v/ZzmqYhX55G1BsAL0VDVW2Aa2wa8gptTn90k8m04TRea/dvs9mwsrKCxsbGDPEgoPjYVlELUuEsKGYZ9xOpVMoOJM7cVg0Fz4neLZmBq+k+jvH557A4zsdzr3rw27978W9XG6BSRKE1BGBp2JX7txHVAnUPQCIdgccXB4zboAawfbuWnV6vqqo6rm4ZU1NTqKmpKXi/MNkG5HJ5yQFfpSISiVg3m1KyXzBT8Uxmj0gksm62JZiIYsrvgpDio6lMDyHFz5lTFlh93rxeL3w+HyvqFAkKZcLV6fd/39cNRzACXyyBprKKgsdoMBiwtLR0wrI1qFQqmJoskC2b4JmexdF7HkHjOXtQ09sOZXNtwaw3DE6nkxX1+QZExUBRFDvoAMBWR2QCyzQaDV4PL+Jp1xRcAS+oSAB3j70O14IDFsghlUpRU1Nz3C2m0WiUrcjJwFhoY7HYcd3X2w0naN8BFNORTfmX8WJ0EfFQGMFlNyJ+Px6PzGKbawkSmleUaM1XTlIG4Mb2ffjxCw9AXqEBwjF8qLIbBtnxeZjGxsag1+szGjSRSMSOiNNzUx6PogMMjOtBRUVFRgR4vpRCDPF4nLVS9dY04oPlEjy7MIbQ0grkunJcu+tc1FJl6Ovrg1KphMViySoMGf/SYgm7fVgetwIAjJ2NoABQAgGoJI3l5WXE4/EMFxBg1Q2EKfkqFoshEolY4SsSiVhfL4/HA6lUCo/HA5vNhiuuuOK4uHqUIq7D4TCcTmfRlvO6ujpMT0/n7OQHBwfR0NCQNy3TwsIClpaWoFAosH37digUCiwtLUGpVGJ2dhZbtmzJ2XGsy3+cw23DZrPB7/fjDHMbRoVR2IZGIWlrhK6lHs1xCSYGhrIG2QCrAWKbSePFWNmqqqryXlemk871e+VyPymmYxdJK6CU86BSSnD5uUrw+RQaakUQGBqAQvcHTwCRwoK4Zy7jY5PJBKPRCKvVikOHDq0T6oXIdr7hcBiBQCCvn3Q0GsXk5CRoms5ZiOFEoNPpsLKysiG/aiZNYrqPaWVlJZIqCX429BzCyQQAwCRV4X3KBiRCEbZEq9vths/ng8/nYy2UarUaNTU1GW3xwsoM5C8/AqNaBqNahoWaXhx1htCuyz3gBFZF98TExMYuShHQNA2/wwXPtA2UQIjuyy8AXyJCIhaHVlx8gSCHw5HxDG40NiAbKpWKffbj8ThcLhf+eegV+CNhLI5MwT27gDKTAYfqebj8/P93woL+mFRd6TCClrPQcmyKYkeAtoAbACDXluGlH/8O3e+/CMsTMzgiHMFWk4WtXpJPtBairdyIz1hOQ21jPWQCEQaPHdvQdtbClM7MZqHUarVwu93Q6XR504gVIt91XOt6UKiBYnL6BgIB1NbWsh3fBwwG7DFY8FLsVezfdjqMb7oaMPkkBwcHs5bUBAo3jMlkEnNzc3C5XNCXq7G9qwejC3OQ7lQhFY1BL1LgvK4dOf0BGYt8PB5HPB5HNBpFKBRCNBpFIpHAysoKxsbGEI/H8bOf/QyXXXYZm66l0OxAscjl8qLyuw4PD5eU41ilUrFZM9Zev6mpqQwftnS8Xi/sdjui0ShMJlOGFWr79u1YXFxEJBJBZWXlhq+B2+3G7Ows69vI+ObdKBHjoTAFt8+Lcxp34CxTE+KxOMbHx8Hn89HU1JQxkGBSn5Wak5KZbi4vLy9qKpzJi5ztPvR6vZiYmMg6oCwmnc9CaDccS2psbafAowSor+HjqP1sdNQpICuip5FIJFktRBRFoaGhAfH46vWbnZ3NWb1sLUwnnb7s+Pg4mpubsy6fnuUi1+DjRNPU1MQGfW1ESKX7mNrtdvznA39AWExBbtAgHgzj8NFh8GtW8N6mbRgeHoZAIIBSqUR5eTnMZnPe3MLzxk70fv5M8LxL4Kn1qDE1QhsOY3h4uGChmOOZczX9mObm5uD1elFZWYnPvuv9+MUz/0C5pRpCuRQSZxA1keLyWTNiLv25VCqV8Pv9x31AIxKJYDKZUNFYh5TDARKnwS8XQiSXIbDiwZEjRyCVSqFQKKBUKqFQKI6L4YGmaQQCgXU+xExWCM5Cy7EpgsFg3oAwBpVQDN/8EhKhCJouOQd8sQhlJgN6u7qL8ocrlmQiAY189Xi0Wu2mI7CDwWDWKloMFRUVbLQqkJlGbLNpkxjWuh7kstCmC9m6urqsgQO1Cg1a1AZWzDIwka1erxejo6MQCASoq6uDQqEAIQTTqQCeOfgUzDW1ONvUjDLRapoopt55JBJBdXU1K0q+mLLgV56HwNOpUK2tgH45hnAgCFEOkU9RFGQyWd5SxoFAADMzMzj33HMhlUoxMTHB+igej6nUsrIyeL3evIJ2amoKer2+ZLeSuro6WK3WjEwfTqcTkUgkw/d0rTWW+Q3WwuPx2Pu6pqampJy36cFBKpUqaxWe4NIKPn3GxatBWRUWULzVKb7u7m643W709/dDr9dnTHuXksaLSRnF5/NLqlyWK5LZbrfD6XTmnFYvJGinpqYQjSaw5cKHQAXuB+z9UDe/Cx38MzA0NFTUALVQ+jeRSITOzk74/X4MDw+zsyL57t21A0mn08kKhbXMzs6yAV+bzXKxGSiKQkdHB+598UlMl/OQJDS2aKtxmWXLuoj7XDDpEnk8HoJCguDSMg7/+R+Q6zSo37cdcaUYjY2NJQm1wcFBtLW1ga9QAKa3njmZTJZRKKa1tTXrb1JZWYnFxcXjImj9fj9mZmbYimLM76WPxxGs2w5pgwkKgRjbzqiF3TZbVAGbbOkNlUolPB7PCcn/S9M06kN82IIh1J2xFRK5DBK1Ch9s3IntlY0Ih1eLOXg8HtjtdlZwS6VS1l1LoVAUbLsJITi4bMOwZxFB5wr2GrP76jMzpqcynKA9yRTKcACsipHkzBJadJVwVNEQ8ClIDHqYIzwIAzHg+MzOIxwOZzRwZrN5UxHY8XiczZuaa/1s9b4FAgG2bNmCgYEBJJPJ49KY1NbW4vChQ9AujSIyOQptdR2I/hLwBMKihGyxqNVqbNmyBX6/n60wNcDz44XlaQTsDowiiANLU/hk5Vb4nCuQSCSora1d18iL+ALs1tRgx7bVqPu4KY7+/v4N+7uKRCKEw2EYjUao1Wo22tdisWRECW82MMxqteb0Ffb7/RtOMadWq3FkZAjT0/0QiIRoFKvhmV1gB0p+vx+zs7NZrbGFEIlEKCsrK1jAJN2toLKyMm/WCGBVTEmlUoTD4YzfjLEoz87O4vDhw2wwDpPGK1/e4PSUUc3NzSX/XoyFloGmaYyNjYGiqJyDTma5bOfK+Nsqlcq3cklrroXIOIC4pBWyNweoAwMDBUsoF4tKpUJvby+cTieOHj2KysrKnPecWCxGOByGWq1mfYzXZoVhAnf0ev0JC/gqlfGIG08FbEi64lDXVOLZhTFEUglc3bwbwOp9sLbQRLobEnPvSaVSmPRG+A0VUNea4LbaIVEo0GReP4uUD+b65Lrf0gvFHD16NOsA5ni4HTgcDtjtdkilUjQ2Nq4bGNtsNuxp7854jplUZ319fXmLiLhcrnXBpyqVCrOzs5s65mzE43EMDAzg0tZtMDc14NEjr0Iqk+OShh04403ByRgo1vZ/4XCYzRYyMzPDVkVjhC5TYIU5z8fmhvEPWz8o8LA0MolRBPEfVaYMo8ypXlCBgRO0Jxmfz5fXYd1qtcLj8WBLdw92iHbgNacVg3QZGiurcVZDJ0ZHRxEMBo+LRWFtzW2KolBTU7PhCOzBwcF1U6vZyDYVtVbUbrYjJISgdeYlDL3yHMQiIUzz/Qjb+mHbdgWi8fimhexamEo/Tp8b//ngb0Ank/DPOUBJxFjyB/F8Qoqrd+7PeW38fn9G58HUqh8YGCi5nG04HMbQ0BAuvfRSBAIB2Gw2xGIx7N27F3w+H1VVVRkCfKM11GUyWc7a5Ixw6unJnuC+EHNBD+52jyAw7UOZSQ/P5Cz+4+IPs5ZFuVye0xpbDDW1tfjdM4+AsuihEIhxfnU7KqSr22LcCgAUTPkDZPqoMalwslFbW8tWc7Pb7WhubobFYsErr7+GaYSQIDRaywysH3u6BXEj92okGccRjx0JD8Fpkk4YRW8V9Cj0fNE0nZHPE3irU86W7o05b5FIxD7LIyMj6yzqm4Ep7Ts3N4eDBw+ioaFh3YyORCJhgxWZ8q1MR/92BnyVQjwex3PTgxBKxFgaHINjaALG9iY8PGFDu48PHo/HVtRjRIzBYMhTaOJc/M/Q80jF41AadJAmgR668Kwgg9/vh8/nK2ogyhT4GR4eRllZ2bq8uhtxO0h3x9LpdDmj/ZPJJLxeb9a+0GQyQSKR4OjRo1mz6TCBUuty0m6yaEw2GNcepuR8NarRkpBCq9UW5WaXbSaOyQ2fHniWTCZBeMAfR18EXyZGyOMHXyJCCgRPz4/hI007M9b/V+Cd8QT//5hIJJK1Ew4GgxgdHYXRaMywnOw1NsBCS0HTNPh8Pjo6OjA7O4u+vj50dnZuqlF2u93rfMuMRuOGIrCzBYHlwmAwZC3/R1EUuru7MTw8jGQyuc6RvSQWpyCZHYReIcWByXnwQRBZ6kN92xnQ7ty/8e0WgIgE0NbXwL/ohPWVw+BJJWjYswXKyoq8Qn95eRkVFZnRwwqFAtXV1RgZGSm6shqTlotpxJVKJfR6PQYHB8HnvzV9yQjw9BrqlZWVMJlMJYnnXEFHY2Njm0oC/zfrEQhUciQWHFjoG4FALMKvnnsYX933vpIFfjbun+3H894ZSCaXIVOX4fUlK6419CDuDeR0K8jGWh81mUyWN/uDQCBAW1sb+7xDJMRfl4exbHsdZVUG8Hk8fNDQCak3uqmUUYF4FN/vewJzjgXQ8SSeXJ7EmdDivbv2FfWMZgusGhoaYjvltUil0oyclsw0utVqzTv9WyhoLdvyZrMZlZWVmJqaYv1rmQ7fTxI4tmQDr0wGj8eDhoaGjIAvJq3ZiYCmadannflLJpNIJBKIx+NIJBJsUGz6+QgEAngcy4iFQqAJBf/8EtTVRugsVdi2fRsoXmm/f7PagG9tuxjD7kXMjk7g8jPPw+zUNCYmJgoaQpLJZMkDUZFIhC1btmB2dhZHjhzJCKpjsh0UI2iZVHyhUCjDHSsXc3NzqKmpyfk945N87Nixdfft0tJSzlkRRtQejwHP7Ows3G73ugHUZi2kFEVllL5mCMdjkDj74LMvYu6NAZjP2AaC1YI96RBC2AHrqWyt5QTtOxDGKpsrwbVCochI+MxMWR89enRTGQJyBYuUGoGdLwgsG2q1GtPT01m/Y8pKDg0N5a2kU5BIcLWDSdF4cNiOWm0ZttXqIBaf2AdXzZcgPusETZLouuJCKCsrsDQ6hera3NO7AODxeLKeq9FoRCAQwOzsbEGB73a7MT09vc5NIZ/VIb2GOpMyiYl2LkbQMUEU6SLJ7XYjlUqVlKM2nXg8jln7PFaWHZh68SACi050vudc+OMRtvxjOkz1HYFAAB6Pl/Geoii2AhDzFyVJPDneB6FMhpk3BmFstSARCuMNvhrX7jqvpMbdbrdnnKdEIsHy8nLB9RQKBXp7e/Hr15/CvGMREV8QQrkcYecyfmdfxq8v/xSEwo2VoQaAx+3D8MTCoAQCBOaXEPH48EaTBB8tkP8aAJYjATwzcwyuJSckVRUoS1KYmprKmzc6V2YPi8UCh8OBI0eOZPX9zRe0lg9mBoMpJiEWi2GTpXD/9BG4p+3gjbyKK7efifI3cw2Xmi0hmUzmFKbp4jQdgUCQkX1EKBRCIpFApVJBIBCwGUiyQao0uO21R6GxVEFjroRMo4Y5IsLY6NiGco/rJAqcaWrCoQUfpAIhWlpaMDU1hZGRkawVKBlGR0dzZm8pRG1tLTQaDY4dOwaz2Qy9Xg+NRoOpqam866UHWtbW1hY94HK5XAULo8hkMvT09Ky6wFSZ8Hp0CZM+JzzjNnz6osuzrsO0aZuJ50hPhZfN0n2iLKQUTSD3RBGVy9F1xQUIOFZAALSqM9tixkB2qlcL4wTtSSQcDrM15Jn3w8PD0Ov1ef3ZFArFuoTParUaXV1dG674lM8Cq1arMTs7W9RUkd/vzxsElg2KogpW0+ro6MDExATGxsY2NN3qouSYWvCiSinB9y7ZgXiKRv+CF8aEELUnaETKTC3dtPcS3LM0iPGBQcjLy3BZy3bI3BHMUtlFKeMTleuYmpqa0NfXB4VCkbORZeqU55qeK2QJS69I5HK5MDo6CoqiCiZuLysrg8/nYzshxuezlGp2NE3D7XZjZWUFgUAAAoEAlRIFApUV6Lj0HMRDEVAUhV3bdmJ7Z5bynG/mg6VpmrWAZXufTCaRTCbhiQQQC4RAaBoLB/uh1KlQs60LigptyffF0tJSRrJ+mUxWUuRwQiGCtsWC8SdfwSv/cxfaLz4LPprgcN9RCEq0zKVzxHoUi655LI1OwzVhRcd7zoPTasOQYRjlyjIoFArIZLJ1wsUe8uDWvqcQ8PkQC4Tw2lNzuETThCvOOLdgMJbP58v6ndFohEQiQX9//7q804yrwkY7VIVCgS1btmDQNoVfPfFnSNVlCPsDoHjAva8+g7qzL8fW7m7E43G43W5WqKZbTdNLeDOkC1NGnMrlcpSXl7Pi9Hi6LHSVm3CWwICZViP8AT8sPDk+dfa74XN7cPTo0XUBhcWS/tw3NDTAZrOxJbXXwpSl3oj7EYNCocC2bdswNjaG5eVlNLY043XvHJ59fQkGtRYX13ahQqpgB9BM0FixMyIMdru96EwlTODxf/zjLszSIUjKFAhEvPjhwNP4eu+7oJdmumMolUoEAoENC1pmNqNQ4Yrj3QfNzs7C6XTi5vOvxO9nD8Me8oLEHTjX1ML66abD3MPHK03ZyYATtCeB5UgAf5p8A2MzVmhEUnzKbAK9surk3d7eXnAKLFfCZ4lEgt7eXgwPDyMUCpVkzXS5XHlHws3NzRgeHs4rVOPxODs9VerDqdPp4HQ681odm5qaYLVaczbA2YhGoxgdHYVYLMa2674K6sk7EQ6HMe0OYOe1X4C9rDYjMOd4QNM0G7jDWEe7zPV4LqnF3l27IXkzwf7U1BQGBgbQ3t6e0RkWCk4CVqsKHT16FDKZLGvEutvtxpYtW3L+DkyKrWKm/pgMDmszMmSzuKrV6gyL6ejoKBoaGvJ29mtLolIUhfLyclRWVrKDl8ZEK35y7FkMOt1QGnUoo/nojWV/TtIHA8VYlqoJjSb/NGbn7Wi64HQQAsQjEXSUVxZcNx3mGVpbRawUHzyTvAyvjQ+iorEWdXt7EbAvwtLUgN07dhZeOQc0TaM/5sK4dwnNF5yBys5m6FvroYAA1UYTIpEIVlZWMDs7ywaMMT6a9831wxfxIB6PwT23iDKjDv3yKD5YQLxJJJKc/tTAWwPwY8eOZQQQHY9cmDRNw5WMQKZRw22bx8v/+yfsvOZ9EEqlGLJOQhpJZVhNRSIRZDJZhtX0ZE+5Tk1N4aKeXewzdvDgQfDBY59Fu92Ow4cPo6ampqSZD8YVhOljzGYz7HY7BgYG0NbRjlHfEoKJGCqFciyXUEktHxRFoa2tDUtLS/j6334LOz+O1HICmhoTDjtmcE1FJ1KhzbnUrB1IFsKbiMJdIUVy1ovxZ19H3e4eJGkary1Z8e669YFhTqez5GMC3qowV0zBoON1zzGGMa1Wy2ZM+Q/tRQgl45ivnEW5smydPzwjqE/1amGcoH2biSYT+PHAM/DFI/D4fYjI4rj5r7/C1970BSyWXBY2ZorearViYGAAnZ2dRT0oXq8XjY2NOb9n/C+dTmdO62+xQWDZYPw6C02jWywWzM7OFjy39KpJ6fkkSUM3FP4VxEamQHWdgVogIzCnsbFxU5H+TGNiNBoz/NMoHoUysZQVswDQ0NAAt9vNRgWPx7142TGFhYlpXNy7B/muBON7+ehrL+KYIg5/MgaLQou9lBYiQhUsFctMo5USnKFQKNDR0cEGaRw8eBA6nQ41NTWsYI2Cxqvzk3BqRdDHKQj5/KyWjWAwiJWVFaysrOQuiZq+b6EEX91yIZ6MyVHf1IR6jQGL9nkMDg5uuBgBA8Wj8NnOs/C1kTtQVqUHnwa2JVTo1lYVXjkNu92+rpxkqfQKdXg+xkO4ftX6pmxswJm8irzPXT6YDnV/TRtCZWIMeRYRACCmBLix+xyUK8tRXl6+bj2aphEMBhGePYJ4OIK5o0OILHtQvaUNgURhi/PabArZkEgkGRkQKisrIVyxI+J3g4h3gVdEBSpmMMT8McE9KcRBCQSQqlXY/Yn3Q27QwtBaj92dO9Fe4kDl7cbv9yMUCmW0HzqdbjVH9Zv3ADOgtFqtbLtVbEBRMBjMEFfV1dVIgeCW++9AwKAARVFYGZ/BZ85+93EV9kQhwZKKQnDaBefYNFKJJEgyhTFVFT6048wNb9fhcECn05V0rEk6BQAQyaXwzs7DV1cFWXkZEiS1btlSC+MwTExMIBaLFSXSj5eFlnFXXGsY4/F4UAjFqDFVYXp6el1bQtM0hELhqgvWBs71nQInaN9mJv3L8MRX01SNP3MA5l090NZXwycvLr8gA5MOKJf4slgscLlcOHz4cF5fN4ZiphksFguOHj2atfEoJQgsG4xfZzEPdm1tLQQCAQYGBlDdLMeRpYcQCAQgqrgEVYrtbBqeysrKdTk9eUIxoDWh3BBia4sz4jAcDrP+dxvxU7Pb7XA4HFmt7LnOS6PRQKFQ4J6XnsTjrkmoTHo4VxZxr30AfIkYZ1bmDtoIUik87LciaPNCU1+Dl/sOYVyhxk/e/fGCx6pSqTA3N1dwuWwIBAJYLBaYzWY4nU709fVBLpdDbtDif8ZfgnVhDEp4EbAv4NvvuwbA6v3lcrngdrsRj8chl8uh1WrzptFZC5+iUCGUo0W3GpFfW1uL2dnZkiz2OQlEcPOeSyBXqxDy+SEWiUvy2Q6Hw+vKSTIUG+jkdDrhWXbhR1deB2tgBTE6iTqFFnKBCIODgyXNujC+pOkR/J8htbCHPBgUDaG3qQ1GZe5ZAIqiVtNjNbTAJUigor4Gmv174Jmeg7ml+KIYhWAyIAwPDyP4yG+gdU4gEI6BPvoP8C76JKiWtyzTyWSSTf3m8/kQj8dXRb9SCaVSuS6v6jQdwhO+Q9BYqkEnk6gL89Gm3pgf99vJ+Pj4ukFaVVUV647GIBAI0NTUxAa5FVNwQi6XZw1SnOSF4JIQBCdtEMqlECnluG9hEDtrmiAgPNY9Z+1fKpVifYpTqdS6ILd0XPEwQsse8AR8eGYWUHP6dlRUGSArL+zHnY+5ubmSXJoAoEKqgMwfx8qKDw1n7YZCVw7XhA3d3efmXKdY0ZlMJtm81sVmHyKEbErQMkGlhdwVZTIZotHounNhCiuIRCIkEokNH8fJhhO0bzPplv7IshupFA1QgnVTAIWQy+V5BS2wOqqXyWQ4duxY1pQ2DEx6nUIIBAJUVlZibm4uI9XYwsJCSUFguZCVKfHq1DAqDUaYlRrw8/gMmkwm+BIz+PXjt0CtFyERpfH0VD+0gYvQoD2jYBoeg8GAxcXFDAEuk8mwZcsWNpeiwWAoKrNCPB7H6Ogo5HJ5zoj7ZDKZ8xqLRCLY1BR4KzzMvHIIoPiIev148NhraOWvNvbpnQTz+hn7KJKJBCL+IPrueQSN5+xGTCvDfNhbsNiGTCZb54ddKhRFwWg0wmg0wuv14qfP/wMzKwsgAJaGx1FmrMDPnvo7rmvYDalUCo1Gw5baPF4cL1E7OzuL7u5u0DQNj9OFpsZVP+VirdjZykkyrJ3mzYbL5YLdbmfdRJrVmf6A3d3dBTMEAKv3GWMZWhvBT/F4qFVoIKhpQDIcBYpwCXy3uRtHBwcQq9RDIJGga+sW7KcMmJqaOm7ptyiKQjs8mLYNYiIYg1RIIRlPwvu3nyP0PjmCiVXRxFS0Sk9TlYtkMokeWomd7/oQRmzT0EmUMEKcN5r9nYDNZoNer193bswzk83wIJFIMgpOyOXynG4+CoViXRAlADgjASg0anhsCxh68Cl0vPtcLPoCOMA/CKNSDT6fzwa5Ma8lEgn7WfpfznuTTuHp+Dymxyex85NXIh4IgxCCTs3GUzIybj6lGh+mJqfwodoteFyhxMSSHVWmKpzXthe+yTkkt2jXba+Y/hZ4K6vM8ax0WWg9xr0tVxD5WrRabYa1n4H5/fJlZXmnwwnat5lGlR46iQLuaAgVLfUQCilEZhZR01Va6phC6YDSl9u6dSsGBwcRDAazdrpr88/mo7q6Go+8+AxeDM2DCPhoECohXgmX5C6RDXvIg9vnD2HBZoe2vgYNSh0+13U2JPzckd1O/ouoqJJi+NACeISHoE8JQf3LaGu7ruD+VCoVxsbGsn6n0+mg0Whgt9tx8OBB1r82SadwcNmG1x1TkLhN6NSYWGtwoQYsHo9npMlaS4KkoKyswMKxcSSjESTqqhGhKUQikYzBDtNZsH6iFA9KgxYrEzZEfUFI1CrwUHhwdLx9BNVqNWR1lRAnfRh84Em4rPM47YYPAgZtwcjjzVJbW5s3uKUQLpcLSqUSNMXD32b6caD/DXTAhXeZ2zA2NlZwyjCZTCIUCuX8/SUSCcLh3LXu3W43ZmZmCqYfs1gscDqdOHLkCLxaCR5zrCbbbykz4JqWPfA6nFhaWso7eAVW732bzVbUADQZi+OKmh5UtzYhRVKokCrB51FsSqbOzs6cA5SS0h2tLMKsLYPDO4//e20KN5zeDqVYiHJeEtWtbSUPgkZHR9HY2AiNRgOzUIXl5WU0NDTgyJEjWdMbvROIRqNYXl7OWSmuuroa8/PzOQcSawtOGAwGVFdXZ9xTuabPNQIJlsaskFdo0HXFRVAaKyBXyHHGzt0Q5yi3XSrxaAzn8o14rVuGxUQIqWUfPt5yGhpUhV1LcjE7O1uSyxGTbUAul2Nn1xaUT8hR0bOffXa9Xi+OHj26LjNMMVUQmRm6jRS/2YjLARN0XFVVVVIe+srKSoyPj68TtEwmGM5Cy1E0Yr4AX+w+F/dOHYLTYICBJ8eXL78ay9OzINF40blWc420s8FM6zGlCddaeHKliMrGbNCNv/unEJ71Q1lpwANTVnz6/Ms3LZB+M/IKEnwKqTcjwqcDK3h4ZgAXV7YhGo0iGo0iFoux/5PJJAYd4/DGggj7Epi3BvGBfdUQiosPwGH8ybI1UkzKGKPRiKmpKdhmZ/FEfB62RACuRSuGjiXQFZfhnMrmopKyx+PxvI3cjgoz7h84AH1LHVKxBKTlSpzbuDVv0Y0LNCq8HnPCt+KG5fRtkCoVEC/6QDwBQLHeL3ItjJ/jZi2mNE3D4XAgMb0IOp5E87vOgnHOAZJIQeqNHbccjvkafbPZDJvNVjANUTZmZmbQ2dWF/x16HlN+F5whH4h7AWPeJXyqZjvGxsbybnNhYSGv1S9fcQWv14vp6em8AXzp6PV6TEc8+PkTf4GquhISpRxHZ8Yx0X8MXzrjPUUNHhQKRd6ArXTGx8fR1NQEhTTzGWFSBfb39+fMRcucdzHi0UkLMDO7jGqNCtftbceWKi3Ao0CZG8Ar8f5kovMZUa9QKDAzM8PGFxw7duwdVUiBYXh4OK8Ptk6nK6rIjV6vh16vZyvRMSmzAIAmNJYifswG3aiSqcGnKLhcLpQthbG9tRMzdBDxcBShRSc+c/GHj5+YjccxNDSEM7ftwoUyGWhCY8o4hXJq4wMLr9cLsVhcdPtF0zQGBgag1+vZQiI+ny/jeqrVarS1ta3LwJHPRYumaYyMjEAgEGw4J3YpgpYpUpNIJDYkniUSCZvJY20AK4BTuvztO+uJ/v8J5WIZPtV+Jlocq5VNqlUa1PbqcgrObGzEUb2pqSkjB+Rc1IdhjwOzM6OoaSpu+vCJuWGIypRw2Rex8tohVLQ04oGJQ9ihrsqZKokQkvU75vNkKolj/f0ATTD1wuvwzCxAY6nG644AOjtXo/iFQiGUSiUqKirYqS6J6104tvIXmOqVmJv0wTbqw65tZxV9PZgk3/k6XCa/5TNTAzj0/ACEEgmioTBcY9M4qNfhQw3nFdUxJpPJvHlEL6pux/CRfszXqpCIxtGQkOC95vzJzHUSBb7Ycy5uf+ERxLRKdFZbcMU5W+G0L6xLaJ4NJjBso9kd0iv46PV63HTJB/G/w8/jUH8f1LVGaFXl+NSWcwqWJy2WQuJ7I6LW7XZDLpfDnYxi0r+aLzbk9oIGQYJOwYoIalMkb+aJQhHWMpksay5av9+PiYmJksXVeMwDjbkGswcH4Hcsw7y7B8IqA7Sm4zuV7na7IRQKcz4farUaPT09GBwchE6nWzcYZ9qofM+X3+/H+Pg4VJVt2LprNwSLk3AGIwB44O3/CHjS0gRPPB7H3Jro/PS8yxKJBA0NDRgcHNxQCeYTxcLCAsrKygqKf41GU1QWFOCtSnRM4FiluRZ3zR7C4cmjKE/aYZSrcYm4GnK+CNu3bcNOPoUxrxPBRBSh8kW0yY9P1pdkMon+/n60tbWxApHiUaiqWg1Q2mj7MzMzU3QQJlPVrq6ujt0fI+jW9rVM8OvQ0BCb1z2Xi1Y0GsXg4GDOrC+lUIygZWYE0wcpGyGb2wGfzz/lK4ZxgvYkwrgNeL1eaDQaNDU1wel04vDhw0Wl+dgIRqMRCoUCf37uUTyfWoZILIHXacfMkUfx1a0Xolz81j5pmkY0GkUwGEQoFEI4HMbIsWNwBlbgnbNjeWgacr0WdCyOZZcLgjcT1q9NZs/4VeX6EwgEaIzPwBsNI5VIgBLwobXUoMfciram3MKkXXsZQollTNJPQ8Cn0NmyDVLn6YhXF2d11Gg0mJmZKeq6xYR8GJrr4V1yYfLJl7D7sx+FRCGDJxZGhbRwGclCYmxm2oqP7trPWg76+voQK+B3CQC1Cg3eX9WdUSVO2dCAYDCIY8eO5RWSTH7FUjuUaDQKq9XKVvBJtwp+qec8/NPHR2NHGzzTc2irtoA2rQrNQ4cOZWScKJV4PA6xWJx3GbPZDKvVWrSonZmZQXt7O5aTqxbLoHMFiUgMS8OT0NXXIEVotLa24ejRo1CpVOt+w2yputYikUjW5aINBoNsirtiB0Rutxsejwezw2PwuR2QVqiRiEZAJ1bFWil5apm0bfkE1PT0dMFsGSKRCL29vVkH4/ks09FoFOPj46zVVCKRgDQ3A9Zj4L3xOqj9F4GnL70y4PDwMFpaWrJmf2EEjEajQSAQOK5+wJshHo9jfn6+qLRTVVVVGB8fL/qZTQ8c+9HTf8PAygLApxBc8WFowgZJcwJfO+utggJt5auizC/RYHp6etMZRJLJJPr6+lat/GvutVwBSsUQDAZzBmGuJRqNZq0O5vV6UZajsAhTgKG/v591J6MJQSyVZK3WbrcbU1NTmypmxFBISCaTSYyOjoLH4x2X2YVsbge50oGeSnCC9iQiEAigUq36dzHTY3q9HgqFAkNDQwVHYRudMpbL5TgkjiAw5QSdIhArpHCtrOCPrz+D8yoaEYlE2EZGLBZDoVCwgRjnq3h4YKYPZbUm6JvqQRI0mg1VaMqT8qsYrmrahR+++CDkOg2k5UrE5pZw8d7slVsYKB4fuyo/hW2Gj+Ng4A3s6TgDfr8f/f39RU3FFFPQgaFWUQ4aBHQ8jt6rL0PA7oC0pR5GWXHiLJFI5NxHOBxGIBDI8IOqr68vukPJNqXPJDS3Wq05rbUqlQoLCwtFHT+wak2bmZkBTdOoq6vL6jPK51EwydVo11VhaMnLBlVZLBa2EeXz+RtK71Zs8KLFYoHVai1YhIOZspRIJDDRIghdQSRDETTt34NkNAqPbQGGWh4rCkZHR9cJvGJSda2dTQmHwxgZGcl7j6YLWKa4RFlZGSorK/Gx6nfje0efwIptHuWnbQMIgWkliWgwBEmRgSiFfAIXFhag1WqL/o2yDcYlwhg8yxNAqgzgK9nzYoJYGhsbMwQGj+IDDVvA8yQ3JGbtdjuUSmXOUrzpQT1msxmDg4MbTod2PGHcOooRdRKJhC0GUcrzI5FIkDCqIedHcexvTyARi2L7xy7HSo7xoUqlQjKZ3FSSfWaKP1dbAaz2dw6Hgx3IF8vMzAzq6+sLLscEaWUzEHk8nqwp6xiYAgxHjx7FGD+Mh0Zeh9I3hCZdJS6SVIMXT70tritM6r1CvvGlkM3tgKIoNvjyVC1/ywnakwhFUWxlpXRkMhm2bduG4eFh+Hy+nA7fTORlqcIgQacQJwlIlAoc/sOD0DbXwbyrByFFEjU1NZDJZDlv5vOkrViOBvC8bQTgUejdtgUXiEzs9MxGH4IuTRU+pO0AVauDVCRBTbsYC1Mz0BQh6ASUGEJqteKaSqVifaCKEbXFFHQAgE6NCeebWvGnkUno2xoRkwawj9ZAJZLmXY8hXwc0Ojq6ThQxHUq+YCIgu5hlYKoBBYNBDA4Owmg0Zlhri8kVCqw2qHa7HWKxGI2NjXmPJ736ndlsXvVPffM3lEgk6O7uhtvtRn9/f9FZJBii0WhBCy2DxWLB1NRUXlGbPmU5OjKCa1r24MWUE9bACvTqCnx+6/mQeiLo6+tDe3s7pFIpFhYW2M43X6qudI655/HE3DDmdALsVNdgYWIaXV1dGfdDMrnqfsRUR8tWXIJBBeDmnvNw+8L90FSa0ak14WxDI8ZGRqFUKouyOhbyCSzWYphOxmBcPQBF6P8QnQ8DwjLQ+m/D7uvA0tISzGbzhqr95SMcDsPhcOQMqMpmkW5vb8fhw4fZKeWTgcvlAp/PLyki3mQyYX5+vuQy4OViGSYCYZi2dyIWDsFrW0B1Z+4gyrq6Olit1pJ90hkGBgZQXV2d15psNBoxPDxckqCNRqNIJpMFraK5Sn8z+Hy+gtdQIBAgWqXG3x97EnSSIOoP4MicA279Im69+GNFH/NGYLLniMXiDRecyEdFxWp+a8ZVgqIoEEIgFAoLZmV5p8IJ2pOMVCpFIBBYNxJmpuLyRRNLpVIEg8GSGsNoNAqbzQYytwKBUoTOKy6AQMhHPBhGR42lYCPB51G4qmkXLjdvwdH+Ppy2dSd4PB7rm1ts6pC1+P1+1Goq0GF+q4GdCEcxO5u9PGw+FAoFK2oL5eDV6/UYGBgoah+7xHo0nHUFZHotjDIVPItOTExMFBVhmittF+M7l63xKMZKGwwGoVTmd3lQKBTo7e2FzWZbZ60lhCCRTEK4RhSnl6LUaDR5o9nT8fv97PEoFAq280kX3RqNBmq1mi3OUGyKm0QiUZK7QkNDQ05R6/f72byLfX190Ol06KiuxjoJp1u15Pb397MC3ZoKwpkKI2Bz4KKu/EFYzy2M4d6pw3CtzGFmkuAvM4/hB5d9HCKRCC6Xa52ANRgMRYm9Wnk53t+4Hb1b38ousmXLFszOzuLQoUMFn8Ns5bMZrFbrhsqqAm8OxjvkGH72h/AIaMTigNMVgq3/32HYehe2bdtxQiw/w8PDaG/PnR9XoVDA4/FkfEZRFFut7GQEidE0DavVWnIOVb1ez1Y3LIXelAqHEikY2xvhnrRBValHZ1CcMzWdWq3G5OTkhmYBGb/qQtZvZrul7MNqtaKuri7vMoVKfzNxHMXciyO+JegazZh6/g2MPvY8Ot97HpYQhyfgR7lyY+5T6QQTMTgiPgQTMSiEqwP2hYUFzM/Pl5z+qxQMBgPGx8czBC1N06yhgxO0HCUjl8uRSCRyWgnzRRMrFAosLi4WtZ/06eLa2lp8+/Jr8LPBZzHtD0JhNKBFXIaK5SiipuKmmGQiMcQ8PptSivHNLZTzNhezs7PrGqmmpiYcOXIEKpWq4EO91v2CEbXHjh3LK2qZxq6YSPzFxcWMkbLKbMbIyAjsdnvBgKdEIrGuwU4mk3ktYSqVCjRN57XS+ny+goIWWG2sLBYLKioqMDg4CL1ej3F+GL8bfwki9zF0GGvwida9kPEEmJubg9vt3lApylAolDGNx6QaWputgaIomM1m1g3Bbrejubk5b6dWrMtBOoyoZQYeyagfhE5ganIGDY2r91dtbW3ejletVmPr1q0YGxvDk/MjOHTUBmOLBcsTNiyU8fAF9bkQUutTstGE4H5r3+qxB8OYOdiPMoMOv3/hcVxS18UK2GKnm9PJ5f9XW1sLjUaDY8eOlVwWFVi9xh6PZ1O+pVR8BM11Ihw8FsRtdzrxvS+YsLVdAoE+AJwAMWu1WqHX6/N2wAqFAna7fd3nEokEFosFw8PDBf2FjzdjY2Mwm80lC2mm6EUp6RZHRkZQpSzHTy//JA4tz2I0IMAHzroQWoGUrdSWrQ1jrLSlWNTHxsagVCqLDgI1Go1YXFzMm9GFIR6P502RB6zm8g0EAnkzh/j9/pz+s2uRCoRIhWOQaMtQuaUFkjIFUqEw7LZZWN+ctgdW7yWpVAqpVMqWJC/Ulx5YmsafJl6HY3QK/+Q5cUV1N7TeBJRK5QmxyqaT7nYAgHU1yOf7/k6HE7QnCWZ0qFKpEAqF4HK5cloJc0UT57OyMLhcLszOzkIkEqG+vj7DAvuf29+Np5Mvo7urC1VKDUKhUFbn+WJRKBRszttipnMY4vE44vF4Vutwd3d31ryAa2EewvRlihW1jNtBvmmvXME/bW1tOHLkCGQyWd7OJZlMrlt3YmIiZ6lXhkJW2kAgAIPBkPW7bCgUCmzfvh0PHXoFd/U/D6FMCl44glGnHd+a+CP+n7kXZrN5w4ImEAhkdEyMNSlXZyUSidDZ2VmUG0IsFtuQ9b+hoQHjY6M4+MSdqFJEEAxHsbwYQDR0Btq6thVlAREIBNBaqjE29SIibi+mXjsCraUOY4tzeEp0FFvUJsRiMcTjcSQSCcTjcUSTCSwMTwAAZl45DGVVBQxtDdA11qG3c3N5m1dWVqDVarN+x/hPj42NYWVlJacrULZp+MnJybwlsPMRDoextLSEFbsLcEYQCBF87VNa0ISCQEABguzHuxn8fj88Hk/BPNj53Gt0Oh0CgUBJleE2i9/vRyKR2LD/bk1NDaanpwsKWpqmMTg4CLVazT5XF9a0Q78chUGiBEVRbFBfNrcxnU6HmZmZolPvTU1NQSAQFCVOGfR6PY4cOVLUOvkKmABgc4sXij1YWVnJ6z+bzlZJBR6yO2Bqa0Zw2QUen8KVW89BV13mPpj0kuFwGCsrK4hEIqwwZOJRZDIZ+9+PBP4w/hrIm+v7Hcv4xcgD+P67r0GDobSy2xuFcTtgjjGZTEIulxflivZOhBO0JwlG0CoUCjYCOt8USLZo4kgqgRH3IvgrdrSoDWwRgvTpYrVanXO6WMQXwChVwaQoX631rFCgp6eH9X3aSBoSJuet1WrFwMAA2tvbCzaEc3NzOUfzAoEALS0tGBgYyJvjjwm8WSvEixG1er0e4+PjeQVtvgTejOiWSCRFT9MwHVqhaGWFQpHXSrvRoA23kkJ5tQlTrxzCysQMWs4/HQmDDu1buiEXFuenmo21HR9FUVCr1QVTDWk0Gmg0GthstpxuCJsJVKiUBeH0zGDGR8HlCSCZoNHMn4NavR/AW4Oq9D9GmCYSCSSTSVh9LoSWViBWq3Dot/ej96PvBZJJLKlcgNoEpVIJkUgEiUTCPm9bBStYCPmgNOoQdHkRcq5AU03yHGlxrM2fuRaKotDW1sYGamUbpCqVyozAML/fD5qmS5ri9Pv9WFpags/ng0QigV6vR9XOqzDw9OPYvWUSapUYQxMBOMK7YJRs2cip5oTJx9nV1bXpbVksFgwMDBSdEmszMMfd05M/LV8+ZDIZW3I2V/tK0zT6+vpgMpnWteXpQXIURaGlpSWn2xhTuKTQIHd2dhbxeLxkn1vGD71Q1g3GzzybixdTMEGpVBYljIs1uDidTkSX3PjR+6/Hi84pBHRVkC4FcKl5/T3HWGSzPT9MxqBwOMwW0Hh9fhLOiWnQNI2jdz+M9kvPgcqkx8i8FSrCZ7cnEolOmKW2srISb/QfhS8aQh1JgaZpSCSSU7ZaGCdoTxLpZv5kMgmtVovl5WXo9fq8ZXCZaOLHXn4eT9CLsNtm8LzQgwqpEv/WcTb8juWSpovXigRGOA8PDyMSiWzYYmGxWOB2u3H06NG8aU1omobb7c7bWKpUKphMprwJ7sVicc5RJZNXMJeozZVomiEYDEIkEuWtiMT44hWb6LqUDq2+vh6Tk5PrpkQ3k2KFjsQRWFhCudmEiDcEHp8PkVyadeq86G3muH41NTUYHR0tSihkc0Owhj14yDaAiZEhTJXzcFldD0RFJnxnAuvs0yPgU3w88eIA3jg2iRs+dC5GRkawLHwDfP5qajmhUAiRSMT+VygU7O8uEonQGI/iWaEbQY8Xp3/uI0jGEpBqyrCnYwtM6uyDvxvazsD/DD4PhyIBON14777zsI2vQ19fH1pbWzc0GGF+92ILMajVagwODkKr1WZ09owfM8Pk5GReP1QGr9eLxcVFVoAYDAY0NDSwFp6+vj40nvZrqHnPAQk72k6rw5HJaihCoeNaoWtiYgI1NTVFX0Nm0Jtr+c7OThw+fBgymeyE+g9arVZUVlZuuqCJ0WjEwsJCVosl8zuk511NJ5t13mg0QqVS4dixY2x1RGD1HrLZbHlnkxYWFuD3+zec5stkMmFxcTFvPML8/DyqqtZbLpPJJOs2UWxwWTGD44WFBTidTtaQclXZ6vUYHBxEqMR7maKodfdVUqfES3wPPLZ5tF56DnQtFlB8PjSKMsTjcQQCAcTjccRisYy2XiAQsNlZhEIhK3rTB9LF8rRjHHcMPA06kcA/4wu4UFYNs9nMWWg5SiP9gYrRSTy0PIYDYwOoqDdjf1UL3mPuAZVD2Or1ehyZCsJ+bBrJRAJRbwDTcw78xLaMm/a9e9O5FZmAtGJqx+dDo9FAJpPlTTztcDiKmnYzmUzw+XwZUebpSCQSrKys5FxfJpOxojZbCpfy8nK43e6sjX+haS5m/01NTQUtycz2DAZD0Y0P03CutdKGw2HI5fKitpG+zuTkJGpjfKirK8GXiMCjCcRKOSxuGkjRwAY1bTAYzHo8jIAo1prMuCF4vV48euAF/M01CoVBC1c0iOcWxuCJhXFD+xkAMi0f4XAYkUgEkUiETaQvEAgglUqR4gkRDEfR22FGd2sVtnfVg8cXwrh9R94BZDoqkQTXtZ2O7z30RyhrVzvWrrAIdRJ1znUqpEp8e/vFcMfCGJH244yWPQBWLZuF8gTnohT/P+CtQarVamUzNjCCnXFZcjqdUCqVWX8fZtDpcDgQiUSgVqtRVVW1zuLLiKj6+nqoyzUA3g8AoAB0dkWPa/CV2+1GLBYraRaJEXG57kGKotiE+ifKfzEcDsPn8226VDiwKkAZH/B04vF4Rv7UbGQLkgMyM+x4PB5WYFZVVbGidi1OpxNOp3NTPsgajQZTU1M5v6dpGk6nc128QbaCCYVID1zNRbof7loYi/VGymyn06I2oI6WwAPA1FqPSDCM07u2Ym9TZ86+HwCbTi0ejyMajWYIX6ZwEfBWWkqmmhrzn7H8jvqW8A/bAKRlSrit84iDxl8mDuHs3l2nbPlbTtCeJGiaZjvS513TmOLHEI9EkaBTeHxuGAqBGOdVr1ojmRs4vQTsxPQkaB4PQ488C4W2HN0fvARCo/G45lS0WCwZlcXWCrBi8yb29vZiZGQEPp+PDS6gCY3km64RxVbsaWlpYWuxr+1MmXyy+WBE7dDQ0DpRazAYYLPZ1jWKTENRjE+xWq1GdXU1hoeHMywV6YOXQvXac5HNSltMw8wQjUYxNTWFRCKBxsZGdCsUaA114En7CMYWAzh3++nYoarKW8q0ELkELbAaHDY3N1dSzXG1Wo1wtRpwATOHjsE7PQuRUo6np+fQ4RdAKhBm+KZJpVKo1WrIZLIM0UTTNAZDPsgUU+hoqsHo9ALC0ThMnecULWYZGsRq/HvPeTA21UMtlkKYJAWFGsWjoJMoUK4oY0W9SqVi8wSXaq0tlD8zFxaLhc3TbLFYMIswfj/+Gh7FEsoWA/jUhe9jl00mk3A6nXC5XIjH49Bqtaivr89puUwXs9n8Oo9n8BWTy7bU7AByuRyhUCiv8JHJZLBYLBgcHDwhQWKFsjGUAmP1m3YuQK5QoEKqQDQSzahwlYtcQXLMdtdm2DGZTDh48CDMZnNGu+92u2G324su3ZyPfIFuCwsLMBgMGfsIh8MYGhoqub0q5D87MTEBmqZzWptVKhU7aN7M4CwaieBcWQ1OP6cLS5EAfJOz+Fj7mXnFLLA6SC/GOkzTNOs+xQjgUCiEaDSKRCKB5+dG4VqyIuj2YeLpl1G9vQPRRBxL0eApW/6WE7QniXSRMxnzIslbjYReGBiFSCLBw3NulDevWk/WjrLKy8vRYKnH1PIi2i7cB4FEgtCCE2X6muN+nEajETKZjC1dmP4gMVOMhR5qxvJht9tx+PBhzJVReMoxhnAgiPIwQWNXO9RFNAwURaG7uztrjtls1ZiykUvUKhQKhMPhdcvn8+/NhtFoRCQSyahClJ6ya3x8HM3NzUVvj4G57unThIFAAJWVlXnXi8fjmJqaQiQSWbWcpVlsquXl+HjLaRihy1FTXpPhQ20ymUpOdp7veJg69KX6wRJCIBCLQMdTiPqCCDqWoTRWoGdrD1TiwtPC8Xj8zRy81ejo+DzCzlGYxUtIiMohM5SeX3Nubg4t9Y1QK9WrH4hW3YD6+voKWuaZDpu5rkye4FKttR6Pp6Sgm7XHsHXrVjx44DncNzeAVCqJxeFBiGVSGK192CszsUEiOp0Ozc3NBYU246uZS8wy6HQ6+Hw+2Gy2DR8/sJq32WKxlCwmFApF1hLEazlex7kWu90OrVZ73NwZ4qkkHg5acejQEDSWamhpEfbzDdi7fUfB36yYHNS1tbVQq9WstbeyshJHJ0YgqlDDIFVBkiCYnp4+LmIWWLUCz8zMZL2HmAwzDPkKJhTC5/OhpiZ7Xzk0NMQOavLBDNA36pJH0zSGhoYyXOAGIyLEIscv/yvjm8wMoNfirZDitZcWQTuWUX/WLoCiQECgEkngPS5H8PZz6pWC+BchvWOXyeVIRGOQlqsgLVNCW1+N+q52bN++Hdu3b0d3dzdaWlpgsVhgMpmg0Wjw4eZdSLi80DaaIZJLUNfSjC0pFaxW63E/VpVKha6uLoyMjMDlcrGfp9dIL4bq6mp4yoT4/bMPI+gPIOBcgU8hwC+HXyx6GyKRCE1NTRgcHMz4vJSyfTKZDF1dXRgaGsoQsSqVCn6/n33PTLWWavW2WCyIRqNsFa54PA4+nw+XywWhULjh0q9MxgOGfH5c8XgcY2NjGBgYgMFgQG9vb87pR6VSyZ43Mz3t8XjYiOFiKeRXxlQFKpZ4PA7FUghhnx/mnZ2oP2MHqnra0KjWY7R/EFNTUxmdcioWRHD+KAJzh5AIuRAMBtHf34/6+nqYTCbwxQooa7bD0nsRgvHS/ReTyWTWlEFMBPnae3ItGo1mXREVAKy1NhaL4ciRIwVnGjZbxUcgEGBBI4BQJsHS4CRsrxxCxOPHgweeZweNvb29qK2tLUrMHjlyBHV1dUWlkGpoaIDH44HX693QsTudTvD5/A0FbslkMkQikaKWZY7T7XaXvJ9sxOPxolNTFcuDtn5YYz6kYnGEPT6Mjo2gTxracGWvbKhUKvT09GB6ehpP2Ybxny/cj/859hxuefE+/P7Fx9Hd3X3c8vcyeavXtuMOhwMajYa9510uF8bHx9HT07Mh8ZfNCMNUNSsrKytKpOr1+oy+sFSGh4dhNpszfiu9Xo+lpaUNb7MUgsEghHNu6CgJ1FUGqPU6UBSFbZpq6Iso5f5OhbPQniTSO6WLm3vx22cehlStBJ/PB08gwLlV+ctp+mbm8ePLPoGZuB9TgyO4fO/5kAlEbGL19vb24xrYIJFIsG3bNgwMDCAcDsMlAx6y9aE8Mo/9DV3o1BRnzZsILkOm1cL68iF4p+3Yds3lmAm6EUnGIRUUJzLUajV0Ol3RRQ1ynQ8TyMWM8g0GA5aWlljBubCwsGEXjra2Nhw9ehRH/Q4ccc4g7A+gw67BB8++aEPbA9ZbabMJm2QyCavVCp/Ph7q6uqLyR661XKVb1Pv6+tDZ2VlUp1VIaFVVVbFR14VgEovv69yK6pYG/MPWj7BgETsq6/Hhxh2QCURwOp0YHByESCRCtb4MkenHQVKrvl+2Y8/BI2rBjtPPX9fBl1LyOJ35+fmcx67X6xGNRjEyMpIzcDFfmr30qm75rLWluJmshYkS9/l8sA2NIuz3QCCXQkrxoG2ug1ggLMkqz1hmS/FfBFaDr/Kl4st1D8XjcdhstpIrmG0U5jiZnKKbYXR0FC0tLcfVL3fC60QinoR7bhG2N/rR++FLYYv5C6/4JsWWTheJRNA0mfHEP19A1B+Gb34JiWAIffW1WE6EUbXJ4LZ01lavAsC6NACr7YLD4Sg4G5ILv9+/zi2KCSrLlg0iFxRFsekeS+0j7HY7hELhuvV0Oh1mZ2dPeOq4qakp+Hw+bO3uAQHgN8gxeGwI+5p3g5KsivRTtfwtJ2hPIszNcpG5E4vVU1gQJkCBwmWdp6G9PPdU8tjY2GpEp6YCJlRAZPdA9qYYrK2thU6nw/DwcM5k2Zs53i1btuDul5/CgzN94AsEEPMiGI6u4Ia2M7BVtzqNk0wmEQwGEQwGEYlEEAqFWEuu37kMJBMwbWlFxOvHyuQMBEIBxsvHUKk3QKfTFfUQMRaxzdRiTxe1bW1tbGUchsXFxZL99BgoisKSVoQ7nnwAErUKQccK7LWVaPcuoFdXep16hvr6erwwcAjQl8ETXEYPnYKQ4oOmadhsNrhcLpjN5pKEvkKhwMzMzLrPq6uroVAoCmaqAIorTCEQCAqm5wmHwxgdHUVZWRkbmLMNamyrqMUhVGJ761u+x3q9Hnq9Hn6/HwPP343QygwqdWUIRWIIReLoaHPnFCKMNaQUi1m2oJR0amtrMTExkXeqmplJyHWPMzlkrVbruqpuCTqFRZezaP/ZcDgMr9cLj8eDSCQCgUCAsrIylJeX471nnIs/TR2E0qhDPBwFn6Kwq6KuqO0Cb4lZpr0phfRUfNl8yXNdo+Hh4U2LQmZWqZgBmkAgQFtbGwYHBzcsoIDV+0YsFm94ZiYbLpcLgel5eH3LUBq0UFcZ4JtfgraEHMJMkFwxlvX5kBdlVQbw+Hy88tO70PvRyxBx+zBin0GFpX3TGRsYKisr2b4LWPXRVSqVEAgERRVMKITH48nI38wElRVyl8lGVVUVW6SmWILBICvI17LRgXYp+x4dHYXRaERvby+mpqZQV12D6upqWKJCmJUGDPNWA6tP1fK3nKA9SaQ32DweDz3aalxcXY14PI7aPGLW6XQikUjkFaoymQzbt2/H1NRURlTz8WJYHIFQKsHM68dQXqmF0mTAXUv/RKputXMSCASQy+WQy+WoqKjI8HczhRrxvb4nkKJpVPe0gUdRuGzXPjTUWbC8vIzZ2Vl29KvX6/M+2O3t7WxRAybFUqllGteKWkoowKjTDn6SQKVSbWo67TnHBFRVRgw+9CwkSjl0LRY8YT2GLZrqDTfIB/0L+N3YqxDOysCjgOkjND6oaYVvxY2amhrs2JG/FGs28rmOqNVq9vqYzeacjXe+gLB08kUIW61WrKysoLW1NavgzWU1UKlUaDHrEFLG8I9nD2PatoQvffISkGTuqftSkrkDq89d+rRnLhh3GIfDkdXaw7h35Mv1utZaazAa8VrciWcXxrA8PoMdW7biRvXZUIreejZommaLDPh8PiSTSUilUnYKdW3HdDopR4yk8I/B1xFOEJxhbMT7G4qzfG5GzDKoVCoYjcasZYmzCVq73Q6lUrlpUciIuGJz7SoUCtTW1q4L9CyWZDJ53KzK8XicreKn0Wjw8bPehf8ZewmLw5PQtdQhvOJFT/j/Y+/Pwxs5zytR/AAoFPZ9IQACBPe9yWaTLbUWS7IkS5Zt2Zb3xInjbDOTxTP5eZLMJJnMzXJ/k7m5M+OZm5vtTnKdxI6XyTiyFMvyIsmWJVmyurnvBEEQC0EQ+74WCvcPqkoAiKUAst3SPH2epx+p2SSIper7zve+5z1HzJmwd0JodWIZaIpCPhbH/M88AbnJAKACfq6InZ0dFItF8Pl8dt1XKpWsx20nIEmSHWYiSRKHh4eYnp7G7u4uO6x2HsRiMdb6K5/PnytIiLHza+efy4CiKGxvb+PSpUtN35duDtpc4HK5EIvFWI/hercNxtKOAWNleZvQ3gYn1C/YMpkM+XwelUpz0/V8Pt9wcWxG5JiBk9XV1YYxmDRNd0zY0uk0TjxHyEUTiB/4kDk5waX+XiiMRk6T+xaZGr91+VE8f7SD3ZMs7pu/A5rQafVoYGAAAwMDoCiK1UkxDgMGg+HMwssscMyUeaO0MC5gSO23X3sJT4X2kNspoZjO4j1X78FIZbSthUq1ZVQ+n0culwNN0zja3kOeppENR0EV8siEIggki1gRrDTU+zJeqARBgCRJCAQC9v8JgkCZD3xp+0eQmQw4Xt6GwqLHytIihuak+OTVd3b0mjt9fxgrn1Qq1dAWjmsrXCiV4Gu7N/DV9D50UgWeGLgMNU1gd3cXPT09La8h5vNttMiSih5kon4M2gwwaVXY2vdjdq65NVKn1RCfz8d5M52cnMTKysppq7bumtVoNIjFYpwIFVOt/cKr38VTOzegsfeiQtNwZ+P489Xv41O2y4jFYshkMuDz+VAoFNBoNLDZbG3vax6Ph4d7xzEj1CKfz7e1pWPAkFmr1XruAAKr1YrNzc0z5L9eD5/P55tWtTpFp4QWOCUZiUQCHo+H8/vEYHd3t20aYDsEg0FWj2+xWGruv98i34Wvxirot41j7rIVGprA8vIyp2EpuVxe40PcCkMyHSzRMopWM1Auo5DJ4fH5e/DO4Tdt72iaZjtzx8fHyGQy7B6jUCjYA0m7++1IUMTXv/81yBQy9BfFIN7o2FwEyWPIPuOQ0K7z1A59fX0s6W6Hra0tDAwMtHz9nR602yGbzWJrawtGo7Hm/tnZ2cH4+JuyRpFIVDNPwlRo3264TWhvEaptu4DThTaXyzVd+JgIw6mpqTPfI5FImhI5ZuBkd3cX4XAY4+Pj7GbXKI61EeLxOE5OTpBMJiGVSnG5dwAvlwqYfP8DKGWzyISimJm6k/Nr75Wp8anRa9itaGDWmUH0EDXWRwRBwGQysZtcPB5HKBTCwcEBSJKEXq+HXq9nPfWGhobwlR98B9czxygf8HHX8BQ+OniFs/k+AAhFJL6PCKKRCIqZDKRaNV5PHGHoaBcLaitLWJn/VgdjMPndCoUCPT09EIvF4PP5eK+Kxj9dfwnTjz+IYiYHHo+P9951P65YG2ssKYoCRVFsAhDz/5lM5nSoJBVDzOMDTdPYf/5VDD50JwavXYZAe34RP5Mc1GwTrPYmXltbw/T0dM21k0ql2mq/6EoFf7r5IvZ5aZS9CZwYdHh9fQU/N3gH7rm8wGkyuxmhVdjvxPrqEgZtRnj8UZjNFngLZhhatPe5VkPaBWvUgxmsWl5eZv1eGajV6qZ2Sc0eK64UQmU1Y+/5VxBzHQEAIgSBjxsnYLPZzrUhdxLOUU1mL8oecGJiAouLi1AqlTWfa/Xz2tjYwPj4+IXo+eRyOY6Pjzv+OcbJQqlUcibD0WgUlUqlK+Kfz+dxdHTEVmOb2boJ8xQ+fOmummuYcXEZGhpqWX3lOiRH0zTW19fxLx94P46QRzCfQmjLiU8M13o4M1Hu9dXOYrGIdDqNVCp1mrz1BlFi1kymmksQBH5w7MDT8X1E3IcAgB+WKPyL+96LmXMQvBxVwjOedThDfvBiGZjCNhy7PC3j0LlCqVSyllit1gePxwOJRNL2WuDz+SAIouNOYyO43W6EQqEz8zQ+nw8qlarma2KxuMaXuL5i+3bBbUJ7i1BfoVUqlYjH4xCJGseO7u7uwmq1NtzMGTLSrG3CxGAyyV1DQ0M4KKfwtGMZAbcXjyrK+IB9BsQbKVGMiXU4HEY+n4dKpUJPTw/bGjQnenHiP0aoV4zQ7gEenb8LfTG645uQab9ardaW1kdqtZrdRPL5PMLhMLa2tkBRFDQaDU74RTwT2kMuloTMoMFLgX1ky0X84vi9DX8v483HEMZisYhQOg7/0RH4QgHWvvpNjLz7PlQoGi9FyjBP8FjSytjucNlcH9YMwK1wwCMuIxOK4k59H6YF6qbfz5D5ZousvUzha/lD5MsULn/iPVCY9AjtuyFUDbZ9Lu3AfBbtqjoDAwMIh8NYXFzEpUuXwBMS2IkHsOZ3oW+kdaBHMJeCIxmEQC6D49nvoWd0CCqLEVmzitPGwlRoGyGdyUM1/CBGBy0ob2+jf/QSMtkcNjY2zpBvBkajESsrK20JLZdgjXoQBIHZ2Vmsrq7WbJydOoMAgBB8ZE7CEGlUsKgUqFRoqHoM6Ovr69hHtxG4XMvMFPhFklnmdzOSFkYzzePxWELrcrlgMBguLGGs1WBeOzBDYlyIEE3TcDqdHcfbVldjrVZr25CcSCRyxoJKKpVibm6OHeBtJk/j4gxT/bnrdDow6tONGMU5LYvpVNST62w2i2QyiVAohMPDQ1AUhb/d/gHSggrCh17kwjEMP3wvXkv68a43ii+dHmrKNI3/uv48POkYkichULkCdp75Ij730X9xYTpVq9WKo6Ojpgf6ZDKJcDjMucPAuMF0uuYwYKqyBoPhTMeLcduo7/LWE1iSJBs6srzVcZvQ3iLUE1pmoRUIzsY0MVZHzSYwuWYva7VaKJVKfP3V7+N/uJchM2iQKefxXd82UtkMHlT0IRqNgqbppkbqNE3DuefAb7/nJ0CKSCyKF3F17iprkdTJqbe6WlJtfdTK0FwsFsNqtcJqtbK2Wl/60bdRSCRPc7G3KfTfNY/vuo8wn5cBdKVm0WZOwNUxpwRBwKjRQ65VIxmJYvZnPwSJVArDYB9mbJMY62/vFFAPiqLgcR3iNx/7OACwr2tpaQnyNzRmnYIUEPjF8XvxF9svnb4XaiXuGZrCFakN169fr4mr7BTNkoMaQa/XQyqV4tXF6/hGzoO0iIfQ4QGW5Dl89tLDsMnfHFrK5/NIJpNIpVJwBo8Q2jkAnxCglM6BKhVBiEUtZTbVaHWd7+3tYWZmBkKShN4yiEQyxV4jza4pZoNsdRCjKAq5XK5rjd3ExMSZ4IV2EazVCAQC6I2UINOqIRSLIRCTECmkuIuvx+rqKoaHh296hZYhNRaL5ULJLIPq0AXm8MG0r2Ox2IVIDRh0Yu9Xj06GxJxOJ3p7ezkd8PP5PLxeL+LxOPR6fUczD81IJUEQbKBNI50yg3ZDiszQU/3nbjKZcHJycq5rj4mCrd7XtCU3iqEg0idh8CAAlS8g5PNhS75Vk4JVD6YYIBAI2DWeIAgcpqPYch+AL+DD/foqNP02KCcGsZ0K4pr0YtwETCYTu/7Wg6KojmLOgVNCu7a21hWh9Xg8CAaDTV2OdnZ2MDIycubzrvdxZzS0bzfcJrS3CPWLCLPZ1W/u2WwWPp+v5aIulUo5+9cRBIGQjoQ4IsPR4hYKiSSoXAHPCNx4+NFPtbVo2t3drclPl8vlrCie2by5ml3XV0uMRiNyuVzLBbgazPCYeagfXmkZyWAY2VgSIoUMAoLAxPgEJB2cwt9lHMbXQj+C/dI4Qk4PxAUaD/V2TmaBU73UyMjIGXlHs2AIrpjWWvAHc+/Fi+XXsDA3D6tMDR6Ph16LBU6nEz6fD6Ojox2L+VslBzWCVCqFUw24dzzgS0jwCQFS6TT+5IfP4OftV1n9nFgshkKhgE6ng7XPhlfJFALZJGiqDO2AFXGPHzozN4IhFosbGuP7fD4YDAb2/dRqtdjf34fVamVtqNbW1hqS2nbVkKOjo3M5hcjl8jPdh/qAhUbI5/PY2dmBRCLB4/c9hLlsHH//0negNOpwR98orhrsyGaz2Nvbg0gkwtDQUNctylbEjCGzpgtOIayHXq9HPBrB4f/4M1R2bqCgUWJfN4nZD33qwn9XOxLXCnK5HFarFdvb202jT9PpNDKZTEunEZqmEQ6H4fP5QBAELBZLxxaEXOYFJiYm4PF4mtrvMZriRge2zc1NaLXahtepVquFy+U6d8x6Pe4w9uMrW7u49IF3ga5UkIvE8dh978CMvXVqG03TrEyr5k+aBk1RSB7HENl1Q6JRI7LvwQ62YCkIoFaruxpeq4der284CLq1tdXxvUkQRNuDdj3y+Ty2trag0WiaziEwPuiNJDP1Bz2SJDkFFb3VcJvQ3iI0GshitDPV38OkibS64aRSaUcXX6UCSHVqgCBAC049KIUCASwWM/i85r8nHA6jXC7X3LQqlQrJZBJyuRxyuZzVb3ER2zeqltjtduzu7nY0gHGHrg/ffOl7ME1PIJ9IQqKU45pxoCMyGw6HMS5Q4fcf/2nsJYIQWiahDGYgF3belvL5fJDJZA0XDpIkMTY2ho2Nja7tZwiKxmSPraYSylQDGWsWmUyGoaEhzkN/XJKD6hEsZqAZtmHrn15ALhjB4EN3o6SQo6enB0qlsuFr+7VLD+Lv9l5DgnCjV63HZ+cfhSxZ5OSdLBaLz2SMN2qh1bfPLBYLW6mtH95oVw1pZ9XFBfXdB61WC6/X25TQMlWW0dFRlmj0ybV4zDxeQ0qkUikuX76MaDSK1dVV6PX6M9Gk7dCK2FWTWa7+nOfBgPc6ll77Dio0jWQ0hN7wCUjXDDBx7UJ/DyPR6ra6aDKZkEgk4PP5Gh52dnZ2mg4JZbNZHB0dsdXY6enprg8i4XCYk0NBX18fpFJpQ7lEM0K7u7vLkvdG4PP5bXX33WAsR+KB0Rns8TPggYe7NDaMFBrL8OqfTyOd+50aFb68fx1FsQj3fvbTSHqPQYrEePDyHSAL5ZrhNcYVhCG5naC3t5e9Vxi43W7IZLKO7cCAzmQHzHrRzB0GOL2XXS5XWxvK6sNet52MW4nbhPYWoVKpnNlI5HI5IpEI+/dGaSLN0MnFd61nAC+uXIdhyIZcVHnqQWnsb0lmi8ViwxtCqVTWbM5MChdjg9VuYWjkC8l4VIrF4rZVIYqiUHSf4F8+8AG8nPTCnXXg4d5xfKCfe4snmUzi8PCQraAxHsDOihN+v78js3nGZ7D+lFyvl2Ysi5qZ8LdCNpuFRCJp+G9yuRxXrlxBMBjE8vIy5zjVbiAvAJFdFwbvXUAuloBCr8WAydJyaEZFSvCZ6XfirrzizfdIc2qozkzjNlvE6w98wGnu+tDQ0Jl7qf66Yt6DelLbqhrC1aqLC5jgBab70EjHyRxGGmnfgOZev4w+kYmWbuRo0gqNXh9zAPhxkVkAwOYrGNTK8B++u4wJgxJTJi0qW69cOKGVyWTsIbxbjI2NncqH5PKa693tdsNgMNSs2cxMgt/vB0EQ7MzAeRGNRjnHaOv1eojFYqyvr2NkZIR9zvV7DnAqlyAIoq223GQy4fj4+MKqtC6XCzKJFJ+Zfl/N1zc3N5seHtoh4g/gY+ZLeMkSRTCfgn1kGO+ADuV4GqaBgZprO51OI5lMwuv1svenQqFgSW6rfZgkSVD8Cr65uwypQgYbX4ZEJNK1XIaL7IBLVZaBw+GA3W5vWeBg1oG3Y6ACg9uE9hah0UUjk8lw6HYDaJ4mchEw5nl4om8G25ICDlM7uK9nGB8dbl2Fqm+hM2g0ZCEWi9mBmHYefwqFoqGNzvT0NJaWlprmUAOnG3x1hvwDuIQblRtYGOS+iDAkY3Z29sznMTAwgMXFRZhMJs6DM4zPYD3qLaIsFkvLKk8r5HK5thZZRqMRer0eXq8X169fbzvxDHDXdjK6sAWhFv7pScTKBYhVciSdR/jEtfe1/NlmYLyTXS4XVlZWmk51VyOZTKJcLjd8XSqV6kxsMaOp3dzcrGkXM4k/9Z9DJ1ZdXNDX14fd3V08u/IannHcwJP0EWZ1VnzAPgOP6xCpVIr1iewGjMSiWnrSTvvbaB1iyKxer79pZLZ68j2VSp1OirtOEEokUSiXkS0A++EEKMEReDdusB6nEokEcrn8XOldAokIO0duiLQq6MTtvZObYXp6GovLSwjqRfAXUpDSPNiSPDx49+kwajabhdfrRTKZPHc1thGKxWJH74FcLsfs7Cw75GUymSCVSuHxeNjvcbvdKBaLnA7aWq22YSBLNwgEAshkMg3vt6mpKaysrEAqlXZU7WSisR+54x48AqBcoSF4o2izvb0Nl8tVo3tluoxMAYPRccfjcezv7yOfz7P2eAzJZT7Pk2wSX4ztILDuh8pqRurAhz/80Ke7fj+qpWqNSKjP58Px8TGnolEymUQul2sr4xOJREin02/LyiyD24T2FqF+I3GlwvgzxytYXXwdz4ljuAc6fPC+hzk/HlcyEo/HEQwG8Yl3vAsAsC0bQq+pF0L+2WE0BoypeSfejSRJsqS2uiJQD6ZaUv/v1XrTRoNmjIVQNwkvDCiKYjW/zSI4bTYbZ62Yw+FAb29vw8+AsVar/reJiYmGVZ52yGazMJubh29UP3+73Q6z2QyHwwGfz4fh4eGmLULG6aDVNRQMBuF2uzEwMIApvR5z1By2YsegKmWYpsSIeU8AXfvn1gwDAwNIJpNYX19Hb29vy+r43t5eU8Kp0WgQCoXOHAiZYIdqUmsymdhNnkGnVl2c0aPGXz/1dZQyWaTCIhyFTrC2tIxfvuc9bTWXXOQjfD4fIyMjyOfzbOrd8PBwR8SHIbOddCaagSEFyWQSmUyGbe+SJAmZTMZa3SWTSRyMzmHcs4pBnRImlQSH0QyuPP5xCMYXQNM0stksOyjm9/tZWQkT5MKQXcYCqhFWIz785daLONl3Q5/ax2O2KXywg25ONYRCIV7lRfHKC0vQjvYjtu+F2W6F9bAX6WiMrcZymQfoFFyDTOpBkiSuXLmCra0tRBJxvI4ovrv4A/TlDnBVqMMYqeF8iOPz+axJ/3lkB/F4HH6/n423bQTGYaLeBq8ZHA4HANQQc0FVB3JiYgK7u7tnSG01GtmQMQEmiUQCgUAAxWIRBEHg64EtpEtZUPkCok43VFYT/sG9in+n6/4eMhgM2PMewmyxQE1KwOPxWG29QqFgXUHaodU6WQ2xWIxEIlFjSck1pOOtgrfPM/1fDNWENlnM47+tfw9ZPoVSJgvXngOZIQr3F3OcKwiNCFM98vk8HA5HjWyA0cA2q+Rks9mGLfT6391oUSNJEnNzcy2Jp1KphMvlavi4JEliamoK6+vr0I3YsZEIgODxsaDvg2drD/39/V2TWYYQj4yMtFyMTSYTbty40fa9DYfDKJVKTUkAY1zdqBLd6ZBYLpfriKAw72M7fa1MJmvqIlAsniYCCYXCmoVUQggxb3izLUZn8i2jX7mA8U52Op1YW1vD+Pg4+94IBAKUSiWcnJxAp9M1fR+USiUODg4a/pvdbofb7cb29jYmJiYaVkO6serigh+eHEDdZ4HjhVcR2HLAdnUWx1YzDKaelj+XzWabWvo1glgsxvT0NOLxODY2NqDRaBoa/NdLn9bW1romswzhZKquzCAkQ1zNZvOZAZya6+rnfxObX/4zDGWPIJXJUHrHVWwWJZjBKblgyGo9mKjtbDbLpg0y0hSGOMtkMtBCAf5y6yWU+TxU3ti0n/VuYkipxyVtL6fXSNM0+8efjmEzGYRQIcXed16BWCEDXS7hdZkZn7j6wE0lApFIpCbCtRMwntJ/+O2vYs3vQqlYxNGxH/uxbfz245/s6LGMRuO5ZAfZbJbdk1qRM4IgWClbu7Vye3sbJEm2fU5jY2PY3d2F0+nk/Pz5fH6NjSRwev19KbKJfDwL/+o20schjL77PuyE4tiVDUIsFkMikUAsFkMsFnNa54tlCv8ztI2Xl29AP9qPIYUeT2hGEQ+GOko2c7vdbRM3GYhEIpRKJdZWUCQSsYT97YK3zzP9XwzVhNaZDCFXLoFHCOBZ3IRl/hIqpAB7iRPcJebmMcqQymaVvupqZPUFymhgmz3Hra0tTE5OtvzdrTxMCYLA5cuXsbJymo5VbyvVztxbKpUir5XiN/7hv0M/1g9UgC88/w38zoMfPVdS0cbGBvr6+jhVRkdHR1lbqEZopi+uRjPLKWaYa21t7Vx58VzQTl8rl8tZi7hq+P1+HB0dtay0MxgYGMDS0hI0Gk3TRZdLtZGpNMbjcayursLaZ8OLKR+e3nwRkpNFWNN8/PYHf7rlz7dqndntdrhcLlbTysgOLBbLuay66lFtW5ZKpeBybiMWD0AkFiJbKkM3eOoh2s66rNtcdbVajYWFBQQCASwuLtZUvTO5Eva9MaiUFNQaLXa2t5pOtVeDoqia11RtlC+Xy6HRaNrq9YA326bMdZXNZsGfewiKN+4zCwDK42EPHs1AEMQZksGAkTZks1lsH7kQ2DsA6Aq2nn4BI/kCSIkYz8X5KJiHWz5X4E2NIWP35s8lkPQHwePzENreh/2eK+DxBAiFw1hZWQGfz4dIJIJYLGb/yxCabir/dKWCZ72b+MGxA4GdA3zg3nfigwZ9y9mHZsjmczigU4CAB+f3fwTzzCj6757HjZAHV/TcD3J6vb5GstAJisUiO/TMhTSJxWJ2vqLZWrm5uQm5XM75QN0Nqa0HQRAY6+1HiuRj7JF3IB2KQvCG97vZbEY+n0c+n0csFkOhUKiZA2CujWrCK5VK8Y+uFexmIqiggmI2j9f3FpGzhPG7j36C8x6Rz+cRCoU4JXgyz6XaGq1VkM1bFbcJ7S0Ec2FWt/uVZiOykShoioJglLtpulQqPSPur8bGxkbDTPdWRuNOpxMWi6XtBa1Wq3F8fNxUb8d4IjKktlNd8LORfch6tDjecYIQCKA06vFS5gjT6G4B2t3dhVqt5vw8mIn9eDzecNNspi+uRjPLKYCbFVA1zkt6GX2t2+3GjRs3MDw8DKVKiRdDB3hm7fsYRgiPWidhF6s6bm8Bb1adm/0M14Q64PTamp+fx5+98BRePNoDX0gg7DoCZe3Bk4er+MRw88WakbM0I6YDAwMsqWV8UC0WC7xeb8e65urWeiqVYu8pxraMIXlCuxH/de0F0GUK+pFBZIJR3Dsx2zbVrtMKbT0Y2y3mM5erTHjuehDHfi8kEjm+/f1VfPx9V2pedzO5QHWUKZOM1wmy2Sx2dnag0WhqrhGXy3WmKt7X1wen09k14ag29Rfr1TBkT7tBo29U4yU6Na5eXcCCqT2hrcd4mcLzlRDSpQJmP/5ekFIxxGol3j/7EIaUBtA0zaZI5fN5ZDIZRCKRM6SGIAiIRCKQJFlDfMVicc2a8h3fFp52r4GmaaSKOXzbvwMhIcTj9jc1+xRFsQQqn8+jUCggn8/XVN4AQCAkkIsmIBSLoerrBUAgHQgDhs46K93KDhgHjbGxsY6uH6VSyTqGGIftcCbDkBIkptQm7GxtQ6vVdnzvjo2NweFwnIvUfnRwHp50DKlKFFKtCjqlGlcL8pYzIABqPqtUKoVQKIRCoYAX1l9GOJ/GybYTnh+tY+oDDyKhJjta++vjbdtBKpXWEFqmQvt2wm1Ce4tQXaEdU/egV6qCJxqEbqAXpokRkKk8Cq5j+MsiTu0/sVjctNLpcDig1Wo7qmhGo1HkcjlO07hc0nf4fD4uX76MtbXTBbma/DKWUc2qFslSHgKhEKENB5RmIwyjA4gXsg2/tx3cbwzdddpOHh0dxdra2pnTrsfjYQcEWqGdtZrJZEIqlWprV5bP589FbBjw+XwMDAygt7cXDocD//2Hz2KHLCCWiaMYO8aPdtbxYf04Hlm4u+NpcJIkYbfbmxJ0iqIaBoi0eq4htRDSnApb3/wBgAqM4wNYinhbElqNRoN4PN5yQxkYGIDT6cRrW2v4h+0fgUjvouIJ47c+8FNNf6a6QplIJFAsFlkbI5VKBZvN1jRNbkpjwftVg3ihl4JAq4DCn8TPjLSPjc7lch3prBuh+jP/P/78GSRSOaDCRyIahEKtxcpOBLxKmbNcoFMw1kGJRALj4+M1BKhYLDZ9jUNDQ9je3u7Iyq8R9GI5HrFO4Du+bQiFQmhH7JBFclDHikAXs2+kgMCvXXoQf7H1ErLSBJAv4dOj1zCkNAA4fb+Z8IBWYIhvI2JTTUL/ce+HiNMFxA68yKYzICQifN19AnPozXWFIcdM5U+j0bDkuP6ze1xaxA8C+zBNDkHd24N8IgXNcQZxS+ODezMwEdLtoq+rwXTIuumCGI1GXPc78R+e/Cuo+synftf+BP71vY937egyMjICh8MBh8PRlQOFkhTj3115DK/KNlAu07hrYhpUroDV1dWWvuzMZ1OPcX4Ee4kT8CUiFLJZJI8CUFcIzg4Efr8fMpmso7W7UYWWSzTyWwm3Ce0tQvWFKeQL8K9n3oUvLL6AirYH95qG8P47ZyAjSLai0m74qVn2st/vR7FYbHmT1mtgKYqC0+ls61nHgKtnHTPotbGxAYqi2MWHkSw0ItwURUESTCMYD2PyA+9CLhJDzOXDQ/c0HrQgiOY3fSAQYCfJOwVJktDpdDU2Xul0mnOkIZ/Pbxt5yhjwy+Xypp91Op2+0BYQSZKYmJzA57yvIeYOwLe8iVQsBkO/HTFTZwtiNYxGIyKRSEOzca4DTjUo0ciEY9D2mUGVKEQOvKiIZfDb/DAajQ0fT61WY2d3F1abDfwWEbFaqxl/8PVnEAuHQOYTEEml+NzG9/B78+8FXSzVtNfPW6GkaRqmkhD/+bFPgc/nw+fzIeg/btsiLRQKFxbVKRQKIVPbUObH8K2v/Tl6zP0YnboDwXACmmsDnOQCnSIej8PhcMBsNje8X9pplhlZDkmS53Je+FD/ZQwrDXghzsPC6FVc6xnAif8YS0tLXbkQ9MrU+MOrjyNTyGNvaxtzPZ3HUHMlvk+XjxDb20MqGgePJ4BIpUKPXs+5pVyPTwwvQEmK8a2jGPrURrz3yiMYleuxt7fHumRweT8Y2QFXQttph6weFF3GtzIe0BUayeMgCqkM5DottipJ9Hf1iKcYGRmB0+nsmtQK+QIMKnSnVWuBEJALWd0vF7lWNd5vn8F/WX8eArqCnsE+8IVCvEc7hsXFRZjNZlgslqbElqIoHB0ddeyfzezjzD7FDIm9nXCb0N4i1A9jyIQkHtINYfySGA+M3MF+namoOJ1OeDyejqIu4/E4AoFAy+lR4KwGlkk36WRT4+qyUE1qaZpGX18fZDIZMpnMGUIbDofhcrnwC/MP4u+DGzjJpaAwG9CTBUaywoaPz3iV1j8PLpO07dDTa8H//vW/Q8wkA8HnYzBG4188/ETXj9cIzDRvM1uiVh603SKVSiMVjaNSLiMTioNPEFBqNPAfepG2prsmtWNjpwtwvYdjJ5OzFEXB5XJhNEvAY+mBymZG4ugEukEbPm6/DIqisLa2Bj6fz0Z0EgSBMk3ja941PHn9ORhT27jT2I+fHL7a0M1jM3YMQq9GJRzB0hf/CZd/8nHsrW3gqbQI06Y+KBQKGAyGhn63ncLvPyXgzONYrVZcv34dvb29Ld+TTlKD2oHH46GYDSERCeGRD/wCcrk0LNZBjI4Yuh6ybAaKouBwOFAqlZoO89A0jXg83pZETE9PY2VlhZURdAMej4dZnRUl8wgW3tDNWq1WKJVKTjaDzSATiVEul7t6TlxQLBZhTwAOUgj7HbMQkCTSxwHcN3N3148p4PHxuH0GvRGqJuRlenqaDevg4mPNhBpwWf8Zve15Ku2pUgHpZAo8Ph+rX/4GrFdnoek1IZhPd/2YDIaGhuB0OjmnVbaDWCxmB6P7+vo4k/hhlQG/dflR/H3kGQwMjGPBYGdlLF6v94wePphLYTnsRQWAOJDCzNDZeFsu4PF4NRXat1ta2G1Ce4vQqIqYSCQaLqbM4BATdSkUCjEyMnJmc6hO+WAcDRr5q9ZDrlDA6XNDpdchFgxBJBJ1vGFwsXyqxvT0NDY3N+E6dGG7nMBr66sYK07gUdsklHySnXyem5sDQRD436x2HOcSIHgC9EgU8Hq9Z/xEgdMp+PpKaDqd5jRJ2w5/77yOI5JC3neMCk0jLpfh9ZgP90u4nea5RG4yefHr6+sNNagX0XoGTt+T4+NjxONxSKVSXLGP4pBOg8fjg08IIDFocad9FG63m01VMhgMHQUN8N8YjNjY2KipInHV0DLDaHa7HZ986D2YjvjwUmAf7kgBHxu/B1ff0Pv19fWhWCwiEAiw5HYxH8KPcseo8IBCoYhXTw4gFgjxhO0S0uk0O42fy+WwG/Eh4T+CRKMEQQpRzGTQMzWGS1cusyEbF4X6VDMAsNlscLvdFx4j2gjJZBJ7e3t45512/GirB1SZRsoVhkIqxN1z57fpqgZj8Wa321tu5F6vl7MN3czMDFZWVkAQxIUM7TFQKpWYnZ091WYajV21rm+WzRHzPn7kzgcwkp3EP7z0HDQWM66M3wFDuADadj4j/EZrklarhVqtZjuErVKogDdDFlpVaYPBIOLxeNPh2naIRqM4OTlBIplEKZaGWKXAzMffC55AgHQ4ilTZA4/YAovFcq7P4LyktlHIy5UrV7C2toZiscj52rLJNXi4dxwLQ2+unYwVI7NmXL9+HRWNFH93sgGKplFIppGPxPEfxobQzZFPKBSy+2c36ZG3GrcJ7S1Co0WkUChApVI1/Rkm6jIej2Ntba3GiqdcPtW+MYNczGRwu6pOMJfC/+X4AbbWN6A5WcFISoDfeP9Pdvx6VCpVQ9/PVpiamsJ/ePYrWEsco5TKIBQg8b2tZXxcN4Gr0zM1xE3A58MqezPqta+vDx6Pp2HyUzWhLRaLbNjBeRa5SqWCxZNDgCTg+s4S1AO9GLjWi6WIB/dbuBFaZoFoR/qZKd2tra0z8ohcLte15CCZTOLk5IQlsWazma2KDVIj+Nvd1/AC/xDmoQGMJQV4eOzNqk0ymUQoFMLh4SFIkoRer2/a6q9/LSaTqaaN105DyxiZ63S6GlI/q7NiVmfFjZwcC3XDKyRJoq+vjyW3/++3v4hw8BjB7QOEDjzQ91vxTacfE1eErC5Ur9dDKpVitDiNrcUyotEopj7yKFAsoeINQn+5cRegW/j9fuj1+jP3PWMN14wMXURyT3WllAlvmBgtwHeSwvGgAGODRkjFF/N6q624mANpK3QSL0wQBOtP3Uqb2A0Yj9bd3V1sb29jbGyso/edOdRfVJWbCWrh8/nsfXCfSgX5cIqtqPr9fs7DpJ2C0VybzWbs7OxAIpFgZKRx5a+d7CAej8Pj8XSUnEXTNMLhMILBIHuQ7+3txcTEBGQjVvzF1ksoF0uo0DSuzlzBP5u8D6HACVZWViCRSGC327vuLg0NDdW4oHTynBuBmSHZ3NxEoVDgdHhtdThiPhubzYbfefYL8B/7IDFqkQ6E0TM2iK8eLOLfXn6U8/NmIBKJ2Krs2zH+9jahvUWov1AYEsZlWKbeioeZWN/f34fP50M8HsfDDz/c9mauVCr4080XESlkAbqCmMuH3T4LXg0d4l5TZ9WiVr6fzZAs5uCW06jEaPjXtlEGIFXIkbEoOVUhG5HaakJLURRWV1cxMTHRsf6w3m6pVCohcegHTQogN+nAr1RQSGUg1HIfbuLiFczAaDSe2jzVGX93WgGqJrFyuRw9PT0NW7sSgsRP2a/gfr4BExMT8Pv9cDqd7PdWG4wXi0UEg0FWC63T6dDT09OUXFitVqytrSEajUKr1TZ9DdVhADMzM00PY+0q3SRJwthrRkEtRi6eBF0qwTA+iB6JsmF1SEmK8Zuz78KfvfgNaPv6IU7k8UvvfBx+rw+ZZKqjYZdWODo6aqpL7+/vh9PpbLh5nncQsFmlVCkXYVIuwmCvHHt7e7D2nr8aXW/F1Q7NSH4rkCTJ2ZO0G4yNjcHv92NpaanldVgPlUqFRCJxIYQ2mUyy7hv1Uqzqa99isSCXy51rQr8dxGIxLl++jGAwiMXFxYYV91ayA8Zrlku3kKIoBINBhMNhFItF6HQ6DA4OnllbLml78YcLj2PNd4B8IoVHLl0Dn8eH1WqF1WpFMpmE2+1GLpeDxWLhnPZYDcYFpZ1tXD1a/Z6pqSk4nU5Oj8klPIMgCPB7NFDwS9j8pxfA4/EgEAhQlsfg1oyzg2Fc9py9RBDf8G8DkT28R0zhnRZuscpvJdwmtLcI9RtyMpmETCbriKwwVjzPPfccNjc3QZIkIpEIG3k6MjICiqKa/knks9jdd6BSpuH83uvovWMGPVIJ9hInHRPabk5z+fIbrQ25FME9F/giMczjg9jb3IKjfFpFUyqVLaswfX198Pl82NjYwND4GNbjfiAlwF1SEbw7DgwNDbUk9lztlgiCwCeNYvyTZx2lTA764T5EDry4NHhH08euR7NwhWYYGhrC2toawuFwRw4VyWQSx8fHbF59MxJbj3g8zkbqWiwWrKysNLS9IkmS3TiYKsrBwQHr3cpIE6oxOTmJ5eVlCCViHCYjUEvlMFcqrGbL5XIhFotximsViURt/RHfbZvEn69+D1K1CnwhgXwqg8dGrzX9/h6pEk+YJzE9Pc0eAi5fvgyPx9P1wFA1gsEgtFpt0/tbr9fj8PCwoVaW6yGoHkyqkEQiaWm7JhaLUSwWz1UJzmaz2NraOlNVb4dude1isRgTExNYXV3lVAXuFBaLBXK5vG3SYTWUSiX8fv+5f7fT6UQqleJM1oeGhrC5uVkzsHozwNj9ORwO+P3+M/HUjWQHFEWx0rBmr4U5IAeDQQCn98Lo6Gjba14rluHuvjHs7Oyc8eJVKpWYmpoCRVHw+/1YXFyEXC6HzWbrqGrbKalt5ycNnH5ePp8PKysrmJmZaXqvcCG0NE1DGs0iEwjj0hMPI+EJoGd8CBMSPSQSCVKpFAKBADswXp3Qx0RIA4AjEcR/WXsO4UIMVJLCVw8WkSzl0Z1nxK3DbUJ7i1B/EadSKUgkko4XZj6fD5VKBbvdjueffx4OhwPvec97sLGxwWZNCwQCEATB/hEIBKdtY7EIEpUcNF2BaXYcCoMGoT0XoOiuUtPOfqseOrEMglAKhVQKCz/7EeQicYg0Sjx67V4YhEokk0m4XC7WOoQhmczNyPweq9WKZCmPf/k//hw5iQAVmsaXV17CL9/xaA2xKhaLNVVXxm6JucHbLXbv7ZuGXCjCU0cJDBn78M6Zh1E5jraMT6xGs3CFVpiensbi4iLilRJ20iF4I14MFSahEdWSuXoSazabO9Z/pVIp2Gw29u+Tk5Mt/WQB1AxjMc/j5OQEBwcHp5XSNzZBgiAgMevxy//wZ6BEBEipGHdnp/A+9RD8R0fo7e3lXGGSSqVtfS8XDHa8Xz6A3XE9hGISPcky7mozgc5UjrVaLQ4ODlAsFtnwjdXVVQwNDXVdffN4PG2J2/DwMBwOx5n2cTeDgG63G6FQiNMBATglK4FAoGNCVG3FNTk52ZEEIBqNQqFQdE1G5XI56wxyM0JJlEol5ubm2PS0doNM59UcMocCo9HY8lppaAc3NcUOzJ0ncKYd+Hw+xsbGkE6nsbGxAZ1OB7vdDj6ff0Z20CqNMZ/P4+TkBKFQCARBQK/XY2ZmpuNrod17ThAEK0WKx+PsodFisdQMZ7bCwMBATbJgK3A9FFqtVpAkiaWlJVy+fLnh685kMi215czQ9Ccm70bFoMZRNg4+IYCWT+LTM/dCSZ5dM5igkXQ6jVAoxO6tT3nXEM/FkEtkkE2k0TM1jO/6tvELsrG3Vfzt2+NZ/i+I+mpmKpXqesiBz+fD4/Hg6tWrGBoaYls0XOxcPjJ1F7746nPoGbNDptNCUKIxVJJibW0Nw8PDHW1Qrey36kFRFDY2NvBzk3fjGxkPnEceiAgh3qGwwVwRN0z+YWQAsVgMPp+vhpB+N7iHZLmA1GHs1DZFrcA/HCzCyBPV5MczhLi3t7fjihuPx8MdaisMl+57k3ToLHA6ndjc3MTExETLxaxVuEIz8Pl88C06/Juv/xUUJiNyyTR2F5/Bv738KKQUzk1iq5HJZGo+b5IkWYcNrjY21dKEfD6PYDCItbU1VCoV/LVvEfkKjVwwAqVJj++88iLIiQx+5u5HOiIjjM1cK9A0DYtAig9cux/Aqe9lq5CF+oNYf38/3G43RkZGWGKztbWFSCTSsaVPOByGSqVquymo1WocHh6eIeu5XA4Gg4HT72Ja1T09PR3ZOZlMJjZYgivaWXG1w+HhYdsUwnZQq9Xo6+vD2trauRxMmoEZ6HE4HJzu8W4Hw3w+HwKBQNtDQT6fb7puzczMYHFxESRJXujAXCPI5XIsLCzA5/NhcXERQ0NDEClk+M7xDv7p1SP0qrUYTQkx3tfPruPpdBonJyeIxWLsYfdmpyNWg9lTisUijo+Psbi4CKVSCbvd3rYazMRlNxpE7hZGoxEkSWJ5eRmXLl068xwymUzDAks+n2eHw5nuxO9Y+3CUjSNijUBGoSGZBWqDRqrxsjABz1EZwV03Sm+sreUKDaHoVEbSrRb5x43bhPYtgnw+D61W23Hb3uPxoFwuY2Jigk2DyWQyuOeeezj9/GPWSYQ1B+AP9EAiIPGAZQR6sRzpdLqlo0IjqFQqxGKxtoQ2m81ic3OTrXgt4BKiown43V5MTk5iaWkJJEmeIbSMCXW1fouRDIQ9ywCfj9CeE6HtA1z+5AcQzaVhMpmgUCgubNFMJpNsW57B0NAQ/H4/20Jqtpm1C1dohq8fb0JuMiDkdEOqVSPg8uBz3i/j0zP3nZvE1qP+fWolPWgHsVjMVkdS+SxS3h+hggp2nn4BtmuXMXT/VZR0nZv1S6XStv6IPp+vproxODiI/f39phPW8Xi8ZiCTkQAw5IQZRvL5fLhx4wY7WMUFh4eHnCe7BwcHcXBwUDMMyMWDtnroq9Hm2A4kSYKmaU4dFi5WXO2QTCZBkuSFeOsajUY2RvVmDEcBpx6lgUCAlZ80e96dDoZRFIWtrS1IJBJO5K5YLDbVU/P5fMzOzmJ1dbWra6AbWK1WGI1GbO/s4K92XkGUR6HijWDP5cR1iQT/vr8fu7u7rC1kT08PO8h8UeDiHlMNJvjFbrcjGo1ib2+P9UVvNdRst9vh8XjaXmedvDa1Ws262kxMTNQQx0avqVnnRcDno0+uhVWqxuLiIuffz+BqTz+WfU6o+0wAKuCDh2mtBRKR+G3ldHCb0L6FQFEU580hn89ja2sLGo0G165dQ7lcRjgcZlsJOp2O0+P4fD48NHnljJWIXC6vcVRQqVQYGBhoWXlQKpVtc72ZAZX6BVerUOEg72CnQZeXl8/c4I3A5/OhVCoxOTCEsLgC8rEHMHDPPOhCGSqcTrRf5OKZSqUaVsssFgvEYnHT0zbzXNuFKzQCk4rm+dEKSIkEY4/dD+VQX0eDCu3QSqc5Pj7e1EaMK2QiMdQGHfgCPqY+8igIgkA+noJqoHNPXalU2jbB5uTkpGZynql6pdONfXUTicSZz7Wvr++MnZbVaoVarcb6+nrDgZ16MG11rve1UqlkD2nM82ynoeVqj9UOJpMJgUCgZWud+V1cXnsrHB4eYnCw8xCCZrBarSiVSl2b4nOByWSCXC7H+vp6U/mJQqFAKpXiRGiZlnEnpvvtBgQZi8f19XXO2uLzro8kSUJmNyHpI5D2nODwlUUYJ0aQ16vx4u4q3nfpzgs9dNeD6dh0U0VkqpXFYhFerxdutxtarRa9vb0N77lm7joMutGhy+XymgCGkojARvQIh9EjTJQuQSYUsd2Qdp0XJqSj2TrXDHfo+nCDVmJ/RI7jvUPM6HrxM6PXEA0EGwY2vVXx46n130ZLMOLvcrnMaQEKBAJYX1/H8PAwq1cSCATo6enB0NAQZy0XTdM4OTlp2WZkHBVUKhWWl5fhcrmaVpHrLbPq4XK5EAgEMD8/33KDJggCs7Oz2N7e5nwzvd8+C7NUhUqZBimTwTY5jJ+beyeWl5cvZFCDQbM2EHC6ODKbSTKZvJDfl0wmIfBGUEhmcPlj78HgA3eCSmchOI5d6ELTqPLMQCwWw2w2w+Vydf34fB4fH7LNIHkchGl0AIbRfohpHgYynS9B7a6zcDgMtVp9ZmMZHBzE4eFhw59pJPkxGo2IRqNnfpdcLsf8/DwCgQB2d3dbdlUODw87dkkYHh5m3R5aIZ/PY2VlBbFYDPPz8+cis8Dp62UGc+pRLBaxtraGSCSCubm5c5HZfD4PmqYvvI05MDAAmqbZeOubAblcjrm5OXg8noa/R61Wt+0eMHZcgUAAc3NzHflKt5IcVD/HkZERNma8Fbh6QrcDVaHB5/HAExDIxtIQysSQqJQw9lkvxDe7FRhN/XlAkiSGhoZw9epVqFQq7OzsYGVlBeFw+Mz3MpG9Gxsb5/qd1WACGL63dgP/5rkv4e82XsGzwT38b68/jR8uXYfH48Hs7CynQIre3l4cHR119Pt3d3fxybsexp/c95P4nfnH8M/H74WUIEGSJEqlUrcv68eO24T2LQCGTLSLBGVSkRKJBObn55u2gC0WC46Pj9v+Xr/fj56eHk4LmtFoxNWrVyEUCrG4uAifz9fw+xqRDZqmsba2BgAtpzqZ2FrgdIGZmprC+vo6J3IuE5L4rblH8bPDd+LnJu7BH8w/jvnBMczPzyOXy+HGjRsXQjLb6ePkcjlmZ2ext7fXkBxwdYPIZrNYW1uDx+PBr7/7YxgaGQapkKNSqeDK3Bx+9q5HsLW1hd3d3a6qvvVIpVItPZCtVitSqRTS6e7TeDTRAv79Y5/E44OX8ZHBK/ivT/wiLFoDlpaWLuQ1MPD5fDXDbQzkcjkoimq4+TWrrPT29sLr9Z75Op/Px/T0NBQKBZaWlhoeLuLxOCQSScctealUCqFQiHg83vR73G43NjY2MDw83LFfajMQBIFQKYtvOlfw6skBim+4kPh8PqyurqK/vx8TExPnHhBxuVznSopqhbGxMaRSqQs9xNaDIAhcvvxmSl31/dyumJBOp7G4uAiNRoPp6emO30uuEchqtRoWiwVbW1stv+8iBn6y2SxSriMgmoZhwIa5T7wHpvFhkGIReN4Idnd3b2qVTyKRtO3YdAK9Xo/Lly9jfHwcsVgM169fh8vlqvlcmWHRelJ7Ht9WgiBwQ5RBKhxB3ONHKZvHweYObhQjHdnHqdXqjva6YDAIgUDAHlKZCi/wZgLo2wW3JQdvAaRSKZjNZhwfHzddXJj2FJdJa6PRyPoFtkKj1KJ2sFqtsFgs8Hq9uH79+pk2p1wuRyAaRq+hBzwej9XLcmlRSiQSpNNplqhLpVKMjY1hbW2Nk75MyBdgUK6DSqWCgjxd9Pl8PoaGhmqE9CMjI10t4lwXf8agfWNjA/l8vmbzbheukM/n4XQ6USqVamKOf2/hffClY9hcXcV7Zt8JPo+PHq0ewWAQy8vLMBqNsNlsXRObVCrV9noZHx/HxsZGV4Mcbrf7VLZiG0C1E6vcaoVcLsfy8nJHRvnNhm+y2ezpUGCT93dwcBAul6tGA9fKRcBisbDXeaPXbLFYoFQqsb6+DrvdDrVaDZfLhXw+D7/fjwceeIDT66nH0NAQ1m+sYFhiAY6zoIsU+CTR9dAXF7x6coAvhzZBeQpQWIz4xv4yHiN60WvsOZfcpBqMxv+iI3arMTk5ibW1tZs+8T80NIRwOIzFxcWaa7eZptPtdiMSiZxL38qV0AKnEolCodBShkHTNCfv80YoFotwOp3I5XIYGx7BH42N4G/2XsVOMg1NRYh//sD7MKo67XLs7OyAz+ejv7//wgfWpFIpIpHIhT4mcErmRkZGQNM067tNEASsViu0Wi0r06uWH3RrfUdR1BveuYeoANh59kUoTAZMfeBB5MS8jh9PqVQiHo+3rY4Xi0W43e4aHiCTydh9+O1Wob1NaN8CYNrYjTZomqaxu7uLcrnckSZKLpe3HOTpxtC8+vHtdjt6e3vhcrng8XgwPDyMAPL4v/ZfQjyZRI+tF0/oxyCJ5zkTleobiYFSqUR/fz/W1tZaVncZFIvFhu+RWCzGzMwMwuEwlpeXOWWU14OLLyADJqZzd3e3Jm2mWbgCRVGs/+Tw8PCZhUjIF2BAqUdEoqrxXGQss5hpY5vNBpPJ1NHrYn5/u2tLLBbDZDKxByuuSKfTiEQiTSfh1Wo1qyHjao3F6Obqr2+3292y+qdUKlEqlWo+g/qBsHqYzWZ4vd6mhJ+RIKyvr+OZZ56BXq9nbYnMZnNX0/f8aBHFbx5ip3yISqWCE+91RO6QgSZxU8IESnQZX3S8DpFKgYQ/CLpSQTiTw+W7rbj3goIlgNPPp5tY2U7A3HtLS0sgCKLhpn5Runomba760J4R0Hj5YAsjFhvMUhU776DT6bpyg6hGJ7aIwOkg0/b2NjweT8P7ohvJASPrCIfDNYUKJYB/e/lRhK3zSKVSGFCdFjoYnWo6nYbb7UahUGg7gNUJuGjqzwM+nw+TyQSTyYRsNguv1wun0wmj0Yje3l4AwPLqCo41Qnx/53X0xI344MQdGFI2diahaRrJZBKJRAKJRILdsxQKBWy6HoR1Jcx85N0gRCKkfCGgLEd+vDMvambNakdod3Z2zqS/yeVy1o3n7RZ/e5vQvgXAnOrK5fKZsIXd3d2uhj0YHU0zQtsqtYgrCILAyMgIisUiFjfX8N9Wngep16CYyeLEe4Q/3XXicx/+Z5yrbtU3UjX0ej2KxWLDKNh6tCNmer0eWq2WzShvRB6boZXOtBnGxsbg8XiwsrKC3tEhPOvfQf6IwvzwBO43jwCVSs3m0G54olllkqmcu1wu3LhxA4ODgx1NWnOtWFutViwtLXEeOmD0gpcuXWr5fYyGbGNjA9lsti3paURomepfu8+zv78fLpeLHapLJBINJQoMLBYLe1ho5cerVCpBEAQcDgfi8TjGx8dxcHCAgYGBmuFELgQi8awDNqURL+8tQa/QYmVnA6PaSxj6xDXWjYCmaVAUBZqma/6/+mvlcrnma8zfma8xSBbzON4+1e3uPvsixt79DlgujSMjaG8UzxU0TSMajd60RKtqtBouvYgo4WpIpVLMz89jY2MDX9t+HS/H3Cjni1AcG/CgzIrBsoTTgGsrlOgylsNeLJ24YMgOwCbXtP+hNzAxMYGVlZUzDjEA2src6sEkwfX29uLq1asNv0culyMQCDT8+tTUVM0AltlshsViOdfn8eOMaGW6hjRNIxAIsO/rd4938PqSCzyCQFhcgXPtOfyb2Udhk522/5k/+XwefD4fCoUCKpUKZrO55oDyqyYdPrf+PBI0DVIuxfjAIH7KtoCtrS3IZDIMDAxwOtAolcq2umK/3w+JRHJmvZTL5eyswdst/vY2ob3FKBaLyFQo/Lf172FpeQmT5WP85PBVFIOxjtJi6qFUKrG3t9dw8W6XWtQpSJKEyGaEJKBBcM+Njf/5LO78pU9CM2SDKxOFRcFt8ZXL5U1dEiwWC0qlUttsbS6DdUwOdm9vL/b29uDz+TA6Otr2fU6luotB7evrQ55H49e++qfgKRWgqRIcvAzWnbu4S2xquTnUo1llknldQ0NDKBaLcDgcbOW83UbaKVGfnJzExsYGp5b39vY2J59H4E1t4u7ublsTc6lUeiakwuv1cvJRVavVbHACSZItB/2A0/e1p6cHfr+/JdFmKi3ZbBbPP/88lEolRCIR1tbW2PeX2RzqN4n6ezS0sQKUK3hm7QeQikh88PLDOHQcIHbj1EKMz+dDIBCc+hTz+Q2/RpJkzb9V/z/zXwblCo1v8AJIpJMYfeQeiN7Qa1tl6rbvJ1cwmv0fFwiCYCv/1W3+m7FB8/l8SO1mfP9bLyAXT4AHHoq5PL4mOMJ/+cDPn4vM5ssl/KfV5+DNxBDyHWBluYCfGb3WNiikGkzFWiwWnzkEciGTjOTNaDS2lZ+0010yA1gDAwNsZ0mr1cJms1145+Fmgc/nw2KxwGKxIJqI48bKs0iHIvCv7cJ67xXIJTL8TfBpPN4/w3qfDw8Pt10He2Vq/OHC4/hW+WUMDg1hymgFwReg12BEOBzG2tpaTXplK2i12qYpk/l8HkdHRw0lh+2Gbt/KuE1obzGCsQi+7FsFT69EqpiDI+zHv1n5f/DvHvjIuY3CDQYDgsHgmRY0l9QirojH44hEIth3O5DwhyCSSWGYGEYpe9oCkhBCzo9FEETL9obdbsfu7i5rUdQInVQbSZLE9PQ04vE4VldX0dPT07JdncvlOgqaqMZ2OQGxyYDjXSey4Sg0iSRSahU+9f6HoBZzf8xGsox6MAN16XQa+/v7bb2EU6lUR4SWqfS0S0gLBoNsklgnGBsbg8/nw9LSUlNfX6lUipOTk5qvhcNhzprw/v5+uA72MNIvB+hM2++3Wq1YXFyE2WxGpVI585zC4TC8Xi/i8Tj6+vrwiU98AqVSCf39/bjrrrs6PjyGVoByNIvPyjVIFzLIlgoYHB/BwAXrZhkIeHz884l34A++8UXoBu2Ie/2YVpvxTvPF5bl3o9k/L5iI3PX1dbY4cNEVWuANb22PE5VKBflEGitf/gbmP/VBiOQyvPj6a7hksNYcOKoPIPWHjPr/PuffhS8TP/1FfB4qAL7oeB3z+j6QAm7XFSPDqPeobaehTSaT2N/fh0wmu/CIYT6fz/pUMxpVkUiEgYGBjtfZTlMqLwIURSEej+M4FARVKIJUyJH0nSBxeATzg/egzz6KK2OdS0wkBIkBmRZT+l4Q/Dc/G71eD71ej0AgwGluwmw24+DgoCGh3draahsS8nbEbUJ7i7HuP0SOqECMCrzLmyjlCzCODyAm6VwIXg+z2YyNjY0aQhsOh88VN5nNZhEOh1k7I4VCAYPBgCfsD+NAy8P16zcw8tA9yIaikMZymNZcbLb42NgYNjY2muaWd7NZqdVqXL16FR6PB9evXz9XxGk98vk84vE4nLt7iB8FkIsl4XrpBsy/9EkozAaUKuWOHk8ul3MegKj3EtZoNA1NzZmhxE7Q19eHpaUlGAyGpmk29cMGncBqtUIqlTYdFqsPqQgEAh1pwrXSYxzs/Cyi8QwU8QoQ/gyg+yWA1/y+C4VC+OIXvwidTgeDwYArV64gkUjg8PAQCoUC9913H4aGhvDiiy9CrVZDoVB0HFnLQP3eUUS/ug4+jweVRInRETNCdgKbm5sYGxu7KVGUA1IN/sXI3dCN9iNiPcaIsReCC9rwmK7QrdhAq22s5ubm2OjPcrnc8UBUNptFOp1GJpNh47OB086JHAQqdAWkTIY7fuGjMM+MAwDunrkDNpn6jCSEoij2/4vFIgqFQs2/MfKQ5YNlhMI+JI6DOF7ZAQAIJWI4+zwYMFo4ayurnWMYct+sAJDNZrG/vw8+n4/Jycmugjo6IZjMLABDoGmaRn9/P2c5GDObcDMJbTabRTQaRTweRz6fB0EQUKlUsJktuGv+KhY31nDpQ49C2duDmPsIk9P3df27WklBGD0vU91uNg8ilUpZi7zq+87tdkOj0bTsGjCdQKlU2vI6eavhrf8M/xdE9QWWS2dASKWgKQpULg+RSo7YoR97lQ0YUzQ0Gg3UanVXFxPTcqwegOkktQg4baMyBDaXy0EikUCv12NycvLM4vEThiloxiiUNTLkPAHc1zuGaCjc0ZAS065qtYDerCnmvr4+mEwmOBwOVoYgFouxFPZg88SDRCSIseI066BQD0bsH4vFkEgkQFEU2+K7NjqNXWkJNF3G3CfeBz6Ph5IrAOlCZxuqVCptG15RD8ZLOBAIYHFxET09PbDZbPj+sQPPH+3At7WH98sofMA+0xGBaSU9uIgKgFarhVgsrkmVq0Z169jn83G/rukicPQZ9JsK2NzPY2xADET/H0A0CigebvgjDocDFEUhEolAp9Nhf38fe3t7uHbtWo2lzsDAANLpNCwWCzQaDZLJJFZWVjp2hhD2yGH4hQXklvZQqpRhujYFs1DADjWeN9igEbxeL8YGhmDUGFGU6bC1tQXTBUkELrIr1A2YiNyvfvWrIEkSgUAA6XQa165da9jtyOfzSKfTSKVSyGQybAtdLBY3jc9Wer2YlOrg6zUiuu8BTVF41D6NAdXp59QtIQjrRNhfeRHFfB6TH3wYmj4zePkSyDKwv7/PPjfmeSmVyqZkRSqVsuReP9qPH3i2IROL8KhBC7lQzDoXFAoFTnKlZmAIUacEU6lUYmZmBvl8Hi6XC/v7+7BarW33kHqHnPOCpmnE43F2cIuiKEgkEmg0GjZavhofN08jduDDfpGC0dSDh6fuAf8oiry2cUADl9/fDvWOQ40Gguu7tEzwUju5mFx+mhbKWAi+XeJvbxPaW4BqQmsSKdAjUsHr9cK2MAOFTguNVoMn5h4GnS0gkUjA5/Ox5IjJo+Z6cVksFhwdHWFoaAjxeBwymazlIsMMbkQiEaRSKRAEAa1W2/AmrkfQf4yfv/s0BepG4QYuT1/C2toa+7y5gGmpt1oEuEwxdwumipFMJrGxsYHlfAivlyMoJdKgiiV4l5/F78w9BiV5Sryj0SgSiQQymQwr9tdoNLDZbDUbWB8Ad+QEz6hDyOfysPX24hdG78H25haMRiNnX87zTJ2aTCYYjUZ4vV781beexA9KJxCrFEhSBXzHt4VyhcZHB7m3yJpJD1wuF/R6/YUsgFKptO2wWDKZ7MzvlfKjmAujWKLw1/8zip/5oALBiAJ8/zcBfe2GwHujYru4uIhMJoNAIIDDw0NcunQJZrO5oR1SoVBgk/rUanVHLh3V4EuFkI/3IJVKgSc8Pfjo9Xqo1Wo4HA4EAgGMj49fSOWkfmCLeS8voo3LrDu3usKTSqVQKpUQCAQgEolQLBbxyiuvYGFh4dRLNZWqIa4ymQwKhQJms7ktKWECNv79Bz6FrfgxlvhrmLQPYb7v/Kllc7IePJuiQff2gCpSIAkhfumOBzFU1f1i0uWSySS8Xi8ymVMZjUQigUKhYPcMPp8PtVqNuIyPP/7aX0Eok4KQkHg1F8BPqsZAZwsdDZQ2A7OOd7s2M1IRiqJYwsa4CjSTILULtGgFppMWi8XYtVylUp1WYOvW8nrQNI0TzxF+730/xdoaAqcV3UaRtheJascht9uN69ev1xx2zWYzltdWwVNJoSLE2NnZaTtYDZx+fsyMglj89om/vU1obwEYQkvTNMSEEL8+9TD+D/eXoB6wQ80T4Zdn3wW1WAaIZTULC0OgmAWrmkA1q+LK5XJ8+9vfht/vh9/vx2OPPXbme5LJJCKRCGKxGGj6tCrc09PTUVyhz+eD0Whkn4NOp0M0GsXMzExHHqMymQyZTKZt9alaE3YzFgylUompyzP4r0/9JTKRGAr5PBQGPXyHbvy/kadxr3GQJeo2m63t76dpGsMVGT7/4V/BodcLqZBEr9ECGE+dCZaWlrpq7XUKZgEMh7dQ3M3Ct7gFXoWGwmzEi4fbHRFa4LSq/Z2XX8Q3IvtICcowVIS4RCtxbYHbkBsXMMNi29vbNUOBTDXf4/Ggv7+/5WNQFMUe1DJJP4jjPNQqPj7yLgXEIhLWHj7kfSOAbvRMdYSmaYRCIYTDYcjlcvh8Pk4kh0EnLh2NXnv9gAZBEJiYmEA0GsXy8nLXVm3VYF5TNUwmE46OjroahKzG4eEhxsfHz/UYF4FEIgGNRoP19XWsrKzgfe97HwQCAQYHB9k1r9P7j6ZpbGxssBVgAJjSWKCwUxdyL2ezWew7HPjDJ34Wq559pPI5XB2bgoqslbIwLhv1FcpsNnuq8zw+RiaTAU3TEIlE+LLjNZR5QPLQB1mPFqnjEF6ZlOAz97733M8ZON13uIT7tANBEBgYGIDdbme1o0ql8sygaUUowG7IB4XZAL24/V5Q3UljDm1c1/J6ME5EjD6bgVQqxezsLFZXVy9UxtYIBEFgaGgIdrsdTqcTh4eHGB4exloujD9Z+y7UqW0Uw3F8avweTtelXC5nZxSYCu3bAbcJ7S0Cn89nfU2lFQE+OXYn28I1Sxt7YorFYnayEqhtizSq4pIkiVdeeQXZbBYOhwO5XA5LS0u4evUqYrEYotEoisUiZDIZdDpdU/P4dqBp+szAh8FggNvthtFoxNTUFDY3NzkNFXSiESVJkp1inpiaxGE+gc2oHwP5DHRibn6x9a8jnU4jm80il8vBGwkhG02gXKKw/dTzuPTEu6Drt0E7aMPCeGfDOW63G729vRAKCJj1Bni9XtbDcGBgAAaDgdU7t7OsuogBiEIqg1IuD6FcgmIiiXw8iTKdwo0bN2p+j0gkgkQigVgshlgshlQqrfkME8Ucni55cbzthnbYhhsONwKzl3G1QkPAu1i95MTEBHw+H1ZWViDo1eOLrusoepfQUxTgsxO1hIm5NyKRCBKJBPh8PjQaDXp7e6GcmABCv4zg/n/HpXEVensIrDokGBl+DOom7+n09DR+9KMfQSKRIBKJgKIojI6eHZhqJpfh6tJRj+r0vHpotVq2WhsMBjE+Pt71NXFycnJG78wEtJyH0KbT6ZZBFz8uFItFBAIBOJ1OjI2NQSqVQiQSwW63Y3R0lK3Ed/qYa2tr6O/vP3MAF4vF5/ZGzefz2NzcPB3iEolgFikwoDKcIbOtIJVKzxQSMtksiq6XwQMP2//0AiwLkxh/z4OAuvM1sxnkcvmFesPWuApEo9ja2gJJkqfDncUE/nL7Zfh39vFkwYtHrBP4UP9l9jNlDrOMfAAAWwiqt83qFPF4HKVSqengK0mSmJubw9raGiiKujDv3WYgCAJjY2PI5/P4wdoi/nL9RQhIAglfAOUihSeT+1goTra9hqqvX7FYzFb83+q4TWhvAWiaBo/HY+2Sjo+PYTKZOrbL4PP5rGk1g+oq7sHBARwOx+mk7HPP4Z577sHKygoAYHR09FwbYDW8Xi/MZvMZc2bGB4/RbXHREna6EYjFYgyOjuDf/ONfI29WIuY9wus3svilyfswrW08NFZNWqv1cQRBQCKRQCKRQKVSwdjTg+HyEZwb25j9+PugsppAKmQY03ZWDaMoCuFwmLXmksvlZxYIuVyOhYUFTtVapp3X6Ymfpmn4fD6cnJxgSqSFt98Gw+gAQjsHUNvMeLdtEgv9l9nvLxaLyOfzyOfzyOVyiMViyOVyNdfoSuIYkVAIVLmEtf/5LfTfPY+D6Am2A14MqgxnbKPOC6vViiCVwx88+XmIVHJkwnFEbCZ8fvdV/IR1tqbToFKpoNPpMDQ0dPZ36/8VAg4SoyNhkLIezI18CCvrbvRX5A27A3q9HnfffTc8Hg94PB56e3sbykRahW/Y7XY4HI627hDVaLcm8Pl8jI2NsU4dvb29nKzLqtFsYItLQEs7HB4etq2e30yk02kcHh6iWCxiZmYGQqGQvedJ8jSrvhsym06nWWu5RhW986ZXURTFtquZdaBUKl2IRlQmlUInlMBbimL2E++Byt6LhMsDifR8Vf5q8Pn8m2b9VB3UsOXYw39e+TbEeg1An3omf2NvGYo0BQtPUjO8ZTAYGq8FXYKmaTgcDszOzrb8PqbDtLGxgWKxeNODRYDTfVHQq4M6YcLJhgNb3/g+3vnbv4QSXYY3HYNKy/1QRJLkTUliuxm4TWhvARjJQSqVgs1mY706AW5DUa1QXcVlJsF3d3cRCoUgk8lgNpsxMTFxYX6QFEUhGAw29FFlhOVyuRxqtRpWq7Vt27UbI+cfxr3IaCWI7h2CIEmUyhT+bPE5/Lvpd6GQz7ckre1ax49L+vBF3QnSVBF0sYRHrBO4w9Df0fNzOp2cCQyXam2nhJZxHEgmkzCbzZifn8dVPh+WgBMv+HdRkcjxPtsU3muvDT9gNvxWm2hgfxmiQgDFfB6p4zDKZQrZWAL+Iz940TQqlUpDI/9WqCbAPB6v5u98Ph8vebYhUkjhW91C7MCPsXfdg2+fvIg77lLDZjJz6jTQlQqK5B0Q951W2gkAV67osLKyAoqiGrbwNRoNNBoNJiYmsLW11fBx21mgjYyMYHNzEz6fj9PGRhAEyuX2ThhqtRrz8/NwOp1YWVnB+Pg45zWk1cBWb28vvF5vTVQwVxSLRRSLxQuPOuWCaDQKj8cDgiDQ39/Pkk4mVY+madx///3IZDI10aVcEA6HcXh42NIjvN6FoxPQNI2VlRWMjIzUkOWL0DNTFIWtrS18xHIJT6rkcG3uQKpS4Ip9GPfL+nHjxg2Mjo7eks+sU8jlchiG+iCP9iLm8mLxC09h/PEHoDYZcKRO4L7Z7iOGucDhcHD2zmUkctvb23A6nTc9XISmaaSDYURdPsh69OidnwRdLAIkAYWQ23vCHKbFYvHbJv72NqG9BagmtDRNQyqVshuwUqlENBrtuMrSCCKRCF6vF319fXj/+9+PbDaLYrF4oVoel8vV1BPWYDAgFAqxi7LJZEIul2t7QzfLQm+Gk1wSYoUMhWwWG1/7NmY/+hhIuQyJXBo9al1HesdqhMNhqCDEn77/F7HjOQSPojA1wL1dDJySyUwmc6bNLJPJmla+5HI5rly5ApfL1ZCccB2AiMfj8Hg8oGkafX19Z57DPaYh3GMagkMxAoPaUBOpyxXzlkF8w7+NpO8YV3/+I8gEIhgcH8IDc1c5e2TWoz7tqj4JixAJweMLIeCTIEgh1P1WECSBsfExSAluG34gEIDBUBtNyaRLbWxsgKKopoST0co1srJJpVKslKQZpqamsLKyApIk27YgO6l08fl8jIyMIJlMYn19nVO8c7uBLaVSiVwu15Udnsvl4jzseBFg0puYhMRGpJ4kSQwODiIajUKn00Gn08Hn83EmtR6PB9FotG2nqdsKJU3TrIyhfqCqVCqda7AuHo/D4XBgYGAAM3o9xhODuEGYMTU5iV6ZGnweD3lLHnt7e6x39Xl+X7X1080CL19C/NAHvpDA1AffBblRA7pEwWrsXA/dCeLxOAqFQsfa9YmJCTidzpbBMZ2mt1Ujn8+zftizPTbMXZmHP5dAIZFC0h/EI3e9A30cU+aqB/veLkNh/2u56r5NUF2BZGIEGWi12nNNazLweDzw+/34xCc+AYPBAIlEgpmZGWi12q4rB/UoFotIJBJNN2WtVnumVTEwMIB8Pg+/39/0cZkbiSuMEgUy4RjkajXG3n0fwAMMZhPGBoZZ66dOkc1m4XK5MD09DYIvQJ/WAKIzy1gAp7Y6w8PDZ76uUqkQj8eb/hyT+jU8PIz19XX4fD723xpJFqoRCARw48YNHB8fY3h4GJcvX255iFGpVIjFYtxeUB3MUhU+KO2H3dYPpVqFAZ0RP9Uz0zWZBcCmXDGaXblcDqVSCa1WC71ej7v6xpBLxDFwzxxGH7kHdKGASY2ZM5kFTtvsjbx3mUpKIpGAy+Vq+vNGoxHBYPDM17lW0WZmZuDz+VpeA8zz6bRjoVQqMT8/j1KphKWlpZYRmIeHh00PpAwMBkPDKNNWoCgKyWTywq3Fmv0ul8uFxcVFlEolzM3NYWxsjPN9b7VaoVarsba21vK93t3dRS6Xw+XLl2+an+7W1qnrSaP37TwVWpfLxVaVmccuZnKYtthhk2vAf0N2IRaLMTMzA4PBgOXl5Y4/92owHbqbAcYOLx2M4KN3PQiFUQdljw4aey8mhkehCOfgcrluSiocIzXodtBxaGgICoWi6fXGNb2tGslkEmtra9jZ2YFGo8HVq1fR32fHv517FE/0X8ZVyxDe238JP2Gb5Syxqd6H3y7xt7crtLcATHVHLBYjmUzWVM7akZV2YFpKMpmMtQ+5du0a7HY7Kxavj4LsFk6nE4ODzeMXGf1k/UI8NTXFxjA2Ilpc0rCqMQUlvlPkQTzcB4H3GBKpDHeXVci2iTRtBpqmsbm5iampKXZhEYvFHR8EkskkaJpu+Dq0Wi329/fbPoZcLsf8/DxbrR0aHcE3/Nt4du17sJeP8J6+KdzVM8ja2zBRh5cvX+Z8yler1S0PGK2QzWZh5Ivxucc+BeD0vVtcXARt678pm348Hkf5KIJff+wT+PbJLuIiMXTpCv7Z+D2cH4Op9LYiB1NTU3A4HE2HuIxGI7a2trrupDDEeXl5+aa4dDDxzgaDAVtbWzAYDDXElS5QyBVPc+XbVdCYgJZOXuvR0VHbSvV5wUhpUqkULBZL20jWVrBaT5O8NjY2MDk1BVc6gnSpALtcCzUpwdraGrRabUcVZ2agj+tz2t7ehlKpvJDuHIN8Po+trS3odLozspJEIgGbzdbw5/R6PbRaLZxOJ/x+P8bHxzuutFZbP10UkskkDg4OIBQK2Qr8NAB1CQgZc7BbbLirZwBCvoANHrhoz+ZOpAbNYLVaQZIkVlZWzqQhUhTFOfAjEAjA5/NBJpNheHj4zGdECgg8apuE7iSL8fFxHBwccPbrviinih8nbhPaWwBmMEkoFDatnHXT4ksmk9jd3T1jEVJNKKujIM8TZcgMCrWTL+j1eoTD4TOLNLOZkyR5ZjPvxOnA4/Egl0rjcx/959iKHePYeAJtWYjLo+NYXV3tajHb2tqC3W6vWRy68X/d39/H5ORkw39rl3deDaZam0wm8X8+8xW4iDwypQKC+RT+au378EkOMCA+1Sg30jK3A5ME0w12dnZqKhWMLZjD4ehomp8LgsEgPB4Pq128x3bqMnDjxg0IO2g2BQIBTtPGIyMjcLlc7OGmGo1kB60GwhqBIAjW1uciDpiNwAwbut1u3LhxA2O9gyh8xw0qmMFu8BBD75pF5VKlZdWmUUBLK9A0jWAweNNibpPJJDweDyiKaiil6RYWiwUVAL/z5OcRNYhP198ihftoLR6du9bxOiISiZDNZjkdVpxOJ0iSvFCJRjAYhNvtxtjYWMNDdabNgZ+RsKTTaezs7EClUjVMGmwGuVx+rgpvNRoR2WqYKmI8PLtQs58xgQy7u7vw+/1sUM550Epq0KlUwGg0giRJLC8v1+ix26VydVu8kMvloGmaswzkvMW1W4HbkoNbAJqmkcvlkE6nG7Y9FQoFkslkR4/p8Xiwv7+P2dnZMySzWCxCKBSyf5fL5RgaGmrbYmuFZq30ehiNRoTD4TNfJwgCly5dwvb29hmiKJVKOd1ILpcLmUwG09PTEPIFmNVZ8cjYHPj5ImuX4vP5atr17eB2uyGRSM5trxIOh1m7q2botJ0sVygQ7BGjmMvDe30NBy9fR8J3Ao+wiIWFhXN5kZIk2bHXoN/vh0KhOLM4Go1G9vq+KHg8HgQCAVy5cuVMZYQJD+GK6uScdhgYGIBKpWp4rxiNxpoNO5lMdkRogdo40pupU7Pb7ZiYmMD1v/wWnDsOFKki8oU8iNUE8jtn7896dPIeMweGi67Qh8NhLC0tsb7D7aQ03WAPKfiJIqL7HuSTaQSdh3gJUSg16o4fSyqVtpR7MPB4PCgWixc2KETTNLa3txEKhTA/P3/uAS9G0y+RSLC4uNhwPW+ETg7tzRCPx7GysgKv14vx8XFMTU01XFObkUCCIDA1NYX+/n5sbGycS4bQTmrQjVRArVZjYmICq6uryGazoCs0jlIxRIs50JVKzfdms1lsbm5iZWUFEokEV69excDAQEckenBwsKWUqhrV+9N5An1+nLhNaG8BmAqtSCRqeFLSaDScdbQURWFtbQ2lUqnhZs98T/3XtVotLBYLNjY2On7+6XS6aSu9Hq1uBLFYjLGxsTNkgcvN43Q6USwWzwjrGf0lY9dy+fJlpFIpOByOts81Go0iFotdyMbicrnaPk43Bxc+XwBlbw8EIjHy8RQkaiWkivO3q9VqdVs9ZzUoimIT6BphfHwcOzs7535ewJvaxWZJWyaTqaGetRGKxSIrheEKq9UKo9GIlZWVmuu0/vdmMpmuyINUKsXY2BhWV1dvmtURAEh4JCZlfSiWivhP3/48eKgAPKDgaq+fNhqNiEajnH7P0dFR01Z2p2Cs5q5fv45YLIbp6WlMT0+fW6LRjHj4Mwko9BoIhHysfPkZSHVaVMQE4sXOPVUlEklbQhcIBBCPx5sOCDHg2rFLp9NYXFyERqOpkUw1+r5OD18WiwVzc3M4OTnB2traTSU4DJE9OjpqSWQBsPaXraBUKrGwsAChUIjFxUXO13I1HA7HmbjjatA0zVkqUA25XI5Lly7hR8uL+PcvPYn/uPQs/mT7Rfyn1e8iS51Gz6+srGB/fx82m+1cxQulUolCodBRd5CmaQiFwtuEth3+6I/+CFevXoVCoYDRaMQHP/hB7O7u1nzPpz/9afB4vJo/165dq/meQqGAz3zmM9Dr9ZDJZHj/+9/fUVXux4loIYNXjvfxinMLMn3jaUO1Ws2J0CaTSSwvL8NisbQkT6VSqeFNaDKZoFarz7zn7cC1OstApVI1XUCUSiX6+vo6ItZMzGSzVqNer68hGhMTEyAIAhsbG01P5/l8Hk6ns+WkM9fWvN/vh16vb6ux6nQYi8/j4Z6eQWRDUQy84wp0A30o5vLQh3LnroSo1eqOngszLd1swxSLxewEebdgJr4lEknLtjKTksSFkDOez53CZDKhr68PS0tL7DXAkGLm790SWuD0Pjhv16QV0uk09g+dWPZsg6LLmOwdAl3hwR3xgy/itglzeY/D4TDUavW5q7PVg140TWN+fh4jIyMX4psNNPf3NUgUoCsV0OUKZj72GKh8AdHdQxTinWtB23lqh8Nh+P1+Tu4KXAbCfD4fdnZ2cOnSpbbXeDweh0rVOMCnFZiKZ19fH9bW1uDxeNp+fyeHtHg8jqWlJU5ElkEsFoNGw21y32q1Ym5uDsfHx1hbW+O8biaTSeRyuZb65m4qtAzEYjE2ZAVs7+4gG02gwgPWnXv4j09+AbFYDOPj45iZmbkQO7X+/n7OVVrGqeIiqu0/DtxSQvviiy/iV37lV/Daa6/hu9/9LiiKwiOPPHKm3fzud78bx8fH7J9vfvObNf/+a7/2a3jyySfxla98BS+//DLS6TTe9773cfJv/HHCk47i9xefwT/sL+LFg038pW8Rx9mzxJVLhdLn87ESg3barlaLIaPZcrvdnF5DPB6HUCjsaEAgLKTwZz/6Nj6/+yr24idn/t1oNJ4h1s1uoO3tbZAkiZGR5hnpjapJjJaW8RkFgBJdRrFMsfGVDPFtBkYT1wo0TePo6Kjt5DhwSiI7HZr4iP0yZoVaDPUPYMDUi3925SE8OncX1tfXux7sAk7JCle9VDKZRKlUanvd2e12HB8fd3WypygKS0tLLJFsB5vN1nZzBYBQKNS1nESv12N4eBjLy8vsa6qWHZxnQwNOuyZWq/XM4a4bpwPglMQ6HA5cv34dbrcbepMR9374YaglClztv4TL9nEISSG2ececWuO9vb1tDygej4fTtd8M+Xwe29vbNW3Vvr6+C5cvNLPVesA8AhPvlEBJNUpo+sz4zKMfRj6dwY0bNzh3AoDTynszQhuPx3F4eMjZMaFeNlYNpktXKBSwsLDASSeaSCTO2IJ1ArVajYWFBVQqFdy4caNpp4mrY001kZ2cnOREZBnEYrGOpCedyhBomsbu7m7TeYjq7zuPzZk7n4B21I69F34Ix7M/AI0Kyn16jIyMXKi+XqvVIpPJcFqXmc/v7VKhvaVDYd/61rdq/v75z3+ejVu877772K+LRKKmJ85EIoG//uu/xhe+8AU8/PDDAIAvfvGLsNlseO655/Doo4/evBfQIb60fx2Fchm5eBJCiQgUH/gfzkX8q0sPnvneZvGmjIuBRCJhXQzaoVAotDzdj42NYWNjA4FAoO3Jfn9/n/OUJAC8HjzE33iXEfYd4EgO/Cjowq9OPXAmxauvrw/b29us4TxzI1XfyJubm5DL5W03TKYqUN+mM5lMEIvFuL54A5uSAm4kjlABYIgW8fPzD7VtYzIku9UpuVFqWjN0o0vyuN349F2PwGg0Ip/PY2dnh7VpauZb2wm4tDb39vY4VZWYoRKu38+AceIYGRnhvOlKpVJQFNXy8MakQ52HHFVr3qampmAymbC2tgaLxXKuzYyB0WhEsVisGURjrmcu1clkMomTkxPE43FIpVKYzeaaw1/lfg3SRzuYktshkJCYWZhHUVxh7aJaHR7kcjny+XzTaySZTEIkEnVVRU0mkzg8PARN0w09WC8aQqGwIaElBQTeJ7XjXQ9NoSwUYEipR6/s9LlQFAW3283GWLdzI2hWnWQOGnNzc5yvxWbXNeMtWz8I3A65XO5C/GHtdjt6enqaetcyFb5mn2c8HsfBwQFEIlHLdMRWaDdE1QyMDIFxQ6h+D+lKBYliDmKBED7XYUupQfXzOM/aIuML4T7Yw+D9dyB3EkU+noLC3vgQc1709/fD7Xa3LAwBp/d8LBaDSqW6cMeKm4G3lIaWabPX35jf//73YTQaMTo6il/8xV+sOSUz3oOPPPII+zWLxYLp6Wn88Ic/bPh7CoUCkslkzZ8fB8L5NCqoYOPJ5+Bd2kIyGMZJtvHvbuRTmk6nWYlBuwuxGlxu+MnJSfj9/pbaonA4DIVC0dGG9U/uNQBAmSohHY2iAuAZT2N5wcTEBMLhMMLhMAixCO7ICfLUaULJxsYGFAoF5+qPTqdrOLygVqvhVgDffO1FFNJZpIMRONIRvJD2tn1MkUjUsu3CpKZ1Em3I2JpxQT6fr/H9ZRZ/Rhc6NDSEwcHBM761XMFF0+vxeKDT6ThvPGq1Gjwej7NmjQkFmJqa6pjUtBtc6lZuUA+5XI6pqSlsbm4in88jFovh9ddfZ23azgur1QqpVAqn04kKXQHSRRSjWVTqhkQYMO4m169fx9HREXQ6Ha5evYqpqakza2kkEoHpjmFoPzAJ1SPDILQSSKVSLCwsoFwuY2lpqeU1bjQam3YCDg8POSfiMQgGg1haWoLX62U9k282mQWak81oNAqZRIp7+sZwn3mYJbPMzwwNDWFubg6FQgHXr1+H3+/v6DNnKtCXLl3qiIQ1qtA6nU4cHh5ibm6uIzJ70ZKWeu/a6uuDJglsHLsRzNWSofNUZKvBRT/bDlarFbOzs6wMwRMP49/f+Cf829e/jl/+7t/iqb0bDYe369EtsQZO9/bpFAlFjwGmkUHIjXooDDqMp4Vd6X3bQa/XI5FItJWDME4Hb5ehsLeMbVelUsFnP/tZ3HvvvTXVnMceewwf/ehHYbfb4XK58Lu/+7t48MEHsbi4CJFIhEAgAJIkz2hoenp6mlqG/NEf/RF+//d//6a+nkawyjTYjZ/AcmkEqeMw+OCh4g5hQ7bBmnsDQLlC4/WUH6vrDgwMD+Mx2yToWBqBQOCm2ftU+2I2stICTged5ubmOD9mOp3GsceHaDSKsNOLdCgOpdkAyMJwqUagUCigVqtrFoGZmRl85XvP4rtpHzKpJLQnq7iLUuGh0dmOiGJPTw8ODg4atpcd+Sg0Q/04/OESSrkcxh59BzZj7dv1YrG45SnV6XR23G5VqVScDej39/cxOjpa8zWLxQKv18tqqM9TrWWGEZsRimKxiJOTk47tmMbGxrC8vNxWW1lvy9UpmO5OM1IViUTO1Q6vhlQqxezsLJ5++mkEg0EUCgVotVoIBAJcu3atq+GQagwMDGDjxirWnvwmUsE4AoootOMWqD8wAT4pQDKZxPHxMZLJJORyOcxmMyf7Ko/H07RazvjWtkoZs1gsWFlZOfNv2WyWTT1sB5qm4ff7cXx8DK1Wi+np6QvTxnJFM8kBF59OgiAwMDAAu90Or9eLxcVFmM1mWCyWM9d3dephsVhkD2udrOGHqQhe9e1BLZOhx2JGuVjCxsYGjEZj08jiVkin0+cmgY1Q7V27tLSEnF6GLxxcR8jpgT7rwiPWCTykGTh3RbYanehnW4FxG4nFYvj1p/4GeYkAYoMaca8f20P9eDXowt09zT3Xge6Hwnw+HwKBAB6/5wHcXc5jMexBQmrGqFiL+bFJ7OzsIBQKYWRk5EKlN1arFW63u+X8DUNku/FhvxV4yxDaX/3VX8Xa2hpefvnlmq9//OMfZ/9/enoaCwsLsNvteOaZZ/ChD32o6eNVKs29FX/rt34Ln/3sZ9m/J5PJC5vKbYWfGrkD/3nteQhEJCo0jT6rDb859wgExTKOjo7gcDig1WrxfNqD6/EjRE68CMl4eOH1H+JX5x7CXQsLN/X5tfLFZAad2vnjRaNRBINB5HI5yOVyXO4dxJpehUqFhnFiGDwA7+w5JbOpVAo+n4892apUKlBCPl4ohxA9PkaFBkKOQzynVeFB9d0dvZZW+jUpQaJSLEKiVUJCK5ANRWHoa090Wt3U+XweqVSqY09MZjCsHaFtFtJgNBrPLErVvrVcI1CB02pqK9/Ivb29rhZVgiDQ29vb0vmBa6RoK/D5fKjVatafsRrpdBoSieRCN4RyuQyCIJDNZuHxeNDb24tYLAafz3chxNlyIMDacQTpfBYGmRahbS9c2QDoSVVHJJZBOp0GSZItyWN9kMfk5GTN9xMEAZIkz3hZulwu9Pf3t/z9xWIRXq8X0WgUPT095wpCOC8EAsEZQhsMBqFSqTiTa8Zz2WazsW3rnp4eNqThKBPHC0EnFtdTuGKyg/aEMDY21lGr/6XjfXxx/3Ukj05AKuX4wfE+3ivvx+XpS107PcTj8ZtCaIE3ZUYn8Sg+849/Ab5UgjJFIZ/K4O9f+Cb4E3fjsSt3XVhRJhaLXWiAh0AmBjHYA/roBK//5Vcx8MCdIEkh9uInbQltp5IDmqaxtbUFoVCIhTf29l6I0StTg7adBtQQBIHp6Wn4/X4sLS1hcnLywqKETSYTrl+/zslb+Dxe5T9OvCUI7Wc+8xk8/fTT+MEPftB24zWbzaxxO3D6oRSLxTMntWAwiLvvbkyCRCIRRCLRxb0AjtCL5fi9+ffiv+/F4CjJ8Sv9d0JFSgAS7MZ0cOTBt7//KiqoILx/CKpQgtZmhv9ig4SagiRJNnjBNjGCjUQANE2DdxjGQ/fce+b7s9ksQqEQG4Sg0+kwODjI3nQD5WH8+dLziIlPW8F3GvvxoeErEPIFNaSDoijE43H8yL2LmNePfDSFpb//Ot7x2Z8FKZfAlQrDxjGDmoFSqUQymTxDAt+hsuGV134I8/gIBKQAMc8xLpXaW9iIxeKmbZdOnR8YqNVqHB4etv2+ViENWq0WwWDwTDW6ulrLLIatNpJWbSVG/tJtO9hisbAxrPULssPhAEVRXVWb6mGz2bCzs3OG0B4fH3NqG3aCZDKJeDwOgiDw4osvQqlUQq/Xo1AoIBQKnfvxo6+toULReHLpOVg1Jrxr+i6YMlYMdxGeAZxKAtqRTqD2QLS6ugqbzVYj1WCkHYzsqVgsIpfLNb02stks3G43MpkM+vr6Lsxv9TxoJDlwu90ddaAY8Pl89PX1wWq1wu/3Y3FxEUUpiS9GNpFMBiEohPHsjZfxc3c9gqsdTKnnqRK+7LwOACgViygcneBAEkfqHd2TWQBIpVIdS0M6/h08Cgq7FbEDN5a/+BRmPvFemMaHQFr1F9phPE+bvxFIngCp4xDyyRRM0yPg0TRy8SRkve35Qrv0wWownrJ2u71hF5FxbolGo6zFplqtxtbWFkwmU0fdSubxGqG3txder7flAZzZF94O8be3lNBWKhV85jOfwZNPPonvf//7nG6ySCTCDt4AwPz8PIRCIb773e/iYx/7GIDTzWtjYwN//Md/fFOffzcQCQgM6XpQ0EaQiMZg6anV9Kl1OuhH+0EVKXheXYbCZIRIJUex3N3pqJvJS7lcDpFJi3/51b+AetiKTCgKkk9gLDsNq1SNaDSKUCiEdDoNqVQKg8HQdFpXLBDifeoh/MRjV6DT6SDkN27JEAQBqVQKkicAXaYgVisw+cTDEBAEEv4Q3NjBZrQInU7XtlLMwGAw4OTkpIbQJpNJ8IJJ/O9P/Bx+FPWCrtBYmLwPmgzNxhC2Oq02uqkZX95uyB6XCfZwOAyZTNZ0I7DZbGwLstHjDw0NIZ1Oc6rWNhpGZAzFZ2dnOb6qxhgbG8OXXv4OEiY5CL4A9/cMgzhJQKFQdKQJb4VqXXH1a4jH4xfyO+LxOEKhEKv35/P5EIlE+Ff/6l8hl8udJpjdc8+FaHVDSxWUYjnw6ArydAlykQzanu4iPIvFIorFYkdEiDkQORwOBINBjI+PgyRJ6PX6Gtsfr9fbcJiMmeRnCN+PQxvLFQRB1HRwfD4fjEbjucgRn8+H1WqF1WrFH7/4dZzsOpEvFJE+CsE8O4pnfJu4ZhwARVHs0Gq5XGb/Xi6X2fQ5mqYRzWcQ2HYCALaf/QH67pyF/eoMYqXOPXGrcVEDYY1QLBYRCATgOfIgfugDnyCw8OkPAeAhFYpCPXVxv/ci9LPVCAQC8Hq9eKRvCq+agxAQh9AM2JDzBDBWbv+8y+UypwotE1fbTj5os9lwcHDA6qOlUimuXLkCp9OJtbU1TE5Ocr5eq6Uv1bBYLLh+/TpsNlvT587VqeKtgFtKaH/lV34FX/rSl/DUU09BoVCw7U6VSgWJRIJ0Oo3f+73fw4c//GGYzWYcHh7it3/7t6HX6/HEE0+w3/vzP//z+Nf/+l9Dp9NBq9Xi13/913Hp0iXW9eCtBpIkwePxGl4kapEUvVIVjpFE352XITNoEXIcYnLiHV39rlZ2L63wbMQJsUGF8L4HpVwWSqMB/+UbX8FPDd8BnU4Hm83GeXNsRSZomkYgEEAgEDiVPNiG8E7BPfjej17ByP3XEPMc4475BfzkzMPIZbOIRCLY2NgARVFQqVQwGAxQKpUNb0aNRoOXN5aQ0UpglalBFk/tVxiN5qShitjpTheMpaUlzMzMdKTpa6Rt7QSMe0Kzxa2ddpkkSRAE0fIxqlvJraq1jGdwNSFzu93o6ek5t87xpagbz0VdIDIkJGoFXvzRD/Erdz2G6QvStTKo1xUzOtNuUCwWEQwGEY1GUSwW2WuOuZ61Wi2efvppVrJEEARrDXbedrriwUHEv74NCAlc6RnBXtgD5QAf3WRjud3urmJV+Xw+xsbGEI/Hsbq6ylaUpAo5XtnfgFKjRjx4gndUVV0ZLbRMJsPo6OhNI0/nQXWFlqZpHB8fX0hUL9NpiqcSAI+H0KYDCc8xeiYHkIjFkU6n2WAP5r5l/s784fP54PP5KNFlPMM/Qb5MQSiTgMfnI+x0A2IzqP7uKpPdRKq3A0Niw+Ew+Hw+jEYj7rt6DUmzAn/7nadgHBkACAH0OYDwRpBX915Ilfai9LPRaBQHBwfQaDSYn5/HAo+H6bAH3wyVMN1/CQ/c/SGEDn3Y3t5uGYDRrlrM2H/RNM1JWiWVSpHP52sel5F0RKNRLC8vd+Ru0eyz7+npgc/na7o+3Ca0HPHnf/7nAIAHHnig5uuf//zn8elPfxoCgQDr6+v4u7/7O8TjcZjNZrzzne/EV7/61ZqT2ec+9zkQBIGPfexjyOVyeOihh/A3f/M35x7MuFkgCIIdoEin0zWbLZ/Hw69OP4C/2n4FQTihMxrwseEFlNxBFFWmjkkFF0PuRogUMhApZFj+0jPIxeMYfeQdUNhsGB4ebkogq0FXKvCmY4gkYuCLzhLqZDIJr9eLXC4Ho9GImZkZ9qZ9OGJB312PICchkKDV+OToPRDw+ZDL5axtF03TbLVsf38fBEFAq9VCr9dDKpWiUqngb/dewzec16Eq+oBSGffwdfipd76n6fvBhCGsrq5iYmKiIQmqP+lGo9GmiW9cwRjWN6rqca0cMQL/dgEETLV2Y2OjYetKo9HUuAHk83lEIhFW43UefPdoG7IeHfZfeBWkUAzTlXGsUjE8dO5HrkW9rvjo6KgjuUF1FZYgCOj1erY62eh7f/qnfxqVSgVisZjNr+/mYFQP8bAOuk/OQvxPUagmB3Df1J3Y9R/A5XJ11DJm7pXzVKjVajXm5+exvb0Np8+Nf0zsw3V4CJFCBqVIgpHMFIqRBE5OTqDVajnny98qVBPaTqz26lEsFtmEwUwmw84CzPWPIqQQQCAiQTwkRimZxvzsFCfJBwMhX4BfHL8Xf7H9EoSSUwL4zpkFPKAZwvLyMoxGY8vKWiN0kxDWCI1IbPUaDgALhA6SOx9FWSOHRiTBVYMdxXwB6+vrnGzP2uG8+tl0Oo39/X2IRKIz9+qCwQ70TWFh4DIAQDs2Bp/Px97Xja7tVt3QfD6PjY0NWCyWjl63xWKB3+8/Qza1Wi2USiW2trYQiUQwNDTU8jpo1Qm0Wq1YXFxktd/1kMvl8Hq9Ta1E30q45ZKDVpBIJPj2t7/d9nHEYjH+5E/+BH/yJ39yUU/tpkIgEICmafT09ODk5OQMcdKKZPjNy4/gekmDq2/o5Rg9W6cuB91egEZaiH2HG1MfeBDFdBZ0qQSbSo9QKISDgwPQNA2xWAy1Wg21Wl3zGkp0GX+6+SK24wHEvcfQ6bTQDdhgESlwfHyMYDDIEtP6155Op1HMF/DBy6dpcFHtIAJHfijqNmM+nw+tVsueTimKQjgcxsHBAfL5PA5yMTwfcYCUS5H0B0Hl83htmMRHQaPVu6FUKnHp0iWsr683PP0yRk2JQwABAABJREFU1l0MgeUyFd0OarW6oaVUJ5UjZrqYSwVGLpdjYWGhYbVWLpfXODns7e11XX2mKArJZBKpVAqpVApHWw4UK2UUExlkchHIetRwJUu4UTztyEilUshkMkilUkil0nOHFDC64nQ63bLdXV+FVSgU6OnpaUsA/X4/VCoVdDpdzdcZv2PGq/Y8hx2hWQHpFQsUC6dV7CnNFHZ3d+FwODgTVJ/PdyH6YT6fj6mpKfyXV74Bp2MfxVwe+WQWlE6FP3rqC/iN+z54Swe9OgFDaBmrvascdcnpdBrRaBTxeJxdW9Vq9ZmOVV/FjryDjyf3DqEdsEKn1uPusrrj5zmtteD/f/X92PQdopTK4L6JefB4PFjMFnYQrRNy2G1CGHB6nxwfHyMUCoEgiIYklgGzdr1r/mrN9UBIpayMpdO2eT261c/m83ns7++DpumOOgiMnd7y8nLDfbjZUFg4HIbL5WpaJGkFk8mEpaWlhtVTgiAwMzPDEu1WA2PtyC4TENPoOmIGrGUy2W1CextnwRBarVbbciCo2qVBqVRiamoK6+vrHd0Y3UgO3G43rvK0iE5P4jiVAF0uY3hiHHfxeqDRaNiNNJvNIh6Pw+v1silTCoUCr6f82Ih7IBCRKKYzSMtl+IOn/g6/Onk/LBZLy01vb28P4+Pj7N+5EjWCIGAymVhSeLD1IyBYRvIkgvX/8Qyu/vzHkEuncZyOQ6FtrW8Ui8WYm5tjoxGrb3JGHiCVShEIBKDRaM59g9eTSAYul6ujCozRaEQwGOSs32Rsmhj9bV9fH8DjwZuOgR90Q1E6NaDnEreYz+dryCuz2SgUCpYgvod8AD88OYDCZEAqEALoCh5/x4NYsE0im80im80ik8kgEokgl8uxn7lIJIJcLodEIoFcLodYLG77nhAEgSeffBJqtRoCgeDMBtRJFbYRisUijo6Omh421Gp1y4MRV2SzWUgkkpqvjY2NweVy1YQvtEI3VmutEKzkIFLKsfH08yimMpj+4MOIaHWIx+NslZIgCAgEgprWen1b/VaBLpeQP9lA3L2J7ZQXfQON5Tw0TSOZTCIWi7GenRKJBBqNBqOjoy0LCwIeHx/tm8X4PIHx6SnIhSJ4PB7s7u527oRCSrBgHcLOzk7NnmC1WmGxWOB2u3H9+vWmA0bVSCaTHQ2v5vN5nJyc1JBYLtX3VmsXI2Nh2uadBKhUv45O9bNMnHIikcDw8HBXmm6tVguxWNww+KVSqZx5XxwOBwqFQtcHPT6fD4lE0nC4mYHVaoVWq8Xm5mbLw02rWQ2bzYbFxcWGP8tUd0mSRD6fP9dA4s3GbUJ7C8Dj8VCpVFjtVLNEsPqbg/G+XF1d5bxJlkolzi0miqKwsbEBlUqF+6/djbvpMg7iQezv7OLRa+8AHzxsbGywU7JMJY25CWiaRjqdhse3hvjRCdInEQR3nBh95F4ITRpMzl6CWNCcXPv9figUijOnzFanx2aw6gyQGnUoFoqYeuJRyPQalDI5BPZdSPJ9kMlk0Gg00Gq1DUkMQRC4fPkytra2kMvl2PY1U6GlaRper/dCiEKjhY5x7uhkIry3txdra2sdDSRVV2uvL97Ay4jitaN1iDMuZPxB/Nb7f6rm+2maRjabRTKZRCKRYA8yYrEYCoUCGo0Gdru94Yb3iaEFVFDBa8V9UKQYj00vQBvMge6l2Wup3p2Apmnk83mk02nkcjmEQiEUCgWW7Daq7MZiMayvr6NQKOD4+Bi9vb14+eWXMTY2hlgsxlZhDQZD21ZdM+zt7bX92VYHI65o5AoBnB5GPB4P1tbWMD093fR5BINBaLXacxFIpq0eDoeRz+fBC6ZAl8qYevxBCGUSCMVijNkHMDw8zFY9i8Ui+99cLsf+PzMExWyu1a3QeiJMEASEQuEZMlytPe0UFbqMyMbXUUgGED3yIHm8g14NHxXju1AulxGPx1kCC4C9pm02W8fVwGg0CrOxBwrylPgy7jxut7tjW7dmDiR8Ph8DAwOw2WxwuVzweDwtyVornX319zAkliRJGI3Gjuz0uK5d1W3zUCjU0b3YiX6Wpmn4fD6cnJzAbrefezhUKpWy97XJZILFYkGxTOEkFUc/XQaJ0/dgY2MDer3+3L/PZrPh6OioZWFBWlX53tjYwPj4eM312szClAHT8WyWFsrn898W8be3Ce0tAKOhpWkaer2+YbpUs8oqSZKYm5vDysoKKIpqeyIvFoucbnwmbaiaKAv5AoxpzciIj0G84U4wMzMDl8vVsF3EWI0M9w/CR1LQDdogUcuh6u2BWCCEiN/aw7ZZxau3txcrKysdEYI7jf141b+PVzIHp2EOAH727kdwn/VU1M+0Dnd2dljjaLVaDb3+TVsZPp+P6elpOJ1ObG5uYmx8DNupII6iIfSGjzDW03NhlSZGeM+cfh0OR8c2YMxmX6/L5oKBgQFsl+J46cXXUQGQDkehshjxF0vP4zfHHkAhm2MTpGQyGRQKBWw2W0fSAFJA4GdG78LPjN6FGzduYGFuAeFwGCsrK01dMvh8PktU68GQ62w2i1QqhZOTE+RyORwcHOD4+BixWAyvvPIK3vve9+L4+Bh9fX1tK2tcwCT3cDlQMgej7e3tmoMRV2QymaYH0r6+PhAEgbW1tabuHD6fr6PYYeD0fY1Go4hEIkilUqw+nbHj0/Vb8TtP/S30o/3gEwRSLj8e0w6d+31lJvwZMlz9hyHFjBsA8//1YIoE1dXhaoJMxd1IBz0g+HzsH3gxNz2M9Rs/ABnkQSTTQaPRnOugU41wOHxGrjMyMoKNjQ34/f5za0irQRAERkZGUCwW4XA4cHh4iOHhYXYdSBUDCGV3ES34QVfmwOfVzpecl8RWo5O1q5O2eTW46mcZ54Kenh7OshKgvZyh+r5eOXbhW/kj+HYc+FrZi8cNY9AnyxgbG+PU3WoHpVKJvb29tl3KZpXvYpmCP5eAKBXFkMjclNza7XasrKw0JLSM3KAdMb7VuE1obwH4fD4EAgGKxSKMRiO2trYaEtpmGwRBELhy5Qo2NjZQLBZb2jBx0bx4PB6Ew+GmCU31rYqBgQGEw2EsLy831Ag+ZpvCSsSHaCEDUiZDIZnBP7vj0ZY3A5Oy1eiGJQiibdulHgIeH++T2TF3rwFZlCHJUXjI+uaEKjNgxmiTstksotEo9vf3kc/nWW2cVqvF0NAQfEc+/PbX/hohBQ+ZkyhKxSJ+4sH3oA+dT443AhN1LJfLkU6nUS6Xu2qJWa1WeL3eltO4zRDnUzBNDMF9fR2bT34HV37mg6DLNAp8YHh4+KYk1On1etA03ZLUNgO/alCwGnK5HMlkEtFoFDqdDiRJoq+vDzab7UJIl9Pp7MjCjNGeulwubGxsYHJykvPrzGazZzS61bBYLCAIAktLS2dawclkEiKRiJOMIplMIhKJIBaLgaZpaDQa9PT0nGmPUxSFsMuLz334F7Gfj6GCCiYWTPDu7jcMtOgEfD6/bfBDOzCkuP4PUylOhE+QCCUQjCTw9edWMNzfi7FBC/qmxyDWXMy9zKBQKDS83iYnJ7G2tsZaoHFFM+ulajCJV9lsFvv7+6eSnZ4IFqN/jlQyh1S6AIF3Bw9Y/x1KxTKOj48RiUTOTWIZdLt2MW1zrj6r7QhnvXNBp6+Jiz6Xz+ejd3gA//Hpv0YunQZNlRE7OsFf7brwf374Fy6EzDLopEup1Wohl8uxtbWFrAD4etaFQ8c+ZJEdzPUO4Jcm72ton8kMNDa6j2UyGSsDeyvjNqG9BeDz+eDxeKAoCnK5nG3BVd907bSvTFTt5uYmCoVC08pPqVRqukFQFIWtrS3IZDJcuXKlo9fAuAlsbm5iYGCg5gZQkmL87pXHcCPkQcwQhzxVwryh+WbBtJNbacvsdjsODw85V5soikIqmcKDb0zn37hxo+X3M1VAZiEtFosIh8Nwu93I5XLYS4Wwn4og70uhmMrCPDeO54/3cK95BBZZd0MW1VCpVFjf24a6R38uGzC1Wg2Hw9GVPY9BLEc2mYZILsU9v/YzyMWSUFt6MGzraykV6QbVmzPTZWhVaeSKeDyOk5MTCIVCTE1NwWKxgCRJxGKxC5m6d7lc6O3t7Yp0DQwMdOyAwMUzlHHBWFlZwfSlS9hKnSCUTyN9cIR3zzcOl8nn8wiHw+wgnEwmg8FgaHqoZLCxsXHaxVFr0VNlIKaZmcHS0hIIgrilfrPtSHFRK4IzuQ3fSRT/4dc/Dj6PD5cvgt47zz/5X41mUhHmOc688X6RJMmZ+EgkEmSzWU7dF6lUipmZGcTiYfzl934DhIgGn88DQfKwvncdUcf/jTHDQzCZTG0/805QPwPRCbj6rLbSzzLOBUKh8FwuIxRFcZo98WZikJp0oE5o3Pi//x7zP/1B6Ef74c7GMKhu3T3tBBaLBWtra5yr+iRJ4vLly/j/PfM38PiPAIIP0DS2Ysd41ruJ99sbDzLb7Xasra2dIbRyuRyJRALlcvncr+Vm4jahvUVgtLPAabpWNBqtuYi4ThNOTU3B6XQ29chrNnnZSGLQ6rk2IkiMbmdjYwOJRKKGVEsJEveZhwEzcP369ZYEi8siKJfLz3jytYLL5aqZDG2mVW4GkiRrLFZCh+uQpw5BFQpY/vunobQYkDmJ4DVcx5TxtPInEokgFoshFotBkiTnTSJZzONP917C9Rs3oPDdwCBPjt+eucTpZxuhp6cHfr+/4zSZK3ITnormIBzuA58gQAiFuCMvA1G5+DZTvVuE0WgETdNdk9pisYi9vT0AwF133YXZ2Vm8+uqrqFQquHTpEnQ6HVZWVjp2CalGNps9c513ik4dELgeTLRaLfgCAX7v63+DkE4EHniIuY9QtGjwE8MLrAtIJBJhB820Wm1Hg3Db29vQ6/UN1ws+n4/Lly9jeXm5q2nuHxeKPDlCdC8MmigMWiUUcjmEvfdga/cAZnOu43umGcLhcMvKOkNqO3HCkEqlnAktA6GMhn1SjmQ0j3/4b5uYvteAiStm2PpFmLGcz52lHuFwmNW0dwsuPquN9LOM1KJUKl2I93GxWOS0z4ghQNxzjFI+j+GH7gZPwEd47xC44PeWkcy0OijVo0zTyCpJKAkz1r/2LdiuzcI4MgB3KtL0Z0iShEwmYxPKGEilUpRKpbd8/O1tQnuLwEgOgNNEK7fbXUNoS6US5wt3aGiI04AIg3YSg3oIhcIa8lENZmF2u91NT9V6vR7hcLih3jcQCDQcBGsEpp3ezoOToigkEokaMT7zHLrVrfWrDJBoVMjGklj46Q/CMD4IPni4+/I8pBUB8vk88vk8UqkUCoVCTVQgUzViIpcZ0ssQ37/dexWedAzg8xA/OoF3RIpnPBv4YH93yVwWiwUrKysdbc7JZBIHjn388Ud+ETvpENKlAgYUesiKFVYOcJG+onK5/MzibDKZQNM0NjY2OF3HANjhvFAoVDMMQ5IkLl26xLpfAKdts0bTyVyxs7PTdfWpGlwdEDqtsnuoNE7UQsQPPABPAFIuwddffxGK4wSsCh07sNcN2fT5fGwSVjMQBMEOrZ7XruxmIJ/PY3t7G9ce/giWF/swMDsJgUgBvkAIrfVUSrKysoLJyclzO5dEo9GmUdUMGHnA5uYmp7VYIpHUpJtxgUSghoBHIhaM44lfnkAmVUImVYBKfDHEvRrtAmA6QSOf1VAhjbXIEZw7O/jQvQ8CuBjngkbgUjjx+XyI+f2Y7xuGExmIRCJIDFrYFVqoM2Wsra1hcHDwwg53zP7H1SWDz+NBSpAoIg/r1WnwKzxkTiJQm1ofyAcGBrC1tVWzLpEk+ZYns8BtQnvLwEgOgDc392p06vfW19cHkiTZ+NZGN2O3EoNqq6pmsNvtTXW1ZrMZe3t7Zwhtp04BRqMRi4uLbQltfXUWOCW0+/v7XRPaCY0J96vt+Ed4IZRJwOfx8KmRO2FSnFYKWrUNaZpGsVhkSW8ul0MsFmOJ70urr4Giy3B871Woeo3QjwxgJx4A0B2h7VRznE6naxLUrojPykMumtRKJBJkMpkzrS3m89nY2Gjr7xuNRuF0OtHT09Mw+KFQKNRch3K5HLOzs2yoRCfXAuM5e1EkjYsDQj6fh0jUPkOeQbSQAV0uo1wqYfUrT+HKp56AsrcHlrFhXDZ2n8bGOBxcvny57fd2StJ+XCgWi1hfX8fU1BQoioJMoYZQ+uaGzVQGGb9vm812rvhiiqI4vXapVIqxsTGsra21vb+kUikikebVtUYQ8Eno4u9FSP0VaHtE0PYAdNiM7KEZtPriUsMuIjq4HszAmN/vx1M/eB7fpI4gEJEIeQ6wuVzET+snwUvlL8S5oB6tJAfMumM0GrGwsIB5HvDysRMr9DZMKg2euHQXSAHB6piB0xmE864dnXiNA6cc4ycG5/Efn/oCDIN2CERCFI5CGC+07lAx3cZ4PP6WiqvmgtuE9haAGQorlUrs15hBFoaAtNK+NoPJdJoktry8DKLPgBdO9rG/s4ljgwj3qm3Y33Oc0btyAdMebge9Xg+5XI719fUaT0SxWMxOLlcveA6HoyP9FmMt0mr4pFF1lnkOXF5DK4wWRPjPj/8sljY3cPfsFfQo1JyfN1ORbYSBshc+nw+WK5PgCQjED32Ix0sImAJdR6jabDZ4vd62PqXpdBrb29styQdj+8Qcli6CpLTanC0WC1upHRkZwcnJCSqVCoxGIyQSCfL5PPb29iAQCFo+70aHQkZb1onrQDvP2W7RzgGBq1sF8/wirkNkI3GABh787X+OpD+MUiqDXkX38aDZbBZOp7OjyptUKsXExARWV1cxNzd3yxPDKIrC6uoqxsbGIJVKz3TDqqFUKln7o2Aw2JEkg0GnHqlKpRKDg4MsqW12vzMG951gd3cXg4a7cEfvOxHO7UEkUMA0OotoJIbFxcVzSXAYXGR0cCNYLBYsuV5D1OGDQEyiVCzhaGsPzw5U8LsPfeymeBpTFHXmfclms9jb24NIJDqz7txvGcEEoUIulwMpOL3eGR0zo+vl8/msU0i3aNXtbARDFviN+55AVAqQfAJ33tmP2HGwbTd3aOjU97j6ECsWi5FMJrt+7j8O3Ca0twj1nm4GgwGhUIgltN0mcmi1Whykw/jDp/4OKpsJqVIWX7nxfawRavzGYx/v6jHFYjHrN8rlexldbSqVYjdpxvSfqUSl02lkMpmOTcZtNhu2traabkiNqrMM6q2xOgETomDXGpE39kLGu7hb527SgC+k9zB47QpOtvZhGhvEz03cj0K6gKWlJYjFYlgslo7M+ZVKJWt11IxQMGT20qVLba8LtVqN0dFRrK6uXkjlrd3mbLVakclk8PnPf55tczMt72KxiNHR0bbV52ZT5ozrACOTaSdv4OI52y1aOSDkcrkzoQoMaJpGOByG3+8HcLrpP/HAwwh9P4+X5V6QcjkMo3K8U2jCieMQui4SmSiKYsMbOv1ZuVyOkZERrKysnHty/jxgdNlDQ0Ps9RKJRFpW/xn7o3g8jtXVVU6BBdWIRCIt9bONoNVqkc/nsbW11XTwtVV8aSO4XC7WpxYAFOSbaXHMUO95JDjVv6fTCN5OEUknwBeLcP3/Y+8/wxtLzytRdGEjbeRIACRBgmBOxYod1Qqt7lZoSa0cbNny2HIYhzPXk87Mc2fOOeM54zmeM8d3fD0z9ujaY8tjWQ6SLCtasVvqlrrVXcVQLBIkCIIgAkEARI4bwMbG+cH+doMgwgaI6up7b63nqadDkYh7f9/63ne9a/3plyCSUph7x1txFI3A5XKdk3LJZLK+STrDVvEF3xpeurMOk9GEn5a+GTMaM7xeLwqFAmZnZ9vuH2q1GicnJy3//8rKCrLZLPb29iCVSjE11Z/N3ejoKFwul6DrMZ/PI5VK4ZGmbqzW4UAsFmvpjEJA0zQkEsmZ/VKlUvE+3m+Uzksz7hPaewSRSHSmQtucGnYRe4yN4gkMTjuCN7eQPorC+aZrCFklEEv7+7plMllPra5GXe3GxgaWl5dhs9n4LGug/2lYMmzVShzfrjpLYDKZkEgkeia0zdKIQSam+P1+TMsM+Hfv/zmsxYOIMnK803kNs6ZhwHQq5cjn8zg6OoLX64Ver8fo6KigU367HHDgtNpAyKzQhVWr1WJubm4gpFbI5pxOp0HTNPx+P/R6PaLRKBiGwYc+9CFBz9FNB+doWNjbVZ578Zy9CBodECbmZ/C9qAeu7W1cmpnHB8wm3maHXAvZbBZms/mM3jMej+MxyyQ++MjbkGAKsCq0MNEqfsCm12EtQgT7rSjp9XpMTEwMxL2iX2xubvKWUAB4/28hBF2v1+P69etwu918tVbI76VSqZ6DE4DT+7VarfaVJtaMQCCAYrHYsUPTGBBgsVj6GojrJwBGCMgQYywWO/VSr4oRzhZw4+c/hFqFhVQqwahKD5vNxg/8MgyDTCbTcoaBEF5iY9dIfgnq9To+s/MCdtJRpEoFMCUJfvvZL+Bjpnk8uny163dC0zTK5XLbv9dqtbhy5Qqy2SxPxHsltuT1CgnI2N3dbXs4slgsfDe3nd59YmLiTLS7SqVCtVrlbS3fiLhPaO8RpFLpGZE1GRwaxOknl80iGz5BhWFRLZUhUytRr9eBOoA+Bta73ajt4HA4oNFosL6+jrGZSXzZv4EvlHxQVoDHjc6+N8p24ni/39+2OguckpLNzc2eNxti1UQ2ZKESDCGPyzAMv+nM623IWuZwdHQENHiGq9Vq/r0Sf0WGYTA0NITh4eG214vNZsPq6uq5z6RYLGJ7e7uvdqNWq+XbyYNoV3YC0dh6PB7cvn0bTz/99MAHjSwWC5RKJd+S1mq1qNfrqHI1iCHq2XP2IrDZbOAkFP7pFz4DqX0IyZMwIjox/EwGHzXO4eTkBDRNw263n7v2K5UKP5QjkUhgVbxWvTYajVAqlfyBUoh2eGdnBxaL5cJE3mw28wmE3TTRg8b29jbMZvOZahbxJhYKiqKwsLDAHwq6SbYIYe6XvDscDrjd7rZpYkS+1WmPiEQiSKfTgj5v4mnudrvbOuV0Qj8BMO3AMAxisRji8TiA0wIECUJhbnHIgUVJI0Ni79S+8VemHkHYHwRwqlFtV7XsNsNAUKqz+NHOLYhlUoRXt6AcsWDIaUdhVC9Ipie0gq7VanHt2jWk02m4XC4oFApMTU0J3vdHRkZwdHTU8RDh8/lgsVg6rs96vZ7Xu7cKgSCHX1I8UqvVqNVqb+i0sPuE9h6BoqhzU4NmsxmRSKQjKWsHjuMQiUQQDocxWpZCbRuCWC7D2AOLYJJZzMoMEPe5yF5kwtFoNEJKy/GPv/AZpLkyJOUMKtk84kssLlUWoJO1bql2e8xmcTzLskgmkx1v8saEtovEONI0jVQq1fPrboTX6wXLsuc2EK1WC7fb3fb3jEYjjEYj/31vbW2BoijYbLZzelsSPJBOp6HV6UCJRGAYhm8j90tG1Wo1FhYWcOfOnQuRWqJrbvf7RDZBkpsGFTXcDDIstrm5iZJWjq8k95CrlsFF0/jU8mOvazVir5wCbEbEdg+QOT4BJZHgxcohHnvzMB7s0Lrf2trC3Nxc2woiTdM8cclkMpibm2v7WEIcDXqBzWZDpVLpizD1C4/Hc8ZXmuDk5ERQwlQzyNT97u4uotEoFhYWWn5+6XRacCRrO8zNzbVNEyNetO2uyXg8jkgk0vPhYW5ujk/rajdU3IyLBMA0PkY0GkUqleKDJpqff2trCxO2EfzutesI5JPYFt3Ge668HWKKgmXF0LWV322GgSBZykOd3ELy4AhVABJaikq+hEqxN92yUOj1ely7dg3JZBKbm5vQaDRwOp1d1xuLxQK/3992rysWi0gkEi0HZZuhVCr5tW98fPzcoYBUaZeXl6FUKsGy7ECKOXcL9wntPQAZCms+zZnNZj41TCjhYhgGwWAQ6XQaFosFV65cwQ2JBMPH+/iT730VWr0OV2ZX8LDYLNjWqxUuIoE4rhYgmrCAOwhi56vPYv59j4PhatiIh/DWkf6mU5u9VoXmoxsMhnOev52wt7d3rgJx0QEzj8cDAG1bWFqt9pwPYDMoiuKrbZVKBcfHx1hbW4NCocDo6Ci/yRxISvh3X/vv0E6MwEkb8EBFhYeuXr9wpXMQpJZszu1+d3l5GeFwGFKpFBaLhU+qEepF3Mt1LpPJML44i3/0xf8GSi6DXK9FNpPCFxK7WKnMtD14tUumImEpjTGtjbGtjfcTeZ0cx8F14kcxEodMpUAmEMb04w9CQtMw2toPB/p8PphMpq6aYlJtDIfDWFtbw/LyMmiaBlevo8iWoZTIkE6lBTsa9ILx8XF4vV54PJ6BT6Q3w+/3g+O4lm4o+Xy+7wQniUSC5eVlxGIxrK6utrRcSyQSGBoa6uvxG7G4uIiNjQ3QNH3mORQKBfL5fEsSmU6ncXh42Ldm2W63Q61Wd2xDN6KfABgSq3xycsLrM4eGhuB0Olu+5q2tLWi1Wn6dn9IOgTENo9Tgx0ta+el0GltbW4KJYTPElRp0iTK4UStsyzMQAagWy7CUgLW1Ndjt9q7a1W6H9FYgRYp4PI7NzU3odDo4nc6Oa5xer2+7R7hcrq6WcY2QyWR88ijDMGcKalqtliexRKLRKJV8o+E+ob2HaE7dIJVQIRqVZDKJQCAA4HQhat4k3jw8DcXCW86c0shCfLdbxc2o1+sAAIlUgrqojlq5jPjuAXbyNEzJMrRaLbRaLdRqteDhk5GREayvr8NgtYCq17tWZwlMJhOi0aggQpvNZsFx3LnNg6bpvm9qt9sNiUTS8bUODw8jGAwKbvfKZDI4HI4zeluPx4NgrYhv5LwoVRhIcgX8ZGcf1ZUreHxAbXu1Wo2lpSXeDqlXkkwIbbv3SdM0nE4nlpaWoNVqYTAYkM/nsb6+3lXD2490Zz8Xh85pR+IgiFu//1nMvOPNCO958Y3yc5jX21qSUIqi+AMqMT+XSCT8f5PhCoqizvx9O8JhzU9hc72COurgahyktAJKiRRj6tZVv3Q6jUwm0xMBHRkZgVarxZ07d1A2KPHFmAulWhXiag2P1Qz42OPvEv6h9YCpqamO7fRBIBQKIZfLtdQOkkCJi4JIMVwuF05OTjAzM4Ny0otS4gDB7QOMPfF+APoLPQeZQ9jY2IBEIuFJuFKpbDl4lM1m4fF4cPXq1QtplRs9kjvJK+LxOORyuaB7nmVZXkpQqVRgMBgwNjbWVc+9vb0NrVZ7rmOp0+mQzWbP/b5er8eNGzd4Ykh8l4XsKV6vF7lcDr/1gZ/D3wY3sZuOQi2V44NLV7BsPC0aBINB+P1+WCwWjI6Otnzcbof0TjCbzTCbzYjFYlhfX4fRaGz7+kdHR7G/v39u7fT7/RgaGup5LSbXm9vtPqfhnpiYgM/nw8LCAn+geqPiPqG9RxCJRC2rnkajEd7AIVqFM3Ech1AohGg0Cq1Wi/n5+bY3TqsqFtEL9jPZKiRHvB1G5Rqwh1HQWiWWnnkScqUCWqMBH73+Tqgg5nPkDw8P+det0Wig0Wig1Wpbvsc0y+DPA2vInGygmi3gXVMruFGvQyTqLBLW6/W8N2A37O3ttdwYW8lFhEAImQVOT8XNvsRC0ai3ffGlbyIXjiPtP4Lney/h2s88g0A1hxJbhUIymChbpVLJ67B6JbXtNmcCjuNQLpdx6dJrqWl6vZ7X8HZ6PoZhBEVXNqJeYZH0hcCxLKyX5iCnaZSLDNQKJSYmJu76YBgAjKkN+KX5N+HPPS8DlAh6KY1fXXorFJLz5JxlWXg8nr40vmq1GmMLM/hHf/PfIFHRUFmMONk/xA+n6ngHy8AsuTtJX53a6RcFIU3tyH0nu79eQTxSI5EIfvStv4JFHIaSlqGaCSO59XcwXfoA5NqLvT/yHI3Xeit3kGKxyPtID8IijTjVbG5uolAotDx8+Hy+jtcdwzCIRqP8MLHZbOb1sEKwvb0NjUbTUn6n1+sRDAbbXj+EGEYiEayvr8NisWBsbAwikQgvxw6xk46AFkvx9tFZaOoSuFwu2Gw2fl3++bnzcdEymQxTU1P88ObGxgZUKhWcTif/nrh6HT4mjZf3A7g2u4B5fX8+xhaLBRaLhX/9ZrP5nL0laf837vPFYhEnJyeCpAbtMDc3dy6kSa/X4+DggD+M9OqF/HriPqG9R6Aoiie15ELNV8v4fPQOXllbhcpsxDslOfzszEMoMwz8fj8KhQJsNhuuX7/elVi280Ls11yeDKz1evJMp9PweDz4N+/5GXz5eBt74QCU5Tp+Y+UJmOjT/HSaps+0cliWRTabRS6XQywW49v7KpWKJ7r/Ze95FNQy5EJh1Gs1/JiJYDZ2iIetnUMXAGExuJFIBDqdbmCV7J2dHb7iKASdWkpCYTSboCsOI59KQ2tnkIucoBhLID2XhMJi7ftxm6FUKvmqTi+T9N2su8LhcEtze7VazT9fq2EGoLcKLcMw8Hq9kBSLmBpzICPhIFerIFXQmB+bwGPOy0icxOH1eqFUKjE8PHxXye31oXFcM4/htuYO5mfakwCXy9XTMEkzAsU0DDPjONk7xO0vfAtLH3wKHAV4sycw03cvunZxcRGbm5uQSCQ92WF1AulYdQqMSSaTbae++4XNZkNZk4N7P45QLIFRix5AHfnQOuSLFyfsrYIqGodyiCZeiPVeLyBRxh6PB9vb25idm8NLJz7ESnlQmQIum84Po2azWUSjUWQyGdA03VIPKwTb29tQq9VtZ0nUarUgG0mbzQabzYZQKITV1VVs1TL4STUG6tXJ6O9svoKfsizhsWsPCD6IN0q90uk09vb2wHEc7GNj+GJ0Gy8H9lBMZvDD8jHeaV/Eh5xXBL/vdq8/HA5jdXWVJ+Zk77fZbDg6OuIPHINKMhwfHwdN02fcX8bHx+Hz+aDT6XBwcHDh57hbuE9o7wFIm5KkhZGF4c/2foIjtohqoQTKJsaz7g2k9v14YmwR4+PjPVVUM5lMW3NvYi7vdruRy+UEWcSQyf5eCF4gEEAymeQnr3/TbAW3xGFjYwMTmvaTxhKJhNcVNSKfzyObzcIbPD1Bgqtj+2vPYvqpx0BBhJ30sSBC2y0Gt9cEs24gC3Qvbdbh4WH4/f4LEadHTRP4ux98F7a5KdAqJYZmnXiTYRzFXB43/QFotVqMjo4OxH6MpumeSW3z5tyMSCTSlqDQNM3HrLbSMgpJ2WIYBj6fD6VSCZOTk9Dr9ViuXsbfB7cQoA2QpIv45UtPgJZIYdSftvzz+TyOj4/h9XqhUChgs9n44IlBQiQSQaNUtb3nQqEQFApF39dHPp9HzB9CbGcfMpUKtpUFSKQSJA6COOB2YJmEIF1uPyDtzbW1Nf5evwiy2Swf/tDue+hFey0UZBD1MBhGjavjlXUvZhzD4DgKUlUR+qIVNE1DoVDw7XmlUtnzIbkxTcw6N4kfR71IhlRY0dkQ3N3HwsLCXZOQzczMIHwcxr/44h8hM6SCVCpGdNeL8KNvwT+sTSCZSODk5ATFYhFarRZDQ0MX0kjv7Oz0vFZ2g91uh8Vmxe/97R+imE6jLpaCK5eg0KoR1p/uxY3rUPNgbat/B06LDnq9HgzD4FsbP8F37vwIcp0a1VcP6d8OufCQZQKjKv2FXj8h0ISYW61W2O12MCopfvdrX4Ty2A5NropnxpYHFrNLHBJId8BsNuPw8BBDQ0P3h8Lu4zwIqW2sJO2mI+BQRzp0jOxJCmPXl1CcVPVld5PL5TpO85IBkUAgwHvFdlrse7Gq4jiOtyNpbv/1ag7eCLVafTpEYLPCkrqDGsfBvDCNerWKlP8IUouw6me3GFy/34/h4eGOJIXonbttkGSooVfnChKH3K/Mo1KpIOkN4N88/Um8lD3CXr6GJ8Yu4Z2OJVAiClNTU/wQCcMwsFgsGBkZudCG30gy21VOhSKbzUKhUHT9DoiPJsuyZ6p91Wq17YGuUqnA6/WiVCqdkxKopDJ8ZPIaMAncunULdJM0gwQGAK9NaB8eHvJdBrPZPDByK5fLUSwWzx1k8/l8R7LfDmR4kNh/Peicwx1JHr5sAizDQDtswfLMHD586Qlk0xkcHR1hb2+PH0wym80DqwKSCuD6+voZjWivENpuTyaTF3Yf4DgO6XQaiUQCmUwGFEXBYDBgfGYZ9ewR3v/kdVBiCpdmx6FxPAKN/RpvFVUsFpFKpRAOh894pMpkMigUCigUCtA0zRPe5mtIq9WirKfxT77wGdRqHO7QJfypP4J/8/QnB0Zi2iEhryOlkyLtPUSVrUImleO5l1/EyEkFVydm4HA4BvIadnZ2oFQqBZHZXkNyWNShHjZDplfj1mf/FsOX50Gr1fAf+LCP0+uicV9q3qPIf7fbu8LJOOoch8gdNw5++Aqu/+wHAUqEFyovYtZgO6Orb9bZSyQSyGSyrhp7u93Oe4t//8cv4PPxbRQ4BvJYBAexFKp6JZa4ed6z+qLQarV8kWJmZgbj4+M4OTnpy8Lz9cJ9QnsPIRaLz2gxFWIpKlwNltlJMCUGWqsJOqXwCMVGCG25jo+PC5psFTrZzzDMuejbZhDhfL+T9lJKjHeNLeELt34I+6U5iFCHxqjHUIxBRBfpmsFO03TbVnelUhFkeSKVSruGK2xtbUGv1/dtf2Q0GntyZCCoVCpnSOWlUSc8EiuG9EOgRK8tlKTCQCzASBt4ZGSkb62hTCbridRKJJKWB4NgMIixsbGuz0fiY7e2tlCpVPjPmimXz02bdyKy7d5Lp64EOWABp8QqGo0iEAhAJpPBZrNdmNzSNI1cLnfm/3EcxwdiCHls8t1GIhHe3q1xCv6fGJ7E1/fXsJWp4dr4Et5hX4RMLOF1iMBr/qAulwssy0Kn02FoaOjCOe8SiYS/VvoZKqxUKoLb7YlEAsPDwx1/phUaCSzHcTAYDLyNHO9OYR/GK9/+U4yPmnEcy4AyzEI9egUAeLuodp9VpVJBsVgEwzDI5XKIRqMol8s8cZJIJDzh/eLBOihahvj+IdhyGQbHKL59vAuHfoivQBNbwuZ/r9frLf+uVqvx/96OrN1OhJAJRcBWWWx94Vt46Jc/AbV1COPLc3AODaaSSiRZQiuzOp0O6XRaMKFViKWwSZW4s+PFzOOPQGe3QqZW4smZh7Bsu3gohDptxw+/4Yd5xgnz7CSURh0UWjWeuPEWDCnU5xxQSBR8pVLhEx0bXVAIL2gsAJHBUrFYjEAtj8RRBNlIDIGb23jwFz6MwEkEO9EQlq2DS22jaRpXr17FxsYG7HY79rxhbOxEMHoziKVpM8yGiw9ZDhL3Ce09AjmdNbY63j9xGf/D8zLkKiW0I1ZkghG8+/q7e37sXqt6RqMRNE1je3u7ZfsWON3cM5lMx8eJx+Pw+XxdNyedTodkMnkh66j3O1YQ3z1AfXEIMbcXv/j4BzEkV8Pr9SIcDmN+fr7j46vV6pYnfKFG4YTgt1pQOY7D1tYWzGbzhQZfhoeHcXBw0BO5bMytbySTGo0G2Wy25cbaqAtjGAZHR0fw+Xx9SxIaSW234UNyuGl8rRzHoVQqCa7akRb29vY2vMkovls+wu7WNiZnpvFLl94Kh0IPn8+HXC6HyclJwS1uIk0RciBRKpVwOp1wOp38QMza2hpkMhk/5NHrJkPT9LmhObfbjbGxsa4tZuJHSqrvy8vLLUmfXCzBU8PzWKEMmHG0bhXTNI3x8XGMj4/zVcpoNIr9/X3IZDIYjUY+eahXyGQyvgrUi/sKuc6FttuFSqvy+TwSiQRSqRRYloVGo4HJZGprKwUAnEgCie0BLF69AvPJCYolBiKRsO9aJpN1/NxYluUJbyqbRSmdhe+7L0NpM2LhXW+Bu8BiXzoMsVjMd/1IhU8kEvHVv+a/a/Xv7TBcmMbNtSLy8RQe+sWPo5IvQDJqw7h6MDpyt9vd03wBcFo99Pv9gosF1WoVj1UNYBfm4T0KoV6v411ji3jUOtnvy+ZRqVRQPAjjSecybtVOux3ZUBSfvvZ2DClO105Seb0oCNn1ScrQpodRyhQglUnAFkuo12oIBwPgoqlzQ8symQxSqfTMP5v/tAMJ3/jKt17AD17yI3hwhJ/c9mNjN4ZPPD0Pq0l14fc1KNwntPcAIpHojOSA4E22KWhlNL508h3MrixjOMtBka8CPXbj2g2EdQKJQdza2kI+nz/XIu+WFkYIg5CBNaPRCJ/PdyHj9mg0iifmrsDpdGKjooZBfNqmm5mZQT6fx+7uLu/n1+r1mEwmnJycnCFr2WxWsFF4OwkGyY4nLfyLgAxNCT2gsCyLjY0NzMzMnCODWq0WPp+v62PQNI2pqakLSxKIHGBjYwPT09NtP9NWhLbdMFg32Gcm8R++/P9BmWXBsTUkyyX81jc+h5+feACXZxd6jhNt9IXuBaTS5HA4zpBbMgRlsVgEfY5KpfLMPReLxcBxXNvPJpvN4vj4GNlsFkajEZOTk4IOjb1EWVIUdUbfXqlUEIvFsLu7i0qlAo1Gw1dvhRJ4mqZ5T2Mhkcocx/HXeafDVq1SQPbwReQSxyhGc2CXZyGhz94XDMMgHo8jmUyiUqlApVLBZDK1tWVqBTJxLxJLMGSxYnV1tSdy1gmNcgw9KwKj0+LN/+RTSPiOQOs0ePTyA1ieGeygWzNGVXr8zMxD+D3PX0PnsIMrlPDWugkWRX/dw0a43W7IZLKePy+1Wt1xoLQRLMtic3MTD12+iic1Gmx53DDrDRgewGAsGXqem5vDNe01vKeQRqJcwInah4dNvQckdQMhxsvGYVTjKZgmhmGcegbVbB6Ly8t48vqjkLSQHJBqcOOfQqGASqWCarXa0hu7mQR7wxwoiQRHR36cRCMYHZvASxthfOCJu+sr3QvuE9p7CJFIdM6L9pJxFOXxS7gxfQMcx2FtbQ16vb6namY/hBZ4rX1LJlsb03DaDfCQWEuDwSBY69ttul0IQqEQr88lYQlko1er1bh27Ro/Hdqq6mw0GhEKhc4spPv7+4INqWmaPlexJmSWTKcOAsRwu9s0OCGz7chjP5/5RSUJ5Hra2NhoWxlVKpXn2ur96EMBYD9zAsXIEJjDELa/+n0svPdx6EYsUE3Z+5JQXCQhj6CR3FYqFf5zpCgKZrOZz6JvhUZ7OOZVp5PmQUWGYXB8fIx4PA6lUonR0dGeiXulUuk6QNcOMpkMdrudJ/2kRX9wcMAPfJnN5q7rF7Gb29zcxJUrV9p+JuQem5iY6Hjw5GpVxO98GTUmi2g0AbVYjPjml6Bf+jCSmTySySQvJzEajZifn++rwsxxHOLxOB544AEAr6XzZbPZgQzUFYtF7O/vg6Io/LN3fQz/zfMijrNpKA05DHFSPKYarPVZOzxoHMM/vfQk7AszMNEqBL0+hEKhCxUliI3hRch/t8M+OfxMT0/z34eOVkLcTwZ8E/x+P1KpFD/0DAAjKj1GVHpEnGIcHR0N7GDTiFAohGQshn//oU/jvz33NcCigdWuwFvl9pZkFniNCAvlESQuuPFPLlcARYlxHNyFa/2HGLFPoMhcbH0cNO4T2nuIZslBMyiKwuLiIlwuV0/pL9ls9kL52jMzMwiHw/ywGGlZNWus8vk8dnZ22soUOuEivrbxeBwajYZfREwmE4LB4DkSOTIyAovFArfbjVAodGbTao7BjcVi0Gg0glueRF9JQBZOIWkyvYDIDjo9JiGzZFJ/0LiIJKGR1AI4d52o1WpEIhH+v4UMg7UCx3HIxhM42fOBoiiYZhyo1zlQMhlk4v6HJIhUYxDkhNjfjI+P85XNzc1NAK95T5Lrs17jkH8xiPT33Eh4ZHCr4lh5+4M8yY1EIojFYpBIJLDZbOd8KntBuVy+cHIcATkEAafXZTwex8HBAUqlEtRqNUwmU1ttsVarxeTkJE9qW/2My+Xih+86oZINo8ZkUKmweO4nLlxdmkA0noGx+ByGJ68Krl53QyQSOXdvDg8P4/j4+ELXTKVSgcfjQbVaxfT0NH+P/W/X34OjQhrbstt456Nvwcb6BnRK9V257xtxdHSEKccELK8GfMzNzWFtbY0PxekVHo9HkCd3J2g0mo7Jb2RNbl4XLzKYTB53a2sLKpWqreexxWIZaKWePO/Ozg4vAQCAjzuu8PMeW1tbA/NabhUXPDkewss3g5hbfhhzyw8CAMaHL16lHyTuE9p7hFaSA+B8IIJSqcTIyAjf1hCCXu21WmFkZARKpZLXqXnLaXwruA2/SYy3Ds+ATecRCoX6Th0jov5+LHsCgcAZP8lOvoQSiQRLS0tIp9O4ffs2rFYrL6dQaNRYO/Rg1GJF8NXISKHIg8VmNAD1mA2jSt1dIbPA6ffPMExb8t9IZrt9lhcdxgP6kyQ0klqO484suM3DhkKHwQiKxSKCwSCy2SzGzCYsLS4izjKgpBIotFqIoxlo8zWgzzWeSFMGbV/VWNkkBNXlcvGfj+J2DrXdFLh0GXsbO5CKKKTHIjgQF3lHh348PluhH39pISBkmxw08/k8Tk5OEAqFAIAfsGo8EBmNRr7rs3RpGcF8CrU6hzGVAb59LzQaTUe7vWw2i0wmg5jfhbgnAKlEjFg8i0ymgGtLTtgWZqG0Dq4VHA6Hz5EavV7Px1v3CpZl4fP5kMlkWnZbpJQYExoT4gotJGIJ7xTRi/9zP4jH4+cGtpaXl3H79u0zFUoh8Hg8oCjqQmQW6HzYJJV8u91+bl3sNxgHOF1vtre3O6aokecYhJc4QaVS4d8PuZ+aB7/n5+exvr4OvV4/UHs64HTPnR0V4fDQgOixGRKJDLMOAx6+/Pp0CITiPqG9ByBklqKoc5IDhmHOxTOOjIwIPn1d5OTZDBKD+CfPfh0vsScoJpI4CsnwlZ/8EJ+efRRvvnaj76qQTqdDJpPp+WbPZrMtRezdwhL0ej0eeOAB+P1+3Lp1CxKbAZ/x/wTJkwQoiRg3bBO4IX5A0Gv4ccSLz3leQdTjxffqUUyk6/jlx54eSIZ7K5hMppayg8YKhJDPkWwAg67GNUsSbDbbuddKqgqE1LYi/kKHwcjzhcNh0DQNu93OH/b+pd2OrwU24WJEsCq1+Ll3vx3RwBE2NzexuLjY80JvNBpxeHjY0+/0ColEcobcRo8juP39l1HjOHxv50VYVAYsj89DtnaIuU8+NnDyWS6XB2rK3w7EFcLpdPKter/fz0fSEmcFi8WCTLGAf/qlP0LJeloBouJ5/Nz0g3i44VBfLBb56N9CoQCKoqDRaKDT6XDpxmNI08fgqgx0GgXK5Sr2AiegHMDEgDJFksnkmU5RI4hUSGi1jHhfx2IxOByOrl6u5CDY6P8sRH/cD0jMbPNaL5PJMDMzg62tLcHRy16vFwAuTGaB0/Wn3SwGCQ5qtc5IJJK+vFQjkUhPRZyxsTHs7e1dmNASnW7zoSUej5858EgkEszMzMDlcvVl9dkKpCosk8kwNenAx/UaGOQpvOXNS7hy+eLf4aBxn9DeI7Sr0Larri4uLmJ1dRVarbbjopXP5/vSz7aDTC7DHXUFJW8aCV8YlUoVeqsZQe15o+leoNfr+UpNLzg8PGwpp2jW0baDw+GA2TKEf/iFP0CFqqOYykIil2JvpIgfRfbxluHOG0mqXMTn9l8Bhzq4GovEfgCVEQvCVBl3h86etjD39vbOLM6EzPYSyarVanFycjIwfS9BK0mC3+8/J0kg3qNEfkDeD2kBdhsGy+fzCAaDyOfzsFqtLbWWKqkMn5i6gezQLI6Pj6GW0lBPTSGZTGJ9fb2vyGdS0Rl01aMVJBIJRoZHkDcMw3sSxHEyCp1cCzElhkzceRq5X7xe760RFEXxMgvgtdjOzc1NcByHH6YPcZRLgSrnIaFlqGTy+FZiH0NeDW+hpVAooNPpMDY21rI6aVr+ANL7z8JSE8EXyeHtH/kHOE6WcOvWLSwuLl74YBcIBNomM/XiUBIOh3F0dITh4WFei9sNxIeVtIVJHHSv1VIhODo6autprtfrYTAY4PP5urbXvV4vOI67UPBCI9rNBRCHmXZrCUVRqNfrgp+H4zh4PB6wLNuT9I+maX4Yq+80v6ZwokakUqlzn7ler0c0Gh1ItHRjVZhIKK5evYoXXngBCnow0emDxn1Ce49AYm+b0S7hiKIoPge9U2u834GwdqhyHIr5AjgAhz9+BaMPXsbw0jQK1YuZKxP/0V5AggZabUTtdLStUKbqUDpHwCVS2P6TL8H5+IOgKDGePalAOd7emoyiKBzm4ojun0b/bXz+G1h4/5OQytNY3dmCaeI130mlUjlQL8BMMY+9VBQGWgmTXIWNjQ2Mj4/3pJdSq9V3vdooRJJw5coVnrjYbDbI5XKUSqWWw2CE6EYiESgUCoyNjQlq/zfLUIxGI9RqNVwuF+9+IRTksDRoOUkrJJNJHB4eompgIUqI8K+e+XUcpSIY0VlATWixtrbGV6Xvtm7y9QQx1Hc4HCgWi/gf31xFMZWB+zs/RpUp49pPvxe+2DEMK2/vaKHVCKnSiKGVjwAATm7dgkRlhkNDYWhoCC6Xi7fj6gf5fB4SiaRtpa6bVAh4zebQbDYLcodphEqlQqFQ4O9/tVqNqampjvrjfsBxXEedKnBaJNjc3OzYXvd6vWBZtueBxW5onsXY3t6GVqvtSOZ6kRwQUmez2foagLPb7X0Nh5FwIrlc3rb6XSqVWu6FMzMzWF1d5e04+0E2m4Xb7ebtHwOBAKxWK0+qB9kJHiTuE9p7hHY3VblcbquF0mq1MJlMHU/DuVyuJw1iO5BUoVgsBl2JQ4EDrn7yGUikUpy4DzA2snTh52hsmwmB3+/HxMREy78Tmu8NAGqJHFy5jGIsgcWPvAOmiTEoNWpcG1/CDUfnVs1YKY9vU3Ew2Twuf/J9EEvEUI9YMD5kA0VRyOVyfJpKozm2TCaDXC7nE4HIHyHVlK1kGH8cWgMX2QBt0GIyLcIvPPxkz+L/fg4RF0EnScLKygo2Nzfx0rEXX/fdBrP1HYxINZhZWYJOpkA2m0UwGESpVILNZus4+d4KrQY/SOSz3+/H2tpaW2/WZgwNDSEYDN5VQhuPx3F4eAiNRoPl5WVEDEZIvieHkdFCZdQgMFTCY2+7AuCUTB0dHcHj8UCv12N0dHRgMpLXE4QsZbNZ5HI5/v6laRpDOj3CBh3m3vkYZGolKEoElVjasvUtBORQQhwXbty4gUAggFu3bmF+fr5n/enh4WHX9D/TkBkv7m3BZLXAqTHxqXPpdBoHBwdQqVR9V1TVavU5j2Kj0YhKpQKXy3VmxuAiECqbWFxcxPr6estoX5/Pd1fIbLpcxHPxAzx78xhztnFM5EXQqjVdvxcyENz18RssufrV0JvNZvj9/p4ILcMw2Nrawvj4eNs1p1PVl6SAkmHyXkGkFUTCwrIsotHoGYeVQUd9Dwr3Ce09QrsKbalU6kjwHA4HNjY2kE6nW1ZoCoXChYYD4vE4wuEwWJbFyMgIrl+/Dt2IFb/7w78Do1egnM3jXVcfhSlVvfBEJRHNC2mNEN+8TlWpdqlTzUgnkrhWVuOW045qoYRaiYFxyIonRlq3DxsxpFDjGccK/vt3vwLz1Djy0QSmpFq8fXblTApXM0gEJsMwKBQK50gvcLqRy+VyyOVynvDWJWJ8ZucFSPRqpPxhFBNpMEMGHInL6EcKKPQzGiTaSRLCtQL+bP05SGgapWQGslklfvt7X8BHhxagVCoFV2PbgVjNNS/8DocDBoMBt2/f7jrcAbwWwnE3EIvFEAgEoNPpsLKyAplMhmKxiFgijmuffpLfOGo+HwKBAJ/sR8hBPB7H/v4+KpVKX/HFHMe9LtcCwzA8cc3lcmBZFhRFQaVSQaPRnJMNlMQcPLEw1HNOlLMFGO02fHL4EjY3N/kKey+v22q1wu/3n/muCWFwuVwwGAyCnSKIjVGna7NQLeOzxxu4s72NoVkndDIF/uHUI8iHY7x7zUW00O3a7TabDeVyGR6PZyCtfRJS0w0SiQQLCwv4yfothM0ypKsMxlQGzLEK1NnawMlsvlrGv9/4NqLFE7DZKm55dzFjsOK33vXJrr8rxOWglSVXPyDDYUL3ymQyCa/X23XIL5lMdtwL1Wo1DAYDv2YIhcfjQaVSOSOt8Pl8/L1RqVRed3lSL3jjvrL/HwbR5bXS8QjR2ywuLg5UL0VIBrlJZmdn+cW2UqkgE47iP3/0V5Fk8vDvefHQ5Ru8dUkmk+lb4K/X63lT8m7w+/1db0whrWGPx4NyuYxfefeH8fbsCdYD+6hk8/jo1cehkAjTOb1Jawe1/GbQY1boVmhUD09jITt9b80WKK1QqVT43PdSqYRUKgVfKoojlwdcjcX657+OlZ99BlajHv58EtfMvU9rE+3dvWpXN0oSPrP6PUjkcuw//zJOdn24/qkPomIxYfrSIgz0xdNnyHtt1QbVarW4evUqdnd3kUgkMDMz05HMkCCNQQ1kEd2k0Wg8U30mrcbFxcUzr8fpdOLmzZuw2WxnrjMySEWcEhqr4EKidxmGgVQ6OD0ccRog5JWQLpqmodFoeOLYad3yer3QUnL8/kd+Bc8fuJCIx/Hua4/AptQBOD0ErK+vw2g0dn0sArVajWKxeO7/0zSNa9euIRQKYXV1VZBbgJC16G99G4hVSxBBBCbPIH0Swu/5wvj37/25u+pGAJwe2HZ2dnomM82oVCrgOE7wNS+Sy/DF5B7i3iR0jhH86M4aHLQOv/3MP+j7NbQCx3H48dEekrkMOLEIR69sw7o8i5iawlEhjbFXrcXaoZPkgGVZuFyujpZcvYIMh3UjtL2Q6EQi0TUm2Ol04tatW4J8oImziNFoPHMQYhgGmUyG/38X0QO/HrhPaO8RSIWWlPQbN7Rum5BMJsPU1NS5aUYyLSwEZMo4HA4DOHVSaEVMXS4XZmZmIJNKYZMaEHqVg5O4Ub/fz/vV9kquhcoESNxmt4oD0dG2IrSVSoUfFiCPM6e3wqk0YHd3VzCZBU7bjY9ffpBf6NMyHXZ3dy88WUrcGxorP9byGP46tYd0MIyF9z8JtVaLiMuDura/DPVOEbivF4j5fjJ4jFqlBq19BHWRGBKZFEw6h3Q8Ad1I7160zdBoNMjlcm11fRKJBMvLywiHw1hbW+s4KNRLDG47ED3w8fExzGZzy43L6/XylnnNmJuba3udNTolNFbB1Wo1RkdH21YTL2LZVSwWkc/nz1VdNRoNNBoNnE5nz1IIYrZPKnpvH5vHEXXEk1ngNc/eSCSC9fV1mM1mQdXVToEHdvtp+Mbu7i7/2ls9ntC16DAXRz6VRjoYRuDlTcw/8zjqBv1AyWynbsvCwgI2NzdB03TfUplIJNLTAOmtuB9VLY1agoP3+VtQm3UIj9DY8O1hRKnj06hqtRo4juP/u/n/dYNEIoE3eoDMcRSpo2Nkjk9gdI4hH0ugUGaALh+xRCJpWUwivupCuja9gKZpPqigFRkkh1iFQiGYRBNf524Q4mNPrMha+cnv7++fGcKuVCoDPQAPGvcJ7T0COSXK5fK+yvhGoxGpVOpMWks6nYZOp+v4e42+nWazGYuLi21PXIFAABqNpiP5cTgc0Gg0fXshCglYCAaDbadsG9GOIBOBe6sJ93YJaO2QzWbPDYOQydJeNwAhKCbSWGHV2HSOQxwMQztiwYhzCnMyA27duoWJiYmeFl+hEbiDRLFY5ONFWZaFRqOByWTCx9/8Dqz97R9h+tHrSIeOMTTrxIMGO6haHWtra1AoFBgdHe2bfGu1WsRisa4/NzIyAr1eD5fLxUsjmkHITj+EluM4hEIhRKNRWCyWtgNAyWQSpVKpLVnSarWQSqWIxWIdSUrzYF4wGESxWITZbMbo6ChkMhkK1Qr+bO8l3Nzfgbhex0/Rj+OJ0datZZZlz2hdSdVVoVAIrroKwfb2NtRq9ZnKU6dqGvG4JYmAFosFY2NjbdcSq9Xa0VOYpmlcuXKFf7xm7WS9XkcoFMLw8HDL32dZFrFYDLFYDKWDMDiujIk3XUM5X0Lx+ATj+sH6oHTrtiwvL2NjYwMymayveygWi/WkwSzXWNTKVdSqVcS2PaAfWkGlyCCTz8EiU/GzBBRFQSKR8J1K8u/kn0IgixjxPf8Whi/NYeotDwJsDciVkPD6sXWcwPj4eNvvudU11aslV68YGRlBMBg8VzRiGAZ37tyBw+EQfPDohS8olUrYbDb4fL6WBSsymLi0tHTu8JnNZsFx3Jlrh2GY+5KD+zgLkUjEEzlCqJRKZc/JWVNTU7h16xb0+tOTfy6Xa7nYkqGcSCTCV3K6aZry+Tzi8fi5Ba1VVcBoNEKpVHYVsrdCt4ohx3GIxWLnIj9boV6vI1hMIx/ahUNrhlNrRigUQiwWG5hHYzvbsMbJ0kE8D8dxcLvdAID/x3s+hpf9bmxKvVicnsdDlgnIxKe+u75XtZVCU8IGETvcDSQhKpFI8F0Do9F45vDEMAx8d+7gt973KfwoFcBensVbRpfwHucliEUUHA7HhYefmkMbOkGpVOLatWvweDzY2to61/Lv9eADnPUWtVqtHSfZWZaF1+vF1atXOz7mzMwMX5UUslY0DubF43E+vOHrKS+OJBVUqhVQMin+5mANWimNJbXlzJAWudeJ1rWfqms3EPmS0Wg8d2AQYrE0MjJyhtharVbY7fZzn49er8fBwUHX10OinUnr2W6mkfU+h1o5B5c3gbe9/5f4n2UYBrFYDPF4HAD4IsE/npvGf7j9beSqZUhpGkq1GtcqqoElOQHdCS3povVTbCCWYL3sR9oci5QvBJ3dikd+9aeQP45DVKrg2vQ8dMrBVabD4TCK4Rj+6bs/gS8Eb6NUq8Ki1uOXH3gvxtQG3t7P7XbDYrFgdHSU368qNRbPhd1Y9W8hZ1XjEcsEPHsecBzXkyVXr7BYLHh55zZCSg46KY1LplGkEsm2ZLITkskkDIbOsopG2O12bGxs4Mc+F6KoQCOV4zHbFGJHxx0lDq2i4KvVKqRS6X2Xg/tojca8+HaWXZ2wvLyMP/ne1+AxAmH3Ph5/8FH83NwjUEhkZ3w7e0kWImbKly5dOvd37RZRokXb2dk5o7npBp1Oh1Qq1XZRJtGS3Raaer2Oz+69hO9GtiFOe0DrNLhaVeGJscWuVQahg1JEg9dq8aEoCjMzMwORHpAp18ZUmFGxCs75G2cqwDKZDHNzc2AYBl6vF4eHh5icnBx4qlU3EN3kyckJMpkMJBIJX7VrtYmSqgTZZBdt4/BIrLCarRA3DNY1Dz8dHBzwFmDNWtJBgFjjxePxlnpKoTG4LMsiGAwiHo9jdHRUkCUTkfZ0uwYlEgkcDkdPyYHkvZFWfYEp4Xe//iOUUlkE17ZgcIxCYzLgy5EilIuPQKPRYGhoqOfBq35AEp3IQFur1y1k86QoCna7HSMjI7wednh4+AxBJhVCIVpo4ogR8Lnx7N/+ASZHjahWWWjpOo7Wv4T68ONI50qQyWQwm83n1tYhyPC/XXsP1hMh1Oo1LBtGYJKr4HK5kEqlBjKwpVarcXx83PFnJBJJX8ELR0dHgn1M8/k8dnd3MTw0hP/nB34Wf+55GaVaFY4JB35q5BL2tvuLR29Gc/QrRVF41D4Dts5BSr0Wb61Wq7GwsHDOXcU6Mow/Ca7Cn08ifuKH18XhWz/6AX7t0XcL6gBeBD8Me/C5o03QWS9ovRbmPIcPDy/1NQeTSqV6djLyqmr43He/COv8FLh6HV/88ffxGyuPt5U4xONxqFSqc/fJfcnBfbQEqTqIxWK+8tPP0MlmNoKXuDiY/RxqbA3rsQBOjqN4t36yJ9/ORrjdbjgcjpavhcSntiKgFEVhaWkJgUBAsK7WaDTyOt5WODo66lq1AoCtVBg/iR1CrlEhcxxDPnKClyxmfGjs7V1/V6VSoVgsdv2cDg4O2tqGAYORHrSbci0UCm03BJqmsbS0hGKxiIODA3Ach8nJybYVmUFE4BIj/FQqBZZlodPpYDKZMDU11ZG8Eb1Wc1VCpVJ1JItk+IlsUltbW6Aoik8Davec5ADWS3XKbDbznrVms5kfrOkWg8uyLPx+P5LJJMbGxgSb5IdCISgUCsFtYaIfFUKuW4GWyaEeMqFSZGAYGwYlk8LoHMPM2CyW5i5uxycUJBykU2S0UIslAoqiMD4+DrvdjmAwiJs3b2JsbIy/H0s0hb9Y/SGGx0bxkMUJU5fhQ7OSg3PEiDvuIL727C289/FrYJgypmwFXOuSlKiR0XjL8NluzvLyMgKBQE+2ce0gdAahn+CFbDbb9cDEcRy8Xi8KhQKWl5dB0zQcAK6Zx1DlapCJT5+HtY3zRL7fAWKybjS35kUiEaQiccvfaXRXKRaL+MbGS3hl6xXQOi3S0RiqlQrYsWGU1bJz19ggK7X5ahl/5b0FtcWE1GEIhXgKWaUCuSvqvg6MvToZ5atlfCfihto2hPDuASQiEdRDJhypgfMlq1P4fL6W++59QnsfHSGTyfgWcD8V2vV4ECqDDlH3IWK3dwEAeaMO/+JtH4RM0vuFF4vF2kaTAqeLaCKR6PgYRL8kpNXVyRuVRPsJueljpRzqHIdyroD9b/8Ylz/5PigNWpww+TMDJa2gUCi6moczDAOWZbsSiItID0iGe6tNR8giplQqsby8jHw+j4ODA1AUhcnJyXPEtZ8I3EqlwutgiaG3yWTqaRiwHZkFhFWbgLObVKVSwdHRUVu9ba3OYZdJ4MXtEBYnpvCQZaKjtVojSMfB6/XyhzOVTou/3/gJwso6ZvUWWBVa/rPx+XzI5XIYHx/vadMuFostAyW6YXZ2FltbW7hx40ZPvwcApWIRjkQNRb0GRqcdLMMg4QvggeXHe36sfsGyLJ9016kFL7RC2+r3HA4HxsbG4Pf7cfPmTeQ1UvzV8R0kDoIY4pL4dmgH/+LyOzCi0vGvqVkrzKQDqCYyMBnUuL48CZNBi2qthot0XMfHx6HX63H79u0LVS57+Wx6CV6Ix+NdXxM5eI+NjZ2rNotEIp7MAqdr/MrKSt9E/qL61kqlgmKxCKZeAyWmkAkd4+D7P8HKx59GPpbE2sY6srrT/a758xxEaz1ayuJ4y41SOoedrz+HlZ99BpaZCcSZ3q0A+7FczFVPZVdclUXwR6tY/OCTUJv1yFZay7FCoRAsFkvL5ymXyz1zlNcT9wntPYZMJkMulwNwerH0mvIloSiw5SpYpgSlxQiZRgWt1QyJuPWptRMYhoHf7++oV1UqlQgEAl0fS6/X4/Lly9jc3Gw7aEPQrg0YCAQEG4RTmSJO3AdQmgy4/gsfRtofgkylhEXR/fNUKpVIpVIdf8br9XaszvKvow/pAbGK0Wg0A7GKUavVWFlZQTabxd7eHqRSKaampvjPtyQBXvG5sCQ/dXqgRKJzj0GmuU9OTpDL5SCRSGA0GlsSZCEgE8TtNqVegjEIZDIZnE4nnE7nGb2t0WiE1WbDZw9v4uaxB9VMDq9UTnA7cYRfWXgMohbvtx3IYNWLr/wEX2eC2PcfwCRNQyqW4OcnH4A6c+qPPDExIUgCwNXreCGyj4PsCVRiOSwnJTx4uXftHple9/v9Xe17GhEIBBCPx/Gb7/4IXkgcYisZhsIoxVtWnkQpEEVebbzrtlKVSgW3b98WHEN8EVJBURScTifGxsbw61/5I5wkE2ByBTD5HIrlGv74+W/gmeFFnihoNBqoVCpeK8zVVnCyUcSdLRfe+/brUNJyQKZFRWHG6uoq1Gp12+jdTiC2ccT6sN/EMiFDtQRCgxfC4XDLOQHg9Lvb29uDSCTquV3eSOSFOAk0zhEI1beyLIt0Oo1MJsM7b0gkEuh0OlyyO/F8JQJKIoFxchy1ShXGURueevDN0MmEuQP1inw+DxzsQyqVQWwx4eFf/yREAGLeACzO7nMhzehVPwsAEoZFfj+AupKG8/GHQGu1qNXrcGrPf/4cx+H4+LgtB+A4rqf18/XGfUJ7D9B4QUgkkjOSg6Gh3iZhH9CN4hvPfx+msVEorxnAlhg4U3VwNQ6UpLdN0uVyYWFhoePC0ctwjEwmw7Vr1+B2u5HL5dpu+Hq9Hul0+kybPpvNQi6Xdz3JJ5NJHBwcYEyvx4ff9k68EPWePqbDjqslBQzi7id6tVqNUCjU9u8ZhkG5XBbcEu5FekCIXqdKTb/+p1qtFleuXEE6neZtYU40FP7C8wriB0GY2QiWDSP4taW3QCyikM/neRkBx3EwGAywWq0XNkXvRmaB/itxBM162++svYRnd38CuU6NYjoLjd2G9UQQe5kY5vS9RVLo9XocmWU4/LEflUIJ+ZMEasUyfs8TwO8/82mYTCbBj/UXnlfwo6gXFERIBcIwaHW4Jum9ygqcEoRbt27BarV2vT4a/TVJNfid9kW80/7a0Aejs+DOnTsXSkbqBqKfvpvP0QoSiQQSqwEGvQq3/uxLKGVyGLk0C9Yo79hloMQyKKffDVm4DL3VDKnSCM34g6Akckw4J5HNZuH3+1EqlXoOtiAx0BexPiTyIaGEulvwAsuy/JByM4h38kWqyoTIN2uJWa6GIluFRiqHSCTiuzmNcpFWrzWbzSKTySCTyZwhrzqdrqXzxs/KgL/03oLKbEB69xC/+Pgjd4XMxmIxhEIhyGQyzE5M4p9bfwq/89XPQTdqPdXqU1rIjtLIanqTDSUSCcF6X3L4AIB/9d6fxR/tv4SQ5wDgWDw1uowbLXzMfT5fR6cQgvtDYfdxBuSCkMlkqFarAE4rtL0Ql3w+j3LoBP/rM5/CX774PeiGbLg27MSD6uGeJ1tJpvigqzMkhi8UCrVtN+n1ehwdHZ1ZuNq5CRDk83ns7+9DLpfzCUvTmMabbFNIlAsYVuqgqVG4fft212GIbiTd5/MJqs42Qoj0QEgrLV0uYifkg0rWe8WdQK/Xn5rHxyL4X776JxAr5ahVK2ArLF72bEMdzWNZa4VarYbJZMLY2NjAhoGIZZqQgRSil7yofs1sNsM2OwkDG0bC7cPO156D+NX385OSGjmjsGGXRtw+2ADLsgjd3kXss1/G9U99AKxKAbd3HzKfj7ccEovFp+Sp6b8pikK+VsH39jdBiUTIRE4Aro76uAo/jnrx7rH+tKvz8/PY3d3tWNknEZ7dKqI0TePy5cs9VU97ASEp/dj7DQJOjQl3kl6MXlnA0MwEFHotLo12H3wLhWNYefOHW34eWq0WS0tLvMfwxsYGaJqG3W4X/Pk5HA7odDqsr6/3TPT70Yh3Cl5odQhnGIbvIAkZcOwGIkEIhUK4desWEkYpvhLeQa3OwShX4iOmeXDJ3BlpUiN5zeVyvHWVRqOBTqfj7ei64S3DM3hgyIFMpYTKZA7VXBkYUKI1y7I4OjpCLBaD0Wg8s9cNJRL4t09+AqyGhkZGY1JjRrVa5b3RhQZgFAqFrtdHo7tK4338O8YP4CX5GqYcExgztfZqv4jO+Y2A+4T2HqPR5aAXfQwhCoQMseNXzujplJeU5ybl24G0aIS2u/uJT7Xb7dBqtbh9+/a5RVur1fInSaCzmwDDMNjf3wfHcZidnT33M06tGU681kqZm5u7UKoaidzttSLRSXrAcRw8Hg9Ylu3YSnv+2IPP799EJhyDTEnjUypRW6/QZnAcx0ftVioVlMtlHCajgFiEpC+IO1/8NqaffitGZhyQzOjxwLKwAaZe0AuZBYRpmYXCwEmQ8hxCZTZg+YNPYWh+EiIA77z+NtiUvT9+yCxFzL2GSQCWqXEozXpMzEzj0QcfAgDeFJ78aTSOJ1Wvk2wK5Wwe5VwB7m8+j7GHVxCv1+HKU5hnldBoNNBqtT3pC9VqNRQKRdtuABnaEXr9y2QyXL16FRsbG5icnLzwZDoBqdL3alE0SHzSeQP/emMT2hEruHod83ob3u/oLAtiWbZr5DbwmsuC3W4/I39p9P7tBCLR6pXgqNXqrnKpVmgXvBCLxc6sVz6fD4lEAvPz8wM/hNjtdkTqDP7b338eatsQaJ0GB3v7+H348B/e+UneNaVf8toOConsNEhHqcPNmzcv7KGcz+f5Kj2Ji29c0yuVChKJxDm9O+lger1ebG5uYnFxsePrELLnEl9Zq9V6bihVLpZgVGOARtz6s/N4PB2LSIMoNtxt3Ce0bwD0Wr4nFRdCFFpdaM02Wu3axizL8o8lFP3Gp2q1Wn7Rtlgs5zwnyftoVRElPp25XA7T09OCn1ur1WJmZgYbGxtnIkab0Y6k+/3+nquzBHq9HruBA/y7H3wJOQWFIVqDD4+vIOENdNUVHxcz+Pz+TdQBVIslKM1G/M3BGqY0ZlgkyjNElUgiGqvMFEVBLpeDpmnI5XKoVCrMqCZAbUmgtVnw4C99FEMzEygkMiiFYtjC6Xci1N+0G5qvUSEQaovVCeSwUC6V8KtPfQhfDNxGKZODWCTCz8w81BeZBYCnhufw3R/9ECKnHXKtGpV4Bs/oXlv8iSVUp/c6zI1iKLyBcK6IB37xI8hH4jDNTuDtsw9BIz71kQ6Hw6hUKqAoivd+1Wq1UCqVbb+XmZkZfPkH38VRdBusCLhkHMGbTBNwbW/zdn29gLTCNzY2wHHchX1Tmw/f9wonh0H8n+/7eXgiIaiVKiw5JrvqAf1+f89hGkT+Qjy0XS4XgNfSyNqhV4JDnquTXKoTSPBCGRy2y0lk8lnICkVck0j478xqtfY1eNgOJDGL/Lkd9oHWaRFc28bB91/B1JuvQWU1wRU4wPLYJIaHh+9q1KrT6YTP5+vLRq1RVtApyKEbUZyamkIymexaoU8mk22DkxiGwe7uLuRyecfDaztpVz6fR61W67ivkqSzu+1jfhHcJ7T3AGRj6oc4EM1o40XbLvKW2Gg1t/vr9To4joNYLMbu7i6mpqZ6WjQ6WXd1Q6OulrQfSVwmMfMul8v8Td3YPnE4HH3pOfV6PaanpzuSWvKeGhcTlmV78tRtBlOr4svFQ3j2XDBMORBLxLF66xb+z/f/PEbMZ3WclUqFJ6kMw+DWsQ9J/xG4KgvPd1/E1OOnlcDnSj/Gg6PTZ4iqwWAATdMdv8N0Og2fx4OfWXkMX417kDoMQULTeGTJiU8vvxXlEoNoNIpAIACZTMZ7lvZzjRIy22tVXKjTQTuQ6sTY2Bh/nVwx2bFK38Fj1x6AWto/mfLs7OLfPv0zOKEqyJWKKIdiUBSrSKfTgu+DTDKFdynG8PySGulaGcxJEu+xzOGqdQIAzpAdjuP4ifujoyMUCgU+iIVEy5Jqri+fwNcKhyiFs9A7RrF+uIfVmhq/8dQH+66qEa9PQmr7jU/t52BzNxCJRCCXy2EyGlF4dZ3pRmY5jkMymey7BUts5Ww2Gx9H7PP5oNfrMTY21pbcT01NIR6PC5KN9RP40fj6HPMz+M2//kNIR4bApDMQ0zLkXqjgim5E0AGkkZySP9Vq9cw/GyGRSCCVSvnDn0IshUypgHbIBOdjV2B/cAVVpgwxJ0IgEEAgEIBCoYBarYZKpYJarR7oochsNuPw8LBtLG0zGj2mm2UFrSCEKAKnA3tqtRpbW1swmUwtBz1TqdS54CSO4+Dz+ZBKpTA7O9u1GNDOBm9/fx+zs7Mdf7dSqUAul7+hq7T3Ce09RGMEn5BM9Xg8jsPDw3OkLJvNdnRHsNvtUKvVuH37NjQaDQ4PD/lWWj9tRSHWXd0wNzeHSCSCtbU1zC0u4FbhGN6frEMpkuL9C6cVATKEMDw8LNjTsx30ej0mJyexsbHRss3fitD2U51pxH7mBOkqA5XNjLXP/x2GZpzQDVvw7OYtLGlfI7SkuieVSkHTNKRSKexmC1RJEyiJBFOPP4Sh+UkAwEPLD2LR0Dp6sxVIBb5Wq+Hy5ct4QCbDpN+CXU0ICzMzWNDbQIkoKJVK3jGAYU7J7dramiByW6vVAJx6Krc6cAlFP04HQOfJazkoOPWWi5HZV50TTEYjTACgBzaiWczOzra1IWsGSep795vehqdFIuSqZVQvlXAcOmr58xRFQavVntugKpUKbytFqrlfDdwBU8wh7g8h6vFiaGoShxNaKFUXa+1TFIUrV65gc3MTLMsKNtonIOtVv3KfQaFSqSAYDJ6Z3BbSFQuHw7BaexsgbIfGOOJ4PI69vT3+M211b5F5hq2tra7dnIvg2YgH9JgV8QM/MscxqI16/H2RwVMzVxCPx8+R08bPjcTVNq5bNE3zBy2ZTNb1ezeNWPH8sQcVgw4KjQoyFY0nFq7irXMP8T/DMAx/zUciET79TyaTQaVSQaVS8V2MfjA5Ocl7f7dDo6zAbrcL1hLv7e1hfl6YTIwUe3w+X8shwebB6lgsBr/fj9HRUcGHLpFIdM4mMx6PQy6Xd/38GIa5p4dSIbhPaO8RSHudLBDdPGhJe6MVGWsXedsIvV4Pp9OJz33uczAYDFCpVDg+PoZWq+Xj7IRCqHVXN9hsNqhUKvzbr/45juk6iidxoA74uBw+FpyG3TI8kCEEAqPRyJu5N3sxqtVqZDIZ/r8vWp1hWRbRo2Oc7PlefcBTwidRKjA+PYkb4+0XTwAYrtfx5koCL8cOQYlPX+dV0xjm9cIDG8iC12yRo2CBt00uwWxo3f6kaRoOhwMOh4MntxsbG2fSpohEY319HdFoFAD4Kkq/BKYfp4NIJMJnpLc6mLEse6FFOBaLoVwun6vS22w2nJycYGlpCdvb2x3fcygUQjKZxMrKCn/NaWU0IKPhP/D15GJBkqkav8+bdAGHvjLKuRKK0RMY7XbE3D64hnZhMZmh1+v7/gxIfOrW1hY4jhN8wOu0XvXzGi6C3d1dzMzM9NwZ62RfdBGQ769SqeD4+Lit/ReRjXk8njPdrGaQiOd+KpdppohyLo/EYRD+H63jxj/4ELh6Hcl8BgblaSeAkFOZTDb46lyZxU+ZFxBfVsEfDGBEocfHZh868yM0Tbd8b5VKBfl8/gzZ5DiOj2omFV21Wt3xdesNBvzlT57F5xI7kCpkeOvwDN42PAuRSCRYVtAKsVgMKpWqZ6LtdDqRTqexvr4Oq2MMX4ntwp0II394jF8fN2NBacbe3l5fa22rCq3P5xMkOWwMVbjvcnAf5yAWi/kbMJ/PtyW04XAYsVisrSG20OSQTCaDyclJBINBfOUrX8FHPvIR1Go1ZDKZnnRyF2lzNaMg5pC2KlE6CMHzg5uwX55FXEkjP3MVU5ODn7Yk77OZ1CqVyjOJZeTk2wtYlkUkEkEsFgMATJhMmJ6bRa7OQkrToDVq1LIFKOJ5VGydW1wikQg/P/sILhvteKkgx1XnJTwyOtPSM7YZlUoFu7u7kEqlLRe8XC4n2Lu0kdxWKhU+SpKiKL5aIpFIkMlksL+/jyeffPJC1TihvppEM6ZSqToeeiqVCsR9eDIDp1WZQCDQMvTAYrFgbW0NDoeDN6xv9XN+vx+5XK6tjnViYgJ+v/9C1mhTMj2+cxyD85GrYDI5mJ1jmNNZYB8eQSaTQSQS4QdrDAYDdDodtFqtYHLSTGq7DSx1W696xUU2z3A4DLlcfq7l2+0xSajL3WyvymQy/t5Kp9M4PDwEwzC8TIG4Y8zNzSEWi2F1dbVlN4DMNPRCaBmGQTAYRPXgGGyVhdExBpPTAf2wFRaTGYtTs3fdb5RE2T509QZomkZldAm7u7uCw09kMhmMRuO5gywJyMjn8zg+PublOkSX3kh0JRIJvh1y4RWkUDxIwei04/PulxHxhzAt0cJsNveV6MZxHPx+v6CUy1bQ6/VYWVnBP//yHyMhqkKipMFIgf/ru1/CJ8au4J03HumrIk1R1Jm9OxQKwWw2C3p/1Wq1rYb3jYL7hPYegCwURHIglUqRy+VaGia3qu40Q+j0ISEa1WoVY2NjiMViyGaz9/S0VaxWwGTyqHMcMr4gLEuTYJkK9rZ3MFmWnVl8BtXuIBGqjaSWVDmA088zHo8Lkjk0k1gyhEM+639pHcJfem9hJ1uCSa7ErzzxCSirddy+fRtWq7UjORCJRLg+NA6lo4Ax/YggMktkGp1sl/pJmwHAVynGx8dRqVSwtbWFeDyOtbU1SCQSvOMd77iwFIVszp0qIYFAALFYTNDktVBtXDNYluW9c1vdWxRF8a4MRqMRxWIRz956GW5lGbkKg1m9FfNVBepsraOJvdFoxMHBQd/fSSAQwFCBwy+/44P4pn8LsUwOl4wj+LnZR6CSys5cA5VKhQ/LIBHJKpUKOp0ORqOxKyFaXl7Gzs4OfD5f2yCAQCCAbDbbcb16vUCS5PqpsvYS6jII6PV66PX6tvZfFouFj2Nudq5RqVQoFAqCihLxeJwfIrPb7fiH7/kwqPXn8L07t6AbGUItmsavv+VDr4t5/s7OzpmI9UEVSiQSCf95NoLjOBSLRWSzWZycnPDSu7/e/gGKIg5HGztIBkLQWS1Yd1D4qXc80fdrCAaDsFqtFzrcF1FDedSA+vEJXvns38K6NAPHjUtgRvqXV1AUhXq9DqB7iEIz+vHJf71xn9DeQ5BqFKnQNssGGjeHduhlI7TZbPjWt76FoaEhSKVSWK2n3qN+vx+pVApOp1Pw5t+PdVcjSIUglohDyVFQTjtw7WffD5GYgmnGgfddfjtsEiXy+TxSqRRCoRC/2A1iSIAMuWxubp7bfEOhUEcJR6VSQSwWQywWA0VRMJvNZ0hsI4y0Cr++9FbkHdcRDAb5mM3r10//+9atW13F/I3Wbu1AKpbdvCIv8p01vyaFQgGO4zAxMYFUKoWjoyMUi0UYDAYYjUaYzeaev5tOhDafz2N3dxdDQ0OCJ6+r1Wpfg1FbW1tn0tVaYXR0FEdHR5ibm4PEqMV/f/5vAJkUaqsJq9t3cMk0in/9rk90fa7x8XH4/f6e5C2kukVstgDgneNLuK29jatLratCjXpognw+j3Q6jf39fb7artFoYDAYoNVqz10rCwsLcLvd8Hg8p7ZLkQgAwGq1IhqNolgsDpwI9pKG1QiXy4W5ublzv9ftcYSGutwNdLP/IgO1qVSKf29qtRonJydtH7PRH1Wv12N+fv7Mdf2YzIqn3/MPQClkiHoOoa/3HpneKyKRCC9hakQ/vrpCQT6r5se2VAPwud0oZwuQqpUYmp+EqktceieQ/eGicx8SEQUmV0D+JAmJXArtqAX5aAIhyT5C9DAsFkvP12ij5MDn82F0dFTwfVWtVu9raO+jNQiRJZPLzS0jn+9UW9dtc8jn81CpVIKe0+12413vehdyuRwODw+h0Wjw2GOPQSwWIx6PY3NzExqNRhCx7de6K5lMIhQK8Xq8mZkZOAuL+C8b30VSpYTeYMBT0mFM608XulYLW7FYRD6fPzckQNP0mSGBbmTKYrGA4zhsbW3BOTeLrdQx8iE3qoEonnj0sTM/2wuJbYXmgSeSNW+1Wvl42pmZmZaPJ5VKO1YueqlYptPpnuOVm0FCLQwGA5/qUygUUCgU8Na3vhWjo6P84Eu5XIZSqYTJZOoYMkGg1WrPOR2QSd5MJoPl5eWeSHI/FVqv18uT8k7Q6/XweDwAgB9HvdCODyO660Vs14uhWSeCKg6ZSqlrEhGJsHU6nYI2F4ZhWnpMN1ZfhIJs8EQbS6JDU6kUDg8PwXEcaJrmK17EkmpjYwN//ud/zg8rPffcc7h06dKFN/FW6IfQhsNhfh1ohU5dqcPDQ0xOTvb8OgeNZvuvra0tnvBWKhWsra1haWkJa9kwvrH9IuakOTwxMocx9Wmnr5s/KgDeWWX8VdcV/bQUh4eHd7U6XSwWzw3pERgMBiQSidcteCOZTMJ6wiCs02L8wWWI5XJU8kU8NnlePiQUXq+37yhjAoZh4NvbwwQrR04qxcJ73gYZTUNnHcJHlt4OFE4jjFmWhcFgwNDQkCB9L+kK9xOiQNbSe9156YT7hPYeolFy0DhB6PV6wbJsx6lLgm4OBwTEsJtsQJOTk/D5fLy+kAwqCCW2vVh3sSyLcDiMaDQKrVaL2dnZM6RkRKXDP5p6DEX7DTjHHbh9+3bHU7pSqWwbupDP51EoFBCLxc5Nw2o0GqjV6jO/a7PZEC/l8T994Q9RBAtE3VDSCkznFzFKay9EYoWApmmsrKzwNj2jo6PnJpob45Eb0U/FMpfL9a2DahVqEY1GsbOzg1wuhxs3biAUCmFoaIivMgGnG1g8HucXYJVKxRPcxs+yxFbwN6FNvLD6Mibz+/jgxBWMi1XweDw9TfI2oteqQiwWQ6lUEryhG41GxONxsNyp04Nq2IzjO7tQW4wQUSIwlYqgaM3h4WGEQqGu+lRig9XOzumi8iGJRHJu6KxYLCKdTiMYDKJQKICiKOzv76NQKMDr9fLT7IPS1Tej12HBblKDTo/HMAw4jrsnSWbt0Mr+K5lMQiqV4ve+/lfYpcvIZeJIR9V4OXKAXxy9hnrqtEDSbZCp2WdbrVaDZVkUi8W7EoDBcRxcLheWlpZaEiOz2YytrS3BGv9+wbIs3G436vU6fv2dH8bf7ryMFzgXtBYzHHkR3j7Sn6Y9n8+jXC737d3McdwZv/VftgzhS3deQkIJsIkcfvHyk3BqzIDhVDLCcRzS6TSOj4/hdrshl8thNpv5wd0zr63K4LtHOwiGw7BH/HhisT997xt1IAy4T2jvCRqnbQPZBJ4Nu7HjuQMsjmG8IIJMKhM8JCIkxWp7extarfYMUVIqlS0NkoUSWyHWXUIqBAS5XA5DQ0MQiUSYn5/H1tZWz4beZBq2eTFpnIY9OTnh3zdpr37raBsl1JCNxMGxNYgnx/A7X/sL/OrSW89pYi+CTtPIZrMZRqMRPp8Pa2trmJ+f5zeUbK2CSCoOg9UClVR2oYplJpPpa9iNPF9zqIXVaoVKpUIwGMTw8DBMJhNu3759hnAplUpeewucHsISiQRfqScazs8G17CfiyPHlHCUTeC3//7z+LnpB/HktUf6bnX1IrEoFovw+/09aS5HR0ext7eHK+NjeDa8BwklwfiDV6G326BlOATd+4hKpbDb7R3v05GREayursJut7e9RwKBAJLJ5Otug0UOkGT9IN7QSqUS3/zmN0HTND7+8Y/zCX+DRq+Etp3UoBHtHs/v9wtO6boXaLT/ip7EsLb2TSRdEWSPT8BRAFWr47mqHL/51vd3vUZInGzzXkOKHUtL/cUxd4LH48HIyEhbskykbHcTZM6g0RllRWLEB979KSiVSng8HpycnPTlvby/v98xRKETQqEQjo+PMTY2hpmZGXAcB7fbjV97/BlQFIW1tbVTMtsAiqLODMYxDMNX81mWhclkwtDQEOoyCX57/VuIZ1NI+49QF1Ggxyx4xmTq67X22gl6vXCf0N5DREtZ/KH7x6hLxAhn4vjj576OR+zT+Cdv/5Dgx+jmcLCzswO1Wt1yke6kg+1GbFP1Cl7w7yCnl+OScQTiVydTSXssFAoJqhAQ5HI5vgJH0zRMJlPLrPF+0G0aNrKbRh11+G9uoBRL4tFf+xlI7GbBUcBCQZKw2hFQiqIwNTWFYrGI3d1dqNVqrIrS+M7+JorJDP42d4CfHlmBOH5q09Zqqr4berGx4jgOoVAI0WgUDoejbcCETCbjvWhlMhkuX758jtQ2gvirOp1OvsLgPz7Cj2++DFAihNa3UcoVYJ2dQMasvJBuS2irmmVZbG9vtx0CaweapsGyLBbVJnx67lH8j7UfoCqVYN5ow8/PPgK9XMm3WL1eb9soVKInjEQi5yr0pKoll8sHfk32AzItXiwW8eijj2J0dBR+v1+w32avIG4wQtBNagC019CyLHvO6/ONCpZlUWVZQCKB0myA70c3YZl3Yuz6MrRmYcNIR0dHLQ+3Wq2WTyAcZIgB8bXt5qmrUqkunBjYCmRd1el0Z4orJCackGyn04n19fWeUxOJn2uv1X2iYTeZTGdel8fj6TmWl+y54+PjvPVkMBjENz3r8KVDoJRynPiCmH7bQ/hGcAtPjM5DJX1j62J7wX1Ce49Qr9dxMxFEjauhWmERde1haM4Jt5QBU6uCFl9cmO92u3nbpVbQ6XRIp9Md2yOtiG1YweGv/euIeQ/wkjSLGZ0FvzL9CCJHYaTTaVgslo4xs63QTDwcDgdWV1dhs9numhCdTMMuT88ivsdg9q2PoA6ASWVhsvUfqNAOGo0GqVSq68lfqVTi2rVr+PbWLfzNi98CbdShWqkg6vPj/73vx2c++mvQKoXpphvRS7WSeNhardauXsDN7WaZTIZLly7hzp07XZOOSIVBolZiKDkJjuNw4jmESCyCVECa06AgZAisHSwWC8LhMB4cn8D4lXeBZdkzfq1KpZInSY1RqMRUn2B0dBQvvvITJGlAJpZgSmNG9VU3iWa97L0CqRoZjUZcunQJW1tb0Ov1GB4ehtlsxubmJubn5wd6zwqt0JJ2fL/escFg8EJBKncT5OCXSCSQyWR4C7ZLM3NwB3y4+tPvg1ShQB3AkoDgFVJ4aPdZkSqtENmbEFQqFfh8PkHfjclkQiKRGBihJRZaiUSi5ZxBPB6HqaFSKZFIYLVaBUmAGiHUz5WAYRjs7e1BLBZjZWXlzD2Tz+dRKpXOHK6IC4TQe4vI5MxmMzakeWgPywit7yB5EAT1jjcDAIpsWRChvaif9+uF+4T2HqKGOrgah0ohh0z4tSlVlqsBAghtp4vb6/VCIpF0FKfrdDqkUilBeh9yYwQjYfzXr/8pxIrTyhSTzeOlvUNoj3P40PU39xUT24poURSFmZkZ7O7u9pxF3yveZZ3Dj37yEsxzE0gdHmF8ZgpvoswDqxATaLXangIp8ioxrLNOHLl92Pu772L5E++BccKODFeBFr0TWiF6a1It0Ol0glvbrQgHTdM8qRWSpKWV0Vg2jGA7dQzr3CRUFhMSBwEszj3W8fcGAaFDYO1gs9mwsbHB25l1WviJywAhX36/H3q9/nSQjmPwp6F1cIkt0HotrHU5npIO4+qllTeEpjObzcLtdsPhcMBisaBQKICmaSwsLECv10MsFiOdTuP27dv8zwwCQgnt7u5uV6kBQXPLtBervtcLRCKVSqV4ac7Q0BCmpqb49/hLOjX+D18IpQk70r4w3jt+CY9auw+0RSKRjul/er0e+/v7fdveNWNra0vwd2M0GhEKhS48WAW8pjkfHh5uK2GLRCLnYl/tdjtWV1cxMjIiaA0MBAKCXQeIhIvoZFsR993d3XM6ftLh60efO60dwjdyRajMBlz5+HuRDUUxPuWEUS5sH2EYpqfwpXuF+4T2HuKSaRQ/OdqH2myGdWEaqHGQH6Ug5YRVpdoRFJ/PB5Zlu7bO9Ho9Dg8Pe3rNYo0KpjknsuEYNv/q65h7/5NwXF6AbmK8byF8u/eh1+txdHSEeDze92N3A8uyCHq8+H995JcRquRwG+t45pEnoZLK4PF4sLW1hcXFxYFMdvaqD9PLFIBYDIVKgSu/8FGI63Uk9g4RVHmgmDiNLO7ldWUymbaEtlgsYn9/HxRF9azLbYdeSe0vLzyGLx6s4blAFE7rKJ558GlUgzGERKG7VjmLx+MoFAoXOjRJJBLQNI1isSjYJqxRC5lMJrG/v4/f3/w+ylIKxXAMbLmCRKaAxTeP4c1vADJL8uIvX778muwolcLExMSZ6pZer8f169fhdrt5542L6n2FENpQKASNRiN40rsZhODdSzAMg3g8jmQyiUqlwg9Pjo2Ntf0Mjw/8+PfP/BzkSgU21Gt4wHFJ0HOFw+Gu8pWJiQn4fL4LSzCI1EZoxbVVmlWvaBz6arxmm8FxXMvYeeJC4/P5uhZpWJZFNBoVVH0mOtlOEq5QKASTyXTuNWk0GuRyub72wgmRCldlJuxO6kBRFMR5Bp+yX4FY4P7ReLC573JwHy1x2TKOZ8Yu4Yd5P1AHbixewkeGl7G5uXkurrQVcrncOYLi9/vBMIygVlE/UaNGuRLMSRLlbB6XPvo0lAYdUkdRWOcf7ulxGtHqfRDMzc1hfX29Z/ImFKTVrFWpsahSgzEc8y2YmZkZxONxrK6udm2dC0Uv/r2P2abxg0MXTspVWCbs4Op1fPLht+OKeQrHx8fw+XxQKpUYHR0V5DaRy+XOaeYqlQq8Xi/K5TKmp6cHXgnshdTKxRJ8cuZBLBVkr3kDD9mxs7MDt9vd88ba7XMuFouC26DdMDIygqOjo75ac0ajEUqVEqX9HyITjGLna9/H2KMrmH/qrYiU8xd+bRcBsQizWCznNNvpdLrlAAxFUVhYWOCdO9rFEgsFcYPp9Bp7jaltXveOjo76TnXqFyzLIplM8oOqJNa42QWmHUKhEHQ6HX/PKhQKQbrXZDIJjUbTdQ0ym818+EC/h5J0Oo1cLtez9luj0SCdTvdsCwm8FoctZA+NxWJtwwIsFgsCgUDXz9Tr9cLhcHTcn9rpZJtB4pBbXctarfZMmqVQpNNp+P1+/ON3fwzFWhWFahmaB6TYvrMFbmRC0L5aqVTaJpm+kXCf0N5DUBSFBywOPL10A3+wFsM/vnSaTDJqHMLOzg5OTk46tmkKhcKZAIBQKIR8Pt/TdGovRtaVSgW7Lhc+aL+M71hCiOx4oR8fxgRHQxnOgjH1N0SQy+VgtVpb/p1EIsHY2Bi8Xm9fcoZOIFrAxs1WLpefWcDMZjPUajW2trYwMjLSdaChGzQajWD/XrlYgvcrJ/DoWybBysRwakxYNp4+P6nuNZqva7VaDA8Pn6uEpMpFuFLH2Iv4MLkwBxle05XF4/ELE45u6LVS20w2FhYWEAqFsLGxgeXlZcGba2P2eDPIEFg7+6BeodXr8PkXv49svYJL8jLepbwEKdU6cpfjOGSzWaRSKWQyGZ4EKyFBjhLhgV/+GGoFBoVoAmZbbxPT/YYQtAKZBm93mOu20ZvNZuj1euzu7iIajQpuOTej28Hb5XJhYWGhpyjfRiSTyZYhEoNGOx2sw+Ho+SDZivjo9Xokk8mua9Th4SEWFxcFPU8/oR8ELMvC4/H0dVAgOtpeCK3QOOxGRCKRjp/F9PQ09vf329r4MQyDQqHQ9rDdSSfbCnt7e5iZmWn52vtJUstms/x3QFEU1JQcaukpMXU4HHC73YKKX81V7PsuB/dxDqTyQFEU0HCBUBSFpaUlRCKRjtXBxg0lHA7zEbm9gAyGdVtQk8kkTyqv6PW4lozhZQzhyqUVTGmHUCwUcOfOHUGn4k7voxVsNhsikchAE2TC4TBYlj2nkVUqledCLmiaxrVr1+DxeLC9vd3T5tkMjUaDTCYjaKFOp9NQyOR490z7AwoxXyc/HwwGUSwWYTQaMTw8jFithP905/solhkkgkG4Vmv4lOUSmEQao6OjA9MMdiNSNE1jaWmJdxLodvBpfhy73Q6lUon19XVBpBjorDF3uVxwOp0D8drk6hz+y/YP8ZNsAKV4CofaOlzZGP7ZypMQUxSfxpXJZFAqlUBRFDQaDXQ6He94wLIs3pmM4OsSCnLDabeidhTHCtfb9U7atRchtCzLwuVyQaFQtCUGjb7Z3V7P8vIyYrEYVldXO0Yyt4NIJGpLaJurlELR+Hi9ELxe0ayDJSb4jTrYfrC7u3uO+Oj1+tM0wg6ENp/PQyaTCS48kNCPXqftgdPuV7uwmG4wGo09zRv4fL62Q1/twLIsH2zUDnq9HoFAoO3es7e317JL0aiTnZ2dFfSakskkRCJRx/ujlwNrsViE2+3G5cuXW34HFosFsVgMyWSya0GjXC4P3HXibuA+ob2HaKw8tNqIbDYb9Ho9XC4XTCZTW7eCSCSCeDzeV7qL0WjE/v5+W40iMXoulUpnhoRoFnhofBbjutcSva5evQqXy4VcLjcQQX8jZmdn4XK5evambYVsNotIJNKyDUYCI5pBURTm5ub4jVkoqWqGVnsa1iAE+/v7PR1QGvPgk8kkDg4O8Acb30dGJgKkEtSqLLyb2/g7RxX/6qmPDlTCQUhZp81BqVRiaWkJd+7c6Uhq25EXo9EImqaxvb0tqKrcjtD6fD5oNJqB6bI9mRPspCNQDRlwtLED7cQo1kJRfCFZw7R2CCqVCjqdri2BrlQquH37Nt6+cgNvph/GbjoKqViMq4/YEfD64PF4BHcnyCG532ojObh2+3yFbIKNsFgsZ6q17apQrdCuQtuP1KAZvRK8buhHB9srYrEYpFLpOeLTnEbYCoeHh2eCFIRgbGyMb+ELRSAQgE6n60syALz2nXcjb2RQ0Wq19rw3CNVNT09Pn3pNN+0X6XQaYrH4HNETopNtBtlnu1Wzyf7UjSAzDMMXDzqtyfPz81hfX+/aoWilM34j4j6hvYcgJJbjOIjF4pYXDakOEsP9ucUFfDO8g/VjHyrRJMo6GqoC+5rmsEcQs/9WKBaLcLlcGBkZOXdjtkqckkgkWFlZgd/vF9weFhrdS+JTQ6GLDQhVKhX+1Nrq81IqlchkMm1/32KxQK1WY3t7G2NjYz1bKXX6vBsRiURgMBj6mjButGuRpLdR8fnh+uvvgdarsfKx96JmVg9cj0yu326vVyip7fT7V69exdbWForFYsdrgaTwNSIejyOXyw3MOaNSqeAwFETSF0KtXEFi34+xG5dAG7QYnZ/GjZHOG1qxWMT29jbm5ub4jdGqfG2DnJubg8/n4+UR3dCLZ2sjOI6Dx+NBtVoV5G6RTCZ7joeVyU610eFwGKurq2fecye0G6bsVWpA0Pjz/RC8RrAsi3g8jkQicUYHO2jrssbn8/v9bYlPpwoeibnttZpts9lw8+bNrjpRgmw2i3g83pdPdiNI97DVwYnIGarVasehr06IxWKC1gGlUgm5XH7uENdccCBFhG462Vbw+XwYHR3tet8Rp4NO32GlUuEtE7utr8QJye12d1xfek1cvFe4T2jvISiK4g3pSfxtuwvQ6XTCZDLht7/2OYTkLOpcHcVMGv/p+a/iP3z4Fy9EUFoNKoXDYYTDYSwuLrasKhUKBYyNjbV8PIfDAY1Gg/X19a7DVEKje8njrq6uCrZHaQbHcdjc3MTCwkLb32+XoNb8M9evX8fOzg5SqVTf2sBOr7Nd1nkviMfjQOAEYkqMxQ88BbFEjIz/CHpNa73yRUAqtEKgVCqxsLDQN6mVSCS4cuUK3G43dnZ22mrAqtUqFIrXYmcHMQRGBnkSiQQKhQIkEglsKhV0NgvEitNrSjM8BAoiTOs7V39Idalbtd/pdCIQCGBzcxPLy8sdr7VuA1StkM/nsbOz09MBrdGIvleMjIzAaDRid3cXGo2mqz6zVYU2EAjAYDD0LUEiZvq9ErxB6mD7QTezfUJ4WlVGL5KCNjw8jGAw2DWSlrgL9OLH2g4mkwmpVOocoSUe2RexhqtUKqAoSnDVfGpqCrdv34ZKp0W5xiJ3koDJZIJMJuMdYoTqZJtRLBaRyWQE6ZS1Wi2Oj4/b/j3Lstjc3MTMzIzg69FsNiMajXZ0E+KlkbjvcnAfbdAsOegm+JYqFTixKFDyhxF4aR0KqxmTj1zBi9EDTHXZPNvhqJDGX4ZvIxdZx9TIGD4xcQ2JwxAUCgWuXbvWcRqz041rNBqhVCq7DlPlcrkzg22dQLxp9/b2+pJXuFwujI+Pd7zRhVprEZ1zOBzG2tpaT1ZX3QbxSIxsvwtHLBbjW37/7OlP4D/vPo+A1weFUY9ppxMPySzY2dkZKBGXSqU9DSyo1Wqe1DZXWIS+prm5OYRCIaytrbWMJ65UKnwXgeO4vobACIFNpVLI5XI8gRkbGzvz/f2GUYM/cr0AUCJIKQqfmnkYw0pd28clrX2h1aXx8XFIJBJsbm527Mb0anlEDOd7OVgMwpuUpmlcuXIFoVAIt27d6qh9pCjqzBAKiffsV35EPjuhBI9ENQ9aB9sr0uk0qtVqRxKn0+laavTbxdwKBYlmHhsb6/ied3d3W0al9wquzuEHaT/+9vnvwHYyjcds03iHdQZ77r2O2m6h6NWmTSqV4mYpit//6mdAG3WA/wS/9YGfg9vtRqFQEKyTbYXd3V3BKXudZCWkYDMxMdGz1IO4Cen1ekEk/6K2ancL9wntPUQryUEncPU6KIqCdtiMaqUKrVSGQjSBw5IHt3KvfZUSiQRyuRw0TUMqlYKmaf5P48WarTD43c3vIYUKisksShyLf3FrDb/z3k/Bbrl4KhGRS7jdbmQymZYEqlt0bzOIN22vGj6fzweFQjFwr8mRkRFotdqeBuI6tY1YlkUsFutrWItMpRuNxjNJbf/2xnvx9+wLcEw5cckyDplYwmuBB+VwIORA1gxCam/fvn2G2PWyWNrtdqjV6pbDYo3Ea2trS9AQGNEfJxIJ5HI5UBQFg8GA4eHhjmTgismO37n+DDaULjx05Spk4vZLK4mGFhpcQUBM3tfW1tom8Qmt0DIMw2vze20Nx+PxvrWRzbDb7TCbzdja2sLQ0FDLCmDze3K5XH3H7IYLGXzdu4rjcBijYhU+PfuBcz/zeuhgewWRhHSrfOr1ekQikXP/v13MrVBQFNU1PSscDkMqlQ5Em/73wW18+2gHRY5FplzC37zyA/gULnz6re8ZyHBSLBbryUrsx1Ev1utp5E8SKJcYcJUyfusr/wP/+zt/+kI+veFwGDqdTnC3o5PjByke9fP5SyQSTE1NtQx0+P8m3Ce09xjk4pTJZKhWqx1/ViWVYUZtxos7L+PqJ55G0heCdsyGj1x5CguG1wgoy7JgGIZvqeVyOZycnKBarZ4hHdvpYwTDBxBJxDh47mU4Hr4C/YQdcTGLTirVXjK+iSdlu0pmPxPZjadJIb/bq26y14hBtVqN69evw+VyIZVKdR0E6NQ28nq9PQ1fcByHcDiM4+NjmM3mliRJIZFhUm3CivU1z0GLxQKj0QiXy3UhSyUCmUzWdSClFYhLAyG1DGo4KqQxWylBK1N0fwCcbuLEFowcKgrVCkLZBMYpZ8chsOYWMkVR0Ol0sFqtPQ0uAUCtUoVNq+9IZkOhEJLJJK5cudLX522xWCCRSLCxsdGyvSlEQ0t8Ovv1Vk6lUl1bz72ApmncuHEDfr8ft27dOrdGNG7iF5EahAsZ/B8b30Ixm0d0bx+eCTssgTt4enTxjA6WpmkYjca7poPtBz6fD8PDw11fTytrp24xt0JB0rPsdvu5a7dYLCIcDl9YN0vwk+gh2HIFSW8Ix5u7cL7pBuI25UDILMMwkEgkPR1OdtNRiACUsnlsf+X7uPFzHwJnNUFj1Pf9OliW7SuqudX+tL29DaPReKF4bKPRiGg0ilgsdqbw02qPfqPKDu4T2jcIhHrMPVYzQLJyA4F6EXqnDI/QI2fILHB62lKr1V0XfTZygOfrJzjZ80OmpKG2mSGRSdAtp0zoIFcjGiuZDucEfpw7wmrkAFn/MaROGy6bhA96SSQSjI6OwufzddUd5fP5nnWTZJK0l82MJGyRFmonLVW7tlGxWOzoadgIjuMQCoUQjUZhtVq7tuAaNVAEZIiP2MP1Y6nU+Fi9VmgJtFot5ubm8Kff+xpuyYtIHAbwLeoEPzX9AN4yLMyHlaZpfljsh/4dfK8UQnTHi79O7OIJ9Rg++bZ3A3jNA5YQWNJCNplMF24hdzsE+Xw+FIvFCw+kGY1GSCQS3L59+5xUoFOFlmVZ7O7uQiqVXqhlWyqV7ope1OFwwGQyYWtrCzabDXa7HfV6HcelLPzpGPQZ84WkBs+G3WA5Dkylivi+H8ohI/7su1/D6DUW5lddZN4IEcPNyOfzyGQygsliM+HpFnMrFBRFwWKxIBKJnJGQETnPpUuX+n4OhmH4EIZcLofIjhepWglsmYFYLkMpnUHy8Ajpmf7CFhoRjUZ7In75fB6pwyPEAz6oh0wYvb6MWpWFRCyGjOqfQrnd7r7WHCJZI501t9sNpVI5kDTFubk5rK6uQq/X89fPoOKPXw/cJ7RvAHAcB4lEgnK53PHnPB4PRixW/Ob4a+3otbW1niqmjVgyDKN6nIJ+xIKh+SmkvH7YTGbM6ToPDRUKhZ4JLfCatdfvfP0v4SonIFUrUUEFf+B6Hr+5/PZzxLwTRkZGsLa21lGLyrIsdnZ2el5oCaHtZ+G02+3QarW4fft223Z+u7bR/v7+uUzxZpCBsVgshuHh4QtryYDTKWYypNOrpRJBL0NhrZAXc3hZlELKG0a9BnCo4/P7r2Baa8aISi/oMSQSCcwzDvzOV/4ENbaGSrmCVDiC743UMee6A4qpguM46HQ6GAwGOJ3OgVYaOqXp7OzsQCKR9BR60glarZbXIDdKLdodLEimfT8+0Y2oVCp3te2uVqtx48YNeL1erK2v4WVRCq9E/SicJPDZOy/gf37HR7s+BulOFYtFlEolMAyDcrmMHe8mYukIom4fTjw+OB9/CAbHKJZWLoGWvHFz6nd3d3vyySXuAKTKJiTmVijGxsawurp6htC63W6MjY0J3oMYhkE2m0Umk0EulwPHcaBpGlqtltcm/8ywBn/w3Fcx8dgNFJNpGCbG8PToEqLRKDweD/R6PYaHh/s6gJycnHQ9HLAsi0gkgkgkAoVCgQ9efRNCWiCfyUEqlUIkEWO5KO9a/GmHdDqNer3es9yrXGPxfMqPoPcm5qZmsFhTgqYkA7PJJHMqu7u7/MG7U0DNGw33Ce0bBN0IQSQSQaVSOdfOJh55vVZ9WJaF+842/uVbP4jv5wKIlrKYmlHhKfVU18U9n8+3jQvsBpGYwpFJgnoY8P7wZVgXpiAC8KPIfk+EFjj10Nvd3W27OJFpz17JvlqtxsnJSU+/0witVst78qZSqZZV5OYqSjqdPk1y6UDO/X4/ksnkQAMRGl9PP5ZKBBKJpKtkphMC+RSkaiVovQ43P/slUJJTovnt0vO49Go6mhDyuREPoloqoxBPYvWzX8bKx96FOgckJsp4YqW17nRQKJfL57RwHMfB5XJBq9X2PWHeDmq1mpdaEPlA88G4nY90v+hVu94vpqam8E33Or7zwx9DrtOgcJKEbtSGP/OvYlpvQYUpg2EYlEollEqlMySepmkoFArI5XIYDAYolUrIZDKURnTwv/QtDMtlGJqfROE4gUmj7Q1NZgOBAEwmU0+OEgaDAcfHx7BYLIJjboWCoigwtBj/8fmvQGbQYrgmxaJE37bi2Y68ajSajoN1K7QZ77bN4dgoRV6XwSXahPfOXYNIdEohk8kk/H4/isUizGYzhoeHBa3zxWIRNE23XUvS6TRCoRAYhoHNZjszGP2vtO/G13ZvISFJ4G2Xb2CsJuelP718vkL10M2o1Tn83p1n4UkfI30cgScXx3Ms8Hsf+ZWeHqcb9Ho9otEowuEwRkZGztmJvlHlBsB9QvuGQaOFVzOy2SxCoVBL4qbVakFRFLLZrGACQozcSQVxEa/5SXaregKnLce+E5bqQLVSBVuuoMpUUIinAfYAfiMDr2wYBoNBsDZWqVRCp9O19KZ1u928mXuvEGLd1Q2NnrxEO9zYtiGDYaRa1i5esVKpwO/3I51OY2xsrK8Iyl5AhgpcLhdUKpXglthFK7RSto7Evh+gKCw8/VYMzZ9ekw8vP9j2oNOqyi1KmPGCKAW2WsXyJ98H++V5lAsllFJZbGxsQCaTQafTQafT8ffOoNC88JOpY4vFcuHI5HagaRqXL1/G7du3MWP1gor/EdhUBpC+HXnVb2LXE27pI90vUqlUW7u+QSNFVaEbteHghXUc/PBFPPgLH0Uwl8emwolRgxlyuRxDQ0M8Ye2GRbkR16QmuB16VIolaHJVvFM9fmFv67sFhmEQjUZ7Pryq1WrkcjkAg09BC+ST+IuEC7E9HwyTY/jBQQAff/zdWMbp9U8S8Qh5JfdbL64QLMtif38fP/3YO/jv9ebNm6jX6zyhJZHlHMchHo9jb28PlUoFFosFNpvt3PWQqzA4yMUR8Qdx2X7WP5nECMdiMajVakxMTLTc/ywKDd4/dgk5fQ5OywSA06j0dnr2dvD7/YL00M3Yz5zgIBeHWC5FZHsP5ikH6PlJ3E6E8JBlsEFGMzMzWF1dhVqvw148DI3AeYZ7jfuE9g0A4nLQaoPuFgQAnFZpt7a2BGnLGIbBnTt32lbg5ufnB5bI1QyO4xAKBmFJlMGaDZh5/GHUOQ5qiwkfmn8MOpESqVQKh4eH4DgOGo2GJ7jtbn6n04nV1VXI9RpkamWYaDUKJ0lwHNf3JtVPZnY7OBwO6HS6U8LRoFHVaDTI5XIwm091gTqd7gwZqlQqfHTi+Pj4wAiJEMhkMly5cqXnam0/Vi6VSgVerxcihsFjy1exwySRcPsAAFdNdszp28tfWt0Ps2oz9CcF1MeGIZPJQeu1eHhqEe9feDNEIhG/6Z6cnODg4OBMu1Ov10Ot7j90olwun9GdEQudQSWStYNMJsPV2QI2vv+/wmygwNWAgOfvEct7sfzEXww04adXV5JeQQhKLBbDyaEPpUwORqcN2uH3Ymh+EmKRCA9cvgp5h8G7VmAYBvv7+/iNd3wIYokEFa6G7Y3bWFlZgcfjQblcvuuHxV6xu7vb8wR9vV7H98Nu/NmdZ6FJ72C0JMLS5cGEiADAc0du1Gp1VLkaXH//Q4wsz+ILz38XE+k6lHK6Z/LaCm63+5z1VyvtLvCartdisYDjOEQiEbhcLnAcB5vNBovFglApg9+78yxKtSpiO/u4yl3HPzc+hUI6y0egj4yMCJJvNQ9IddKztwLDMEgkEn3tr9GTE6T8Ryhl8ohteaC2mJHY9+N2SQmxOQHgdC0gzkbknzKZrOc0PIqiILEZ8Kt/8wfgFFLIlDSeqqXwyekH+M/hjYj7hPYNglaEllR45ubmOp7maPp0IWmeTmwGMVDvZOROErkCgUDLFmm/sZrxeBw+nw9WqxX/5sM/j78+WMUrPjdq+RJ+dvZhXBs6fa7GzT+bzSKVSvGLDk3T0Ov1vMctcHrjxVQi/McvfQaGSTvKuQIepkz4h+/6UM+v8W5Br9fj8uXLcLlcvAk7pZBjzbUORkcj4wvgxqtDawzDwOfzoVQqYWJi4kKWMAREo90riAG+y+Xio1sHVdHkOA5+vx/xeJzXdV6pc3jlxI8XUyI8OvcwHhxygBIJV6mR6/u3nvkUXoocYEe6jxszV/Co1clXdmQyGb8BEpCBlOPjY76yReJqtVptVwLH1TncSYbxSsQH/dQYbFJVx0PjIFGpVMCyLCqRb2JkSIbvvZDAmruC/+lnzLgx4wWk/VfNm3GRSN1OqFQqiEQiSCZPD6ImkwmTk5P4lfk5nLzyNezs7IBWS8FxHH5q5sGeySzHcbwsg6yjCorC+Pg4jo6OsLS0BJ/Ph62tLSwuLr4hWqqxWAwKhaLn6+elmA9f9K2jKhMj7PGiPOnA5zwv49Pzbzr3syzLolKpvHYNVSq8Ew759+auizewi/jJEVIHIRSjCajfboJMSePK1asDkW6QWPDmQ+Do6Cg2NjY6djooiuI9z1mWRTgcxubmJv5w5wWUNXKIpBKIKDF29z34T8EEPrr8CGZnZ3siehzH8WsJgVar5dMPu93zvXjONh7uGIaBRkHDaLEgJaLwyK/+NEqpLGQKGs+85UnYXk0XJA5HlUoFDMOgUCggkUjw32sjx2hHfmmahkgixv8IbYCjJchH4zDPTeKFyD4mtWa0nhJ4Y+A+oX2DgKKoc7GFOzs7vDtANzidTqyvr8NsNrdckMlQiJBTpNPpxM2bN2GxWM79bK8OB8ViEXt7e5DL5Wc0fD878xA+Onb5tNVubR2hqdVqodVqeYsghmGQTCZ5wieRSFCWUviCfx0sV0P+JIliPInVGTkC+STG1f1r/YhH8KA2N1L19Pl8+OaPf4Bvc8cIur2gIy6MqQ2YLc4jHAiCZdm+jLE74SKDPMRLmAQYdDLAFwril9usBaZEFB62OCEZSeBGjy00krpFru8HjGOYFqkxZetedaNpGjab7YwOMJ/PI51Ow+/38/ITjUbD59OT+6JW5/Bft3+I7dQxToIHeOnFFB6oavCpt7275wSqZnLRSDAIuWjckEjSkVQqhSzNQMICV5dl2D6sIJGpobBbgk2bgNmiHMh1nEwmYTAYLvw4wOnnG41GkUql+LjYVlHZH9fPIvjIOGLJOC6NOnFjpPPQZCsQD+Lm78NisfCRrk6nE+FwuC9N5KBB9PL92GzdOvEDAAqpJI5ecYHWavCd6I9xpUCfCacA8Nq182oFTyqVQqFQQKfT8f+v+XOISFlsJY4w99SjyISikMnlmDUOD4TMEnlVq/ctkUigUqmQTgtzOZBIJBgfH4d9zA4uuYlqIo2dLz4H3bAFE49dh3LC3lfXq92eoFQqeelPu2HgSCQClUrVcV0gPuSxWAwsy/KHO1LA+UdDevzHb/01ZHotzOYhvEVkQimaAJxa/n0LXXc6kd9INgX/9i44jsPut57Hg6MWKFQK+HMJzOLeH/ja4T6hfQOAnPpIS5SmaQQCAUgkEsHaO4lE0tb4Oh6P4/DwsKehkLm5uZbDZkIJLRlGyeVybVNUaJoGwzCCXg/5+cbUMZZl8f292yilsigl0rj1p1/EQ7/0CXAcEMynLkRoFQoF8vn8wCtsTqcT/9n7IoIHB6gUSygXimB1Jfz357+JX3nLYEzDm8Gy7IWnVIkBPqky9zNVe5Gs804gh7XGcIZOjgNCQGzviGyF4zie5O7v74NhGFAUhT0miZtxD2QqFcrFEtL+EG6Nj+CDbBlsmhVc+aIoiicVjf9Uq9VnyEXbz6z0S0DwR2AYPZ56lIJtSA7L+PtwXOIQWFvj752LDHQlEom+zflJYMXJyQmv0R8aGupY9a9UKqgUGbznxg3eS7pXeL1e6HS6trKPxlb2yMgIaJrG+vp6X5HMgwJpufdzf0hEFHLhGJJ7Aeidw1CaDZBLpLhy5QrEYnHfr4llWbhcLswpT7tf3whuoWauwsKI8CsLb+77cRvhcrk6Oqw4HA7s7+/3dNinRBTMGj0ychkcj16DVC5Dna1hiO4/Mrnd65PJZLh69So2NzdRqVRgs9lQr9dRrrEQ19E2zpwk38XjcQCn1enFxcWWXdn6SQb/6ZlPQ6lRQ0qJIRKJ4Ha74fV6e5bMdCK/U2wFX6wFkfQfYfapxyBTKsHVAZ1MAYrqf/j3buM+ob3HIFXZcCmLH2aC+BEXx4pxFOZivWerFbvdjmdf/DE2a2nUKREuGUcgy5URi8U6xti2glarhVwuPydjKBQKXaNqSQVubGzsrmo/JRIJLBodqgwDjc2MpQ++E3K1EunDEMLifYQ5BW9E3yuIddegCWatziFVLUGsUuDO578Gy9wEFj/wDsjGbHetPT0oqyVSrQ0EArh16xYWFxfPSFfaVbXz+Tz29/chl8v7yjrvhHaHtXK5DIVicIMMFEXxHQMCjuPg2nwBtUIR/q09bH/h77H4gXegVq3htnEHUwYrT06JhKFd5evCUFwC7J8Bjv4QFmsQ0coK7OO/BadYDqfTiXw+j+PjY3i9XqjVaoyOjvZ8vRUKhZ5+h1Sb4vE4KpVKy8jgTvD5fJiYmABwKtsJhUI9vd5IJIJSqdQx+ai5lW00GiGTyc44R7yeSCaTqNfrfemu8/k8zNHTQ7JlaQZytQoyJY132hcvRGZJTDOZAZgB8JR9AXUAq7duQSu7OPEPhUJQqVQdyapSqQTHcT3bVP6D2Yfxf730ddBaNbSjVtRDCdyQ9ufS002+JZFIcOXKFWxtbWEteojvFIIo1argjhL4lQffwa+NzR0Ki8XStTNQLBZRrVbPfUZzc3Nwu93weDwD228VEhkehAHfkURhGB9GrVqFRaHG4yOz2E1sD+Q57gbuE9p7DIlEgp3kMb7o34BMpYSsnsULm7fwG+/q7rfYjHi5gC9k3MgEsjCMDeOvbj6H9w3N4WNvfqqv0z6ZdCTCd6DzUEg2m8Xe3h4MBsNAK3CtkM/ncXBwAIlIhKeuP4JbJ4cQ1etQmQ1409wlvG/qIcSiUX6y3WaztZVjtIJSqeyrItTutZIseJZlQeVKUGrVePDTHwVQRy54DMXQxECeqxUGUaFtxPj4OF+tJXGlwXwKL0S9OPBU8abxOVgVWlQqFXg8HlSrVczOzvYU7ygEJEK21WGNEKi7DU1NjFKugOHFGWh/zQTNiAVMIg1lTQSZTNbXNHPfUD4AynEZKO1i2GhE6CjKd2vUajW/2WWzWRwdHcHtdgv28xSqny0Wizg5OUEikQBFUTAajT3rFMnz5XI5XkMukUh6ctHo5AzTiFat7EY7tEFFQwsB6Wr1aufEcRx8Ph8ymQze+/BbwNZY+JQ1xKMxvMt5BU+NLvT9esjAXPOBUSQSQYTTA0A8Hr/Q4CPDMIhEIoKCI+x2O4LBYE/EbcFgw6eGVlCdp6FVa7H8yDD2d928LVUvqL8aP98JFEXBNDWOf//lP0adEkFp0CFfyuOPPS+CKlZQKzFQKpWwWq09VeL39/cxPd06aGZubg4ejwdut3sgcxd+vx9vskzi4eUrWDvcA1Wu4YNX3gzFG9jiDrhPaO85KIrC9wN3QIlEYEoFxDw+OB66gq/tr+Eh4xh/sTde9K3+naIofPXwNqBWoBKOILZ/CLFUglV5AZ/ok1hSFAWn0wmPx4OFhdNFsVUFjhCXWq12LrayG4jsoBdT7v39fXAch8nJSajVaizV65jaWUNIlcDy9CxuDI2DEp0OfYyPj4NhGBwfHyMQCEChUGB4eLjrJqVUKhGNRgW/j0YUi0U+C55lWT4LfnR0FBKJBP9kagT/dft5MNkClGYDhlQaXJEYsLW1hdnZ2YEToLthhq9UKvm40r959lv4DneMfDwJFZfG92L7+CndLBSVOqanp3vWAwuZoA2Hw3wee6sNodFx4G6AdCGu2hyIv+VJvHJyiHK+AIlEin/8zo/iwSEHYrHYuYnru63NJJ/FyMhI25jSxkpzMpnE4eEhGIaByWQ65+dZr1ZQ33oB8aAPGqUZ9frlc0MxxDUinU5DoVCcDvj1Ge1L4PP5zkmnhEZSC3GGaUSrVjZJntvc3ATDMHfNdq0RXq8Xo6OjPV23RDs+OjqKqakpuN1uPHn5QWi1Wni9XizZ+7PsKhaLcLlcGBkZ6UiQRkdHsbe3dyFCu7W1hfn5eUHfldlshs/n62m+geM4qEQUbky+Jp9bXl7G1tYWAPT03Qp9Xnc6Cr1jBKmjCF7571/E1NseRCqeRGVWioeXLwl+PoJ8Pg8AHQ+eMzMz8Hq92NnZ4ffrfhAKhZDL5fjOxrhUg2AweIbM3nc5uI+WEIlEYKoV1MUiVFN55KNxMNk84gUGwWAQwGsXT6Oov/GCIv/u2tvCSS6B4x0v4h4fLj3zJA533Ng37/OaQKWytwERs9mMcDiMZCoFTi4Bw52tkgQCAUSj0b4rGaS1343QEnunUqmE6enpM61PSiTClFyPG/POlq+Bpmk4nc5zrVetVovh4eGWbVRaoUA8l0GJrXY9lTIMwxPYSqUChUIBk8nUVge1ZBjB/3b9aXybexGjoyN41LEAhUSKdDqN27dvw2q1DtSEv1ar3TVy53A48JnQTaRcR2CKDKqVCupVFj+YkeJ/efwjd+U5A4EA0uk0VlZWOuov78Z7Jm4dZrOZ70L8Qt2Ot43MYN/gh1WmxBXrqb6YDJqRKX7SLSBa1rvVwSCb7vDwMILBID9U2Qqd/DytZhMkX/5dIBpA8iSLYY0cHFWA6G0/xU9fl0olaLVaWK3WgbU7WZZFJpM593jNCVjt3vvm5uYZR4NuaNfKJu1jl8uFcrk8sDSmVsjn8ygUCoI/w8bqKdGOZ7NZlEolzM3NoVKptPU174ZQKIRIJHJOUtQKNE3zOvF+7jefzweLxdKTtMNqtSIcDgu2ZSTRv40gUeW9klqhhJaWSFFjWVRzRZgXZmC9NAuKojBkMgl6nmYISZEETgNJfD5f36SWuI00zs4Mwpf99cJ9QnuPQVEU5nRW7IeDUFuHoBmxAWwNb3vgUSzM93ZB+nRAMeSCWCrF8NI0NCYjpoZHYTabkc/ncXR0hEKhwN+UCoWCn7okwyetYJ6w43/+8p+ialaDSefgM4jwbuMUfAenNlwXSa1SKBQdB8NYluXbaZOTk21Jc6FQEGT43th6TafTfOvVaDRieHgYSqUScSaP/7z1A9y5s4Gh6iEeH57Fx6au8xZSlUqFJ7BkE+y1tWpVaHHdNAbnsJMnzHq9Hg888AD8fj9u3rw5MNsnlmXvarWywLGQ6zTY/c4LUOp0mHryEVSVd6c15fP5UCwWuybjDdKhAji9Vg4ODqBSqVq2X6e0Qxid1mB/f//c78pksjPdgqOjI/h8PqjVagwPDw/U0aLxPZMq7djYmKA2KbEzI9rX7W/8FWqra7BpFDhOZaCS6nHwjS+AwxDMzpkz09eDhN/vb0lWdDodTk5OOhJal8uF8fHxnrWv4+Pj8Pv956qRhPgMovLVCbu7ux21vo0gmtaxsbEzzhx7e3v8Y7SL1+6ESqWC3d1dqFSqnnxSR0ZGcHx83PHg1Ar5fB6pVEqQ1KARdrsda2trPRHaVutFP6RW6LqyohtGLRCHbsQKuUaFar6IS2OTcGp6J7TpdBpSqVTwveZ0OuH3+7G9vd1T1HY8Hm8Zk9zPtXSvcJ/Q3mNIJBK8yeJE9OQEa8kAVGYDZhVGPFTvXf/3nvFlBAop/GBnH+a5SVQPjvELj78Jep3+3KbJcRyKxSK/qIRCIT5MgKZpqFQqnuz+qfcVlNUyZAPHoPUafOVHz6I8cYJPvekdFyZKNE0jlUqd+/+NPqUOh6Nr5aKfCoFe/9rnEo/HcXBwAIZh8JeRO8jSFECJwHEcvh90QZYvY0FuRKFQgEwmg16vv/CG3k6P5XA4MDw8jN3dXYjFYszNzV2oVX03JAfAaVvS7/dDFs6AokSYfuIRWBamUU5mIDlKY2trC+Pj4z2T8nYbhsfjAcdxPS3SFwUZaJNKpVhcXOx4YBHi2kHTNKampjA1NcVrWT0ez5kD1UVBNh+hVdpmEHcV27gV5UMDVgMx/Jcf7eB/f/oGFq060LMTENnvTrWSZVkkk8mWE9tarRYHBwdtf9fn80GlUnUkvO1gNBrh9XrbEpapqSmEQiHe1muQhyW/34+hoaGuh2GWZeF2u1Gv188dqgKBwJnH6JWENA9+9QKLxYLV1dWerjGO47Czs4NLl3pvv1MUBY1GI8jCi7iRtFv/eiW1QghtpVLBzp0t/Nunfxov5o4QikWhLLL4haW3gRL1ft0cHBz0nPbmcDgQCASwtbUl6KCUTqdxeHgoaHi8WXL0RsJ9QnuPQVEUUK3jaeclvMU6ifn5eVjMQ9je3u5ZtC4TS/ALjhu4wijhnJ+B6rIIQZ8f9ivnT4UURfGV2WYwDIN8Po9isYjoSQyra6sAV8edL30LpslRjD9yAzGUkc/n+djJfhb4XIXB3wQ3sLm7g0vlS/iw8yrMchVCoRCi0eg5n9K7CbPZDLPZjGK1jFjoFRT9aex+4zmYF+cw5ByF26HAOx6+PPCp504WMCsrK4jH41hfX8fo6GjfOr5BSw6SySQCgQCoV83p//XUp/BvvvNXgFUMiqJwaXIWv7H0NtSYMu/jarPZMDIy0jcR2NnZgUwme90S0xiGgdfrRa1Ww/T0tODvXSKRCD5cNWpZGw9UQ0NDfQ+TNX++drsdN2/eFFSlbYZoeBLBVB46Wo5//sQKSiyHZAUYMd09PWkwGGxrDdaJpMViMRQKBcFVzlYYHh5uaXtIYLfbQdM01tbWBubWwTAMTk5OulZEY7EY/H4/H0LS/BixWOzMYwgltES6UK1We7J1bATZS4R6xAKnh9OxsbG+rdEcDgf29va6Pt/x8XHXdZOiKKysrGBzcxNAZ1LbjdCSWHnSXfvYkA2YBG7dugVZj4EgwOlaq1Ao+vqcxsdPY503Nzc7drTy+Tw8Hg+uXr3a9r2Rocx76c8sBG/sV/f/ByALj0QiQa3KgpademcuLCxgY2MDSqWypxNzMpnEwrgTllc9WJOqeM/EmKZp/gaq1+sYTW+jWCph+sk3gZJLoNCqoBTLkEqlcHx8jHK5fKYqJJfLQdM0/0/yp/FmqHI1/O6d7yNazCKaTaGeOMLGvhufMM1jaszRk0tCrzYuHd+7RAqlRo1CIoXRa5cgVdHQWEwYdzgGTmb/b/b+O8yR+7wShQ8KhZxzbKDROc10T2QWKUoMkigrB8uWgxy0K0u7WtvrXd/dvZ+8n9de+66j7PXaa1mWFSwrS7YkSiQliqRIijOd0TmggUYjN3IsVBe+P1pVRKMRCugekffbOc/DhzPTaKAAVNXv/N73vOfwWXCMRiP0ej18Ph9u3rzZU7DBeVRoGYZBKBRCOByGWq3G2NjYic/8PeYJOMeHQQqFMMvUx/IMpQiTk5Ncas/c3BwUCkVH66bGz8Xr9UKlUvGuAJ1FYkHTNHZ2dlAoFDAwMNB1tYqPzrMZ2A1Vs/hOq9XaFRlt/PwcDkfXVVoAWM3VIL78MCYCL2J2P44ZlwXrow+jHIpicPD87axYHW+7TSyrua+vZOfzeQQCga5b141gJRrt9OtGoxFisRiLi4ttExf5olNyFEVR2NzchFAobEk4Nzc3eekrG1E/+HXWobe+vj74/X5e10symUSlUjkhl+gWUqmUl4UX2+HjA5bUtotNb0do2Vj5ZnZv3Wx067G7u9tRXtUO7PtYWlrC1NTUqWMvFotYW1vD9PR02zWi0cby1SpBuE1oX2EIhULQNM39nz3h2V1jtybfh4eHJy6AwcFBznqrF9InEAjwtv4Z/M/vfgV9M+OAgEB+P4x3PXQPHOrTelY28ahcLqNYLCKXyyEej6NSqZyw3Tko57DmXwcpESG6uo1ajYFUo4bQY4HL3t1AVLfpZe0Qi8YwWZJi3mmDTKUAKZWAOsxgQqA6l+evB189FkEQGBwc5FLXZDJZWwPyXl+nGcrl4+HEdDoNi8XSdKMRCoVgMZnhVDXXN7OpPS6Xi2ttsZPjjWQtXsphMx2FMXeIPrkWKysr0Ov1vPVy7DF3a1PWGMXbq/WNTqfrqPNsh/r4TnaYbO7HwQis9Vy3sNvtXVVp2cEqo9EI5zt/BbXCuyH44TMg7389Lkhktywmdn9/v6PHNbthYIkkRVHcgnzWY2FtxjpFiKvVas7Wq5cWPYtOyVGRSISzqGr1GrFYDCKRqGtZDzv41a0rTSsolUqUSqWO9xp2w3jp0qUzv2Yr3TOLdDoNpVLZ1XlRX6ltds9pJRMrFoucZrXZJoe1N+tm4xCLxTjv6rOAdTpZWlqCxGXBzcMABBBgRm1DKRDBhQsXOr7GrfJlP2/cJrSvMAiCwNHRESQSyamSPkmSXEY0n3YQu2uqfxxBEBgfH8fq6mrPFYwZmQnvG7kTZYsSEiGJixcfQnR7D7YZ7amLmyAIriLb7kZPRv2Q53aQCoZRzhUhViqgtptR60Gfk8vloFKdjXCymi6CIPDhN74TC8kgnltbhEwswVsfuguJvWBPaSydXrObm61cLsfMzAxisRinWeuVOHVCOp1GIBDgqhXtWv3NBglagdUt0zSNg4MDzM7OcvHGs+kDfHrrR4j5ffi+KIX+NPCB66/rSHIawabt8UUwGEQ4HD4XiUsnnWc3qB8mKxaLCIfD3DBZq2CEMp1BpnIA6mgcYuHLmzyHw8G1rNuBoigsLS2hv7+fI88ChQYCvQ0CyXFQhcfj4Yj2ebXeGYZBLBbrGPeq1WqxF/DDarMBtRqWlpYwOjp6bpKavr4+eL3ejtcVa+u1sLAAp9PZdbWRoqi2yVHr6+uQyWRtO1XsJqwbckhRFFZXV6FSqboa/OIDs9nc0X1gfX0dHo/nXFrXnXTPbLhPt2hHalsFx7B64Fb3HbPZjO3t7a4IbbffbTvY7XaspsL4q69+EsYhNxiawVd2Hsd/fPS9vO6V5+nLfitxm9C+wmAlBwRBoFKpnLrQ5XI5BgcH4fV6O5KGRCLR1ExeqVRCo9EgGAx2VekCXjb7fuzaPScWjYiAhNfr7bkdMmawQ5gpQqZQ4OrPvxUpXxBUIoOpa923vvikl7UD6+VYTxAvG12wDx/7XppkKpjGx29JZaqX5zGbzTAajdja2kIoFOoqtKAd2HZ3KBSCQqHA0NBQx+dNJpNQqVRdL1AkScLtdsPtdiOZTOLm8iL+dOl7kJm0YOgjHG7ugbIaERXR6Pab5VuhZStgrSrPveBWTQSz94H6YTLWncPhcEAqlWIz9W3Mxj6J3UgSiZ1/wl22j8ClugvAy1Vat9vd8n2yVSY+7hpWqxVyufzcWu/BYBA2m63td1Cmq/h0YA5P/vAZWJLLGMgJ8L6Z+861asQmubHxvO1AkiQuX74Mr9eLSqXSlaRjc3MTg4ODp94vu7ni8x1sbW3B7XbzvvbOMvjFB3a7nSP4zRCLxSAUCs/kWdsIm83WlESzQ8+9nhutSG1jUhgfMgt0H/MeCoVgNBrPVbP6w3IEcpMOB0urqNUEsAz346nDXVx3dZaryOVyxOPxczuWW4VbF+XEA7//+7+Pa9euQaVSwWw2461vfSs2NjZOPKZWq+FjH/sY7HY7ZDIZHnjgAaysnIxeq1Qq+MhHPgKj0QiFQoGf+qmf6jom8ZUCK7ZmK7XNoNfrYTQasba21va54vE4TKbmkX6Dg4OIRCJdXVQAuAW/sQJitVqh0WhOfV98wDAMNlfX8KHLr8PlyQuQCUW4MDWFd1kmUE13vws8i4bW7/dje3sb09PTp6oyJEme+E48nmOf24WFha5Si1rhLMSHIAiMjo5iaGgIq6urXKWiF7Aev7Ozs6hWq5iZmcH4+DgvkhIIBLrWZjZCr9dD73FCpFEhtubDi3/1ORzRRyCEQoSKma6fr1qttj0fkskkbt68iUKhgEuXLsHlcp1r61yhUCCbzZ7b8zVCrVZjfHwc165dg0ajwebmJp567iv4zuJfgKaOz1emVsXzoT9DoZrgfo+t0jZDOp3GysoKLly4wJsEsK33lZUVJJPJnt8PwzCIRqMdq1ef2X4JS4cHqAFIBsO4mQlhiU73/Lqt4HK5sLe3x+uxrDSsXC7zvhcmk0kIBIITFoTlchlzc3OoVCq4cuVKx++A9ZxtVklOVgr4uPdp/Jn3e/iDhe9iL5vAxsZxMtalS5duCZkFju+XUqkUxWLx1M8oimorD+gVrGVYI2Kx2JmJ88WLF5FOp09wifoKbTab5eQufNYfmUzGBSS0A8MwODg4OPN9tRHZYh5Uvoiodxe5gyhESjkKNMXrd6VSKedFeysTQM+KV/TIfvCDH+DXfu3X8OKLL+KJJ54ATdN4+OGHUSgUuMf84R/+If74j/8Yf/EXf4EbN27AarXioYceOlH+/uhHP4qvfvWr+PznP4/nnnsO+Xwejz32WM/G0j9JsBUdoVDYlpCwOphAINDyMcVisW1VYWxsDKurq7yPjaIoxGKxlkMS7AXX7pgaQdM0FhYWYDabcXlkEv9++iH86d3vwn+5/EY8eud9CIVCSCQSnZ/ojKAoCnNzcwCAy5cvN21ZisXiU8TVbrejv78f8/PzXW8ObgWUSiWuXr0KmUyG2dnZrj67fD4Pr9fLDV1du3atq4pPPp/nFrFuwXqdbmxs4ObNm4ju+EEXCxAIBbj+y++Bvt+BYjqL+PouvF4vIpEIb8JeLpebfp/ZbBZzc3OIRqO4ePEiBgcHb8nUrk6nQzqdPvfnbQaj0YiLFy/CMS5B7aiGxR+G8MTnt5GOl3HEVJGuvExg7XY7EonEqXM6Fotxm7puv0u29R4IBHouIoRCIVgslo4L5dLhARjUcLC4jv0fLUKiVmI+zv/ewxdq9XFsM2tjyAejo6OQyWTcUFErsB2vemLn9/u5lMBmVdtm2NzcbDpMRh3R+OOlp7CaCqNQpbARPcB/+Ke/AS0WYmpq6pZPqdvtdi4QqB6rq6sYHR09dzJEEATUavWpDVUkEmnpltENpqamkE6n4fPv4Rv+JXxxexZf2p3DQTzKpdHxlbuYTCYcHh52fFwwGOR1PfBFPp/HysoK1IkSJEoFXNcvwHphBLlwAhM6fv2v/7d40b6ikoPHH3/8xN8/+clPcp52r3nNa1Cr1fCnf/qn+E//6T/h7W9/OwDgU5/6FCwWCz73uc/hgx/8IDKZDD7xiU/g05/+NF7/+tcDAD7zmc+gr68PTz75JB555JGf+PvqBqzUYG9vD36/H/v7+3A6nU293kZHR7GwsAClUnkqYIC10GoHpVIJnU6HQCDAK4lqc3Ozo03S6OgolpaWIBaLO+rIWEuTVqliBEFgZmYGc3NzIEmSVyWhl8lR1gKnU1uPnUxthF6vh1gsbjnR+krAbrfDbDZzlZixsTHMpQ7wLd8iDrZ9eFRP4K390xARQsRiMQSDQU6j2Wtbbm9vD/39/bwey/qLplIp5HI5kCQJjUYDm82G0dFRZLNZ3Bvbx/MiEUixCGKlHFddw3j/xH0ol46tjdjzwmg0wmw2n/rea7Ua1tIRvBTaxlW9AlM4fl/FYhHb29sgCKKjl+x5QKvVYnNz81zT3lqhXC4jGo1i2x9DIUtBpZPiDT8/hEqZxq63gIFKAqqBLPcd24UU9v7yt+FREIBjCKHh1+AwX+LlP9kKbKLW2tpa11nyDMMgHA531M4CAJ0rIBbYh9KkB1WqIBeK4TB3hJvMTe58UqlUUKvV5zJIs7+/35Vm3uVycbZeMzMzTckja1dFkiTy+TzW19dhMpm60rM2es7WYy93iHg5D5qi4fvhTTjyBRhG3IiIqvhJuDc307UGg0Hue7kVcLvdWF9f59YUiqLAMMy56aonJifw77/8t4gKKJQyaUTWZvHtxA/wZ+/9V129hl6vx9LSUtvKK9ut4HM9dEK9vWJ/fz/+w+gI/nbjh/he9Dno3A4Y4yU8qOmtCvxqJbevKg1tJnPcXmRPTJ/Ph0gkgocffph7jEQiwf3334/nn38eH/zgB7k2af1j7HY7pqam8PzzzzcltJVKBZVKhfv7rWwPdgJN05ibm4PRaEQ8Hsfi4iIymUxLP8WpqSnMz89DKpWeILDt5Ab18Hg8uHnzJoxGY1sCzFaY+JDKqakpLCwstB0EY/V5nQgg28JbXFzkRRbz+TzvgTCGYbCxsQGGYXhpJhslB/VQKpWYnp4+NUDzSoIdIsxms/jCM0/gW8ltyPQaZJkqnvB7EQzs417Fcezq1NRUTzf8LFXCSiqMKlUFUcy1/H4aCSxBENDpdByBrUcikcDe3h7+9SNvw+BLP4TEaYZZpcEFvQOEQAC5XM7pbdmuwerqKmiahsFggMVigUwmw6e3foQfRncR3/XhBTKD1x4OYrqmRqVS6cpL9qyQSqVdVfe6RbFYRDQaxeHhIcRiMcxmMx6952dA+LYxO/8C3MNG1HCE6xNvwITiTuzv76NYLMIkrsHy/U9iMRhHn00P364PtNeL6d/8Ewh6MHxvxPj4OAKBQEuLoGYIhUIwm81tH5vNZrG9vY075DY8Myg8dkMRi1GMJ/DuO1+Lq+7jqNdsNotcLodQKASKojgDfpZMdaPzNZvN3BBdN0Sf3WjVu9NUmSNUmSPQxTJKpRKGh4exs7ODTCbDK14WAPLVCrJUCQqQpzxnWRSLRewHAoiv74Ku0mDoGsRqFcqpHHZXN6CJHHc+SZLkLBVZj1PWT/w8YDAYsL6/B41RD1VNiEgkcu4DaPWQSqUgCIKTnoXD4TNZgjViJ5tA3qJEcduPsHcLNUIAw0AfvJkI7jTzDxghSRIMw7QdBvb7/XA4HD1vLuvnIFQq1Sl7xV8evBPXq2pcmJqCCATm5+ehVal5bfKbdSxfbXjVENparYZf//Vfx7333suRuUgkAuA4u7keFouF04JFIhGIxeJTw1AWi4X7/Ub8/u//Pn7nd37nvN9CTwiHw1yaCdvC3tvbw+DgIGQy2anHkyTJWcbUtztSqRRvzc3ExARWV1fb3mS2trYwPT3N6/nqLcaakVB26Iqv/ZhYLObeY6ffyeVyvCy7WPF+Y1xkO7D65nbHefnyZSwtLaFcLnc9cHeroFarkbEpIUgLsPvsDWQjcVjGhpAzG/FLP/Ug5DJZT63Hg0Ia/2PpSRRpCulAGAaDHsPFSVjk6q4IbD2CwSASiQTnwGGVqnC1v3UtSSwWw+l0wul0cr6lu7u7WI3s45vRVUh1ajBUFen9ML6wvouJR96LmVsUV9oOvfpOtkI+n0c0GkUqlYJUKoXZbD414NVXfjdMVy5BpCpDI3ahX30vBAICGo3meKH71j/AG0rgMJvHH60H8O7LQxgW5oFkBDinsASXywW5XM7bAaFddbaxsn5ZehnjsT08PvcjKDUqPHzPm1EORJHWHBv6s16+LBiGQTabRTabhc/n4zSACoWCI7mtbJ1qtRoKkjV8+kd/BZ1FBo/6fkwa3gFCIOz4GWi1WkxOTmJxaQlrkhJezB7rfkl/Ah994C2YnZ2FzWbj7Trz3eAavuKbRw1AzneAj97/U9zPkskk4vE4stksZDIZxsxOTExfwNqiFzM//QaUYmnYBvrxzisPQyeRc58La6vIBjtUKpUTEiqxWAyZTAaJRAK5XM6R3k5Ei2aO8K3sLr4/+xKMI/2gdsP4vx/7GV7v8yxwOp14YXURGpcN0cAuHrnn/p6eh6ZpFItFFItFFAoFlEoleKMBxHd3AUKAxI4flqlhUKUKKj2QO1aO1KxDSdN0Rx/mdsd9cHDAaYdbdQiSySTsRjNk5PF1OT4+Dq/Xy6tDI5FIUCwWX7XVWeBVRGg//OEPY2lpCc8999ypnzW232u1Wsf4tXaP+e3f/m38+q//Ovf3bDbbk73HeYCmac67NR6PY3t7G0KhENvb2+jr64NarT51okmlUgwPD2NxaRFxkwwHhRSyoSBGL0xBQXReQOVyOUwmE3w+X1Mbn0Ag0HQQrB1Yov3sjZcwJ8vjgMpDI5bhUa0HknS5K60R+x5Zy7J2v5vP5ztWpgOBABKJRFd+vgA/3RArk1hZWUGlUjlXW6+zIJ/OopzJQ6yQQygSQ2M3Q8DUEPD7QdP0KaLOxkOKRCKIxeJTfxaLxfjU+gso01UwNI1yJouCSoE/e/JreLt9gjeBrYfP50OxWOTcO2KxGAwG/lnnBEHAbDbDbDYjaZBASgWRO4jgmT/5JK798rugsVuwn4zDqdRDqVSea1paJ7AL11ls1bLZLMLhMLLZLORyOSwWS8uKYT6fR40R4NrAO5s+F0EQMGs1oBQyZApl5Mo0NLIffx61Ws/H2AxGoxFSqbRjl4Wd5G58PxRFcelVjZX16+Z+GIaPoNPpoNfrQettWFhYwMDAwCmSQBDEiXhrFvl8nvtsC4UCGIaBVCo9Uc3dy38f+8KvIxjKQKzXwXv4RTA1GtOm9/H6DORyOVImGb7x5HehsBhAFUsopVL4yx9+C//9Lb/I+z60kY7iy755AEAxlQFdY/DXiz9ALZGFsCY4Idth8d7COL7eX0FBIwFVEuKDw/dwZJb9XORyedvKcL2XeKFQOOUlzgboyOXyE6T3yegWvLkYAODQdwCpQorP+ufwnw1v5PV+e8XTGT8+ffM7UEftKMaTIDwWPOJsHhdLUdQp0sp2VEiShEwmg0wmg06ng8PhgHtkCC/I8sik0rj8vjdDaTYgH46h4o8gq7R0JaUwGAyIRqNNCa3f7++ah5TLZfj9fuRyOdjt9o6dx1QqdWLNVyqVsNvt2NjYwHiHjT/rRftqxquC0H7kIx/BN77xDTzzzDMnqlxsJS0SiZywZYrFYlzV1mq1gqIopFKpE1XaWCyGu+++u+nrSSQSSCSSW/FWugabDgQA9913H3dCsxKE3d1d7oarVquh1WqhVCqh1mjweHYPy6s+SLVqHJXK+IPF7+D/uvQopMLOlkVutxtzc3MwmUwnFgyKohCNRnvaJQrFIjzBhLA9twXDsBupaBx/uuTFn7zrgz2RCblcjtHRUSwuLrb04S2VSi1vzKznokajOXOKUCdMTk7eMsN5vqhvN40KVdh022Ec6YfKpIdcr8aD/VOYGm4dDcoOwtA0zf25UChwf95cW0O2UsL+S8sAAcgNOlTMmp7aiWyU7eTky9XYWCyGgYGBnt67Xa4BAJSzBVx41xshlssg0WjgUOuRSqUQDAa5RUsmk0GpVEKhUJyL3rIZNBoNotFo14Q2nU4jHA5ztlF8NwithoRYRCIRBEoimAUEJm16OHUK7BwWILX2Q6nvPBjS7fnMR5JzcHBwwmeTpmn4fD5kMhkMDQ21lTuxx8PqdxcWFsAwDC/pT7PI73K5jGw2i1QqhUAggOf2P4scnUHIl0H6sAT3qBYvRr8OXele1H68AWDv2/Wb3vp/++HWAgiJCJtPPo/Y8iYm3/4wDio5bG1vgxAIuOepR+MG+pnQNg4P/Kihhu2nX4Tn3qsolUuQOy24YDmt0aYoCqVkBv/poXcDANIjx+cTTN1V4Fn7slZkja3ysqT38PAQpVIJP1h9HrFMHOHVbSR39nDhbY9gYXkZy2IXSOFxNDb7H0mSEAgEJ/6t/mfN/r3+PxZbmRi+E1yD3KDD4eYeDMNufGH9JThrUmgEYo60smScrT7LZDKYTKaOcgspgH8z9Vr87jc/B7lBB5VcgY+88X0Ykem59XlgYICXpEmr1WJ7e/vUv7Mchm9BJJvNYm9vDwzDwOVy8S4iNFsv7XY7MplMx0RR1ov21exy8IoS2lqtho985CP46le/iqeffvpUtdDj8cBqteKJJ57gbnwUReEHP/gB/uAP/gAAcOXKFYhEIjzxxBN497uPL+JwOAyv14s//MM//Mm+oR5gs9ngcDjAMAxXEbt+/fqpm3m5XOYWu1wuh1AxjaWgD5VcAZH1HXjuu4ZoKYf5xD7usvAjBRMTE/B6vScICZ9BsFY4KKRxWC1DpJRj7jNfh21mAraJISynwy1TpDpBrVZjcHAQS0tLmJmZ4X0xJRIJ+Hy+W+a52AwejwehUAgLCwu4ePHiTyz3mjVpTyaTMJvNmJmZwVWShD22h8f3V6Hoq6FfIMd7BtsPGrCLWCtMMxGsRoMAUwNBCiFVKjBo7m6hPJFC1SDRaLc56QRtlcAkLcdLBg3kBi2EIhGuE1pMuU47GRSLReTzeeRyuRNWdlKplGtHK5XKMw2PqdXqpgtXMySTSYTDYc43s1VoQivEYjEoFIqmnx2rT9bpdLj6ujdCMD4M35f+Ghp5CQ7PGNYs07jMMCA7XFe9tBlZSY7X60WxWITL5UKOKh8PLaVz0Ov1nK5wf38fsVgMbre76/sP6wfLktpequJsGAz7uzGdHVv7cQh2BcgmShBO6EEKhSfOCfZe1Or/toINIREN8f3XIJZLIVXIoXdYMDQ4eKp72Oy+RhAEknoxFiXHVk99lRlYJoYAACaVtun7WF9fP/H5sQTqPOUv7LGxVd76auOUOI/w0g3Yp0ag6bdDZTVAKVdhcGCA0482/sd2KWmaRq1Wa/qYo6OjU//GYi4RQHx/F3S1iqV/+iZm3v8WiOUybGsOcM0xCJvNBrlcfqb78aDahH89eBcuXr4EiZDkvr+pqSnk83ns7u6CIAgMDAx0vIc1kyP5fD5eA7aJRAKBQAASiYQ3iWbRGNxUj9HRUczNzXEynGaQy+WIRqO8X++VwCtKaH/t134Nn/vc5/D1r38dKpWK07xqNBrIZDIIBAJ89KMfxe/93u9heHgYw8PD+L3f+z3I5XK8733v4x77S7/0S/iN3/gNGAwG6PV6/OZv/iYuXLjAuR68mkGSJCwWC1wuFxQKRUvbFjb6kq1ar6bCUJYCODqiEZr1Que0gRSRWCrKYBw44iIV20X/SaVSqAw6/PfvfhFpjQjCUhXXRMaWA2ksGIZBPp9HPp9HqVTiqnjRUhaZgyhEUgmkag2UJj2SewfYKcvhzdROVJi72eXp9XrQNM2RWhbNLlCGYbh2JZ90tfOG3W6HVCrtOrK4F+Tzefj9flQqFTidzlO7++vmflw39wMAbty4AQLdp7DV42eHruM3FxagcdlBiklQe1G89Z7250o9WMs2l8t1inSk0+meNx6sa8NvPvbT+OazT0HTZ0ctlccFz3DTjVCrdmu5XEY+n0ehUDhBdMViMVQqFXdN8SHd/kISX/bN4zlJFlN6Ox60j4L48SLIan9jsRjK5TI0Gg3cbndPQ2ut0qLYQSqZTHZSy+ocRfH1H4B9aAhSqRQj6TSvzWJ9AEw3YPX1Gxsb+PyzT+AZQQJHtRria9v41UfeDlkohIODA9hstjOltLHSH9Y266xDQURiFIXUTdz1xj5E/HkQQuDa0JthNvEny28euYLVYgIMTcN1aRI1gQAzRypIJBLen+PdtiE8G9vFQSENqfi4q3ifdQhW+ekNTyKRgEgkOnUduVyurh0besVQgcT3aAbmEQ+oUhmp/RA++OaHziX4pRXkKQdmFWWkA2Hc/ZH3o5LLQ+O04dL4JOzK3gopjUin09DpdJCSp7ufSqUSFy9eRDabxebmJkQiEQYHB1ve+xtjcMvlMgqFQssqK8MwCIVCCIfD0Gq1PQ/0ptNpaDSapj+rH8ZutW5KpVIu/OnVqqN9RQntX/3VXwEAHnjggRP//slPfhK/8Au/AAD4rd/6LZRKJXzoQx9CKpXCHXfcge9+97snJtv/5E/+BCRJ4t3vfjdKpRJe97rX4e///u8hFHYW8L/SqNdp6nQ63jc6l1KHWrYAISHEXR/5OZSTGRg8Tjx84V7oIEI+nz+hESMIAgqF4gTRFQqF+JecDzf3t6CqWZHxBxEb9GAmd4h+lYFb4Ou1Ro3PZTAY0NfXB7FYDKbGYEVFY/XAD+e1SegcVkiEJN535Y2Q14RchZk9JoVCAY1GA61W2/GGZzabQdM0vF4vR7gbHQ5YJwWHw9FVxOB541bberG79G5st8xmMyKRyJk+l1quhF+//AgEVh0EAsB2WY69rR1YL3c+b8vlMpaXl1tWzKPRaE9pb6FQCLFYDDMzM8hmsxixujA6MIqbN29Cr9eDoijeiXZsla6xbU1RFFfRjcfj3HCRWCw+cU2xQzOBfBL/z+KTOKSyiAR3sZaOIFHK4QFlH2KxGCiKgsFg4FXN6YT9/X3YbDZuAeJjUVYfRKLVamG1WrG2tnZC/tGIs7YZ9S4Hvul9AsV0FlKdCgwD/PV3voJfv+sx3NNlSlurxZRdlFlS28u5zp4vo+YH4R60YTP1bUj7y6CDbkwZ393Vc/UpdfjtS4/i68svoiAr4IELV9F3JGlr69UIsZDEb00/jGfCW5hNHuGB0btwh6n/1OMYhoHP52saldqrY0M3YAsObrMVfzrxK3ghuosKQ0NtnoCLvrXyvnGtFZeVVny3vHc8iJYvYjQngFV8fvddNhq7HdRqNWZmZpBOp7G6ugqZTIbBwcFT5LMxBndnZ6ep1Kq+83YeaYaZTKZpkigLsViM4eHhlqmk/2/won3FJQedIBAI8LGPfQwf+9jHWj5GKpXi4x//OD7+8Y+f49H9ZNFNS4hhGPg3d/D+4ev4djmIXLUCKp7E+9yX4dEeD0g1kob6qmo8Hsfe3h6SxTx+uPYjQCDAjU98CdarEyD3D/D5/Lfwesc414JVKBTQ6/Udp1wJAYGPTD2Aj0e+iqxTD7veiLd5ZqCXHLsQ1FeYgWNCmk6nuQlk1maHJbmNn4fdbke1WsXSqhe78iOs7mzBrNLA5u5DMhJDJBI596oo63TQbaX3vG29GIZBMBhENBrtaZfucDiwtLTUM6FlK4GNN1WKx0AB6zDRLiI1m812nSIUCASQzWZx8eJFEASBaDTKaevZm6/VagVN01hZWWlL2NpBLBYfp5k1DHKwRDefz2N/f5/b8H0ruIpUMYFcOo3QygYM7j58cX0X11//MxgZGTn7+VlaAEqzoGg5YmE7rt15f9tBqk6w2+0oFArw+/0tnVJ6rdCyCBZSkJuPNxg3/uaLmHrHIzAM9YExqnp6zla/w5Jar9cLhmG6ch5ho2Ff9qfuw7D22A5yR7SDWDTedeXXodDi7f0zoCgKLtOx5rXbDo5ESOIh5zh0kQKutrCJ2tnZ4fxtm8FisTSNiD0PsIWE+s3qG13HRQeGYTA7Owuj0XjLhjIFAgGuMhpcefQ9KBAM7HINLILjocRuh5FbIZ/P85YBabVaXL58GclkEktLS9BoNPB4PNx3Ux+DWywWUa1WT6zXxWKRWxNdLte5VdYzmUzTIfDGY9fpdNjZ2XnVDDh3g1fFUNj/6ajVah3jOlmwO2Gr1YpJ+yReW7uOQrWC8kQeiVjrrGU2UaX+okxVitBVdnG45UeNoUFKxNC4HBjon8DVgd6MnWWkGK81DPBqH7KVYvYmy9rsZDIZRCIRUBTFGaazJNfZ14c//+e/R7icxVG1CnlZi9kvbuDfXHnolngd9kpogfOx9SqXy9jf30c6nYbNZut5l846FRSLxZ6qgmxufONr2+12pFIpRCKRpos9SxI6OVV0e0ysQ0K9PKaeFGs0GiSTSU6rW61WsbW11bM+vBlaEd2b0gJ2AxUU1zYRurkCg9uBGkEiEo8heXgIgiAgFou54VS2MiyVSjsvvukvA7H/LwAhtrYKcJv7sLWuRiZ/1HTSvxGtNs7Dw8fyjFgs1lKDeqbqTL6M+KYPpESMS7/8TlDJNBiahlZ82prwrGgktXwCLnZ2drgo5GbXutvtxvz8fE9ShsaNAGvrtby83DHchQ9YmUy7c9vpdGJ2dvbcCS17fbfarBIEgcHBQWxubnaUsvWKUCgErVaLQcdJAsYOFJ+V1KbT6Z6+I/beEIvFMD8/D71eD7fbjVglj38KzOMzuQ2IUyV88J43cK+zt7cHgiDgcrnOffaD74bU7XZjaWkJiUTiVCFGLBa/qhNYbxPaVwlomu540TVr2xICAVRiKVQGKfy+va4qvUS5CnU4B9pqwugjrwEpEYPKF3CHib9ZdCOy2WzPLfZmNjs0TSOdTiOVSmFvbw876Tj86ThKyTQiaztwzExA1+9AUXf+CyMAiESiM5lJ92rrVT/F6nQ6z4WIselH3VZCWa10q98bHx/H3NwcqiICgWoOQgGBC3o7cocpLj++3YagvrLKB1tbW2AY5kTFtfG80+l0SKVS3A3Z4/FgY2OjpVXdeeKK2Y3ntrwwjw5CYdBDLJbgjitXcffFOwCAs+ljp8RLpRIymQwqlQqXcgTgNPEVE5CGfxdiIQOqSiEQqqBYCsA9+TiGr/42r2PL5/MtfZunpqYwNzcHuVx+6hrutd2YTCaxu7sLuVyOR6/fg9l0CEKBABWNEtpEBR5x90SB73FMTU1hZWWlbTIi64Si0+naylJIkoTZbEYwGOyaFDIMc+r8l8vlXAenmaa8G6yvr3ckiwRBcOTqLK9VD9ZDutP1rdfrEQ6HkUwmO264ugXrv9rMy1itVnd0yeEDPnKDdmCtBSORCJ790Qv4THQZFAGU9oMgjmr4o9nv4H2GcRjU2lNBCOeFdtd9M0xNTWF2dvbUvIFMJvuJRNP3ituE9lWCTvKLdDqNra2ttm1bl8sFv9/Pi/zs7Owgl8vhY2/9BXx+40eYLdFwDw1iOAVYRL3r+rolJ53ARp2yxESQ2Ic0u41CPIXw/ArsUyPIHUSxRM5D6shxdkxnnVKvf/3zSH2qt/UaHB3Bi3EfZkObEB1aMW14eYGMRCIIBoOQyWRdT7F2glar5chgN1XeTgsmQRBQuK34za/8LdRDThAkCRxm8TPOy7j38tWOr9XojdgOrN1X4zneeN5ptVrs7e2deMzo6Ci8Xm9PpKQbjEr1uEtsxrqJQbhSxZDBhsfUL78/giC4imw7NBLfcimMTLyEClXDH/7vCO6/Lsf0mBJGTYH3sbVL1qsfDGmsanXy/W4E666gUqm4obSx2jguxf0IF7MwypS4pLXDu9RaV90OfM/fyclJrK2tHbdwtVKspMKQCkncax2CoERxVXs+r9/X14fZ2VnY7fauNb/NHl/vAlEul3uKSg4GgzAYDLzudX19ffB6vedCaNnExWZay2YYHR09TqXSas9Vx7uzs9O0c8RCrVZjeHgY8/PzPZPabuQG7WC1WrEnKKEcWUA2EMX6489h5OG7IZRLIbtiw7il/8yv0QrJZLKtfrYRBEFgcnISKysrJ7qCMpkM5XL5VWN72ojbhPZVgE4VB5bkdGqdsOL/di3yYrGI1dVVzt4JAN5kGsGbLWOw2+0oFou8k0OaIZPJnGtbtx7pdBq5nX0w+TJ0Livu/sjPoVY9gmV0AG+49ADUAlFTOybWLLt+II7Pje2l2B6+tP4cIBbhtWPTeMQ5DuIMEaEejwd7+wH8+hf/F45sWiRj+9haBR6yjeKayNgx5eU80O1wGN8F80v7S5BaDUjtHUAoFkMAYE1RwWt4DIuJxWJe55rX64VKpWqq80yn0yfOO7ai2Egm2JhmNjL2vEFRFDY2NvArD70FIpEI68YNOOx2bG5uIm/Md7VBOUV8ayaAsQNHafzKe0xQSAWgmSPMrcsgTXpht9s7VsByuVxbPbdYLMbo6CiWlpZO3AP4VmibEVnu/QgEuPZj1w0Wly5dwsLCwi2Njx4fH8enn/0OvvmjVeidVtRqwFdnn8P7HTO459JV/h0tgoDD4eAGrPji6Oioo+Z3Y2MDGxsbXXVPKIpqm7TWCLban81meyZo7GCuXq/vioCTJAmHw4GdnZ1zWx86dY5YaLVaDA8PY2Fhoet761k+q2Yol4qolsoQSsRQ6NUQCAhQ+SKS8UMwJtctG9pLp9MYGRnp6nfYyPHV1VWuoME6HdwmtLfRFu2ynXO5HG+C2dfXB7/f37S1HQwGEYlETuWH14vF5XI57+SQRhSLxVvSLkmn09jd3YVEIsH16cuwjg7id7/xGcgcNlRjSbzXMgmrQsMdfyPYOMP6gThWRsAOvrFm++zg22w8gE9sPI8ClQco4Gt7i6gc0XhrP7844FbYJUooaaTIbO2hki+C8B/gc+u7mHjop888xcoHDocDCwsLvAhtNwtmvJwHIRbhYG4VSpsBA/ddR6yU6/h7LIlvB4ZhuEW0WWW1WCw2jYlWqVRNqysXL17EwsICSJI89xao1+vF8PAwR5I0ajWy2SympqawvLx8tu9YIATsfwwcfAQyaR4EAZj7HoXL8x+RL5RwcHCAnZ0daLVaOByOE9dCrZBBbf1FFJdWIdO/BZC39qpWq9VwuVyn3CHaEdp2RLYd6j1kaZrmpVHtVvrA1Gp4iUijxjAIbeyAJISQyGUI6cmutZV2ux03btxoO4DV7Hg7PXZ0dBSBQABLS0uYmpridY6wnuHdnE8ejwfb29u8XD8awUreBgcHe7pu7HY7FhYWuNCQs4KP1IKFVqvF0NBQ16Q2HA6fS8eRdaaR1o5gNptxJBPDMOhCxh+CZ3QI/Qod5ubmIBaLYbVamybonQUURfW0NpvNZmQyGU62I5fLUSqVzpXknyduE9pXAarVatMdz8rKCqRSaVdieqvViq98/7uYQxoSoQh3WTzQCCVYX1+HTCZrSowbDe3ZQZ9u9Va9JCO1QzKZxN7eHmQy2QkLon6CwL+78CDGL0xBWAMWFhbaPg9JkqcG4liwSTeNk+qf276BFJ1HOpzAUaEI2/QYvpF4HpcE2qam4I2G4K0wH9pAIZZApVTB+j9/D1NvfxgqmxlChewnksBCkiSkUimvRWVra6ulL3I9KIqCMJJBLpXA2GP3I+0PAfQRHAptx+NJJBJtF1eGYTgC3orstDrvdDodDg8PT33vbFVsfn6eOzfOAxsbGzCbzSfa12q1Gvv7+3A6nXC73R3tsTpCNgN4vgVEvgGnZxj7BS2GBUIolUquUpVIJDgzfavVCotcBOILvw+U8qgFEmBSKxC86VdBjF5v+TJmsxmFQoGbdm5Voe2VyNaD1Zl7vV7QNH3ucpAqcwSKOYJYKcfq156AZWYUA3ddQa5a6en53G43F9rCB3wlPi6XC1KpFHNzcx0/y2QyCYFA0LVUQy6Xcylf3RAcPpI3PhgbGzsV5tMLQqHQsS9sF+9Bq9ViYGCgK1Lbi/sKC1bfG4vFTjjTeIqj+PzOTURLOTgsQvxs/x0YdroBzwDK5TLC4fAx+f2x9/xZOxdnDdUYHh7mQhfUajWq1eqZjudW4jahfRWgUqlAJHrZsLneyaBbm6XZeABfSW6glqhBbTXhGysv4a0qD+69eKXpza/VzXZ8fByzs7NQq9W8bxqHh4ctbX+6ATtIolAomtpThcNh2Gw2zuTaYrG0HfxoB7al21hx+D6ZRNy/jdLSJvKRGFRWI/Q2C2QyWdNYxsZ/awXCZcLmWg16AFK5DPoBF5h8EZn9MG76Q1CpVLBYLLc03YwdDmtXgU+n06jVam0rMfUJT79y/fX4ZHAe2WoZapsZRCKHd95z2hOzHmyVvNXCwgYxdGpHtzrv9Ho9QqFQ098hSRLT09NYXFw88yINHMuCmpExpVKJQuFY42o2m3F4eNjSEYIvqCMJpNppGB1T8N24ceoaZjXnNE0jEolg4R//CqQvALNcAgEYADXUnvoMaiPX2mpjPR4PFpaX8KfPfgOzBz6oAzo8NnYFjzoncHh4eGYiWw92k7GysoJqtdqxpd/N5q9WpSHYP0S1RmHwdXdDYzcjvrUHq6W7DhQLs9mMQCDAmyh0o1k3m82QSqVtz0uGYbCzs9PUc5YP+vv74fP5eHfgQqEQIpHIuQTVSKVSGAyGnu/XQPtBsE5g72d8SG2vA87FYhF+vx+FQgF2u/1UV8YiV+PfXngQwPF7mZ+fB5zH9y+pVAqPxwOPx8N5yft8Pi4Gu5d1oV2gAl9MTU1hcXERfaNDWE9HkVeQuHpEQyx8dVHIV9fR/B+E+oWkUqUgEh+Ts7O2db6wOwuZUYeDxXUUc3mIhCT2+gbxWIsLIZvNNp1+ZEXhfPW07M39LFVGvtWeeDyOy5cvc393uVy4ceMG7Hb7uWlPL8jNeD76IkYeugupvRCkOhU89DH5PUtFb9rgxCPOCXwnuAoQAkjFYnzoNQ9hQnccKpBOpxGPx7G9vQ2xWMyRk/P0cOw0HMamrU1Pt5ZXxGIx+P3+EwlPv2N1YCcbh1BAoLgXBspVoI0tUzu5AUVRWFpa6mhF1U6Dy1qutYJYLMaFCxewvLx8Jv/ifD6PYDB44pxshdHRUW6j2CuJLhaLXEfHZrMhGAw2JQckScLpdMJm16KYU+HpzRA2Exkcj5/GIVmYh1SugFQqhUgkglwu56zD2M9zjszh2c1l1GoAoZbjc/PPILCygQcHL5wLkW3E5ORkT3rSVvD7/YjH4/iNB9+G/7n8NEKCKKRaNe7rH4ezJOiZWA0MDGBnZ4cXKaRpuqv7olqt5s7LZgNrPp8PDoej53sdG4fLx45wa2sLFEV1FTveCR6PBzdu3IDVau3p/Nna2jpTSARfUttt2AubWEiSJG/bLdY9o9l5qFQquS5ANptFOBzG1tYWF4/Nl2ynUqmeQmvqIRaLQVi0+Ldf/l+Ih0JQ0gn458X499MPQSl69ehpbxPaVxDJcgH/a+1ZfHvzR/i+Iod3CkpwFQW80qVomuba5az1T6VSwe7yGo5qDIIvLMA8OYTB+6+jyLRuEbRLD+lGTxuJRHpujXTTtszn85DJTrfnPR4Ptra2utb9NkMsFoMhU8UHH3obfhDfhUBXwh3uMfz05J3Y3txqG1HcCQKBAG/3zOAB+zDmZEuYHhqDSfvy519vW1YulxGLxbC6ugqapqHT6WAymc6lRW6xWFoOh/n9flgslqbfQz6fx+bmJhQKxamKjZwU44L+2N6mLNN1bC0mEommgwoURWFxcZGXR2cnmYtMJmvrvSuVSjE+Po7l5eWe/Cppmsba2hqmp6dbng/1x8BuFFdXV3sevKzXDNvtdszOzrYlZQJLP8itBZjUMjw64QQhJAG9FbULF192UCiXcXh4iHK5jEqlwskLvrP8DBiGwcrXn4LW5YDz8gSSF/tu2eAncEz6fT5fyzAMPhpatkVusVi4c/CXDi9BckEDk04PreT4fNjZ2cHS0hImJia6Ioh6vR57e3u8Wve1Wq3r71kqleLSpUtYWlqC0WLGjyoxfH/jeTzDJDBGSfDGe1/b1fM1gu3StKqEs7p1jUZzS77r0dFRrK+vd63lzWazqFQqZ27D6/V6Ts7U6jpsHDRthnpZgV6v7ymWtt49o9U5WC+ZSyaT8Pv9KBaL0Ov1sNlsLe9vZbqKVPZ8BrW/GF6BSK1EMZWFXKdCrJTDvwSW8d7B8/d/7xW3Ce0riI97v49IKYfa0RGKuTw++/x38ZtvfA+USiW3yBSLRVQqFe7/7M2cndyXSqWQyWRcfOydiOHG8iIm3/EQyskMagyDIU3rBT+TybQVvfPV03bSQjZDLBZDIBCARqPhXe05ODho6gloNBoRDAbPPHAQCASQTCa5NtGjngvIT+Th9/uhlCswMzODUCiE2dnZnuyGWOglCoyYHTgqt9bxSaVSuFwuuFwuMAyDZDKJg4MDbGxsQCaTwWw2Q6/X91SpYQc0GgktS2waiSibRHV0dISxsbGO1UW2tdjKIou1pGokA2yHgm9kcGO1vhE6nQ7JZLLt8bKVkMbJfj5YWlo6MQTWDCqVCtlsljsGdqO4tbXVUxWyUqlw1lusd3MzE3QWgutvwvqLP8Sw8ceVQrkaxGP/GgKS5Fw/mqFcLkO89RyKh4dQOWyQaTUQyaRI7h3gJnGTi8BWqVTc85xnFS8YDLYckmr1OjRNc4lpjRuUUrGIqQaCPDg4iGQyifn5+a5DDoaGhrC9vd1xxoHPUFgzsLKY//z1T8FP51Au5xFenMX6gBNXillY5L1vbK1WK27cuNHU8qpcLsPr9d5S5wm1Wg2RSNT1nMZ5BjSw742t1NZ/Dp3CXvL54zWhVCo1lRV0A4IgutJls4EN7Jqwu7uLcrkMk8kEi8UCqVSKLFXGX689i810FMltP95jEOKdnssgeNrvNRbMiuUSttc3wFBVhGaXUKsxcFyeQpTH4O9PErcJ7SuEEl1FsJAGQRDYv7kCqlSGY3oC3/3RcxC7MhxRlUgk0Gg03Ina6aJ5ROmGT7KNqkUNQkDAWSHxZveFlo/nM/3YSU/bSQvZiHoi24uNSisSMDIygs3NTd7eiI3Y2toCTdOnfl+pVKJYLHJ/t9vtMBqNWF9fRzgcxujoaE83M6VSiUwmw+uxBEGc8OMtFouIx+NYWloCABgMBphMJt5t7FbDYZubmyeqpmzkbSKR6FoG43a7MTs7C6vVeuo7buaLyCcitx5skly7z16v12N7e7vjoJFWq0V/f3/Txa0Vtra2YDQaO25q1Go14vGTsal2ux1er7ctEW2FYrF4YhPqdrvh9XpbPk88mYLk0V+E3qIFqhXA4IBA1JqAJxIJBINBAMCjY5fxTD4IkUQCAUFAadbh5648ggt6BxenzbZDC4UCJ2NhI7PVanXPRNfpdIIkSd7fSSQS4aqOjZ9Fu42uXq+HUqnkAhb4zgGo1WruM2i3+TpLZHC6WkbSJMXRfgr+5+fhumsGAoLACzHfmR1X2Dhci90GESEEcHx/ZTty5+mB3QysPyzfif5uPHf5ohWpZec0GsHKCsRiMVwu17kNlJrNZnxz8UV8Or4KQiLEdZMHj/a1t4msXxMYhkEsFsP6+jpomsY3kpsIC49AVcogZVI8dbABg0SB1znGTnpb/7gjUyqVTvitsxZvUqkUEokEarUansEBxLNp2C9PQe/pAwEBbLJXl9vBbUL7CqFeTG0e90A74IJ1Ygjj9mFc7bGEn06nQaVz+PN3/CripTwICODzrkGI5rsyvpGunfS0fKyXgJcXHL1e35PXaiKRaEuo5HI5JBJJ1ySBYRisrq5CpVK13CFrtdoTSTdisRgXL15ELBbD7OxsT5pnuVzecmiJz++63W643W7QNM3t1EulEpRKJUwmE/R6fduFwuVynRgOi8ViEIlE3E26mU62GxAE0VIKEo1GTxAHdiHtRssaiUQ6Vnfqc9M7gR2karSravXaFEXxqqio1Wrs7u6e+veJiQluo9hNm7JSqZz4jMRiMcRicVNiRdM0/H4/rly5AkGbc4GiKBwcHCCRSECrfTmxaLpWg2HPi+9GcjA5bRim5ZyspFmcNgCO5LFDLc2IrlKphFqt7khk2M3Q3NwcZmZmwAiAcCENfaUI248/g2KxyMlgWlXKotEoTCZTy9cRi8WYmZmBz+fDwsICJiYmeH0nQ0NDHTfRZyG0R7Ufd+TEItBUBcV8AYe+IDZyBG4mqiBJEhKJBHK5HDKZjEt24vN6BaUIv/f1T0M+5IROLMebdUOQZMtnjorlC5Ik4Xa7eXUqaJruynO3G7BrxYuzN7CmpLGdiyO94cdHHns39DgfWUEn/CjmwzN0DLmtQxgG+vB1/yKqDI23dNi0sJ0umqYhlUqPveRLRSzPfRuFRBqhhVXoR/pRLZTw7VAWmsH8KbKq1Wp5xW7/6tRr8J+/9AnIDFoQJAG7QoPH2hTLXgncJrSvEERCIV7vGMP3wpvQ9zshlUhQK1bwgK0782MW5XIZW1tbuHTpEggBwbWjqk5nSyPwbDbbMjWoEe30tLFYDBMTEy1/t57InmVSNhQKYWhoqO1j2F1/JzLHgnWUaGcLBRxXMw4ODk6RVrbtv7GxwVVr+b6/bshWO7CDBSy5y2aznN9ufdJaI1FUq9X43vyP4JMfQUGKQewncNfV65xOVqVSnXmy2Wg0IhQKnSJbxWKR+zurd+x2IeUjc0lVingivIFnZ5MYNtrwSN8EV41qBqvVCpqmW+o3ge6GwIDWoQQEQXDpZXyfC2hOkNiUwMZj3tjYaDtAk06nEQwGQVFU09apQCDAjMyEiTveAJfLhaWlpbaaZPZ9dSK69X7QjUS3MfjEaDSCJEn8y3Pfx/cFhzjY80OT28Hr+sZwJ2lEMpnE2NhY24oi3zQ6j8eDdDqNxcVFXpIiuVwOkUiEdDrd8rG9RAaz0ItlkMRyyFSquPoL70Jqbx/GYTfeOf0QBtUmMAyDYrGIYrGIUqmEw8NDVCqVE10zmUzGkV2pVAq5XI40VcJfrj2DqkSIcjoLfyGKv9zYxsff9a9+ImSWBRv00inA4KyDYJ1gMBjw3eXvw7u0BYXdjFKtgj966XG8RzcCPSE5s6wAwAlbx3rLR4Zh8PjaHBiaRjYcQekwA43Tgq9Hn8FYRYpqtQqappsOuJIkCZIkIRQKIRaLj/9MCGGwWSGUikEV89CPDcDsdmLM5MLVsd71rmSqiP/P696Nbzz1BKxWM35m5pG299JXArcJ7SuIt7unYZVr8E/eAIZGRzEp1vWki2IYhtMdNpIP1gi8mVYqk8l0ZefB6mnrbYfYC7PZTTAUCuHg4ABGo/HMxIimaVAU1bEVTZIkLBZLy8nvenTjKKFWq7GxsdHyNScnJ5FIJDA/Pw+3231LUqj4op5MUBSFRCKBzc1NUBQFjUYDk8kErVaLZ8Lb+GJ8DURiA1SlAqtKC/mqHCIQJ3x/z4qRkZETA2LpdJo7PnYgsNvzg4/MJUuV8XvzjyNcSUKwn8FGMQFf7hAfnry/rV2V0+lEtVrlYlEbX3dtbQ0XLlzoanFjI5QbrxO1Wg2j0cj5vfYKtVrNtQ3Z10gmk6jVaqe6FQzDIBgMIhqNQqlUor+/vyMZ7OvrA3A83d+rMX8vRFcmk0GlUkEml+NJKoTQnh9MTYBKvoAvPv04FNdeh7dcvaft63aTRgccd2MuXbrEDUV1IsKDg4PckN95gt1sf+jKQ/hOzo+dbByETIWf67uEQfVxtZkgiLY6aDZUplwuo1AoIB6Po1QqYSkRRMi/BaCG+c/+C8befD/0bie2s3EYZLdWatCIxvtDI7LZLKrV6i3T8wJAmiohTFYhUskx+w9fhdZjhyaRwsKoDO8Yu4ZCocA5wxwdHZ0ip3xQb+8oEAhO2DwW83mUsgWUDjOoyirQD/VBIpFybhbdOgg9FB/FF2LPof+uqyinsyAEAjzk6H1gulgscrMVG4ZlGNSGVx2ZBW4T2lcUAoEA99uHUfLMYGJoAtVqFaFQqGvvWa/XC4/H0/Km1iquMZPJcAsVX9TraY9IAtFY9BQZPE8iy4JPe5kFHxsvVq/ZjVZMrVa3rcQYjUauWhuJRDA2Ntax2sFaS92qqFuxWAy73c6dU+l0GtFoFGubG/jL1achVEhxGAiCqdKg9WWsu3L4men7zvUYpFIpdDodDoIHsCj0iOwFYfU4OT1aL9P+fIZJXorvIVctQ6RSILa+DalODW8qhHAxC7ui/UbO4/FgY2MDu3s+BCVHiBQzMMlUUEVyGBwc7JrsazQaZLPZpouyy+XCwsJC23OLRbtzxel0IrizBY9JA0ahO+VVWj/IYrVaeVecCoUCd42w/z+vtCegPdEtFovIZrPYOgggvH8AmqKx+OXvYPKxB+G8NIGCqnM1sZfAF5IkMTMzA7/fj7m5ubZtZjZtsBc9dCuw9ye2SjyG42S3/HQee3t7vJ+nVagMkTDhBVke5XQW2qE+SFQKFJMZ7K1uQLh/2LFqfp6QSqVcbHsz/fJ5DoKxqNd/ZzIZRDMpxNd3IZSIIYAAGqsFxn4nDBYTdDpdU+9xPr7jfPGwuIq/+M6X4LrrMqrFEhQ6DR50tO86tEIsFsMoocZvvem9WEoeILK5i1+YeQR9yuZuRnywvr6OsbEx7u9HR0c9P9etxG1C+yqASCTC0dERPB4PZmdnYTabed88dnZ2oFKp2t5IW8U19kKkCILA8NgofuefP42kVYHU3gEujU7go30OpKJxhMNhGI3Gc49xjcViXVWF2tl4JZNJ7OzsdN3itlgsiEajbUkHQRAYHx/n2pYOh6PtBkWhUCCfz9/SIIV6sG4YRCyMo9UaMr4gbvzdF+G6/y4MGHTY3tnBkkADkUgEsVgMkUjE6avY/3pZ2Pr0Njz9P76EmtIFX2gLzOVRVC4qMXOpN3/LTjIXAKgcVXFUqSIbjCDq3YZUqUSNYXCzdgP9WvOJVizbjq3H8MgI/svX/h5+FKE26ZEKRjCgMeO/9mBor1KpkMvlWl6nU1NTmJ+f73hOtor5BQDz4TZe+sT/QJ9dh61kEY43/DwIgkAoFEIoFOJcM7oZZGl2j2Cn+3up0naD+uqjzmyCKb2KwmEag6+/C6YxD4QiEipR543F4eFhz8fqdruh0+mwuLjYtpMzODjIDTidFYlEAj6fr6meXKlUgqKoM6c/TehssMs1WNkOYOTBO1FJZjE1PYm3zzwEESHsWDWvJ7rnIVFwuVy4efMmN/zM4jwGwSiKQjabRS6XQy6XA0VRJxw6PB4PJmQTWFBWsBINYPTR+1CjqhArFHj96CXoVecbj92IcrkMVTSPX7r/Mfzw0IfIbgAPOcfxVnf3Q39skYAdcLvDOoCbRdmZyGwkEuGcTF7tuE1oXyHUL+IikYi7yNxuN3Z2dnjZ+cRiMZRKJV67176+Pvj9fq6teZYb4ndiWwhLjlDeD4MuV7B+4Md/C3wKH7zjkXMnssDxBc9qhfiCtfFKZtKgRAQ0YhlkpOhMqTdsIAHfx165cgU7OztYWFjghmwaoVAoUCwWbxmhZRiGq0JkMhnOGUCpUsFst0KiUuCuD/8smAoNpcWA11y5GxPm4whGduEsl8vI5XIol8ucnosF20aTSCQtCTBBEMh9cxMOkR6r4W1kyznElvdweeQ1PZ0r7WQu9dDkGSR9+1C77HDfOQN9fx90SgUevfoAcHQc/5nP55FKpRAKhUBRFKdPlUgkiBwVsVcrIBeKIRONQyKTIaEUwJsMYdrQXTyrWq1uOwBIkiSGh4exurradsCole9pLRFE7bt/D7NcjK1EFqlSBfjmJxGsELAMj/c0hAk0Txlih4466R7PEzJShDdYR/H3a9+Ec2oE1UIJWpMFr7W3nzno1oGlGdRqNS5duoTV1VWkUqmm0hCSJLlkum47bPXw+XzI5XJt76OsXvos3qJiIYkPj9yH/x1MQzHoQFkYwgeG7ubayJ2q5ux1w+qvgWO/ZaVSyZGfbteXsbExrK+vHw//1Wpgjo66HgRjK/oseWUYBmKxGCqVCiqVCg6Ho+Vx/euJ1+DPo19H2EZCJZHhKmmE+ydAZpeXlzExMYHrSiUew2XcFN/EVU/3m2bWnaTREUQsFve83tM0jf39fe47oGkaQuGrT2rA4jahfQXB6m9IkuTykc1mM4LBYMfBi3w+j0AgwFu3Ve87SJLkmeLwVpIhCEQk9l6YRymZxoW3PYKiQ3susbfNcHBw0FNUaMWgwK995W+gHnJCKBDgftKKKZX5TKk3SqWS90JOEASGh4eRzWaxvLwMm812yj5KLpcjHo/3dCzNkM/nkU6nkclkUCqVQBAEVCoVNBoNbDbbiZvah7Uy/M5XPwWDx4XCYQrOMolp2fEATje78XriS1EUCoUCUqkUKpUKKIrC0dERki8tAgD+5pkv4FLfKO4bugr6IN/Te4zFYm0n1ovFItbX1+HQ6fAf3/Kz+Oz2DVCaPNRV4KNTDx47jAiPb/TNvkc26z4S2AQYBiKFDDc/+WXc8a9+GgCQq7b2Dm4FdlFpB61WC41G07L1CgClUqlphbYW8QG1GixyGX7+80/jt143DZNSjLE+A4gzXJeHh4dNfaoHBgbOZJHXLRiGgSNTw398w09jN59AJhjF+y89CkWHlCK+DiydQJIkLl68iEAg0FKCwHbYrFbrifsLn3sN67Qik8k6VpONRiN8Pt+Z3BMAIBmJ4pfveQRGoxFpZxrhgzAMam3b32mn2WWJbiaTOUF0pVIpVCoVV9VtVW1VKpU4qObxN9/6OzAqKYhwGh+669GWaYb1koFSqQQAnObaZDJ1HX4jI0V4na6fk0B5vV5eMqBe0a3ndjskk0kEAoGmaxvbBewleXRjY+PE50hRFEQiEWq12pmO91bhNqF9hUHTNORy+YnFjt2ptiKrFEV1TCdqhnrz5kwm05YU1IOt8h0eHiKTySC7vY9KrQTz5DCOKArlTA6SM1QlOiGZTPKaUK5HulLEP/hnwYiPp3iLqSy+Ko7gzjf9/JkWAVZ20E1lSq1W48qVK5werz6YQKlUdqWJqwdFURx5ZasRMpkMOp0OHo+n4wCdMJHDf3/Dz4JSiLGzvIqH7rwXCwsLIEfJrt4fW4ltd1OOvnCE+GEMb5q8Hw6dGYsHG7AbPVDTY11Xz2KxWNOEMeC4wnV4eIiJiQnI5XJ4AFw1uZHOZRHaD8Ku0HZ8foIgIJfLcdE9BHViDXSliivvfwuqhSISm3twXnyoq+Otf95OJMTj8WBubg46na7pd1Aul2EwGE79u0CuRoWmcSMUx6MjdoyaNFBKxRDI+LmYtEIul2taCeQz3X+e2NnZgdVqhdPpxB0Yxs3CzY5kFuAnTekGbKTp4uLiKb9bgiCaDqR2GhpiY56dTifvjXu7yGM+YBjmRBIWG4d7ls4dK91pRLlc5qqmkUiEc3Zhtccs0U3XqvhGyY94MAiVzYxSIYu/P5jHfzFYUC2W2koGeo2RrkexWDzh9T4yMoLFxcWeLAs7gSWzfD2324G1bGw1i8DKnboltOl0GrVa7cTvURQFmUx2JueOW4nbhPYVBk3TkEgkKBQK3L/J5XIoFIqmgy8Mw2BpaQmjo6Nd33jMZjMWNtewWMvAv7mFt5lfD22Lx7IENpVKgWEYaDQajiipBp344+WnAKYGhdkACGqYphTY2dk5d2uVbDbbkzH7fiEFusZArlfhxb/+Aqbe8TA0Dgt2c/EztZH0en1TT9FOYD1ZTSYTVldXYTKZjofXDgP4562bWJCV8KBjFC5l82NjFyBWOsC23FnXgm6rEfl8HqVSiZO25GT7EIlEmJ6exuLi4rncaOtRu27Awee8mPFMgBAIYDNaUL3bivn5eWi1x9V9Pudzq4SxfD6P9fV1mM3mU9PSAoEAOrUGOyV+chEWJpkSP9t3CX++6YOu34F8OIFfvOMhxDf3oB0WdU3k2EpJp83C1NQUFhcXm8piSqVS0wpX2TqERUYDgzwH/aAD4VwJwxPXgL7ebACBl4lYq/PqVk33NyKRSKBSqZwi1p02B3ylKd2ClSCsr68jlUqdOC6n04nZ2Vk4nU5e1yPrv9xtShmfyON2CAaDp4IDWF/qs7htNINUKm1+zv5Y8sO6L/zAv4bEgQ9UsYJn//zvMfX2R7G7vIanaT0uOvo7SgbOinA4fGJDIRaLYbFYEAgEev6cm6FYLHK2gGe9x6bTaezu7rbtOqrVasRisa6el2EYzkqxHqxk7TzsJm8FbhPaVwj1JfxmFar6IYP6E3VtbQ12u70n7Vogn8Q/ZTZR8GdRLZaxvfQkPjT5GlzQO5DNZpFKpZBKpUDTNFQqFQwGw6lBMgAY1pjx2zOP4LOH30Jf/zCuWzwY0RxLJWZnZ7u+ObdDq6jbThAzAqT8BziqVNF3fQY1+giHu/sQe86eOy2TyXqe8lYqlbh69Sr8fj/+/FtfwAJZQDYdQSqmwEtxP35r+iH0qwycdCCdTqNcLoMgCGg0Gmg0mqbfSbfY3Nw8MbXKki2lUokLFy5geXm5q5CDdiiXy9gXpnH3v/kpxJcDKNJlGB66BFIrhRMeJBIJeL1eSCSSjg4CiUTiRIWSYRjs7OygUChgamqq7e/2oiVTZSh8/K0fBC0RYte7hruHp0/k3HfTOdBoNCcsy9odp8fjwfr6+il9fLMhreMFchUXfu13sfHNz2PKKMd8LA/ip34FgjZJQ53QSZbEphneyiotRVHw+Xwn3BqAl7Xn7a7BZDLZtJp9HiBJElNTUwgGg7h58yZ37hEEccpVphXRiEQiCAaDPQUZEAQBvV7fdXQsi2g0ekqbyjoN3Eq/13qwRJetcif0YrxAx1HZO4De44JYIYPB04eLFy/Ao751ll0smnkVs445Vqv1XIg0HzIrFot5DWyn02lsb2931Mf34nfOBuo0vmdWclCfnPlqwm1C+wqjVQWBJEk4HA48Pv8CynoFlCIJXJSYs2HqBV/bW4RIrUR+148jpoZMOIY/D3wJHxy9BwqFAgaDgfO96wSXUo+HHGO4OvIyQXQ6nTCbzVhfX4dIJOo5EpYFq5PqhhyzUa2ZeBzXPaPYYvIgBIBhyA0TI4YwnMZO5WyVZFZ2cBbdk8vlwsr208jshZHcC4KRiCAWkvjbyNfw1v5pKBQKaDQaDAwMnGulFDi2VdNoNCeelyVbrMZtfHwcy8vL5+IfXK8Tq5mliEajILUvE082+CGdTmN9fR0EQWBgYODE50sd0YiX89jb38Ol8WOSxwYyOBwO3hnoiUSC9/WTTh9HU5v1x6SoZDQjmUzCaDTytnSqh1qths/n4/XaRqMRh4eHCAaDbWN76xPWxGIxmKHLEF+9Cv3WFlLpTE+6ORapVOpUPHEjPB7PLa3Ser3epmElKpWK6960QmMa3a2A0+mEVqvF8vIy5z9d7yrT6h6zs7ODUqnUk2Udi76+PiwtLXVNaNk0uGave1YpQ6+gaRqySBbiIgXDQB8URh2EpAjKRPGWD2YBp+UG9RgeHj4X6zCWzHYqFIhEIpTL5bbndjab5YKU+N6f+Wqu6z1nG1GtViGRSG5raG/jNNj2aaupwaWjFP527vswDvSBKlcgTBXwZ+/5UNvnZAdz6nOaKYpCpVLB6uoiYqU8Eus+FJMZGN/zRkjMupaG1r2gMRK2Wa46X3Tr68j63zocDly/fh1Xawyejezg+VQN030X8Pq+cYiFJEKhEGZnZztaarWCXq/vWffKgkENhFgEhUmPrSeeB12tYvD+O2Du8+DqxfP7PhrBxjg2Vme0Wi18Ph9HnpRKJYaHh7GwsHCmRdfr9WJwcJC7ObcbjtJqtZiZmUE+n+dsgvr7+5EWHuEvVp5GrlpBfH0X71DVcIXRgKKorqpbrFyE73e+vb19YhGz2WzY3d3lzsl6Syc+57lcLueGV/hgeHgYc3Nz0Gq1UCqVpxakxoS1RCLBEVCbzYa9vb0zEdpMJtOxAs3qIOtjoc8LPp8PBoOh6YZWrVYjHA63/f1OFdzzglKpxJUrV7C2tsZJENh5BY/Hc4Jw1Ff3z0qQxGIxZDJZ124TgUCg5WufVcrQC9iI7aHBQfw/E2P41I+eQlpawoWBYVyAGmuray1T+84L0Wi0pX5Zq9UiGAyeqRPB+grz6Xp1GiBlN7HT09O8ySyfjgaLRs/ZerAV2lcrbhPaVxhsBjNJkicWrBJdxdf2FqFxWrG/sgERQULnsuOrS8/jftMgKpUKR1brtW711kkSiQRqtZqzUXpAzeDp8BbEKgWoXAE1+ggjxu7dA4DW9kEs6iNhI5EIRkZGum7ZhEKhlhdWPVhRvMFgOGF3QwgI3G8bhmGggiHr0PF0O8DF3Pr9fty8eRNDQ0Nd3agIgoBUKu3oRNEOghqgTpSQyuUw/NBdUOi1yIVimLhwb0/Pxxc7OztNU+OakS2tVov+/n4sLCz05AyxtrbGhU2wEIvFnKNHKyiVSkxNTaFcLmN7dwd/8KNvQmBQQyAAGABfevo70Nz9KB67eL2r45HL5bxbb7FYDBqN5sQ53uwzaqenPCsIgsDU1BSWl5dx5coVZAuHEImPN7/NEtbi8Tgnz1EqlSiXy2eahOf7ux6PB0tLS+dKaFm9eCsXBaVSeWLuoNnv/6QsxYDj72pychKhUIir2m/sbmGNySIYCUDtccAqUmB5eflMm/xGeDyerjyB8/k8N8TZ6n2wcdVnsR/jA5qmsb6+DqFQeOK+/UbLKGw2G/f9BQIBeL3ecw9XqMfh4WHbav7IyAiWlpZ6Kv50Q2aBl208Wz0XS2a7kk7x6GgAx2tuO8/ZarV6bgmStwK3Ce0rBDZ6s1qtQqlUcicxe7IU6ApqAMRKOXa/+wK0bjtIEYmkxg5pn/QEUeW7YL3VM41wKYMfbu9BN+CCOJrGW8ydCWMztDN4Z8FGwvINGagHS9TbXTz5fB7b29uQSCS4ePFiywtcKBSeysFmh7QcDge2trYQCAQwNDTEm6CazWZEo9Gu3ReAl3fY/+raQ/hqchM//NGLUJoMeGjgItSRPCjr2UzTW6FxEKwRzabwjUYjaJqG1+vtypw+EAiAIIhT7XKCIJpmkjeDVCqFdcANcdiKzEEU85/9Gjz3XMXQa64i03nAveVzdtqMsbKVRt0mcEzyG6uRrfSUzSCTybraCEmlUhitCnzi+x8EI4+gVDhCnHgTNKU7T1XOG+U5JpMJkUikJ2KSzWahUvFzSGB9Ps8rKYum6aYDKfVgz9VWiEajTe3GbjXsdju0Wi2eu3kD/3gwj7Q3C1IsxkvPJvAAacE7737wXKvGcrmcs5njQzT8fn/H6mtfXx8WFhZuKaFlq7LNwipKpdKJz8jlciEYDGJpaemWhHm0kxuwEIvFMJlMXQ+IdUtmgdaaV/a5etFc8+lotOreNT5GKpW+al0Obr3y+zbagtXQslnvLHRiOVQiCWo0jfE3PwDz+ACEchmUpSPQNM0R2m6qL1KhCB+dehAfHL4H/+2ut+JP3vGriPmDHf0xmyGfz0OhUPB6LBsyUCgUsLCwwKtKFolEWraAKIrCysoKtre3MTIygvHx8bYXOBsv2wxisRiTk5MYGBjA+vo6NjY2eBEuVuPYLXw+H7a3tzE9PY0Bpwu/cfH1+PfTD+Ev7nkPfm76NZiYmMDi4uItEd03DoI1gt3FN8JqtUKv12NlZYXX68RiMaTTaV7hIJ0gJ0Qoxg/BVCoYeeReaJwWJHaCEFV703BptVokEom2j9nf34fFYmnazrPZbC0XBqfTibGxMSwvL7ecKm71GbfDFvNZZCv7OAyVUMhW8KONr0LlSZy49svl8qkNps1m63q6mQUf/Ww9PB7PmWU4LFZXVzE4ONhx0W7Xms1msz+x9L1GyOVyRMxiFKoUkv4Q0uEosuEY5qQF3vfMbsAGLXQCRVEolUodK9ckSXIblPMGuzk+PDzElStXmlb12USyejidThiNRiwtLZ07meIbjdzX14doNMp7vawnoN1UNcViMSqVk17XxWKRI8a9FDs6dTSA056zzdDsu3k14dV7ZP8HgGEYVKtVkCR56uYsJAj82uT9EOQqUBh00LrsuMPkxs+97jFUq1XMzs7C7/fzrnaxEAgE0EnlsMrVkEqkXDpRtyiVSl2129mQgaGhIXi93o434FgsdorQshPtS0tLcDgcmJmZ4XUM7QgtC6VSicuXL8NgMGB+fh6BQKDtjZOVd/BtYZfLZczNzYEgCFy+fPnETUlECCH88TQ66zKwsrLSNfFpB3YQrN2NVaPRIJPJNP2Z0+mEXC7vmJSWzWbbavS6QSgUwsriEh4bmoFpbABaixkamwXuwX7Y88e2Mt0ubkajEclksuXPaZpGLBZrWYVRKpVtNxusnjIej2Ntbe3U8Wm12pafcdPjYSo4LG9Cb5Pghe8EkAoX4RrTIlZaPvG4WCx2ihyw51gvG9ZUKtUVIWQt5Hol0CyCwSAUCgUv+UKrzUE+nz/3QcpuEc9lIBCRKKZy2HryBYikUuQKBdC1869s6fV65HK5jve4/f193tVFj8eDQCBwHofHIRaLYX5+Hna7HePj4y0DE1oRJrvdfktI7eHhIa/OAkEQGBwc5JUWmc1me66mNnIBvsNk7dCpo9HMc7bX53olcZvQvsJgK7TNdDMelRG/7LiE//rge/Dnj/w8HraPoVAowO1248qVKxCJRJifn8fGxgZvYtVoW6TVaqHT6XhPX7PoltCyYG2rAODmzZvI50+nRTVrAbGWYAqFAlevXu1qsW0mOWgFo9HItVxmZ2fbVilY2UEnRCIRLC8vY2Rk5JROq5mnqlQqxfT0NDY3N9uSL75gW0md5BGdyJbH4wHDMC3PFYqisLGxgYsXL54twSiZxM2bN1GpVHDlyhX8zNXX4sOT9+MexzAedY7jv97zdtx7/S6oVCrMzs4iEonwfm6pVNqW4LEa43bQarVIp9Mtf87qKXU6HWZnZ08QYD6VEhY0TSN0EMHeahbRQBFTd1jguaiFkBBCJDx57SWTyaZVJqvV2rHV2Oq1u12IPR4Pr0phK+TzeUQiEd4+qK02YPF4/BWRGxSLRfh8Pty8eROiRB4imQSuOy7ivn/3i5Dr1JDkKSzMzmFnZ+fcOzB2ux0HBwctf84wTMtzpBlYne15bKr5VGVZdJKysfMP50Vqy+VyV7I9vV6Po6Ojtp9L/dBWL9XUKFXAbHQP25k4SqUSZ/N1Vu1qq44G6znbKqymGW67HNzGCbAaWraE36zaxzAMBDVgUH98c1aMjWFxcZET0NvtdtjtdiSTSayurkIsFqO/v7+tRquZVMDtdmNhYaGrSWU+Pnnt4Ha7YbFYsL6+DoVCgYGBATwX28XNuB+p/RAeHjm2AUokEvD5fDCbzW3zzduBT4W2HgRBwOVywW63Y2dnB4FAACMjI6c+V7PZjLm5uZYEqNXQQz3K5TIkktOCULFYjJmZGSwtLYGm6Z68Jlm0GgRr9pqdqnmjo6NYWVlBMBiE3eFAhipBRBCQC8VYWlrqKP8AXv4+mvmpbm5uNtVEX9A7oPbQkMlkXEKU1WqF2WzGzs4OQqFQ0++oGVrpWMvlMgqFQkephMViwcHBQcdNldVqhVqtxurqKnetEgQB+ugIlSMaEmHz6yeRSCAUCoGiKFitVrzx7g9gNf0lZA8pVKkjEAISo7rHuMezAQLNrsdO52gz8NHHNwNJktDr9YfeB64AAQAASURBVG3lQq3AMAzXUuULpVLZtIrYacDnPFEsFhEOh5FKpSCVSmE2m+F2uzGNS2BWn8HTL/wQUpUCapEU//b+18Iu0yCZTHKpXCaTqanfZ7ewWq2YnZ1t+b4jkUjX95CBgYGuBs6aoZ1Wthn4SNnYaOFeh1Xr0RimwAcjIyPwer1NB8TOSmYf31/FV/cWEN/ZxQ+YONyZGn7j0XefS8eB7Wg0VqNbec62wqtZcnCb0L5KIBaLkcvlTvxbY2a9WCyGw+GAz+c7UcXQ6/XQ6/Un7I5cLlfTG0gum2l6w5iamsL8/DyUSuUtS2JphFQqxczMDEKhEP7iW1/CnDALqUqB2MEeDggKof19XHIMnNkLtddkE5IkMTo6imKxiO3tbQiFQgwPD3OfD0EQnPa58TNjLZU6TTQXi8WmhJZ9/ZmZGXi9XlAU1daPtBU6DYI1e81Om5XJyUk8d+NH+PjqD5CWHW/MrIkKPnTPmzoSylgphx8dBrC3Q+Nu1yjMMhUoisLOzg4qlQqGhoZaPker4b7h4WGODMtkMgwODrY9fp1Oh0Qicar9urm5iaGhobbHDxwPWGxsbHR8HHCsp7x8+TK2trbg9XqxJqvgi96noMquYcxowwfH74VafBzUcXBwgGw2C71ef2JA0VF7N9RSG3YELyIZKeER9wegkfRxr5FMJlvqXVlHjm6CQNo9Xye43W7Mz893TRLW1tbgdru71ho2ng9sUM2tXHTz+Tyi0ShHYq1W6ylfawLArwzeifGCCAPjo3AotJAKj+2OWN9lhmEQiUSwuroKhmG4DVov9zrWnaDVZiIUCrV0jGgFduCsFzcXPpv5ZigUCrzOPZacn5XU9rL5kUqlMBgM3KYeAAiB4JSNXreIFLP46t4CAICmqkjuBgCPE3tUBpPnoL1WKBTI5XIn1qNisYhUKsXLR7q+a3O7Qnsbp1DfMmkcCgOaZ9bb7XbMzc01XaDq7Y78fj/nuWm321Hb84J5/O+Q8+1B6+pH7R0fgcD6cguaJW9er7fjyX2WvO9msNvt2N2qobCXhO/5OQhqDIQiEfxTDrz3HAaLSJLE0dFRz78vl8tx8eJFpNNpLC0twWAwcBVPmVaNb3lfgtXhwJTeBqVIip2dHeRyOV43tkql0rYaRhAELl68iJWVFVSr1a5dFZqlTbWDWCHH6sEeBu19XCW0GV4QZbCz74fCakQ5nUNeIsLNchRvQusqkC+bwB8tP4XD6AEklSi+G9vCe7UjkJUZXhWcdppluVyOmZkZJBIJzM/Pt3XUMBqNWF9fP0Fos9ksCILgbfWkVqt5+1ISBIHR0VF8dekFfO6pJyAUS0AXi9hMRPAHT30FbzONQiaTweFwNN14CAQCeDSvgVt1L5aKSyfILHC8KDfGmNaDbUfz3dSk02lexL4ZSJLs2vYpEokcB1j00IVodObopRLJB/l8HuFwGOl0GnK5HBaLpaM04vDwEJN9A7CrTU1/Xt9loygKkUgECwsLEIvFsFqtp1IiO4F1J2gktOl0GgqFoiei3N/fD7/fj/Hxcd6/021Vth6FQgF9fX2dH4hjUksQBObm5jqmZTVDt3KDeticDvzu1/4BCZMEBCnCZbkZU7QCVy9f4X0c9X7x5XIZ86E9HG77QRVLuPG3X8aVX3wHypk8dmNhTOrO7jjRLAJ3fX2dt9SA9aC9XaG9jY5o9OdslVkPABMTEy1bHsDxDnJ0dBQ0TWN/fx8vPfk4jM98Cg6lDKUqA3k5DebLfwTiA78Pgexlax61Wg2z2Yytra22fprFYvHcp3XLpeJxPO3aNlQ2M6RaNSBqHjjRLbqVHLSCVqvF1atXuWAGQqfEP4QXsb+5A1PBAyktwJtEdoy5PLyrIeVymVdFYnJyEltbW1hbW+O9uIRCIeh0Ot5Vr/nEPv5i8wco5PLQOax49+AVvNZ++mZXrVaxGvZDpJJj7h++BoXVANe1i3h2cQ4TR0oIhUKQJMlVytg/f3r1BVAUBQEpRC4SRzYYweNuBr/3yM/wOj6CIDpuTFjfW9ZjeGRk5BRJbSat6DYJiE2L60bLfSCkoB9wYft7L8IXS6D/rssoG7SYnpmBiMci2MryLJvNtiWrer0eOzs7vI+TrwVUK7jdbszOznKt4XYoFovY399vaxXUDmwblf0eEonEuVk7ZbNZRKNRjsTabLaufIYTiQQmJiZ4PVYsFsPlcsHlcqFcLiMcDiMQCEAmk8Fms/EihiRJQqFQnNpo7e3t8fLzbgatVsvJIzptznutytaj22IJS/rZSm03pLZdmEInfGlvAftSGqVgCjKdBt9a24b+wTdyr19PVCuVCsrlMkql0onrVywWQyKRQCaTHacz9nugSG3iaD+EmZ9+E0QSEgKhEEeHWdy8eRMkSUKn00Gn0/XksdxoB8YOCvPt3NR/N6/WobDbhPYVQuPF3tg+a8ysr4dUKoXJZILf72/bLiFJEh6PB31pH8ICYD6UwA+2Qrho1YGolICwDxg4efN3Op3wer1tPSXz+XxPGrtGMAyDUCiEcDgMD+QoGjQYeO2dUBj1oCsUVKEs8kP8W6Wt0I33KR+wgwm//a1/QDB8AKpcQi4SRzyVxfy0Gg934VNYqVR4t/OGh4fh9/vh9XoxMTHR0V6lk6dgPVKVIv73+g9ByCWoRuJgUMPntl6CoUbCKJAil8uhUCiAYRiQJAlBrgJSLIbj6gUICECh08JiNEGlUoGmac4b8+jo2GaOpmn4d3aRoYrYn/VCICBw4Z2PoCbjvzFq1mJuBtZj2GazYXNz85RUBDhuv7FdjmYhCp2g1Wp5TTvXQ3RUQ/YgBt1gH1R2CwSEACqdBmSLpEA+aKXBbkQz/9xWz3fW7gtbbQ2FQm1lMgzDYHV1FZOTkz1XfeoJLXtunEWelM1mEQ6HORN6i8XSU1gGq2vu5bOUSqXweDzweDxcZXhnZwdqtfpE4EAzuN1ubG9vc4SWJTBn2aC4XC7s7++3rUifpSp7VrCv1y2pjcfjPUc2LxzuQ6xWYueZl0BXKNgmR/Cd55+BK8VwMzESiQQSiYSLlWcDlFpBWSziMq3EkseJ1F4IYpUC1wx9eMtdD0AgEICiKKTTaRwcHGBzcxMEQZwguHyvIYZhwDBMV+sD8OpPCQNuE9pXFI1axfpdTywWw8DAQMvfdbvduHnzJiwWS8ebFSGRwq6RgxAAF206zIcOYVRI4BGK0GwpnZiYwOzsLJRKZdPnLpVKJ7S93aJcLmN/fx/pdBoWiwVXrlzBdO0Sfv8bn4bf7QSdL+Gddz+I15uHsbmxAYlEguHh4Z4XqrNKDpqBIAgwRjWk1SI2v/A8ZBoVpn/6MWSJ7ogzq/njC7fbjVAoxJmMt7qJsfpdvje5YCGFSrmMcjqLnR+8iBrDQEAIMC8w4nUDU7DZbFAqldzz/bJNjU9tvghFIgW13YxiNIl33v9OGJWtq83XagksHgYhVsiRCcXAFCvwmPnr17qttEulUly8eBHJZBKLi4uwWCyczECqUuDF3TW4XS4k9/Zw5XL3FUKlUsk7djQQCMCeqkJt1kOsVKCGGkrZPEazQuRyOd4VF7a6zBKlWCzGy3LI4XBgd3e3I9lIJpPn4t/a19eH2dlZbhCuGba2tmC328808KJWqznXjV6DHRpJrM1mO7OHcjqdhkajOdNzAC9HULPPub+/j2KxCL1eD4fDcer+zH6WrO7V5/Ohv7//TMdgNpvh9/ub3k/OoyrL4iydAb1e31Wl9ixyA4qiUDiII3EYg9JqhVhKwjg2gAGNCVdneostZz1rP/jQWxGji3iq9izuueMuZDb9nKOQWCyG2WzmJDU0TSOdTiMej2N7exsEQUCj0UCn00Gr1Z56b6upMD7jn8M/5regLzD4hWuv7+r9/yT06WfFbUL7CqLVjoetbnW60Y+NjWF1dbXjLlMweAlHSj329w/x4IgTpEiIkFiP2XAadmGwaZrT+Pg4p6dtPIF7texKp9MIBALc0Fp95SObSOK9E3fD4/FgfX0dF93HleOZmRnOv7CbpLF6nJfkoB6xWAz0XhRHdBHDr78b1XIFTLECh5Gf/usssNvtEIvFLbVj+XwelUql4+LOMAwSiQQODw/hi4eQOYhCqlbCc/8dx7IPlQKTY+Nwmk5X2e62DEArluGriSpGxy6gz02CjqeBNoT2fUPXEC1lkaRD0HmcEMZzePdr+RPJXjcmer0eWq0W+/v7uHHjBqQ2Az7hewn7m7uQbirhVhowI7jS9c3QZrMhGo22JaPZbBabm5swmUx4032vw0wxg++HNkExNKZG7biksWNlZYXTZXcCm8nOEtpkMsmrrc3G/naKs02lUufiEEAQBCwWC4LBYFPv00QigWq1euY0qvo44mYzB62QTqcRjUa5DYnFYjmXIBAWt8I6TKvVQqvVchZcm5uboCgKZrMZVqv1Zd9htQT/6fHPQmLVQxLO4j8O85P0tIPapMffv/gkpGYdBtVGXDf1Ix6Pn2tVtpuwnmbQarUYGhrC/Px8x/kFvmEK9WA9timKwhtGZvDN9C4YmkZyNwiCIPCIk5+8pNnz1jsjuCDFBb0DIxozipNKrK6uNpUXsnp19j7PMAzS6TRSqRT29vbAMAxUKhUMBgNSQhof9z6NHCqg9jPYZ2r4QtSLj5rMnONSJ1SrVS498Lbk4DZOoVV1ju+UsVKphEaj6TiAIZDIELr/F2BTPglSykBgdMJ552NwkBJuke/r6zuhJ1IqlbDb7djY2Dil2exG58RO8oZCISgUipbxsnt7e5xVU6O+0Ww2w2g0wufzYW5ujrc9E4vzIrT1Egm9Xo/fetN78SerT2N7aQXGkQHQwTjefX9vLaxuYTQaQZIk5ufnceHCBdRIAvuFNGRCESJr2y3tj/L5POLxOFKpFIDjif++vj6MjY0hZpbiRtwPqUKBbCSGSbsblwytCfqQwoA3D17CxR/LVjpZv6nFUvznS2/A9450cLpdUFaBqH8f2i4dGHoBQRBwu92w2Wz48Jf/GimqCKpYAnNEI2Ey4Fv7Xrytf6ar52wnO6BpGhsbGzg6OjoRhdun1OHnRu448djLly/D5/NhYWEBExMTba8tmezYEYElNt20tc1mc8co3MbY0bPA6XRidnYWTqfzBImmKAo+n69ptHCvaDdzwCKdTiMcDnMRwedRiW2FXC53y56bdTRo5pTAqKT424NZxA+jEJWzEMuk+MuVZ/AbF1/Hm7g0olCt4O8ii9jyrsA6MYTv76/hh+UbeEP/hTNXZU+8TuHsSWparRajo6NYXFxsS2r5yg3q1y+ZTMbZYl4GYIvb8FJsD/vxMn528gFM6bvfnHVyRpDL5bBardjZ2ek4hEgQBOd4xB57NptFKpXCl5Z+iFjMj0qljKh3Exff9Sasp6PIVsvQiPnJB9l1/9VKZoHbhPYVRavFKBqN8q6SeDwezM7Owmg0trx4GYZBLFvElfd+5MTNR4DjFjZrBRYMBjEwMMBdEHa7HalUqidfSYqisL+/z5l5t2sDxWIx6HS6tgszm9LSjT3TeYFhGOzv7yMWi3ESCfZz/J0rj+FreQmmLk1DMwXE/UEYeQ5tndUtQqvVYnx8HI+/+CyeqEVBkwQKiRQGZVpcEl/mXiORSCCZTKJcLnN6rma+tB8YvRuTOhsOCmnEqzv4wNRrIWyzWDVWVPhYvwkJAhapEsMGK0iSxNLSUlduAWfdmAhJEgKnAfKcFIv/9G1YLo5ArFBgmRbjtdrjxaqbcypE5/GP3hdg0ulwj2UAMlKMYDB4rAvvYNlWD4/Hg3Q6jcXFxbYVL7lcjng8DuB4MezGXstqtcLr9bYktGf1lm4EQRCw2WzY398/cT/zer0YHR09l9eKl/J4KraNJ76/B6dUjcu1Gog64pZMJhGNRjkS63A4ehqo6QbnoUPmi0anhL976UnEtwPIRA8RnF3Blff/FBZ9m1jXDcAgVZ645gmCOPX3Zv9/8mANh/kchAoZ9hdXQYpEWHRY8cuD/efafs7n82eSsrFQq9VtSS0fuQGf9euayY1rJjeWjnQYUXYvdUkmk9jd3e1oS+l0OrGwsMBb3sSCIAiuqj/AHCIQEuJgbQtCsRi9fG3VapVzmrlt23UbJ0AQxKmKAjv0UiwWeVdJWB/O9fX1ltO9Pp8PfX19LS9gkiQxPDzM+YEGAgEMDAxArVZjfHwcc3NzUKvVkMvlHRc91guX9U3lk/rj9/t5V2tYeyZWhtBYWT5PUBQFv9+PdDoNh8PRtBohZGqYNDlxQX/sR7iSTCMWi/FqZ/Ed6GkHhUKB5wQphDd3obKZkYsm4HMI8annvotpuYkzux8aGuqstRYIcJflWLe9U9Mgl85A0oaQNRJakiQxPj6OpaWlplIVFvXn0FhDWMithpAgoBJJkEoeYOj1d8E06gFJCGGQKhCPxzkfZ+BYg6tQKKBQKKBUKk91Fr6zv4qvJLdA7eWhcVrx3e0FvFniht3UWwiIVqvFpUuXsLq6ilQq1fTaqW+xx+PxtnZdjWAX8VYbqWQyeS66z3o4nU586XvfwXOVCEihEM6iEH1G47mQysNyAf9t/ttIFOPI7sRhGOmHYPsG3mgYQjgcRrFYhFar/YmQ2Hr0quU9C4rFIhKJBAo/9jIv5XKo0TSywSiUViOoSgWl2vHEBFth6/R/9s/bgR3k4lGUi0XsPPkCRh59DUqpDHaD+5hw9p8bee9VytYM7Nq1uLh4KjK2ndygXlbAd/3SaDRIp9NdSRgSiQT29vZ4D7FNTEyc6T553dyPJ30rEAkIDD94F3LhBO68MAO1iL9mmb1v9OLp/pPCbUL7CqJarZ4grkKhEJFIpOuhDK1Wi3A43JRIURTVcnFshFgsxvj4OBckQBAEhoaGMDExgZWVFQxfmMRGNIA8c7xDq29hxWIxBAIBSKXSjmll9QiFQlz7nAUfc39WhtBtShQflMtl+Hw+FAqFU1rfRmSzWU5XBADj4+OYnZ2FVqvteKMvl8tndoso0lXkCBqqPiee//inYBobhEytRN6MlrZufGCz2bC9vd12YS4UCqcqiUqlElarFVtbWy1brvULplgsRl9fX9vHnzfugxFfEO9DadSBFJMwafT42ZnXnmq9lctl5PN5FAoFxONxjkiSJAmBiMSn178PoUyKXCwBhqkhUaaQuG8Q9/GMbm0GkiRx8eJFBAIB3Lx584RcAThpOdZLW5uNwm3WAUqlUueu+5xP7ONrmW3UElWIVQrkwgn8/jt+6Vye++nQBgqlMhjUsD/nhUSjxJf9j2Pq3rdjyM3/HnTe6Mauq1ewBDadToOiKMhkMhgMBrzljvsx91QU5kE3XJenjq2eKsCIs7/ne03VqsHmKg0tAJGQhHlsEOLqEdRCMdbX17nCjFarhdFoPHNE63lBqVRifHwcy8vLuHDhAgo4QqiYxn5gF4/ecz/3uFayAr7QaDSIx+O8CW0sFkMwGGy76W+EWCyG2+1uKgHkA4/KiDdInJgfU4KWCCEJpvALnmtdyVBY/f3tobDbaApWcsDUGHx1bxFf9z6LciaHh6/dDQ8zAJLgb+czOjqK2dlZ6PX6E0RwZ2enrVtCM7BBAtlsFqurq5DJZMjJCHzoS/8ThEKGGsNgU0rhA8N3IhQ8QCKRgF6vPxVX2gmtrEMkEgnK5XLHm0p9ShQboTs8PNzzBVeftNbf389rY9Go+2JN9FdXVzt60Z7V7xMAJASBcjSJbDKJi+9+FFSxBLpEwaQ6W6VNLpeDoqi2Q0StKipOpxMrKyu8K9VWqxWxWIy39OAs2NrawpTJiWsXpvGtF5/BwPAQ7rANQSE6fd5KpVJIpdJTpJ6mafgPowBBoJRIYuXr38PAfVeh67Nhc3sbPpERCoUCcrkccrm8p/ORTfpbXl6G2+0+9Tn22tZuF4Wby+V6sqhqh6/sLUBh1GHvR4uooQbr6BA+v/w8/vXYvZwGmKZpHB0dtfw7CzZEgcVmaAOZ5AES+yHEvJuwTY5AqlOhwhx3uUiS/ImTq7PYdbVDsVhEMplEMpnkCKxOp8PY2NiJ14rFYnindQrPy/dRIhhc8ozgMcvxgG83Eph6zBiceLPrAv4lsAwAUIkk+LWZ+9GvetlWkj2+7e1t7tzUarXQ6/Ud7+NV5gihXAq5o/ax271AqVRicnISn33623hBmEaNECITOEDOrsZbnVMIBoO8ZHHtoFarsbu7y+uxoVAIsVisp3Qzs9mMeDzeUwcgkUhg3GjH28dfBwBIj6QR3PND24X3dj1uSw5u4xTYKuS391fx3eAaaEENuWwGN/NhaHwLeNcg/wlw1ntzY2MDk5OTAMCZOfc6gapWq3H58mXEEnH81298Atl0GgKxCBqbGd+7+SIE/jh+avquntsgwWAQFovl1O+yBtB8d8lsvGgkEsHs7GzXMoR0Oo29vT2QJNn17jyXy52qaqnVamg0GgQCgaYT3ixKpdKZCFwymcTOzg7ePjiDb1sCqJYryIbj6HP2wZ466vj6nWAymRCLxVp+lu3ILlupbtaqb4afhPSAHeBiuxXXTf2YsI90vYiRJAm3yQqT2YxAMo2Z974J2j4bxEo5rrmmoVKoUCwWcXh4iFKpxH1OMpkMcrmckzB0IltKpRJXrlzhJAjDw8PHKXrxfYR+FIPBxW+ivx7scTQmDd6q6sth8hDJSAwHsytQGPXQ2SyIVYGcI8cFcIjFYi58ozGMo93xiA9t2F54ClWKwqWffxvEYjGGh4Yx7HAhl80hEomAoijOzkij0UCtVt9Sfet52XWVy2VO+85WQPV6PUZGRlqeN2y7/C33PICxjQ309fVx37HhkvrEedQtHnNfwIOOUbwgfAmvuXrnqSAQdvPGOuZQFIVkMon9/X0UCgWQJMlZStV7poaLGfyZ9/uIHiZQTGWwo6nhF0fvglBwfudhRQi8QKZxuLsPsVwOoViMLz7zXaA/jtdOXubVvWyHxo1WK7DkuZ3dYiew99VuzmOGYU4NYWq1WgQCga4isVncrtDexikIBAJuJ38j7gcAJPeCKETiKKQyeJZax9vc010ttkajEfO7G/jyD76CopQAcXCID973pp6Orz7pJJw5BCMRoQYB5j/5FYy95XXov3YByqG+nm13GIZBNBptauzMVmi7BZuFvrW1hVAohLGxMcjlcniTITwZ2kDYL8F91kFoJccEi5VJKBQKjI2N9VTNaVVl9Xg8mJuba1uhqFQqPb0mRVHY3NyEQCDA9PQ0ronFmM4dYiMdhf9oHe9/zWOQECT8fj/m5ua4z6Fb2Gw2rK6uNiW0nSQhBEFgcnISKysrvEjqrZYesElZ9Ys5TdM935xJQoiHhGZ8zZJGvlgEXa3i9dYhvNY13rSNxzAMisUiisUicrljssWe4yRJQiaTndDqsosVQRCYmpo6Tqd74YcYW/02JNsb2M+XcH3Mg9p7fxuCJrZq7eBwOE5F4Z4XEQOOr4mDgwMkk0lYaRESEGDyLQ+Cyuahc9lwr3206wjnZrhocOAuaPGC045M/BCDDiceJMxQq9TQ617exNM0jWw2i0wmg2AwyJ279ST3vIbherXrYglsOp3m7imdCGzj77PWTwRBnOqesFKWYDCIubk5TE1NdU3s5aQYFrUWRzTdMdmOje9l7x00TXMDevWeqX+19yJyJEAVSxDJjl1W+pS6phZYbGALW8Vv9uf6yj7DMDg6OsJWMoKkP4RStoAX/uofcfFdb4Bx0A3VgPPcYpLZIkyr7yoQCCCbzZ45xY7PzEwjfD4fHA7HqXN8aGgI6+vrvMMl6u+Vr1ang9uE9hVEtVoFSZIQ/VhaQIhFIGRSVHJFUFQNXq/3RMtNKpVCJpNBIpFAKpVCLpdDKpVyJ1qqUsTXigGEN7ehclhQyqfxt3sv4b/o3wix8PirZu1tisXiiVi+SqXCvVZj0olJrYPKZIBUrcCdH3ofwNTAMIBe0rvFit/vh8PhaEoopFIpZyvVLdiWfz6fx/r6OrzFOJ49iiOV2Idvl8FTwXX8iv0SiolUTzKJbjAxMYHl5eWWhK5blwPWbSEej2NoaOhEdbdfZUC/yoC5eBkiEFzF3mQyYXV1FSaTqWt/UdaipRl55eMZKZfL4Xa7sbq6ysXKtiPCfKQHJEl29FJthM/nA03Tp4hyt89Tj52dHYxbXHjdtXuw5NuCVCDEhcHWFVOCIKBUKptubthB0Hw+j8PDQ24oBTj+DhQKBWQyGRwH81j2ekEIaihWjyCmKTCP/y2E7/9YV8fezG4slUp15ZjQ7D1EIhFEIhGIxWLY7XYMDg7CHnfhf3zvKyjaNUgfhTFAqPC2/umeX6ceyWQSd1oG8IHJx7Dj34NKenw/XFhYOKFPZAcj6ztVrCl9KpXivLHFYvEJktvLucFX11wulzkJAUuEWB/Vbje5NE1jeXkZ4+PjJ6JJmx2/0+mEWq3u6KbRCjKZrCepFEmSJ0IBGIZB9DCBYDyGciaL7e+9APPEOHROI34QLcE0cLqgwVbuBQLBiQp+s0o/+1iCIKAsmPDZ3ZtQGrS4/ivvgsHjQimTQ3xjF3OHFAwGA0wm05kDPtLpdNPNv8/nQ7FY7Cpaux20Wi3i8TiCwdMe8o0ol8ttB0xlMhkvCUO3AUCvFF79R/j/x2BtMB5yjOF/rzwDqUIO04gH+XAc733tmzFjP7lAshVTtsrDDqqwu6X5wyBi0X0wTA0Ln/8mhh+6G+tr6/hmUYY+xfFiRRAER4glEglUKhVMJlPHWL5fFNyHP/rnf4Te44RASEB4kMRFSW9SBpqmkUgkcO3ataY/b8yc7gVKpRLTl2bw8W/8DdLRGHKZHAgJiXihjKdoKT5835vO3DopFottBy2kUin6+vp6FvLXg5UXWCyWtsNe7MQte4NSKpW4evUq/H4/bt68ibGxsa5aTKx3aeONk68Jutls5ipjTqcTNE23jU/sJD1gBwb5bgR8Ph/K5fKZP/96hEIhlMtlTtozbLTh8PCw5+cjSRJqtbrpJD67+czn88ju+0CCwWdnd1GoUJiwamE9qjVN++sErVZ7YiHLZDI9VU0TiQRCoRAoioLVaj2hQ6QoCqG9AP77Wz+AsoBB+UIJ0UCQ21yfBQzDYGdnB5cuXQIhIGDRGxEOh2G1WtHf398xSa/RlJ49XjZ5aXd3FwzDQCqVQq1WQ6vVnkjKq0eqUsQ/7dzE3mEMTCwN58QIrPKT32WjfZ5YLIZer8fAwMCZJ/tZfSzf61qtVnd002iFXrtnjSAIAia9ARJShIpAgL47LsF5aRwkKcKUbQiXh87HzzsQCCAejeJtl+7G9+K7yB5EIVbKcblvEO+fvB/M0XG4zO7uLlfVNplMp2ZROoEdzG4ktDs7O6BpmrtXnBcGBwcxNzfXcQhvfX0dY2NjLX8+PDyM+fl5XoSWvW/flhzcRlOwRPS6uR/xUBg3BqRQmwxwm8fgLDavXLI7+WbIBpVQE0nkDzMQikhQuSIMQ30YuzCFcT1/e59mGCZU+MjVh3FkVkNJSjBzrwOry15IhaKuBeo+n69ttVAqlaJSqZzpeAGAOqIh1quhJgmsfP1JUBdG0HdtGhKj5lwuSj76I6vVikQi0bOVT6O8oBOR0+l0SKVSp17L7XbDZDJhfX0dOp2ON3mxWq1YWlo6RWgLhQJvy6jh4WHMzc3hSEJiNRlGMpVAHzUItfj0jbiT9EAoFPKubPv9/nMns8lkEpFI5MTA3620shGLxdyATdDqRDbow4fvm0S2TAEQYCl7BOHcHFf94kv02Sjc+pQhvtdEPp/HwcEBstls27b46uoqhoeHjzs9ADRiGQ52987svwwcE4X6NqpSqUShUABwLL2iKOpEZ4APGqNFgeMiAhvIUCgUwDAMZDIZNBrNsZOJTIo/WnoSh+UCsrEEhASBP1x8Av/XhYdAZfNIpVIolUrnSmDrsbGxcYqY86mg1rtpdCNBkEqlyP3YGuwsiEQi2N/fx1sGp/Edyz4SGz4ISRHkpBiP9p3dIYINLDCbzbh27RquAfBs6eFTRjE+NIwZgxOEgABBEiekEWyXZGlpCQzDwGAwwGAwdLR9UyqVpz6XjY0NrmN43iAIAhMTE/B6vS0LHLFYDDKZrO0axW7sOlV7G4sIt4fCbuMEGhcPc5XE//3ad3L/vrS01DZ1qRkumVz4emAZmUAUl973ZhyVKhCE07AIz2YNxTAM/H4/7rt0+cSudWZmBgsLC2AYhrcWiaIoZDKZtoMJfEX2nSAViiDLU0iE4hh77EFYxgZQiKdw5IvCJz/25j1LGyWXy/Fq046NjWF+fv6EkL9TlbGdvKAdtFot9vb2mv6MHZ4LBAK4ceMGxsfHOxJytoXXuEh2myil7rfjt77ydxAb1KApGrOzWfzW9EOnKllAe+kB37QwduDhPCsj+Xz+5apg3fUrlUpRrVbP7XUakU6nsb29Df3FB3ElFwTyaSyEUnAatXC97d/hyDaIWCzGpUUZjcYTUajNUB+Fm8/nT1jPNQNFUQiHw4jH48fyB4ej7ULt8/m4TPl6OJ1OHBwcnElDm8/nTzkyNN4z7HY7aJrG2tramTY0Uqn0BOEBjjsz6XQa+/v7WA77sbqzBFImQXDWC+vUKPKJFL5ZkuK1Qxfg8XjOlcDWIxAIAEDP3RPg2E1Dq9VicXERw8PDHe8zUqmUC/boBWwUtEajwaVLl3CNJDGZjuIbqacw1X8Rd1sGeCdXNQNbAABwqgBgIWQYG7nUdk1lZUFut5uLGD44OMDGxgZkMhn0en3TEKP9Qhr/7F/GrKKEC3oHtIfHloznoRVvBblcDrPZDJ/Pd+p12DWbj7+72+3G7Ows7HZ7y03t7QrtbfBGOp0+1c6amJjA/Pw8p5PlA51Ejl/tv45PhFIQqTRw2fR4+2suYHdrG+Ufp8n0gv39fdhstlPkjyAIzMzMcLtZPs4CvdiI9QKGYbCxsYG3WybwdYUM/p1dECSJR2fuxM8OX0MsGsPCwgJ30+ll0cnlcujrax0Ny4INrqi38moXqsBXXtAMfDYDLpcLZrMZ6+vrUKlU8Hg8bW9SZrOZS75i0e1A1Rf9i5DZTYit70LntqNEU/ji7hw+MvVA08e3kh7wIbSBQAC5XO5cySxFUVhbW8OFCxeaXgfnEa3ciHK5jO3tbQDgtN614RHUdhaAJS+IN7wdAq0JJMClRdE0zZFbmqZhMplgsVia3kPMZjMCgQMUyxUYdNpTP2cYBrFYDJFIBMDxRoOPd2Y6nUYmk2lqW2c2m3Hjxo0zLfTr6+tNK68ymQzFYpG7ll0uF3Z2dnjFhnYDdqLfbreDsWpgEiURX/eBypch06mhNOkxODwKl7V3h5FOYOULzT7jTlKoRrASBK/XC41G0/a76bV7Vn8uN3orD6tNeJ1zDJf7er9e+RQAcrlcV3ME9RHD7Huov7Y0Gg1MJhPSwiP84eITSJYOsR+o4YmXnsebhmbwixOP9Px++MLlcmFubu5UFbnVIFgzEASBvr4++Hy+ltdJY1fl9lDYbZwCW7YPBoPo7+8/8TM2dcnr9XZlwFyNpfC7b/zZEwTNclmLjY0NpFIpjI+Pd0VE2AWyld6VIAhcvHiRI7XtSHM3NmIsMetlN0hRFJaWlmC32zE+Po7BkBNRyxQGPS/v/tmqC1v9YhiG8/7ki260nFqtFiqVirPSKhaLp0hGt/KCVlAoFB3lEFKpFDMzM8fT87OzGB0dbdlWY71L2YWul+8lUc6jVqshtrGDTDCModffg5isdeuylfRAKBS2JY/BYBDZbPbcBjCA4/e7tLSE8fHxn4ivKWuzk0qlMDIycuJ7EUgVEEzeA0FJAoH2dEwoSZIcuWUJ6ebmJijqePjFYrFALpeDYWrw+sp48umXIBAQmJqaxDsf0UGlECOdTuPg4AClUgkmkwkTExO8z0WKorC1tdW2MqTX63uW4AQCARgMhqbfA6sfr7/3DQ4OYm1t7cwWdq3glulA7UWg0Gsw/Z43IOMPw2S1YErXW/GAD/L5PHw+X1OHGKA3O0CSJDEzMwO/34+FhYWW3znfDgkLmqbh8/mQyWROncsszhowwxYAbDZb2wLAWaOdpVIpXC4XXC4XGIZBOp1GNBrFZ5afQywTQ76YQ2h1E31XLmAWafxCQ/jQrcLU1BQWFxehG3YjXslDWROimsl0tYmzWq24efNmSzlQtVq9ZZ2G88RtQvsKgWEYzrqLoqim5EOpVMJut/O2Msrn8yAI4tSJRxAExsfHOZ/WyclJ3ifn1tZWx2oKS2q9Xi8AtCS13VRn2USkbgkEq52qJ2jZTAZDjj6om7Sy2KzrcrkMv9/P3RjbtV+A3kjd4OAgbty4gW06g7UDP7RyFcwOGyQE2ZO8oBU0Gg2SySQvSYDdbofRaMT6+jokEknTYAqCICCVSrnqV7cVoEQiAWYvhspRAcOvvxdHlQrKiRRqJSGSA61lNc2kB+0W1GAwiHQ6fa5kFjiW/3TrT9wrWG2hw+FouyDx2fARxMv6QIZ5efilXC4jmKhi1V+FQECgWi0jlsjhE5//Pu65qIdarYbb7e7p/Xq9XoyOjrYlDg6HA+vr610TWoqiEI1GW26utVot9vf3T91/2Dhm1krqvFAul7G27MV/eODt+HZ6BweFNNRaCr/kuspZA5436jsF7QJPej1X3W43NBoNbwlCOwSDQS6Vrp3ErNnmng/K5TI2NzchFApx6dKltufcWRxNmoEgCM45w0JHEAwK4P/6MrKBINx3XgLNHIGp1SD8CRBasViMpVoa3/mXp6FzO5DY3MNbr96HbsfqhoaGsLW11bSzVU90z0sSeCtwm9C+QqjVaiBJEgcHB21vsna7nXfq0u7ublvCaLVaoVarsbKy0jR9qBHFYhGlUonXwtNYqW3UdRWLRVSrVd43yF7sYQKBABKJxKmbW6FQ6Cjql0qlGB0dBU3TODg44FLX+vr6mu5YuyV1LFZlZXztyW9DopBDqtNg/gdBvEXugdvhPFNUbT30ej3X3uMDsViMixcvchueZguZ1WrFwcEBhoeHeWv02LxylUqF33zju/Hx9WcRTSZQpKoYGR/Bvxl/DeIHEezu7qK/v7/pedYoPSBJkougrUcoFOJMy88Ta2trp4ZumoFPXHM7sNpCnU7Hy7eXnTbnuzElCIIbeGIYBitfvYHUYQSb3pcQDKzhjvt+CkabG5evXIHwDFZmRqOR17UGdJ+Ut76+3nZjXz8Y1oipqSksLCxwQzBnRTab5dxLlEolxvr6ARy/p9XVVcB5/tpJtlMwOjra9nM7i78ycLwxmJ6exurqKnQ6Xdd2f4lEAj6fD2azmde53O29lNWHHh4etqz6NqIxovw8MSjS4Cl/ELbxQVgnh0Clc3DUJDgLle3m+9vLHeKlShzMEYPUXhCkVILnsvu4KxPHkOZ0F6cV2PmLZt091pHp1Y7bhPYVAutBG4vFWraOWPBJXSoWi2AYpuPOXC6X48qVK1hbW+NSY1pdPJubmxgZ6S6NiK3UMgwDZ18fIsUMqgyDxI4fo0P8E2q6sYdhGAarq6uQSCSnTKK73ZmTJAm32w23241YLAav1wuJRMJVrLJUCf+0M4uVvW3oxXL8qtsOq5yfIf1huYDnU/tQmAzwzy7D4HagKJEgf9+Fc22H9mp7ZrVaodfrsb6+jnA4jNHRUe6zMxqN8Pl8AI43CO2G4djACo1Gc8Ln92NX3oS1wwPsbe7iTZdfA7GQhGlUA4qi4Pf7sbe3x+l7WTRKD5pVaEOhEBKJxLlXZv1+P0iS7Oj1CPCPa24EKzNhGOaUtrAd2KGuXtqABEFArVaidkTDMzwDs70PJpsbNFXE3OwshEIhFAoFN8nf6ph2swl8fW8RmWoZjpoEM0I9rl3iVxdih8P4tkVjsRhEIhEv8tIMrN5/bm4OJEmeqfLInt/NZEGsV3i3A7184PV64XK5ev4MuoFYLMbMzAx8Ph8WFhYwNTXFbdbY7lnje8/n89je3oZEIulYMa1HNxIJliw7HI6uCgC3itDGYjEYM1W88+4H8bWXnsHREYOrF2fwNv0IZmdneQ3envkYSsfSLYVeg+f/52dw6WfeArpCIVrKdkVoAWBkZASbm5untNn1PrS3h8Ju4wQyVAkL8QCOaBoPTHXewfJJXfL5fLzb+ezz1afGNC5ayWQSIpGop4txamoK88tL+N8rzyKmFIAqlkEkcvjvo0Pg+2xSqbRltaUe5XK5Zd49cLYEJLailc1msbe3h2K5hC+kN1GQEEgmD5HTH+EPFp/Ax6686cRkLkVRJ5LWKpUKKpUKdpNRxDd2QdM0dr7zHFTvfwusowOgBOdvgUKSZE/2SGy1NhaLYXZ29kT+u1KpRDabRaFQaDoMx7bL9Xp901x0KSnCJUs/jvYTJ7xIxWIxhoeHQdM0/H4/F7rBto7rpQeNhDYSiSAWi3UdJ9lpoxOLxZDJZHhXfLuNa66vMvUiM5FIJCgWi12TJta/VSPKwGx3QSSSIrC7Cp3Bigeu9+HyuAUM8/9j7z3DG0nPK9GDQiHnQAQSgWBmN7vZcXLSzGiCRlmW5CBZkrX2yr5ee+Ww63D32t7kveu1tbbX9nWQbcmSLFuSJStrZiRNTmxmNBMIggBBEDlnFAr3B1U1IIhQBbKntd4+zzOP1N0IBaDqq/O973nPoZHNZpHNZrG9vY1yuQyCIKBSqViSG6sV8fsrT6PeaKBWrWHF60futjtwhaNukNkgcSG0zHnBZWK7m36cIbWLi4t9Ew2fz4dCodB1rmF0dBQrKyunSmg9Hg80Gk3Prlo/Mq1ucLlcSCaTWFxcxOTkJMoiAZ6JeXGNTuIO5yTO6KysbrpWq2FiYoL3JqtSqfR8TrFYxNbWFmQyGS+yzCCXy52644DP50Mul8Ply5dhDYVw75sdyObzcAwdhleUTRa43W6YTKa+ChZcizEmmQqFeArFeApn3v4wZBoVMnsHiIt3ESVUMBqNnNdGuVwOiURybEN22pKNG4VbhPYNxm4ugT9Y/S6i/gBKmRx2LWLYSy4MyLrvHpnUpfX19WMal3K5jFqtxnvnbrPZoNVqsbq6CpfLhZwYePbAgxpdhziYwo/d3/+UpldRx1biAESWRDVfhM5hxV9tvIRfv8jtNaVSaU+zema33k0TfNIEJOBwCnhmZgar0T3sbT2Har6A8HUPnHdeQj6ZxpeK38V5zeuyESZljQmvUKvVkEqlGCMn8TQRx/66B1c+/B6orEZENrwwDF440fG1AzMg02+0o8lkgl6vx+bmJiKRCCYnJ1FXy/AnL34TxUIR77RqcXngcJEOhULY39+HXq/v62bDgCRJjI6Owul0Ym9vD3Nzc6yeeWpqCvOLCyga5dja86E2oIKJIhEOh/vKRu+2QKfTaQQCAc6RkAAgEonYdK9eiEaj8Pv9PYdYuqGfND1mw2G32/HgA+O4cLGMlc0oxFQIj75pFGOO18NXGG05A4bkZjIZhMNhfGt3FZFYAIRMjNDKBsbvvx2buRhS1SLnBEGj0chJSuXxeOB0OjmdV8x534mskiSJc+fOYXV1FefOneNM/miaxvr6OqRSac9OgFgshkql6nvwrRVMcEU3HSqDfD5/ogGrdmDiu78/9zI+H7mOGl2HsBDBy5kg3iy1YUSoxMjISN8EvlsKFbMBy+VymJiY6Lva2RoFfBIwHUGZTMZueJlNNfmDjTez5l+5cgVerxcrKys4c+bMDUnbqoTiuEM1iGW9BoltP8RqJd5+9nY8bjuL/f19+P1+aLVa2O12Tud7rw3ZDzOxvUVo32B8dnsOtXodVKUKCICakMAXdhbwc2fv7/lck8mEVCp1zATZ5/Mdc0ngCqVSiYsXL+Lbr76AzwWXoBk0Ix9PgqrWYI/58OBQ92E0Jkq3+b9arYbX3MuHi9H3XkYlk8Oln3wX9gpJzscllUrbaiUZMLvjXgSq3wSkdiBFIijNA0iVKqjmSxDJpSBFIthHXbgyzM1y5gmpHV8wHdoaydQq/OjF+6AtNLC+vn6kxX9S6HQ6xGKxE2WVkySJs2fPIh6P4+svfB9fye4gG45CICAQ3XgBDwVscNEyGI3GExHZdu/rcrngdDoRDAYxPz8Po2kA38rv4vqaD0II8FIxhAukDh9/7H19fWc0Tbc93mKxCI/Hg9nZWV6vy8VwPp/PY2trCwqF4sTfl1wuRygU4vRY5n1VKtWRDo9eI8UDtzmgJuMYsXXvYrSS3E0lhZ0AjYPtXeT2o8gEw1BZjKB5GK4PDQ2xFaxOyGazqNVqnM9jrVYLn8/XVSYilUpx9uxZrK6ucnIToSgKKysrsFgsnK0PXS4XVlZWTkxo2wV5dEO/2v5eEIvFCBpIVPaqSO6HgUYDMrUCT1mK+Mu3/8ypvx/w+sbPbrdzIvNvBBgHnWZpFNPBYKQsjDSLwejoKNLpNBYXF/uKG+4E5rw0mUz4+Yffhd1cAi82XsOlM+cwPXB4/rtcLrbKvrW1BYqiMDg4CJPJ1HF9E4vFMBgMCIVCfVt93izcIrRvMOLlHBpoYOOpFyCRyaEftmFDX0B0YJrd1XUDm7okFcFfy6JeoyDKpU9kHk6SJAJaAQQHBHzzKyinCrBfmsLn55/FKCU9QlRb9YskSUIkErGJRiKRCAqFArZBKw6qeVjOjAFiEcqpLBqRFHxDPlitVk5JNu2m2SmKYv0SubSDT7NVoizToAJhaKwDcN5xAUqdFiJCiMuWYU7PD4VCcCh0+LO3/Su8urKIcacLZp0BANgW/0knixmo1Wpeg2HdYDQaEdSTKAWziAX20ajWQDfq+LYxjb9658d4f79cLdkIgoDD4YDNZsPXll/GqncLxVQO9VoNarqOjTEVEpVCz+5GO1AUdaw1TlEUrl+/jrNnz/KWanQznGdasvV6HVNTU6dSKWJ0jN1AURS8Xi9KpVLX9+U7YAYAl40OPOV3g6QbmHz8PojEEhgoIXyr66A5DJwyn4EkySPesa3Y3NzE7Ows5+OSy+VdN8LNj5ucnMTKykpbeQyDYrGI69ev874uxWIxNBoNpwp0JxSLxbZBHt3AJ8GPL3K1ChRWIzwvLyC1to2ZH3kM6VQKvt1d6LRaqNXqU+mUdNqA9Qu+w4ed0DoIyCASibCD3Z3OP61Wy8YNJxKJngS912fO5/NYX18/cl4OqwyoWEdglRzv1DKODNVqlR16VqvVsNvtba89JmzBYrGAIIhjx3PL5eAWAABWuRYxhGGaGoGgRkPnsMEl06NUKiEajbLDPDKZDCqVCkqlEmq1+oggW+Yw41e//FfQjNmRDcUwYDRiqnwORmnndgxN0ygWi0d0nYxUgaIobHmuo1TMIb2zh0qugMGzo6iIwQ6HMISVa1Xp4dI4Xlldhml6DPmDGPSOQfzM1N1QNKTY2NhggxiYC4YLmIuY6y73tAYBKIrCxsYGhEIhfu/9H8On1l/EaiILh1KHHxu7Cr20d4s1n88jFAqx2jurSgeJQMj+u8lkglarxcbGBiKRSNdhPS5gnntahL4KGkqrGY2lNcQ8frjuuw1Srbovn0WJRMJL60cQBEQGDSxnxrHv9mDur/4Rd/7sj6OcyiJWzPVFaFu/F5qmsbS0hPHx8b4Ip0gkQrZUAN1ogPjBd8KYvUej0VOtzAC9rXMYGYjT6exp+cdYsfH53CNqI56QDePZYQEoCQl5rIDffOIDkIBgddB2u72nTZbNZsPe3l7bY/T5fDCbzbw3F1w3TGq1GiMjIyypbX08YwHIx+awGS6XC4uLi30RWmZz1S7IoxtOs7XeimGJGs9tvgDL+DCcF6eh0GoxbrFDIZcjFothZ2cHNE1DKpWyeutOJJdu0PhG4Dpe2ttEIZJAdUiHKwY7pw0YX2Sz2RMP0oVCIYRCobYV/VgsdkSe1On8Y+KGg8Egrl27xmsItBnhcBjBYLCtZKbXRlcsFh+p2m5vb4OiqGP3YoIgMDQ0xM4zNJ+DtyQHt8DiQ+O347d2d0CKRYBYAEWljp+698FjcX/FYhHZbBapVAqBQIC1YlEoFPhr36sgtSpENndBCglUSAJ/t/o8fsJ5+cgQUvOkO0mSR3SdOp0OUqkUUqkUBEEgYZbjHzdfA+jDlqHGasKMfrCvllk8Hkc5lsYf/+jP4bXYLrao63jXxTfDoTy8oZtMJjZKc2FhgY3SbK6AzMcC+MruMtyqGu6zjkNepDpexJ1wGvpZRqfbTEh+evROxNRjnNtgTARns3dku3QpLvZZfKBSqZDP509lKtolVuN574sYffAuGMecKEWSGBGq+iK0YrGYd9XErtQhG4lDJCJx7y99BEKRCI1aHfHtXSz4w+wAH1fy03rDWVtbYzXlfOHLxfHnay9ga8UNW2kHHxi/DSOEkiVknXxTbwT42n8Bh5vWYrHI632KxSKcUjX+4I4PAjicwBdUKYiVyiMDfnNzc0cG/Fqh1+vh9XqP/R7lchmJRKIvjTEzGMblvNfr9aAoCs8//zzq9TrK5TLUajXMZjMnSVM3kCQJvV6PcDjMy/+WsecaHx/nTXhOGh7QCel0GpZUHQ9fuQtPXXsJOpcd8MfwM2++FybF0WG1crmMbDbbleR+2b+MJ4PrKKezqFJl/K+XvomHFXa85cIdnDzX+SCXy8FgMPT9fI/Hg2q12nYQkPHQbf77Xudf8+xKt01fO1Ls8XhQqVQ6DiUyxQIuYKq2zVaVSqUSdrsdSqUSVqsVX/3qV7G8vIxMJgOlUgmXywWBQHCrQnsLhzDL1fil82/GX69FodaqcL9+sm12NROv2Awmdz21VgBVqcD79ItQGHUgSCF2NSWUzWchlUpZqx0+lY0326awvLKMDZsF6VAEo0oDPjxxB+/PF4/HEQgE2IrH444ZDETLLJllIBaLWXusfD6P/f19eDweGI1GbDVy+Kd9N5K5KCJBMb597SX85NhVPHb1Hl67w1Qq1Xf7jYnOrdfrx25qfHVqbrf72M2pW+JVs33WSaq1Go0GqVTqxIQ2Ho9jMEvjXXc9iJdSAeREItx2+TKeUDpZlww+5xofSzYGykwVV5VWrJsMoKoUMr4gfuUdH8DlAcexuNfmRKxOaNbQejweqFSqvkz3i1QVf+R+BiWqBgDI5fP4f7/2Ofz8xYdw78XLN4Rc0A0KS7HP4pn9L8Gr1GPa8Cgm1O+Ed3sH9Xqdd+VHLpfzHjDb2trC2NgY+2eHwwG/388OrHYb8Gs9l00mE6LR6JHvf21tDVNTU7yOiQEpl2DRv43J0TFY5L3PfblcDr/fz0ajbmxsYGNjAz/5kz954t/P6XRicXGR17m1traGwcHBU5EenQZCoRDC4TAuXbyIM+UybiONcE2Mo36miEQgBNP0Uf01UyjpRnK/sPQkKKEA0Y0dCEgRrGdHkRiRnUjz3wl8I28ZMPI2vV7fsXhxcHBw7LdlBhO7rbtKpRKXL1/G5uYmEolEzwRPLscCHN5XubgDNaPZqjKdTmN3d5ft3jKdRa1We+ivDLwh0fX94hahvQmQCkk4tcbDPHCzhbP4+tA/Uo0J1wg29wOYftuDoCkKGosJF0fOnMjLNJ1K44nh8/jl6WlsbXswoDdAIZLweo1WMssVSqUSk5OTbJrRZ779JRRqFRRiKeRSaRidNngV/FvnfKJpm8G0GjtZgVUqFc5SBq/XC71ef+zm1CtC8jSqtQwpPgn8fj8ymQyuXrmK2wkCP0bXsTmwCZvl8IabzWaxvLzMq6Xea+CvFZubmyAIAv/20R9BtJRDulJEZiCEUdHhDaM17pVJxGL8Lc1mM3tzqTdo/PPuCr69Po9aoYTbw6O4R+vgPXRC0/ShZVw4gFg4gnq1Bs/TL8J6bgoamxmBUgahUIgdFiFJkv3/7f6XD1bin8dm6huAqIJiMYNnw5/BWm0Pj1z+V33JGrjqThnE43FIJJIjOkK1Wo1SqXSsQtg84Le3t4f5+fljxNZqtcLtdrPEIBQKsXIrvnAnQ/hfW88jHgzBkN7AfZYx/PjY1a6dhGAwCLFYjFKphM997nO455574HA4TlzZA8AGOXBd430+H2QyWV+bq35s+nqBqU4ya7rf78eIzXEos5IqED444NTSbyW5pvI2CsUignOrEMrFEIpI4AalavVTtWbsIHuta8lk8pj1nFar5TS/wCR4MvMTTLploVaBP5eEvpCBXX0oR7x+/TqnNVYsFvPenLYeu1arBUVR+OIXv4j9/X2sr69jYmICVqv18Pe/RWhvoRVMy5kRX/OZJvzAyBX82sIydC4raBog9hN45wPnTnQ8Xq8Xs7OzEBIErCYzYrEYL7lBv2S2GUyakWbUDnG5gv3ldSgMasj0GpTrNV6v1c8gAE3TbEun2/RzsViE2Wzu+XrRaBSlUqmt12anxKtWNFdrY7EYRkdHOX+/XAaHOqGdNQ0AiAghLMZDtw3tDwZBmGGHVCrFyVdUKpUik8lwOo7r169DLpezThUmmQommQplqQYbGxvHpr+bE7GAwxvO/v4+Njc3oVQqsVCN4blsECWqimI+i6c2FmF+yArGiIlx7WjVmlcqlSPfJUEQh+29ehkNmoZYLoX10nmYJ+0gxBLoNFqIxWL29SqVCiiKAk3T7P/W63X2z93ADGWQJAmhUIgXg19DrZHD+rUIGg3gwr2DUIzs963RbSd/6QSapuHz+dp6wg4ODrK63Xbv4XQ6YbfbWecKs9kMm80GoYjEK/FdfOPlIBQyGRyJOt79pkd4f44yVcNfrL+AhlgIunq4XjwX3oZTpsWM0sQmHzK/J9M2jcViyGQyEIvFsNlsoGkaW1tbMJlMEAgEJ9Y+c13jw+EwCoVC3wEhp+lwwMgeWiuCmUzmyDXOJPnxldXcZRrBMwdbMJ0ZAykRgabq0EeKvLXcvdAPmU0mk/B6vT2109lstu2mi2+wDTM/4Xa7kSZpfCW3g9C2F1+ngjgnMeB2cgCz589zup+VQcOXisJStUMl5n7/Y7q/2WwWuVwOpVIJqVSK3Vz1ex95o3GL0N4kkCSJer0OgiBgNBp56awye2H87ls+iJwEIAQC6GaFCHh2oO0z9jMQCBwZvuA7IX8aZLYZZ3RWLIZ8sM2egdJiRGI7gIkH+RH2ZDLJq6LJTLAODQ311HBVKpWei0uxWITf7++YAterQtsMplobCoWO7OS5Ppdv5YaxprHZbG3PSa1Wi2AwyP6ZGXYIBAKcJAhisRiVSqXrMTA3VKPR2NaCidGtdTLRZ8DoxIDD3/iPn34WsUQckU0fSokUhu+5jK8+913Y44e/BUEQrI+wRCKBTCZj9ebtPhPdaGCJyOF6KgTzhAMNisbQoAlvnroAGXk61TKapo8QYUNVjR1fHNViHXqzEoRQAFL4xsRS7u3twWw2tyUJFosF8/PzXdu7zc4VzPn8UvEA16oxVLxZNOo0Vo16XMwnMKpun3LUziqQoigE0nGEfX7UKzV4n3ntcPBQIsFreRHMYxfY31Iulx+5fiuVCp599lmsra3hrrvuAkmS0Gg0GBsbQyKRwM7ODsRiMYxGI0wmE2+CxGyyWu0Wm5FOpxEMBnl5H7eiWCxyiqTuBaY62Ryqwvy9WCw+ssaLxWKYzWb4/X5ebf33jlxCrVjCc/oE6pUaPnjP47hdZ8fa2hoMBsOpWS1yjelmEAgEkEwmOWmnDw4OOkrauA4mMhCLxTh3YRY/86U/QzabBU3TyOxH8Fz9ABfe/G5OZPb5g218ZutVxLf9+HI1gA+M3Ya7LccLDMViEfl8HrlcDrlc7sh8jkqlYp0P1Go1NjY24HQ6sbOzAwBtA3V+mHCL0N4kNBMau93OWWcVjUYPn2M5eiFlU+muC2YnVKtVRCKRIztsPhPyXMgs35z7D43fgaDHi6p1ADKVAvcOjsOSqKI8xL3qmkqlOC+KjHE314GzXt9L84Ryr++EDwYHD4f01tbWoFAoOFVrtVotkskk580S4yTRjTR3OnaHwwGtVovl5eVjN8NmSKXSrjt+xl/RZrN11dSNjIxgd3eXc0VLrVbD7LSjPqBGpVSBUHzoMmEZG+474IAQCPCzZ+7Fk8EN7KojKO5H8bGLj54amQWOVmjL5TLEqXNQqvcxddWMkRkdDnZzaOxPgrL1PxDEZeNTrVYRjUY7VuMIgoBer+dkVUUQxOHvazHjj772GvKxBIJLG9AOD0KikOOLrzyLt9vPolarHTtXmE0HYxcoEokglUrhsAxCFTGAIEmMk3dDM2SGSCLG7Mg5jA91lpRIJBKMj4+jUCjAaDRCo9FgamoKIpGI3QyVy2VEo1GsrKwcbio46LSbYbfb2Spt6zVbLpf78j5uRaFQwMAAv6jTVnRzdohGo22vaYfDgWvXrsFsNnNen4UEgbsUg3j84WmkUikYZAbI5XJcuXIFgUAAc3NzvDbuncDV6YaZmWDS5Li+dqfih0qlQjab5VVUSVWKEFv0UMrFeO4P/hb222ZgnR7DqyuLGCoR7PlOkuQR1yGSJLFfSOOz268BhAANmgbdaOBT6y9CRxFQ1AnkcrkjDkpKpRI6na5rYMno6CgajQYCgQAkEgkmJiY4R1XfLNwitDcJJEmiVqux/5/LNCyTed+u6jc+Po5r165Bq9Xy0p55PJ62J6lGo+l5Qcbjcezu7naNgQReT1HierOVCAi8e+gczl+8AKGAgJAgUCwWsbq6yjmykot9TT6fx8bGBiwWy6leqGtra3C5XF0X934ILfB6xjrXaq1Wq8X+/j7nzVKnjPpWyGSytu3BVglCJ21qpylZpjrMJXlIqVSCoihe8pKHh6bwac+rUBq0MI07QVMUnGmcKNWJJIR4i+Ms4DiLa7VrUIpOL3q0GYzR/JsvfwR7pTE8P/9PMMqsuOOON0NVO8PGk/ZDApjfs9vv7vV6e14ndru9Z1jCEQgEkBt1kBt1CLzqBpUrA4QAErUCdrudvXFzxXunbseXd5dBkiToGgW73ox7LWM9n5dIJPC2t72t4xollUrhcDjgcDiO6bTVajUGBga6nq8EQcBsNiMYDB6ZdaAoCqurq315H7fipJZdzPBXp+pkMpnEmTNn2j53amqqrQSoG5iiA0mSiEQi7PfHhBZsbGxAJpOdyMKQS+RttVplNdxcpX+9hr76IbQqkRSgGyhEE7j64XeBrtehGrJgZNAFnU4HiqJQrVZRKpXYrgRju7ma3EfUf1hFvf7PT2OifC/EchnW5QHc65rmtdlgIBAIMD4+jvHxcba40I+rzRuJW4T2JkEgEBwhNFymYTc2Nrpe3DMzM1hdXeVs15PNZlGv19suxDqdjtVJtgNXMgsckjA+5M3v98PhcEAsfP30lMvlmJ2d5TSAxIU8+/1+xGIx3hPhvapYPp8PKpWqJzliJCf9YnBwkNXWqlQquFyutr+DWq3G1tZWz9fjklHfDGaSt90NtF+/RabVyYeUORwO+Hw+zsEid1tGQRIE/iH8FAZMQ7jfNomreju2t7cRCoUwNTV1ImIhk8l6yiD4goldBcBe2+rMeTxx7vyRjoxarYbb7YbRaOQ9IMoQ2k7Xez6fR6VS4TSUIhaLOX8HYiGJszorVsMBDN91AfIBHYqxFO65h9vGtRWP2c/CpTLiZeEyBjQ6PDJ9CSJC2PU50WgUGo2G84a7VaedTqfZ6f1u0gSbzYa5a3OgNDLQABxKHdwrKxgdHT0V3ehJhsI2NzdB03RHyQMjeen0+kqlEjKZjHOQBLNGMwl0rRI3qVSKCxcusEOx/fo49yL57QIKuKCTVpwB18GwZkgIIa5UlXhWq4bKqEd0ywezVIEnxi9ASoq6PleeGsIrsgJomsbUEw+AFIshlIgwNToGk/HkzhEGg6ErH/hhwS1Ce5MgFB5dZJkqbacFIRQKQSKRdD2hpFIpXC4X1tbWOLVht7a2Oj6uVSfZDD5kFuA3nETTdNvJUeZ1Ll68iJWVFVAU1XHhTKfTHf1ny+Uy3G43BgYG+mozl8tlSCTt3R+SySRyuRynBDOSJE/s5ccs+syQTSci2E3PxQx/KRQKXsMoer0ePp+va0Wj2W+xVYLQekzMjYWvib1er8fOzg4vScvtJheErku4cvn13396ehrpdBrLy8uwWq28pTsMDAYDksnkqRFaRtvd6riRTCYxMTFx5LFisRiXLl2C1+vF0tISZmZmOH8nvay7tra2ONtotVp49cK/mrobv78fBW0yQjdgxD3DF0EEk6CNjr4qc5NaM1TDh+dyLzILgJVM9YvmSOBu0oQqXcc/p7ax+51XoLIOgN5P4OcuP3yqgRt80WwH1W0TFI/Hezo+jI+PY35+Hnq9vud5F4/Hj3zuTpIXi8UCo9GIzc1NdsN5WlZ4TEeKj7c58HpIUbdrnO9gGE3TcLvdeOLsVdyvuBPebAyEZRr6PN2TzALAlNaC8/ohXAt6IVeroHZYMU4oUdjZR6gqOHGErVarRSAQODVt843CLUJ7E9FKaJxOJ5aWlo4RtXK5jP39/Y4DRs0wGo1IJBI99bShUIgddmmHTi3xZDLJi8wCh+SdK6ENBoNdHQRIksSFCxfgdrtRrVbbfsZO/rPBYBDhcBhTU1N9E45Ok8TlcpmNqeQCPpPlvWCz2VhtrUajOVat7dT+apdLzhVcrZ6USiUuXryIjY0NVoJQo+s4qGQhjO5hamAIpVweHo+H942FAUOgTiob0Wq1uHz5Mnw+HxYWFvpKK9Lr9VhbWzuRhR4Dv9+PRCLR9nvplrTWnB3PtfIkl8sRCoXa/ls0GoVCoeD8XXSy8Or43qQYj+lHjnSWotEolpaW+h40FYvFyOVyPR/HtzrbC92kCc+nAwhW8yilM6BpGgK6gW/n/biI/mPLGdxIayrg0Ami19AXQRBwuVzweDw9OybxePzIhkyv1x/6XbchXiRJ4uzZs0gmk1hcXOSUQAd0d33w+XzI5XK87mMMkskkp00I18EwhswajUb2809oDtfjlZUVTrZojJb/a5QYMXUOZ0fGcLtpGGiAXc8mJib6vu+dRgHmjcAPb4bZv3C0VmgBsNO18Xj8yN+vra1hcnKS84U3Pj6OcDiMfD7f9t9pmsb+/n7P3RaTeMIgmUxiZ2eH901GLBazeuFeiEQiPatjBEHg/PnzyGQy8Pl8x/49l8sduXCr1SqWlpbYhJWTVM/atbBommb1vTfCSJ8LpFIpLl26BIlEgvn5+SO/GyMfaQbjHzs1NdW3mTlXUk6SJGZmZiCTyfDcyy/id17+Kj7tm8cfLDyJX336c5hzr2B2drbvvHWTyYRkMslrwe10/hIEgdHRUUxMTGBtba3t+dUNfOU17cCcr0wLuPV74TK5rdVqMTs7i93dXU6foVNFiabpvjYLjIUXFzD2R82/iclkgs1mY78HvuDaFbqRVSdGmjAzM4OrV68iJyNQTCSx8/wcFj77VSitRuwV0qfyXnwdDpLJJKvd5ULOelUkGRiNRtRqNWSz2a6Pa92QGY3GY/e9Vuj1ely+fBmZTAZLS0s9K6DtBsIY8kjTNM6fP9/XZikUCnEK7GEKCd3Q7ObSjsyPjY2xDgO9QAgInJEb8SPTt+FO8wgIAcGuZ1NTU9je3sbm5mbf6xOXz3OzcYvQ3kS001A6nU54drzYzsSwm0tg1+9n4wK5giAIzMzMYH19ve3NwOv1wul0dr2Ya3Qdr+ZD+O8vfRV/s/kSNvf9LJnlS9q43lyi0Sj0ej3nRebs2bNH9IX1Bo1EKQ8aDfY1wuEwlpeXMTIywsvDtRPK5fIxQru2tgan03mqusl+YbPZcO7cOWxtbbFEJiao4h/cL+Mfd+axX0gjHA5ja2sLs7OzJzpmnU6HdDrN69iuS8pYu+5GrVRCIZpAKBjEoqJ04oEYq9XaUSLTCsZ+qBuUSiWuXLkCoVCIa9eu8VrIWzeCfBCPx9nztRPRisVinAz/mQFCgiCwtLTUl5ek3++H1Wrlfc1bLBbWkaUX9vb2MDQ0dOzvT0JquWyiT7s62w3JZBL1WBqoA4MXZzBy71UkPLsQJPs7T1qRz+c5e9AGg0EEAgFcvHiRU9W9k99qJ0xMTGBzc7Pjv6fT6WNEs5fzCQOCIDA5OYmRkRG43W4EAoGOj83lckfum9VqFQsLCzCZTH13cxjLOC7fm0aj6eq3zZDZbsNocrkcIpEIyWSS0/EVCoW2v5VcLseFCxeg0+mwuLjYsRvTDe0KIz9suEVobxI6TQum6xX8tf8a/tNzX8J/euWf8T9e/CoGnfy936RSKZxOJ0v2GBSLReRyua5VuUajgT9ffx4vZPextu/Hc9vX8TtP/j2c0xN9Lf58qiV8IwpHR0ehUCjwtRefwa+89CX80vf/Hv/T8wK+61/DysoKMpkMLl++fGL7FwalUulIZYGxNLkRkY39gqnWCoVC/N1TX8d/v/ZtzEV8+P7+Fv7d1z+Fhd1NXLp06cQksteC3Q7RRhma4SFsf28Oq195CprhQYRKJ9/1Dw4OIhKJcHpsuVzmfPN3OByYmZnBzs4OOzjTCzqdDolEgtPrM2A2ZsyUebfzNZVK8dJdOp1ODA8PY3l5ueuNkWmRMqhWq0gkEn3piZstvLqB0SN2+rwmkwkOh4M3qeWy5txoTSBN0wgGg5ibm0MsFsNH73sC+gEjdENmqAb00LvseMfwOczNzfHaGLYDV4eDzc1NFAoFXoWJWCzGyw5MKpWy3rR8Xo9PBVCtVuPKlSuo1+u4du0aisXiscc0E9rT6EgBh5sgrt+FWq3uuD42k9le8onx8XHOVdpe0hOTyYTLly+jVCphYWGB18Zbr9ffIrS30B4CgQCNRuPY3//N5suAXo1cOI7UbgjlASW+vLvc13uYTCYQBIF1/w6e3t/AU8F1vLKyeGyYpBXRcg6ryRAEJIH49i4yoQhUw0O4ltzr6zjEYnHPif50Og2FQtEXYTZYLfjnpAeBjS2U01lQVA3/6ztfRF0r4yXV4IJmTVQ6nUY8Hucdm/pGweFwwC0tIRM8QDIcRWB5DQ0B4FHUT+U70Wq1vAhtPp9HJRBFbi8C1wNX4Lgyg5Q3AHGBXwpcOzABJVwqD8ViseNgXzsww3cajQbz8/M9qyVGo5HXwp/P5zE/Pw+dTtdzkIsJWeB7nWi1Wly8eBHBYBBer7ftYyQSyZE27tbWFsbGeltedQKTCtYNnbxNm8G4NvAhta3kvN373qjqbLlcxubmJubn50HTNC5fvozJyUnYdUb8qGEKP3XXo3jvxXvwUeslPHL+dszOziIYDMLtdvMaJGpGp8ocA4qisLS0BIVC0TM4phV8N1DA4doTi8Xafp5MJtP29QwGA2KxGK/3cblcOHPmDDY2NuD1ekHTNK6nQvjkxkv4im8JG5kIQqHQqXSkgMOOHxe5AdC56syHzAKH90+VSsVpc8hlXe9XhtCv1eQbiVtDYTcJBEFAIBAcOwn3CikQYiF2XlqASCwCIRbhWn4Jd4tMrIE4Y43DpcKmtJnxq1/4CyjsJlDlKmrZIpxnJqDE6xc2RVHI5/PI5/MoFArYiR8gtrEDEAKk9yJQWoyAkEC13t/JTJJkz2rJ7u4u5ynqVuwXUhBqFZBSOrz8x5/GxOP3wjwxgr1aAdxGtPijWq3C4/FwHgK7WagIAYVBB8/3XoFcr4ZEIoFnYxNB3QRvz+JW9CINDNLpNHZ3d0GSJD5696P4E+/L8K9tQm0egMFlx5t1LqysrGBiYqJvHS3wekBJr4neSqUCjUbD+/W5TlzzWfiZQUWuA3HdHDx6oVeim1wuZ72FmbSik9j0cLHwCofDHb1Nm8GQ3pMMijXjpM4G7ZBMJtkWuMPhOEYcfT4fzoyOw2KxgB6isbCwAODwe5qZmUE2m4Xb7YbBYOgpCWtFN8uuYrGI69ev92V91WyvxRcTExPHvGm7Hader8fu7i7v95HL5bh06RKCwSA++91v4OlaGBKZFMl0BL/zrc/hvY4LePddbzrxOcMk9fHpbLUOhvElswxGR0exuLjYtbrMN/qYkSFEo1HOw3YnkVO9EbhFaG8SBAJB2ylIrViGeDmPgfFhECQBmVoJu80GmUyGarWKTCaDcrncNkGnOTWH+d/Pel6CzKRDzBNAg6ahc1jx5y9+Gx8ZvoJSqcRWexQKBRQKBaxWK1yjI3hBlEGyUoRcr0UxnkJ804fJM2+6Id9FPp8HQRB9kxmFSIJ8NIFiIoWR+67CPDWKarGMxG4Q11KHsX4qlQoqlQpqtbpvz0emncMsSpOTkyeq8PCNR+SLbDYLyV4SVL2MmXc8DFIsgsKgxR26w5vl3t4eCoUCgMOFitFq8yG5CoUCmVwWGtXxljFji6NQKDA1NcX+vr+tfQv+PiPAwKAFTpEKl6fPsTdzpsXcD0iShFar7RmSUCwWuzpp9HoPLhPXCoWi63QyRVGsXRof+7hYLNb3sTPolOjGeNEC3S39+L5XJwuvarXKiyCcFqk9zeosIyuIRCJQq9VHzvNmVKtVpFIpVrvJrHfN4SRMG52x4Wu1ausHyWQSXq+Xtx0ecCg9i0QifQeOqNXqY960zJxEOzCJeP04NgCHGn3P3hwKG3FEIglUikUMnp/CurxyKmtsOBzm/XsoVSrsRPbhNA9CCEFfZBY4XHeYDlSnDTvXVLRWmEwmGI1GeL1ehEKhrm4IOp2Os573ZuAWob1JYC6w1ov3J8Zuw++98nXI1EooTTrUkzm8/Z5ZmAa4mVUz/5XLZRQKBQRCIeTyGYSW1lFKZjDywFVIbDY2r7nThf6L5x7EX268CF+1BqJQxkfufBQ53z7yUn6Ehwt2d3cxPDzc13Pz+TxC6x6cUZmxrVZBSIog02rgtA7hxy48CikpAk3TyGazyGaz8Pl8rN2UTCZjSa5are74XdANGt8JruOV3Q2Uk1n4y2lcdUycWJfLVPJOqmVtRbVaxdbWFmiaxq88/n58cudVrHq30Gg0cF4/hPdN3Q6xkDyyMObzeaTT6bYkV6vVtr0Z+nNJ/LnvVcSuZzFkt+FDE3dgWmNBKBTCwcEB9Ho9zp8/f+zzyQkRbreM4PzMebZKxdzM/X4/rl271re1mtPpZC1wOqFSqZyoEgwcVpO0Wi28Xi9rBdf8mowRebtzhCEZfM3cgUNdIN+WcTu0JrrZR4bxvZgXWwEfhkIm3KGzn/g7Yt6nk4XXwcEB7xs787suLCz0tFzqtGE8jepsuVyG3+9HNpuF1WrtGWbTTr5hMpkQiUSO6XhtNhssFssRgtGNjHYigIFAAMlksmPyV8fXo+v4B+88XorsILa1iyduvwc/MWgFycHTtxWt3rTxeLxrRd5gMCAej/M+LxhUGnWQMikSvkN5XCVXQDwWO5XCQTQa5eQxzmA1uY8/2nwGhWIROqsJd1NaPDh9se/P5nQ6MT8/D4vF0vaznCT6mCAIjI+Po1gsYmNjAwqFom2IE2NL+MOKW4T2JqHRaBxLCwOAaZ0FHzScxZ52GCIhiYfPXMTu+haGVPqeN5h2MoTLpXO4FguAEBKQ6TSgy1VoKg3s7e3B6XR2XChNMhV+8+JjoBsNLMzP48roDMpD5bYm+ScBQ8D5kkOKouD1elEqlXDu3DlcllzG19bmsAUlJh0TeHhoijWkZtJoWslDsVhENptlU36YanVzNVcqleKffMt4an8dxVQG+Ugcvlwc45OTOJlV9aF122kSWsZiKZFIYGxsjP28/372EaxrxyBoNDDtaq+JVCqVxwgkQ3KbNwEqlQoajQaETIL/ufY95MUCVGIlpIt5/O5TX8AHrOdxxjna9QbP2E4xVarmlrTT6YTZbO479lIsFkMikXStjp5WVZy5CeTz+WPVZb1eD7fbfWTIkaZp9pzlSzIAbgl4fMBIEPyBAH7lH/4/FPVypEIHWNn3Ye9iBZP18SNpff2CsfBqHfiMxWIdk6m6oZnUdhtuYgbDmtfNk1Zne8kK2qGTfMNoNHYcTCNJEpOTk2w8t0KhwOjoaNvjbtdqXl9fB0EQfRH3r+wu4/nwNuo0DapO4eVkAEq/Au9x8ZdXEQQB46AV/+07/4icQYq8N4hfGLZiUty+yzAwMICdnR3epI+JhVcc5CGWSnDm7Q+hkitAadRhRKjF/Pw85HI5hoaG+pLRVKtVEATB+bxJlgv4/9aeBy2ToByJIZzz4TsGHd6kvov3ezPoFJ/MoFAonHjIkZFvRKNRzM/PH+tAnYYt4Y3ELUJ7k9CsoW0GRVHQkBLMjk0ilUphQKmB4uxZrK6uYnZ2ljf5ed/IZYSKGURKXojtclhMVnz8/IMgSjVsb2+Doig2p7ntcQoER9qnFy9eZIcX+Ew/d6qW+Hw+3tXZcDjMEvLmG8oFpQV3zro4t4XkcjnkcvmRC5aiKGSzWeRyOUSjUZRKJfzj6lOAWITYhg8CIYmxB2/DswcenNFxGw7ohNMU2TPfydDQ0LEWtkAggF6q4P1eDMllfmeaplmSO7+zDv/1DdAAfM+8ipH7r0IxYIBszAaHtbtkIJvNshrWwcFBHBwcHBmsa4295LuBcrlc2N7e5lVNOQkYi6/m6vJOJYO/uP4c9LUAZnSDeMw8ge3NLVgslr6HCLkauvNFQSVCwaBA2h/E3oIb0489gMgPBkMvD5w8IMJisbAtdAaMzVS/Gwuj0cjakXUitSKR6Bih7ac6y1VW0Anb29ttq5LtZAetUCqVLMFYXFzE0NDQsZZzM6GlKKqnFVQ30DSNV4IelDJZ+F9ZQrVQgkynxrO5JdyrGIJYLAZJkkf+6/p6jQa+EFvDSjQAYUGKhqCOP3R/H79x8VHYFMe14FwDWxhUq1U2JMHhcODX3vkBfMrzCl7Z20KxWsMdtnH85PhhRyqfz2N/fx8ejwdarRZWq5VzF4hvN8GXS6BcLqOSK2D589/ApQ++HWKdCjvZOKxy/vp9BjabDfPz87DZbMeunX6lGu3QKkNoDpmRSiWoZFNo1CkITmHDe5r44Tqa/8PQrkK7v78Pi8VyhOzI5XJMTk5iZWWFtw+sSizFb1x4DN/IiXH24iwcSv1hHKTkcPK5Wq1ib28Pfr8fer0edrv9GGk2GAxIJBJQq9VsUtfm5iY2Nzc5tz+ZnV3za1MUxauFWiwWsbW1BZlM1rYCmMvlTqwvZCKIGeJANxrQl7YQ8+4htbuPgalhZPYjKGv6axu1vtdJ01ey2Sy2trag0Wi6VkW5DnB1A0EQrDyjrJZAV9pDYscPrXMI+hEHSIkYYg5tyWw2y2469Hp9x6n75iGscDiMiYkJThs6ZuFtRxT6cQjgCqa6/O3XXsTng0uo0zRK8Sj8wT2sLi7hN5/48b7128ChR+3IyMgpHvHhNRgMhZALx1AtVhBze+G4fB6FWBKbggEM1cXQarUnkh80W3gxv/v+/n5b71k+YK7RTqS2dcqcb3W2WCxib2+Ps6ygHZiUtU7fn8ViwcHBQU9fVIZg+Hw+XLt2DRMTE6AkQnx++xrcnk3YDGb8qFyMhG+vp5SFsUorFosolUqH7iOVCltwKIYTqKEGoVSCeiaL9N4BdHYJSqUScrkcKIpCrVZjh6SY12TAaGFJkkS2XsXCxnVAJITnqRcx9ui9aKCBuZi/LaEFDq/fboOEwKHkw+fzoVAoYHh4+Mg95Ken7sFPjt2O5aUl3DZ1lf17pVLJPo5JvCyXyxgYGIDVam27ttQbNAq1CqLRaM+kznK5jGQyiWQyCV9sH5m9A0jUSlgvTKGaLyKxtYuQwIw4qem7w0kQBIaGhuD3+49UY2/ELEarDEGlUmFEXIPmq59A7lU36Po6BG/+SRBn+q86nzZuEdqbBKFQyLacm8FcOOVy+cgioVarMTIywpJaPidvpVzGqNGKUfVxfY1YLMbo6ChGR0cRjUbhdrtBkiQ7ONJoNOCuJPClV76LofQY7raM4j7LGCYnJxEIBDhnxjPxt82Lxt7eHqcqAk3T8Pl8SKVSXbWV5XL5VHR/zSgWCjBGy8ipFBi5/yoGpkZQTGWgCefZgIp+CdJJKrTNOtmZmZmen5sgiLY2cf1iABJID9LQ2wahNOpRzeRhtttxwdC7at/6OymVyo4SAWYIK51OY3l5GVarlVNnYHh4GD6f79gwEl/LLr6QSqVIWxQQJ6Twz1/H9vdfwfiDdyBq10AoOZm0pF2oRz9gZDapVAokSWJQpYJu0Ay6UsHlD78bOqcVEpkct42fQbVSxfb2NsrlMivHYXTVfM57u93OyjKYYzgNLXA3UstUaBlwrc7G43EEg0EQBMFZVtAOjASomxOKXq+Hz+fjZPTP2C2Vy2Wsrl/Hn2++BMGAFqlMCtl6Bf/31gb+8L3/Glq1liWt+XwepVIJhUKBtdAiCAIymQxyuRwKhQIDAwOQSqXsPeUnh3T45MaL0GRyMI46QJAkbtPbkM/nMT4+zmlTSVEUKIpCKJeCZF+JUiIFkVyKciqLaDqHmECL6uCZtq81MDCARCLRdp1nIsYrlQqGh4c7diwkpAgE2nu9A2CLFjRNIxqNYm1tDTRNw2QysQWlhXgAf7v5CgrFPCqRNH5zzI5p3euFjGYCy4S16PV6jIyM4MzZMwiskliL7sFydhx0tYqLFy7gkek7EI9Esbu7C5lMBqvVyrvrMjg4iLm5OdjtdvZ85+twwAeMDOHAt425P/oPMMtJ5Ks1oF5D49t/jYZxCAITP//4G4VbhPYmo5nQpNNpdjiJJMlj3q16vR7VahVut5tXOzWdTnOyKTKZTDCZTCgWi/D7/fB4PPATZXwn70cin0Y1G4c/n0SdpvHg0CQcDgfkcjkWFxd72g61Gp0zOedXr17t+Bzg9QGaoaGhvtNd+gFDojOZDH718ffjn/aW8eTLL0AjluH9ly/jwaFJhMNhLC4uQq/X90Vs221ouBxXO51sL5xGhZZBKBRCOBzG7777o3gyvAV/OopKMI6fv/AIZCR/0ma1WrG/v99VR63VanH58mU2l7y5BdYOarUalUrl2CbqRmx6mlGtVhEPhlCIpyFRyVBOZ1FO50DXaUQnohgytx/o6IVisdj3cVerVcTjccTjcVSrVahUKhgMBrhcLvZY3h2P4KtDdWRLBZClOn7u8n0Y0x/dbFIUhXQ6jUwmg2AwCIqiIJVKoVarodVqu/5+YrEYJZrCdzyHEdQ2xcmJOYNOpFYsFiOXywHoXZ1tlhVotVresoJ2CAaDMJvNXdcFhlz2qkg2QyqVQuq0oBaSIOv1wffCAsxTo1BYjfj6K8/inH4IJElCJpOxg69Wq5Xz57nD7EImFscrwyKoBwwwxkr44INPIJlMYmVlhZOtGCNHGJZYMKw0wL0fxcy7H4WQIIA6jcvmw+FNJh6YGXRqNBq4VozgC889BfPkCO40u/A25zmUS2Xs7OyAoigMDw+fyE6uGQRBsK4DFEUhHA5jZWUFqVoJn46sQqxRopDIQKKR448WnsIvjt4NKl88RmDbrUX/ZuYBfMX9CgICFay6AZyXGqBRqqBRHjoR5PN5HBwcwOv1QqlUwmq1cv5cTqcTPp+PlS/163DAB6ZGEaRGgpWDFL6yvIvffPOh/r0R3LpFaP9PB9OWaSYZgUCAnYTtVL2zWCyoVqtYX1/H9PQ0p/fK5XKczaCBwx3Z9PQ0aJrGZ7/5KcRDe4ht76Faq2Do3DSeOdjCg0OHVQuj0QipVIrV1VVMTk52vKm1VktCoVBXrWu1WsXGxgaEQiGnARou+fZckc1msbm5CavVyg6tvMM0jfvusxwh1cxCyBBbo9HIyz+Ssajhim46WS7vdVJCS9M0G2nJdAl+ZOSw+nSNvga1uHeFoN3vpNVq4fF4ej6XqVAxLTCNRnOElLXC4XDA5/MdqbDdiEoGcyOMRqMgCAK3DY5hU1iEtjYEuV4LogHcOXkOVLmChYUFiMVidvPI9VzpZUXWinQ6jVgshkwmw1r+dPL5jcfjcCj1+NPbfgqxdBLJSAxT+uOdE+Z1mo+jXC4jnU7j4OAAW1tbAA7dMXQ63RGpQqiQxmdT64itRdCo12F2OjDgsMGu7M9TtxXtSG3zJrpTdZbZvBcKBVgslr5kBe1AURQikUjPNjVwuI5EIhHerh5StRLljAINAaAftUNu0GLq3DlcMZ9cljJQFeI33/QekCQJv9+PYDAIm80GvV6PUCjUdmCoHYqFAh4izRi804jdYhJqkRTvcV3EhPZQGlatVhEOh9nrYquRw3fSPmRqJZDlPL6yOY/dDQ/ut4xhZGTk1BIf24EkSdhsNthsNjzlc6O6W0YuEsfmd57H+JvvRkEsgt+UwL2j3CzQRIQQV1SDuN8yDpPJhIWFhSMyKKVSeYSQHhwcwOPxQK1Ww2q1dv2sJpMJgUCA3bCfxOGgHarVKjtLksvlUK1WIUgeQFGqwqVTYnKAKZA1AOnp3HdPA7cI7U0GU4VlWjTMyd6N7DgcDni9Xvh8Pk5Tjblcrq9BFIIgINOpIUrLUC8WEVndhkQig9xxNIpXqVRidnYWKysrrOVMK1ortAcHBx0X+0AggEgkwsvW6DR2qMwUeqFQODaAl8lkOla5GWLLLPRciS1JkpwGILjqZHvhJIS2Wq1iZWUFg4ODbWUiGo0G6XS65+/V6XfSarWch56YFhjzfXc6T4xGI3Z3d48MS1QqlVO5KdI0zZJYplV5/vx59n2URi2+7JkHLUvh9ukZXKC1cLlccLlcKJfLiEQiWFhYAEmSLLltt2mjG3WUqCTC0QAunL+t4/FUq1VEo1HE4/HDwVKNBgaDAaOjo13PF2ao5vLlyxAIBDBqdAj62keWtoNUKj3mq5nNZpFOp49IFf4xtIJivYxKJg9CTIIWEfj77Tn8uwuPcH6vXmgltRQBBDJxiPflx6qzrbKC06r4MWDkSFyuVUYby6cDNaY2oRaMgSSFuPKBtyMTiEDtGDrxoCoA9jdjvi+73Y75+XkMDg6CIAgMDg7CYrGwet7mTlGyXECgkIJaJIVVpMD6+jpuu3QZ93WoDovFYjgcDjgcDpTLZXzyO3+HsH8XB+s7CK1uwTY7Bd+wFL/Yh1sDc8/px0VGp1RBPWhCnhTCNDWKgYlhECQJl93BS/ZTKBTYYtLExAS2trbabqyY2QTgcDO6v7+Pzc3NruR2ZGQEXq8X09PTJ3I4YNx+GPLKeEMzbj9DQ4fDgI0GDbqwA/eLz2J4QAMICEBvgWC896btjcItQnuTIBQKjwyFMcNgXDE6Oorr16+zO+de4EuCGFssc4pCSKeBdfawYqu2WzAp0mFubg5msxmDg4NsNeTSpUtYW1tDqVQ6dnExu0jg8Gai1WqPHRND3AYGBnpKEVrBtwrdinQ6DY/Hg6GhobbkP5PJwG63t3nm62DIHkO0TCYT7HZ7x+++l4aWSSOr1+ucdLLdcJIKLVOx7laBZ2IrexGDTr+T1WplBxO5YnBwEEajEVtbW9jf328bdGGz2bC3t8eej5VKpW8dKiOTCYfDqFarGBgYwJkz7XWAl4wOnNcOwi1z48KFCwgGg+x3KJVK4XQ64XQ62QrVysoKG9/LaPjy1Qie3f9dZKv72PGnANuP4Ir5p0EIhKBpmq3C5nI5tv3Z6Xg6YW1t7Ug89GlU8ptvzsDhWvK3MTfK2SICcytsqExetIcVwgKRSMSGwjSnIEqlUt4yHr1eD4Ig8JnvfRMvkWnEfXsQrAD/5rEfgYuiEAqFTlVW0A7FYhGFQoGX9pbLIBQDmqax6b6OX7z6KL5XCiFUSEOtofCxkTuh4dAl6YXWexFBELDb7UdIN9MtYbT8gUAAeb0Un9mdR73RAFWlYE5U8BtP/Fjb77hcLrPJlMxwGk3TqOaKqJVrqFerIGVi6IaHIO3zemWinPshtOf1QxiUqbGc8MI6M4FKJo8LI5MY0/CrgjZLnJRKJSQSSc9uS7PFZDO5bXVm0Ov1+L77Gr6dDyDo3cG7LCrcbR6BQNBeO8y41GSzWWQymWN+7AMDA103wAIBAbz1ZxHez8OQEUJw+xMQXH4EAtGNm0ngi1uE9iaBGdBhbh5cpihbcfbsWaysrLAtzHbg22KlKAp+vx/JZBIulwu/MPE+fGVnEV9JfB8yjRK3q+z48B0PAY3DFjiTD8542s7MzMDr9cLtduPMmTPsxdHsXxcIBI6kEFEUBY/Hg1qt1jdx65Vl3gk0TcPj8aBSqXS1ReNjicIQWybxpxOx7URo+9XJdkO/RCUYDCIajfa0jNNqtdjZ2en5ep1+J6VSiWKxyHtal4kN7ZTcZbFYMDc3x1bL+rnBJZNJhEIhlMtlGAwGzhG9zd+5zWbD+vr6sQ1oc4WKqbK63W7QNA136S9AqOMolWuQKoRYj3wHhagEOvoiKIqCTqeD2Wzue2gpEAiw6XDNEIvFp6o1JkkSk0MOZKol2K+eg2JAD92QBdM6C6Ympo4EwlSrVRQKBVSr1bZpiCRJHiG+7eLAqxIhnqUiyPgjKCazUA7o8GfPfBVF5xVcGJ08NVlBJ2xvb2NiYoLXc6xW6zH7unagKApLS0twOBwwmUyYxWFceLFYxPb2NmDmbqXYCclk8li12GKx4Nq1a8cqnsz1F0km8F++8ueARAKlSYfUbghVkxEvBD2YUQygUCiwARvAYWWfSac0GAyQy+WIRqO4GLUhrxRBplVCbTUhtbuPdz3UXwVQKpWiXC731ZERC0n8iGoMwxflKAgBQSKDfzXzAAjByc6b8fFxdu6CyznYTG6TyST8fj+KxSL0ej3iEhpfLwSQ9cbQoGn8nedVFKkqHrFNt5UMEAQBhUIBlUoFl8vV18Y+EotDceF+SKEBcdc7eT//RuOmEtrnnnsOv/d7v4f5+XkcHBzgy1/+Mt75zney//7hD38Yn/rUp4485/bbb8crr7zC/rlSqeBXfuVX8Pd///colUp46KGH8Kd/+qe8PFJvBgQCATsU1DwMxhczMzNYWlqCWCxuS3y4tuJpmsbe3h6i0SjsdvuRBe0uxSCuPPBeDA4OYmlp6fCiFrxO3Jj2Ik3TsNlsGB0dZXVRTFIUSZKo1WqHcawSCbsohkIh7O/vnzisoR/bEmbgrJcWrN+2lc1mO1KxNZvNrH8g3WhgPRPBxoEXkkEjhlUGAK/rZK1WK2+dbDfwJbSMXpYxZ+/13TKDjL2+q26/k9FoRDwe7yvus1tyl9lsRigU4rUmMLrQfD4PrVaL4eFh3hum1u98enoaCwsLUCqVba9VsVjMavjK1QJefmUP2e0Knv1nH8xDCoxfNELt8uLucz9x4jCOfD6PeDzeNthAo9Egm82eavXy3fbzmHvtNehH7CilMtBJ5PiJsdvahsF0A0VRxwhwJpM5QoBXE/vI7EdQyuRx7W+/iHs+/mEoLEZoxh0YtJw0DqU70uk0CILgfa50s69jUK1Wsby83FZiw6Q+8hkua4d0Ot3x+c0t7lZQEiG048MopjKY/7uvwjI7CZGIhCcUwPlJM6xWK+RyecdgiKWlJahUKnz00XdiaHMRTzUWoRschFM7jLON/j4PU6HtB+VyGaVcHh+6+iAAYG5u7tDukgfarYUkScJsNrM+6nzQ7MyQTCbx5899BZlEGMndIBoCIUQyKf7Ouw/9TAEkSUKj0RyRDJwGQqEQlErlDXNUOCluKqFltIof+chH8J73vKftYx577DH8zd/8Dfvn1h/m3/7bf4uvfe1r+PznPw+DwYBf/uVfxlvf+lbMz89DKOQf1fdGoTn6tnkYrN1jer3O+fPnsbi4iOnp6WOLUSaT6dqKp2majSq1Wq1tW/3xeBxjY2Ps5GzrosnsIpm0Fp/PB5PJhOHhYSwvL2N4YgzfiWxhzj0Pk0+Nj977OPL5/KnoQgH+hJOpCNfrdU5hFVxdItqBIAiW2DZXbL+a3cFSdA+ZwD5eEqbxuGEcjrIQKpWqrxQpLsfB1barl162E/R6PeLxeMfn9Kr6Wa1WbG1t9Z1f35rcNTAwAKfTyZqRWwatqDc6k3pm6pi5qQ8NDZ36EApzrfZyBZGIZBiwaKEdKGMmPgCRUAiRiEQ2Xsf+/j7MZvOJpBPr6+s4d+5c239XqVRIpVJ9/w7tsO/ZwX9/x08hXC/Cs76Ft1y+D5I+TNkZbWe3z65MD+EZOoayewszP/E2iOUySFUKqMU3zt2CwUkCPbrZ1xWLRVy/fr3tGs9gZGTkxIEi7RLdGOj1egQCgbb+zlqxDAQEECt+YG844YIAwMzoVMf1gJlZyOVymJiYeD0tkJbivz76E+x7LCwsQKfT8b4WpVIp63LBF9vb20fuyWq1umv6YDt0GlR2OByYm5vr6H3bC4w0yTDiQMogRTp0gHQgAoNrEIZx16kWQpqRzWYhk8lQKpUgEoluyHucFLxZxIc//GE899xzp/Lmjz/+OP7zf/7PePe7393xMRKJhB06sFgsRzR2mUwGn/zkJ/H7v//7ePjhh3Hx4kV85jOfwerqKp5++ulTOcYbBX8+iS/6FvBbr3wFf7r6faQb1d5P6gCSJDE7O4v19fVjO9JurXimckjTNC5fvtyxgtVMROx2O/z+9kMjYrEY4+PjuHz5MkQiEXZ3dwFCgH/3j3+B73pW4EuEsRgN4Le/+w9YXV/D1NRUz6EVLuDjcBCPx7G4uAiDwYCZmRlOC0oqleqb0DJghk8uX76MpeQevvfy8ygmU6iWKkj6gvjMq0/DMurE+Pj4DTH+5/odM36vExMTvJOGTCYTkslkx3/v1S1gjPBPquFkkrsEAgHm5uaQymbwdHIXP/mlP8H/cH8Xf7XxIqr1w9ZnsViE1+vF3Nwc/H4/DAYDrl69iunp6RsyUc346q6urnb9nAIBgQsDH0AqWsbw+AC0BgUGnXq88/6fh0qlws7ODubm5uDxeJDNZnkdw+bmJux2e0dCrVar+yYC7eD1eg/dEXR6zBhtsMvUfZFZrlBXAFOGAimTYOKuw5u7jRLj7CkMTHVDOByGTqfruxpmtVoRiUSO/X02m8X169dx9uzZrtVXhgDm8/m+3p+maZRKpa7vMTY2dihtaIFCJMGPjl1BKZGCwnDoXDGmHsA9lvZR20y0qkqlwqVLl9j3pGn6mN/yzMwMNjc3eVscSqVSVCoVXs8B2kcVDwwMIBaL8Xqdbvel0dFRTs4u3XDJeChj01jNuPrhd0Np0MMQKSEUCp3odTthb2+v5xzJzQbvVSWXy+GRRx6B3W7HRz7yEXzoQx86ceJLNzzzzDMwmUzQarW4//778V/+y39hKwfz8/Oo1Wp45JHXJ2UHBwcxMzODl156CY8++mjb16xUKkdOdL43hJMiUsziK4FlVBt1FBMZFI16fGL1e/hPV94GKXl058O1lS4Wi9kbZXPVsd3zo9Eo/H4/jEZjz+po60WpVqtZAX+3VCqmuvfSzjoyqCL96hIOVrcwfN9lyAxakMP9V5hakcvlesoqKIpiLaf4VkALhcKpkRuCICDUa2AccyKwcB0rn/s6Ln34XdDZB5EoFzCoMZzK+7R7315EkatethOkUmlX14ZcLgedrrtNk8lkQjgc7iu2sxWMzvAPn/4nLMT9KCRzUFkMeGXfi2IkibsUhxUSi8XS1f7rtCGXy+FyudiQlE6Y0D2OLcRgmiyjXiXQiLqgkQ4BUrDynGQyeWQi2mw2H2tHJ8sFvBD2okzXMERLoKmjq8TmNCOZk8kkCoXCGxZDzMSg/vKb3omnN5chHjTCOHk7pMEUyqXTCaZoB0ayxXcOohnt7OsYWRTXa3JkZAQ7Ozt9fd/RaLSn9ZNSqQRBEG0dTe63jiNrPgPlqAMaqQyzetuh72wTmtMe263D4XD42DEw4T9ra2u8Plersw5XtIsq5joj0IxCodBxyFWv1yMYDPKu+jbjoaEpHEQjeEobh1BA4P6p8/jx0asIB/ePuU+cFBRFoVQqsV3aH1bwJrRf+tKXkEgk8JnPfAZ/+7d/i9/6rd/Cww8/jI9+9KN4xzvecaql6Mcffxzvfe97WRPh//Af/gMefPBBzM/PQyKRIBwOQywWH7tJms1mhMPhjq/7u7/7u/id3/mdUztOvvBkY2gAaDSAvUU37HdeQLZWhj+fxKT29ehW5sbClVwwEbmLy0sIGyVYi+2jfBCHdXoMQ4pDW6SdnR1oNBrOpC4Wix1bYBiLKi6aRJlaCY1jCHWqge1nXoVEJkUpk0M8FgNt6OwAwAe9Im/j8ThrcdaPTvc0YwUpigIVSSO+7YdULscDv/YzKESTqFdryO6FcW0vCplMBoPBAKPReGrV2m6Etlkv205TyQfd2qa5XK6nbsxisWBtbe1UCC1wSLIzJgWktBYb33kehFiMsftug2ewjp+/94k3jMS2wmg0olAowOPxdBwEikajmLbdjVHroZ79ev76MSLRHNOcTqcRiUTg8Xggl8thtVpRl4nxX5e+jTJVA1WjEN/24d88/r6ex8esPSc5/6rVKrxeb9ekrNMCTdNYW1uDTCbD+fPnsbCwgB+57X527SzqilhbW8OlS5duyG/u9/sxNDR0oteOlXL43N4S/iKxigG9AY9qXFAVKF4bcKbS2Y+WNhwOHyNy7TA2Nga3232stZ3NZjFmsmHadnxIsTmoplle0O4YmgeGGej1eqRSKQQCATgcDk6fp59B2E5RxVxnBJpRKBS6bqAmJibafo9cQQgEOE9o8d63/TSkUinrbuByuTA0NASPx8PKGU+6kdvf38fg4OCJNdo3Gn1dfQaDAb/4i7+IxcVFvPbaaxgbG8MHP/hBDA4O4uMf//iJS+kM3v/+9+OJJ57AzMwM3va2t+Fb3/oWtra28I1vfKPr8xqNRkfrCgD49V//dWQyGfa/vb29UzleriAJAoyaUayQIbW7f+j91qL57SdJSq1W4+V6Ap/+3tfhDu7AW8vgt5//Ep586TlEIhGcP3+eV1s7lUod22UODg523TAwqFarqAVjqB4kMDBmx5UPvhOWsxMw2CwwNSRYWFiA2+1mvTz7RSdtJkVRcLvdiMViuHjxYl9k9rQCG5gFfXFxEbfbx/DWu+6HUERCbTXBOOrAg2oHbr9wCVeuXIHT6USlUoHb7ca1a9ewubmJeDx+ou+o0+JerVaxsLAAjUZzKlGkTGxlO3AhSGKxGDRNn1qFEABkpAh0tQatfQjWs5No0DRUcuVNI7MMmm272iEQCBxp8Y2OjrZt9zLQarWYnJzE1atX4XQ6kUql8Kff+iL2t3aQT6UR8exAax/ElwPLPfXUKpXqxJ0rt9vd1krttL935hw2mUwYHR1FOp0+MngKHG72BwcHT+3e1Pr+iUTiRJuwGl3HJ1a/h7QUyCZSCOwF8CcvfxMD48O8NxVMlZYPmEomF7ImlUqh0WgQjUaP/D0T+tIKRl4gk8mOyAvaHQNBEB2PYXR0FPF4/IZ1VBl3mU5+wEaj8dhn7oVu57pUKoVOp+N0L22HcrnMJs218h2mYzsyMoKNjY2+JBvNiEajsFgsnLqhNxMnWlkODg7w5JNP4sknn4RQKMRb3vIWXL9+HWfOnMEnPvGJ0zpGFlarFU6nk12UmNSsVCp15HHRaLRrxU4ikbBeia2eiW8EzumHIBdJIABgGLZDKBJBHspiSHr0OPpp/WWrZazXUpAbdNh68jkkQxFkYwkkdCJMT0/zHp4Cjl+UzEXUaWFhyNvy8jLGHMP4r+/5KIZ0AyAIIfRiOX71yuO4fPYcrly5gpGRERQKBSwsLGBlZYU3ue1UPY1Go1hcXMTg4CCmp6f7rjSdZCCMOb5AIMB2Fa5evQqr1Yq7STP+w5vfj389fS9+94H34b13PoilpSVQFAWlUgmn04kLFy7gypUrsFqtyOVyWFpawrVr1+DxeJBMJk+sNT2JXrYTmEpKK/hU+xjZwWmApmlMFcWgqjWYxp0YvnMWOpcNs9DA7Xb3PQV9WpienmZbj81gBjCar1epVAqVSoV4PN7zdZVKJUZHRzEwOQLVoBFxTwDhpQ2QcimqdB01ut71+RqNBplMpr8PhcPWv8FgaLu29tsKbodsNsuew4wUbXd3ty0pGRwcBEVRvElJL3g8HoyMnCydK1hIIVEpgFTIcP2fn0YxnYNh1Al3+oD3azVXabmCrw+6y+U6MkvB6G+bf+9yuYylpSWkUilcvHix5xpzcHDQ8xj46mn5bJ56RRX3mhFoBtf1zuVyYW9vr6+13O/39+ySKpVKXLp0CTqdDouLiwgEArzfJ5lMsi5MuVzuX1aFtlar4Utf+hLe+ta3wul04gtf+AI+/vGP4+DgAJ/61Kfw5JNP4u/+7u/wH//jfzz1g00kEqylEQB2+Oipp55iH3NwcAC324277rrr1N//tKAgxfjQ+O1wqYwYGRjCA45J/PuH34PlpeUjCz1JkrzJ3UH4AImdPaQDB0js7KOaKUA9aIZAzF8KkkwmYTC013QO2obw7eXX8PT+BrYyr98gwuEw5ufnIRKJcPXqVej1ejhVevzOlbfit257K/6f2ccwpnl9eprRE165cgUTExNHyG04HO75+Vt9dpkJ/UQigcuXL/My6m+HTCbTlw6JyYafn58HQRC4fPkyu6BXq1Xk83lcHB7HJaMdZpkaWq0WY2NjLKlthlqthsvlwqVLl3Dp0iUYDAYkEgksLCxgYWEBPp+vZ9Wiup9FeSeJWuTwJhcMBrGzs4PZ2dlT3dA1u3c0I5/Pc97ZWyyWUyEd1WoVS0tLuHvkDH7zze/DWeMQrgw48fFLj+D99z8Cm80Gt9sNr9d74s1Bv2BcSjY3N1GtVlGna6jUcx1TAEdHR+Hz+Ti//phmAKRUCqlKhslH7kZqew82hRbiHkNZJxkMSyaTyGQyHeUlIpHoVDYS4XAYW1tbR87hbDYLkiQ7DrxNT0/D7/ef2kYmn8+jVqudeJ0hBUIU4imEVzdBysSoFUvIhCIguBmTHAPfKi1fuzwm4W5vbw+FWhV7oX32+Yx7gdvtxtjYWNsqfTvEYrGex9Csp+UCxlO5F5io4m5yBj4bMa6dvebQCj6gaRrZbJbzeWcymVh999zcHKdNMYNgMMhey3wkkDcDvMtWVqsVNE3jx37sx/Daa6+1HWp49NFHOZGAfD5/pIXm8/mwtLTE6sJ++7d/G+95z3tgtVqxu7uL3/iN34DRaMS73vUuAIdVhI9+9KP45V/+ZRgMBuj1evzKr/wKzp07h4cffpjvR3tDoZUqcJd5BOfPnz9shw2YoZTIsLy8jLNnD7Oiyw0K8UIWGo2mo4SiXC6zkZcAoNFqMe5wYtPjwex7H4fSYkTc68fgEH8dWywWa3tTqjdofDqwgGc3XoGRckBAknhY74KrJOpqw9UcrtAOUqm0YzyoxWKByWRiX7eeryD73R0Et3YBtQSUeRjx6qF8hE9kbi+USiXe+qNgMIiDgwOYzea234XP52tb0dFqtRgZGcHS0lJHrR9BEEd0k4wn4cHBAba2tkCSJPvvzE46+10vigsHyAcDiHnF2LdVob5iP7FethMMBgOSyeSRm1Mmk+FMaEmSBEEQffv/Aodry/r6OptuRkaj+OilB4+cz1qtFleuXGE3YVar9ab4V4vFYkxNTeHLz/0B6kPzqJQpFEIKjE7/PoCj5x7z+4bDYU4VtYeGJuHe2UJWo4bcqIdeosD9jd7Sm36rqFx0s6dRofV6vSiVSseuk93d3bYWiAwIgsD09DTcbvep6Gn7CVFoRTKZRNjrhU2iQkWZx9hDd0GmUEBCiiAMJBEWc/utm8FHS5vNZlkfWz6QDejwf3/xk2g4B5DaDuDHH3gMspgMu7u7GBoa4hXlm8/nIZVKOR0D0wXy+/09NfkSiQTVarWnp7LX6+UUHavRaDhFdPORqjGhFXzCTMLhMG9bPcZpZ3BwEF6vF8FgEGNjY13PD8Z1RiqVnuosyY0Cb0L7iU98Au9973u7fvE6nY7TjuPatWt405vexP75l37plwAAH/rQh/Bnf/ZnWF1dxac//Wmk02lYrVa86U1vwj/8wz8cuTF+4hOfAEmSeN/73scGK/zt3/7tD7UHLYNGo3FkcVer1Th37hwWlpcwhxReC26DEApxxjmC/+vs/VD/INaQGf5g2pJGo5HNkadpGm8OhyA/I4V7Zwt6lQYfu/Iw9Oka3G43pqamOLd+O1m4zMX8WEuHIdNrkDmIoV6j8A87e/if7/gobNrON0tGVM8FzfGgDGlfWloCQRAY0BlAfHMfggKFTCwJbUGFZ//7F2B9/6VTTQHiewEzIRHMbrjdc6vVKnK5XEe9KmOczeTRcwk0MBqNrD64Wq2yiTKlUgmNeBnk81Ho5BrUqCpW97dgzQ9g5JEbR9wMBgP8fv+RBbfX4F4rLBYLDg4OeJuPA4dyk0AgcMTrNZFIdLScYTZLfr8f165dw8jIyIkrbnyRaCwhJX8R2e0KQAB6E/Ds/n/DW4b/4Nhm1uVysX7Gvc4PoYDAvbJBfOQdD6PaqMMoVSKw64fX6+1JOBjdNZ9rwO1299Ton8TwnqZpuN1uqFSqY8NDTIu91wZUqVTCYrHA6/X2TObqhng8DolE0vfADePFLZPJMDs7i9HyBP7y2W+gYlSAjmfxsw+/AwMSJUs+JiYmeHVTuDoe7O/v83YqajQa+LP151FRS1HY3QdF1fDZZ76N6sRV/Midb+It8To4OOAlexodHeXkT8uca90ewyeqeGBgAJFIpOf6UCgUeEWxT0xMYGtri7OLQygU6uqQ0g0kSWJycpJ1nBCJRBgfH29bPNjb22N/l3w+/0PtcAD0QWg/+MEPntqbP/DAA12HE77zne/0fA2pVIo//uM/xh//8R+f2nG90ZDJZKxZtVQqRVAnxHPPzkMgFkGilGM3HcMfvvB1vMM4iWq1Co1G0zHycm1tDWdGxvCg5R64tYctH6lUClhf92Blqlbd0C0yN1EuAI0GqpUKNr/2LM6//zEoDDoUBd3btiKRqC9hulQqPRIPGpjbxM7GGggB8PWl7+OBqdtwZmgcNnLgVHeQXFPW+NigdarONoMhp1xJbTMYGyqmopN8xQc/otiK+PBH3/8MPv7whyEkhKjFCxANnHzYrR2YGNtm8I1SNZlMWFhY4E1oGdum1upbr2hkgiCOTQdPTEzcMJunVoQLq9Aa5IjtFbB2LYq3/tQkstUgyvUMZKT22LGazWYEg8GeE9+hUAhGoxE66eu/tcvlwvXr14/F8LaCGQzj2u1gdLO9Hi8Wi/uSM5TLZbjdbtaOrRU7OzuctayM3CQej/edUOjz+TA7O8v7eeVymU1WnJqaYs+x0NYWfvb+t0KtVuPatWswyw7X6PHxcfY5AF5f03uAS5WWpmk2DY8PClQVoWIGYo0CS//4DRgmxuC6/RxKJmVf8wrpdJr35mJmZgbLy8tdXSCY+Ntu4FNl12q1XQczGfCNYler1RAKhW3t0FrBFLJO6oAjl8tx4cIFJJNJLC8vw2g0wul0Ilsr4xsBN5KVIsreffziW98PgJ9s7Gbhh7t+/C8cTAVEp9MdEZvvFJPQTwwj7d/H7gvziO/sYTsdxcTEBK5cudKxpe71eqFQKFgyIxAIjmgDjUYjZmdnsbOz07OC3s6ui4GiTCO64YVEJsPVn3oXCtEE6EoFZln3k51PhbYTxGIx7IM2OPVWFMplHGTjEJNi+GJBuLfWEQqFTk0f1ytQIRqN4tq1a8jlcrh48WJPL1OmOsul+mc0GmGz2bCysnIifafCqsOAUo96o4GP3fejGBmwIVsuYGVvE0tLSwgGg6c2oNMMZpMGoK/jJwgCUqn0GDHuBKZyBxymcTX/DtVqlfPiz0wHj42Nncp0MFeIhXLk04fV2dm7LNhxp5DP1iAi2m8qbTYbIpFIz++2U/LT2bNnEY/Hu2rp+DgdpNPprrrZZjABGnyQzWaxurqKqamptmS2WCyCpmleJGJqago+n6+v8z8YDMJkMvEest3c3MTa2hocDgcrN2OOn6IottDQOhAslUoxMzMDh8PBS/fdS0vbL6EX1Glk9g4Q9+zCcddlDEzYIVbKISP7m9XoR8fPBPkw132nx3QLV0in0xAKhbzOGy663H7a8+Pj45xcOE474ECv1+Pq1asQiUR4/pWX8Bvf/TxeCHvx2s46Fssx/Mn1Z0E3Gsjlcm/4AD1f3CK0PwTQ6/VHCK1KJIWQIGCYcmHotnMwTgzDMjTYdVfOELlmHVA7qyaxWMxW/RYWFjpemIlE4hjxYjK3LbQY777vESiMOpBSKYyjTtxV10FY7T45LRaLUavVuj6mF8rlMjZTfhzUUnAarfjx298Gs8aIC6NnMX3PLGiaxtbWFq5duwa3241gMNg3we00EBaPx3Ht2jVkMhlcuHABo6OjnAgTl+psM0wmEywWy4lIrdihgU+bxZB6ACqpHGqpEufefifueORe1nNybW0N165dg9frPTVLHKPRyCbrFIvFvqzPGNlBL5TLZda2qZ0OjovmrRXMdLDBYGCng/sl5lyepyjMIhWuwXXGgOEzBgxP6aAp3AbP5k5bQk0QBIaGhjqm9gGvk65ON9bz589jd3e342/OdTCsWq3C4/G09Q9th14koxWhUIgd/upEPPhUZxkwrdduhKgdKIrCwcEBZ1LRbNlnMBhw6dKlY8SgNWqV0Wq2Qq1W48qVK1AoFJifn0cwGOz63r0cD0KhEK/WeLVaxebmJtbd1/HYxCWYpsdgm51CLV8E2WjgwUH+1n+hUKjvcCatVguNRtPxOuiVFra9vc27MtzLvqtfralYLIbJZOr6mzIBBzeCWNpsNtQdRiTTKRysebC/uAaZUY+NTATBQop31flm4MblD94CJzCVqOYqwROOGaylDkBQDUh1hyfuu1wXOr5GOp1GOBzmpalxOp0wGAxYXV2F0+k8UvWgaRo0TbMkrZ0p9hSAB+1TSFWKGJRrIIcQq6urXbPGT5JAxBxDKpXCxMQEzvzyJK79zVOYUI7igErh/I+eg8ishAo6to1aLpcRj8exvb3Ntry1Wi2MRmPXzUG+VsFuLoGddBTnRK9rmtLpNLa3t6FSqXD+/Hle1Zle2tlOYKrtbrcbMzMzvBfKjY0NDL/1IlQlErW1LRhun4XIelhJF4vFsNlssNls7HAZkzoll8sxMDAAo9HY1+JsNBrhdrsPW1gcpRvtXsPn83XVemazWWxubnY97xKJRF9aXOYYjEYja73Weq30Ahcd6vr6OghCjo89/klspr6Bar0As2IGIzNvQiKRwOLiYtv3HRwcxNzcHOx2+7ENFU3TODg46JpcxTgsLC8vH9EbM5DL5V2T3xisra3x8rbuNRzaDI/Hg2q12nWAq1wuH6lu8oFarYbRaOSkKWbg8/lgt3MLhWF09VarFVevXm37GIZsNp+/Op0OkUik47nGR/fdSUvbPPDTC+VyGT6fD4VCAcPDw5icnMTlRgMTUR/WU2GUCQ1u09lh6tGlawUTdXsSouRyubC0tASNRnOsANGtGxAKhfqKKjaZTKz0pR1O4l1ut9sxPz8Pi8XS9noKhUKnZrHYimw2i4DfD6pUQTlbQHzdi/EH7wQAVOrUv8yhsFu4MWC0PlKpFMMqA37j4mP4XPZbMDsduGodxbSu/ZRrsViEx+PBxYsX2/rFdoNSqcTly5exubmJWCwG8ZARf++dRzByAKNADGdpCo1cEX6/H3a7/diCP6TQYkihZf88OzuL5eXljhrdfqebw+Ewa9rdfAzkfYOYvnIFpYUFCAzHF2WpVMoSNuA4wRWLxawjANP68+Xi+MPV7yNXKiET2IdHC3zIfhEh/x6bQtTP5D3f6mwzLBYL21LnE/0YCARYW5h0Og2t0MaS2Va0DpcVi0VEIhG2WmA0GmEymTjrYJnNC03TyOVyvKpAzZDL5R2Tx0KhEEKhUM9Y0F759FzQOh3cLe2oGd0qtEzwByMvAYAr5o8eeYzRaIRer4fH40EoFMLU1NSR34BJUWytMoVCIU5DY50is7nC5/NBp9Px1mD2qlrTNI2VlRXodLqeFTSfz4fh4WFe798Mh8OBlZUVTpX8crmMTCbT85iYdEIuuvqdnZ1jzgxqtbqnVpOr7ps5T5k5DQZcnDLK5TK8Xi8qlQqGh4ePfD8CgQB3mUdwl/lwXZubm+NNerjE7XLBmTNnOupp251rNE1jf3+/r6ji5rWt3Wc9CaFlflOv19u2+BGJRE4Ur9wM5n6YTCZRrVahUCgwa3Xh5WoU9ToF1/23gYAACpEYVokKhVNKrbyR+OE/wn+haL3ItNrDaFpm9zWk0OJNpnFcOdM5Fo+iKFy/fh1nz57tWB3pdeNgbGzW/Dv4jS/8FVQ2M/LJFMpKOX71C3+OX7ntLZydA8RiMUtq2+l8SZJEvd5dltCMbDaLra0t6HS6Y8fQPGTEtIB67VzbEVwmDpghuH/hn0NJSqBaKgMCAV6bn4c0ksO/vv8JXkNNzei3OtuMwcFBltRyae0yCxVTta9Wq7xiqRl/YJfLBYqiEI/HsbW1hUqlArVaDbPZ3JPE6HQ6pNPpE7WqhoaGcHBwcIzQcqncATiR9VcrmqeDt7e3IRQKO04HM+hEaMvlMlZXVzE6OtqTRBEEgcnJSVZHajab2eqQyWRCIBA48jm5VGebIZfLMT4+jpWVlWPfp0Kh6DhUxOhm+5227gTmu+ESVV2tVlEqlU5s03fmzBksLi5CqVR2/T17DRBls1lsb28fkgMOG4RsNguCII6RUOY34EIQmU1JPp/HxsYGFArFMRkUU6VtXjui0WhH675isYidnUO5y/DwMKfvl+ugYjO4xu32QrOelsv5eNKoYmbupd35WSgUTkTSjUYjgsHgseuuOeCgHzAOOIlEgh361uv1mJqaOnKevj2XxD8Zc0glkhiQKfEz0/eAKldOJTHzRuMWob3JYG52er0eOzs7nNsJTAVjfHy84yQ2nxM/TNagGbEjubuH6195GlOP3wfjuBMii573lP3FixextLSEsbGxIwsh11ZjtVrF1tYWgMNJ1nZEMhqNsouJyWTC1tYW71aMVCrF4OAg+7xcsYC093mUQ3nM/90/wzjmxJkn7oNwyNA3mQVOVp1tBiMNYDYxnZDP5+Hz+Y4QmpMQO8YHmKnmpNNpxGIxbG9vQywWs9Xb1k1VgqTwpbmnUS2WYBgfhlPF3wpLrlLiOy88iWtEBla5BncPuLC+tga9Xs9J+xaPx0/dgksul+P8+fNIp9NYWVmBwWCA0+lse50IhcJjhDadTsPj8bB+01yhVqtx9epV+Hw+XLt2DVNTU1AqlRgZGYHX68X09DSAw+qs2Wzmdd1qtVp24Ki5C8AMhrUSWkY3281vth/w/W5OWp1l0Kyn7UTyGK1xu25BswvBmTNnOK8XOzs7HQkyX5cJRvfNuNk0b3yUSiVommartJ18X/P5PDtENjw8zEvGYbPZMD8/z5nQMpKH09pwMnra1lCSVtkPE1V85UrnYlEvmM1m7O3tdSS0XDxtu4Gx8Wom54xvLFcwMrJEIoFcLsd6WLtcro7XFkVRMFWF+Mt3fgxz89dw+5XbABx2+37YHQ6AW4T2hwZyufzI8BIX3Z3FYum52HEdZBEKCAjFJGQaFYRiEWrlClK7IWxIViG2F1l9EpebJEmSuHDhApaWlo5pu7odD5OlnUgkjpHhVsTjcfbGy+ikTqrxUcrksFgtiAoiGL7rIpRGPUrxDLJ0EFFTlLeRNXA61dlmOBwOBAKBjqS2Wq1ifX0d586dO/Jd1Gq1U7Og0mq17G/DeAQzg2sGgwEDAwNYK8bxycA8wtubkKgU+G/L38Evn3voSEpcL9RpGp9Y/R4WMntQbGcgIIX4Rvx7+PVH3gdjhwS7ViSTyVPZTLQDE8wQCoUwPz+PoaGhY5uq1gptKBRCOBzuajXUCy6XC1arFWtra1CpVBgdHcXi8gZ84U1ASKKU9uFdb32Q9+uaTCb2/GHIsVarPeJFyYCvbrYVjPyomczw/W5O+9pSq9UwGAwdU9q2traOdUcoioLX60WhUMDY2BgvAphOpyESiTpelzqdDqlUinf1mZGpBINBzM3NsZXu4eFhzK+5IXdaENvdw5WR17+3bDaLnZ0dEASBkZGRvjoqjGyJq86TazgIHzB62mb7K+ZcYzYZpxFVrFQqOw7a8Yn57gS5XA6ZTIZoNMpelzRN91zD0+k0EokEUqkUCIKATqeD1WrlfI14PB7WrUcoeP3+kcvl+p5DeCNxi9DeZDSTjuZFvlwuQyKRtH2Oz+djq4tcX7sXLhht+MLmqyincph6y/0QSySwaPV49I57kc/mkEgksLu7C5qmoVKpoNPpoNfrO164zaSWpumercNmnWyvnXPr0BpwaObPN76xFQKBAO8dnMHvuTegGTqscI1OTeBnzj2MTCTGes22G8LphNOqzjbD4XDA7/djfX0dUxPjwIEXoOugTcNYca9hcnLyWIXoNFvvzWj2CKZpGvF4HH6/H3/62jdRFAGZcAJKkRDqcgX/tLWAXzj3QNfXaz5nl+J72EqEIVYqEFrehEyvBlw2JIUUuBoNlcvlG+4lOzg4CIvFwlZOx8bGoNFo0HC/gPr3v46a0YDGXW/Bdk0CiqJ4ewu3g1QqxaVLlxAKhfDkd1/AyysZlMoBSOVKNBrAyGYMF6e5B1kwsNls8Hg8LKmTy+UoFApHHuPz+doO4PABRQDxfAZWnRECgQCbm5ugaZpXep3f7z+V6mwznE7nMUIEHHaENBoNe10xm+94PA6Xy9UXqd7Z2enabtfr9QiFQrxfFzieChUIBFAxyPFHK9+DOmVC0hfEhrSCDwhmEQzsgSTJU/FdttvtWFxc5ERou0keToKZmRksLi6ykg8mXEEqlZ5aVDFwSDpbdcmnOTjlcA3jD77+eaSsShQP4nhkfBYXWh6Tz+dZAktRFFQqFQwGQ08LyXbI5/OoVCpt79WnMYfwRuAWof0hAqOjtVgsxy4UBtFoFIVCgbNFDtcKrYqU4O0iO65fGIDH58W58WlcITSIhg/zrZmTnDHiTqVScLvdoCgKMpkMGo3myHAVcEhqL126xJLavJTAy5EdlMM6XB1wQiIkWc2ZSqXirNVNJpMwtFTozGYzdnZ2TkRoaZoGEcniv7/zo3h6/mVYLBZMKAdgVKphVKrhcrnYxDKGyHWryJx2BakZTqcTO2urWP8fv4BJ0aEtzUq6BvsH/l3bY6pUKjc8g5sgCJhMJphMJmgzaygF9pDy+UGVy5BJpdhLlbEt621KzmAjHkAmsI9quYL1bz2Du372J0BKpchT3Cyf+IY5nAQEQWB0dJSVy+x+83MYD7wKMlsElQ5iYf4lGN/1cxi/55FTfd/BwUG8sJRArrCLUGAHYqkc5y8/gJcWQ30RWgCsFrFdpe2kulmKruPTW6/iqeuvQeyXY9w8hAcaRjjMVl7aS4qi+jLj5wKGEE2eO4uDcg4SQojI7i4u/4B8MdHWQ0NDHZ0LeiGZTEImk3U9P0/iCtP8GpOTk8jkc/jYF/4MtVoF4evbEMmkeP61l6EcKeIDdz58atcJSZLQarVsZbETisUixGLxDZmaJ0kS4+PjWFtbw4ULF44k051GVDGDgYGBY/Hw3QKJ+OJL/mWsN7KoB1IoZ7L41sAO9EEdxggVkskkyuUyZDIZDAYDZmZmTlwV3trawtTU1Kkc+83CLUL7QwS9Xo+9vT2W0LZeGNlsFoFAgPOuls9i4fP5cGZ4FI/YbPAZfVCpVKz1UnOiEEEQUKvVUKvV7IVcLBaPDFeRJAmdTsfGEl64cAF/892v45lCEMVYCm41hW/tLOPdyhGIQPDSnAGHk56t7Q+uFkPdsLa2BpfLBalUinsdU5icnMT8/DzwA2MFgiBYLWk+n2fjZZkKHUEQaFSKaLzyNTQSIXhzNFwP/8iJjqkbnHtz8Gbi8DRoEAIBVAQB48LXgInjmx2Kom44oWVQLpehCGchqDcw8+5HgUYDKpMBD9rOYMbFbSMGAPqCDS8JM4hueDH7/regASDt3cPQxc5hF82Ix+MnHhbiC7FYjJmZGaSe/F9Yi2bwqjcMmZjAHS4LyPUXERqZAU3TqNfrbKeBmZimaRqNRuPIn3uBIAj4d/0gBCRAA/u76zAYD9u4i4uHrVGZTAalUgm5XM75HDhz5gyWlpZAikXYzMdwsDWPccMgcjvBvtKxGHxz7zpei+2CIIWo5PJY2F8AeeY8fs1xO6/XYZxXbgRIkoTYosPP/cOfQDEyhNxBDFMGKxxJJ4L+ACfngl7gEkkLHE2RPAlqpADKYQtqgQO89tdfxMh9t2Pk7ouQ2rg7l3CF0+nEyspKV0K7v79/w+yngMPikE6nOwzOIAF/7ACVRv1EUcWtMBqNWFpaOnIvOonDQSteifqgMBmw+PlvQqFXQyAg8LVoAb94++Oc0+K4IhwOQ6VStf1ublR370bgFqG9yWi+aSmVSra91zq5Wy6Xsbm5idnZWV4LKZebYjabRS6XYy2xFAoFm9A0MzODlZUVEATRcQGSy+WQy+Us6a1Wq0in0zg4OMDW1hbqjQaejnuRi8ZRq1ZBBsOI50vw3G7Gj56/m/NnYVAsFtu2P5gKdz/tpEAgAIlEwjomKBQKlry3e02lUomzZ8+Coijs7+9jfn4eGqUCQy9/DtJMBNVaFbmDDCboBBof+C0IRO3lI+1AURT7X7VaPfLner3O/l117jVQ5Sq+69kDKSDw8QfOA/H2ptwnSRvjimYN9C+86Z34zN4iVvZ2UM0XcWXAibc6z/F6vUGFFo9Ih/AVfQLFfAG6ASPeZ59FYH0LMg7xzclk8tSqMVyQz+eRTqeRy+WQO4gDDRorkQSG1HIICQFq5RLE+AFh+kF1iiRJEATB/tf6Zy6oiwfx/HwQepMNmUQEFpsLdrMK586NIp/Po1gsIhaLoVQqsbZ5YrEYMpmsI9klCALTM2fxq//454g0KpClFSgk0vjAHQ/hKk//5eb/Xl5bQToTQ2R9G9n9CC68/y0ICvgFn1AUhWQyydk3li8ajQb+PuQGLRUhEzxAPprEci6PrxIyfPTex09cCYvH41CpVJxIAhOwcBISlkwmEdgLIL0ThESrwv0f/wjoBlAtlpHc8GGT1sBqtZ6aWb9YLIZCoega43qjquvNcDqd+MNv/SNeyYVA1+qgiyX8+7f9xKm9PnN9NmtmC4UCdDrdiV+bpmkUokmkYzEQAAgxCcPEMOyGoa5x1f2+197eXkdXlH59xG8GbhHaHzIwbaZSqcQuYhRFsaEFfHZKXG6INE2zRJmBXC5HIpFg/zwzMwO3281WKHuBSTxhduixYg7i6CLkDRrX/uZLGHvgDrjuvYyajP/pl8/nOy7uZrMZ+/v7vAltNptFPB5nK9+5XI5dlJxOJ7a2tjq+JkmScDqdcDqdiC08j43rh6lD/ngWZwZ1CPt9oF9+CrTzHEtQ6/U6S1CBo4NDDKkRCoUgSZL9TygUQiqVHvk7wdQ0ku4MHhobQr0BQCAAVNyGpU4byWQSXq8XVquV1UD/kvYhROwXEQkdYHaKe2WWQT6fx7BQib9658ewtH4dDrMVloHDAQnGv7Vbm7p5EOQ0wchustksMpkM2xlQKBTQaDSw2+2QPfQ4sovP4q0zw5gd1OMgW8LMpbuhvAFVqctnzMjmK5i/vg+arsNiVODx+0bY9m87UkFRVE+yu5Q7QEYlQt6zj3w4BrXdgm8crOM2swsSEKhWq6jVaiiXy6jVauzgCgPmXBaJRBCLxRCJRFDL5RBXJZBq1JBrdShnCzCojh9fNzBa+xuFcr2GWD4LASnEq//r8zCM2+G66zLSqLHrD9+KVaOUR8MzD1BV+FIUZu99iNPzGPcbviSmXC5jf3+ftXqaGp/Ar1q1+JvNl1EullCIJXBpZhYfO/cgirk8G6ii1WphtVpPrJd0uVzY2NhoK01Jp9NvSITqWuoAbmkZhZ0UqoUS9MND+JvtVzGht0ItPp11gZndYO6LhULhRJ2DarUKv9+PdDqN2wYcWNCrIBAQkOk1yAYjuPfs/ady3M3oFRSSy+VuEdpb6I5OFTPG36551+d2uzE6OtrXItOrMre5uQmn03lkgW5t3xMEcaRSy1enqpcqYNDrkSYIXPrAOyBVKxHd8EJv4e8/GIvFOnr8qdVqbG5u8no9Jl+9mdA3L0pSqRQ0TXNquxhVcuiHDChXKXx23gOLVg4pSYKsU1AoFEfIKPPfSZC49BhC86/gwpABnlgWyXIdxjf/5Ileky+aLdZafTcFAgH0ChXijd7xta2gaRobGxuYmZmBWEjCph8AVXmdcF26dAlerxcrKys4c+bMse+yWCyeCpllyCtTeS2VSiAIAgqFAiqVqqMFTuOhD2BnexdWTR5alQoD978LbpEFE12qVv2CIAR46A4n7rk0iKUlMW6/bbrnc7qR3Wq1imKxiFTMi3qxhHKxhK1vfB93/MyPIVONwmsMwKkbgEgkgkKhYNOWuGgif1Qnx6996ZOwTI1AqlIitr2Lu0a4a32ZwcN+tavdkM1mEYvFkEwmUdyPQKiSY/Lx+6AeHIBCr4VWquhI/hUKBeRyOZRK5bFzsZFLgf7cfwYKaUTzJagqdYhGbICrd8ei1f2mG2iaRjQaRSgUYjtqzVXs2+TDsCl02MnFEXBv4H3nHwJJCCFuOg+SyST8fj+KxSL0ej2sVmtf1WFm890uFGV/f/+GyUWasZUIo5orQkAIsPL5r+P+X/sZlMtlhIuZUyO0AwMD2NnZYQltv+15Rk5YrVbhcDgwPj6OSw0a/7Qxh+9HMhgaGcVYjoCV4u4lzgXlchmpVKprt6NQKPQdjPNG4xah/SGDTqc7kl+/vr7O2rDwhUAg6Prv8XgcNE0fI6jtzOCZmMylpSUA4EVqhQSBj03fi9/+yqegGRoAKZXijuEpmHN1+P1+XnYgqVSq6+OVSmXHZKl2cLvdx8zxWxelwcFB7O3t9W5xDo4BIimoSg4fuTqBMt2ASi6D/tI9EGi4zuVzQzqdhi+Zw4Vf/1MId1cwXCxhsybBwOBxn8IbFVkYCAQQiUTahmgwIEmyr3Q4n88Hi8XCktLWrgEAjI6Osp6brel0/fjP0jSNbDbL/lcul1nyqtFouvo3tiJXqkDywPvRuL8B8dgYZDIZLlEUlpaW4HA4TjS82AkSsQjCU/iZGXI6OzaJlzNB6KwmXP2p98I4MQwRIcTVmVnIyP5urKJMGT9/8SHsKwGKpnFx5n7U9+JHdPrdEAwGT+3mypDjaDTKTnGbzWa4XC78knMAf7n+AmQ6NahSBVajCT9+4X6oxMfdQ4rFIvL5PGKxGHZ3d9nOC9N6l819DbJkHEoRgb1UHrNWI+in/hbCn/l9TsdJkiRqtVrHYJRsNov9/X3W0H9mZqYjqRpUaDCo0GAhlAGB4/cHJjmR8TDd3t5GtVrFwMAArFYrL7I2PDx8TCvMeOHeiAptPp9HMplkr910JoxauYJGncbZ9z0GgiSR2Y9gR7KGujGJgYEB6PX8fNZbcdLZjWg0ikAgAJlMhuHh4SNFK6GAwO0KK+697z1sWuTCwgKUSuWpOQ5sbW31lGW9kcO1J8UtQnuT0Xwx1Rs0noxv4x+f/SZIsRh3lyJ4k3HkRJqZThXaarUKn8/HyxidIAjWiovxHOSKQVKBXzj3JuhGHZCTYtgUWggEAvj9fiwsLHAaDGtu0XeC2WxGJBLhtGBytR9iMtN7EVqBQgPiPR9H4tO/B6OyBr3RgmXHnZAIpThNw5N8Ps+a2pMkCZy/H3IAgqWltovPaYv6mQQ3g8HQczimW/Rrt9dv1nQDhxWfdjcOo9EItVrNShB2RRU8vb+B/c0dPHr1LrynYTnip8iAIa+ZTAa5XI4lryqVCiqV6sRDF4xh/vb2NktEGNcPt9uNcrnMa6r/ZuCswgRHQYDgiAOpnQBIAYGfnrq7bzKbz+cRDodxb6stn24QbvehVKfbWkfT9ImjPxnfZGYzbzAYMDIycmyjctU0DEmZwrxwAIJaHW+buusYmQVeJ/+dKt35fB65dAzpdB7uSBK78RwEAgKKRAaqvQA0Gi2USmXHa2g7E8VfBl5DLvAynIM2/NTknXCpjKhWqzg4OEAsFoNMJoPdbudFEjUaDdLpdMdNX3MUNlP5XVtbYy0YLRZLzzWlNcwBONxo8rlvdAJN00in00ilUshkMqBpmt14MtfuLF3H5nf+Hj6ahsqkB0EK8f57HsZjo5fZavzu7i4bOMAn2rv1c2azWZAkycnhgJm7iEaj0Ov1XePUk8kka+3GdEpXV1dP5GPd/NpCofANkX+8UbhFaG8iBALBkZv91/2reGp/A+VaFXSpjGe2VzBoG0K/wYDdiMbGxkZXY3SZTNaWHDGkdmFhAQRBcK6C7ezsYGZy+tjO0ul0wmAwYHV1ta0xfTPi8fgxu65W6PV6eL3enseTTCbb2g912o3q9fqeVjQAIBgcQ/axn4V9egoiiRTnfxDjee7cuVPZ5RaLRayvr2N2dvbYb2ez2bC3t3ds2IJv7G0nUBQFj8eDSqXSMcHtpGA03efOHW3HSqXSjq1XRoLwDy9/F1/YeA264SGkijl8N+IBQZJ4p+PcEfJarVZZ8qrRaGA2m0/1szA3N7lcDoqijlyHTKdjc3MTm5ubN8TS7TRQrVaxvraGf/f4jyLZqGJOvIB7L1zBgJKbw0QraJpmAz/agdHpA51JbT8JaMDryXaZTIZNtjt//nxPQqCoCfCOM1dBURSyiRQMai2v9xWLxdDr9dBOz6JRiqBE1fHElANiEYmi0oiCkMTBwQEKhQLrq61QKKBQKKBWq1EmGvhD9/dRIAWopIqIlfL43ef/GR82nYOUOEzv6xX93AlMaAOX9bvZ3YWiKESjUfa3slgsbVMCGYyMjMDn87EhMKFQqC9rKCamPJVKsbIfjUYDnU7X0XO1UizhXQOTqFy4A/vJOETpIt49cjgnwTj1AIfnemu098DAAOcgIca+S6VSda2cFotF+P1+FAoFDA4OcnLKaHWnkUqlGB0d5Rzx2wk0TcPr9fZ0LDlNG7I3ArcI7U1Ea/VqLuYHAGQPYsiFE7j0wbdjLubHu1wX+n6PdtWxUCgEmUzWtTLZHI/Y7ribK7W9KpyMY0Kni12pVOLy5cvweDwdNZHAIaHlElLQy+qmWq3C6/W2rU53sl2x2+1YW1vj1CqmKAoiyeH3JpVKMT09fSq76nK5zCaEtdvRG41G+Hy+YxKD06jQMsEXTqfzhrTLGXi9XgwNDfVFMANyGgqjDr4X51HNFkGQQnzJE8DYJQFbeR0aGrrhFjQ7OzvsTbuT3GNychJ+vx9utxtnzpy5IZKQfkFRFFZWVjA5OXlIsKBA2eKAiGr0/ZrNlnid0IvUHhwccKrOUhSFeDyOeDyOUqnEEhS+U/WZTIZNDAsEAn3HmQrufDsqextAMA6pmATkKqjf/W+gGTi6eWe6Bvl8Hnt7e3gl6MH+rgd0g8bWt5/H+MN3Q6bXAOe1uGQ7mXuHVqvF7u4u7+eRJMnGhVerVYTDYXa2giG3zeeyWq1GpVJBIp9FtUGDqlM9r23me2CqrxR1+BytVgun08mp3c5soM4zhQTrGObm5trK8MRi8ZEIdGYDtLOzA5Ik2WjvTuuGXq+Hz+dDA3VoNcc3CMlkEoFAgA274Kqh7+QuoNfrkclkOibaccHe3h7MZnPPtfB/J4cD4BahvalovYmJCCEAQKZRoEFTiG/uQGl39q2BbPccZvq1142h2bqrHZqTwHrF1O7s7PRM9CEIApOTk0gmk1hcXGTjGpvR7PzQDSaTCZFIpOPF7na7MTk52ZZcFgqFtoSWGXjppSfKZrPHnq9UKjE6OoqVlZW+U6Kq1SrrdNHtO2Bsx5rdKE5SoS0Wi9ja2oJCoejbe5Prc7LZLAqFQkfi0et1BBBAqlWDlEhQFRShcQxBLZefqJLBF0ycKRdC7nQ6EQ6HsbS0xKli+EaApmmsrKxgeHj4SCuS2ST2M9AWCoUgEok4tZo7kdpQKHSMLDWDcWtgdNadpAR80LzuMumN/Wy0BGIpDu78cdjOPwpCqwbMwxBIjle9mOIA8x0XjQq8JM4iseWD2mZFQwDQFAUxcfLzpB8pUCvEYjGbElgulxGJRLCwsACpVAqLxXJY/RUAr9bj+H//+fsgJSIYpEo4SpMwyV4nSYzNYyqVQi6XO9I94ZPK2Iz19XU4nc4jvxdTpOlFiJt/g2q1img0io2NDVSrVWg0GrZ6yyCYfwXPhH4XtUAJ02cm8SbVv4daZEM4HEYoFIJKpcLU1BTvcyeRSHTsSLpcLqysrPQl4WA+E5fBytOyIXujcPNX0P/D0Wi8XvV4eGgKn/a8ColGA5lOB8OoHXcqnJifn+cducqgddFaW1vD9PR0T3LQbginFQypbTeUw6BcLoOiKM46Hb1eD7VajY2NDcRiMYxohpB7yotUOA4KedRcZyAydjeuNhqNHSsqHo8HJpOp4/Hk8/mOLgo2mw1+v79rmziVSrVdhPR6ParVKtbW1jinvDFgKmbj4+M9F2O73Y6lpaUjhLZWq/FuG9E0DZ/Ph0wmg4mJiRMNITCDYd2qAe3s41rRHGHZDvdYRnFtfRUGlw0Glw2lRApvGeHnfXtS9IozbQUz+La4uHgqspSTVnrX1tZgsViO3STlcjlSqRTv18vn8wiFQrwiThlS68vG8Vz5AKlqCYLdKH7jnR888rh0Oo1IJIJsNguZTMZZSsAFrZUpZpPcb559IpnCyFV+4RHTWjPoQBQq8wDGBwygqxTsA2Y0wim4k+5jQ0R8oVAoOBE8LpBKpax9YbFYxMHBAXw+H1byEbxSDKFWLKGSy0E5qcP/vPZtfMx5O9LpNLsuaDSHXrjj4+MnPofD4XBbN56BgQEkEglen1csFsNms7GbK6Z6u729fVjkUOWxmP8DSDU04lslFKgIPvfCr+Ki8ucxZHXiwoULfZ+PvQagz5w5g8XFRSiVSl7rhsfj4ezhnMvl+j7nbwZuEdqbBJqmIRAIjrRA7raMQkQI8dm9FAiCwPvP3os7TIekjKnkqFSqYzvPTmjdhfv9fhgMBk4XNNfpTZIkMTs7i+XlZUxPH9fIer1e3nnrJEliZmYGBztBfP9/fAEj+iEkchmoZQqkPu+G8aOXQMg6VxwZ/8tWEhWNRlGpVLq2HrtVgRl9breKeSqV6uiRabFYUCqV4PF4OLc/mYrZyMgIp+oYSZJsZjnzWzCVBa5gPGWHhoZOxbxeJBL1JLQej6enHIDJTu907k+INHjMNAG/5nCCXhfO4zHLG6dRTafTkEgkvEmpVqtlZSntriE+IAjiiOUfH3g8HqhUqrY6drlcjlAoxOv1mnWzfEmKccSO//zFP4dQLgVBkqijik8sP42fHrqMVDLJntNms/mG6JBTqdSRypTJZMLCwkJfN/dkMsm7sk1RFNaWV/GbD70PLxdCCBXSqPoO8G/veScUIgmy2Sx2dnZA0zRGRkb6GuxhLCJPa2KegVwux+joKEZHR/HSte+g6E8gOL+KmDeIi+8jkZJJQI/cgYmJiVPX4ZfL5Y4hAXq9HisrKyciaM3V23K5jJc8n8b+dhb5fAkvfiMAtUECg1WB8fNmGGX9D30ySYHdrhuSJDE9PQ23281ZS53NZlGv1znPvvS7ltws/O9zpP9CUa/Xj/z5NtMwiInDnfwV0+sVRkaUn0wmsbGxAZIk4XA4ei5kDKHN5/NIJBKcKiV0g8Z39tfxjY0X8awojUdt0zij62yVIxaLj5BahUKBfK0Cgm6gUqn07bupzgsxrLFiObCBOZ8b/+qeHwFdqqEazEI63n04zGQyIRwOs5Pk5XIZfr//RBPSza/baXit1wLgcrmwvr6OQCDQc8qdIbM2m42XBZXD4cDe3h6mpw/9SLkGDFSrVWxsbEAoFJ7KFC0DsVjc1bornU6jUqn0JCYSiYT1x2wFo4v+wH2PssedzWbh9Wxzihg9DfCtzjZDqVSy19Do6GhfNn3A68EsfH87v98PmqY73uy7DeV1Qru2L1csJoLQuew42NjGzjMvY+S+Ow5juNUuXLwBRKgVqVTqiD1Yp00yFwSDQV6JddVqFcvLy6wd3ggOq4Nu0g1BrQ6IDrWp58+fR7FYhM/nQ6VSwfDwMK/zRqvVYmtr64a4bZTLZRwcHCAbCKNRB/SjThgmXVAM6KEZ0MMxOASijfvISeF2uzt2IJlr4rRsDKVSKYZsQ3CKtTjYFeDCA2YABCQyEiRxsvMznU5zavUrlUo4HA6sr6+zg3fdsLW1xblDyAwq/u+E/72O9l8YevnEtgPjE5jP57G7u8saMbfT0TAXba8J41Z80beI7+5vIlbIgEqHsZkO4+PnHsKktrMBulgsxrlz5/Ds3Ct4RhBHslFFJnCAt8/chouNRtfPWiwWUSwWUSgUUCwWUSqVDsMMdtOo5RKwqAdgVutxkIvBlwhCv0XDKhuB0WjseGMbGBjAN19+Dkm5AENyLfxrmzh79mzXhYwLERgaGsLS0lJbQttOP9sO09PTWFlZgVQq7TpgxQyh8R3CUqvV2NraYj9PrVbreRPm4inbL5gKbTvQNA2Px9Nz2hY4rPzEYrG2/9ZOF61WqyESiU7NKqgb+q3ONkMsFuPixYtYWVlBuVzuK+teJBKx9nZcEQ6HkclkTpX4d2r7ckWtWkN67wA0VQdBiqCxWSBVK2Gz298QT8zW6XLg+CaZC5iYaq7HXP6BK0o7CZfFYsHBwcGRrolcLsfZs2dRLpfh8/mws7PD2edYKpX25RHd7dgPDg6QSCQgFothsVjwM4++C7/6lU9CMTkCmVaFqGcX7524ekPIrNfrhcVi6Vpx1ul0iMfjpzbY6lTdg4W9L6JcSOPut7hQLtZRCVpQMAmhPUGYXSKR6Ch9a4XJZEIqlerp5RwKhaDT6Tifi8Vi8X+bQAUGtwjtTUarxpXZFfW6KSmVSszMzLBReT6fD0NDQ7BYLCAIAmupA3xl4xWUiiVM7Q3ggeHePq8AQDcaeCbkAVWpopBIIbUfhkKjxne2l+Gcua9rwpVYIsGzggQ219ahGjKjWizh2ewexmN+nFWajhBXhrQChwMncrkcCoUCBoMBcrn8UC4xQyEeW8D2rhdvOf8AdAo1hBopFPdOI53PYHt7G6VSCTKZDHq9HkajEWKxGHSDxic9L+NJzysw1PeRDYbx0UsP9RwQ6eRw0Ix2LX0GnfSz7TAzM4OFhYWOHpbr6+tQq9V9kRrg8OYXCoXgcDiOWUc1g/GUHRgYuCHpS8AhUet0Pns8Htjtdk5Vr04yGK/Xy/rRtmJ8fByLi4snNlDvhU7VWb7vyejS19bWUKlUeE8xc1k7mpFMJhEKhU51cK5YLHbNhu8Gxh9bFstBrlFBolFBolQgtx/BiMmKIUV/tmF80EnWYjKZsLKywovQHhwccL6Gi8Uirl+/3lF2wriYtJMBMW4qzP3A7/f3tEEEXu+e9Ov8USwWEYlEjpBYp9PJnvehUAg/d/Y+hLUkKvUaJqbuAeWPnrpZfzKZRKFQ6CmRGhgYgN/vPzVCKyU1cJY/CNuFNdDiHPSGUUydezt2vIcOJlNTU31VOTOZDC+51+TkJBYWFo7YkTWD8b7lc00Wi0VOBZofJtwitDcR7W52xWIREomEk4YGOFyQxsfHQdM09vb2MD8/jzhJ4Z/SHlTzRRTiKawf+GFwDGIIr28ZKYpiCWapVEKxWESlUgFVryOyvg2BWIR6rYbsXgSgG4hREWxLt0FRFHtszZ+DpmnkqmVsbG6AbtB4+c8+B8fV8xBAgG/GqpBPXmVJq16vZ0lr1+9HSsLw4+ex8he7mDBaQA4ooHrABaFSDLlawS7WxWIR8Xgca2troCgKG8U4Xkz7IFHIkdjZAykR46vpbdxHnYe0iyk8F0ILHG/pM+imnz322X5gfba4uIiJ6Sl4y2mUqCrGNAPIh2LsBHG/GBwcxPz8fMfXYDxla7XaDfOUZSAWi9sSUUZq0DzA1ut1WitKzI2sU3WRJEkMDQ11JAKngXQ6DZlMduw77LaR6AbGQN3j8WB9ff3YedYNfJLZ8vk8a1/H5TgZ2UG3c4WmaaytrfXshrSCIbK5XA7Dw8OYnJzEZP4s/vLFbyNvlGBYa8SdpPmGVPZa0UnzSpIkCILgRQCj0SgnEpHP59kuWrfvt1cSInM/oCgKe3t7mJubg9lshs1ma/t7aLVaJJNJztcgAHboK5VKsV2mZhLb/LhQKITbWvSdReXAqYUDAIfXWScbxlYolcqu7j18EQqFYDY4MTry4JG/n5yc7Jhi2AvMusF37ZiZmcHy8vKxCHLgcNPf7jdqh1SliG8G3Pj+5jXkHTq8a9DKOjD9sOMWob2JIAjiWCue8U+laRrlcpmz7QxBEOyU6X/6/heR3A4gF08i6Qth5P6r+PsXnoJpssISUbFYDIlEAplMBpVKxZrLEwSBNyvKWE4EoRseQnxzB1q7FW+bvAszpuGux1CmavhcbRegaThuS0Bh0kM/4sBZ1wzOjvTW97RDqpaH692XYexCRuRyOWsfAwDupWfRCFcQ3d7FzvdfxQO/9jHU6DqSlQIGSW3H1ykUCpwIKdPSb91w8NUukiSJ8ekp/Psv/zVqgzqQYhKFcBzvtc/iHXfcz/l12oEgCKjVagRjEWQqJdANmiUDoVAI+/v7ba3RbgTaEVE+UoNO6OYn3IzBwUEsLCx09SY+CTpVZ086UDE+Po5gMMjaenG5GQmFQk4V2nK53DGgoxMYK79uhGtzcxODg4Ocv2emVV4oFDAyMnJER+1Q6vHjjouw2+1QKpXY3NxEKBTqu2vBFel0uqPfNR/ZQTqdhlqt7vm7ZbNZ1uGjF1G2Wq04ODjoSZBIkoTL5YLT6UQwGOzolKPVarG/v9+T0LaSWIvF0jHQADi8vhnP7NbHMENjJ7ExbAYTX871POZq39UL1Wq1a9WT6Rqtra2x0dlckEwm+7LKEovFmJycZIfEGDBdUS7Dk9lqGf918dvI1yrwJsJ4OuFFdL2C/+vM/X1JJN9o3CK0NxGtSWHA4QIvk8lAURQvQtsMqV4D/cQwwls7KMYTaNQpSE1GzovHhyfuwGe3X/v/2fvv8NbS8zoUX9jovRIAUQiCvR2Sp03vGs1o1IstWbJcZDm2XBI7tpwbx9dPFMexrv2zHSs3cWI7cmzLViQXlaiNZjSjKZrRzJzDDlYQBAGCIAiA6L1s3D843x4ARNkb5JT8ctbznGfO8IDA3thfeb/3Xe9aWI0dQq/T41H1IG7rEswCgEQgxDsGpvHNnSXoB21Q9OmR2T/Evbe/l/M9EASDQU4NFQBgVmqQT+egH7RB/F4lEl4/NLZ+aMSdv8tsNsv6+zabzQgEAszG1qsA9bPRPZQNCsT3/BBrVSjn8niaDuM9tRqocywgdK2GHxSO8Z1vfgV0pYpnxQl80nkbTnyHUCqVPWvK9gKRSIRyudzws+3tbTgcDs6lTlINoCiqo55wM8bGxrC1tcVJPooNYrFYy+wscLqp8/nny2zYbDaIRCIsLi52tMgkYJOhJZrG7Qw62qFTUx5wmo2kaZpVwEkC2Xw+37GZqV51ZHR0FIuLi9BoNK/LwaT+2tq9PxfaQSAQ6GoEE4vFsLe3xyqYBU4DULfb3fV1BETMf2BgAMFgEEtLS4xBgVAoxELmCF+6+V1Yc17cYx7Gg5YxJnDJZDI4Pj5mxni3ILYe29vbsNvtHRVjyKGKTTNTO/j9fiiVSk68f+Lsdd6Admdnp6vMmEgkwvz8PCeL95OTE9aVvmaoVCoYjUY8tfgSfHIahUoFkqMEfvT2B1n9/iuRfaTLBZRLFZRyOfAoCmuxII5yKVjeALrPeXEroH0T0Sqgzefz0Gg0KJVKnLuKCS7rbPjhzVcwct9tSA4PggceBsrshfUlAiE+OXE3gNPNb3V1lfXvfnBwHvRxAkeqfpiNRly5bMLBlhv6HvT4uDZUAKcLnCZWxPzUNAKVLCr5IgwjA7iT1uHId9Cx7Myl+5Vk/cjGdnJy0tOp+igVQzGXQ8x/hIO//zbmPvxOHKxv40XBy1BJZODz+QxvWSgUMn8nf0QiUUte8zPBHbySCqBSKqMGYHfXg89u7+GPP/DPXtdgoBWag6xYLIZqtcqZx/ZCyIO/2/0h5Fk3nLQM7xiYYV3KUygUUCqVCIVCnMqr3bC3t9eW7tAr5aAZxGN+ZWUF09PTHZ+fQCDoKLdHlDPGx8c5j4NOTXlsVUQKhQI8Hg+KxSIrKbr6OUlRFKamprCxsdGz5Ws3lEqljusUW9pBpVJBqVTq+B1Ho1Hs7+9z1iolNAGuShjEDSscDmN1dRVrmTB+UAkjXsqCzsTw5b0EspkMJigVEokEZDIZTCYTZ6pOKBQCgK7zzGKxIJ/Pw+fz9SSllclkEA6Hce3aNU6/ZzAYEAgEenbZAk6fHY/HYx1IOxwOaLVarK2tdXVbzGazPcmwEVTUUvz595+HRKkA+DwUUln0xZx4j/K1pnCaps9QDvP5PFzBHUSOvOAJKFSLr63ZRbrc6qPecrgV0L6JaBfQymQylEolpNNpzu9J0zS04Rw+ePkevFI4RiWTx+3Dk/iAfRYLCwucdS5FIhGkUmlH3lbzPTkFSnzoyv3MhhMTyXoqLx0dHbEOPnK5HLa2tqDVanHH9dtwnaaxEjvEzawE77j+AAYUOvj9fiwuLmJmZubMZsRVyoWiKMjlciQSCWg0GiSTSdjtdla/SzIf8XgcpUgUAA/WqzMQyyTQDFigVqlwx9XroKtVVCqVM3/y+XzD/1dffV39WHrSu4Ro4hjBDQ8Of7iEaz/9QfBMeiSyp2OK0EveCNTrIXPhu9XjlfA+/sb9MlK1Mk4OAtjLF6G3WTAE9pvS8PAwU3q9CO5eLBaDXC5vG9hcpIajSqXC9PQ01tfXO3LyOjXgAWjpAsYW7ZryaJruKJcEnM7Pvb09VCoVDA4OsgoEWs1JmUwGs9kMj8fD2cqWDdjIJRE3vm4d5Z3WLuIi1Utg3t/fD5/P17O0G1FO+dJTf4e47xAn3gDSJ0koNAp8+yiOux/+aM/fLdeGQEI9CIfDnA64XJV76kG+717nJzGd4bqGqVQqXL16FZubmzg5OcH4+PiZZ38RNuVPHW5BM2CBd2EV2aMIBq5dwpde/B7sCRqVVytlFEUxzdhSqZRpxtaODmBrmUYNAF8kQimdRZ9eD6tMc65reqNwK6B9k9Ec0JJJJpFIujp1tXqv5eVlOBwOXDUY8HEAyekkgsEg7P0W9Gl1cLlcMJvNHRfjZjidTuzustPzLBQKjE0sgU6nY9yu2HIBASASibAqEft8PkQiEUxNTTEZET5F4YrBDtpwjAHF6cJPfLRbaX2ybQirh91uP+3IlilRLpfbLo40TSMWiyESiSCTyTCZD6fTidnaPAprT2P9YA9qqwnZYAS/cds7IeDzAT6/58VtW00jEfKAL5eCV6ugWimDqgHZZArxcBTF4mt8aoFAALFYDJlMxvxXIpGce2ElyFfKOMwmYM+lENk7dXDjupG8cOxBpVBAOhxGZNuP2Q89ghdCHnxkmH3XLuGZu91uTo1W7dApOwtcvI6jTCbD3NwcE5S24j93UjlYX1+H0WjsmTfdTk+4k1xSfSDL1QAgl8u1dLiz2WxYXV3tKUvZDc36s61gNBqxsbHRcQ0Nh8Nt165AIIBYLNYzf1ShUDAqMec5lEpVKuhHHDjZC6BWKsE4OQK9RNHzd9qJN9sJRPFFIpGwHh/n0TgGTq2RY7FYT2oHHo+nZ0teiqIwPT2NcDjcMsEUjUZ7kk3M5XJIpVJIp9PYWdtAJHGMwkkSoaVNWKbHIDPqMTY+Bpmks2OkU2nAz4zfhS/u3kDJoIU0mcev3P8QRPzGe32jkiFccSugfRPB5/PbDgyJRIJiscj6vUgwa7PZGjYstVqNnZ0d5j2vXbsGj8eD1dVVTE1NsZqU9U1q3RaQ4+PjlouE0WhEpVKBy+ViFRgTO8tOEyeTyWBrawtGo5F12UmlUuHy5cvY2NhAMpnE4OAg1ndPsLnjhUIqwNAwDaGA3WRN54Evf3sdomeOUC5loOobxvjg6WZQqVQQDocRjUZRKpWg1WphtVrPLNgiUPj12YfxA9EqsuUitDQf/bzzKw48YpvCjYgP1WwBttkpyPq0uJ3fh35z/5nAg/C1c7kcCoUCkskkisViQ/AikUiYJkKJRMIEvd0Wtt1kBP95/Rn4d7bxldQuRqHAv5n+8bavLxQKyGQyZ+Td/Ls7SJXSKKTzKGdzSB4eQ2znzjMzGo0IBoOsKw7tEI1GoVQqu5adz8uhbYZIJMKVK1cYrdrmoEogEJwxawFON2GZTHbhDVXRaLSl+14mkzm3k1WnQ2a97edFHbyAU6vPbs0zIpEINE23zfARPepWc8Pv9yOVSp1b81ev159bT/Uu8xA+//Q3MXD7LDKhCGiaxl2m3pVAuvFm24GiKMzOzmJlZYWV/XM4HAaAc917X18f9vb2OL9HJpNBNps9d3WA2K+7XC709fXBLcjjicAmgu493DdzFT9ttZwJIoHTfT6TyTDBazabBQCmubuvrw+P3XU/Ens3oTQbIFHIUSmUYIWkazBLcJtxENf7HKjUaCwvLKJf2vs6+UbjVkD7JqM+m1J/4uYiv1MfzLaaoM1SL8PDw4jFYlhaWmItpD8wMACfz9d1sT85OWm7WFssloZTfCccHh62LeGTkk8ymexJckogEGB2dhb7+/v4T//9GyhSBiRPQpApNIjnt/Hhd4xDwO8cqBWKFXzle24IpRqEgvswWQbxtSc28NB1LXjVPAQCAXQ6HSYmJrpuuHyKwqBcC6lUynTFnrd5qU+qwKenHsQ/JGvgyyS4ZBrAnYMTcLlcsNlsDeVQgUAAhULRkYpSKBSYoDedTiMSiTRoCZMSlkQiYf4rFInwXzeeQ6FaBk3TSB2F4RuV4en9dcwrzV01ievl3egBAz6//eLpa5QKiJVy9J+Ue+LETkycfg9cuXf12N/f7xqUXBSHthlE8m1zcxMej6eB49gqQ+v3+1EqlS4kK13flEektupLrySQBYChoaFzNd5ks9m25X+BQIDR0VFsbGxcmIYul4wnoR20OiAcHBy05IR6vV4UCgXWTk2d0N/fj52dnXMFdVO0Ao8MzmBPUkaiQuFepQ3vsPfmdBcKhUDTdM/8dJFIxNg/d5LzuijHR7bW7s3Y2tq6kOcHvJZg+seXvo//uf5DaAZtyOXzWEwfQbD7Cn5y+DakUikkk0mk02mUSiWG6qZUKhn1j2bcr1YjVSngq7EXoervw4jWhJ+YuAPLy8uYmZlhlcTi8XgQ8vgwGAxnDk7NVeW3Em4FtG8imrM3hUIBYrGY03vU26O2W9xMJhOOj48bsiQ6nQ4KhQIbGxtQKpVdif86nQ4ej6fjok828E4TxmazoVqtYnt7u21wTE6hrbI6ROKmv7//3EGfVNmHdFmB6LEbuVwag2oD/METrG4eYmRAzejtkmxM/f8fBBM4PNhHla7ipWe/hjsf+CDkcgUSaQ3edg93XhxxJiIB4UWUU+lUDh+9fB8UCgV8Ph8kEgmuXLmC7e1tJJPJrh269ZBIJJBIJG0PP6TJgAS+kUgEoWQcXtcm6GoFq//wXTjvuQo+xccrOT6Gp+SMIQYbTeLbjIMo01X89X4YArsd160j+Pj8fdj3ehEMBjExMcE6MySRSKDX67s667QDm+wscGprfZHZw2ZMTk7C6/UyYvxEu7I+oA2Hw0gkEhfmAiaWiJFIp6BTaxpUJlKpFPb39wGcP5AlyGazHXnpGo0GSqWSlY00GyQSCajV7Dq5zWYzNjY2zgS0hOPefP/b29ugKOpCDhXAay5fvfJAE4kE4vE4fu7+dwE43Xu2trZ6UlY5j5FGPRQKBYaHh+FyudoeUrpxtbl+Hhf5Lr/fj76+vgvX7A4qAEV/H7affA650AlA8fDtbS8u504THGq1GlarlfVawuPx8F7HLOYpLcADwqFjjA44kclkOOvi9vf3M1XQ/x1wK6B9k1FfHuSqk0mCWYvF0nHAkWC0GURShDRLdZMU6e/vb5CqakY4HGbFz3M4HPB4PGeyS/Xv03w/NE3D4/Egm82yKkuxQa5QgUyugmVgHF/9m9+HTKqEUCKF11uDXGhkgnOiF1z//xqtGjKFGhSPwvDUVUgkMhgtQzCZTT0ttvXd1aRR4rwBbTQaxezsbEPnO9lUA4EAaykoNqAo6kyWd6BagSq0hGTwGHM//h7ItWooDDpcGpiB08G9w/hOoxPiyXswMzODnZ0dCF/N0pGGQKL1yOb7dzgcWFhYgNFo5Hz/bLKzwBvjhe50OhEMBrG6uoqZmRkcFdJYix1CmbDDWBMhEAhcWAbzu4EN/O3608CuAEZI8FOTdwIAlpeXIRAIMDIycqEKGmwaZIaHh3Hz5k3mgH4exONx1kol7WgHrSoGm5ubkEgk5+qqbwWj0dg2S9wJpVIJbre7IbMukUhO7cY5NiX1aqTRDjqdDrlcrqWhiMfjgdFovJDDEsBNvqtQKPSkqNANlUoFyVAEmcNjCPlCVKpV6EccEAuEmJ+fP5/2a60GiVgCm82Gg4MDOJ1OzM3NweVywWg0sjrMk3HRPM7fqhzat+ZV/R+C5gxtcxNEpwYPEsyazWZWpyepVNrWIWVgYABjY2NYW1tj+EmtYLFYcHx83PbfuXSqDg8Po1KpwOfznfm3YDDY0JiRSCSwsLAAuVyO+fn5Czsh92ml4PN5yOdSuOttPwqhSIx+6xDuuuMyxsfHMTo6yoiTDwwMMKV6o9GIqbEBTIzYwKMoDA3NQqnWIhs/wPggd+kuoDGbJxKJoFarOz6LbiDlKbIIEZcnApvNhrGxMaysrCCRSPT8Oe1A0zR2t7Zxn9wGw+gg9AP9KKYyMEjkeMjSXeC7FTKZDJRKJZOdIqUvmUyGK1euQCqVnjrlRaNd34uiKAwPDzP8crZgm50FLlbloBMsFgsGBgbw5098DZ95+Rv4hm8N/8/L38Iffu+fcOnSpQvZfBYifnzFuwyIBchFE/Ac7OO/3fgefD4fxsbGMDMz84bLwRHMzMxgc3Pz3KXQZDLJqSGH0A7qEQqFGgJMl8sFuVx+4cEscJolJhJZbEH2jcnJyTNjs5f342qkwQbE1WzFvYkve27iL7dfxHe2F5HJZC4kE0+g0+lYN17v7Oxw1kPvhEQiAZfLheXlZdzdPwLd2CC0TiuMY04U4qkGPeBeUa1WIRAIYDQamTWRcPDz+TxcLherOUP6Dv53wK2A9k0ERVENGdpisdiwMIjF4pZatPXBLFvOktFo7BiMKhQKXL16FZFIpO3mQFEUdDpdy0CLnOK4nO7Hx8eRyWQQCAQAAGW6inQuC4qimAzI5uYm/H4/5ubmLryhRSET4T33DyObiqKvfwA10LhjRof+vu4ndh6Ph/e/bQTTTjkmx6x44K4ZfPhdc9j3ns2Es0Gz/qXT6WwZ7LNFKBRqOFzodLozgZ5KpcLc3Bz29vbg9/t7/qxmkANIX18ffubBd+HTlx/F+0av4SHDEH7r8mOQC3vLCNeXhElTTD0sFgsuX76MSCSC1dXVrhx0kgHnEtDv7++zDk5eLw5tK9AyEW7wU4h59lHMZJHwBRDSCuBKvhagkDlKNK5zuRzTYJJIJBCNRhEOhxlJqUAgAL/fD5/Ph2dWbyB9GEZ0cw8Lf/1VVOgq8gYZHOOjr0sgy6YBlUAikcBut2N7e/tcn8lVNcBsNjeshZlMhmlkJX0NOp3uQoOwehA1Gba9FsBrAWirrGTz/XQDFyMNruhz2PD/e+lb+M7GAl4OevDnz34TG1L2TdJs0Iqi0wrhcBhisfhcTaTA6Rrv8/lw48YNHB8fY2hoCNeuXcND01fwyzMPYECuw8iAE9f4enxgsHcHRQJyoKYoCgaDoeGwMjo6CqPRiIWFha5WwK3GxVvVNewW5eBNRPOgyOfzDYs4yarVLz69BLPAaTbB7/d33IyJpEgoFGqrWWu325mSRT2i0Sj0ej3r6yGYnp7GwvISvry3gB1eFsnDY1y3j8AcseBg39dVhPq8sJlk+NFHxjE0OgUeZuHf32P9uwI+hSGLGI/cN808N7fbDa/Xyzkj07yZCgQCGAyGnq0+Cd2AwGAwYGtr60yZiZzY3W43XC4Xpqameg7CiJ1tsVhscD4a15gwrjFhPUOhWigCCvYmH/VIpVIYGRkB0L4pRiAQYHJyEqlUCqurq+jr6+so2k6y1Gyc06LRKNRqNetDG8mQvBE4SidQyRdA0zW89N++hNs+9REkfUG8UHoZVePpQZZs4BRFMQorrf4Qeg05WFIUBY1GC3ExBoXNhL7pESj69EgeHMG1vII+rQ5arRY6ne7CAniuMnpmsxknJyec9UwJenH6I5q/ZO4eHBzAbrd3bdK9SHCx4iVZtnbrCUVRkEgkrHilF9Wc1Q7PHLkhH+hHZMeLbCIF89QInjnexfuH5iEVXBwvnRyM2+2lpIp4nvuMxWIIBAKoVCqwWCwt1xoHX4FfuvZ2JJNJaLVahI/D5zaAqa8Q2e12LC8vN7xnvdLCwMBA27FKDHzIIfNWU9gtnAFZBOsHRzN/SSwWN5y+iYC50WjkPNjJ5sQm82E2m6HRaFpq1opEIojF4jOyR+FwuKvNYzu45RW8uLAOWZ8W+VgSL5c2UUqk8BuPfuTcAUF9V3YrnHYk26HXSAFIcSQUMmYJbND8fY6OjmJ9fb3nhqN6EJ6n2WzmFCg00w2A9hqi9ddNtBF74SiTZj2r1dq22U+v1+Pk5KRnDlz9d11PO2j13ahUKly7dg1+vx83b97E2NhYywyLSCRihOq7HULYcmcJXk8OLU3TSCQSODk5Oe2CrpZQyeVBlyu47ec+DIlcBu2QDfdcuh3zBnaGH53wbvk1rBSiqOSL6HPaobaa8DbLOO5wXkYqlcLJyQn8fj9omoZSqWQC3F7vP5vNctaFnpycxMLCAjQaDWdeNBf+bD36+vqYIJpYZy8uLrbVCb5omM3mBsfCdkilUgiFQl351DabDYeHhx3VbNgYaZwHuVwOB34/Tjx+pMMniG7tQ65RoZzNI55NQ6rmnjhpByLf1W4/dbvdrHn59SiVSjg8PEQ0GoVKperKL49EItDr9chms7BarVhbWzt3QFt/oBYIBC0Nkkij8ObmJuLxeNtGYYvFgsPDQwwPD98KaG+hPWq1Wtt/k0gkSCaTzP+7XC4YDIaeSzykiYDNaZ4M9FaatQ6H44yofCf/825YT4SgsBix8fXvoVoo4tKHHkXCILuQYKBbQBuLxRoa00iXLRvyfzuO5PT0NFZXVyEQCM61KFEUBZPJ1LERrxXaNecplcqO+quk4WJtbQ1Op5P1huzxeJBOp7sGwgaDAaurqz3ZXLYq37PR4hwYGIDZbMbW1haEQiFGR0fPPDObzYabN2+iv7+/7fWHw2FO2dl213wekMAxHo+fOgJqtejr62PG71Y8hJfUUaSDYSgtRtgSNOb05ztUEZikKvyby4/ib154ErEBIe7pm8A7hy6DetX+s/4ASK4zGAyiUqlALpczAS7b7y+TyaCvr4/TNVIUhfHxcbhcLs4KKGwMFZpRq9WwXIriq88/C5FKiSmZHuWFCibHJ3oSx+8FbBIVpVIJ29vbmJub6zoeNRoN3G53x9e43e62tIVeUCqVEI1GEYvFUCgUIJVKMWmwwEUnAB4wcNslCERiSHMVhPcDCJa90Ov1MJlM56a7dJLvSiQSKJfLnA4m0WiUGfftsrGtkEwmMTw8jEgkglKpBJ1Od26b7ub9qdW+DbxWme3UKGwwGOD1epm15hbl4BbOoJ6/0xx0eVIRfH7zWezv+zEdn8RtZSWm7UPn4iuRgIJtcERRFEZHR89o1ioUigajhVgsxlruhqB+EYtu7SFfK8I44UQhnkelWIKE31tZutU9tDtRtnJlkUgkUCqViEajXReyWCzWNqszMzOD5eVliESic6kV2Gw2LCwsMI0SbBCNRjE1dVZPkmRIO3HBZDIZYzyRTqc7Zi1zuRw2NjZgNptZ+b0LBAJG9oxroJdKpc6MMbZanCKRCLOzs4hGo1haWoLVaj0zj8bGxrC1tdU2g+X3+zmrBZzXyalQKDBzpFQqQS6XQ6/Xn3EpIjSkD125B++RC/G9F57HXbffAXEij93d3QuziDXL1HikbwSGyTtO763NpqZSqRrGWCaTwcnJCTY2NlCpVCCVSqHVamEwGM5snK+E9/GV/WV4XVu4H3fiJ8duh0LIvlqgUqmg1+s503648v8B4OngNr4d2kYqn0MpHkdYcAj1nTrc+QYFswRmsxlHR0dt79flcmF0dJT1/RG+fav1LxwOo1wun2sfomka0WgUJycnyGazzBo5MjLCBOXTAHJiPv7WG4BAIoFJqsQv3XY/TFIV8/t7e3soFArQarXo7+/vObht1mkn1+h2uzE3153LWiqVcHBwgFgsBo1Gg7GxMU4VrnquK2nedjgcWFpaOndAW7/+KBQKxkSn1fXZbDaoVKqWTprk91Op1IXLll0kbgW0byLqg616DdpYIYs/Wfs+ipUSioUCVlZW4NPpcNeV6+f6PDJpuEqz1GvWEmmkeqOF4+NjWK2dXZtIiTQSiSCdTjPGA0NDQ/hUvwZ/uvEcBGIRDMMSFFJZTBfZuZp0A5/PbxvQBoPBlp2rw8PDWFpa6hrQJpPJtlkk4n5DJI06BZGdAh+KomC1WlmVxAEwnL5Wz1en03XlUQOvGU94vV4sLy/DOjqEbwZcCOfTsMq1eP/gHGJHxwiHww12w2ygVquRSCQ4B/nJZPJMQNuNdtAMg8EAnU4Hr9eLxcXFBu1alUoFsVjckoNJsrOvNx+2UqkwGz1RPGFjzrGxsQGj0chc94zOgjG1EVCf2t2eN9PTfI0GgwE7OzusD8ZEzo1k5jOZDGKxGLa2tlAqlSCRSE6bTakSPu8+Nc8oVytYiwXxp+vP4Tfm3s4pI+RwOLC8vMzaDa6dxW43vBLeBwAkghEcrW1i/sfeg5U0N5WAi4DBYGi7Pmxvb8NoNHLKGFutVuzs7JxZ/87DmyX0mHg8Doqi2jon1mOOr8H1d34Car0OcoGIGQMURTHjndiK7+3tIZ/PQ6PRoL//rBtiJxD5rvpr8fl86O/v7zjvotEo09BssVhYHerbvQ9ZD2UyWcP+eJFzFzitWB0cHLQ95BInTZfLhWQy2TCmrFYrDg8Pe6JgvFG4FdC+iWgOaMnJZzMRQomugEdR2HvmZUy87yHwdAp4UlHM6rnbfdaDSM1w5XcSzVqfz4fFxUWMTI7jy64XUU5uI7Xrx7+wfgTNS1Mmk0EkEmkokZpMpjP8rDmZDP/y0kP4p+z3oTLo8ODdl6DJ0ZycTdqhXYaWiJK3Om2ybchKp9MdFzESGK6srGB6erpt4NdN3sliseDGjRus/MM7aQGnK0U8cbCJV8QZOFUGPGydAL/DwuR0OhEIh/Drf//fILT0QSATYzcawvOv/BC/fse7etJkJJtHLwFtq0MTVwtQItdFtGuJqQipRpCDTP2C7fP5GjQ7WaGwCeRvAiUTIGrveFfPgxUIBNBqtXA4HKw35M3NTahUqoZxWn/tk5OTWFxchEwmO3eXNgE5SPQKEuCSgDiXyyEWi+HxpRcRPfKiWCwguu2FfmwQnnQU6XIBKhG3gHNqagorKysdXacIOlVaOoFXAxIHR+DxapCqVUgeHEGQK+Gm9CaA0+9JLpdDLpdDoVC8brJmFEVBJpOdaeYKhUKoVCqc13qJRIJKpdKwLnHlzZKsfDweR6VSgVqthl6v5xQMRaNRXL/eOYlDOvjJmheLxeDz+ZDL5aBSqdDf39913Ot0OsYUBDgdjycnJy3Xt0KhgMPDQ8b4ZmJi4twZy2g0yvSfyGQyRo3ovFnaVt8zoQ50SgIIBALMz88zCQ2yB6tUKmxvb9/i0N5Ca9QPqPosAQkyKoUCKKkY2UgcMrUSggs4FRmNRmxsbPTcsORwOKDRaPCZr/41/MUUeJthUHw+/mj1KfzG9EMQ50+zTJ1KpK0woTHj/fZZDA8Pny4QutPJvbS0dC4jhXayLIeHhx2DVTYNWWwygyKRCJcuXcLa2lrb+yiVShAKO1MsHA4HvF5v1/IxyZo2I1su4rNL38VBIQLBXhrLGhX20lF8avLejtkvfzULnkmD4y0Piuk0lKY+qAcsqOi4NewQqFQq7O7ucv69diXhXi1AiXYtUfQgnGG73Q6Px8N8z+FwmFtzU60GhH8PSP4DEMkB+38OmH4bUH8AQGceLNesh9vthkQiaciUNpcZSaVgZWWlQXmiF9RXdog190WYcshkMshkMjiLY/Cpedh7eQkiqRzR7T2IFHKU50sAx4BWJBLB6XSysipNJBKMegZbRKNRmCJFiGRSjDx4ByJbe5BqVbgqMTF23IVCAZlMBtlslrGKBl5r0KkPdM/7PZLsGUkWEDnEXt0UifYoGVtutxtms7ntQasVD1av1/eckKjPWnKBTqdrkOM7PDzE9vY2VCoVTCZTy0w1Uf1IF/KQiyXY2trCxMREw2vC4TCjEmGz2XrOxrZCPp9nDjsSiQTF4qk82XmVbtoFniaTCcFgsGsM4HQ6GbohUTxqJf/4VsKtgPZNBhl0+XyeKV9f0lqhEUnhPwhh6N7rQJUGdZSCJFUEetPtZ0D0Xc/D76uIBUhbVaD3ktj65vfhvO86KoUivpqm8OFLd3HmEBGUy+WGhV2n00EikWBtbY3h73JFuwxtNBrtWDrr1pDFReZHIpEwPuWtggo2/D2j0Qi/398xiOhEN3g5vI9EKQeRSoETzz5ADeDFExeuUTrohFKUSiWUy+Uzmbet2CGykTgEEhEObnjRNzkCkUyCSo+ndKK+wMV0oFmjtx5caQfNMJvNMBgMcLvdDAUl6H0BGfqPoJCk4ds24vID/579G2afPQ1mX0WhUEF05bcRk2tQqik5HfI6gWRZmsvMrb5XkUiE8fFxrK6u4soV7rbMBPVSWlqtFolE4kJlqe4yDeMbCy9AJlfAcN0GpcmAMYEGBx4vDnBaLuUS5BgMBqY5rVNAwEXztlQqMQ2GP/G2d2EmFsD3gzsQqxJ47PJduMc4jLW1NYanLZFIzlRMiLU3qWDl83lm3tVndUmgz+Z5CeRS/NPGy9BWj2EUyWGOlnB1/nLPzzol4eE/f/drUI7YYa6KcLfU3FBZq1QqiMViHXmw50EgEDgTVHJFfbNiIpHA8fEx3G43FAoFTCYTM5b8mRj+4mABad8PIeRReKd5AlcUChQKBRwcHCCRSMBgMGBqaurCrawzmUxD5r55v7Lb7VhaWrpQrd/6voxuIHRD4kgq1qvx+Se/jqPDI1hCu7jbNPyWahC7FdC+iajfeOpNFeRCEf71/KP4Q//fQT5pR8kTxKff9zEc+w+xvLx87oml1+sRDveuc1dDDRRFQW3uA2o1FNIZ6CxmDIyPnkuqqlVXuEwmw9zcHFZXVxmnLi5oFdDGYjGoVKqui32nhiyuMj8KhQKjo6Mtg4pOAVs9hoaG4PF42vrBd2pky1fLqNE1pI+jOFzchESnhVAkBM3nQavVQiQSMX/q4SxMYmmhgOCWB1d+4r1IByKgJDIMq3qXJCKnfLbPslVDWD240g6aUa9d61p6AvLEv8VOqAKLkYKOBwgiNcD6J2d+r96koFAooFwuoxD6AYrHRRSKZfzXL0Xx658wQafmY2JYBJHmYmwz/X4/crkcpqenW15TswMhAIaWsLm52fL32KC+iqRWqxGJRC40oJUWqviobQ4vKQOoSUW4ahvDux2XIKT4DH/T4/HAZDLBYrGwmjOjo6NYWFhgDsfN4JJl9vv9CIfDDRJw142DuG4cRMBwWhVRKpW4evUqo+s8MTFx5jopijrTOEdAsrqk7J3P55nDWn1WV6FQMNddqJbx+8tPwJ2LQLxfROYoitmRMdwhvp3VfTUjkI3jP289h0glj2z0GO7DCLJXrmAkHkc8Fmvgwdrt9gtTOyAgZkIX2XxUH9ymUikcHx/D4/GALxbhLw4XUZLwkfHFQVcr+Fq1AvHzNBxqA2w224U1VbbCyclJRzWP82ZpW+FUV1rDqvEZeE2r/BXXMv7L2jOIx2LIJxL4gvsVhHIp/MhQb1WA1wO3Ato3GUS2q1AoNCysvHwJPzl7H8bHx+FReVBIZjA8PIxUKoWVlZVzGQ6YTCbs7Oz0HNDqxHLYRAosHXhw6UOPQSgWgq7QEPijiKrYTRIuIBNqY2MD2WyWU7mnVUAbCARYlRgpioLdbm+QKyFIJpOcZX40Gg0GBwexvLyM+fl5JqitVCpdKQfAa1yvdhklstm2wqBEjciOF/I+HSbf8xBqpTL6bVbMDY11VJTQS+T4Kcs8/nvwBJRcgcE5M24rKpBPpiE3iFneeSMMBkNH7cdmELHxdjCZTNjb2zt3cKVSqXBtxAv/Bg/rOxk89WIZP/qYFp6Nx1GIPotyTd1AXxEIBBCLxYw2s1wuh9Y6CYlciIOjGn7hx/qgUfFhMYkA+eC5ro0gGAwikUi01cPtpH1rsViQTqfh9/t7cq/KZrPMmFepVNjbY29C0g25XA5erxeP3XEfHBsbZzJ9EokE4+PjoGkaoVAIy8vLkMvlXQMqIknUToqPjUJLKpXCzs4O+vr62vLGSaMcOfyOj48zqhpcqksSiaTl3KZpmnF2i8fjCAQCTFZ3KxOBO7SLGo+H7Seeh+3yJPZzcSz5dzGiNjK/X/9enf7+hG8NmUgMVbqKxb/9Bhx3X8Xi0hK2xRaMWx2ve1PQwcHBuTW8O6H+MLF86EV8I4FsKIrVf3ock+9/OxTlCmiLFrPD7DWne8XJycmZuUw0w0k8QOhvXALabhUru92Ora0t1ns1RVEIKHig5FIk10+Q9Pkx8vBdePJwC+8auASp4GJUic6LWwHtmwSapltmUggODw+ZrmCr1coMPpVKhatXr2J7exuRSKQncevzlmlRq+GBmh7y+avwJCLgZQr4+YffjUmVCR6PB36/HyMjIxfWhAKcTqiZmRl4vV5OjlbNKgekGYxtg4bZbGYasuoPHL3yBw0GAyqVClwuF7OQlctl1l3WIyMj2N3dPcMLpGma6RhvRjQaRc4Xwi899F58LbSJEl1FYfcQvzhxLzt5tJM0/tP7fpa5X5qmsbi4CIFA0BMNpJP2Yys0d9u2er9CoXBumSwAQK2MgX4R0ikBbqwWIBICMpUAokELJEoWPNfa+1GpPoPY1uO4dkmKBVcexrFfgUh4vmZO4PTAEg6HO5o7dKNyjI+PY3l5meHDcUE916+THB5XVCoVrK+vY3p6GhRFdaQAUBQFi8UCi8WCVCqF/f19lEqljq5cMpkMZrMZbrf7TLYtHo+3VWipVCpwu90ol8sML7YdWjXKkfV6Y2ODaT7sFRRFMZnZZsT31yHOHiDhC+JoYQOmkUHkhEmEwmGoS7wznOrmv9eXjE+faw01ugaRQg6hVAI+xYNQLoXVZoNO27sEIRuQRsnXMysK1CmKHB6hlM5CZtTBfGUWCoMWSosRKmlvPQJcQKh/zfOVSHeR9ZY0vnHJ0nYzdZFIJKAoCrlcjvVemK+WIDNoUC7k4XthEXd+6scBnFYIbgW0twCgNXGbpmnk83lm8SILKVnoKYrC5OQkotEoFhYWeuKX6vV6xGKxnrKpGxsbGB0cxr1mM6OBeUl3uimMj4+jUChgZ2cHFEVdGKeKwOl0IhQKtRWAbkbzxnt0dMQ5M+10OuH1ehkOWXM2nSvMZjNKpRI2NjZQNCrxgncF1j4T3qHTdl0YVCoVKpXKmYUoHA63LF15PB5ks1mm2/vBoRkUqhVkJ5KIHccATeesZigUYigJBBRFYX5+HktLSxgfH+/p4EIWbTaLKZtA9by0AwaKh1AKfwG5ogif+pgBdE0ITd80oBoGeCyCZR4fB9VfhXXuAVB9FYyq+7ET1WHmnMo7sVgMfr+/Kwe2HeWgHjMzM1haWoJMJutJL5NALpezskntho2NDTidTs4qACqVCjMzM4wr040bN2AwGGC1Ws/MT5vNhtXVVaY7nSCbzbYcv6FQ6FUXQfaVMKlUeub7IOowgUAAN2/e7BoY94JLRhvKP8xAolbi8sffC75AAKVcgfvnrkEp4v5Zj2kVWKzGQNdoDN55GaaJYZiqQsT8QUS9B7BYLDAaja9LlraTSst5USgUEA6HmaYmvV6Puy5dxpa8jJWwD7bZUQiFQlDxLG7r427+whWJRKJl5YmsjfV7OtcsLZt1gEhvtqOwNWNSY8bjq6+gkEhA5xwABR76pAqoOTZsvp54a4qJ/R8CHo/XYFBAEI1Godc32vsRS8J6GAwGzM3NYX9/Hx6Ph1PGxGQyIRTirpno9XohlUqZoLCVioBEIsHs7CwGBgawsbGB7e3tlkoDzWC7QJrNZoyNjWFlZQWZTKbre9Z/di/cYYPBgGw2y3C7uFjjtsPAwACeiXjw+9/7R7wQ2ME3Auv47PLjyFfKXX+XZGnrEQ6HYTKZmP+vVCqMBu7s7CwTiFA8CjKBCH19fUin08w9tQJN08ym3gyBQIC5uTlsb293fQatYDAYWHXLsm3YMZlMCIfDnK/jDGRXsJX+BYyO2OCwqXGUGgWs/5ldMItXReNPYrCMfgjQfASa/vvA4/EQi8V6vqRUKoW9vb0Gmko7sGm2I5zhtbW1c2VZ1Wr1ue4LOF1PlEolE8T0kmUnigbXr1+HXC6Hy+WCy+VCKpVqeN3U1BQ8Hk9bMxvgdLwtLy8jmUzi6tWrnA5IxLikFWw2G6amprC2tsZ0y18U4r4gPjZ6GyxDjlNZuqkJfKBvHMlwb93oVrkG//LSQxhU6qEWSXHd6MBv3P1ezM/NYWZmBvl8HgsLC3C73R3Xj14QDAa7appzQSKRgNvtxs2bN7Gzs8OYrFy5cgUOhwNSqRQ/P3kPHjYM47JtCB+4/X78mGka5Sz7ClKvIHa3zWhVwarP0rIBm3VAo9Egm82y2psBYJAnx52yfqDKg0gpg1GqxC9PP9DWYOXNwK2A9k0En89HrVY7I+wdDAbP8DMNBkPLzYNkAMRiMRYXF5HL5Vh9NteyL3AaNLXSXiVd681QqVS4cuUKtFotlpaW4PP52m6gbBuj6t/70qVL2Nzc7Lip1mdoE4kEq2awVhgaGmKCyHg8fi73LwBIlvJYodKgKxWE/QHwBAKE82n8INRd0kqhUICiKGbDbqYbpFIpLC0tYXBwsKPN7MjICDweT9t/DwQCMJlMbZ8LkSTb3NxkPe4I2o3nZpBn1g31tIPzIBqNQqi5H5r5p0GNvwzD9B8hFGW34AOn/L/mDXl0dJTzgZMgk8lge3u74VDSCWztdhUKBZxOJ1wuF6vraHWw0Ol0Z4JGLohGo2fc6Ho1OSAwGo24cuUKBgcHcXh4iJs3byIYDDIl2NHRUayvr8OdDOMp9yrywtPNmKZphs40MjKC8fFxzuuEwWBAPB5v++8ymQxXr15FOp2Gy+ViHUi0A9GGlcvlePe1e/DHd3wI/2r+UfzBnR/Eu+56AIlEAn6/v6f3HlUb8a/nH8UvTd+Pnxm/C3Lhaca7/vCg1+uxs7ODxcVFhMPhc889UmY/T/WLpmmEw2G4XC7cuHEDx8fH0Ov1uHbtGmZnZ2E2m8/MIwHFx+0qG37u8kP48PBV3HH5Gtxu97m0ltkgnU63TIy025sdDseZpFY7sF0HbDYbDg4Our6O0Ht+9sF34219w3hs9DI+c/VdMErZKf28UbgV0L6JIMFWvUsYkV5qlZXS6XRts1AkA7CxscF6EdNoNKwzLJlMBn6/v6WmIyk9toPRaMT169fB5/OxsLDQMjPMRou1GRKJBJcvX4bf72ccW5pBURTTeBcIBHo+/avUajx9sIl/8fTf4ndf+l/4bsSNao3dAk4aOoizjNvtxkuLNxHZ2kMpnYXnuz/A4eom4h4/PPteVkHCyMgI9vb2kKuU4DsKMif9QCCA3d1dzM3Ndc0iazQalMvllsEoTdM4Pj7u2pwhkUhw6dIlrK+vc8rWkENQt00wmUyyzoYT2kGvIEFNPX/PbrezWvDJ74fD4TNlQZFIhP7+fvh8Pk7XUygUsLm5iUuXLrHe5KvVKuuDocFggFKphNfr7fraVoEm0VrtBaQJrHk9yeVyjDTYeaBQKDA5OYn5+XlUKhUmoygWi/F42I3PfO/L+PzS9/Hn/hv4Xxs3sLCwAKFQiGvXrvVMoWh3sK8HaRizWCxYWlpCIpHo6bMI1Uun0zENfjweD6K6MvPMzAzS6TSr59sLdDodZmdnMTMzg2w2e+6src/n66kZrFAowO/3Y3l5GcvLy8hmsxgaGsL169cxPj7OKvmQTqeZgzORuWN72OsFnXow2s0r4pDGJkvLVhbRbDZ3XTNzuRxzqI5GoxCLRJBLpG8puS6CWxzaNxEk2Mrn8wyXJhgMti2J2+12xuayFWQyGa5duwaPx8NK3stkMuHw8LDrhC+VSszG2urUp1QqkUqlugYeNpsNFosFXq8XN2/exMjICNRqNX4Q8uDp3TUUUil8yCDDNQ78JeJqsrm5ie3t7TMuZAKBADRNMx7WvW5WTwQ2sUSlkfQGAfDwZGATPPDwQec8gNNFNZfLIZfLIZ/PN2hLUhQFsVgMmUwGsViMvr4+mG1WfIcO4XB7F3M/9m7oBm2gRCIMa004OjpiOMhKpRJqtfqMuD8lFOArB2vwBW8gG4nhtvEZPJRMQC1XcBJTJ/SF5kYjr9cLq9XK6pQvkUgwPT3dVme3HdRqdddxk06nWTeInFftwOPxnNGHJY1vrSxxm3FwcNBW+cJms+HmzZvo7+9nRaEolUpYW1vD9PT0uXiu3eB0OrG6utr1/uo1aOvBVVMYOA3G6pvA6pHNZlnrO7OBQCDAwMAABgYGEIvF8PWXn8Mr/h0U0hnwQKFSKOIL0afxuQ/8M1hU5294UiqVrChJRN9za2sLJycnnBrGKpUKI2PY/Myan8f09DS2t7fh8Xh6akojSZdO6wDJ2jqdTkSjUezs7DAOZc2ue+1AtHnZHl5TqRTjQikSiWAwGM7lKtlcgVCpVDAajS0bCS8CvRpH2O12VlxaNhxaAoPB0NZit1QqMXNVJBJhf38fCoUC5XJ3atybgVsB7ZuI+oCWZA7D4XDbgITRHezCK2Qr70Ws7DqBlLXGx8fbfqZKpWKdBSDWo6VSCW63G39/4xm8jBhK+SKqhRL+YusF0LUabjMOsno/gsnJSeaUPjs7yyyiZEE+r47fy2EvKAqI7QVAV6ugBAJ8zXOIgZPTjIxEIoFUKoVUKkVfXx8r958PakbxedkRREo5KsUSPjh5DQ875piTL03TSKVSiMfjCAaDjFWvRqPBE1EPgjIguXsEulzBS6uLkFwC/sX8uzjdVz19gWQoSqUS4vE4pw1QJpNhcnKStd0ocJpRjUQiXTcxtqXf86gdEEenVpuXw+HA6upqx4CPZGc7mXVMTExga2sL8/PzHa+lUqlgZWUFk5OTnBuluAaXwGkmb2FhATKZrO2BL5/Pt3xOarWaEZ5nC5fL1bYJLJfLNXDBLxI6nQ7aYTtUOT8ykRMsf/lbuO/Tn4RuwIpktYSLUPkkPFo2gRnhc5KGsampqa7Pu1QqYXV1FUNDQy0DItIzUD8GxsfH4Xa7Wx74u4EEyGwPqcSGljTq+Xw+aDQa2O32jntWMBjs+NxpmkYsFsPx8TFyuRxjjvB6SojZbDa4XC5Wh1muiEajbSUWO4FkaQOBQMdsNpd1wG63Y3l5+UxAS6oA4+PjzLhMJBKQy+VIp9Ocr/2NwK2A9k1GrVZjAlTCIeo0QQnnpdupsVnea3x8vOUAVygUDcFMMzY3N2E2mzvyGHvh44pEIkxPT+PzkVUkPCHEj0KQ6XWQ6rV46nCLc0ALnDZayWQyLCwsvGYzywNyxQIKsVjHYKMZuVwOiUQC6XQa6XQax1u7SFYLkBkMqFbKUFtNMKq0bXUpuyGTyUCWq+DPf+QXsR3YBwolzA42WtYSAez6zbFQKCAWi+HlHRdiyTi8zy+ilMlg9kcfw24u0VNAMzIygo2NDVyan0O1RsPn9WJwcJDzPRHzCKKzy6YpoZOWabusYCdotdqe1Ds6WaSKRCIolcozHfL1CAQC6O/v7zh3FQoFpFJpxw2SpmksLy9jdHS0p2oCF8oBAUVRjD1zu8NIvepKPdRqNeLxOOvvu7kJrBnFYvHCVQAIotEoYrt+pI4i0A0N4N5f+SlQPAqRrT0Ihu85twsjcBo0c+Wt2mw26HQ6bGxsMJJkrVAoFLq6JvL5/Ja0h9HRUXi9XmxubrLuagcAoVDIKaAl6JS1JWM/Uy7iq/vLOMwmkNs9xC8/9qGG9yiVSowqQaVSgV6vh8PhuHAjh07rzNTUFBYWFhiL4otCO4lFAkI7aPWa+ixtu/WmWq2yfmbEirk5DlhdXcXg4CDzs0QiAR6PB7FYzLln4o3CrYD2TUTzxnF0dNQ1i2gwGBjby24n03p5r3YC3yaTCcfHxy0DVr/fD5FIdKG2e83gS8SQqBXILScgoCgk/YfYP4rhZtXAlOpJ9pPIDHVaCAwGA2OXG1Tw8M0DFyL7fgzoTRicmUSf9OximMlkmOA1m80COJVOUavV6O/vx+joKEp2Hf565yWoLQWkjqIQiEV4yML9hA2cBi2EwiHmCzCkN7PmaUokElgsFgyOjYCXPkE2mUa1mIdQJgGdzDDNJp2chZohFInwvcguPvetVyCQSqA5KeB3PvgzPd2bRqPB0NAQlpeXu0pMURTVMqNEkEgkuoreN6O/vx97e3ucAtpAIAC9Xt9xXJEGqlYBLeEbszkw1TtXNd8zCWaHhoZ6VtHopj/ZDhKJpMHJrhntmkw0Gg329/dZfQZpAuuko3shWsJ1IJlCUuJ9/x33I9evxNPri5CoVZAbtHivdRqVZBaLocVz62eTa+d6HzKZDFeuXIHH48Hq6irGJsbx5NE2thLHUAjFeNAwhLTvCJOTkx0Duk48XqfTCZ/Px5SQ2UAgEKBUKp0rmGvO2t64cQNylRJfjG7ihC6gkMkil4vhj13fx6+N34f0SRzxeJxxyXo9LGfrkUql2ga09Ye9q1evXsjY7PR5BES6q9WaVM+lbZel5ZrY6B+w4W9e+B6UQxZYZGqYEhXmuREcHx+Dz+dDKpUimUyyfu83ErcC2jcRNE2jWq0y/x+LxViVeYnkEdsySL3At1wux/DwawLxOp2uZad7NBpFLBbrWh4l6HSibIdMJgN9KIvDKg3HnXOQadUQKWT4wOAcrtlPF9x6biqxgqwnzEskEojF4oaAVyaToWbT46+/+UWI1QrkTpLIOuz43NpT+PT4A8ik00gmk0xWWS6XQ6lUdnQduss0BAo8fP9wG4fRPH50+Dru6+/uNtYKm5ubcDgczHfVS4b7vY5L+H+e+SoMA/2olqvgC/j42TvfiXmDHUBnZ6F6v3iFQoGnIh7sCApI+6OgRELAaMAX3C/hU1P39XR/Op2OCc66SU0RPeRWYzmZTHZUaWgFrrSDUqmEo6OjrsGoSCSCVCptyY8k5VI2n0dRFBwOBzwez5nyL+FFnkdBo5cMPYFGo4HRaORUmmZrsECawDp9zxcZzJIO/0qlAovF0hCM/Mz4XTAlKpD2aTFqsmFAoWOucW9vDzRNY2RkpOcgjsiZca0SUBSF0dFRxGIx/Puv/w0O5YBYKUc5V8TTLzyHz77/k12zk90a0xwOB/x+P1wuV9uKRD1EItG51Rjq34tkbV/YXcfWztbpYXB9F8bJEWyvrOJ7BSkemb76uruR1SOdTnekO0gkEuZA2+kwxhbd7G6B1wLadmtBtywtl3WgTFfxp+4XsXS4DZ0wjUwkhmGVAb8z/fGG18XjcUYH/416NlxxK6B9k0CcwsrlMkQiERKJBOtSitVqhcvl4sTrqRf4XlxcbOBrNQuCs9l8mkEaw9gEtKSbPJlM4hcffj++FdrCt15+HjKJBG+3T+MR22uld5KRbTexS6USE/Amk0kcHR2hWCziCd8aUKth7wcLCN5YhcKgRdx/iG3pAOx6U09C7neYnLjD5MRN+iauWXprFAgGg8wJm6AX16VJtRkf0Iwia1GhUilDHc4zwSx5z3bOQsQvPpvNIhKJ4LsrzyCWTcL78hLK2SLu/LkPYyPOXaO4Hq0c0VpBr9fD5/O1HMvtytzdwIV2sLW1hdHRUVYLtNPpPMOBpWmaVUBcD6PRCLfHh62nXKBrYpgMMsh4JzAajefm6p1XOslms2Fzc7OBc97toNrKUKD5mto1gdWjXu2lF1QqFQSDQabi1C4o5fF4MAvkuNZkbSqTyTAzM4NMJoOdnR0IhUKMjo5yzg7q9XocHx/3bBAgUsoRNoiR2T/E0cYuJAopjGPDWEwHMdLX2W67HeWgHgMDAwgGg1hdXcXMzEzHZ8Ln818X+SqFRgWxUo708QkSgSMozH3QD1phGXa8bsYK7dDOXKMeBoMByWSyZ9voesTj8a4HdZlM1lbTGOiepeVSqVk5CeAgG4fCqMXh0jrkRgMiSj72UhHGOrlQKDDKDHw+/1ZAewutkc/nIZVKcXh4CLvd3v0XcBqcCgQCzhlRoJGvZTQaMTAwAG2fAc9urcA6OACnXIed9Y22igbtoFQqEY/Hu27IROi6v7+fKW1+dOQ6JjPCnrpUiW5hc9bMrazC9XIEhpEB8HgAJeBDO2THzMQ0o6n4RiOXyyEYDHJSIWgHr9eLO8ZnmKBjW7CNaDTKajMghwTyWnN0G0c7SaisRlTzZUR2/dBI5YhNtueMsoH5VSe5TtkghULRVjas10WTLe0gGo2Cz+ezLu9LJBIIBIIGrlkwGOTsmpQrlLGwW4XXswi7cwovv7KMQYcRP/+xS6zf4/VEvT2uSqXqymXWarUdD+SdmsDqwcWGsx6ZTAY+nw/5fB5ms7lrabhb0K9QKDA/P49EIoHV1VWo1Wo4nU7Wa5NGozljfMIFZboKukoDFIXM4THkl8YhEAlQYXFYYSMdBoDJ7K2urjY00TZDJBJdqHlCoVCAz+dD8iQKuVACxcwY9EN2pI+jEItFqPoi2EzX4HQ6XzcudTPYrjXDw8NYXl6GSqU6FyUI6N7oKpFIulbtOmVpuXDps5XTA0spV8CRy43bPjnf8HPgtFldKBTeCmhvoTVI2r5cLkMsFrMWkCew2Wy4ub0Ojb0fFrkaOjH75pl6ea/nXvkhvlE8gGdrB335IWQ9h/itt3+Y82KiUCjaasECjb7oraSdzlMqbUYwGIQulINKp4VUp4bKaIBILoU9Wga/SgPntJ0mUmBcJnW3LJVIJOqoTViPVioERH6JS3YjGo1if38ftyn74bGegC8QQCCXgsen8PHL9yMSicDj8bS1E2UDi8WCSqXSkbcnlUrPHM56aQgjYEM7IFWCy5cvc3pvYrAxe2kKAMU5OwsAW3sxVGkBJBI5Xnn+W3AMTSJXkSOayKNP21uZO17M4dt+F5Y9SwgaRHhsYBpCip1sTzMoisLMzAxevPEydpRVbPi96FOo8TMmHfplZznNGo0GXq+3ZaaoWxNYPbLZLOtnTtM0QqEQgsEgpFIp7HY76/Uzk8mwkgbTaDS4du0awuEwlpaWYDAY4HA4WM37XuTMgNN18Njrh/g4BbXRAP0HHznVq87nMa/vrtFKEh1GxxpQAAEAAElEQVRsYDabQVFUR2qQQCBooMX1CkIBoWkaAwMDGB8fx3B2Gn+5/SJCfD4EJ2n8y7vei6k+KxKJBLa2tkBRFAYGBs7tytgJXA19iG00F3nCekSj0ZZ2t81go/FMURRMJlPLLC2XsTek0CO+FwBfIoLz3muo0TREAiEciteSGbFYDEKhEHw+H0KhkLNm/BuFWwHtmwiKolAqlZDNZjkFIrVaDd+NefD3L38HhsQQBHw+PjF2J2dlgOHhYXwz7oZncxulfAER9z7kahW+HtnCpJUbd5EEZK0QjUbh9Xo5+aL3glQqhZ2dHWi1Wrzt7nsxV7yCf1j6AVLiLO6YvITrahvW1tYwPDx8rswj6fLkUg7f3t6G3W5vm4EinCk2i6Tb7cbQ0FDDz0QiEeRyecdOfIJYLIa9vT0olUrMzs5CJBKh+mIJB/1VUBIRpIEEHhqcYagQxHlHIBD0xPEcGBiA1+tty80khiH1pbxeGsLq0Y120Epzlg1k4ipw/PvIVNeQylIwyt4HiteZF1pP8chms1hdC8DvDSOXz8K7vQibYxQH3g3cvJlHn1ba0AwpFAqZjLpEImk5PjLlAn5v6XFkykUcpyJIH7iwl47iX8w82LMtJSXg4wk6hO2Xd8ATC5AWAn+w8gQ+c/XdZ7zb23HA2TSB1SOXy7W0Am1+zcHBAVKpFEwmEys1jWZwHVuEChIMBrGwsID+/v6uBgBk/LFd74jNdDgchsPhwGd/9J/hL7dfhDsZgW3UictlJaa0nekGAPcAlFQXFhcXW36XpCmsF5C1IxAIQC6Xn6GAWOUa/PaVdwIAohPRU5e1vtODxPz8PHK5HHw+H3Z3d2GxWJgA/CLB9nBDIBAIMD4+zjRPcr2ek5MT1pVYNrDZbC2ztGydwgqFAo639/Az1x7CNxMeRPYD4Ber+IXZh6ARnz4rouNO/i4QCN6SpgrArYD2TQVFUSgWi0ilUg32j92wchLAM0duSNQqFOIpyPQa/NXODzGhMUElkqJSqaBSqaBUKjF/J3+q1Srz82q1io3tbdC1Gg4WXaiWKph87H7sePeQGDwtIbLdLKo1GgfZOPgRP4bVRqhEEpRKJezs7IDP57PWJu0F9dnfmZkZJtNnlCrxHtupIDTR2Lt8+TJcLhfS6TTnhiMCcnpmG9ASW8h2hhnAawFtt2xEJpNBuVxuGVQODw+37cQHTjfyvb09SKVSJpAFToMEq0KLx14NPALKAHw+H9OYYTabYTabkcvlcHh42FPW1ul0wuPxtBR4NxgM2NjYaAhoU6kURkZ6a7oDOtMOMpkMJ8OGBhz/OwwZ1rB/WES+QOPqzFeBxCgqyh9DJpNhAtd8Ps9sAlKpFAqFAkqlEv39/ejrdyJe2oTfu4HbH3gfTNYhqBRSPPzADIRCPmNlXCgUUCgUkM/nEY/HUSwWG4ILEvguJg5xFDoETyjAif8ASqsJS2kPNrRO2BSn2aBWZfZOP9tLRXEQj4In5MPzvZdw5RMfQK5SxlL0AA+0UPdoVqvohYefz+fbHvhIYEQOVVz1VOvR69giQdXBwQFu3LgBu93edk534oY3IxQK4eDgACaTCdevX2d+/i8vvY35u9frZcXfZEs5qAcxP2glt9dLU1ilUsHBwQFDgWJz6Gil3kO0rSuVCg4PD7GwsACDwdDTQbQd0uk0ZyMPlUoFs9kMt9vNeRxms1nW+wYbUwuSpQ0EApy5vbFYDB6Ph1HOeBt9GVv9HmhEMti1lobXKZVKZk2rVqu3MrS30IhytYLV2CG2okFcK2ZZl/hLpRLWD7zIHIWROUlg5zvPYvq9pwvfU5Xn4VAZIBAIwOfzIRAImD98Pp/hANb/maPiWIsHIZJLIe/Tg0/xYIAYkUgE+/v7zEmPKAGoVCrIZLKGSVaqVvA51/dxM7AKWc4HpVqFD+smIE4XO2omXgQCgQCOjo7gdDpbBi/lcrlhASHOYh6PBy6XC1NTU5xP2ST4ZAPCGeu2sUskElZi1bu7u20FuYVCIcLhML72ta9BLpczG38qlcLe3h7EYjGmpqbOjLW9vb0G3VmbzcZs2PUbh0wmw+joKGiaRjQaxcbGBvN6NhWG4eFhbG9vw+fzNRwmWm2avfDD69GJdrC1tYWpqak2v9kF2WdB8YCvPBGHWScAj+IBnn+AwDrDKEf09/czhhWtIJEAd15SIxFVoloTQEwV8aG3z0EoPKUIUBTVVZ4OABP4bu6mwI8IkAxFcPDDVeidgxBKRAhFjiEtng1aW11X88/yuRzoUhlihQylfB7HqzuQ69XIGCdaXgtxfSMKF2yawAg24yE8EdjA7tYG3tUnxiO2SVA8CoVCAYeHh0ymfWZm5kLkm84ztohKhdVqhc/nw82bN1uaHCgUiq4cyEQigd3dXWi12q68X6fTiZs3b8JoNHa89l4CWuC0SkJR1JlyukAgYO0KVc9lttlsDcE5G1itVhwcHJxJNAgEAjgcDjgcDoRCISwvL0Mul8PhcJxbG7abwkE72Gw2rK+vt3XYaoVCocBp/IrFYhQKha73SLK0NpuN9V7m9/sRi8UaEk1Cig+7zohIJNLw2kgkArFYDJFIhJOTkwuX1rtI3Apo3wSU6Sr+0buEjEaM1UMvvhRZh/pooEEGirhEkWwS0UcViUQQl2sQSCXg8/mYfPcDUFpNkCjluO/63dBLuPEOPzJyDfsrTyCUy0Mkk0DKF+IXZ9/GSNmQa8lkMkilUjg4OEA+nwdN04zg/A9i+9iOH0IokyCXTCIVPMZfqSL4sw9+ipX9Xi/amYReoNfrO24G7Xipw8PDCIfDWFxcbMjqsgHb4JM0RE1OTnZdAGQyGY6Pjzu+JhqNMha6reD1epHL5eD3+zEyMoK1tTVsbW1hbGysZSALnGbSKpXKGf6hw+GA1+ttmcUkHbZGo5EJOrxeL3Q6HaxWa8fvcnx8HOvr62eyTfWWoWzLZd3QinZANGe5bITEpSgSiSCzUYZUXMTwgBB6LQVLnxCWoUHAOs/p2vjVBP7NL78TuVwe4fAxDFpp919qAgl8bxscxxMnHvDCEcx88BHQhSJsY8O4Z/YqJPzeMin9VSueLBziJJ/B8P23QSyXQWXQQZWu4ObNmw0l4ApdxSvZINZ3foiRoWE4kjVcGhpj9R3vJI7xOdfTAIBwNoGv7q8gEArhmvCUemCxWHqybG2Hi9qMBQIB43jo8Xiwv79/RsOWNFQ1z4dMJoPd3V0IhcKGSkk3TExMYGNjo2NT6Xk4rxqNBuPj41hZWWGCWjYBcjQahd/vh0AgaBDi5wqz2YyFhQXY7fa2z4hUi8hhgHBye6WQnedwMzk5icXFxbZqMs1g27RLIJPJWDVKcsnSEg10onrUDIVCcUZXOpPJQCQSQaFQIJlMolwus7bVfaNxK6B9E/DSsRehbAIKbT8qhQJEMjE+/8qT0I4VUS2WmQ1dqVRCLpef0Uedpmmsf/8YG8oslEY94r4gPjxzJ+dgFgD0Ejl+c+bt+FZWjJGxSUxqzWc4chRFQaVSnVmoSqXSaZC7G0EyeIzQxh6OVjdx+8/9GPgGDUq1KqToPvC5EPOJZW61WmUViBJZtFYwGo2QyWScebVsdWM9Hg/MZjOrxU4ikaBYLHZ8jdfrxdzcXNt/DwQCEIlEiMViePrppzE0NASHw9FRRN3r9Z7h4wKn343f7+/aqCaRSDA8PMwcELa2tgCcBiLtyq3T09NwuVwN0lD1lqGpVOpc/FmCZtoBW81Z4DTQj0QiTEZCr9fDarVCZfoVIPo5FEo1XJmSYdtbRPL4boz3sw+UQqEQdDodxGIxxGIxPJ7eO+IBYEChwztEVjxuySNbLEBZ5uEdQkvPwSwAiPgC/Nrs2/AXS0+jaNBDTvPxS1cexZTR1lACVqlUeDJzgNVUECfBALypKESUAH80236cEtA0jaf9GyjlCkgchRBY2US1XMHT2hA+9v5PQSa9OGcmglQqxbnE3AkikQiTk5MoFApMgDUyMoIiH/hqeAuB/Zdgt1rxkeFrcMq0DDVqZGSEsySdQqGAWq3uaHvaa4aWQKVSMRbWly5dQgYV7CSPYczEziQ5AoEAjo+PodFoLiR7Tg7KoVCoq5kPcVAkFTCPx4P+/v6O7lnNOK/EHWme7OSwV49oNMqpMkQytGzAJktLbJNtNlvbrHLz+MnlcpBKpUin09Dr9ZBKpbcoB7fQiHgpd6pwUMghl8wgE0lAJJNApFZg2GjtOjGqlQoeVTrw2Mx1pCpFFOQh3KvpXRsvn0zhvpEZDJi4vYdIJILBYMD4yCi2sydQGrUw//h7UEwkgUweuFZlNcJKpRKrCeL3+3F8fMwp+OwWkCkUCoZXm8lkWPGQOjXAEUSjURSLRdY8zW5atIFAAAaDoeO98Hg8HB8fo1qtolgsMlar7VAoFFAsFttmVIaGhhiOFRs0Z219Pl/brO3U1BRWV1chEAhgNBqh0+mYzEAymbyQgLaZdrCzs9NWc7YhC5vJQCqVwmAwYHZ2tnE+1n4ambwEUu23QKksmLz/IwilrKwz/aT5pz6oZsOV64RUKoUhqRZ/9q6fRTafw/6eF3K5/Ay1gysMEgV+wn4FlOMaJBLJaSnS2FgC3js+xDMv3jhtANrag8Zuhs5uwdcWf4D7TSOoVCool8sMh78eFEUhsO9FOhPB4SvrSIfCsMyMopjJYX19AyqlEkqlksmAXURm9aLGVjMkEgmjYbuxtYnP776EgkKE9MkJeGoZfue7X8LHLXO4fXr2XA2pTqeT4ZK2c5E6rxGCQqHA9PQ0vvjM43iRH0ds/xDPipK41zyCD9kuwe/3I5VKob+//8LcswisViuWlpZYu1NKJBKMj48zATZx4bPb7V0D7Fwu17OSSv3nO51ObGxsdG1+5GohLJPJzpT/26FbljaVSjFNud0y6PXrUSQSgcFgYIx5JBIJqtXqLcrBLbwGk1QFulaDVKnE7Acegc5pg4jiw2myQsDv/kg2NjYwNTHJDMyM2oa9vb2eXUxisVjLLB1bXOJp8GSuAlmfFoo+PSRyKT7aP4v19XVWGo7dgk6iXWs0Gi98AQVe49W63e6eebX1KJVKPUlCtQMb8f5cLodUKgUAuHr1Kg4ODlAoFFAul9sGSx6Pp+NzJ0Em17JcfdY2Go22zNpSFIXZ2VksLy+DoiimMaVSqSCZTMJqtbL+vHaopaJQvfAlRB7/T4BUBkw8CE2dHm59FhY4pSh0cosDAPB4iFXvhn7yQeDVLIdZdhoErK2tteVyEwQCgTO6tb06SxHs7OxgZmYGPB4PCpkchUIBMzMzWF5ehlKpPFcAlc1m0d/fD5VKhb29vTNyQDKlAvoRByqlCvwvLkN0aQy1Wg01oQBarZYpW4tEopZjsGTRYPNbX4JxwomRt9+JciKDB26/C1cnrjA0p6OjI2SzWYaaRCpXhM/PBplyEQtRP7a2XXj46p14vbRWJBIJ5FYTErsVJDf88Dx/A8MP3om+QRsw2HeuZwGczpvx8fEzBh8XjbKAhxcFcZzsHaBSLKOQzuJru0+BGozhHXO3nasprxMEAgE0Gg3n8jyR+BoYGGBUWcRiMRwOR9v5fFHZeoPBgHQ63fEAmUgkOH8WVwdJkqU1mc2o1GrMz4PBIEKhEGupMdIjolAocHJygomJCYhEIkYzv1KpdEyUvJm4FdC+Cbitz4EX1EacvCp9IeBR+NmJuyFiEcwGg0FmMSeod/jqhSTPhnjeDn6/H6VMFp/7yC/gS099G85LkxhTG2F+Va+SaDgajca23Kh2GVqikgCgZ90/LhgdHUUoFOqJV1sPl8uF8fFxzrzgdvbBXq+3I6/M7/cjHA7jwQcfxMnJCfb39xGNRvHwww9DKpWeuZ9arYZisYhisdi1YW9kZAS7u7usbDJboZWPu0ajgd1uh0Qiwfz8PBYXF0FRFDQaDfzHQeRLxXM/6xpdBf1P/xGmXAR78RSK0QTmyt/Bsd2BKF/JlNJaZmG7IBaLnSkdkkz/xsYG0ul0S9USmqZxfHx85mCi1WpxcnLSU0Dr8/nQ19fXMGYkEglyuRyjmUksoXtBfVe2zWbDwcFBw731SZUwShSIIouBO+bQ5zyVJLp3dAY6TefgjaZpSEIpfOzaA/jKwg+gNxphkvXhYamtLc2pUqkwga7X62U2fMLnJxnd+vuNF3P47PJ3kSzlEfXtYVlWwKcm78UcC11X0nhH/pBDYqlUYv5bX1kRCAQ4KedRo2lIdWrwxSJIlFJkTuJIhKOgrefn8KpUKsjl8gbKzkUjkk+DLxZDZtDhB3/8PzD+ngdhnRmFash67qC8GxwOB1wuV88HPFIpSqVS2N/fR6lUwsDAAPN+qVIBTwW3sLO1jVnnGCw1a8/ydgROp7PjAZKN3W0z2FQC68Hj8bBUjOKP/um/oFIo4DZhHA8JTJDzRV0tyOtBXD9lMhnTP6NWq1EoFKDValGr1V43xaLz4q15Vf9/Dh6Ph3faZ6B2WrFQWsBHr78XWnH3gJIEBa0ydYODg9jb2+MceJyHFO/z+ZDJZJjPnNZZcK2/scROFhdSDrJarWcW4VKpdCagJvSC11sloRmE87q2ttbxs9sZIRBJq14aI1oZDLQyUSAoFArY2NiAVqvFtWvXAJye6u12O6RSKZN9VavVWFtbg6q/D1+NbsOXjqF4GMaPX3mg6zWpVCpmUevFhpag3sc9FothZ2cHlUoFFosFs7OzeP7Gy3g87YUneAg+D/iIQYgPOS/3pHdYKpWQP9xD4WAfhUoF/++zLrx7ZgB8PgXd5iIc7/rJc91Lu9KhQCDA7OwsfD4flpeXX3O+q0SAahK+QAVWq/XMxqLRaLC3t8f5OgqFAiKRCPPsCXQ6HaLRKAYGBjA5OQmXy9WTZibQ2ERlNptx48aNBnMBPo/Cv5h5CH+x9QMcA5AJhPjw0FWMaTp3jtM0jdXVVZjNZgzJZJiR6Jms3+LiIlL6VMs5RDJ4zfOS8Pmz2SxCoRDDPZRKpfhuxI1INgoI+KhRPJSLZfzlyrP4t/OPoVQqMXJoJEitL9lTFAWRSMToAQuFQiiVSohEora6wHSNxg8qEaysrWDi7Xejb8QJPs3DhMKAhYUFKBSK7pWALhgeHmaoB6/HQV9UriG6sw9KKMDln3gvlOY+pEIniEn8CEtNTEXl9YBIJIJYLG5w5OsFKpUKMzMzKJVK8Pl88Hq9UOg1+B/Ha0hXiogEvdiVlnFClfHx0dvOfd2dDpDxeJyTNGcveD60ixvVE2RP4hBKRHhl4SZS9kH87iMf4/Q+CoUCkUgE0WgUer0eyWQSfX19iMfjTJB7K6C9hTNwqvtwojSwCmaBU6rB+Ph4y4VEpVKhUqlwDlCj0WhPJ26Px4NSqcQ0HJGMVzvYbDZYLBb4fD7cuHHjdHIrJPjvWy9gecMFvcGAn56/H6MiDdxu9xlNxl7Qq/sYybatrq7CaDS2bMBoZYQQi8WQzWZ7pn4Qw4b6zXpnZ6elZmYgEEAoFMLExETLjbE+2yuTyTB/+TJ+6ct/igyfhrRPh0Q2g384Xseg2YJhVefMwdDQ0LkoLc3Q6XTQ6XTMAW1lZQVfC7jgDweRS6VhGBnEk4db6JMocb9ltCFLRjzFy+VyQ7aMgAQggkIagmIJPAA2jQxyoQByoRB2iwmicwQSqVSqK+/O4XBAqVRiaXER47rvQkX/EyoVGtEtAa6/8wsAGg90ZD5z5dESBYtmGAwGbG1tYWBgAAqFAhaLBdvb26y50ASt5k+rpp0+qQL/5vI78EpFj9tYzNn6YJboedZnr2ZmZrCyssJJu5rw+ZuzerlcDtnIFvLpDMKbHoS3PZh49D6khAKcDJxAKpFCKpVCrVYzAeq5A7Ua8GBND/Nt92J5cw2jSgM+PH4bbPJTTeBUKsXIWxmNRlgsFs7rVD314KLmJXB6SPJ4PKhWq/iJex7Bd8I7ONn1QaRQ4PrwJH509E6Egkfw+XxQqVQdzWLOA6fTeerIdwH3JhKJGLnBv7v5DHbX1iFUyJA6PoF+dBDPh3bxroEZ1vtwOwgEgpYHSNLk3cu44sKvd8WOwAOQOo7h8MYyrn78/TjiFVCmq5xcA+VyOVzuLaTzOYwNDWNnZwfDw8PMelCtVm8ZK9xCa7DttGxFNWjG4OAgPB5Px672ZsRisba6pu3gdrsBoGGDZOO+Q1EUnE4nrFYrdnbd+NzjT4DWv5oBLBfxB9/5Mj4xdgcevnrnhWQd2DabtYJAIMCVK1ewvb2N9fX1M9JbzR2oRL7nPLxZmUx26pbzKjKZDGiabghwSVZWrVafyczVQy6XI5PJMIebSDED3oABOIpg/atPwH7nPHg8HtZiwa4BLWnIOW/GpBkka2sZsCMVXkItTGPr289h8L4cjKkMHg9lIXcmW2bJ1Go1+vr6IBKJWo6VWq0G+uAebPzwOfz49THweBSUCjmWyyqYfL6OFI5OiMfjXd2sgNOgXTEUwOpzX4ClT4BsnoajvwYc/gow9B2A1zguiY4r22pEKBSCVCpt+TyaS5UWiwXJZJJzibqV/XCnph02ZdvmYBY4bdSqr0CIRCIMDw+zarTpBplMhmnHMA75JVSKJWjs/ZDrtRi02DA60oOxBgtsbGxgYmQU9xmNcAkMGBkZaUgyqFQqTE9PM/a9pDmSqwufSqWCWCzmpIXaDpVKBV6vF8lkEiMjI9BoNJgFcKnfgecqr2BidAy3W4dB8aiGSsvu7i5KpdKFO3mRILlXGl0rUBQFWZ8W+iEb9l5Zxf73X4ZMpwZFUbgpWsSQoR9yuRwKheKM1jpbtDpAkkxnL6jns3ZCNBrFyZ4fJyEf1HYTyulhVMplZEMnWF5YBI/Hg0QiaeCft1o348Uc/sv6s1hcXkCtRuNHpO/AWJXX8F3QNH0roL2FRnA5sXWiGtSDlC67NVnVo1gscsroEg275hJ4Op1Gf393a0bgdMPSD9pAB7VIHh5j45vfh+XqFOxzkyiY1RdWQuPyPbTD+Pg4gsEgFhcXGzQjZTJZgxbtxsYGRkdHz1WKkclkCAaDzP/v7OxgYuI1IXtiIkGcXTpBLpc3mD+QE7rcpIfMqEetUkVk24ucgl3z1cjISFcNzF5QKBRwGDxE7igKkUqFmQ+8DSpbP3TWfkyZh3BttH3Q3gk8Hg+Ft/00yvEyJqQlLB9nMPoTv4x+vQV+v5/Ru+QaCMTjcdYNa6LqJuYnZHjy+RieeimDP/zNAaAaBSphQNj4HlqtFvF4nFVAS5yYOq0H5EBDxsn4+DgWFxehUqlYl7pbNc0IBAKoVKozFstsqiFEl9loNDLfO5Hsa14LdTodTk5OOkpUscW7BmbgThwjXPJAPzaInOcQP3XvB871nu3g9/shFouZ5kcej9c2aUFRFCwWCywWS4MLHxs9Z4LR0VGms5+sTVyyes2Wu82qLMOqPlQsI7Bq+kHxzj4jnU6HSqXCrJFyufxU3u4CDr7EMptLgqYTaJqG9CSLE18QOocFyh99DEq9FiZrP+6cvYJS/tSiul5rnZgKkUCXjXsmOUD+cNuFPSqHgHsPj87fDq56I2W6iq1MFBveOK4MjsGpbKw+kIZJchD+8O0PIrTzPLLxJGQKKYqZHD5859twfeK0alIoFJBKpZBOpxEMBlEqlUBRFKRSKWOa9Ge7L+Iwl0ClVIJQLsPT+y5keXpcrRtPtzK0t3AudKIaNIMsAmy6UDOZDKfT7/r6OhQKRctOTi6WfsBpgCUQiyA3aKEZ6IdYKkXyIIQTeRA5EztR9m64iIAWOF2gFAoFVlZWGNkTkViESDCBAZpG4OAAarX63FxfQhMATk/ccrkcMpkMpVIJGxsbUCqVrFUeSIcqgUGiwCWdBa94NmEad0JjMYGqAmNCLW7cuAGTydSx9CmRSCCVSs8EMr2gVCohFAohHA4ztsSfePt78HX/GpR9OhQSaQgpPh62tnalYgvPvg9jH/4UhAoF+IuLqGnN4OF0jhD6y82bN5mMFBuwpbGUSiX49stIHOQxMihDsULDvV/A6KAUoM5WMjQaDfx+Pyue3fb2NmNL3A5E15fMSaIqwaWUn81mWz5rh8OBjY2NMwFtt2oIafSpz+6Gw+G2zT+jo6O4efMmNBrNufimYr4AP2G+hLvvNMFo64dymkLk4AjQcneI6oREIoFYLNagPiAQCFhV4YgLHwBGGYSmaUYZpN2zpigKo6OjDdQD8pnd1ol2lrvN6KZtKxAIGIWBevOdXukUBL0kaNqB3OsV+wh+wazHXzz5dWiddlQDYfzy2++HQioDpLIz4530D2QymQb3TOBVRYu6YLd+z6oaVfjDr/wPaAasSBwGsaek8QsiAeYNdlbXW6pW8Ier38Pm4R7oSgVPJPbxsZHruF1rx9HREaLRKGQyGaxWa8Ne/5vyR/G11ZeQkedwx/AUZMdpZs1q5T5I0zSjkBMIHuKVpQWAriG04ob19mkUM3mEFKcW3GKxGMBp9euWscIttES3xY4N1aAeBoOBmXTdFpKTkxPWpRCXywWVStVWp5Ur/08vlmNa0YdnNncx+c77EfccwDo1hvsHp5ky1nkXxPNQDpqhUqkwNzd3qlcrofDVuBv+LTf0R8u4R2jETz70rnN/RrpUwFYiBHHsEKldP26/dh3BYBCHh4es9APrIZFIGiRfeDwefn7yXpR8xyg6lehTqfHugUswy04pH8FgkOnSdTgcLbNDw8PDWF1d7SmgrVQqTBBLBNTreWbvhBF9MhXWTg4R2t7DJy+/AyZZ71meVCoFiqKYQKhZGqve6cntdjPuap0OUmxkflKpFGNIMTD4cYz2vYRcKoRShQ+arsKX+zAc/LPBGdvAJ5FIoFarde0A1+l0cLlcZyyGR0dH4XK5WEk+tTukEq5pfQa4mznK6urqmWAW6C42z0W4vhPCx2HcNjXFBEaJSBThcLit+QdXkHHUTDnqpi/dCvXKIEdHR10byTQaDY6Ojpj7IfJ37b6vWCyGvb09Vpa75B7YatvW0ynImiKRSGCz2Xo68A8MDMDn87HW825GJpPBzs5OQzLADDMU0ylMzF1CNhpD+SQNqFrPp3ZqG8BpxjOTySCbzSISiTDrrUAgwN/6FiFSyeG7uQyhXIZKsYR/dN/AlMrEfN/133vzM3j2yA1/JgaBWIRMMo1M+AT/afvv8X9deRSDtoGGxsx62ORafNBxampisViQUCewurraVuWArJEKhQL9/f2wnYyiSFdA0xXIjAZUkhnoBrRnlJBu6dDeQgPYBIBEoJ6Ns1E9yCLQzTIyHo93VUUgZcJWmxFBLpfjrJTA4/FwZ00H/R0P4hgl1IRa3KN1YszmAGynAVA4HMbq6ipTmuPaWVsuly9URF0kEmHs0hR+8R//K4rVCsqFAiK+Azw3zMcDTU46XOFLx/Anrqfg8+3gO0kvNBCBLxRAr9L0pL3baiPl0TU8YB49QxugKAo2mw02mw2JRILRjW22lBSJRFCr1awDAZqmEQ6HEQqFQNM0DAZDR0eh630OXO9z4GZGdK5gFgB2d3cbAqW+vj4cHR2dCQRFIhGmp6eZjU8sFmN4eLjlNXY6AIZCIQQCAUilUgwODr4WeFS/BPrwi6CyPozPPYZ1X1/bMrpcLu/IU6ZpGm63u6NbHEG7rJpGo4FWq4XH4zmXpezg4CD29/eZ9aNTFs3lckGn051ZP2ia7io2T4Trt7a2epaOq1QqjFU3wfj4OBYWFqDRaM6d/SO84FZSfecxOhCJRIyBRbdGMnI/Op0OfD6/5WcSy12xWMzJcrfd+3VC/ZqSyWRweHgIt9sNg8EAq9XK+rMNBgO8Xi/nhEmlUoHH40E+n8fExERDMJbJZKBRqqAVy6C1ynDjxg3Y7faeZBYlEsmZNaVSqYAX2wSfziN5cAy6UoJcqwEtiGNLfrq2krW5+b8ENwIbiEYPkE1n4f3+S7j6Ux+AbtiOgYlRGGWd97T6OaXRaGA2m7G5udmVusHj8fD+wTl8eW8BIpEEMpkciXAc7xu7hlwyx2Roz+uw9nriVkD7JqNWJ4DcjK2tLdZUg3oYjUZG5LnTJO2WxW3VwNEKvTQL+Xw+GLQ6XHe+FqzfuHGDuSaBQMDwywqFAo6OjuD3+yGVSmG1Wlmd9guFAmftv27YjR2Dp5KjdHiMhS98HVd/8v1IhyL4/soN3GcZA5/PZ/jRhBvY6e/k2f6PnR+i8OqmEd72IqfTYHkwgU+N9q700MylCwaDXTmjGo0G8/PzbS0lnU4nvvfD58EvnYDi8XDFMHCmOzgajTLSSX19fZiYmOB04GknicYWhK7R3IhDNI1bQaFQYH5+HrFYDKurq9Dr9UwWJFkMIJhdwOb+Ph6+48eY3yFcViIC3zJI4GtAaz4OKn8EKMYxPQ2mCaj5WRAebbu55PV60d/fz/p7USqVSCQSZ+aKw+HA6upqR/F6Ng57RHmCPK9W1RCXywWNRtMygGfTSAqcBjXxeLxnPm0oFDpzAGtVqu8V29vbsFgsLZ9bLxnaVujWSEZRFIaHh/HEzRewmY5ClQ/ioZFZDKv6Gmx5x8a407nOa6erUCgYNy9iekDWdzZas1arFQcHB6xd70hVy+FwtKTeNR9MHQ4HvF5vz1ngZggEAlwZGMHjm4sYvOsKqsUStDYL7rINY3ac3Vgr2DTwuV+B9CQBvuBuUEIBpCIJdOLuzmbVarVhX7dYLMjn8/B6vV0pTQ9Zx6ETy/CNk6cxNjgFtdgOu1IHd+g1Hd1bOrS30BKdAtVgMMgQtXsBWQTaDeBu5VOaprG8vAybzdY1G5dMJlk3hJHPPjk5OZMpbLewkCyN0+lsOO1rNBpYrdaWC3S1RiOWTcMp7J2ukMlkkE6nkclkmHJSpJxFMZ2FwmyA4+4rEMllkOnUMBtMUCqVoGmayTwVCgXUajUmQ0R+XqvVmL8TrK+soFqrYe2fnoRUp4L5R9+BFL/9YYcNSGMQGUPhcJh1U1crS0mNRoOyRoa/O1oDohuQG7T4hm8N/2ru7ZCVgcPDQ+RyOeh0OgwNDfXMgybC3r0Kq+/v77cMUgQCQddAjTS6BINBLCwsQKhNYbv631GlK/DG4qADS7jH8FuIhyrIZrOwWCxdM+jN2SXi4iUQCBruUafTYWNjo+XGncvlkEwmOTXlER5tq8PfzMwMU8puddhopXDQjPpycKVSOfM+hKbULgiNRCKs143z8GnD4XDL8aDRaHB8fHwulQDSxNmuesXn8y80o9WpkSwu5eGvdl5GpViGqmDAjeQh3iNzop8v5cQTb4ZAIGhQdDnPtZPkSKFQwMHBAbxeb9cmOLPZjIWFha4BbSqVws7OTlcqRXNjp9FoZGhCF9WQ/B7rNJYXFhGzm1FIZ2Eq1PBjw+yTE3eZhrAZD+FJ3yH0Q3Zkg2F8+q53szJfaqUTS+hibKpr8wY7KrZpTJjGcVA6ANDYPF6r1W41hd1CI8hka5Wh7ZVqUA+LxXJGBL0encqnlUoFy8vLGBwcZBVUcGkIq1Qq2N7eblk2ZbOwkNM+cJqJ29vbQ6FQYDqnRSIRFqMH+KvtHyKw5Yaj7Mc/m7gbU9rWG2e9IHt94CoSiSCXy6FUKtHX18cEZ3StBo+qhkX/LgYuT6OUy8Oi1uH+kWlI+L3zdSfpQ4TScUy/7yHQ5QqKyQyyuwFsijd77hquD2gJLaQX6gJp+IhGo/jtJ76IXD6DQjoDSiREIpHGH/n+J37uykOw2+0X0t2sVqsRj8d7CmiDwSBjudoMnU6HWCzGKnghMkR/+fzP4CgchkzFB12lsesKIqX4U3zw+r9lHSA0B7QURTEOacQoADgdc+0yYVtbWw2KF2yg0+ng9/tb/htFUZienm5rupBOp7vyhevLweVyuWENWF9f78i5B04DEC4WqoRPy4WCQzq522WUWqkEsEUqlUIwGOx4yLioDG0rNDeS/ccnvoRyvoBj9z5y2QxkMileHBLisw9/9FyfQ7RHLxISiYR1Exzh3LeTnSN7SrVa7erwSBIJzeNhaGgIHo+Hs1ZzO+y5d/Gbj34EQrkMQA0by6sQgn0QSL3qHmqKFDE0MwnEM1Dl2CU4iO5tM2ZmZrC4uAiJRMJqna6voNTr29+iHNwCJ/RKNWhGf38/AoFAy00lHo/Dbj/bcUmC2aGhIdbNP1z4TRsbG205isApN4+tSgNpniBlOJfLhVgxiy8cuyDSKgG6hnylhD/deA6/Pfso+MVKy8CVaPPVB67tQPF4+IXJ+/ClDI2wMos+hQoTlPpcwSwA/NTYHfjMt78IZX8fBGIxeMcJ/Np7PwpeoYzDw0Nsb29zkvMBGpUODg8Pz22TKZPJUJGLUUkl4HthAcHlLcx86O1Q9Nsv1NtdpVK1DcQ6gabpjgdBEoCxzcZRFAV1fxVinQZf/4tNaIxi3PueQZjUQk7ZrlbzgwS1S0tLDTJsRHeyfhwGAgGo1WrOGW8STLWbnzKZDAMDAy35dZlMhhVdh1SC6g+h6+vrUCqVHYPZQqHA2Q9eIpEwCgts+bRHR0cdn3ev1INSqcQczDutfefh0LK9DiLFlKtVUKNpxL0HyEdjuPZTHwTk3L7jVjgv5aAbmu2xFxYWzpg2WCwWfOHpb0GSs0IplOBByygUQgnjKDk8PMxqv0qlUi1pLjqdDvv7++dyziQIhUIQi8UNa4TdbmfV11KParUKm0KLGZ0FtIbGwsICqybpdlTCeqWTS5cudb3PZDLZtsJ7qynsFs6g1aAIBALnohrUw2KxYGFhATab7YwwcquyRKlUwsrKCie7WS4LAGma6bTwGAwG+P1+Tu9bX4Z72r+B8kEJ6Z19bH/nedDVCii+AM9UNLhtYIx14NoJfIrCJakBE5fvgUgkwurq6rlNBxwyLT4xcBWyYSuEFB+KVAmxwxCcTifzvtFoFDs7O6wVIGQyGRMYJhIJzhyxTCaDWCyGRCKBUqkEqVQKm0ILjEigsRqRDp8gexSF0TzU8323Qq8baCAQgMlkarvYymSyBuUHNtBKnFhyv4IHPuREMloEDxR0Em7NVDRNt5S5EQgEmJubw8rKCqanpyGTyaDVahGLxZjxSTrde63WaLVaJBKJtnPOaDQimUye4afm83lWc6SiFON3v/plJGtlDJ44cZ/AiEv9gx2DWQA4Pj7uKQNvNBoRj8dZm0REIpGuNI1eqAculwujo6Nds7oXFdDWyyul02lks1mm0U2pVEKpVOLeuSv47soNXPnoeyCQShDbPcCdd9577s9+vYNygmZ7bFJ9s1gseD4XxHejHsjKx5CoVXjavYIPKoYw0G/llLHvVJkcGRnB7u5uz82HwOl8baURTWyju8nt1SORSECrPXWXoyiKNde3E8dVJBKxtsNutQZwbc57o3EroH2TQNL29ZQD0vx0HqpBPSiKgslkQjAYbNisWp1SC4UC1tbWOMtDsQ3kMpkMQqFQR3crAlL+6UVQWy1VQNnfB6leC+u1afAoCuoBC+bn5uHs4i/PBfUZqbGxMbhcLlb31g5erxezYxOvbfJ9p572er2e+X5JJqNZAcJsNrfUqhQKhYhlU/AfB1kdUFKpFOLxOOLxOCqVCuRyObRaLSYmJph77R8exB+vPYWjWhV8oRBT02O4jPN3zTeDBLVsmw9omsbx8XHXuVNvCcwGxuw7oZLtQWUuQq4UIRNQYX7m46x+t/7a2m0CRGVhfX0dc3Nz0Ol02N3dZebrzs4ORkdHe95E9Ho9IpFIx0Pk6OgoY7rAZe7nKiV8zvUMcmIeMoEYvLwajqQh3DbXned7cnLSczNW/fV2ojpxodlwoR6Qbv1uc4qu0TjIxZHKZGCwmCETsKM0VCoVJnBNp9MMf5VQoPr7+xn3vnrck7ZhV7WPqOZ0zkzr+zGaFpw76/h6UA66od60Ydu3hy9//3GAohDwBqC2m8EDD7F7pnEvy0Yxgng83jbrqFKpGN3ZXnWPO2nG9/f3c2pui8fjDVUSo9GIQCDQ9Xl2WzcVCgUGBwfhcrlazkGyXpEYpVQqnaEbvFWD2lsB7ZuI5kGxtbV1xmL1vLDZbEyWlqD5lEqCWTYOVM1IJpNdS5M0TWNzcxOXLl1i9Z4ajQb7+/s92R7O6q2wy7XYju7BOOaERKOEIpKDJF0ENJzeqi2aFxSJRAKtVsvZWpSgVCohmUyeOXkTT/vmDES9AgQp0y0uLkIqlaK/vx86nQ7ZchF/uvEcfuh6GdTOC7h7ag6/VHUyTQU0TTcEsDRNQ6lUQqvVwmq1tl0QdRI5/u3Vd2E/FcXW6jreedsD4FMU/H4/bt682ZXDxhakMYwt7cXr9bKys9XpdIhGo6y65f1+P4RQ42fv/0vEi/ugeHycqKoIH8Vhs3XvNiboltWQyWSYnJzEysoK5ufmkPftoCatIMpXgsfjncuwQ6VSYXd3t+vryFhTOa3YiYcQS4cxUylDImhPpdlLRZHIZUGJBHA/9UNc/cn3Q2bWYzMRglHaueG0VYWILSiKYsWn7UY3aH5PNtSDcDiMYrHYNUtWqlbwn9efxcqBB6VMDt/K+vArMw/BoWwcz81ZVxKMkKyryWRiNZ+i0Sjy6Qz+w3t+EunSaQCsFEmQyWSwtrbGVAB6wetNOej22VqzCdqhAcT3fPA8+zJGH7sPjrlJlHjcmmbJPOw0F0dGRrCzs8NKp7kZ3aqrpGLK1nY7nU6fSRKwySKzyaIaDAbkcjm43e4zY7lUKqFYLDJrby7XKNn1Vm0IA24FtG86yImHTIbzOOK0AkVRMBgMDcFW/Sk1l8thfX295wWv1aRrxubmZlux/nYYGhrC3t4e5/KPkOLj03MP4/Mn3wBl0MBpMOFtD01g37MHl8uFqampcx8YYrHYmUXL6XRiYWEBRqOR80bt9XoxODh45udEh7LeF7zVa5oVIDweD74ddcNPFQEBH6VsDpu5KP5u+Tncp3EgmUyCpmmo1WpotVrOGoxCio9RjQlJ2QH4r36XRLN2bW2tJ0vZZiiVSiSTSVYBbalUQjweZ5UhNhgM2Nra6hrQhkIhJBIJJrgxSMcAAJohmnnObJuI2ARvCoUCI85BLP3xb4Af9iKzoobnJIurv/QZVp/RDmQD75a1EYlEiKoE+OzX/weURgNKuTw8y1X86/lHmcxiqVRCIpFgMoeeeBhJ/yGEMikM407kY0lItWrGZrkdzuNtT0D4tJ30NWOxGKeqQTfqQSaTgc/nY1VBe/xgAzvJY4DHQ61WQ6ZUxOdufBe/OnI30uk0Q30htqN9fX1wOp09BfmZTAb7+/sMtUIpem2dVSgUuHTpUk/VNwK2ph+vB0qlEmL+QxT9RxCr1bjy8fdBadQjuncAmXaEUwk8FosxJfx2kMlkEAqFLeXuOiGXy3WtQLarmLZCO+47eX7d9KrZgPDnm+lGJKCtbwgjfPe3OuXgrXtl/wcgnE8jlEsinjn1ZGZje9kL7HY7Dg8PATSeUjOZDNbX13Hp0qWeT+/dBngwGGS6VLmgvvzDFRK+ELdrB/ALlx/CO+zTpwHY6Cgj/9LLe9YjHo+fCbQIx8nj8XB6r1KphHQ63ZZPaDQaGf3GbiAKENevX0eIKiIZCsP71A9xuLSB6K4PywdeaLVazM/P49q1axgdHYXBYLgwTUGFQoGrV68iHo9jfX39XJugRqNBOp1m9VqPx4OhIXY8XqKZ2gnRaBTBYLDlYYqiKIyPj2NjY4PV5wHsNwH13g04SicIpgq4cRCBQyUB9fh/R+2cwQTh5XZCma7im5FtSNVKRD1+UAIKvkAAf/38d7G4uIibN29ia2sL+XweWq0WMzMzeN/9b8P83Dw0FhMG75iH0qRH9egEhnznDE4kErkQfWhCsyHSWfVIpVI9JQdGR0eZJrd6VCoVpsrE5ll6IkdIh08QXF7H2j9+B6H1HRweBUHzTg+/165dw7Vr1zA9PY2BgQFoNJqe5mGhUMDm5iZmZ2fbXpdEIsHc3By2t7e7joN2eKMDWnJfLpcLFpMZv/sjPwspXYO8TwexQoafeeR9mDM6sLCwgGg0yuo9I5EIq4PU8PAw9vb2OF3vxsZGR8c7ApvNhqOjo66vy2QybVVGSJb2IjA5OYlwONwwLkqlEvL5PBPQ5/P5/y0UDoBbGdo3BbVaDU8f7uB/1gI48C7jhX88wacf/uDrdvIRCATQaDX4/tYKstUitEIRUqkUtre3WXU7tkM33b5cLtdV1qYTei3/FAqFltdlMBigUChOF8lXS/a9IJ/Pt9wsCceJC1WiXXa2HpOTk5xdjfQ6PWiZGNmrM+BLhBAIhbAPDrAu4bNBKwMEiqKYRXJhYaEnGkv9e3dDoVBAPp/ndF9EzqzVdaVSKezv77e1igROD1tSqZR1E1GtVmM3t08OYVBKIaUo/NmLW/h377wGKnoCQzYJvrJzZqkT9Ho9Dg8POx4qM+UiKjUaPD4f2995FtZr07BfnkFNKe74Xfza7Nvw9f1V7NAiSEo1/Ny734mo/xCrq6uYmppqGaTlcrkLq0SNj49jcXERGo2mYc4dHR1x0sYmqKcemEYGkSwXYJGpsbu+CafT2XatbOafl6NJ8CkKA7fNQyxXQCAWQgwKJkMfZ3WHdqBpmqGKdVsXRCIRLl++jOXlZVQqlQuz/L1oFAoFeL1e5PN5DA4OMvNaQ9P4OecdGJ6dhkIogvTVqoHZbIbb7UYwGMTY2FjHvSybzbLKUEskEsjl8o7GI/Xwer0wGo2s1vxWFdNWiMfjbbPJ5Pouyrp5dnYWS0tLkEgkp0o2r2qlk++yUCjAZDrtP2FD23gz8aZe1XPPPYf3vOc9sFgs4PF4+NrXvtbw77VaDZ/5zGdgsVgglUrxwAMPYH19veE1xWIR//yf/3MYDAbI5XK8973vRSAQeAPvgjuWTg6wFj+9xkIyg5pEgL/xL6JMvz7E+ypN43+lvfh/n/8GvrD8PP7L5rP4nz94EnNzc+fiO3Zy+qFpmjm19jr4ZTIZBAIBUqkUp9+LxWJtAxyJRIIrV64gnU73lEXsVrqdmJjo6EhVj27ZWYJesoIfGJxHpVCAUq+BfWYCMo0KzhjN+bvsBKlU2lZw3Wg04tKlS9jZ2YHP5+vp/dloeO7u7mJkZITT+xLDgWbkcjlsb29jdna2a7asXSavFViX6dR9KFXKUMhE+FcPzYIHHtJVYHl7Fzdv3sT29jbC4TBnPqNKpUI2m+34mnwsgYz7AHSpjNt/4aNQGftQzOUxZurM95MJRPjoyDX81t3vw9v1Q9CKT7VRLRYLlpaWzoy3TCZzLoWRZhA+bfNcTqVSPXOP1Wo1ngzt4NNP/C3+aPV7+MWv/hmOanlmntI0jUQiAa/Xy2SvDw8PIRaLMTU1hWvXruFTb3vPKRddLILGZoJMrcYnb387Njc3sb29zWrcdMPq6iqcTifrw4FAIMCVK1cQDAZbZrXfTBQKBayvr2NjYwP9/f24cuVKwxoeDodhMhrRJ1UwwSxwek+Tk5NMk5PH42m5ZpRKJU4Z8OHhYXi93q6vy2QyiMfjXVU96uFwOJiKaTu0qgI2X5/P57uQjKlAIGAaU18JefHl7Zfx8okP8WIOwNkM7Vs1mAXe5AxtNpvF3NwcPvGJT+BDH/rQmX//gz/4A/zxH/8x/uqv/gpjY2P43d/9Xbz97W/H9vY2k47/1V/9VXzjG9/Al770Jej1evz6r/863v3ud2NhYaGlVM5bAYfZBCgAuUwK2995BvqRARxk83ie/zKMclWDfWr9n3Y/b2epSv68eLyHnUwUQpkUMe8BlCYDFvty+HFeDefxRUmn021PkcQO8ryb18jICDY2NjhleWOxWMcSNAkQSRaRC3+4m12nTCaDVCpldXr2er2sS+UqlQpqtRp+v5/V4nm1bwAfUo3iUO+AUq3GXZeHYBYpsLGxAbVafSH0FqKZ2i7rQQ4PXq8Xy8vLmJqa4iReTxrD2gUmmUwGNE1z5gXqdDqsrq42dBuTDfXSpUusrpFYje7s7HTlebPdBGpX3o61J76FcaMaMoEAS0dxXP2JX4Nw6tRhiGQBXS4XKpUKpFIptFotDAZD12uuoob9eBhGpaah2z4ajWJ/fx9arRa//b6fwH/bfgHZchH5kwSuDYxCHc6i0t9dbaKZZ2kwGKBSqeByuWAwGBCV8fAt/xpC/kNctg5hjJ7oyrVlC4lEArvdjueXbuJYw0f05ARmWoheTaNvRnzYEheQ2Y+CrtLIJ1P4p+A67BI1CtnTTb4b/1wlkuK3r7wTCxE/8oMllLxB3D9yOk6i0ShWV1eh1Wq72pO3w+bmJqN6wgVEi5SMIS6B2OuBQqEAj8eDcrmMwcHBtnO9HQWIQKVS4dq1a4zDn9PphMFgQLFawY3IPnyBAAakrd+7FQQCAXQ6XccqDNdmZwKKoqDT6TruEd0SJwKBACaTqa3OPFfIZDJ4JRV86VtfBAWgRtfw7xe/g//7yjsa1q9OutZvBbypAe1jjz2Gxx57rOW/1Wo1/Mmf/Al+67d+Cx/84AcBAH/9138Nk8mEL37xi/j5n/95JJNJfP7zn8cXvvAFPPzwwwCAv/3bv4Xdbsf3vvc9PProo2/YvXCBUigFXQNkChUsV2cAHqA06nB5ZhZSvoAZNMTVpP7/639WrVbP/BtN02fsVl8MbiMW9SHiD8L33A3c9+ufBAR8xIpZKITinu8jnU63lCAJh8OM68t5IZFIIJVKO2Zdm1EoFFgFqEajEQrFaZBns9lYlY+bpVRaYXh4GEtLSzAYDG0nPsnOcjEkcDqdWFxchE6n65qVoWkafZQE77zSqEM5Pz8Pv9+PxcVFTE1NnStDL5FIWPFcnU4nEokEVlZWmI2GDboFtLu7uxgbG+NyyQBeC77IwlypVJjSLZfvQ6fT4ejoqGtpsp1zTzN2vH5YP/FbUBfCQCGHYYkeOxUKpOWJyGqROUd0gre2thhpHY1GA51O1zD+FyJ+/Kn/ZdCBG1AatPjYyG2YEmmxt7cHpVKJ+fl5ZvP8D9ffh8NsHB7BJh65416k02ksLS2xOvQ1S6KJRCJcuXIFjy//EH/x5PehG7LhJHKMslYKvvtlfGL8rq7fCWuopPiLp14AXyFBIZmGzGSAImDGI7bOzk+lUunMn5d3l5E6DCKTSOLlP/syrv30B5DNZAClFFfGJ1hv5jKBCPf2n1YPPCUxE8CQQDQUCmFpaQlGo5F15ztwqr5BURQrpY5WIEHt5uYmvF7v69a70Qm5XA57e3uoVCoYGhrqeCgtFAqgKIrVQZM4jbndbuzue/HNYgAROo/4XgBKiwG0To77+9npcdc3+rZ6Nh6Ph5PRTT0cDgeWl5dbBrS5XI4VLYUoGLExW+iGMl3F9xP7kOk08DzzCgbumEO+UsJTh9uoHx1v5WAWeAtzaL1eL0KhEB555BHmZ2KxGPfffz9efPFF/PzP/zwWFhZQLpcbXmOxWDAzM4MXX3yxbUBbLBZRLBaZ/7/IMiwb3Gly4kmJHKAoiGRSGEaHcLUkR/okBu3rcGKOu4V4+RkvrDNjGL7nGuK+Q1RzRejF5+OxtTpFFgoF1p3AbEF8qNkEtO34s+0gk8lw5coVbG9vIx6Pd3VoY6PqIBAI0N/fD5/P13az4NLIVI+pqSlW9p+hUKjt6f+iFAlkMhmOj49ZvVaj0eDy5cvY2trCyckJK21VlUrVtjkjFotBLBb3VAGIFTxYSv0pVhZTMGntkIbux9XpB3ridY6Pj2NpaaljUw+bTYCUgK2OQQCDAIA+AMcuV9vDnEKhgEKhYDI0hUKhQZBeJBKhJhXiv3pfgkApQ+ooCkokxH/81pfwS3MP457Zy2fmilwowpjGBKElh5OTE4Y6sra21tWNSaVSIZFInBlPAQkNZX8fAjfWkY6GITNo8f34Mh5RDkJY95012512+nvzz77hXobIoMLRxi5KiTRsBi3+58KzGK+ecgJJ53YzXUMkEkEoFEIkEkEsFkMikWDAbIWiGoNALgP9vofBoyjQlSosur6eN3O73Y7V1dWGOWk2m2E2m5msoslkOmOC04xwONygvnEeTE5Owu12Y3t7+0Kd/jqBSyBLwNXlkNAQ/mHjFWwubUColKFUKEAgkeDLnpu4w+iEmN899CGqBK2yoIlEAvl8nrNZTf01KpXKlodhNmoM5PqazRZ6DTjzlTJKhTxK2Rwim3swXz3NOifyWQgErzWnvVnybWzxlg1oQ6EQADBkZAKTycRw8kKhEEQi0ZmHbzKZmN9vhc9+9rP4d//u313wFbOHmC/AR4avQui04u80S/j0lUcwqTXD4/F0bKbgCpqm4Xa7oc9V8cDVO7CePe2UN40N4e0SK7bXXD1n6do1hLlcrgvX0iVuOGxI+tFolHPjE2lkCoVCWFxcbKulyqXcYrPZcPPmTfT39595r14amQhIedXtdnfchILBYMdmOqJI4Ha7EY1GMTExwXnMSSSShoNhNwgEAszMzCAYDDIZ4k4BqUwma8vR3dvb62lTz1cSePrgd8CTJ5E8KSBysA5D/yHuUtzP+b2A03tyOp1wu91tpdW6jZlMJtO2eXJiYoIJmLuNO4lE0tDsWCqV8Ix7DalwFIV0Fqt//x1c/akPQOOwQmjVdzz49fX1wefzwWg0QiKR4PLly3C5XMjlcm0zgxqNpq32q0QpByURoVqgUa1UAIpCqVw6/TteM5ippy1w+fuh/wCp8DEi217EPAfQjTggkorBE/ChV6shEokgEolYjfF36HVYLUSxHFiG/eoUMuEY3j91HZ71TeT6+3vKjIpEIkil0pZySxaLBWazGYFAAAsLC7Barcwz9GdiWIsFIaT4mBBrEfYHem6ybYXR0VH4fD5GurEdSFWj13U9k8kwh9PBwUFONCGu8msERSGgthpxsLCOw4V18AUCiJVyHJ6EMWRkFyDX67jXl93dbjfm5uY4X1M9nE4nVldXz+xpiUSCdV+A0WhscNbsRd85Go3i4OAAVDgNuU4Dx13z0FmNoFGDQ6yCmHptnSBj4K2qRfuWDWgJmr+4Wq3W9cvs9prf/M3fxK/92q8x/59KpWC32893oRwhEYhwj20cK3orRpWnA3p4eBixWAxLS0s9awYSRKNRRmx+fHwcl2s17KYiSJUKGFBo0Sc9Leeura3B4XBw7pZMpVJnZEXcbjfMZvOFa+kCp9/N8vJy14CWy2LQDLPZDJVK1fY76SSl0gpjY2MtRbDZKBt0u85oNNo2wM9kMpBIJF0XNsIljkajWFpa4mR5TH6/l6YEi8UCjUaDjY0NVmoTzRtpOByG+tUghSvCuXWU6Rx4ghqe+coeHvqRIci1NYRzG3Co7ub8fgCY8nE77cpOKgfd5KAEAgGrA0wriEQiDNnskO6rUc7lMfTAbUCVhkAsgrIL1UihUCCXyzVcx/z8PNPU1OpaVCpVy4bI242DeN69BplGCd1Dt6OUzePhq3fA6RjkdD+dMFdNYuVoD+Nvvwv562lU8wWMj41jwNpD8MkX4NOX3oa/jRRgmRxF+SCKB4fnoVAocHBwgBs3bnTNVreC0+nE7u5uy4MYRVEYGBiAzWaDz+fDjRs3kFEK8feRTQBAuVhE1hfCH/7IP7vwkq/D4UAgEMDq6ipmZmZavj+h5nCdc/WB7NDQEOe9IRaLcW7uq1QqCAaDyLgPkI2nMHDnPJRmA/RDNvByJeRPErjpP5WT1Gq10Gq1UKlUbe/barViy+OGxKSHQijGyX4ADoejp/WnHiKRCHK5/My6wdXZrX6fYUtvomkagUAAx8fH0Gg0mJycxO+MD+GPbj6OAz4fFAW8zTKOOYW5Ialwy1ihR5BTfigUapBfCYfDTNbWbDYzour1WdpwOIy77mrPzxKLxYzzxZsJcpoqFArMRCf8SNJMwZXwXSqVsLOzAx6Ph8uXLzNBDY/Hw6i6MUBTqVS4evUqtre3EYlEMD4+zvp0l0wmG77zWCx2rhJMNwgEAmi12q5SSee1eZTJZLh69So2NzcRj8eZ0niylIf70Aerlr1+JjmQ1C9Y58nO1oNk7lQq1ZmF9eDggFMWiTTwbGxsQKlUXqiFbTsQqofb7YbL5WqbIZbL5Wdknnw+Hy5fvsz5M3O5HA68IezunEAsEaDPKkc+U4F3PY5RXhx2Re8ZqLGxsZaubkDnDK3L5cLw8HDHMWs2m5lSM9fNvRZJwVoUQDQ6CJFUAvApqKJ5XNJZu/6uTCY7I0E3OTkJv9+P5eXljtqn9ZhUmfCgqB974/0o82pQhbL4QD93W+tWoGka29vbGK7J8eEH34HH3SsQFssYtg7gzpKGk31yPVLxBN42Ng/ngBM5Q46RD3Q4HOjv74fb7UYgEOgqFVUPmUwGmqY7rlEURcHpdMJut+MXvvbnOInHINapUDhJQOew4/GjbXxSfYHc41dhs9kgEomwvLzcUqaNz+dzCmjPG8gSBAIB1gmKTCaDg4MDZLNZmM1m/Oyj74PA/TJuRHzgURQEEOBX7n4U469aoFcqFSQSCRwfH2N3dxcURTHNfvUVkYxcgN/59legHLailMlhglLhX098tKf7aYbT6Wxoeu4mhdkK9WYLpHm8HQglMJVKob+/v2G96ocE/9x5J15OivDYXe+AUiyF3+9v4PPe4tD2CKfTCbPZjCeffJLZvEqlEp599ln8/u//PgDg6tWrEAqFePLJJ/HhD38YwKn+oMvlwh/8wR+8adfOBiSzJRQKGwJa4LVmCq4UhEAggKOjI06ZNlJu55qlq28IK5VK8Hg8PQUZXOBwOLC0tNQ2oD1vMEtAURSmp6cZbtuyOIubySCiO/sYHh/Fr6kehVnGLns+NjaG5eVlOC5NIFcpIb5/2BN3thkCgQCjo6PY2NhooBYQMwqugY9IJML8/DwCgQBu3rzZlQ5Q/3u9LMLAaxliUpVoNfbUajUSiQQzPwKBACc3tlwuh6OjI8RiMUilUgz334YT+VPIV09A8XkwmOVQyIzQCEcY+2C73c65OiISidpmUtttAh6PB1qtltXhZmJiom3A3AqlUok5FP/uB34aL4T2sMTbgKPPhDGBGgEWnvJ9fX2IRCJnXjcwMACZTNaSniOXy8+U1be2tvDuq3cz1YRCoQCXywVdB1clNshkMtjc3GR44LMAHtQ5EQofY25iGslkkgnQuAa14XCYmaf18oHkADk9PY1UKgWXywW1Wo3h4WFWz2VgYAA+n69rtl0gEEBg1kKrVWDpb74CsU4FHo/CZo6GX2aDQqGASqW6MFMU4DWjisXFxTPfGVv721Qqhb29PQgEAoyMjJxL5aZSqaBSqXR9j3A4jEAgAJFIBJvN1rCGfHL8Ljxmn8amagcjRisGNa9RGAUCQYNSBJFji8fj2N/fB03TkCkV+NzeixAYVEgcHKFSKGJvVIaXwl7caTr/Oi6RSCASiZix1UtGGjhVA1paWwX6lIimTzBYKUNaZ1udSCTg9/tB0zQGBgbajr90MgW7wQyl+DSIrTdYAE6fya0MbRtkMpkGxwsi76PT6TAwMIBf/dVfxe/93u9hdHQUo6Oj+L3f+z3IZDJ87GMfA3C62X3yk5/Er//6r0Ov10On0+HTn/40Ll26xKgevJVB0zTEYnFbnuDw8DATaBIKQoWuIlbMQS4QQf5q2TCXy2FrawtqtZr1htcMrlm6+syHy+XilN3tFQKBgDEvaJWB7IU/2wkWiwUL6SN8+9nnoOo3okbTSNcq+G+bz+EzV9/N7pqFAjyTOcDKt16CRKNC4SCM3x38GWgu4Po0Gg2USmXD9xEKhc7wzrnAZrNBp9OxpgMQ6a7zlN9IVaKVpJhKpcLBwQGA0/lydHTUteEwk8ng+PiYCWLNZjOcTiczLx7R/QesRL6IsmYdOr4dD418ClLB/8fef4e3lp7XofjCBrDRK0E0AgTB3g4PDw/P9D6jUS8jS7Jlx0UuieOWxE58k/jGcZLr5Pp3E9uJ4pL85FiOI8uqliXL0oxmRqPR9MNOsBMEAYIgiN7rxsb9g/r2gCDKBsjxzHNz1vPMMzPnkKh7f9/63ne9a+kA59mGfHx8jJ2dHRiNRlgsFt7vzWw2IxgMXiB0jQhtJBJBNpvlrQOmaRp9fX1wu91tuyBEblQrW3rQMoyh6lmF0GazYW1tra21XCN7MwKDwQCpVHohUpUcQMj/RyIRCASCc9IYqVSKnp6epvcxH/h8PoRCoQvBMLRACBUtg0AggFarxeDgIFZWVjA3N9fRupjP588RqcHBwQshL8QqKhgMXtC+NoNer+eGotqtl/0KHVYPXZj40OMoJNJQWXoxax8HTdOIx+Pw+/2cn61CoYBCoeAGBbu9H0ly4PLyMq5fv849Trv421oiOzo6eiVew4FAoGnxolQq4fj4mFvzp6enG75ngUCAPoUWMvsw4vF4y+cjdlpkD2FZFnunfqRSKRQzWdz+ky9h5N33Q65RY0W6iymZgTvsXAa111Y8HkdfX/vuST1yqOBPDxeQ2MlCKBbjpWoYvzr9GMrxNILBIFQqFa9uQqFQgFj8JhEuFovnvstKpfKOtUMF3mZCu7CwgEcffZT7f6Jr/cmf/El89rOfxa//+q8jn8/jF37hFxCPx3H33XfjmWeeOadj/L3f+z2IRCJ84hOfQD6fx+OPP47Pfvaz7+gPvRYikajlYE2tn2NRJsJXk/tIlc8I8Lv7JjCLsw1kfHz80osIqdL5fD4sLCw0HY6qXYw9Hg96enoupfftBHa7nbMqqd+gYrFYVzZOrXDC5qFzWLH93BuI7bohlNCICYXYUo9CITnTqYpEIm7gpPYfAHjxZB97wjxysQSK6QyUpl784caL+J27PwJKcPnWzdDQEF5+4zV8P3WEWLWE1J4P//DdH73UYxI5AJ8OASG03ZrYE9Ree7WWYkqlkgsF8Hq96Ovra0hM2pHYc69ZpMM9ll/EuCyBcDh8RmZ/AGKNReKGSZiF1WptacNGMD4+fsGFop7Q5nI5eDyejp1ArFYrVlZWWua47+3toVgsnpMbEcjlcoTDYQDA9PQ0lpaWQNN00++O/H6zCrNSqcT169extraG/v5+GI1G6PV6rkjBMAw8Hk/Dzo3D4eAskTohX6VSCdvb21AoFJhvUuGtfa16vR4syzZtpTdCoypZfZW2FmazGUajER6PBwsLCxgdHW25HlqtVhwfH7etkD8ps+FQdgAYtZDrNVCcpPGRR29AKbu4zudyOc6nuJboymQyqFSqjogu0VSurq5ydm1CoRDlcvnCzyYSCRweHl4pka1UWRQYBqenpxfukVQqBZ/Ph1KpBKvVilu3+LkNa7VaHB4edvQ6KIqCvdcMjdWIconB8LsegFhCg60CSiGNk5MT5PN5rnJNNLEymQxKpZI32ZXJZFiI+PCVlw8QO/TjR7TvwwMqVUeV0M+7FyAwqJBe8EJpMcDn9uD/dn8O/+SBD/DuUJBOW20lvj6Q4o7LQQs88sgj3HRrIwgEAvzWb/0Wfuu3fqvpz0ilUnz605/Gpz/96bfgFb71aFWhJaBpGtdnZ/EPvvpHSKbT0A5YUcoX8efPfgOSu5/E++fuudLXVGvr1KjqQMIFEokEkslkx9G0l0ErKxXixXkVINqq4OY+MpkYep1WqEy6M52VQYdevR5M+awlls/nkU6nUSqVUKlUuFYZAHzXt45YNIDkcRC+l5cx88kPIhdLYFnpgl6hglgsvkCK+U5jA2cpcM9XQlh5eR1Kmwn5ZAz/yfUcfuPGeyGtaTl1ChIBSuQAzYZg5HI5kslk189Tj9prz+FwwBDcAvs3/xPFpV6EhD2461O/xv1sJpPByckJEokE5HI5TCZTR/rfVrZgFEVxtkqFQgEnJyfwer1Qq9Xo6+trqgmUSqWwWCzweDwNXwvLstxEeTedFEKYx2euIcnk0SNRQCaiuTa+2WxuWsGVy+XI5/Pc+5uZmcHq6mrL+GudTodYLNZ0GJPIozY3N5HNZpFSi/H5zVfQL4jBEC3iiembDa9lcn3xCaYgiMViXIW6GQlvVEU0GAxgWRZra2u8dL+np6cNq2SNqrS172doaAiFQoEj9KOjow0JpNlsxuLiYktCGwwGIWGA//rUP8BxNgExJYSCEWB3a7uhy4FcLm9IJnO5HJdm1QnRVSqVmJqawrrLBbecwXf2VlClKDwwdg0/PnI38ukzjaxEIsH4+PiVrbsvBHbxpYMl5NIZ0KkCrJMjsMjUCAaDCAQCkMlkGBgY6FiT2+0Aq1xE46POG/jTl5+GcdQBVAFlCXhsYAp9xvOdsFKpxH3ep6enyGaz58iuTCaDQqHgvivymT8f2MHLlQiSu6cAy+J/7b+BKoCHLBe1wwzDoFAocJ7JxWIRpVIJK6uriObTOHXt4mRtB9c/8R6Ieo0dzeCQg1wkEmn6M2Tu552qo33Hamj/vw5yg0kkEl7WR9FiFkKTDjQYfO8//ilM10ZhnR7BQTKCYDDIaXGkUumVXGzE1qm2SkcJKWzGg9g62MNIjxmRK7Au6QaNrFRyudylFlWWZRGJRBAKhZDP56FWq2EymfCLjo/j3y1+E76NHQzePYvw3iHeY5mAoYdfOIDfIEboSArDuBMCiQSVEgNdnxEDNjuqTIXzyCQn/VpSXL8AkzS4WhLsyyWwe+oHJRFj9zuvYPTRuxAqZLAa8+Nu4+UN0/V6PSdFiUajF7SCUqkUJycnl36eWpBrb/Mbn0Polb+CpMLCtRNFv1qG9LN/gVPn3RyJtVgsXQ8i8t3kpFIpnE4nFxBxeHiIQqEAo9HY0NTcZrNhaWkJmUzmwsa7ubkJh8PRdSVLKpXCK8jj9//6j6G0GCESUPiwfgS6LIuJiYmWGz3RO9f+/9TUFNbX1xtWdIEzHe3R0VFLdxESP/tXb7yIv/j+a2CKJRztlVHO5GAfG8K9aCwD0mq1XNu41eOzLAu32418Pt/0dda/nnoYjUawLAuXy9VW5pHJZBpWWFtVaQmkUimmp6eRSCSwtraGnp4eOByOC765xBmjUUs9kUjA7/dzMokBVQ/3dwaDAW63m/fBjZCnemlJK6KrVCo5shs2SPClZ78NsVQKsUKGlw42cbS5i0+M3XXpYJZ6bMWD+Lx7AQCQjcbBqpT4rW/9BT5ln4PNYu1KC12L+uAPvnjSNoFEzyHETjNC+4f4sYffg23XBiSU8Nx1S6zhGh22CNnN5XIIh8PI5/PcZ/75nZeQE1RwurkHkUwBiVKBL4afg370jLjWrlEikQgSiYTzTZbJZNBoNBgdGcV+Lnq2plVZVIplGGX8HXmAs9Agu93OEdpGnRm+LgpvF+4Q2rcZfDfVciaH6P6Z/+7AQ/MQiYWQ6zXQyBQolUrIZrMoFAool8vn2gIkYUUsFkMqlXIm4oQAt2pB1VbpFhYX8XzpBF7kENk9BNgKfvaB913auqQbECuV2uCCTpLECEqlEkKhECKRCBiGQU9PDwYHBy+QjZ+33cL3qyporSaMjT8Ixsd/4vyJvjG8ETpErJiF1miA0tKLWxUtFFJZxwsrSYkjxJdhGFTyCbAMg0IijciOG5YJJ9LBCFazUsis6aZVgU4gEokwMzPT0D+2Uy9avqAoChO5IxwIhfjKyiHihQKeujEMxfe/jb75912ZmwYZduG7UWq1Wmi1WrAsi0AggLW1NYhEIk6SQDA+Pv6D6eWbyBcYsGwVfv8RZDJZxxZ5tTjKxPFs3o98OguRKodCLInPHPjwXz/281DKO58kl8vlGBkZwdraWsOWvFKpRCaT4fVYG6IsJCoFTrf2kfQHMfTYPfjW0WbL4RkSTKHX6xtulLlcjtNz8/nOW9kKmc1mMAwDl8vVtCqcSqVaHgpaVWlrodVqMT8/z3nL1tsA2u12rKysXCC0uVwOe3t7uHHjRsPPo7+/Hy6Xi5cndyvwJbpPu76PaoXF3ndfRymfR/+tayj1nkUtE217I/Cthtb+3DP+LSRPA8hms9j+xncx89STUBr1cEyPo0+h7ep91qJZ8Ec7RCIR3HSOYmhoCAvxCpRSGebm5rCysgKGYXg9Xiuy21M6RCWZACoMKtkMaLkUCpWuaYW/EX5i6j7838tPI8xU0Ds+iKw3iMcUnenTs9nsuWu/UChccINiGAZCofAdS2rvENq3CcSkv51OJhQKwefzQaFQ4GN3P4rvRg8gUyuROY1Bzgrx1PV7oaKbEyOWZc/FOhYKBaTTaUSjUa5dUYv65BxyIyb0NBZe3IRYKkE6HIF+wI5vRHfxUPkaFOK/e1JrtVpx+/ZtLkudr342l8vh9PQU0WiUm3KdnJxsuXDkonH85F2Pcz/DaM1YXl5uWxEDAKVYit+48V68FjrAdkGK+6ZuYExrujBMwwfkcELTNEcob8ilwBvPQmU24K6f/hgEANQmAz489wR0Iim3QdVXBUQi0QW9V7vFs9Y/1mw2w2azIcOc4DDxErTJJGzKu0ALFbzfDwDOxiiXyyGbzSKXyyGfz5/dHwd+yMoVGDU0grkcWJaFSiK+Ur02idftJozDZrPBZrMhl8vh+PgYHo8HWq0WfX19kMvlyBRo/Nv/8k0kEzG8tlXEVD+F9737wfYPXoPa+7dQKOA13zYSx6cAW8Xrf/g5zP3UR6Ey9sCfS8LIw3mDHKBrNyStVgur1YrNzc2GRI/opNtVlYsVBgqDDtUKg4Q/hujuISpyJfxmPzdEVg+RSHTm87m3C9p89h04VD0QU0IEAgEEAgHejhtAeyJls9nOyT7qcXp6es4msh58qrT1z2c2m+HxeDibL6VSyd1/tQdjhmG419XqgDU5OYnFxUUolcorrZACF4nuoCCCUiKITCSJYi4N48QwVCK6Yfw3X5LT7Of6qhnI2SQK6TQMo04IKAFotRIyYffSqVq0Cv5oBb/fj/HxcQBn9wLpvMzOzmJtbe3SMe/3W0fxhcAL6L97DpSQQjGbx6OzUx0VH0xyNf7R4L1YEPaiz9mPiVsmHG7vtR38JGiW+ll/fd2x7bqDpqhWq9hIBPBC4QQv0kk8Zh3FrMF+zvRYr9djZmYGNE1jvFrFcMSCRckeqN4SRoQqiNschCmKglQq5b3w1Wt08vk8kskkttz7EAqAk5097H3z+7j1Mx9DKZvDK/RtDOiM54gwn+rvVcDhcMC1tw2xWQ9fMoxrkmsNfy6VSuH09BSJRIKrkNW3AZshl8txulYCkUiE69evt9UfEijENB7vG8dYVQkKFORy+YVhmm6QyWSwv7WFX3vkI/hSaAOhdAolfwj/8NGHYPoBuWlWFWAYBplMBrncWcQpGbQg76++skveo1wux/z8PNxuN5559fMIK7+Kw3gcxeD3sS76Ep50/Pa5ISvgbBEk7bZ8Po9MJoNiscgtjhKJBEqlEjKZDD09PZDL5WfES5JH9TufhYACHhq2I19mIJq8BysrK5BKpRcserqBSqVCJpO5lDsGqXICZ9Wc/f19RBNZvLicQDwWQbGYx7H/EJR4HA9mS1Ap6HP3WaFQ4A6X9YdMcogh3tk6uRIStRKKHg0cD9xEIZaEQq+Buk1QAoFMJkOhULhAEM1mM/L5fMN2tsFgaGjfVY85gx1ffP27sM9fRymbg9rci0fsZ0Rgf3+f2yC1Wi30ej33GuQ9Wvzr578AplcDWi5Fr1iG9witMGn1HbsTAO2JFbHO2traupDulkgk2laCh4eHsb29zXt2gFjs5XJnfrYSiQRDQ0NQm3vx6Rf/BlKHCVaZGo44i+mxibbknVgtulyurj6fTvCuvnG8sbkG04QTxWwelFCID0/eden7rhGeHJ7GM3uLkOt06L+phoCiYI2UIcfVDHg3C/5ohUKhwO2hwJmmnNgIEh365uYmGIbp2DOe4LHeQezSLpwapRAIAFusinl553Hk+UQa75me54osMzMzWFpagkgkaru+kbmYWuRyuXMetMAdycEdtMDTR5t4MbAPtc2MTOgIG+FjfEQ9CDMkF0yPgbMhufleByYVvfB4PHA4HOdMma8CIpGoYdVxXinAtqKMSrUKx2/+EjKnYajNvbg5eQ0iFtzmTKq/5XK5of6nUfWXkOBO9VGnojJ+++WvQ24xIBdNINgrxU+P3QdUq4jFYjg9PUUul+P0sN20qZuFFNTqD2vtbVpBrVZzelMyTONyuZDP59uShXqQ6hV57rmBEZQqDNZXVjGhbm/bJRKJuPZ5PRiG4QhoPB5HIBDgBhcJ2ZXJZNjLfRWnByGAFaBUYFCsBPHi9p9gVPFDyOVy50irTCaDXC6HTCZDb28vL623YPoBoFJG7q/+HBN2I7akVkge+AjmjSZkMhkcHx9jb28PRqMRfX19XenrlEolN/l/FSC+litbQZTKbyCZjOCFv/0c3vtDPw//4Q6+83wW/RY1p4UjMiCVSsXrINhXtWGNiWM3eQpVjx4KiwGGcBEOefvsd+BMItKs2up0OrGxsYFAIHCu4mQwGJrad9XiflUfthRG+HVCMMUirEkWn5y8F2JKyN1DhUIBsVgMBwcHKBQKoGka3wjvoKyRIuU/gcpixKbfDfWUCL8+cjev91QLvq1uh8MBj8fDpZ6xlTLSqcSFDbwRyHfWadCFXC7H7OwsYrEYXl+8jb843UAoGoZWVsLtQAROSx/uUd/F67GUSiWsVit2dnaaRi5fBQZoNX7INIlQrwSZdArWohhP9I2/NU9WKONHTTM47aURjIShLQvw1PX7uupmXRW8Xu+59V+r1eLg4ID7M6If39jYgNfr7XgdB4DdnV38whMf4e5JhmHOQnNUqo6KQvWafYqiMDs7i+XlZYhEopafXzQavWD3WCwW0dPTc+7P7rgc3EFTvHiyB4FAgEImi8LGHmi5DIvDMvzWox9v+XtEt6hUKqHT6eDz+bo+HfLFfeZBvLi9iqRCDrleA7laifsqWuQSKdhsNl6LDdF+1v6TzWZRKpU4AlyL2qov0QCTDb8qpPD/33oZcpMesX0vVFYjXthagTiQwJTaxA1jXCaGl2VZpFKppibUtfpDPpWSWgsq4M1J8729vYbVomavaWdnBwAuPCctFKG3txehUOhSLTCy+DX6Tkm1NZVOolzNQEwL8bU/2sTUPUbMPGCBTH8KlVkFk8l0aQsfgUAAwexjoBg1hPPzmGRZLC4uQqPVQalUnhERlkUwGOS0rMRHly9qJ/+vAoVCAaFQCIcHB8hnU+jpseDuRz8MsZiGqW8Q8/Mz6Ld0vzELBRR+ZfoRvBR047UYiwdv3osxsQarq6u8hmaIfKAZJiYmuAo4+RyJB2mrdmOhUIDXc4hff+8Pg/qBZeLe7i6SsfgFD9paf+NCoYCTowVk42n4F9bAsgJc++iTiIq63zj5VpCcTid2d3ex8sIXYBRHcHgchs7Qh0rRAaGk9UDN0NBQ18UEvV4P0aAFqeNFFNIZbHz9OTgfuIWETAB3KsIlWbWD1WpFPB5vm57YLViWPQvFuOchrkK5sLCASqVy5Z7jDMNgZ2cH983Nn5G4obPnUqvUV9LNIlAoFA2HNRuh0fovl8sbuhJNTU1ha2uro4E94MxPWafTnVsrm4XmtEIz7XdtN5FYsDVCOp2+UPDJ5/MXuo/Eh/adWqW9Q2jfJlAUhXKpAgAo5/Jg8yX0zU1BptK0+c3zg2ROpxMLCwswGAxX4gHYDJUygycUdjz15L3IMiX0K/UwydXY2dnB1tYWxsbG2l7kZDKf7+uslz8Q/W+hUMBxKgb/5i7KhRIW//xrmHjqSVjHByGy6DE/cbkEIoJQKNR28EKr1WJgYIAbqmmFZgOAIyMj8Pv9beNEiTUT0eU1gtls5oZo3gpQFMVZ/ZhObcjEPXjyx4chV9IwO9QY7Z251LBKPWrbXiRZrHahpyiKI0i5XA5HR0dwu90wGAzo6+v7OxlaTKVSCIfDiMfjoGkaBoMB73niPmTY/TNT/7ueAFthUcmdQCm5fOSriBLiEesolH0pzJvPNk9KQPFKxWpns0YOWcvLy6BpmtskW9l3EfeAiYmJc889NDSE5eXllteDVCrFgM2OiloGSiREtQokvccwV7uLJu9U49enKmEpsIG8SIhkOo9+SxGx7W+j93r7ooJEIukqjhgAymwFSpMBpVwe7hduo5TJoZQroMxWOnqciYkJLC0tQa1WX/n67/F4YDabz5Eavh66nWJzcxNDQ0Pn7tdaV4Jaa7ja4JVOUZ882ArNQmqaDZJOTExgb2+Pq/q3Qy6XQygUauinrNVqodFoeBerwuFwQ10zcFYYunbtGtbX1xtK5Mg9U3/fNLLBfKcT2nfmq/rfBLM9NggEAmgsRuiH7Uj4TnCrt/OFYnJykjOAf6uwu7uLkeFhTOqtuGUc4DSaY2Nj0Gg0WFlZuVBhvSyI/EGv18NsNqO/vx9DQ0OYmprCPTdugpZJIZbRuPkTT0FnM4MpMzCp+bVe+SAQCPBKbTEYDDAajdjY2Gj7s2SRrgcZMFpaWkKpVMJeMoSnjzbxyukBymwFsVjszH90fLxlNYYYY3fjudgJfD4fzPkPwObQQ2eUw9yvQtavxbThY1f6PKlU6lyQilqt5hb6esjlcoyNjeHmzZuQyWRwuVxYW1tDLBZr+Rztqpb1IBZvGxsbuH37No6Pj6HT6TA3N4eZmRlYrVZIJTQ+8JAd18eMmBnrw2P3juDXfv7DODz0IBAI8P8AWryG+gABkorVqi3IpyItEolw7do1bG1tcfc0icFthL29PVit1gskoTbZrxU+MXQTtFAItliC1toL68QIPuS4htu3b7f0xGyGTjbbYtKPIYcJm/t+PP+qCyxbQTkTAlu5GCJQj6GhoaY+xu0wpjYhvueDSCrB5Acfha7fAiYYQ/E40tE6SlEUJicnsbGxcaX3fCqVQjqdviC3MpvNCIVCV/Y8wFlbX6FQXOisGAwGnJ6eAniztU8OT92+V61Wy9s3u156Q0BIcSOMjIyApmlee8H29jYmJyeb/r3T6UQkEkEqlWr7WPF4vGVnSiqVchK5+usrkUicW2MJGn3GxIf2nYp37iv7/zhYlsVHHDPY163jlK3C6LBhvCzHCMvvlF17epXL5ejt7e1aw9MOhBA0u2GsVivkcjlWV1d5Tf5fFn6/HycnJ/iR2QfwV941FJNpaOwWaNMMVIE0Sr2lS1fmGg2DtYLVakWxWMTe3l5LrS6Zqm80SEYmwf/7M3+NRXEaUrkMLKr4yhsv4JO2WV4enAA42cFb1Ybc3NyERCLBo/d+GJu7A2BNURh7LQgdlJGMZWEwtNch8kU6nb5QeSBdCRKZW4/aUATiQNCqaquUSZD07UM2OApBE8eQRhZv7SQtJwE/Pvjk/LkK3uzsLHZ2dpBOp3lVcZqhUSWSWF+1qtSS6lI7SKVSjI2NcXKaZgM1wWAQDMM07Qi0SvYj6Ffq8a/n3o8vJL6NsdFpXO+xoUeqAMMwcLvd8Pl8nDtAO3RKdOLJHHa3fRgdMKPEVLC+64deq4YJ7VOauq3SlkolHG3t4p88/CF8LbgBj9uDfr0Rn7r3I5AVKlhdXYXRaITdbudFzuVyOTdPwTekohWIrKmRxzhFUZz5/lV0YlKpFKLRaEPpRiPt9tDQEILBIFZWVprG3bYCX4lRKpWCTCZreA9pNBrE4/Gm79/pdMLn87W0h2skNWiE6elprK6utlz7iRa93bVCDvykm0geLx6PQ6fjVwhqFYT1TsAdQvs2QkwJ8YR9AiaTiWs7LC0tQaVStV0gSVWJECOHw4GlpSX09PRcKaEkpubtAhS0Wu2Vap0aIZFIYH9/Hz09Pbh58yZuURRURSDtpGA1GHHDYEc+k8Xq6mrLNCE+aDYM1gpOpxNbW1st20QqlQrxeLzp5yOQiLEiyyN5EABj0CIXSyGtUiBh5J8ZbjKZsLu7e+WEtlAocAle5PXnUmXMzT1yloM+zrT0FO0G6XS6oSZtenr6QsRsIxCdM6mqulwuznLLYDCgur8E5Zc/jXAyDaO5B4J3/SSoyfsAgLM768TijYBhGGSz2QvXIJlQ9/l83KbcTcWjWWtdq9VieHiYl/ygHdRqNQYGBrgwgnpj+lwuxwUANANFUbDb7U2T0wj0UgVuGR2Y73uT5ItEIoyNjSGXy2F/fx9CoZCrgLUC33jbg4MDSCU2TA6fQCwSIF9kzoitehxLS8u8SGWnWtpMJsPp5ZVKJa6Z+nFsOH7zcKM8I3LN/GubwWg0ct6xna5b9djb22sp17Hb7dje3r40oSW62WZ7C7l269v7RAbRThfaDI2s6+rh8/kwMDDQ8O/4xOj29/fD7/djbW0N09PTF6Kvm0kN6kHTNJxOJ7a3t5uSYz7SOAK1Ws11cvrGh7EWD8C9u4WPP/zkuZ8jMbj1IFr6dyruSA7eRjS6MMiQULs43EZt0snJSWxvb1/pBefxeGCxWHht4mRyPxQKwe12X9lrKJVKcLlc8Pv9mJmZgdPp5BYINSvERybvwl3GAYgpIdRqNW7cuIHDw0N4PJ6uno8MA3Rj5TQxMYFEIoFgMNjw79VqNdLpdNPfT5TyENIi6Ib7sf7V76BULkNtNiBWzDb9nXpIpdILDhOXRSQSwfr6OqamprgNtr4yIBKJ4HA4uKG1q0CzjUcqlcJut2Nvb4/X41AUBaPRiLm5OYyPjyMej+ON734He3/6O6BZBtkSA7ZcQvSrf4jNl7+L27dvw+v1QqVSYW5uDrOzs7DZbLwrQu0ORP39/ejv78fy8nJHcgeCVhsyIbXLy8sN29d8q7TAGbnSarXY2dmBXq/n2s3Ey7V+s24Es9mMeDzespXeKsFJLpdjZmYGFosFa2tr8Hg8Ta/tarXa8vUkEgksLS3h9PQUMzMzmJ69C323fhQKyzXYRmbB9Mxh9Oa7cevWLYjFYiwuLsLr9TZ9vtoqbTtEIhFsb2/j+vXrXNGhVCo1PHTYbDbcuHEDyWQSS0tLvNrOY2NjCAaDvIMwGiGRSKBYLLbU4JPvqd0e1Q4ul6vtAcVgMDSUOGi1Wly7dg0bGxttJUX1IF2yZiCzG80KQ3zDkGw2G4xGI1ZXV/FiYBf/ae1Z/N768/jaay+0lBrUw2AwQCwWN5UqRSKRjgpIer0ejFaOf/TFP8ZXDpbxnH8L/275WzjKxLl1pZFlF9D+/nq78c59Zf+boP7iEIlEmJiYwPr6esubplHrRCqVcibeV4FcLodkMtnRiZ9onUQiEdbW1i5l88GyLDweD9bW1mCz2S60mJrddCKRiBsaaqcpbIROTryNMD09jUAg0HChbUcmDFIlJJQISd8Jrn38PVD36hHa8aCn2pm5OJEdXAXcbjcCgQBu3rx5rhpyenp6YSE1Go0ol8u8Nvh2aFYlIDCbzSiXyx3rLKVSKUZGRnDLpoeKprAbTeMzr25j+TiKeK4IqyCHW7duYWpqCgaDoeMFnFSD21XI9Xo9pqamutqU24WyaLVajI2NYXV19QKRlEgkHZGR/v5+VFgWX9q5jV9/7vP45Ze/gP/47S/CZrfz9rceHh5uefjIZDJQKFqHcuj1eszPz0MikWBxcbHhobHZmplKpbCysoLj42NMTk5iYmKCu7ZEch00gw9i+K6nkGHf1BJarVbcvHkTQqEQi4uL8Pl8DR+fj5bW5/Nx1ezaa7pUKkEsbnxvk2n3yclJHB4ewuVytdXXzszMYGtrq6t1l2VZ7O3tcSECrUC8fLuF1+uFRqNp20UzGo1N72+pVIobN25wny1faDSaljra4+PjtnseCVhoB7PZDDeVw+9/84vYjgawsOPCN8K72Mx2ZhU4MjKCQCBw4fBLvudOOzHPpryQ6FQIbu5BJJehxFbwZc8SR2gbpYQBZ4S2XRjU24k7hPZtAjnlNVoglUolnE4nXC5X099vpgWy2WxIp9O8TvTtsL29zSt9qxEcDgesViuWl5e7OslHIhEsLi5CLBZjfn6+4cIXDodbEk+n04mBgQEsLy939HnwHQZrBjIp7na7Gz5vK1IrEYrwQZUTMpkUcp0GSmMP3nv3/dAkyh1tICaT6dKElmEYrKyscNG39cQuHA43rAyMj49jb2/v0hXi+oGwRhgfH4fH4+luIFGmhFElx7RJh3m7ARMmHYYMamiMzZOi+CAYDPKumMjl8q42ZT7T/Gq1uiGplcvlHVeFd6RFvHS4iVQsjshJEEuJY7xWaNyFaAStVotKpdKUBORyubaEloAQzWw2i4WFBSQSCVSrVWSOVxDbfhrxnadRSJzFsmYyGaysrHA63KmpqaYkvNFAJZGnEGlLI2IrlUohk8maHuJ2dnaQzWYbRgu3O7SRx5+ZmYHNZsPa2hrcbnfTe4umaU4G0Sl2dnbgcDh4dSH0ej1SqVRX93gikUA8HuflVtCu20SKF9lslndnqN1gGJ90LRKwwAcLhTBUViN2X3gd4e0DqK1GPHe8zet3Ccjw3+bm5rnPIhKJXPCKbYdSqYSjYz/yqQzCOwdInYRQRRWxYo577Hw+31TKQVEUhMKrCbu4atwhtG8zWJZtuIAYDAaoVKqmrXuapptu4pOTk9jZ2bkUoQgEAlCpVJfS4xoMBm6ykm8FKpfLYWVlBdFoFDdu3Gh5Uo5Go7xsta5fv479/f2Gk/GNnr+TYbBmIP5/Ozs7Fwi9SqVquhgmEgn0smL84Uf+AX712uP4zbn34WevPYL5mzcBnHkz8iEjl5UdZDIZLC8vo7+/v+GgIWmVNiJVNE2jr6/v0rKTdDrdltCSKtb2dmcbBACgbwRwziCWL2CqrwfhbAGwDgPOmS5f8Rk6PRDVbspbW1u8foevPVUjUiuTyTr23r0d9kJps+BkdRf7z78Kjd2ChXD7+6kWw8PD2N/fb/h32Wy2Iy0kRVEYGhrC9PQ0/H4/Xv325xDa/i6K6SBKKT98t7+I2y89g4ODA4yOjmJ6eprX4/f29jasCNYSWwBYXFyE3+8/Z594cHDmSEKst1iWxdraGmQyWVOP6XK5zHut0Wq1mJ+fh0wmw+LiYtMWtF6vh0Kh6OgAHIvFUKlUOmpdm0ymjh07GIbB3t5eRy13PuRxbGwMCoWCV0eu1d4ZiUSg1Wrb3ltarZY3oS1XK5CqlShEYggfHiHo2sWhaxtbW1vw+/28JSJyuRxWq/VcpyMUCjW0FqsF6Rjt7OxgYWHhzNZRqobWasTk+x+B0tgDCgI4VT3nKrSNDn7vZP0scIfQvm0g1dlyudy05eR0OpHP5zuutBFCwVdfWA+GYXB8fNyRQXQz1FagCKEsVRgcZxOIF98kZmRAYHt7G8PDwxgbG2vZRumk1UK0vcVisa3lSzfDYK2et5FVikajaaijLZVK2Nvbw/T0NFS0FGNaE/oUWq7F43A4uFM6H3Le09PTle1RIBDA9vY2rl271lRH3E6WYbVakc1mL9UpSKfTvAI7tFotFApFRxVOABAIKFAf/iXErj2J4Qfejdj4w6A+9k8hEHY/SEUscLoZxhobG4NKpcLS0lLbTbkT+5wLpJYWYT98gmSpNallGAahUAhbW1sIb3uQ9p+gZ6QPIiGF0NY+sqeRjlrbcrkcEomk4eG2VUWoFYgdkV4Uwp4viFeW97C07oEvEIVJmsbMzExHj9tOqkNRFPr7+3Hz5k1UKhWOWFJiEb55soWf/daf4Jde/gL+eO27eH3hNmc32Ax8KrT1IBXqfD7PVajrMTQ0hHg8zot0ETcJPlKD+tfRbFagGfjoZuvR29vL2Xe1gs1m43Tp7bqCzbpkfr8fdru97XM1C1hohHlDP1LHpxi4bx6O+eughBTefes+7nmOjo6wsLCAhYWFcyS30T5ltVqRKuTwuy99A//ija/hv7u+B3/x4hqbSqXg8XiwtLSElZUVJJNJWCwWzM/PY3Z2Fr/y0Adh1RkgkkpRKZbQp9DiE4M3OSlTs/vxnT4Udsfl4G1GpVJpeXNPTk5iaWkJcrm8oc9js0qN1WrF2tpaV8bfOzs7GBoaujLxN6lA7e3t4ek3XsK3yyfIsWc+j49aRvGgzIJAIACHw8HbyqibVsvIyAgnZWhkL9YuGawb1FqlkGQvtVp9obJBqjntiLxcLsf8/Dy3WE1OTjZtoZpMJhwcHPCuurRKIatHJBJpW2UZHx/H+vo6bt26xev569HJZj80NMRZeXVCYASUEPn+azDMz8O3tIQqJeRh2NQch4eHHRODWthsNiiVSiwvL7ec4O40QICQ2i997xl8j4ojcuhDb/4ATw1cx3vsU9xjJhIJRKNRJJNJiEQi6HQ62O12fEr/IfzZ7mugxCKoLWYoenV41H6WKqZQKOBwOHh97kNDQ1hdXb1wUOr0/dT/bi5XAMsCx8EIpGIRJkfkUMg7D2fga+tEURQcDgfsdjuOjo7wO1/7HDbLMRSzOVAiEZ7Z+j7oWw/h3jb3Xrv1v9XzDw0NoVAocN2n0dHRc2vB5OQkVldX20Zz7+zswOl0dnwIE4lEUCgUvPcYvrrZeqjVat5yAr1eD5qmsb6+3tLphnjJ1h7KCUHlqwunKKphwEI9ntAP4kC2g6BBjPCOBx+971FYkixYC3uheJLJZJBKpXB0dMSlSspkMmg0mrPwDIUcTzMnWNpcgaxXhwpK+N315/GrYw+BzjOIxWJgGAYqlYqzFmx0X+kkcvzm3PtwlI1jE+t48vqDEAtFyBQzbV0g3slDYXcI7dsIlmVRqVSaVmiBN/WYjRYm4nTQTBYwPj6O1dXVttZGtSB6tG4m/NthcGgIv/utFxEKnEA72A+2VMIXv/ttiK7dj4/e9XBHN0okEsHg4GDHr8FgMECpVMLlcnEJUwWmDH82jlQ01jRt5TIg9kdra2uYmZlp2PLa2dmB1WrlnVfudDrR29uL9fV19PX1NZxKJlUEPmShVCphbW3tXCxpM5BTOh/tn8lkgsfj6TjdpxuCQ6rXfGKICWpJs06n63hiuBa5XA4URfHeEJuBTHCvr6/D6XQ2TefqeGORivFCNYKI2we2clZl+YLrVYhiWegrZ4djnU6H3t7eCwfa+5RKiAUUvhB8BoYxG8xxBh++fi+AN+30WJZFf39/y7WDJKnVmtZ3S2bJxp/P50GrbZhQnxHqa6M2HJ/GsenLYsLYuV+qWq3mTdIIsc2eqAFvHIcvL4ESiTH11BPYL7c38G/mcsAXUqkU09PTSKVScLlc0Gg0HDmlaRojIyNwuVxNbcVINbrbIVi73Y7Dw8O2nxXRzfKNcq2HXC7nHVmrVCo5C8lmqYqNvGSPjo46ipBvRIrrwTAMDt0H+Gfv/QRomsaSbAmzo7NgGAZra2sYHBw8d7+QFMbaNTiXyyGRSODk5ATe6CmWNpZQYVmsf/nb6L/vBkqZHL6VFeOHrt3L21YQOEscdKoMYK39SCfPXH3a3Yt3XA7uoCUYhmm7AdI0zVX5asv97RKOaJruyEaJTLl2OwjWDrFiDiWpGEK5FK/9wZ8juLoPw6AdJYOy45uk2xYlAC5KMZ1O4ztvvIJ//vrX8P+sPYv/67tfwV/H98B0GD/JByRNjAxr1Fq/kGptp3G1SqWSG45ZW1trqAsjkaWtkEgksLq6ivHxcV6vIRQK8a6O9/f3IxqNdjyExGcgrB5yufxsqrgD7S7RzAGt07D4wOv1drQhtoJUKsXNmzcRCAQaaiHbuRw0QiCXBCukIJLLsPKX38Tp5j7ysSSiKGN2dhbz8/MYGhpqqiG8ZRzAjzjn8M9vvQ+Pjl3nJB5arRYzMzMYHx9HOBzG7du3mzoCAGfSmePjY+7v+TgcEDAMA5/Ph4WFBRwdHcFut2N+fh7TD/4IskIjDD1aCGkZpu75AO55/KMIh8NYWVnpyMrKZDLxanHXQi4+qwabp4ah7jMiEwghvu+Fz+drqtcM5lLwJCPIMJdPWFSr1Zifn4dGo8Hy8vK578ZgMDS8JxiGgdfrbarv5QOlUslFkzcDkVJ1oputR6ffCZGZRSKRhu9drVafGwwj3YlOCjk6na5t6tj29va5SF9iGUbTNGZnZ3F4eNhWtkG0s2NjY7g2ex2944MwDNlBKxRgyxWojAY4xkdgtVq7qvYTcg+8qZFtdsgi6847ldS+M1/V/wbIMSX86c4r+LPtV/GfXM9jM37S8ufVajVsNtu5oRG5XM61JZrBaDSiUqnwGsryer28PWf5olaQvrO2jpTvGGKpBI5H74KsV4X0aRQKYWfPl0qleFcym4GiKIyOjuLr0R34NrZRSCRBURS2MmF8p8MJVL6wWq1QqVR4buk1fPl4Hf/ihS/ivy0/j4Mjb9cyB4qiMDIygv7+fqyurl7Q/1kslpYLptfrxeHhIW7cuMF7AJDPIEItuolm7obQAmct+3w+z3sIMRaLcRUWpVLZlScs0DxI4TIg3ZlSqXQh2rSTqmYul4PH44FnfRuJQz9omRTDj98LuU4DTb8F/WZLxxuU3W7HycnJhWl/Ej1MHAEaDUVSFIW+vj6OqPNxOIjFYlyUsUgkwtzcHKamprh1gBLRKKsncf19vwbL3T8LpW0OYrEYExMTGB0dxf7+PjY2Nni5YWi12o603wzDYDglgEAgQP9d19E77IDSbMCnHvsgRCIRNjc3sbS0xJHbarWKv9xfwL9e/Bt8bv8N/Is3voaVaGf672YwGo24efMmyuUybt++jVgshv7+fmSz2Qt6+s3NzSuRltlsNhwdHTX9+83NzY51s/XQ6/Uc6eILYiFJUdSF2Qki1yPoxJmEoJ1bQiAQgFgsPkeSay3DiBQvFArxmokAAJNMjQGlHrRUBsfd12G9Pg4mX4DEn+h67ap/H8VisaFlV+3n9U617rojOXgbwFar+OrhKioGFYqlEiKVHD698QL+5ex7YFc2j6Azm81Ip9NcxK1cLud1ah0fH8fy8jLUanXL+LxoNMorvaQdSJwhWYA0Gg0sFgvGxsaQsqjx195VFOMpGEYHIUzkoD/NImfK8a64hsPhK5EGFCplFKRC0CoFFv70azDPjqDKVvFajMFAhoJIJIJIJIJQKOT+m6Le/PPaf/hCZtTjf7z8FeQyOUjVCuzt7yE8cwP3XXKB0Gq1uHnzJnZ2dhAKhTA+Pg6RSNRUE0gy0RUKRUdtQJZlUSqVOmqry+Vy9PT0tExQq0c6ne5YpkAwOTnZ9nonKBQK5667TlqbtbjKYcJ6EA/KpaWlM4IrYLEa8UMIAYwWM+gGQ2ypVAqnp6dIJBKQyWQwGo149/0PIWqW47kDFwwDNhQSSUwPj2K+l19cdi2JriWl9d8TcQSw2WyIxWLY3t7mhqkI4bdarWeaZ1MvDsNBOC0XXSFKpRKOj48RiUS4hKNmawSx22pEmuRyOWZnZxGLxbC6ugqDwdBUW0hAul/t1iSS/PWe63fjuuA6Xjv1gNFYoIsUcZfZyb1XMmC3ubmJzVgA34y7IdVqzl57lcVntl/G79z1ESjEnet+60FRFJxOJ+c04vP5MDg4iO8tv44luoAkSlDlK3hPz/CVSMuMRiO8Xm/DIWKPxwOdTnfpgx5Zd7sZonM6nQiFQtz9Q36/NvkuEAh0LIdoFbBQKBRwfHzMuWIQqNXqcwUGcmjd2tqC2+1uO4hNCQT45elH8Zf7C3jFe4IBVQ9+ZO49MAvl2N7ehkql6viQUkvuGYZBsViERqO58HPkZ96p1VngDqF9WxDKpxDJp6CFEidrO3DcfwMikRjL0aOWhBY429zIIIZer0exWGz7fCKRqG183vb2dtfDLCTnPhaLoVQqQaFQNBWkv69/CjaFFt+KVzE7cB0PmIcgKFewubkJs9nMixTw9TBshkKhgFAohFA4jPRhAEKVHDM/+gGgUoHa2IMR4yDsdjsYhuE2SpIeU6lUuD8n/91q8rOeFL8Y2oeAFiMbj2P3uZcw/dS74UmHEMgkYFPxy9NuBhKrGovFsLy8zOkvqzIa33C9AaOxF9f1NrClMjY2NprqM1shFovxzv2uhdPpxO3bt2E0GnmR4ctISkQiEefFOTPT3IKrkTWNyWRCOBzuiNCSLkS3w298YLVaoVQq8fSrL+LbzAkSiQQooRAvFgL4pzNPQCk6cw84PT1FLpeDWq1Gb28vRkZGzj3Ojw3fgjbH4lSThloswQ2dDWKKn6dkvdm61WrF7du3W8ak6vV66PV65HI5eL1e7O/vw2q1wmw2wydl8P989Y9QKTMwOwfwi9cfxYTOjEgkwrXMrVZrW/IJ8KuwkddCYmXtdnvT8Auj0YjT09OW60wwGITf78e1a9cglUqhBzClO5Ps7OzsIBJ5U78rEok4fbp7vwJh4gDRAy+2/vo5TFHvAkVReFH0OgbUvefWjPoDdKP/bwaapjExMYFMJoOlzXV87mAJxWIB2iEHDj1HyMtEuMFcg1TUWWhLI5BEr9rvIJFIIJlMdq2brYfRaEQoFOrq4EjWndXVVW4gmGil5XI5ZDJZV1rmZgcfl8uFiYmJC98PsVOsx8TEBNxuNxeL3ApKsQQ/O3E/7iqrMDk5yb3uubk5BIPBjiKT698HcLaft6rQ3nE5uINzEP6gGletVlHK55EInCIfSeIgK8Za8kxnQ6YaG91k09PTWF5exk42gmc8q9hWV/CIZQRWhbbpcxoMBoTD4Yam0cFgEAqFgvcmzrIsYrEYotEo0uk0aJqGXq+/MGXbDDM9fShZxzBv/4GmSgzMz8/D7XZjZWWlpbCdnNA7PSVmMhmcnp4iHo9zgymz16/jn9j1+NOdV1Flq4jseqB3DuBDIzehpC832ENAyC8hvtJcEALR2UYlqFRRZRikTiLYcK0jKH5zUaQoCjRNQyKRgKZpiMViSKVS0DTN/dMMer2emwx+dW8DX0u6kQpFoHfaIM0x+IjSiXtv3upqeOn09LShLy0fjI2NYXt7+8o2uFbQ6/UIh8Pnho/qEYlELlSo9Ho9Dg8POzowBYPBS+fa84FarcZtcQbBXR+qVBUynRaHRz785+Mv4719E9DpdHA4HC3vY4FAgAGhEk/MzoKmaSwuLoJ1DPC6nxodAJxOJ9xud9tNWC6XY2JiAgzDIBAI4KsvfAdfDm2ilM2jUq6gwBTx75/+An6u/yb6TBaMj493dH2GQqGWh5da2Gw2WK1WeDweLCwsYHh4+EIF0WAwwOfzNbwOyKwBwzBNBxCdTifW1tYaXhe9CjVkvXoIpBI47r8JXb8FlEiE2fFpqIQ0d4Am/5RKJRSLxXN/Vq1Wuf8mIK+jVgdJTPCPimkUS0VED/1Y/6tnMP+pjyGaScCdDnMk/DLo6+uDy+Xi9haim71x48alH5vAYDBgc3Oz606IWq3mhi37+u34XsKLJfc2ZAIRfuzux7t6TDKjUEto3W43jEZj0/uQWIbV7+1DQ0Pw+XxYW1vjFSkNXCSXZrOZ00wHAgGMjo7yKgxoNBrEYjHQNI1yudzUsuudrJ8F7hDatwUGqQp9Ch2yAHR2M6gqBcv4IH5s7n3QCCXcRKjP5wPDMKBpGhqN5hzJDelE+MzTX4SgUkXoRIpXgm78H7PvblnhHRsbw+LiIrRaLUeIGIbB0dHRhdZIPeplBDqdjpMRXBWGhoa4AaVm1cNOYmkTiQROT0+RSqUgl8thMpngdDrP3ZB3G50wydTYTgRxXFbhIxOPQH1FZBbABUnCQ4NT+NriSzCOOGEYHkC1VMbY8CiemHsAQsGbr4u09kulEgqFAkqlEpLJJAqFAsrl8oVTfi3pFYvFoGkadrsd//W7ryB6coJyvgBKJES1XMHxvWNdT+K3ctVoB7VaDYVC0ZJkkudoFGncKUZGRrC4uAi9Xt/w/cZisQtdCYqieNvxEHTTruwWsWoRcnMPlv7HVyE16TD+xP2omDUdSYVqianFYsHR0RGvQ0qj74UQPz7teeDsfujv78eGIA1p9hCZ0yhcX30a8z/1USgMOpinRjGk6UzLWCqVuMolX7SzvWrW4i6VShxxa0WsyJpdW6UluNc0iFdPD7B6EkaPow/p0yh+4sH3wKK5WmeZWmLsF5ehjPcin8pCJJciG4qhUipja9WFvPJsKJUknslkMsjlcsjlct7tfUokxIuhA3zpxX2oVRo4k8B7Zu++lINDPWqT3LolVWTY8jf+6k/hraSRiyUgFIrxh+5X8H9qNLDIL7baW0Gr1cLj8XDXQiKRQDqdbrkekMGwRnKP/v5+0DSNlZUVzMzMtPz8mn0GIpEIY2NjyGQy2N7e5pwvWn1mer0eHo8HPT09KJfLTUMV3qnaWYI7hPZtgEAgwIccM9gT5xHU6GBkxfhn19+FXtnZEIzRaDxXRS2VSkgkEgiHwzg4OEClUsHntl4AJRYj4NqAymGBXKXCd4638NNj9zV9XjJA9PLKAhK9cpTZCpSRHO4autgaKRQKiEQi52QEvb29vNp/l4FWq8WNGzewvb2NcDiMsbEx7vkqVRbhcBhTU1MNf5dUjmvbriaTqS3pHlD1YEDVg6C4B5lYHD2qyw2cNQPDMAjvHeIfP/hBPJfyIlEqgPKG8ctTD58jswA4+yepVMprAI6QX0KA8/k84ok4wokY2GoFG199Br3Toxh9/B6cJDsbriBIJBKXHsYbGhrC4uIiDAZD080ykUg01HB1CiLBcLlcDQlfMz2ewWBAJBJp2o6uf60KheJKN+5GYFkWwWAQpYMTlKgKpj/2bpRzeRSTGZiH+R8w6om61Wrl2u/t7utisdhQbkISwPhWSAFAKZJAolVBplNj6ofeDSFNQ6pVQ9WFhrSbgR6CWturzc1NqFQqzvYqJ6HwuZUXYbFYcY9xAMifVR3HxsZ43QdOpxMrKysXCK2YEuLXZp7A5+MVqPstKHlDeE9f904DzUC6PDRN45rBhko4BY2xBzf/3kdQyRfRq9biQw8+xmmwC4UCcrkccrkcwuEw8vk8d3CmKIojurWEl1wzn99fwFo1gfRhDCIJjXWBADPVGWihvdL3RMJiuv2+ASBVLiBmlKF8EMHhK0sYfvJBMGwFr5we4IecnVWU5XI5ctkc2CIDVgjs7e3h+vXrLX+HDIY10y+bzeZzpLbVoaJV+1+pVGJubg6BQACLi4stJWZk1oJYiTZ6TvJcAoHgLV/vusU781X9bwCZmMaHnWNgnR7Mjs9CXmCBJvsSTdPnSG6FZSFLbkCQyiB5EoX7u6/BODqI7UAKrrIaMpkMCoWCC2Oo3aiyYuBP9l+DMCCDSEojeRKC3mmDntUjFoshHA4jm812LCO4SohEIkxPT3N6oF6nHX9xtAJPKoKM249fsqhxv/lMPE+GLSKRCEqlEqfd7aaKaDQasbS01HVLvRUYhsHKygrnO3g/zrTMfrsf6VAUun5+tkXN0EyGMBwewt7mDm5+6qOQqpUQCoUQhBNYWFhAT08Pent7eX9Wp6enHbkbNAI5VG1vbzclQOl0GhaL5VLPQ6BUKmE0Gi8MXLSyijIajdjf3+dFaA8PD98ymzvgzQ4K2cR//QOfxKe3vofoaRhiuRQmnR7DGXHDSmAj1B8WKIriXaWtH6AjUKvVoCiqI/eRu4wD+MbmG4gDcMxNIXLoxxirgFnW+YEpEol0RKYbQa1WY25uDqFQCMvLyzgVl/G16D4S3mMYigP48uL38EnjNTw4fxd/n0+RCBqNpqHMS0QJMaEyYn7oBgKyAI6Pj9+SdQc462oFfD78h49+Cn/03W+AMmrh7DFhpihD6CTIVRfJAboR0ToLrzgju/l8HtFolCNAbLWKb7i+C4FEjKOFdah6DbDPT+H5w02Ma0xXWgDxIIuvv/gMzMMDuM80iAfNw22rhrlcDplMBtlsFtlsFsFkHOHtA1CiM+14IZdDdN+LvTiLpXgVCoWCk+C1qlJXq1Vkvu9F/KvrCDyXxUE1grEfvbft9aFWq9umGur1eohEIqyurnIa7W5htVphNBqxt7cHv9/fVM5DURRKpVLTz5NUxu9IDu6gIchUrlar7UiHJ6QoTPT24XZgGTd//EPIRxNQGHvw7tmHMNwzwN3AyWQS2WyWO1lJpVJ8LbABgVyK0IEXxWIJPf1W/MHffhn0zOPQ6XTo6+u7dBXuqmA2m6HSqPGPv/LfkKOFEMloVOUS/I+Nl1EKJ6Apn914BoPhSoj3ZSZpW6FUKmF1dbVhcg2pkNlstitfKAqFAu4ta5DotyJbLKBSKGF8aAi/eO1xSCghYrEYvF7vuWp2o2lkVywAXyaOE88ufnJk+NKvS6vV4uTkpOFGDwDZbLZrWUMj9Pf3Y2Vl5ZxZfjQabeqlK5VKeaVFkSGKbofX2j22x+NBPp+HzWY7N3D2b25+AC/vusBWGDwxfQsSSojNzU1Eo1GMjIy0vI6SyeSFKivfKm2xWGx6jw0PD3OhFnwgqLD4oGIA6YdnkCwX0D98F2QnKcTj8Y4m7wuFQsdyg1YwGo0wGAz4ua/9N8QiYaSiCbACQCKR4Mgg6mrCfnl5+cJ1XrvGmM1mbpDnquHxeJBOpzmt78f6r5/rVrhcLlAU1dZ/mqIozvS/HhWWhTq1hXKxCJZhUcxkkY7EESqJsVJdOVdFJN9V7WxA7VwATdNNv8uXgvv4gn8Nodgp8mkVPOkoGJbFY31jHOGuJa6kuiyTyaBUKqFSqWCxWDApkeB1WQb+bAIsU0Hv+CAEAD428wQGVQZkMhlkMhlEo9FzPsJSqfQc2cVeCtnX/VBJFNgLeSEWiyB6KQIMXHTsqAWRTrSDWq3motMbJVsKBALeA1oikYgbEHS5XNDpdBdkCCQoQihsPCR6R3JwB01BLkQyTUhOu3xJzfvUTpyofcjoZJCqFBiIV3G/wQmpRNL0lF0oFMBEtsGmGOSiMYS3DiGXyyCxmTA9PX2lJK4VOnmfGTCgHCZUT8JY+LOvwHLzGthCEbtyE37m1uNX3vowGo0IBoNXZpBfKBSwvr7etE1JURRMJhMCgcCV2j4RO6F33XU/HhdTWPUfIBWJ4V3X74XoB1PtBoOBO0QRvfHe3h6nN9br9fi6bx3fOtoAkysiFQojtv48/sm1x7jH6BYjIyNYXl7mKhG1uIxGrhlIDOiNGzcgEAgQjUZbVvX4pEV5vV4MDAxc6euMxWLw+XwXbK5qoZXIcbdlEOl0GrIfTKhPT09z1l6Tk5NNSXYymWxos8WnSttq8ySbPd9K8fb2Nq6NT557f4yBwfLyMmia7qhrwKeS3hEEAFQSiNISuJ99BcZhB4YeuxfhZKLjhxKJRNDr9QgGg+deZ22lnKIo6PX6pge8bkBs+VQqFXedJxKJC97O09PTWFtbA0VRXX+OQorCPX1DWAh7YbsxAZXZgHQoio/c9yjmei+uo7XyKCKRSqfT3HxAPdkTiUQQi8X40s4ryLB5JINRZFNp6CxmfO7wm1BPpDlJBHHYsdvtLfezX5p+BH+2+xpilBd6iRwfc85h+AfabbVa3XCtLhQKHGEOh8M4fXYT5aMk9oKHcJ3s4Tc/8Ison6RRLVcgELdeH5sNhtVDLpfj+vXrTQsinUKpVGJ+fr6hDEGr1WJjewvqJpK7d7K7AcEdQvs2glRoy+UyjEYjb21QKpVCIZ7Cf/zwTyPHlCCmhMilM9je2mopRpdKpZgbGEVQWMLA/bdgnhqD2mSEqXJW4WEYpuM2dDfoZOBGQolQyuSQTyShc9qh0GrAVqpQK5VviY7HaDRibW3tSghtLpfDxsZGw9N1LWw2G1elvQokEgns7e2da1Xd6hvGdnq7KRHVarXcYpnJZBAOh7G8vYX/tfcSpFo1Stkc5Do19lNhvB465CQf3YJYye3s7JzTRF91dZyApmlYLBb8xV/8BfR6Pfb396FQKDA6Otqw6kBSw5ptIFcZpED0scfHx1Cr1bwm/OuN4YGzSqtWq8XGxkZTS6pmh4VOtLTNMDQ0hOXl5baENhAIQCaTXfjsRCIRN4VeH/PdDOFwmHdVuB0YhkEwGEQwGIQ8XgBr0OP6x98LABBKxKAjGSwsLMBoNHI6Rz5wOBxYXl4+933E4/Fzshq73X7OJeAyIIfoes1kNBpt6N9dS2q7ff6fGLkbVJnBi7Ig7GYr7huaB44iYHsudp7aubTUgzg9SE/XQWUY5CIxMIUCegcdMFitXXmna2gZfmX6UdxXUPH+fSLJIJ+p7YiGP72DTCGLYqWM/bAPo1YnIGx///CJzSWgaRo3btzAysoK+vv7ue+olQ9uO9TKEAKBAEwDdnzm8HU8+/rfQmu34rRPjo8P3gRVszbeIbR30BZkotpisWB/f7/tglIqlbCzs4Pr169DIBBwRty0VguNRsOFLjTDe/uncJJL4rXMWRyuXavHL08/Cp1Ezg1VkTa0UqlEb28v9Hr9lVbMWJZt2tao/7mTAy/6i2IIB/sh1aghkcsgU8hhL9NYWlrCwMDAlZiDExCrm8sSK1Ih5aN/IhtJu+l/PiCpMzdu3DhH+Gma5pWSBLyZJ87oFdAU3MhF4lj5i7/B+IcehSyRwp6oF9fkvRf02Z3CYDAgGAwiFotx32G3CWF8QK7rXC4HqVSKvb09yGSyhocXrVaLg4ODpo91dHR06e+qXh9b/521Aqnw1EMul3MBG9FolPPCZKtVhBPxptdiuyotn0OoSCSC0WiE3+9vejhrZjhPQNLG1tbWmlpi1T5WNxZ+9UgkEvD7/SgUCjCbzZidnYV9chT/vze+iYxcBlouxYjCgF94/CkIIUAwGMTm5iZYluXIbavPRiQScdc6IbXpdPqcRzAhed2EetS/l729vYaH6Gb+3cTcf2VlBRRFdWVBRwtFeF/vGJ54yMndT6FQCGtra5iZmbnUd0ScYh4ensafv/os+u+ZRSmTRS4Sw/WRq7MF6xRRcwUnmQjuHb4BpUwBlUSOg54UjKhCgNateRI3y/ezJul4a2trYBgG+rwU6Ve8SFkYSO8dhkjXuSsMkSGkUin8q7/5c0SEZZQLJYikEjwf2IVBqsTjfW+6wNwJVriDliCalGq1CrlcjlKp1Lbd6nK5msYIOp1OLC0tQafTNdXBiikh/sHkg/iAeRxH/iPcde0Gdwojixm5yVKpFMLhMA4PDznv1lbT6XzBMEzbmyIUCnHk/Dc/9ON42r+FpYNtSCHEj9/1GExyNQqFAjweDw4ODjAwMHBlXqDEJLzbimkqleIOHXw/K7vdjsXFxUuRJL/fj0gk0pYI8IVJpoZUKkWqVMb4+x5G7/AAUGVhV+txcnKCdDoNAFAoFFCpVNBqtR1vxiTFTqvVgqIopNPpK3E4qEexWMTx8TEkEgm+8pWv4JFHHgFwVuFrRGjb6akjkUhbq7tmaKWP5QtyEG72dxMTEwiFQmc+syY1/vJ4HaHACRRiCf5xXw8mdReH7mw2G27fvt2wSlsoFHhZqdVex42uwc3NzYaG87UgMd8ul6ulLOTk5KTrNjkh1rFYDGq1GgMDA+euXZNIjZ/ru4niwC0YDQYcbe5CCAGnNyXpX4FA4FzL3mg0NnxvDocDi4uL515v/c/19/fD6/U2dXFpB7/fj1Ao1PBgVCqVWgYxUBSF2dlZLC0tcRKIThGPx2G327n/NxqNYFn2SkgtANyjsmJXZYVfL8TJ1j4+eN8jGExRvGUu9eikU1iPra0tUDIKD//zjyO3dAKaDmP8XQ8gYxRgcXGxbSFDrVbzjrslIN/RG1/6Lo6XIiixZeROKER30+j58VmIevhp+UnFm/w7XyggQleQPo3j6LUVyA166Af6sBUPniO0ZL2543JwBxdAbm6RSMSJu3t6ehAKhZou0m63GwaDoWWbc3p6mtMKtrroNLQMKbHsXEuhHrVaIpIGdhXShFYLSalUwvb2NsRi8bn38L7+KTygtZ9N2svPXpNUKsXExARKpRI8Hg8ODw/PtWS6hdlshsvl6orQxmIxHBwcdERmgTcPE/VaO75wu90oFApX6oeqpqV4qmcUf3J4DKFBB6ZYwocmb+GxgdlzbfpMJoNUKoWjoyNks1kAZyRXo9FAq9W2HJoSiUSw2+3Y3dnBmE6GxO4abA92Z3JeOxiSz+eRzWZRKBQAAELh2RBcLBbjDg2hUOjcBlyPZgcbMsDZ6QbNRx/LFyKRCJVKpeXPGI1GFMUUfvUr/x0SnQqlbB5SiwJ/uPki/u38B6CXXHR5aFalJVXtdmgVievz+aDT6XitGWazGfl8vmUcaDQa7WiQimXZs4n/QIAjpq2iRjPJFHc4rNpsF94T8dTt7+9HoVDA6ekplpaWIJVKOYN7AnJ/L7u3kaVYVBs0qNRqNWeV1cnawbIsdnZ2QFFUU/lFoxCRehDCRCq1nV6fjYY5yVrmcrl4hwU0AsMwcO+78QtPfAQ0TWNBtID5sXmOMJdKpY6LAaVSCWJxZylpDMPA5XLBYDBw64LmyWGo9AnIpoyQ4WwIrdXcBNC8w9IO1WoVjmMJ3BUG2yf7kPdLUWEryDyzBtnD/ZxHOcMwnB65XipANMlkAE8kEkEqkYLt1cN23yy0AxZQEEAuPn8N3hkKu4OWqE10KZVKsFgs2N3dbUhoQqEQ8vl826xnmqbhdDrbxn52qr+haZrLZydRn7XSBDIhz2fBakZo/X4/Tk5Omorfm02f0zSNsbExMAwDr9cLr9eLvr6+rqudRJ/Y6Qk+Eong8PAQs7OzXZ1g7Xb7Ba0dH2xtbYGm6baVHb6DCASlUgmaTAV/9LF/iHXPHlRiCWadF+ORiUSBfN4sy3Ikl1QiKYo6R3JryZFJr8XxZ/89Emwc5XAS1OGLqH7s1yDoafz91ZJW8m/gTa9M8jwWi4V7HnLoEYvFUCqVGBoaQjAYRDKZbEogjEZjw2Qiv9/P++BA9LGBQAAqlarjBKxmaKShbQR/KQXtSD8Sh8fY/Jvncc/P/xjKbAUHqQj0vRcJbbMqLd8KLdA4EjeXyyEUCnWkd3Q6ndjY2GgoxSEEm896k0qlcHx8jEwmA6PRyGsAtr6iSd6T3W5veP9IpVI4HA44HA7kcjmcnJzA4/FAqVTCYrFAq9Vik8rgM9/5K8j1WlAiEdI9Uryv/3wUuc1mw/HxMe+kOhL0YDabW653sVgMw8PtHUpEIhFmZ2exvLzM228XaD3IaTabuSG1bu3Vtre34XQ6ue+tNnJ2ZmYGm5ubKJfLHR1wOj04EG3y0NDQhcOBVCrlAkuUSiWuX7/OzWI0K7AQGVhHHU+2imqZhZyWYePEDRFEGLU4oUgIOTKt0Wg4ssr3sT9avIXPPP8NDN19A5VSGUKBAO+q80Ym33G7g/TbiTuE9m0C2YyEQiEkEgkKhQK0Wm1D2QHJQefb4jQYDIjH4y21bBRFoVqtdvXaieaT3KipVAqnp6c4ODjgpAlGo7Hhwp9nytiMBcAWGdjYfogpIZdo0tPTg5s3bzZdGNvpQEUiEYaGhuBwOHB0dITbt2/DYrE0bX+2AqnO8SXFhLRcpt1PJqL5TjuTTUKr1fIaYiPXGd+q+ubm5tmmJpXjmsWBaDTK6/coiuKq++T6IyQ3kUhgf3+fs1tSqVRQbXwXw9UYNoIJCCkKyKWQ+9ofovjUr3JTxcQFBHjThkcmk6G3t7ctsSF65scffxzb29uIRqPo6+vDgw8+CABYXV1tmH3eKJmIb5BCvT6220NOM7SSHNRCQomQPY2CKRbROzaMmPsQMq0G9ERzDXtfX9+FKm0+n++oYud0OvGtpVdQNeugFEsg9Scwd61zMjMxMYGVlRXI5fJzz99ObkDkAKFQCDKZDHa7vSM7wkaJhCTmt11Qi1wux9DQEIaGhpBKpXBycoLvr97G//KvQSiRIOYNwHp9HH/tXcOUzgqH6k1yZDabcfv2bV4BNuS65jP9ns/neR+kRCIRN1nfbqCVoF0YitVq5dar6enppj/XCIFAAGKx+Nz3oVKpkMlkuHCH6elp7OzsYG9v75w2uRU6IZNEmzw1NdWw40QINvmMaZrG3NwcXC4X8vl8Q6JNBsM66Simsxls5H2QM0L8gwd/GKF0DIO9dqhuDkDRZQGHZVmYEhX86rs+ho3EKVLBEP7ejXfDqtCe+7lqtXqnQnsHzUEIpVgs5lqjxDaqttq1sbGBqampjojS0NAQlpaWmuoar1LYXStNKBQKCIVCcLlcYFkWOp0OJpMJcrkcJ7kkfnftOZycnKDKsvhu4Rg/pBoCkyu0tBrqFGSC3uFwwO/3Y3FxESaTqSOvV7PZjM3NTV6ENhAIIBKJYHZ29tKfq8PhwMrKSttFjmEYrK2twWq18q7okioCnw3K5/NxUcvA2Sbdzgy8FWpJLgHLskilUogdH+AkmsH39k/gT2YhEAAScRSKWAxKpRJ6vf5cKlEnIENyRAIikUjwxBNPnNvIbt68ia2tLYTD4Qv6TrLpkIqMz+drWekih89sNtu1PvaqEIvFUDgIwKrQImsxghJQ6B0fgjbLIOv2IwJpQ+1hbTWSfBbFYrGj+/P13An+bONl9GSsyEQSMKm0uEl3rjkmA0vLy8uYmpqCTCZDia0gFos17FZFIhEEAgEwDAOz2dz1ATMSiWBycvLcnxkMBhweHp6LDm4Hcs3HdTSk2UOkT8PY+MrTMAz1QyShEcglzhFa8jy1e0Aj1F/XrZBKpTqWhtE03RGpjcfjDVPkakG6e52Q2lwuxxUKaqFUKhGPx8+tk2NjY/B4PNx+2Q58JQeBQADBYLCljI8UC2pBrt29vT3O7aZ+bQmHw7wILcMw2NnZQaVSwT0//z7k/+YATDQHT+QYsmsmyOdbe9+2wubmJldJfhCTWFhYuEBmgbfGTvGqcYfQvgMglUpRLBYBnBGp11YWUVTRMErV8OzswuFwdEz2yKl1fX29adXzrbDhkEqlnK6MSBMODg6Qz+fxef8K4jRQrVRQyhexvrwC/QTwjx78IO/HJ1IJPjcW0SrabDbOd89gMDRtG9aCb264z+dDKpW6dFIRAUkXajXoQIIaGrW+WqHRotsImUzmQnuYpmlev9sJiE5P7nAi6dnFU9edKDIVGJUyGC1WCHm0SFvB7XYjn89zpIbISOoJAEVRmJqa4oaoalutvb29OD09hV6vR6FQAMuyDe/Fq9THXhZEhy4UCjF/Yw5z1E1827+JhVAed9mn8G77JIRVcMlBo6OjF95TfZWWtOD5IFMu4OvedWisJhxvuCFTylHoM+PFkz282z7Z/gHqIBKJMDU1ha+8/BxuSzJI5/MQxbMwjg/BodIjl8vh+PiYO3hcNmSl2XUCnAVIuN3ujge3eqVKSFUKlNJZTDz1BEqFAjJb+xBYrgN14Xt2ux0rKytNCW39dd0Ozey62oGmac5GrVllkqCRv3Ej9Pf3w+fz8SKdLMtic3MTk5OTF96nUqlsOFTldDrh9/u52NhWn0+5XG7rqFI7m9DqseRyOeLxxpHiIyMjCAQC3Gsi95FarW7ppELg8/lwenp6br2Xf+oG2EwJfdsKSK7ZIaC6q5x6vV5IJBLeHUHiTvROJbZ3CO3bCEKWaiu03wnu4E/Wn0dPdg/lRAZP9V3DtLGzFg2BVCqF3W7Hzs4OJibO62Eu42HHF/XShD88WUTEfYy9516B1mHB1IefREbZ2SVISFknBJ+iKE7/GwgEOEN/h8PRcpPu7e1tOaTn8XhQKBQ6bqG1g8PhwNraWkNCy9fbthHkcnlb2QDLstje3r7y99QMqVQK24pBOMwGGCgWbJXF8nEMyqc+hm7Nu0gVSKPRnHsfkUikaToYcNYd0Wq155J0tFottrZ3kM6W4PcdngtSeKv0sXxRLxliWRZHR0cIh8MYHh4+R6o/YJvCQKKK2YE3D14kOWh7exsqlQpDQ0MNNaOdbl6JQh65eBL5aAKeF16D85G7ENk5wHKUQc9pjhtEIYMpYrGY0/vVav9qnzfKFvF8OYikLwSRhIZUq8Fvf/fL+CnLdSglMthsNt6t5naIxWJNrxOtVovDw0NOv8kXgyoD7tXZ8fXtA6hNvVD2aPHg9XtggAQLCwvnXFpEIhFkMtmFKOFm13U7dDo8VwupVIqpqSlsbGy0nNzvpHpH3By2trYu7Eu12Nvbg9Vqbfg5t0rbstlsoGn6AoGsRyvJQW0wBZ/Di1wuRyAQaPr3VqsVUqkUy8vL3OfYbg8m8qze3t4LRSmBQAChSgJDnwmhUKgr3/RYLIZ4PH5hHqBZ0ah2KOydKj24Q2jfJtReLDRNI5VKYSsexNe965Bp1Uj6g2BKZTzTe4xHSwWo6e42SrPZjHg8fmF6/u+C0BJf23A4jEwmA0mOgcZmwui7HoBYJgGTzqLXOtjRY8rl8o43k1oQy51QKISVlRWoVKpzwwa1MJlMTYf09vb2wLJsywW5W9A0DZVKdc6fFXjTDqzbbG8iOWgFt9vNLb71uOpTudfrRTQaxez9D0N8992o7i5AyJRwzTwM10kcN7qw1WlmKg+ctWkHB1tfb0T75vV6sbS0hIq4F3/13AGeW84jHQ/gl3/6g1C+xfrYdgjl0/iT7ZexsLKIIdaPTw7Nw0Ep4Ha7YTKZGg5eNRsGVCqVmJubQzAY5IIVyPVeW6Vt992TbkwwGES2kIe4xEJit2DifY+gd/zsM3987D7MGwfAsiyXEkWsg0qlEjfhTya1a9en1089SAXDyMfTWPvy32LuRz8MtbUXGqcNU4bu262NcHp62pIADg8PY39/v6OujEAgwI2KGlNPfgL7QT9sul48MDINgUBwzqVlcHAQer0eanMvPv29r0M5YIVdqccTxmHsbG41vK5bgVgkXubelcvlXARrI4lDJpOBQnFxwLAVHA4HPB4PdnZ2GmqSY7EYyuVyS9lFq26d0WgETdNYXl5uKssol8sN/7xUKrUd6KoHn7VVr9dDKpVifX2d0z1LJBLkEhnINAqOJJZKJezu7gIAZmZmWkpKDAYDJxnoBIVCAW63GzduXPTxJXrg+oIJ+azfyQELdwjt2wSWZcGyLFeNKJVKOM5Ez+wy9Bp87zNfwsyPfhC5bA4nuWTXhBY40xYtLi6emy5/qy5MkoFNKoE6nQ52ux1KpRK60QH8m6c/D3WfETK9BkVPEA8qOhOyk5vtsiCV40gkgrW1NSgUCjidznNETiqVNhzSI64CV1URagSNxYjfefrLoBy96JWq8KRmAIVwvGM7sFrQNM1JWxohkUggn883fV9EdnDZKmSpVMLm5iY0Gs2b2jiahmD2MQCADMCQPAaXy9WRDVksFuPawY0OPPl8nvdByOFwoMRK8AeffRqUUISg/wAqjQ5/9D+fwXvvt2F4yPG26GPLbAW/v/484sUcqqgimk7iP3zjc/i5qYfw8Ox802uDYZiWYSbEQ9Xj8WBhYQGjo6OwWq340nPfxvPJQ0SDQRizTtgUb+oka0lsqVRCT08P1+7vGXPivyw/B0p09pyPWccw33tGEimK4lKX+CJ3osUbS3EU01n0jjshlEmQiyUQ9B3BTqs6Gvhq+1wNNvNakECR+gpqKyQSCQiFQtxyjMKp0CObzXIEhri0EGK7ub+LLyb3EAgdQSNnsexz43uvvoTf/vBPQanorCvTrivBF3K5HBMTE1hdXb2wBsVisbb62UYgQ3aE1MaLOZQqDNRCuinZqkUz4kWg1Wq519xoTWhUoSWDdp04PHQCuVyOGzduYG1tDfq8BOXvuLFfOYDZbIb6g6M4raYQCoV4x9zylcbVgmVZTkbS6JCrUCiaElqBQNCV3djfFe4Q2ncACLHU0DKwqAIUhYFHbyEfiQFVFoeubeSVJ9Dr9TAYDF3paScmJuByua7MdJ+AYRiuCksqp729vQ1bPYOqHvyE5TroYStEAgrX7rFid30DMaWWtxZULpdzhv5XARIWkUgksLm5CYlEAqfTyX3GRYkIX1x9CUajCbd6HfDu7kOtVl9JNG4zFCsM/sv2izjMxyGNAMfFYywkFvEHn/zFS4VatDrEMAyDvb09XL9+venv10/ydgNCOtst2Hq9Hul0uqUPaS18Ph9isVjTwY1EItHxBpXMAnbnBA721vGNL/wXPPSuH4a2x4hC2X7u0FaLdvfWZf6eoigEsglOd3fw/dvorzDoddhRNKlaXht87NooisLQ0BAKhQJ2d3exnTzFVyM7qHhzECtkOFh+Gv9k+lFoSoKGJLYWoxoj/vnEI/D2BDExOtrQ87YTmAoCUNEMegb7IVErgCrwwF334oZtDMfHx9jZ2YFarYbFYrkUEeE7QDU8PIzNzU3esbu195ZcLsfp6emFnyHE1nuwjuBuEPl0FtEXXoF+oB/iQRsibBFKdE5o23Ul+EKpVGJsbOyCz3kikcDo6GhXjzk0NITdvT389rf/Ej7F2drE+sL49cd+qO31qlKp2n5fSqWS0wHXk9R6EhiJRODxeLrugPGFSCTCtG0Ur/zOV8FWqqBpEcTRKJZ+/6sY//uPdHxQrh9cbQeXy9VyLqfZHntnKOwO2qJ2yvJWrwMvnuxhL3ICncUEWqPCFDR4130PgmEY7oYjFixarRYGg4HXzadUKmE2mzkycRmkUiluQ6coCj09PedIYDMcHR1hamgEVsubVdlOjbzlcnlDL9rLQqvVYm5uDqlUCru7uxCJREgqhfjT4DJSgTC0A1b8z+9+E7923weunMySIRTy7/XwEY5PT0DJpNj48rfRf/8ceoYd2EwEcb+5PbnrBvU+j41ACG23UcNutxvZbJZ3xKvD4YDL5WppY1ZrKt+qmnt6egqTydT07xtBIKggGDhEuZjFo0/+CNR6I0x9ToyODsOol7fscLTrfnT79yWpCGK5FPFDP3ROGxQ6LcRKOcRU6yjpTvyHpVIpZmZm8D++879QTCZxuuNBz+gAyrk8/vg4gV+66928Bq/KuQLGLPZLkVkyGCSTyfCff+QX8PmlFxBR6KFmhPiRvlnodTrof1AdTCQSlya34XCY1wCVVCqFTCa7IAtqBJ/Px7XAAR5rGC2C3mEDJRbheGEdxokRgKJQYjv3/+ykK8EHarUaIyMjWF5eRsGqwWoigOOdPXzKYcZolyTQLS1hPXYMJCgIRUJAVMUXT9bxG5bWwTZKpRLhcLjt40ulUs4Xlkg6GLaCPFPmrKh8Ph8SiURL28h26MRXljlOY9w8iP2gF7//7J/h7z/ww5i0OGEUd17prh1cbQePxwOVStVSStHswFWtVrnP5p1KbO8Q2rcRRN9EpAdCCPBrM0/gmd0VeIXHuOfaDfRVaC46kOg/gTMNTCQSwe7uLkqlEmQyGXp6eqDX65veUDabDWtrax1HBTIMg1AodGYDVChAoVCgt7eXl7aOgKT01J8+OzXyJiEUbxXUajVmZ2eRyWTwi1/7b8gUiyikM2CYEhQaDRbypxjK2c4RUPIPy7KoVCrn/q5SqXD/3QwkZlUoFEIkEiGejqKUK6CQTKOUO9NlxfZ9CGsGwRqdl1pMGunOgsEghEJh22uCz1BZIxDzd4PB0LEbxOTkJBYXFyGXyy9UYviaygNnh7B2/qEELMvC4/GglI7CYbPCXcpjfPoeFPI50IiiRyP5Ox3+qoVAIEBvpgrh8AD6bigQ2fZAaKzgLuNAy99rJzlohKpCAv1QPw5eWkSVrWLy/Y9ApzfxNv1Pp9Po6+te30rav7W60SdNY1CpVFAqldjc3ESv/s12ular5Q7F3ZLbeDzO+/0NDQ2dtY5bEAmGYXB6etpRTPKUzoIvrL+CUiqLWz/3CRRjSeTcx9Bf7yzVivi0XjW0Wi28UgZ/8bdfhGbAhkwmgt9dexb/+NpjGNe2thAkeula/fRrrjVUq0BgZQvpYBh3/8zH4cvGUWHZM1/qJlAqlTg8POT1mmmaxuzsLNbW1vC0Zx3fzwcQ3HLjWVEUTwhNMCu1l3aqIQd+PoRWIBGixJSQLuXwyPA9KJRL8ESPoa1OodOVRavVYn9/v+3PRSIRpNPptu+z2YGrdt+4Q2jvoCGEQiFYluWcDuRyOW7p7ZiWGeAwnMVyCgSCC3nYUqmUm9wHznRfkUiEi6ZVKBQcwa2tzExOTuLlN16FN0RheX8N+zrgg/0zUNTF3CUSCUSjUcTjcc7wf3h4uOuN/OjoCBbLxfx4oDsj77caMoUctN0E0VEQG//zWehH+uG4exY7O7vwUgaOhJLo4trJbPLnJGmoVYZ6Izgqg/hOwoujTA6Dj98L0+ggRCwwrDJgaWkJNE1z0ZqdLiwSiQSlUon7HguFAo6OjnhtuN140ZKuQreaNIqicO3aNXz/lduIFXuQyTHo1ctxa1IPv8/N63FzuRzvlKtAIIDj42P09fXh3nvugkazA4dVAVqmRa9ejnGHGhsbro4t064CPp8PkUgE//apn8IzwV0cpCKYmTNirCiBTtKauHSTWz+k0ON7G7uY/eH3IxuJo1IsYULHP8Wu4xSkGgQCAQQCgQvt31wuB5PJxFVImx3Oa8ltLBZrSW5zTAnfOtqAPx5BNZzAdPU6pGh/X9E0DY1G07KDsLe3B6fz4iG01UBTr1iOx0Qm3B5TIC9g4bQ78BMPzeNw342c0ci7Q8S32twNXs4cQ2U24OCF16G0GiCLJvCF29/D3xuc5wb76mNXyVpY625B0zQMOh2UyKFnoA+G0QGEdz2wDA22jGUHOo+PFYlEqNp68JVvPg2JSgG2wmBjdQ1xkxm///6f6vaj4MDXFhEAKlYZtjN+jJgcGDLZcZIMwzbqxF7CD+lGBENDQx3tte2qw7lcDh6Pp6ODVT1IAe6djDuE9m0CiZAjVRMyJSmXyy8YPhuNRi6zupm3nlwu5/xfgTdlAX6/HyzLQqPRQKfTQaFR45ulAA5edYNlWRQCe9hJnOKfTj2GeCSKWCyGUqkElUqF3t7ehotxp2hWna1FJ56HnXjRdoNSqQSv1wt4w0CVxdxPPQW5Vo18JI656RlMjF69s8E5lCt4n8QG100jlldWMKTuxSeH59H3A7PrQqGAk5MT+Hy+hrnxrVAb0QicmWrXG343QydetCzLYm9vD+Vy+VJtPACoVIVYdlcQCq7A2j+K45Mgbr9xG//8lz8Chbw9UT09PW07rUy0vQaDgXu9pVIJuWwaH3zivGvAjRs34HK5kMvlmibxXSVI210ikXCazY86Z7m/39vbaxgPW4tKpdIRuWQYBjfyUkTHJhAUFEDLpegJFfC+Pn4+st3en0RCAqCh3r9YLHLXLqmQtrv29Xo9d/ioJ7c9xl78wcGrCOZSSJ2GQQmF+L215/DPrr8LojYyDuBssGl5ebnh9ZXJZFAsFhu+vlYDTS6XC++/9QB+TKtFpcpCKPjBZ9BjhsfjwdLSEq/43ng83rVdVzNkMhnEYjEEdg9QLpWQ8B2jmM1DbTSgQgmg0+k4+zW+19snNPdh43tfgVSpgG6gD4V0FrN5CaLRaNvvttO9YCcVQu/IALyvr2Dv2Vdw189+HEWNFPFiHj3Sy+m8+c53kNSxB/7ZR1FZDaOSLOI0wqD/k7cwJJOcm+fgS2z1ej0ikUjDNYBhmI7DmZp9rgKB4I7LwR1cBHE5IP9de7prZPhMrHRakdpakIQap9PJJTJFo1E8s/YG9t17KBUKOFnfgVguw2nOjW9nadw9OHFpU/JGaFWdrYVUKuVIbSthvkwm69iLlg8ymQy8Xi+KxSL6+/vxb37oU/g/vvjfoezvg4gWYcpkR1+MQSKReMuM8xmGwfr6Ou6/eQuPS6VYYXswd/384IlUKoXT6YTT6WyaG98MEokEuVzurG3o9UKn0115RTyXy3Epa3yjg1vB409CRCshFInx0nNfgnPkOiy2YYTjJV6EtpUPZyaTwf7+PiQSyYXpbbfbfc53loDIZLa2tjqK2uwGjdru9RgaGsLi4mLTuGmgswotwzBYWVnBtfEpPKC5D6lyARQEKGdy2Nve4dWaTaVSbU3r61EoFOByuWCz2Zp6P9dusnwqpPWoJ7fPb65gZWMRtFKByMERBu+fw2Emht1kCJO69muWSCSCwWBoeKDY3d29kDZGoFAokMlkLtx7Ozs7nB8ygDfJ7A/gdDrR09PTNK6ZgOwtlz30k30jmUxynT+dToeHZ2/iDd8+xt/zMKRqBdKhKO6/e6qrroVJpsYPKYaQHLyGqojCtM6KEdWZHVU8Hm95f5HPkW/3RyIQIuE7gUyrQf99s0ifhJGPpRDuC0Jls19q6LaZ9rQWJOGNmyN4+Oz7Hwlq4Q8GOO/rubk5JBIJbG9vQywWtyW2BoMBu7u7Dddbl8vFa8alFo0OXOSaqve/fifhDqF9m0E2GalUyp3ualvCteiU1BKQgSutVouwkoJOEEFky434gR/p8TD0Tjv6x0ZgM119tYlUZ/m2OoiRdzPPQ/Izl/GirUdtytPAwAC3OAYCAfzGg09BbNSCpkToU2jBVipwuVzQ6/VvyXDY2toahoaGIJfLUSgU2i6wjXLj9/b2oFar0dfXd25BypZLeCHsxmksgvHMIEzpCuZvXvQsvQyCweDZ8F+bKns7FAoFJBIJJJNJuDZ8OPKcgCmXUS4XUWHKiEdPUGbaD8iRhKv6e6VUKsHtdqNYLGJ4ePgCsSgUCsjn8y0rRBMTE/B6vVhbW8P09PSVdwyatd3rQdwJdnZ2mprA8yW0hMzWBjNo6B8cGvRSRKPRttVgoHNCS6QpnUqOWlVI20Gv18My5ICRDSK0fYDQ+g5EFAWlyQCP+hADEg2va9jhcGBxcRFms5m7BoLBIDQaTdPvrVE1j0T2tqv6q9Vq3Lx5Ezs7OwiFQhgfH7/w3UYikY6ttFiWRSKRQDweRzKZBMuyUKlUnPVi7XP8pF4H7/Y+ElYjRGIxHreNQ3+aA2PtXNri9/sxbLNf0C7PzMzA7/djYWEB09PTDT9L4nTAh9DGYjGoTzJQqVUQ2i3oGbQjvOfBh+5+CGqpDC6XCxRFcRZ2nd7PtYmfjUAGzxp1HsxmM27fvn3uM9BqtZidnT0Ln9nehkgkwuDgYMNrklhM1sPtdkOn03U0MwM0t+56p+MOoX0bUVuhlUql3MRmsVhsSmS6JbXc71NSpPePoLGZce8//FFUWRZiCJDeP4I7U4HdfrlTaj1IdbaT19nK8xC4Oi9aQhgapTwxDIPj4+ML7XLqB9U5t9sNl8vVMJaxW+zs7MBsNnNVjk4HeUhVHjhbvL1eL+dKoO014Pd3XkQgFkH6NIyX3Bt411334+YPpnz5ol6yQMCyLLa2tkBRVMcSg0KhgFQqhWQyiXQ6zd0PRO9o6XMgUtiCe3cNDz7xCYjFNCrFJCInbpQywZbVh1AodG4xZ1kWXq8XkUikpQ52f38fwzyidx0OB0KhEJaWltqaoPNF7WfJ12ZPr9cjEAg07R7wIbQMw2B5ebmlpdrQ0BCWlpbOIotbkL1UKsXr8wPOJBPFYrHtddPoumtVIeWDYZUBCfcRZBoV7vulH0f6JIxSIosBpYFzlKFpmrNMbBY4YrFYsOneg7hXC6WIRqCNLl2pVCIYDHL/n0qlEAgEeNuAESvGSCRy7jsrsxX4M3F4fAeYH2stD2EYhpuVSKfToCiKk6a1k5pFg6f4xXvfC5vdBgEEEAgEiMViWFlZ6ShohGVZnJycNP2sbDYbtFpt07AUpVKJk5OTtu9ze3sbAoEAj95zH24wc3j2eBvZchF9tmvoSZS5blKpVMLJyQmWlpYgk8nQ19fHuxvXyhaRBPG06m4YDIYLAUjAm4PKtQ48jYhtPbkPhULI5/NdpT42k0/cGQq7g6YgNhjVavXc6a5ZjjiB2Wxuq6ltBK/Xi1g0it/8yE/ic55FRLJJVHxh/MZTP4oh9VnMq8vlgkQigcPhuPTprNPqbC2aeR4CZzdbMpns6jURokqITrPF1+PxtHRxGBoaQigUwuLi4qWrkcDZdyMSic5typcZqiGtVZLW9vWFl7DhXgWtlCGwsomBB29hNX2KYD4Fi1zD+3EbedGStnirFmjte0okEkin01wVSCqVcprt2vjVWjx4TYlK3gKJUg6DToZ33XsNGpUEqVQK+/v7YFkWNpsNBoMB1WoVHo8HgUAA+/v7ePTRRwGcH/hqpefOZDJgWZZ3G9NoNEIqlV7JUCOftnszjI6OYnV1tSExrFQqLUlGqVTC6upqW39giqIwOTmJzc3Nholkte+jnXSp1v2Cj2wjl8s1TKRqVCHlg0KhAN/mLn7p/vfja5EdZJgi+vrt+Pj8JHLRBPddFgoFxGIx7O/vc++LEFxyf8blAvzbb30Z2mE7UidhPDgwifkWB0WpVIpMPodKlUWlzGBnZwfXr1/vmCgYDAao1Wpsb29j++gQX8t6EC/nEdraxz2iFH5l+lHIRGfzGKVSiYs7zWazEIlE0Gg0MJlMGBkZ4f3cxLmh/h7S6/WgKKojUuvxeNrGKyuVSty8eRObm5uIRqPnXqtSqUQ2m236u6RjVHt4NYiU+JGhN69dv9/PSYdomobD4YDD4UAmk8Hx8TH29vbOqvkWS8frPNG/q1Sqtnpmu92OlZWVpvd9O2Ir1ajw7NYyHINO9IuV8Hq9XQ+BNZJP1K4hdwjtHTQEuUBqJzb5iK4J8XG5XG3bnY2Smf5Drw1slcXmxiZM1FlLkaRnpVIpHB4eolQqob+/v+N2BYHf7++4OlsL4nm4srJyrlIll8tbtnYaoVAowOv1Ip1Ow2q1tqwGFQoFpNPptpus0WiEUqnExsZGx5GUtQiFQkgmkxdO7wzDnBsO7AYURcFgMMA07ICOCeHw9RV431iDcWIYuVgCLsUWhLZBqNXq9r6ibAWu9CmSkUPMjUxgWm+F3+9HMBhs2BYnFSBSeSUHNdLG5DtwyDAMSoUEfvlTT1z4ebVajZmZGe779Xg8KBQKiMfjAM4GMF599VVsbW1hZGSEV/V4f3+/Y6N4tVrNeV0ODAx0dS2EQiF4vd6uD0g0TcNiscDj8VwIoyDWgI1AyCxfJwq5XM55WvMJvWgEMhjTiftFM7cKiqJgMpng9/t5y4DqU+UeGJ5CkWUgoc5cSwrWs4MFqdzV6sFzuRxisRi2t7dRKpUgoMX4g8PXQOtUiHtPwFYYrFfiWAh7cauBnVqmXMRntl/GiyuvwFR0wxmr4mcffO+lEgBnZmbwL5/5HPa8h1Ca9RBKJNiPnOBPXn0aj+gGOPmSVqvlkhu7hdvtbmptptVqMTw83DJylqBUKiEej/O6hiiKwvT0NPx+PzcUJ5VKm1ZFC4UCtre3oVAo2t7zNpsNLpfrgmMGKaoAZxKO/f19lEolGI1GWK3WhvdTGVXEcmnoZEpUKhWsra3BarXyOpyKRCIoFIq2MxqNiK3EpMcfuF+Cb3MXPTkviodB/IenfqbrvbeZddc7lcgS3CG0bxNqpwi7nRrkQ2pb2SZRAgo2mw3Hx8fnPDrVajWmp6e5aX+PxwOTyQSbzdaR72yn/ouNoNVqMTg4yJ36ifULXy/aVCoFn88HhmHQ39/Py4t0d3eXN6GRy+W4efMmXC4Xkslkxxs8eX2NWo1E/3lZsCwLcSSDqNsLmVqJm3/vQzCOD4IWCDHdP4h8No9QKIRCoQCKoqBQKKDRaKBWqzlixbAV/N7ac9gIeFFOZ/H93DGmCjK8f3gWc3NzXCWYkFfy2jUaDTQaDRwOR9fvpV21HDireI2NjYFlWXzuc59DOBxGJBJBuVyGWCyGxWLh9d3EYjGIxeKuCeXc3BzW1taQy+U60ljzbbu3g81mw9LS0gWNeTPLnU7JbO3zrKysNNx8M5lMw0oqgdfrRTwe5x2wQZDNZpsOl9psNiwuLvJaoxqlygkEAkiFbx4epVIp5ubmsLOzg2QyibGxsXMHarlczmldN4M+FHeLKCQzWP/q0xh64n6kvAHcrrrQx9CQy+WQSqWcrd9nd17FTuIUAopCxONHSi7FUu4UTzTRvNZ6Xdf/Q3yvS6USDoMBVBgGr3/mS1BbTcA9szgyURi8+diVzRvkcjlks9mW66hWq+W6a61I7e7uLm9ZCkGtBMHhcCBBV/FV3ypeEMZw0zSARywj8Pl8CIfDGB8f503cid+1UqlseLAniZIsyyIYDGJtbQ0URcFqtZ51hQD82e5reHrnVcjDqxjqMeH+shbXJzoblHM4HNjf3+clc6gltv/q25/DST4NlmEQ2T2E1mbBNwIb+HntQ7yfux0IX6lUOg/4+LvCHUL7NoG4HHRqdl4PQmpfXVrAkiSLo1wcWlqOjztvgD1NoFwut9w4tFotp++p3whomsbIyAhYlkUgEMDi4iJ3wm9XzbtsdbYWer0eDMN0JLGIRCLw+XygaRoDAwO8F7ZYLAahUNhRBYOiKMzMzMDr9WJlZQXT09O8NupSqdSy1dip1VIjkDb7NfsAPjx+C9/PB5A6jUDCUvjl2cdg0fQCNcVElmWRyWSQSCQ4DSEA7OSiWIvuQyASIhmKInESQlSpwA2DHcmlJEQiEVQqFTQaDfr6+q5Mh823Wk5AURR6e3shFAqxv78Po9HYEZk+ODi4lME6SSzb2dnB1tYWJiZaW7yRtrvRaLwyt4Tx8XFsb2+31WN2S2YJJicnG0qCmg2EMQyDzc1NKBSKlqluzdAq9YqiKPT19cHr9TatHvJNlat9zImJCQQCgXNVwXrY9L1QmgxQmgy49dMfA1tmINNpYNH3gGVZRKNR5PN5lEolVCoVvLD6MlgB4P7eAhQGDazXxvCtl16Adihz7rlr/5v4txJ/axLCIpVKuT/rjzgRyqUw/r5HIKLFkCrkcPY3jzjtBnwP+2q1mpuDaNS9IbKebtxiiATh27dfwp/t3waqLI5PWGwEfVheXMTHrt/fUg7TCOS7JvHwEAggAC7MFxASa7VaOftEr9eLNxJHuF2OQiQRI5fMYOnoBJLZOTzaoeuDXH6WQMhHskOgVqtB2XuhSEmw9T+/CrlOA+PkME5yqY6eux5vtT3mW4E7hPZtBglWAN40R+60kmU0m/Af156F/yQA3XA/oqkE/uXSMv7PRz6K62PtBeEGgwGRSKSp/pGiKC7EIRKJYHt7+4IjAACUKgy8mRhQrSJ6coK7Osykbvkef+DF63K5MDw5ju3kKSrBA0zqrVDRZzc+Id4nJyfQarW8vBrr4Xa7ucz1TuFwOKBSqbC8vNxWS0k00BMTE01fY6lUgkbDX99aC9KO0ul0uHnzJkKhEO6zDuPHht8N184W7CYLejUX2+IURZ0bLiOv9WDzdQgiVST8Qbi++Le49TMfg0yvRU9/H6ZN9q5eIx90U8URCoUIhUJ48skncXBwAIZheCVWhUIhaDSaKyHjY2Nj8Pv95w44bJUFW61y/qak7d0toWwGuVwOjUbTclDqsmQWOFuvnE4ntre3zw2eJJNJ2O3nrwmis75MIEW7wTar1Yrbt29fmMgHOkuVa/S4arUa6+vrDV+/mpbhqYHr+KvDVSgNeoR3Pbg2NoEPTN7VMJLYVj5EupiHeucQPZOD0Nr7MGRyYH76co4jPzF9P/7NX/8ZdHYLJCoFcv4QblS1l3rMWpDuBd/DvlKpxMTExDkbxlKFgZCisLu7i/Hx8a5fC0VROFIJIJLSOFreQqVYgmHQhu1h54Vrjy+USiX0xl78u2/9BU41QggFFJ60TeAD/dcaDs4S+8S+vj585dkdRPcO4V/bAZPPY/6nfgjecqbBs7RHf38/vF4v72RDALDI1Eglkhh66G7kInFkAiFYr11uXa637qpUKh0NEL8duENo30bUuhwAZx6hqVSqY92kP5tAViGCSK3A6pe+CfPUGHoG7TihK+BDzfr6+rC5ucnL+oa0Xohnaz6fh81mg0irxO+uPYdoMYvMaQRmmQbTlVkoKUlH76UVzGYzQtkkfvELf4hstQwVewqNUo1/NPkI2FgakUgEJpOp67ZtfeZ6N9Dr9ZDL5W0He1wuV9vKcTfpTqVSCXt7e6hUKlxFqTYNjKIo2Awm5LM5oKf94wFnm8e4pR/PxT3IxpN44Fd+AqV8EWq9DgP6tyaJCDjTWRKCzRc7OzuwWCwwm804Pj6G1WrlJA/t4PV6cePGjcu85HOw2WyQSqVYXFrEnoLBy3Ef2GoVM/o+PEpbwOQLHbfd+cLpdGJxcfHc4BLBVZBZAoPBgHA4fG46u76Sytd+7CrgcDiwtb8LicUApUgCi1yNbDaLra2tS71fpVLJBWokk8kLVeD32KfgVBngSUcQqurwwaF7G5JZAHh//zT+x8tPwzozBoFAALFEjHf38wusaAVzVYKfn3oERbMKQgGF+bsciPjOQiQ6IUfN0E33QqlUYmpqCq8u3sarohS8pSSKyTRuyky4IWt/r5FqZS6XQy6XQz6fR7FYRKlUwr57E/lMCqV0EulAFJbpEcSOjrGwsMARL4qizqWSicViTv5B/qndK76T8WEzGgBdUUGu0+BvfC4oxVI8bB5GJpPhJBfZbJaTvdE0DQkAbb8VVSEFISVA4tAPWZexz3q9Hm63u6Pq6I8O3cKvLy6jZ8gOSkRBVgHuEfFc4Jug3rrrTvTtHbREtVo9t5lJpVIkk8mOCRVbqSAVCKGQTKFaqZ5JGUQi8D1MkefrZKqeLFSlUglHR0f49PNfQVhUgbRHjVwsgcxYD750sIhPjd3X0Xtph5cKQZQlQmR8pxBLaGRPY/hPnr/Ev3zsYy0n19uhm8z1ZiD6u62tLSSTSYyOjiIf3kE5F4NIosZx6kxb2m5wqFwu8/4+WJbF0dERQqHQhSrS5ubmOQ2gUqlENBrt6D1d01txS9KL78hOoDT3Iu09wUd0I1CK3zqCsr+/z3sDZRiG8wcmm/e1a9cAALdv30a1jT2Z3+9vGUzQLQwGA14Me/CV7z8Hrd0KkZTGd197BSnHMP7FEx+/0ueqBfGm3d3dxcTkJAqVMqrVKsrl8pVHTI+NjWFxcREKtQqpahmxfJZLFNra2oJIJOJtP9YMfA93cbqK/+vlr0M5YIWIFmFCqMb9YlPbASU+IIEaHo8Ha2trmJycPPeaxrQmjGlNSKj6cHoShE7duLvyiGkYfu0OijY9Tnbc+Knr74JT1d1AKQHLsnC73bj/+ty596kbGYHX6+XmLLqF3+9HT09PV5+hXC7HG6IUFlaXoHP2IRk4xdqIDN872cND5mGOsBLvZyLPAM6uY4lEArlcDplMxtnFiUQiFGxa/Odnvoqhh+5BIZGGrs+MG1Ynbk2+uQ+wLItSqXTun2w2i2g0inK5jFKpdC4w4Nn176MiEGD/b74Lw8gAFFo1vn6chGb0TBcuk8k4X97az0Lt7MO/v/0t5ONJ9I44wbAVPCrpw8LCwjlPZ76wWCwdDTkWQzH868c/joxChLAxiEGVAZVCEV6vt+u0uHrrLoqi7hDaO2iM2guD3FBisRjxeJy3ITbJZ87mcujX9SJlNYFWKCASi5DcP8Lk7Ht5vx5S0WqmP2sGmqYxNDSEatAAQSiC25/9KkRiGgIBhVd9YVxLX52nLQAsbi4hV8wisLyFo9dXce3j74Woz9KxxVE9mmWudwuKojA1NYWjoyO88Fd/BKeuDFpC4+Q0iiKlxr0f/MW2j8F3EyeDfxaL5QKp9/l80Ol05ypTzSZYW6FSqeC6QIsPfvhnkWSKMN1SYnd9oyOtVycIBAJcjGY7FAqFpu1goP3m0M4L87LYK8ahtlux/exLyIXjGH70HuymwwiFQhCJRKBpmvv3VW4Uer0eX1x8Eb/rexWJ41N8mw3iIUaH+27MX6lhOkVR0Dn68Ctf/mNQ1h4kj0+xLS1inlFhwOG49L0JNHc4qEWZreCPt74PqVGLTDAMgZDCS8Uj3Hhi9Eq9tZ1OJ2KxWFNpUau5BOCs0vnBmw/AYDBgIS+/NJkFzroLFoul4ft0OBwIBAJYWVnpyrv8svdHhWXhKSWhslvwxp/+FdR2MwQCCn8bykM9kjlHWE0mE1dBbQdzBniP8xpWqTTSEhp2hsanRu859zMURUEqlfJeo8xFN8LHJ1D06KHo1cI4NIARfR/mplrr0QdUPfhJ4zQ2FEYo9FrMGmyY0lm5jpnP58Pw8DBvPbPVasXi4iIvQptKpZBOpzldOKOzYmVlBfPz89jY2IDP5+sqBKjWuqs+2fSdijuE9m1EfdVILpcjk8nwyp2vT7aaKF3DFw4WsZbMQyOV45MP3YfgvgeaMZpXm81oNGJxcbFjQkvQI1UhLc+ib3YCIrEYUpUS16ZnL60Lq8e8PIeV8BGqVRZquxX5YATwRy6VHNYqc/2yMGlpZBU5bOyfQq2gkSsyuDaqQyF2CJmh9dR9u5ZTLpfD7u4uJBJJw9Z1LpdDKBRqOCDR6aLkdrvPfGYVGph+8GdjY2PY3NzkbQbPFyzLcqEW7UDsn1pZXZHNodkEPCEDV0kmGYZBLBZDOBzG6ZYbuUICKlMvpEolqkwFEpEYhUIB5XIZDMNw/ybWfbWoHQiiaRpCofAcCa79dy2WIke4TaUQ852cDWStu8CMj+KJFg4E3eJ/HS2jJBUj5/GDEgjw/OIr6Hv4vbjnCsgswI/QJoo55JgSaLUSr/zB52CZm4Tj5jR2T4/woGX4yg8LraRFzeYSCoXCOZcAMjdxGcJdKBQQjUZbDkIRmylCajvpRLjd7rZesc3Asiwi4TDi+0fI5/NQWw0wTg7BNOjAWG8/5sa7Wzt8Ph/K5TJ+5sH3clGsCwsLkIkud3C5KezB3xS8cD4wh0LirDr5eB8/rS+dL+Pv3/3k+T+jaUxNTSGTyXBr9dDQUNvvm6R71luJ1YMMOpJuFABuPSgUCpiamuqa1NYWPmqjlO9E395BQ9TbdtE0jWw22/BiJ3YhzZKtVLQUPzt+P2LGiTNvP3M/Snozb19MiqKgVCrbeuA1w48M3sRvLH0GOocVYAFaQOFaofUG1A1+ePAmVrY2oDQaIFXK0Tsxgp8buAu7u7u8Mq8boRvf0XYgbgGnnj0ETmOoVFj80eefw49/5EHEEhloyt0nnTEMA7fbjXw+3zC2lTz/5uZm0yx54nvMZ2PLZDLI5/MXdHhqtRo9PT2Xams1gsfjQV9fX9sNNBAIIBgMttWhUhQFo9GIYDB4YSCIYRhEIpFLyVWAN2NDSe69SCSCTqeDw+HA3+97Cr+7+iwqZQbGe28gcXyKebmZtw0eIbqkZUr+n7RmiX1TvZXdt3wbSCYCiB+dYP87L+Oun/thHPh8eH1lEWr6/L3ZbJNqdvCp/fMyW8H6yioAwPW178A0OYyx9z2MAHP5ND+CfD7fNkpXJZaCLZURcXsx8/H3InkcRD6VBZvMY2Vl5VyIh0ajgVKpvJTEpNbaKx6Pn5P1NJtLqE+gI+lOlzlM83UeIJIaQmr5dj+SyWTHDhwklIC8tx994An82Yvfxsij9yITjEAgEOCJvtYOIM0QDAaRSCQ4ORIpCun1eoRCoa5ikIEz4n6Xpg+DTzqxFPbiNO/BT117HGNaU9vfDQaDLb9DpVKJ2dlZxGIxrK6uwmAwtLUidDgcXPBIM5DOXP2eZzabcXJyAqfTeSlSS1BLaN/JuENo3wbUbgYikQgsyyLPlPBV/zq+5XoZOz0CfFJxL3plKk6jGovFYDQa2yawyOVyBAIBAJ37Ytrtdni93q4IbTWUwL96/OM4KCSQjifwgfkHkA3HrjznXkmJ8eO2G1AM9aGKKkY1JijFEsBsRyKRwObmJmQyGa9TMHDWrpfJZJe2tiFWV+l0mkuuUalUUGjNGLCZIJWIIBaLMDZgRiAcx8pOANaCsmOLK7/fj5OTEzgcjpaDHm63G2azuen7UigUyGQyvL7rVhPJDocDS0tL6OnpuZI2NglFaOcZu7e3B4ZhOG/idrDb7VhcXLxAaInHbTfIZDKIRqOIRqNgWRYajaZh2tk4lPhJyyxeLNHQ9VgwN3Yf+lkp77hcYsvU6UHN2yOE3ydCIZ+HdW4clXIZ2n4TRoaGIRc1lzd08uekYmPN7aFQYTD2/kegMugQ3/OiUFWCGet8sLERcrlcUw9agkImi7mCHG84bKClEjDlMnrlKjzcP47xoTMSSWKWo9EoDg8Pz4V9qFQqaLXajl5vvbUX+T4bzSWkUqkLCXQqlQrZbLZrQhuJRCAWi3kPu+n1eohEoqZ2WvXo5LDPMAwCgQBCoRCkUilsNhu3RomORChP3Y+YRoST0j5+fPoxOFSdu13EYjEEAoGGtmt2u52zwOsUW1tboGmaKwA8ZBnGQmmBF5kFztZlPlZwJMGR2GD29fU1dd0g11Emk2m4thKpQaO10mAwwOfzcR3XqakpuFwu+P1+zj+ZD0jBjWVZCASCO4T2DpqDRN+WymX8/vrz8GbiCKZiWE+eYu+1r+PHdeOgmCr6+/t5G/aTqXYC4rm4tbXVdtpVqVQin8937D0Xi8VQLBYxMzaDwUwGR4Ij6CRy6Gxy0DSNpaWljvK9W2Fvbw/TY+MNiZhWq8Xc3BxisTMirdFo4HQ6mz4vy7LweDwdT7YXCoVzCVjAmcWJRqNpmMKTV7wf8d1nAQBSqQQ3Hv44ZKYpLmpYJBKhv7+fe0+ldBDpowXE9zaQNrJQ2m4imUpjf38fPT09bV0cEokEstlsy6oKX0IbCASg0WhaEv7JyUmsr69fOhQAuFjBqgexO9Pr9R1VjSiKulDB6bT6VCgUEIlEEIvFUCqVoFAo0NPTw6uFK8uU8GsPf+QceZXL5Vc+oFWLRyyj+LZrAUqtBponHkAhlcFwVgwlzV9TyBefHLkLf7b7GiQ0Da3FBJndjnebZ7C8vAy9Xn+pYA3grELb6jUTJ4WfedeH8UQ+gf1UGFFBD9597S4kIlHOE5joKWtJT6lUQiqVQjKZhN/v5zoXpJKrVqvbHjqItdfq6iqn5bZarefmEvb39y8cDJVKJYLBYFefSbfrl1qtxtTUFNbX11tee6lUivv5VohEIggEAiiVSjCbzRcGAAuFAoLBID5610OgKAo+RT/oQuc6zEwmA7fbjRs3bjRcZ4jsphNdf6toWr5drFQqBZlM1tH1TdLDvF4vFhYWMDg42FD/Tyy8pqamLrzueqlBLYh2uJYMT09Pw+VyAQBvUkusuyiKOkdo3wpnlqvAO/NV/W8CQmj92RgOSzEAQPIkhNjhEShKgFPLBD44fjWDKhMTE/B6vW0rps1as81A2t9kURWJROeSRIgN1vLy8qVtezKZDCqVSlsSRk7BoVDowoZaZitYjPiQKRchieXhMJnaZtyTzS6ZTHJtS7VaDYvFwisDXWYYhkRrh6/yIkx3PQCh+KzdazabYTabkcvl4PV6sbe3hx6lGKLw90EJBGALMYT3XsbK6ip0znt5VfNYlsXe3l5bL12lUomTk5OWP8MwDC8tq1Qqhd1ux87OTtsggVYgFaxm3y8Z/uo2ZtjhcGBlZYUjM263uyV5JjrYaDTKSYH0ej1GR0c7uo5JAlv9d6dWq3Ht2rVLvadWUFFifFw7ivCYFOlSAQJ/FJ+8/11YX1/HyMhIV52YZrjPNAi9WIZvJgWYcMzgPpMTWokccJ75+66srEClUsHpdF7pgBZwdsgtlUockRqhjRjRGJHS2HF0dISpqSnOE7jRUBRN05wdIQHDMNx9T8gaRVHnSG79NVBr7ZVOp2Gz2fDc6m3sivMQZUowS6UXDob1BYhOQKQ53ZALuVzOXXvN7Mx2d3ebOiMQK0AiUWs18LS5uYmJiQnuczcajdjd3e1oWLBQKGBrawvXr19v+X5tNhuOjo54HVLJ4ZhE2daDyEHa+Sb7fD4MDAy0fb56UBTF+di63W5ucKz2gKFWqzmbstr7hnz3rdYhq9WKk5OTc59Fp6SWWHddZTjHW4k7hPZtxv/L3n9HN5bdV6LwxuUlciYIgABIEATBXCwWi9XV3eqg0N1qSa1oZVke2xqPNJ7kJ4dvPMFPntGTx57k9eZ5POOxx5JlK1rByqFbqYO6u4qxwEwQRCCInHO4+P6gzm0ARLgAWaoar9prcXUXiXCBe+85+/zO/u1dG6wAADyGQTGXx4DFBKG0Nw1qq4QPs9mMYDDYdqvTYDCw+dNcsLW1BavVyg4yfD7/TGOLUqlkDbbPU43q1oxbq9WyBH11dRVylRJfTOzDk42jUiwj4jjCP3/qPSBCDKKDJOSVrM4VCgVUKtW5XBAoWgBapGLJbC3EYjGmp6dPbY5e+DLc+15UGQb2PTcYBrCYBjExNQGKQ8PD9vY2zGZzR9IglUpZaUQrkEYwLp9Zr9cjEol0bGJoh3YTKGn+Os/1w6MobB6m8L2XnwGfL4RckMSHagg4wzDsdnQsFjvt3v+ZRc95KqjHx8ctJw+hUIirV6/2FJfbCVtbW7j/8hWWrGz3bYOpVHDlyhV2Iu9m+7ETTHwZ3mhdwPRI/aKG3IfRaBR2u51tjOlmUdDsGiSERKVSNSUwcrkc2WwWDMOwnsDdyDzIwrj2/QjJbRcVTay9/st3voCXQkeQlnxIeE/wmmsPYLo6DeoCzOm5SnPaQSgU4vLly9jY2GArhGWmghJTQSIchUqlqjtHpI/D7/eDpmkYDIaOxNHr9bJ65dr35RpdDpwWFW7duoXZ2dmO542rh2u5XMba2hpGRkZaShTILlY7Qkt07ecZH/h8Pqanp9km3/7+fthsNvazEpJOznU7qUEtyHfRiLm5ubro3nYg1l3kOuDxeE0bV+8W3CO0dwi1zWBaoRzKYgzJYh7D1xegHhtB5iQEnieMrLr71VFjwkctSMV0fX29aWc40etxWZX5fD4IBIK6G56iqKYXvFQqZSsCvVSHzqN1JZXQz978EVZWbkKkViKXTEOolOMvXvgeJOMZUOXTAVChUFx4fCtXUBQFo04NFc+Mny5vIZHOY8SghlwqAqqdt+iCwSAAcNKQ1V5/zdCqEawdJicnTxcOHLZoG+H3+6FQKJqSHNL8dV4v0RdWfQikBAiHDk+lPloTnn5+D1MjIsRiMZTLZSgUCgwMDFyohVs0Gm07+RBZ0P7+PhsAcN739vl8kEgkdZU3khM/Pz/P+iRflOk+0DryloAQxHg8jp2dHdA0zSmWOpvNQiCoD2jhWq3XarUIBoPQ6/VsyESvMg/SeV47drWKik7zKng57EIqGEXKH4HaYsJmOoSNiBcLmvoEJ0KcujmenZ2dcyVtEfD5fCwsLGB9fR3fdG7ghewJykwFlDuMf/8LvwrgdDF5fHyMXC4HrVbL2SWBSA2auS8oFApEo9GO1U8SeT45Ocl57NdoNOw5bwYSLNIptU4ul8PpdLZ9r3aL1W5BFkNEMkeKKIODg/jO2kt4sRKGhBZAfpLCg1e5NbHK5fKmjd7z8/PY2NgAgLakllh3qVSqOh/auxV399H9PQfDMKBpGoI+Gh+99Dro+8TgCwXQy5X4vTd9APdfuoK9vT1sb293tSoSi8XIZlt3GCuVSly6dAmbm5uIx+Nn/m4ymXB8fNz2PfL5PI6Pj7vSMQqFQly5cgUHBwcs+eIKp9N57qx7RiaCWK3EydYhlj/5FaSOQ6iiCs2wEUtLS1hcXITVam2arvTzgnBgDMFIAmq1Eh9+72vh9kWRKInAo9snrhWLRbhcrq62/NuR2l4mTJqmYbPZsLW11dXzSChEM9K3v7+PWCyGhYWFc5+TvaMoAApH+3ZsbbyI0MkRXlregkAgwNzcHJaWlmCz2aBWqy+UzHJdvNlsNigUCqytrZ2rCkLuzcbvUywWs24JwKkMSSKRYGVl5UKqLplMhhMpUyqVWFhYwOjoKA4PD7G2tsbqNZuhcXEdj8fZ3Z5OuwFDQ0Nskyzwisxje3sb0WiUw6dqD5JkNzIygtnZWSwtLWFpaQlCjRJ8qQSSASW2vvFDCJVS8ABEC2fHZbK1zRXBYBACgeDCdNc0TaNoVOKray8gGQwj7Q8jxafwB09/ES+//DLbhLq0tISRkRHOEoetra2WY4hOp0MoFGr7fFKBb4xY7wSj0Vh3zmuRz+fZlLxOZJqLX3e7yPheoVarsbS0BJFIhOXlZXzypafxnfghvrt1E59/8Qf4YnQXBYqbddbQ0FBLadnc3Byrf24F8h2Qivc9QnsPbUFcDnRiOf7x+AP4w0fejY9fewumVXrW6mNwcBCrq6twuVyc/EMlEknH7eRactnYlECqKO1gt9vrdFFcQVKDfD4fvF4vp+ecJ8WpWCzC7XZjZWUFRU8QVR4P5uvzuPpLb4Vy1IByLI1sKNrVFtjtRJmvQVo4jslxC2i+EEvXH0JWMtNR77q1tcVJz1sLUslvBAk16EXvrFQqIZPJ4Ha7OT+nmQ8smcyIj+N5BlKiUfYe7cDvPUC/SAr14BAGdSMwj05Ar9fftiYHr9cLYxcRmAaDAWNjY1hdXW27KG2HnZ2dllVesn1Z+2/yful0b9nzBFwJLYFUKsX8/DwmJibg8XiwsrJyhmSGciksHx8iUT29P30+Hw4PD3H58mVO70XCKmp1qmTsOzo66rkhqxPGdUbItAMYnLDgyvufQsLtR4VhYJIozzxWLpfXJTK1A8MwcLlc517cN2InEYR2wgL/tgMrf/13KKTTCKOIqctzPVWzSaBLq+fJ5fKOJH5rawsGg6FrCRNpDmu8f9LpNCtdOG/kM9DZquu8MBgMmL08j++7NpEJx+B+eQPFXB5QSvBD3x6n15DL5S3va4qiMDc3h2Aw2PE+YBimztrvbiW29yQHdxDkAiEkNZPJNN2yIw0Lbrcby8vLpwb3bVaFtQkf7UDI5dbWFgqFQl2Xp1qtbqmHdDqd0Gq1PVcIyBbr5uYmSqVS2zCHXlJq8vk8AoEAQqEQaJpmt8kW+q6A2X0BL544wONRUAwO4COPvg16RgC73Q4+n89pC/R2oVwuY3t7G0uPvLmOTA4wDOx2O8rlclONpdfrhUQi6VrG0Wyrk2sjWDtYrVbcvHkTarW643dZLBbPmMLn83nY7XZO/smtQEINSAeyVqvF2596Nb7z3AEAQG8ag8+9j9fef3Ga1UYQv9huZTJkB6Vd+lkreL1eyGSylhO2VquFy+Wqq97Wvt95mtO4+ho3QiwWY3Z2Fvl8Hk6nE4eHhxgZGcFmOY7PO24i5j6BWK3ANdcuHtVaOVu1ERC3gdrPTGJst7a2kMvleg6UaQWNUIpftN2Hv9m/AVrAh0gpxyKjwEQTGyguenaC8zSCtQLDMMgEIwhsH0ChHwSuTqOKKgRiEYQ9BBXk8/mWgS61IAvqZvfH7u4u5HJ5zylzeqMBX1l+DkqzARbZAEx9EtYVoJuFOmnaa/YcrlZd50G2UkSfgA+qj4Lz2Rug+miojDqkSwXOr9FuLqcoqk5+0Oz7rpUR3ou+vYczqCWytQNTJpNp67U4MjICg8EAp9MJr9eL8fHxphOXUChEocDtgierNKLfI1vWRqMRe3t7Z24C0hTR7kbmerHPzs7C4XDUvW8jnE4np5SafD6Pk5MTRCIR8Pl8aLXapvnxvzr5IF6jt2Gtbx2vu+8hKH5mMK/RaJBMJnF4eAiGYTAyMtIVkbgIbG1twWKxnBk8yaCzubl56ps6Ogp3OopsuQgtLYLf7+8prUsqlSIWi9X97qIigOfm5jhZee3v72NsbIz9dzKZZN0SullYlMtlBINBhMNhFItFKBQK6HS6On2oVgucnHgwILNCqRzAkw+NoZD0IJnUXEjFphE+n6/nCZlUEe12O7LZLCedHtEsdroWNBoN/H5/3bGR5jS73Y5MJtO1N2+3Vn/NIBQKMT09jWKxiOWdTfy3F78OiVaDUiaDRDaL51VZPHbletfv04zEA6+MfQ6HA5ubm2eskc6Lh/TjmFEO4QeV5/HQffcjeHDUVDfaSc9OkM1mkUgkztUIVot8Pg+Xy4VkMolXDVmxgzQyqRSEMgkEcikm0jTikWjXW+rtpAa10Gq1CAQCZxYTTqcTFEX13CBZrJTxZ64bWN6+AW3VinwqgytVBX79ibd3LVsicpDGMbkXq65uEA6H4ff7kcvlIOXRoEeMuPKBt4GplBEPhAFhBFkjt/6aoaEhHB4etlyo1pJaEkJTC5FIxC647iWF3UNbNPr1dVo9Ep1iPp/H3t4eKIrCxER9VjnXAbIWNputztpGKBSyejvy2sT7rpMlVCuXhWawWq1wu91N7cQ6dfJms1mcnJwgFouBz+dDr9d37Mrn8XgYkaqRlA+yZJZALpdjfn6+rlLULNbydsDlckEmk7Wtjs3OzmJzewv/97f+GkF5HwAgse/Gv3z9u3siE1KptE72kUwmUSqVLmQbTSgUwmg0Yn9/v2XTEbFhIxO83++H1+vl3PyVzWYRCoUQiUQAnBK1TpZaagmD17/7AfbfxaIa6+vrF25jBZxqHc8TC0yqiFybtwiR6HQtGI1G2O32M9c1mdgcDgfsdjtmZmY4X1dcomm5gs/nQ2QchMpiQmjPhdXPfA2PfPRDkGrVOM4mmlY5O6FVcwxwOga1s/U6D9RCCcbkGujFcmhmZrC6ugqpVHrm+ubieco1EawT4vE43G43u3An19W/NRjxpfXnkRLl8ND0Zdw/OIq9vT2EQiHO8rJOUoNaNJr/A6eLwEwm09LthAue8zvgzcQgVisRPnSjWqpgc1yIPCrott4sk8kQi8XOkLxerbraIZlM4vj4mHVWGBsbg1gshiFjw//z9BdR0g2glMvjCdsC3jrFPR1TLBYjn8+3nZMbK7W1n1cikSAajbIa2nuE9h6aolvSWQuhUIj5+XnE4/G6jkiKopAtF7Ed86MaPMKUUg8Zn9sWS6O1DYnPI9Wa3d1dTpZQNE2jWCxy3toZGRkBn8/H2toahifH8eOAA+lSHtRJDG++/EDdY9PpNAKBAKLRKEQiEfR6/YV2pAOvVIrK5TI8Hg9u3LgBnU7HOaq0FVo9NxqNso1PnXAs48GRjqAUKYIW8NEnF+OvPauYN1i6tgMiOfIE7WyzegGxgGvVzVxrw0aifJtV1WvRTErAdQs6GAyeIet8Ph+XL1++cFJLju8irsvp6WmWcM3NzTUlPd0QiU4JRFartaO9XyM6ORx0g3g8jpDDhdiRDzK9Bpff/UZkI1GI1XJohJKeXtNoNOLo6Kjl+SVj3/Ly8rndNFqhtmmy8V7v5HkaDAYhEol6lkPVRqdLJJKmvrE6sRxPGWfZ4gBweu0Fg0EsLy+39Ksl4Co1IKAoCp5sHCHnBobkahgYAYLBYNfb+OVyGdlslnVmWdvbQPj41HFi/3svYOF9bwIAJIr5M5HPndC46AcuxqqLIJ1O4+TkBPF4HFLpaXJk43dslCjxy4YFmGcmIaRo7Nk3IZPJsLCwgHg8DrvdDplMVmef2YjBwcG2zg/AK6R2bW0NwCukViwWw+PxgKbpu1ZqQHCP0N4hNHYNNhonc4VSqcTS0hIbpSfSqPDp4C0cnuzjRwhCIZXjN+cfg7FJM0IzaDQaCIVCrK+vQ2zU4s9f+BbEQQMGin14SDKEaW3nLvr+/v6uu6b1ej1yqOA3Pv+nEJsNYMplJHx+CIa1eEPfBAKBAOLxOMRiMXQ63YVtu7UDTdOwWCwwm83s96tUKjmR+lZoXCUXi8W6YIpO8KRjECkVCLywDNeL61j84FtwcuyDLxKCQa3pesBJl/II59PIhmIYGBi48ASpmZ9VpeRyed1gGwwGIZFIIBQKsbGxAZlM1pRMc5EScIXX6236Hnw+H1euXMHq6uqFkVqPx4Ph4eHOD+QIk8kEsVhcF1ASL2SRr5QgYfq6IhJA6wQiAq1WyyaZdSIywKlcanBwsKvPVItisYjj42OEw2HI5XI8MHMZcY0ITx/vIB9PQaxRQhctY0bR226JVCrtWKWqHfsuMr2tdseqtmmydktdJpMhlUo1JbSkEawXXXu30emlUunM59ZqtVAqlbDb7RgYGGgpR+EqNSD4snMNXwptg4rsghLwYUiDtQprRDabZX9yuRxyuRw7x/D5fIhEIohEIqhUKtw3N49daQnlYhkiuQwCqRjJQx8ig14Mjou6GuMaF/3A+a26auVxQqGwo59vPp+HUCCATnJ6D6rValYyROb/cDiM1dVVaDSapruUQ0ND2Nra6rjbSPpb1tbWQFEUNBoN65p0O2RZF417hPYOg1x46XQaEklv1QfglSi9/+f7X8SB+wC8PgrlfBE5YQmf3n8J/3Lh9ZxfSyqVwmgbw//1t/8TxVIJUh8P24EQ4pcrWGQWQFN9bZ9PKrTd4lYhAqFRi7DDifhxEOoRIz73zLdgfYDGmHHkwjt7uYKiKJhMJphMJoTDYdYc3mKxnCtBhXTyT09Pd9RikZz02N4RUrEQVNZh9In4kAwOoJovIBmOIOj2srpsiUQCmUwGqVTadGIuMRX85e5P8b295yFL7KA/mMYfvOsf9vxZWoGmaVitVmxtbWF+fp793IRMraysnDE370VK0AnZbBY0TbdciNA0fWGklmEY5HK5C58A1Gr1KeHaWMcyL4H1fBgAUDg8we+96f1dvZZcLmdJQatrTyqVssb7BoOhrV9lJpPpqbGK2AaVy2UYDIY6zfW7pIuYUxnw0/IyZicmYYQIOzs7PWtdtVotfD5fWzJS65fdbUNeO9QS6WZNk3K5vKWVocPh4NRHUIt0Oo2joyMUi0WYTCbOBYByudz0HuHz+VhcXITL5cLKygrm5uaQZkp4IXCIElPBQAYY5rhDAADHmTi+692CUKlAaO8QvGoVGB7Cj3bXYRWpWOIKnI6/AoEAYrEYIpEISqUSYrG45XX7KpUK3kIK33dugOqjoBxQ48MPvRUmSoydnR1QFNWVFVijhC4cDnd9rZPxOxwOg6ZpTvI4gpOTkzoiajabsbq6Wvc70jhOCi+NO4p8Ph8Mw3Bq3KwltQAgVSrgCPlh7AcmfrYLeLdWau8R2juIWi1KOp0+95YdRVEoD0ggTCuw9fVnUMwWMPn4g0jQLqwwg6zEgVSGaZpm85kbf14IHKJPKkJ6PwjH88u4/N43IVDMwJ2OYUzeXmPZS4UWAFLZNAqJBNLhKI6X7ZBplFAMG2Aas0AtUfT0nVw0yMCRTCZxcHAAhmEwOjrKiQA1DgK7u7swGAwtJwGGYdgJn2EY6PV6fOTJdyC58X1s3bJDNqgBj2HwkQeexIz2lQG2XC4jnU4jmUzC4/Gwgn4+nw+ZTAaZTIYfhQ+xEnajXyhA5NAL9fAQPrn/In5z/rHev5wWUKvV8Hg8+OpXvwo+n49YLIbh4WFsbm6ylbDzSAm4wOVydWwyIaR2bW0N4+PjPZNav99/4d6UBGKxGDGdBE8//TTEaiWYUhk8UT8+dbSM39c81dVrke7/dg1ghMhsb28jlUq1rIx343BAfHKJR2+7xcq0Sg/aNAGdTHsaA5rPw+Fw9LRDQyQwnaprpCFvY2MD+Xyec2piKzTraWhsmmwVgZtOp5FKpTgv5oPBILxeL/h8PkZGRrpeVJVKpbbn0Ww2Q6VS4QcvPY8vJxzoU0hQKuQRdR7jX771F9GK5uXzeWSzWeTzeRQKBaydHCG05wSYKtY/+w3Mvv1x5JMZBNMJLGhHMDQ01PMClsfj4b3jS7gq0+Po2IMHLi1C2n/q472wsFBH9kdHRzsuWogbjFwu78qqi8g8gsEgO35zDaWoRTgcrrtHaZpmyWvjtUkKW16vF8vLyzAajexj5Go1vr+1DI1eh0mlHvI2UkRCar/zwk/wjbQTB84NiFMqbAsLMFfP3wB6u3CP0N5hkAsjk8mcqxpAtuwKDh+YShEL730Tjpc3IVLIMT8xhcWFV5pTGIZp+1Mul8FPCkELBRgYH0HkyIO0L4BSOovCdGf3hG4qtLWkrS+WBE8ogGbCAt20DSK5HHQ6B/fWHsIiEQwGw8/deaAVGhvIDg4O2sYoEpCVPjGzbjZZ1jYHaDQaTE1N1Q3u/+rKk/hMlIHSoMNAuQ/XtfXTCE3TZxKNgNNrhMQmvmBfQzAWhGd1EwnXMS6/5yncTK5jX2QGTdPo6+tjFz1EO1X7X/L/XAa2SqWCYDCIo6Mj6HQ6OBwO+P1+PPHEEzg8PDy3lKATSJoTF4JKGrHOQ2r9fj9bjb4dcGVjUA4P4fD5m4g7PLj2a++BP5dEvlyCkO7n/Dp6vZ61AWwHiqIwOzsLt9vdVMfLpQG09j4H0FXVsHY8sVqt2NzcbDqZc3kdrimItQ15uVzuXBKnZt+NUCjE8PAw6+jRClzivkn1LxAIQK1WY25urmdJFBfpm1wuh1fTj4Qzimo8hnQ8gQHjEP785aehu/Q48vl8nSSAoihWFiAQCKBQKLAon8W3S8fgURQW3vcUqD4KYrUCixPT0CgvxttV1ScErdKzZJZAKpVibm6OdXno1PxbS2g7WXUxDINoNAqfz4disQitVouZmZmez0c6nYZYLD5zDZnNZiwvL0Ov15/5G3GIMJlMcDqduHHjBlQGHf6X7yb2t3cxOGGBmO7HRy89hmGpquV7UxSFZ/vjCHh8KGbzEFWr2EkEEQvG8OaePs3txz1Ce4fQuGLP5XI9bV+TjlWyZfdbb3kf/vOtZxAtZCHVDqCvWMbr5fUTFhci8mqJED9JexE5DmD2za+DdEAFUa6MtNuPDV8EJpOpJbmkabpjwko2m4XH40EymYRGo8HMzAwW+AtQejbxv5/+OsTDegzK5Pin978ZBokS6XQax8fHcDgcUCqVMBqN59ruvyjUNpC5XC64XK6WDWQMqqhWq0in0/D5fHUd8MViEScnJwiFQhCJRDAajS3JVDlXwHXjOGZnZ3Hz5k3Ox8rn89kK82R+GqljARKBMETaAQhkYgwoVBgcHES5XGYXNuVyGYVCoe53lUqF/f92jY2E9GYyGRwcHKCvrw//6T/9JywsLGB6ehqxWAz33Xffhet2G+Hz+dra4TXiPKSWSBtuh51PsViE3+9HaOcQ6UQQ+pkJCFUKhHcPoTbqwe9rLwVqBNF0tvKobMTIyAikUilWV1frYrPbORw0u8+7ndz7+/vrFsjT09Ns6Ea3jhykKs2l4kmIPLH16iVIBjitGDa7T/R6PSKRCPv9N/pC+/1+yGSyluMcIWSpVOqMXKNXcHWnSZULUFpM2PzaMwhuH0DyrjeCkVQgEApZLX67e0AN4AMT1/HZgxvoo2moxkYwmaJgoi/OA7xcLqOvzT0hFAoxOTnZsflXLpfj2OeDVCptadVF4oGz2SzUavW5JVIEJycnTccuiqKg0+ng9Xpb7jxRFAWr1Yrh4WH8h6e/CMeJC+VsHuVCEXnw8Kndn+J3Lj3GuhnV/rdSqSCdy+Jgdw9VMDjZ2EWfoB9qyzBC+fMFsNxO3CO0dwBkcKtWq+yN042PY+2KXCqVnulY/b3FN2En7oez34glywTCxyeccrNrMSiS4qPzr8N/dn8ewkENRhVafOC++6ASiNlJyuFwQKfTwWAwsDd5ialgLXaC45AfDyvFGFe80ijCMAx8Ph/8fj8rhm+syD05PAvFbBqzC/OQ9gvZzn2pVMo+NhqN4vDwEPl8Hlqttu797xSIVtRisbA6JrVajeHhYaSYEv5s+zksr61AG7mFS3kxfuV1p9vDfr+fTWnR6/Udu/yB088/MDAAoL3xdzu8wTSDZ154DkqtBooRHWLuE/zDq6+7UOsqQnpjsRg8Hg+KxSIGBgbYqkIymWSdB27n4qQXn95aUjs2Nsb53rnIbHfg9F4n25bEI/LDr38H/mD9e0imk6gWi5Cb9HiIGoT9lh1TU1NdEcbh4WHs7OxwJoZEx7u5uQmlQYtvRR3YdB5A3i/ERwwDGFdo2a1Wv98PmqZhMpnOVXnn8/l1C2TiH7u6ugqhUNhV85ZGo4HT6ezq/a1WK3w+H2vr1ctY02rhNz09jeXlZcjlcshkMpbQEpLVrBEsHo/j6OgIAOpst36esEgH8MLNl6GdskA3Ow6mWMb03Dj0Ou6Wao8O2TCjHMIzxZ/g4fsfxGC/+EIb8rjKYJo1/5KxO4cK/uzwRby4fANCvhAfuP5aEAU3KbIkk0nI5XKYzeYLD+WJx+MtF18mkwnLy8sd3Xf4fD6gU0HBL2H328/Ct7qFkQeuIE73Y6ffhP7+fra/oK+vj3VBUavV0PqNKPIqmH/PG1BKZ9FH8SDuuzOx8Fxwj9DeIZAoOZLCwdUax+PxIJfLQa/Xt1yRi+h+XNEMw0xJEIvFMD8/j9XVVfD5/K5uuGGREr86+cAZMiAWizE5OckS1LW1NUgkEugMQ/ifhy9iL+hDNhTFi9UI3jW2iCWJHsfHx8jlch07bfP5PCRCUVt7FbVaDbVazU6cxBCaxCTeSX1PbQNZMBjE+vo6/tJ5A0XV6ec5OThCTCXH0OqLMNKSnqpW0WgUMzMzAE4n6EAg0LURftJ1gn/72nfiO7duwGybxPicEow/BsZ0cfoostWo1WphNBqxs7ODhx9+GGazGalUCo888giy2SwODw/ZHYqBgQFoNJoLW6DE43FIJJKePlMtqQXAidS2m4C4gjg7EO0dSbqr/U7+7eIb8MOjTbgqR3j9wkOYUQ0hmUxifX0dOp2Osym9UCg8tfrjsA1PIBaLMXd5Hv/si3+KXD+FcrmEopKHP3zpW/glzSyEFTQ95l7B5/ORSCTqfkfTNGu31m36UzdVaQKDwQChUFjnMsEV7XzBKYrC5OQk7HY7xsbGEAqFoNfr4XA46pqGGm23JiYm7tgOVblchiFSwtL4DDYCLlD8fgyKZHigIO86YGNQJMWESs+68JCGvIsgtZVKpatxtdnY/TeeNWTkfJSKJVQBfMm1ikoyA331tEnNaDTetgVFPB5vq4GmKApDQ0PweDwdx/8hiRwn2QS0UxYAVahMQxjXGztKo3557lX4i90X0E/3o8hUoeCLMafprkHx54l7hPYOg0wmKlVzLUttVVMkEmF4eJiz0F+pVOLw8BBWq7WnwT8cDrOVwFbHTgaAZDKJL9z4MW4ebYAvk6GQyyF1EsJ/3/4C/tUDb8GUZZzTANVNJZmQWIPBwFqhuFyuln5+P2+o1WoU+oCo4zkk1lzY+runYbp+CcNX5hASMnjblWs9vW7tAkir1WJtba0rQutyuSASiWC1WFGIJLBkPa0CBflBbG1tXagXLXC65Xr9+nW43W4YjUbYbDYMDg7i6OgIc3NzrHaNuBuQmF+VSoWBgYFzVY29Xm9dElm36IbUhsPhnjXeDMOwmerlcrmj9k4lEOMpy2XslUSYUZ1uScrlcly7dg0ulws3b97E1NQUp3vOZDLB4/F0NTGf5FPoG9Gi7DnB1jd+CMtDVyGUShA2zeLtM71d163A5/ObNpny+XxMT0/j1q1buHLlCmfybDQacXBw0LVcQa1Wg8/nd024Ok3+crkcMrkSX/nuBvYPjzEyGoNekcPb3jjZte3W7UaxWMT6+jrGrVZcUy3h5c11yFUqTAwNIxIOY21tratmzsYqqlAoZEltraylF3AtFDWDVquFWCVHLLSGtOsYm3/7XQxdnQFN9cElM+BN9z1420ndyckJjEZj28eYTCbcuHGjowvGOy2LsHuO0C8WQaobQM7lxwceelvHY7imHYVWJMcPeC8jJYjig0tvxPcD375HaO/hLKqo4oe+XTx9sIYFKWCuWMDvOz0l2WwWLpcL6XQaOp2up4GMaGXJjT07O9vV4B8OhzmTAblcDoXFCEUpAs/6LXifXcXir74DA5Nj0I+ZIZVwG/xjsVhP9j9CoRAWiwUWi4Vtqtrd3YVarYbRaGRJfDQahd1ux+7uLiiKwszMTE8TRLFYRD6fZ39yuRwKhUKd1o+maVT6eMhGYqiiCs2cDUrLMGQGHVSK1mL8dkgmk3X2buQcc/UxDofDbIhDo/ZRq9UilUrB5XJ1XfHlctxLS0soFAoYHx+HUCiEz+eD3W5nqwRisRhmsxlmsxkMwyAejyMQCODg4AA0TZ9ugWm1nBdkxAD9vJUsrqTW6/V25cNJGqX8fj+KxSIGBwfPNAByeY1GmM1m6HQ67OzsQCQSwWaztZ2A1Go1HA5HV9U1IgWqMgz6+QJUmSpkQxrIFBcTrlALPp+PUqnU9G9SqRRWqxUbGxuciZRYLGa1gt3e+8TKbH19HRaLpauO93awH1Vg33Ujl80gt7sD/8AQRD94EYNKflcNdOdBp/Ofz+dx69atOl9iKa8fZtUg+n4mhyFWhFwT15rpXC+K1PZyfmtBU30QyiTIx5KQmXQQymUol0uoFksXEvXcCaQRrROMRiNcLlfbeVMlEOO9yglg+jr4AgFk4xUU/FFA1rpgRWCWqfFq4yTcFTdkgotJA7xduEdo7xAYhsF3PFuAKgN3wIVISIrDtSx+eegyQv4AaJrGyMjIuTWNKpWKXd2LxWLYbDasra1x0mp206jGMAyocBoxtxuGGRv00+PIxZJQ6wahEXDfOuq1Oa4WcrkccrmcJQx7e3sol8sQiUTY29tDtVpFLpeD2+1GJpPB/fffD15NylYtUS0UCux/a8kqn8+HQCCASHRq1K1UKiEUCutigr1eLwKBAF536RrW8iFINSoo9FokHR7cf/WNPX22SCRypmqu0WgQDAY7ajez2SycTicb4tAs3clqtbISkouIwCVwu92YmpqC0+lkq20Gg6FuAqwFRVGstAQ4JafhcBgHBwfsNTI4OAi1Wl3fcV+tYCf6dXjTLyHkzeGS4WL6cTuR2mKxCIZhOJFR0gWdz+cxMDDQNLWJC9rdv0KhEAsLC/D7/VheXu5IvnQ6XUeP1loYRQrQnigEIhGsr70OqVqBjCeIIdvFTymdXFPUajWKxWJXuwt6vR4+n4+zNKMWfD4fV69eZW29On1n7SQHAFAoVuA8TkBnHMNXP/PHGDJZYaFpZCt6LC5e6vr4ekW7RXE6ncb29vYZglkqleqeo9frwTBM3UK1HVqRTqFQeBr1vbnZtcSj02tzBV3lYThSRqRUxuQTD6NaqUCslONBwzjW1tYgFAp7skbjgm52ewwGA1ulbfV5k8kkZCIx5kw/k0MNAmtra6z+txMoikKlUgFwvoTT2417hPYOIZBPwZUMw0xZkAxFoYjEsOLx4dKiHG+cv+/CohcHBwfh8XhYOymlUomRkRG2otEKnfQ7tfD5fDg+Psa1IQtSin78NHjadFHNFfFGiZmzlVCxWLzQ7TTSRKPValEul/Hss8/C6TyNRPR6vWykH3DaSU2eQ8iqQCCARCLh1LVLQCQiJycn0Ol0uHr1Kq7ygM++/CM4+xUwGY148MoTONk7hPayrOvzTDxca6HVarG1tdV2Yi2Xy9jc3MTs7Cz7OVKpVNN0J9JwIxaLL0SnR/w1iV6zdkAkx2y329uSET6fX2fun06nEYlEsLGxAYZhWHmCs/h17MS+BgA49EVBaY6hzQxCLzm/jVYtqWUYpo4gHh8ft7WRisfjODk5Ye3DRkdHz60R7ESUgFOCodFosL+/D5/P17JprLbBpBNIpe63X/N2/DDpwsrWJgxqPX7x0Xch6zuVjMzMzPxctyX1ev1p1On+PicNs8FgYEM9egHx6dze3u7oi9vpPJG1dDwSgEI5CLlShyrD4NjjhN3Og1wuh1KpvO0SqnK5zI6DtYjH49jf328aCdyMNJL7oNlCtdl7thpXxWIxu6vYC6mtVCo9zyfZbBabm5v49Uefwhdu/gRJOR8ysRimaAmXR22gaRrpdBoejwd7e3sX3pzs9/u7kkqZzWY4nc6W1/7R0dGZ15uZmcH6+jondwwej4dyuXzXSg0I7hHaO4RcqQgSq+B+fgXqURP0s1YoDdoLzRGXSqWssT6BVqtFsVjE9vZ2Sw/EUCgEXYeOVeI2MDAwwN4U/6BqwmOmKaSKBRivK3C4tctZFxuPx1tqic8LmqYhEAhOZQCVCnK5HAQCAeRyOebm5i4kh54Qe61We2aQmBWo8a4rD7HnNi1VYX19vavceOIT3DhoEo1hu20wu90Oq9VaR1BTikaswgAA6G9JREFUqVTTiZimabY6chFWQB6PhyVKNE2fmdxNJhNb1eFaYSMJaLXyBL/fj+9s/TXAqyDiT0Os6Ec+W8F2+JsXQmjJ8S8uLmJlZQXVUhEDnjUgHkTQl8DS+z9S99hkMomTkxO2CnI7dN1cqiU0TWN6erpt0xhFUZDL5YjH4213hUiljmhIf2XIiMclI6fpRzI1MKlGMBjE8vLyhcbHcoHFYsH29ja8Xi+nqqlQKKyzyeoF09PTcDqdbUl8p/uH4lVBl07QR9F4zRs/AL/3ECbzFN7+hkkMyPsRjUZxfHyMvb09AKcxuQqFgt0Vuig0q9AGg0G43e6uNMrAK7svne7pTkUMsVjM6qS7GSuB3iu00WgUDocDly5dAk3TWFKZ2FjpcDiM/f199tqenp6ua47uts+lGRiGQT6f76qYoNVq4Xa7m55DEvnceJ3z+XwYjUY4HI6Oi0BSoaUoqs6d6W7DPUJ7h6AVSdFHnZrXD983D6lWjbjbD0YVQ1HDTQ/JFXw+/4y1k8lkgsPhaFldSCQSLS/ydDqNg4MDCAQCzM/P1x0rj8eDSaICfibzrK32dRp8I5FIRxF8t6jNiO/v78fQ0BBGR0dhNBrBMEzbpC6uaEdkgVfsq2q/JzIYdkNqk8kkFIrmiWkDAwMIh8NNgx0cDgdUKtWZRUU7AiwWi2GxWDhvHbYCIZvkWiKa7kaMjIzA7XazVeRuQOQJKpUSFp4SqVge2zeCkCQFkMpTYIInkIXq/XppmkZ/fz+EQiH6+/tZq5ran3bvd+XyPFb+40fBVOKg+3iQJLPAVwtIPflh+ANBxONxSKVSDA0N3bYu6G4nlU5NY8PDwzg4OGhJaMPhMI6Ojs5cr422WlrtaaqX3W6HXq+/UBuzTpienma3gztJZkwmE46Pj899fiwWC/x+f1tbr1YLD7JAeO9bH8CWMwvncQKVnARvesQMo/Z0kV27M0FCQuLxOA4ODpDP50HTdB3J7bVKWCwW6/SsPp8PwWCQkzytGchCtd093ckrFuhtrAR62xp3u92IRqMsgfd6vWciZv1+f12RprE5utaJyGAwdP3ddWrGboXR0VE4nc4z17PT6cTo6GjT5xgMBk7Sg7uVwDbiHqG9A2AYBmJagNcbp3HUR4MvEYNXruC3nnovJvuV2NjYgEKhgMViuZAtDLVajXA4fGZiIak7jRWNfD7fdNAoFovY399HqVTibBtDqkN2u73jwJjJZC6sghUOh+H1elnSSoim2WzG1tYWaJpGIBDAfffdV6ef7QZ+vx8ejwcajaZtJTMajTatPHc7UEcikZYVbJ1Oh8PDwzOE1u/3I5fLnamScJF3aDQapFIpOJ3Onhr1ALA+swR9fX0tJ5qRkRG4XK62OwftwONRGOAt4MDzDF73Hivy2TIiJzm8+lVvh1W1VPdYYiJe+5PJZFAsFlEqlc6ERhACTMgu7duDqRjBVigBfyyNKYMayz99DmLlBAxLj5zbuosrepm0WzWNicViMAzTtMpDJvpm97BQKEQsFjvzu6WlJezv72NjY6Pn5kuCbibU+fl5rKysgM/ntx1PlEol9vf3ez6mWuj1+pa2Xq0kB36/H16vl328dhB4NQC/fxCFQrbp+5BKeu3nKpfLSCaTSCQS8Hq9KJfLEAqFrFRBKpV2/P4SxRzsIS+kQiFM1So8bjdSqVRbWRo5nnbodE9zdSLoldRyBcMw2N7eBp/Pr/vMzTysJyYmsL6+DqVSeebzy+VyzM7Osl7xKysrkEgkGB4e5lw48fv9mJiY6PozaDQaNtKXfD/lchmZTKbtrgsX6UHjNXy3Etx7hPYOYlShwT+9/y34850k5idm8YDuVOOiVp9u262urkKr1Xa05OgErVaLnZ2dppWS2dnZMxWNYDBYR4wYhoHT6UQsFuspDlQqlcJkMrFNBc1wEfqcxoz4Zh3jRFMLnFYu4/F4x7jaRgSDQbhcLqjVak5bcaFQqGXluZuBOpFItCSWYrH4TBZ8Op2G1+ttGiqQTqc5ySwsFgs2NjbOXBNc4fP56iq8vHIBpVQO1cHBpgsJs9ncM6nNZrOQxB7Cq5YEiJTXIJcIcGng1Ug4FWAU9dVokubVTdMjIb75fB75XAa5UhmDEiH+4w/W8Mt9k7Bp5VAKub/mnUSrpjGTyYTl3S0oTDroxXKoBRLs7u4CQEtyIxQKUSg0j8S22WwIh8NYXV2t647vFqQxjAuRoSgK8/PznGwKyVjby7XdCKVSyWo+az9rY1IYwzDY398HwzBNFwharRYrKyucnUaIA0jtDkw+n2d126lUCsBphCup4tZeo9sxP/771o8R9p6ALxXjm3ureN/YUkf5D9fzQfSdu7u7Z6qH3ehcSbgOV1LLdT4pFovsbkKtDj6dTrO6/1rw+XwMDw9jf3+/ZXWfNHWPjIwgmUzi6OgI+XweBoOhaVwtAVlo9yolGRsbg8PhYMdOl8vVUSfORXpApAZ3O+5qQvuxj30Mv//7v1/3O51OxyYrVatV/P7v/z7+7M/+DLFYDNevX8ef/MmfdL1leSdABrh+qg9KkQRqhbJuG4MQL6/Xi+XlZQwNDfW8dcfn89t2Cc/Pz+Pm8jK+f7ILez6M0K4T73v0Seihh9frxcnJCYaHh89lHaPX69kKQrPPcR79bDAYZDPiDQYD5+M0m81YW1vjPJmRLVeFQtGVpqyT/QoXUkv0s+0GablcDnfQj0H1APqYKra3t3H58uWmz0kkEi3lC42Ym5vD8vIypFJpV2QtnU6fVjNpGtVKGcz3PwX89GmUqwyY6XlQb/1n4InPfi/tJsBWIE0ci5evQSh8uO5vwWCwKyuhZiCaS1L5ql55AMzGNwGGwe89sYh+moZMJERVM4y9vT0Ui0WIRCKoVCpoNJoLryhdFBqbxnaEBXz2p9+GZnIMFI+HhyoqPGqdazspdhpfNBoNK0HQaDQ9NWKR+Fuu3yNXm0IS+HERhBY4XVhevnwZGxsbGB0dhVAsx64zBh7VB7FUBSGfh42NjToZQSPItdZN2EUjhEIh9Hp93XY5kSqQlEWKoiCVyfBf938CRtAPplxBwnMCh0qBYxkw0+E98vl80yayZrBYLHA4HGea9rrVucrlcpbUdhqDuexeEMmHzWY7U6hpl/qn1+sRDAY7as7JMc/NzbFVWzKWms1m9vzaoz4849tF+CSAGYUeV6vVnnYO1Wo1NvZ2sLu3DIamAHcI73jNEx2f10l6UEto72Zie1cTWuC0gvj000+z/67V2/zRH/0R/st/+S/45Cc/iYmJCXz84x/H448/jt3d3Qtp8rndIBcsRVEYGBhAIBA4o3M0mUwwGAxwuVy4ceMGzGZzT4OvRCJpe7E6ZAy+8JNnoBzWI1HI4JNrP8Lh5jYem168kMYgAJicnMTKysqZLTPgtHu/Wcd9K+TzeXg8HsTjcajV6q79OwGw2rNOTWuk+U0mk53RDHM5zlY597WoJbXNqkqdCH+imMPfBG5h58YR5CYdhqMV/LPXvrXlsaZSKc56ZYqiWF/Iboi8x+NhyUv15W8BWz8FTQGFMgD/EZhv/zn6fuGjTZ9rsVg4k1pCZltV43rxx+wEnkoH6o0fBvOdv0A/TWPGoMXe5OsglA9g/meTYDabRTgcxs7ODgqFApuERgz67xYQWdAN1x4++92vgilXkPJHUEym8Iw+jTdpHz33e/D5fCwuLsLhcPQkQehEmpuB2BS286gVCoUtZRa9gnzWnzz3Mp7biKNYqoDHo7C8Hca8hcKrri90rFQbDAYcHx9fqHSFNFISksYwDJwBH2LRODInAWx/+yeYfftjUBh18GUTHV6Ne4WWwGq1Yn9/v65vo5fGLblcztpPnidoghQomo0bDMMgmUy2HXumpqY4uwQA9VVbsrAoFouIC4DPhrdAURRCbid8o0XI3HY8Ze7esi2US+PzyT1E9oLgS0SoAjAFJ3CfdrTjcztJDwiRvZttu+5OIUQNaJpmV5p6vZ4lPdVqFX/8x3+Mf/2v/zXe8Y53YG5uDp/61KeQzWbxmc985g4fdWeQi4J0rUulUqTT6aaPpSgKFosFV65cQSKRwM2bNxGPx7t6v4GBAUQikZZ/fynqhnpsBJvf+AFONraQDscQHBTWxS9eBObm5rC7u3tmckokEh0HeRL/uLKygr29PahUKly7dg1Wq7XnLRqz2Yytg11sx/xwpaJ1q89oNIqVlRWEQiHMz89jcnKy60mvUUPaDoTU3rp164x8oJn/bC3+fOd5BFFEMZNBwnOCPaTxUvK45eO7nYyEQiGsVivsdjunxxPtFjmnVfcWgCoCySxuuoMIp7Jg3NttX4NoyNvpHDuRWQIyftjt9gsbkHkTS6B+/f+F6L2/g/KH/hCXn3oP4vE4XC4XgFNCNTIygvn5eVy7dg1ms5n1S7158ya2t7cRDAabNsndCfhySUgGVCimc3jxv38aMoMWAqUMJ7nO5IYrrFYrTCYTVldXuxrD+vv7e/qelEolDAZD2+tWr9fj5OSk69duB4qiECmokU6lEA2fIBELIOj3IpjhZr+lVqu7HuO7ASkIhLw+UKUSJPpBzL/7SfQL+KhUGAwIJB1fo1gsQiAQdPW+NpsN5XIZe44DfMu9ic/t3cDXvXakS/nOT66BUqnE+PipH2yz66KZG0wtXC4XfD4fFhcXm44bXKKRa7fqu4VSqcTc3Bzm5+fxY+8uIruH8NywI3LkQzmfxzd2Tuf4ZDLJ/qTTaaTTaWSzWWSzWdYrnUihyuUyvuZcAyPoR6lQRPjIC7FGhc86bnY+oA6f556G9oKwv78Pg8EAgUCA69ev4xOf+ATGxsbgdDrh9/vxxBOvlNMFAgEeffRRvPDCC/jwhz/c8jULhUKd5iuZTN7Wz9AMpIRPtpHL5TKkUmnbbkOapmGz2djmrKOjI4yPc4uU1Wg08Hq97Zt7qgwK2QIkcgWqAE52D3GzehN8Ph8SiQQikYhd5fd6QfP5fExOTmJjY4PVj5EbpdVrZrNZeDweJJNJaDQazM3NXVg1xZ1P4E93ngc/sgm+VIzLaiPeM3QJrqMjiESic79XNBrtKkq2ltReunQJAoEAuUoJsXi8pZSiWq1iLxZAPp1BYMsB5cgQhq8ZsR3348nhs/KbXlNu1Go1UqkUJ69Pn89Xt90JoRThTAHZYhkPDOuQyBfhzjHg3bwJhULBujA0Hhep6pD3rFRLqDBF9FNi5HI5toOay4KmW9N3LuDR/RBphlAoVyDD6YJte3u7aSMduXdI1Zp46ZKoX+J53BgWcTuQzWYRj8eRSCRYW79SIQlQFLTTFlCCJ5GPpyCUS6HidyY35D7mcl2p1WpIpVJsbW1BpVJx0or2UqEl0Ov1KBQKLa9bvV7flWaVKxKpAjR6M3Z++GXk00nc9/CbkM5yJ+VcbNS6QTabRSAQQCQSAZ/Ph1arxX1Xl/B/mQfxR1/9NDS2MeTjCYjjeTxm7Jx4VyqV6lILucI2MYF/+/VPwZlPoJDKwK/sgz0VxL+58gaIOHqWA6ekcGxsrGlQUKvKL8Mw2NragkgkajsG+Hw+zMx0El0QP+NVvLDiQL7UD4WUj/lJLfrp1vcBcapIJpNIpVJIRGMAj0IqFEHmJITC7DgYikIoFGIfX/vf2v9vrJru7m0jnAghtONAyOGG0qgHMziASpVBH6/zvdlKesDF8/puwF1NaK9fv46/+qu/wsTEBAKBAD7+8Y/jwQcfxObmJqujbfRK1el0bIWkFf7gD/7gjDb35wmGYeouRD6fD4ZhoNPpEAgEOq7giT4sm83i4OAAFEWxcaKtQC7IVpPO/QMj+Lz9uzBfm4d8SItiJov3ve4NWNKNoVgsIpvNIp1O4+TkBJlMhn0dkUgEiUTCTtZcyJ9cLoder2errIFA4Iwuh2Tb+3w+0DQNk8l04fZHlSqD/7H9HAQ6NZK+AGT6QTyz9zz4Yyn84gOPndvjkdh19RKvOT09jZ/ceBE/oWIIFFOIO734kF5cR1Cz2SxCoRBisRhShx5UBP0Yvm8epVwePPAgoZtXT9LpdE8TEXBa0bbb7fD7/fWEtQGBQABXr15l/x223g/3sz/AtdGfNURUGfCe+GVgZhHJZBKRSARutxsMw5whuDabDXt7e/jOzf8PcdmzqIKBiBmCKvpGXLvySFc6w25M37lCIBDUka3p6ek6Et4KtV66ANjvgbhzyGQyDAwMNLViSpcK+JprAy/t3cCOgsFbzfOQ8Ztfr/l8nu2CT6VSYBgGIpEICoWizht3scrgZJPCS/ubUJv0yGeyuCbQwiDprLUm3wHXe4Z0kzudTqytrWFmZqbt2EHTdJ01WLcwm83Y3t6G2+1u6sErEok4pyZxhVJG49bGDhauvhpiqRLpZBipqBPb2yJOXe9DQ0PweDznIrTpdBqBQACxWOzUSUGrPbPrZir24zcfeAuKA2JIaD54njCK2RyE8vbkMp/P99T34E5HEVbxUXIWEDpwQD0+gnA+jeWwCw/px7t6LbVaDYZhWPkB+VzN7MCKxSI2NjZgMpnajl3kXuYyl1WrVThD/Xj2hecwMjYDHnjYO4rh3U9Ooq+PYqUL5IfsvMlkMshkMgwPD+NtisfwWcdNiNQKxD1+SAaUeHB4sie5ycMKIOm2o8ow0IybIRCLIAjEsXnLzjl5tJn0oFZDezcT27ua0L7hDW9g///SpUt44IEHYLVa8alPfQr3338/AJwRTlc5iKl/93d/Fx/96CvavWQyeSZ96ecBkr5BzObVajUODw85P18sFmN+fh7JZJJddVqt1pY3IonBbdxKKZfLGE0A73nwCXxv+QUMD5thy9IwV04nJ2JV1HgzMAzDEt1YLAav18sOBkKhEBKJhCW7jd2iRqMRX/7yl5FOp1EsFiEWi1nz+ePjYySTSWi12p4qpIRINv4Ui0VUKhX239FsCu6dPRRzBdz68vcw9tAixh66BtqouRDD8lZ2XVwglkjwg2oAe5t7EKgUoCVifOlgGbxEDkYI2fjXgYEBzM3N4cM6CT5zcAMUeIi5jlFMpPDkleYVhmaRt91gZmYGKysrLCFrBEmZI+fb5/MhWKax+Nt/DN7mc0ClBN74IniWU42YUqlkry0yATQS3Ay9D3vwa6DjfVANCuHY28L0TBki0eu7Pn6upu9cwefz2U5yApvNBqfT2ZVbA9GWk8pu4/dACK5UIcd/XP8+grkUApkoin4HduN+/JvFN6KvCrbymkqlWFskhUKBwcFBWK3W1tY8PAr/ZPYRGFIMeAopbDoD8ocnnJqThELhGa9rLrBYLIjH41hfX2/amENwngotwfT0NDY2NlhiV4vh4WEcHx9fGKFNp9PQCGMYt02gUD6dZkeGR/CuJyfBYwpwuVwdvUrlcjmy2WzXOyrJZBKBQADxeBxisRg6nQ4Wi6Xpa5TLZZycnOCBGvJSVBo4aUMbY2+5Il8pAQBoAR/HN7Yh1+shEIuwmRPBmOuDTCaDXC7n/NpkPqsltY2FhGQyyerxO53jTql/tfCHM3D585ArNTh2HUA1oIU9dAwxFYJxUAyKoljy2qro9KjEhmy5iC8GfgiNSY/RIh+/aLuP0/s34snhWWx7nIiJRagUi9CpB/Cbj78esioNl8uF/f19DA0NtfXHbebiwGUn9W7AXU1oGyGRSHDp0iXs7+/jbW97G4BTz7ahoSH2McFgsGPCFYk1vVMglVJi50LTNKsDahaC0AlyuRyLi4uIRqPY2Nhgt/Eaqzqk8ayW0JLV7dTEJOZoGpf7FGz6CSEtrQYAiqJakpp8Ps/qfSKRCHK5HPtZRSIRstksCoUCQqEQisUihoaG8M1vfpPVxA4NDaFcLiMej7MElPiDlstllpg2Wy1SFMX6hhJ7pr6+PtA0zXbd0zQNDaNF3/rT6BfwsfDeN4BXBRLHAcgtF5Of3s6uqxOSxRxivApkRh1e+l+fh2F+GqWMEduUAg9fe/wMwXh0yAYVX4z1qBeU1gJlIIMRafNGt1Qqda4FHEVRmJuba9kk5na7MT5+WmlxuVz1fpa693d87WYEd8X+acTDRexvBHHizOCD/3IBRTqEfCUOEd39ooFr5C4XCIVCdnuwFhaLBS6Xq+f3qCW4tUT/6Y2buOVYQ79EhPChCwK5FKFsDl9MUJjTmNgKd7MxoBMoHgVzvxyLU6dbuFmRGltbWx09pPv7+8/ovrlCqVTiypUr2NraQiQSaSqt4fP5KJVKPb1+Lebm5rCyssK6VRDI5XLs7u72LMepBUnXuv/6Eh58kMZJKINqtYohjQT9/X0ABJy9SjUaTcvAlFrE43EEAgEkk0lIpVLodDpOFb79/f0zZJdoKdvZUgHd6/AJBvvESO67wZMKceldT4LHAwbGR/C6yw9AxtBIpVLw+XwoFougKAoSiYQluWKxuOn50Wg0bOOn2DyEHx/YUcxmITJoQKcK8Hq9nP1rw+EwZ/lJKp1HPBpAOhnDs09/AQ899i6oBoYwZBzD0jw3VyIej4c3jszBnOLBYrFga2sLvAoDtM+baIp+qg+vE5nw/qcewvGJD0NSJXSi0+uczOvEOUkul8NsNjflGo0uDrXf+T1Ce0EoFArY3t7Gww8/DIvFAr1ej+9///u4cuUKgNMb7Mc//jH+8A//8A4fKTeQVU9tHKhWq0UgEOhJz0W8CP1+f1MPW6VSiYODA/bxZAAYHR2FUqmE1+tlrZxqvRy7jT0EwFocNaJcLrONPGT783Of+xze/va3QyaToVwun26hp1Lg8/ksERUKhZBKpSwZJT+93Fy1vrq/ev8T+EpoB6lAGBS/H3qJAoPBHKIqbnG97dDJrqsd+nl9SJ2EkIsnoJ+zQT1mAipVqJXqltWy+QEj5gdOCbRb5G66vQqcBlicNx1NKBSyHeS1PrekOUEsFsPhcKBYLHZN5sgWeSqVYquMlWIfBvVilEsqiJUC+I9SkKkEoKy965u5JBlxQTsfVrPZDK/Xi42NDczNzZ3LNowQ/bi8HwN9YcTdJ0i4/NDN2KAYMcJ2aRYL2t4CMJq9H3C6C2QymbC7u9u20iwUCs8lCaBpGvPz83C73VhZWTmzM0Pinc+L2nFtdna27l7SaDQIBoNtt6M7wel0IpPJ1C0AhvXNd0M6eZXyeDzcKkfx+e98CcoxEy4PGPFB2/2szjQajSIQCLDjjE6n60qWlU6nUSgUmjY/ES1lOw1vL+Tf5/PB5/Phd598L/5i+3n4SxUo1Co8yhvEuPr0e28suBC9KUngIjI9Uvkk1VytVgt71Id//+W/gFitQLXC4IVvHOID5gU8ed/DnI61cXep1ecOBoPw+/1IZQroo3jQm8bxwKvfiirDQCgSw2zsfpFdKpUgFAoxMjICj8fTk01mMpmEUCiESTEAdb/odMfX9ErxgqIo9pqLRqPY29sDwzAwmUxnroNGF4e7WWpAcFcT2t/6rd/Cm9/8ZoyMjCAYDOLjH/84kskk/sE/+Afg8Xj4jd/4DXziE5+AzWaDzWbDJz7xCYjFYrz//e2rQHcDiB6lXC6jv7+/jtCura2dq0GBdHSTlZjRaITBYEAul4PD4UA2m4VGo2EHT3IhN1bu+Hx+U9JyHtA0DblcjvHxcUQiERSLRfzKr/wKdDod5HI57rvvvp71nVzQzFd3yjiKlw420V/l4Y2X70dfFdjZ2UEoFGJTlLpFNpvlZNfV7hgfNtqwNhQHxaMwaDWDVypjtCTAxsYGxsfH224Dm0wmLC8vw2Aw3LYGI6VSCa1Wi93dXZjGRhHMpRDznrAEiNhBtUNtcwTRZguFQshksroq41RxGH/90gaGhgGZUoSxORUGCg9hY3ULOp0OJpOpp/N0nshdgtodlmYwmUygafrCbMPGFYOgciUwxRKWPvQLiDncEIDChKL9zhQXNLtu9Xo9YrFYW910s7SwXkB0fuvr67BarXXxohflBkF6EDY3N+uqdkajEVtbWz0RWiJhkclkPVfjG71Kd3MRPJPzIVfIQ1wqYiXsRTL6HbxBOYZsNgulUlmnge4We3t7mJpq3fzFJUGKK4rFIptMR8j+71T7kbUWYTWPYn9vDz6f78xWf7NkNPJ6ZNyoreb+rfNlVCnAvbaJPj4f+vFR7IrLeCOH42eqp9XLZjGxDMMgHA7D7/ejWCxicHCQ1X0bRuL4ytNbEAgkGNAMYViVwaCq+7GfhAtptVq4XK6WMpF2II3iQPOwnVqQAhhxvHA6ndBqtTAajexuJpEejI6OolqpsMd5t+KuJrRerxfve9/7EA6HMTg4iPvvvx8vvvgiS/Z+53d+B7lcDr/+67/OBit873vf+z/Cg5aAYRj09fWxFwlFUaAo6kJ8EWs9bJ9//nmcnJwgl8vB5XJhc3MTOp2OrW4DzSt3SqWSNV6/SE9EYrZO0zSrm33ggQduG5kNh8PsDds4QJtlaigslxAKhSDoO70l5ubm2BSl6enpriuaXGxfGkGidMkxLvF4eOZoE8/HypgYGsdjxmkMik7t3To1AxKrN4fDUVe16UXn2A4mkwlfeu4Z/MH2MxAMKBHcPsDrzHN489TVukVZbXNEKpViq3lkO3FoaKitewbNKDBD/xqEl9w42HNiRvIg5ieeQrVaPXf4yHkjd7mApAM1Nq/0Al6+hDcITLgxq0SklMP45AQeqA5A0X/+8xqPx5sGbtR6SDdbSAmFwguRBACn5K5WgjA+Po6bIRee9m4jpBPh0SEbxPT5xsZaj1pCsMh42+3Ym8/nYbefNt2cN6Chtmr7zAtfR9x9gpNbe3DfvIWRpUtIyqX4R/Ovhvycc5zf74dMJmu7KCaEplN1vhPI2NuokU6n0xgaGgLF48Fms2F5eRlqtZrT+MTn86HRaM5UcxGxg5eMIbC+B4FCDqVWA8fePnyaacjl8qbj+F4iiL/cfQHhXBrlowD+zcgvQQope+x+vx/5fB4DAwOYmJg4c3zWYSU+8KQV/pASM1OTiIQD5/7OdDodfD5fV+NZNnsal1x7TrkEdJDdNmKLuba2BpFIBLPZDL1eD/+LTyP+lf+Iin0flfIuqpnu5rWfJ+5qQvu5z32u7d95PB4+9rGP4WMf+9jP54AuEGS7hmEYCASCui5/svXVazJYLQixYRgGt27dQiKRgMfjYSsTXBK6RkZGYLfbLywiEjiNPBSJRHj3u9+NUqmEw8PDnvWm7ZBMJnFwcACJRNJWOtFs21iv10OpVLL2Qm0tzxoQDoc5d9ETg2+VSnXmGOclWtguP1pHDqVSKadmQI1GA7fbXTegnbchrBHJYh5PMwEkQ1HQmQxy0RSelbtwpTQJxulEKpViqydki9BisXSdgLS1tYXFSw9BKpXCUPGCoijweDzweDyMjIzAZDLB4/Hgxo0b7I5ENyDpZLeT1Gq1WlAUhZWVlZ4N4bPZLHZ3d/HGVz2Kt/H5bBOs1+vtqHnkgkQi0VRfTVEUZmZmsLm52bRiR7T/FwUiQfB6vfjDr/0N9iVlJMLHcB3ReN7vwL++8iRE5yS1SqWSHdvIvUoCDbje66TZqJdFbzMUi0WEw2HEYjHEvSegaQrSwQFUygVIBtVQDA5Ads73YRgGHo+nzoWkFYiWsjF8ppPPK3nM7u4uKpVK07G3toBCURSmp6dht9uxtLTUw6f6metCqoQon4+H/8UvIbx/BM24GdfUZjAMwzbiAacuAwqFAoyoH//N/kOUmAqy4Rh4Uj7+8IWv4x8aroBXKEOpVGJ0dLTjuS2VChjSqiHg98FgMCCRSDStOHMF2WHrhgM4nc4z1WW1Wo1wOMwpnY+iKDbBjkhgCscOqG9+DY5kFmWGASI+4NYNVH/tI+B1YbH288Ldq+79e45Ge5HaMr5Wq0U4HL7Q96tWqxAKhahWqwiFQmwjXeVn2wjJZLJtdXRmZgZut7tl+EO32N/fh9lsxsDAAPR6PcbHx+HxeC7ktYHTwW1jYwNHR0eYmZnB5ORk2wG4VRe1UChkKzg3b97kNGmTpr9OA348HsfKygoikQjm5+dhtVrPPCeVSrUkoKQZUKfTYWNjo2lgxcTEBPb29ji9Xi9wRgNIxxOgBP147r9+EtVqFdVcAbsBD2QyGaamprC0tITFxUXYbDbo9fquyazL5Trt7v/ZpKJUKpFI1Jv9UxQFs9mMq1evolAo4MaNGwgGg129j8VigVAoxO7ublfPA1Cng28HjUaD8fFxrK6udt21XywWWWkEWbwQRxeTyYRSqdT1Z25EO321WCxm7a9+XpAMqrErLCJ66EYsGEYVVYTzaTzn797Mvhm0Wi2USiV7zkkTFhf4fD7s7e3h8uXLPZPZfD4Pn88Hu92OmzdvYmdnB+VyGRaLBb/yxFuhGDFCYdBg/LUPIhdL4Cqt7ikStRZOp7Out6ITZmZm4HA46q7vYrHYNvY2mUxieXkZKpUKc3NzLT1ha49BKpVCq9XC6XR28WlOX2d/fx87Ozv4Z695K67MXgJF05APaaHLAO+bexAmkwmzs7PsWDQ0NIRisYgfrr6M4619BPecsH/le0gcB5GIxJCT8HHt2jXYbDZO57bxvpmcnITP5+Pscd/oykBRFNRqNef7uVgsolAonJFmaDSangI6iARmll9ABTyE0zl8a8sDVBlQhQwQvdggkovCXV2h/fuMWpcD4kNLQBogLqLjtlwuw+Vywev1AjgdnKRSKfL5PORyObu9mEwmm241EnTqbO8GyWQSpVKprtpLdEO9COFrUS6X4XA4kMlkMD4+zllf1kn0Tsj3rVu3OlYAo9Fo21QvIhno7+/HzMxM2y22TCbT0ZGAaKHC4fAZlwupVIr+/n62wpJKpXrWZ+fzecTjcbZZi2EYpJkyKvkiBFIJbG94FKZrc6AFfEyPT3QtuWgGEj5Qq+GWSqVsGEAjyI7E8PAwXC4X3G43RkdHOR9Lq8z5TiBd/lzIulKpZPPouXZel8tlrK+vY3JysuV7zMzMsN3LFykrqYVWq0UkEjlX9akbpEsFMMUiqgC2vvQ9VFHFgF6HvYoMV4SDTT16u8XIyAh2d3fZJkqpVNox0GB/fx/FYrGj+0Mj8vk8wuEw4vE48vk8+Hw+1Go1xsbGzpzXSbEYvyAfw8aUErRMjCtPXMNgtNiy2ZPr+ycSia7GWZqmYTab67bRybE3A2m4bZfeVywWm563kZGRpsb+rRAMBuFyuTA8PMzer7+jfByxYhZ9PAoO+zaYUhnoqyeLRJc7LeZhsC8GhmEQPXCDFvZDKJdArVJ2fO9aEBvF2vcgzYdc7vFmqWvDw8Ow2+2cdkWbVWeB89vd8SVSWAZkCKUymNHV8IP+O+cS1Q73CO0dRqVSQX9//xn92cDAACe7llbI5/Nsx63JZMKrX/1qBAIBbGxsQKFQoFKp4P7772dX2YlEouM2W238KWvD1CXINtTly5fP/I1ILXr5zGQbLRgMwmKxXHgIA3BKpK5evcrm0U9NTTUdqEKhUFMSms1mcXh4CIZhMDExwYn8dKPnI5oy4nKh0WhgNpths9nwnRd+jJJZgwP3FgbGzRiWtpeZkCSpxmYtuVx+xs80MEDjyy/+GNqxYRSzOUxoDLg2eP7UJYZhsLOz01OTDU3TsFqtKBaLcDqdODo6wtjYGCfnCqvV2jWpJT6sXKvPcrkc09PTWF9f7xjbS9xIrFZr20meoijMzs7Cbrd3TbQA7oEbtXra2qpUN2lhnZDNZnF8fIxgJAxergSmWMbiL74FfIkIcvMQZg1mJBIJeL1elMtl9tpUKpU9JRmS9EKhUMguhpoRWnIuVCoVp2sjm80iGo2yBFYoFLKxrZ0WHcViEYM8If5/r3rLK780Apubm3C5XD0tTHd2djAxMdH187RaLYLBINsb0GxcIlriwcHBjk3E6XS65U4Rl2a0bDaLnZ0dSCSSM4/j8XhQ/yy6d2xsDA6Ho2XD55xqCDqRDKFcGuqxYQyOm9EXSqHsDaMs13FeLDW77klTNbkf26HZAoHP50MgEHQk9+VyGalUquWcJ5FIeg4N4c08iKPvfhFVUFg0aQHwUB0cAZQXIz28aNwjtHcAtQbFZGu60fJGp9Ph8PCwa3JHtC8Mw7B2XLWv+fjjj6NUKmFzc7PuAm9cYbaCWq1GIpFoGu3JBS6XCzqdrilJMxqNnFektSDNVENDQ7h27VrXx0TAZRIkyVXEDN5isZyp/jVuP5Go4lKphLGxMc4DS6/kgLhckG7ppJCHzwbsoEI8FFI5uNa+g9+49DpMKE6/Z+I0UBuDSpKkOjVrAcA7R6+geHgCalABKlvCO+dfDZrqwUSxAU6nE3q9vunEL5FIkE6nO24HkqjlYrEIh8PBEttOiTkkctfhcHCqZgkEgq41pFKpFLOzs7h169YZC6la2O12GAwGTmScq81WM7RqCGtE7W5NLZkg1aBeq8OkKcXv94OmaRgMBthsNvQNyPAfv/l5KKynVcmrUOHVE/X6dLJ7cHJywoZcSCQSKBQKKJVKTmMb8agdHx9n7aFqr/t8Po9bt241vecJCIGNRqPsd6FWqzkR2Ea4XK6mVbfZ2Vns7u5yvjYJwuEwBAJBz/KIqakprK6uQq5QIJROQCZ4pZPf5/Ph+PiYs5a4nfSJz+fDbDZjY9OOok6OXLkEm2IQBomSlRdkMhlMTU11PK9KpRJHR0ctG6P4fTR+5/IT+DvnOlZ8Cdw3Mo2nHppHIZXG6uoqzGbzufpGap1g2hVZ8vl8U298i8WCg4ODtv0YHo+nrdZ2YGAAkUikJ0IbyZeReu0vY2D3p8h63OA98HpU1dFzy15uF+4R2juE2hg5soKqhVgs7srXMRwOw+12g8/nY2xsrO2g0t/fX6fZ7ZY4WSwWbGxsdN3JT0IWWon+SegBl2Qi4HRr//DwECqV6kKsZWia5lwRJWbwxN5LOTyEzxzehCsaAB3OwDA9Dq1ACofDgVQqhfHx8a4jLM8TUQuA9bP8nW9/GrlYArHjIBQGLZKBMP5H8O/w/pFThwviNDA8PNzSuLwdQqEQHhqfY22P+i+AzBI3hFYTtkKhQDwe5zw58/l8TE9PI5/P1xHbdoO8zWbD7u4up8WbUChsKYNoB7FYjEuXLuHWrVuYnp6GRCJBplwAwIO0X4Dt7W0olcqurKS42Gw1QzeBG0KhEGazGVtbW2wFnZD6bolbPB6H1+tFPp+HVqvF/Pw8WxnL5/Poi+fwmw+8CaOzk5ALxDja3T/TpCQUCtmFHEE6nUY8HofT6UQul2MbEwnJbbzPKYrCwsICVldXURVk8Mzmn2JQr8CI7AFQ+QHs7++fWXik02m2AlssFiESiaBSqZp2w3eDcrmMRCLRsgo8OTmJ/f39jkSJgHhv17radAuapsEfVOHXv/SnyPAYCKUS/ELxOkZSp+e+mzE4lUq1DUCSqZX4sx/9LVJOHsQqBSjw8DaVDepcFWazuasduPHx8bakUNovwLtGF3ApL8S89fQxErUaSqUS+/v78Pv9LXfjgM4WjSaTCZubm23vx1Kp1HSsF4vFYBim5X1F7MTaFXLUajW8Xm/XBSiyy3vl+quwIZJBPlcGdd996HP8dVev8/PEPUJ7h1Br19XKx1KpVJ4ZuBtfw+/34/j4GEqlsquYWEIIlEplT8Rpbm4Oy8vLEIvFnLdZd3Z22voeAmBNpdsNWLUa1Pn5+XPbmxGQCZnr69E0jbm5ORz5vPjtL/wZBEMDyKXS6KNp/Jtvfxq/NLSAucnpnuUPF+FIQFEUeEoxBEk5Qj94EeE9J6affBh9Y5qeu4kb4fP52GvvIjwK28lSCJRKJZxOZ9dOIEKhELOzs3Xyj3YLwMnJSU6kls/nIxKJdHUstcd0+fJlvLR8E88yYbiY08bLoQwP7xxd6Ekv2clmqxm6DdzQarVs5LXJZOqqSl0sFnF8fIxwOAy5XN6yk3xrawvDw8MIh8Mw/EwmQyqFjQlGjSAphuQaIdZxiUSC9ROlaZpNViM2gkPjAvzv7/0uAGCCP4Dntz4PG/1+vPb6u5DP5+F2uxGNRlEul1kC247w9AKn09nxvHcTr+zxeKDTcd9Cb4YyU8HfBG4hVcwjl84CFIW/+P5X8RuveTsetXU3xnVa+HzXu42KToH0rgPg9SETDOGvJUH85bv+Cei+7j4D2WFqt+1OmrNrQVEUJicnkUwmsb6+3rJ3gksBZnp6um1ceD6fb+k2NDo6CqfT2fQce73euqTUZiANq90Urogr0uzsLPv82+VnfpG453Jwh1Br29WqQ1qiVuJb9hv4sW8fodwr7gKk0Wt5eRmlUglXrlyBzWbrakAl2xAA963GWhC93ubmJqfubp/PB5lM1nHCVCqVSCaTqFQqdVZmwCtd3gcHBxgfH6/r9r4IEB1kt4jzqxCY9Yj7Alj7/LcQ9/pRovsgsp1NX+kGqVTqXNny6XQam5ubEJwkIRSJsPi+N+PyO58ELRBCEsn31P3aiGw2y5pwA52b67hgd3cXZrO57bntdgej2fPn5uYwNjaGw8ND2O121sexEZOTk8jn83C5XC1fr11aGBfw+XzsSktY3rqFfDKNdDCCraAH63RvriJEFsD1/uz1nNlsNvj9fqTT6Y7fQa3P5dbWFqt/nJycbDouuFwuqFQqZDKZuspWbZNSNyBpa2azGfPz81haWsLMzAwkEglCoRDW1tZw8+ZNfHf5f0As7YN3P4a1l9zwHSaxG/8m1tbW4PF4wOfzMTMzg6WlJczOzsJgMFzoOEQiv7lsdVssFkgkEtjt9paPKRaLCAaDPTeSEYTzGYTiMfSJBNj86vcRPHBicNyMQF/vTUet3yuNSqmMZDCG5//r/4ZILoXYOIhcpbcFM6nStkKjy0At5HI5rl69ilwuh5WVlTNzRCaT6VgQIvfj9vZ200V/oVBoSfCVSiUymUzT5wUCAU7NmQqFgrPjAnAqcyL2is0cGO5W3P2U++8piH9kpVI543IAnN7Q/3X/WRzs2KHlRdBP9eEfT7wKdDSDZDIJo9F4rm12pVJ5GouH00ogSRfpBsTGp3bbsRlINYaL72GJqeDZ7DH+29+9DLlOg0f043j76GW4j1yIxWI9bd1zhUAg6KkjlMfjgaIAHsVDuVRClamgkM6gkO2dcAGnA2W3FldAvfxkZGQEvzsxjj/Z/DE2nPvgURSuzc3iH47fD6/TxSbL9Kqra9RvEW1rr0Q8Go2iUqlw1q2dtwmp1tN3b28P/f39sFqtZyaX6elpbG9vt2zGuYjq9F42CuWYEfavfg88isbsWx7Ddqx3e5xmsoBWaNek0w5kon7+5g3sCLLw+E5wtTKPN49cgvBnPpXJZBLHx8dIp9PQaDRswlKn4yHuFjdu3DhTHSdNSu12sLiARKbWXm9Hm3+BfIRGNJLF0V4U7/jIHFTKPizNXMyORieQrn2uGBkZaRuvvLe311MoDtElJxKJ0+bQUh7pQBi0WADLw/dhcMyM8IEbMZ4KaW3zRUkzdNqiz+fzKHnDiLmOoTRoMPOOx5AOx4B0HqW5HMDvXsohFAohEolaXi+dpGYURcFqtSKdTrN9HhWlGJ/efwl7u3sYHx3Fh6WvxZC4dWGIBBg0a6ru9P7EZ7v2PvD7/dBoNJzGP1LA4jJ3ulwuSCQSthhDdgpJEuDdHIF7j9DeIdRWaJtdkF85Wke6VEC/WIR0OI5iMoU/dvrwB09+8EI6+EkiWblcPld6lFarRSqVatt1u7e3V9cV3w5fPFzBDpNEOhKDaFCFv1t7AZ7NXXzgvtee29KrE/h8fk86yOF+GYpHfghlEsy99bWgQEGn1UEQyWAtvoaRkZGeJ12uZI1EZgYCAajV6jPyk9++/Di2lFYwlQrmxmzg8XhQ/GzrvVPqWCuQLdza61Emk/XcUUss17jq/GQy2bnIcy3kcjkWFhYQj8dbhlVMT09jc3OzpW3SeQb6YrGIwnEIsbAf+vlplHJ5xI+8EEtSCJqDnCeuRjTKAlrhPPKWSh+Fv8s44d32guL3IX68i93oCd6vmUE0HIFIJMLw8HBXzZDb29u4dOkS0uk0RCJR08/OVXrQLUYGFlCmo3jsXeNwbMQgVQhhUHTvtNELyuUyotFo12NdY7zySS6JSD4DSfm0eacTkSkWi3XktdbVZGhoiI0A9w0K8I31F6GfGYNMq4HUPII3jN2Ho6Mj5PN5Vsfcbnu61bVG9O2FQgHvXHwIOa0Uz730U+imx5E69OG3Xv9unPh8cLtcPS3CrVYrNjY2mo7FzSQHzSCVSrG0tIT1vS184oufgXREh2wui5NSFv9l4xn8u6Wn2gZ+KJVKqNXqrm0B9Xo9bty4AbPZzF7rHo+H81hZW8Bqh3A4jEQiUac3Jg18FxFtfbtxj9DeQfT19bXUpoRzKTCoIukPwv3SOqwPX0daKUcikUCxWIRYLIZQKDxX40FVzMd3tpeRTcVxpcqgj9fbpGC1WrG2tgaZTHZmsIhGowDAmdCthD2olMsIH7gQ2D3E8NVZJEdkPeWrd4teJAfEB/ETb/8Q/mr9x/AJYpBVKPzypddgYmiY3ap2OBwYGhqCwWDgNPlyXWTU2rPp9fqWVXsej4cBoQTFYrGuQ1UsFnNKHWsGv99/ppIqlUpxctJbVXFnZ6dpuEQrEB34RRBaAqVSicXFRUSjUWxsbLDJZuT7IDKb83iB1iKbzcLpdKJQKODtc/fjcwE7qpUKIg4PBics+NDEg8hkMnC5XJBKpTAajV1/XpvNhpWVFdbSqhm42Pa1wmrEg4KYRr9EAO/yJsAwCDIMXvOqETzQg33Y/v4+hoeHIRQK4XA4Wt77zfxRLwJXBj+IVPEECd4yFAMClMJqXJv8Rxf2+u3g8Xh6Tkwk8cr/6Rufw77itFAS3jnERx57G2rpOJE0pFIpJBIJlMtl8Pl8KBSKM5Z8jXivdQkZxzGoYQ2UIileZ5yEgi8CtHqUy2VWUiIUCmEymeqIdIVhsBx2Y+tgF3OmUZC7p5bI1jqQfET0ACZSfRiZsqF/LAdhAbCcYxFOPmMza8h2koNmSMn5kI5oETk6hufFNciGtGBQhSMZxpy6vQSg1+RNrVYLv98Pg8GAcDjclQczKWC129Fim8AaSDJp4CPPuyc5uIczqHU5aHaBDEvVcKdjUI+YIBCLIdcNwmoYwcDAAOsWkMvlWAJGURQEAgHEYjFEIhHbrNXqgl8Je/Df3TcQPnRDKJfCtUHhNy69tucO9bm5OayurrJEm3w2LhW3WqubyK4TaV4FMpMeTK6AYjaPyIEbbp0bWq32thnGA93n0ZMAB0Ii32m4hMHLgxAKhdja2gKGTiflyclJMAwDr9eL5eVlKJVKdsJuhU7JbdFoFG63GxRFYWRkhNNWUruBiKSOESJXG87QCn6//0zncLvQg3YIBoPo6+vrqpItl8u7ThXiinZhFcTrtbHq2Y0Pazwex9HRESiKwujoKEtSTTo9Xg65cBhj8IHLj8MiP932s1gsSCaT8Hg8yGaz0Gq1GBoa4rTw4BKKwtW2rxky+SwSxwEU0xlkwzEohodAC/hQ6bqvKofDYZRKJZbEdqpWXpT0oBb9fWK8dvj/hpXeRkqdRC7BA5+6uHS9VuDSsd4J4f4KNnlJpPbCECgkoGVi/M32T6Ep8tBXqLCNcMTtYXh4uCsil8lkcL9xHHMzZyvWNE3DZDLBZDIhnU7j+PgY+/v70Gg00A3p8Se7z+EgGUJ4z4XnSwEcl9IYLwrPEFn2s4TCWLRMwDBgAAaAmzdvYmho6FyLcIvFgtXV1TNEkkj/uKKPR6FcqoBXZSBQSJAJRpEqlbBduYW+oQRUKhWUSmXLMX5mZgYrKyvoFwrgr+RwmIpgtlyCqE2cLKWW4eNf/TTosSGUXH589PXv5ny8AKBSqRCNRpv2dTQ2gdWisbhyT3JwD3WoVquoVqtshbYZ3j56Gc5UGOG8BxqbGaXjKN5rvgylUtnS8DufzyObzSKbzSKRSCCXy7G6PpqmIRKJIBKJ0Mfvx/+89QNQgn4U4inIDVo4kiH8wLeL15tmevpMNE1jenoa33npWezIKkiWC5DF8njX1PUzN0g2m2XTcmqtbqampvArgyL8zcENyItlxI+80EyM4oPj94Ou0tjb20OxWIRKpYJOp7uQ7PRaEAlGJ5TLZdjtdqhUqjpCl8lk2OqGRCKpszUjxHNkZAThcBg7OzstyWiqmIcj6Meott7WhmEY+Hw+nJycQC6XY2pqqmuC39ho1whC5Eg4g1arPROTyVSryGWzrM1aLXppCisWi3C5XJw01rU4b2MYF5CwimAwWBdWMTc3B7vdzuafA9x8WIPBINxuN0QiUdNwjXGFFuMKLTayAhiF9ZVYuVyO2dlZMAyDYDB4umjCqT1bJ0mCUCiExWLB1tbWmUVIrzrkcDgMr9eLvlwaQrEYSqMOPB4FvkAAMc3HqKx1Wl4zkBAMsgBOp9OcSPbtkB7weDzIhXpUCyIMmATweDw9J+xxBfHSPg+OM3GIlHIUs3k89//+FRY/+DaAqSKJCh64ACcGj8fDaWdCKpWyC/lwOIzPPvt9vOi2QzyoQjF3ugD61KEH//mpX8GsrnlFMxwO112rJMab/K5xEa5QKGCxWNoSdJqmodVqzyxGSZWaCxiGQX8wBV40BY3VAqlWA6ZQxPjcLN62+BgK2Ryi0SgODg6Qz+dZJw1iF0eqpSMT4/jtr/wFKjo5UoEIbi5n8NFLj0EvPrsDky4V8F/tP0Csr4Kq5xjVcgn/3+6z+HdLT51WyDlgYGAAJycnTQltbRNY42dt9v93K+4R2juETpOIpF+A3114Pb6WoDG1cAnGV8mxt7mFoqZ5VYaiqLYWWkQrm81m4YuFEQsEUS4Usff0C8inChiw6HEjWoEpUWW71vv7+9n/J+SFz+e3PO40VcHfxR3IuJKQ6DTY8/rB0ynxTzWDiEYiTQls42d5ZMgGYV8/XgoewRPO4RdnHsX8wOkWnMFgOI0ojEbh8XhYY32dTndh1ZlOyGaz2NzchNVqPfOe5XKZ/W6IV2+zwYOQpGw2C5fLhYODA9Yz9htuO77psSNy4IJhbBT/XPAYTAIZPB4P4vE4dDpdz82A3TxHr9ezA//y8jKMRiPU2kH81f6LWIt4kXT78ca5a5j9WXNjLQix4zpBbG1tYXJysufPdFHpVO1AGodIWIVWq8XMzAzbXW4wGFr6sNYuRNRqNSerOZlM1rLTnaIoVqtIGi65SBI0Gg0SicQZuUQ3tn3FYhEej4etiJJF1VBsDH+19xLCdB/UfQJ85NJrIG6jJWyGnZ0d2Gw2lpCcnJxwIni3S3oAnJ47vV6P5eXlMwu7i36fYDDY9aKuERqhFJlIHNFDD668/60QyiRQDg9hYri9awjXY+xWs05RFLRaLTQ2Mwb6EjjZ2sfed5/D/R95H4RyKSBqfky1hRgCuVyO/v7+M/7nZBFOFp3NFuG1GB4exvLycp38q1UUbyOi0SgcDgfMZjP+0zv/Eb7kXIU/k0DZGcBvzj+GfqoP/Q3WXETiEYvF2NAjkUiEb4f2UZDykThwQ6RSIFUs4K/2XsTvLDwBhmFQLpdRLBZRLpexEnAhFAiC6aOw8/VnMP+uNyBfKWE77sf9Wm5SIblcjr29vTO/dzqddU1gtchms2fGhruZ2N4jtHcIDMN0TNugqT6MyNSYUZ0O6pOTk5xi9Jq+Fk2zHngqzQB04VvIZjNYeN9ToCgehHIprl65Aqv2NC6U3EjFYpG1DCmVSigWi2cuaIqiwOfz8VzwEIVcHolQGNvf/CGsr30AL9+4gZtlJSYMw5y9Gu/TjuI+7SjWykrMKOqrlBRFsYQQON2aDwQCODw8rOtYvh0TD6muNYsqbdRgtdNrEYjFYkxPT6NcLuP4+Bifeeab+EbkAJLBATDlCtLZDD72tU/hX8y8GhbzaE+dyo3oZjAiFWSTyQSXy4V/9+VPwidi0C+XIJNO4ccJN/S+QbzWWN+kSJwOuCwyvF4vZDJZzzrY87oqdAuDwQCDwcASfbLl/VLoCN85uoUSD7g+PoMPTlwHHxQ8Hg/C4XDXCxGFQoFYLNZRY8fn82GxWFhJwvHxMXZ3d1tKEqxWK6unJd8ZF9s+Uo0l30GjDGBWZcAfXn87thU7MBoMkEu7Ox9erxcikahutyIej3O+5m+H9KBWM6jT6eDz+br2PeYK4id63nFLGi9gmBEipVJAPzuO8IELDyuG23bfc4Xf728bhtAOBpECUY8PYrUCs295HYRyKWgeBa2ouZQjGAw2JVg2mw2rq6tQq9Vnvisy9pN7c2hoqOn5oigKQ0NDdVX3SqXSltCWy2Xs7u6iWq3WyXY+PP0wAGBfsY9yOguoz+7O0DRdN2cBp0TR71lBPpOFd20TpWwettc8gFifCzfLatA0DZqm0dfXB5qmUchkwJTL6Of3Q6ofRD6RRjoQhpunxTgla/p9NENjeFA4HEYqlWoZOlHbwHdPQ3sPLcGlqtRIkuRyOacYvU7op/rwq5MP4j9867NQGLTgS8WQh3OwFPg9NZoxDHPqEctLoz9zAh54qJQrKBdLUAwNYnxyAgZZc9PodiBNP+28XOVyOTsx5/N5BAIBrK2tscRXq9V2VZkg9kuNg5vD4UAul8NiiyaXZp27rfRajSAVpptMFMLcMU629rDzlacx/+43YMA6DMPUODQSJefP0Aq9DkQURcFisSDmEiF3HMDmt3+CwanTqsBqxHOG0MpkMqRSqY7EIp/Pw+/397RAI7gdjWFcYDKZWGK7HnDj8/YXINaoIJCIcNN3CLfDibcPzcBkMvWkiZTL5XC73V0/Ry6Xn5EkkGo7Of9zc3NYX19nJ+ZWtn214QdKpZKTxEUiFiObzXZ1PrLZ7JnrIJlMdi0pumjpQa18xmQyYXl5+bYQWoZhEAgEzlWdZRgGdrsdCoUCv7b4WuylQuhXyzE4+TDyLv+F7GL4fL4zdlNckM1mUXUF8drJy1gvRRE5cKFaYvCrlx6CpP9s3CtwSrQmJibO/J6maQwNDcHlcrVsYiT3psfjYZ0BGsdgk8mEGzduwGg0ssFGrQhtOBxmg1VazUVGoxEHBwecF1NisRjjI2akRBTK911GtQqoLcMwqwextHjWHm6kYsHzlTAi+Qx0k2PQWIah4IvwqG0BiVgCR0dHLHFuN+epVCoc+Y8xbDChWix1TI9LpVJ1uyQ/j92w8+Aeob2DqE0Ia3aRNNsK5BKjxwXT0kF8ZOJVEI8ZIKEFmFbpcXTILXWmERRFQSgU4lUjE/jbl34ErdWMgVETUGFgECtwvL2HwoAGw8PDXZFLQoy4hhMQ302z2YxyucxO6uVyGQMDAxgcHOw4Sfb39yOfz7OPq9XLtvPybJZNTtM0q0flcq6k/QIIVQoM8oDMw1dRrVYRO/IhZYuCEckvZCA5z3ZRJZ1HMZOBUC4BUyqjUixD0CS1Ry6XIxgMdny9ra0tTE1NnetzKZXKtobptxOkgl1Iu6CI6bD3wxdRjCcw8cQjKOo1mL+yAH6XqUYErdIDuR5XoyRheXm5TpJgHR/Hn3z/yzhSUvBtH+ApwWvwXusS+qk+hMNh+Hw+MAwDg8HQlfuBWCxGKpXq6ni3trYwMzNTdx1wlRvU4nZID8j9QhbIPp+Pk5F9N/D5fHVd5N0in8/j1q1bsFgsUKvVWF5exuM1uwFBnEYoz87O9nyMJDij27Qo4gIzNzeH+8RiHGfisMt2MD5ogHWwuRaXFEhaLZ5MJhPbINbqMRRFwWw2w2g0wul0wu12Y2xsrI5wms1muFwuWK3WpoS2XC5jZ2cHPB6vZTMlAQkg6EZq9QuWRdzcugXJ4AD6hQJkPAH84vU3NX2soI/Gb19+HH97uIobrgAWNcP4hbErUAsk0KlP50cSoEHmPJVKhcHBQXZxGc6n8T+9N7HvcEBpNmA0UsG/eP07236u2vTAiwjNud24R2jvEBonK9KQVHtxtdK2dYrR4wKn04krU7N1W3xWqxVut7ulQXc7lMtlBPeP8NFH3owfpDyI5zPo90Twrx5/D6T9QgSDQWxsbEAikcBsNnNq9lAqlew2Z7egaZrdHiaNCS6Xi60e6XS6M81YJ9kEvuvfBRV34n7rDGbEGmxvbzfVyzYikUg03Y4zm81YXV3lRGgf1o/j2ZMD7Cd9MC/OIR2M4D2vfj1EvD4sLy9DrVZ3vSioRa8TZjgcxtHREa7JDHjZxgePR0Fp0iN26MZrFh4783gu9mculwsDAwPnbuzrNd3tIsHvoyEf0kI5akDGL0SVYQCGAdVBUtTxdbvUIrd6jWaShN1yAs9FPKASPJSqFfzYvYuwx4eHZKdWSxMTEz05igiFQoRCIc6PJ7ZcjeNBo78xV1yk9KDxfhkeHsbq6uqFE9qTk5Oeq7PxeBz7+/uYnZ2FWCyG2+0+I13QarUIhUJd20TVojFAhQt2d3dRLpfrpDZGiRIC03jbRU80Gm0ZA0vQ2CDWCjRNw2azoVgswuFwsEEyZLfT7XajUCigxFTqnkeIOJexn8BgMODk5IRz86CMR+MfmBZAjerBVKvgh1KQ5BighaGGgi/Ch6YexOU0H0vTZ6u4fD6fdZlgGAbxeJy930UiEf7av4FYfxWVQhGxQw+KGhVuJo7xasnZSjhBbUWWENq7mdTeI7R3ELWDTrPVTyaTaVql4GLD0w5EF9vMLWFkZAR8Ph9ra2uYn5/n9Nrlchlra2vsCvgBnFYCnHon0pE4pD/b8tRqtYjH49jb2ztjV9QM56lS1YI0JpDBPB6PIxAIYH9/HyKRCFqtFkURjf+w8X0k42FUmSpuhFxY6lPjw697K6eJvVVFgWwDcansiGk+/tWVJ/HnwTz001YIojksCvUYHh6G2WxGMBiE3W4HTdOcrboa0c1gFI/HcXBwAJlMhvn5eVzt74dxdxXPpwGTeRSXJx5AyRMEo9J3RZZrU6AuAj+vxrBWeGTIhm+98GMoBzUwTNsgVEgxWRRhbWX1XMl2JKTiPPHJtaiVJHzlmc+BKRSw++2folqpwvY4sKPX4V+8+q3n+h67cZ4gXqiNetzzSkguUnpQe7/QNA2lUnkuYtgIn8/Xs+bf6/UiGAyyc0A76cL09DRrGdjtAok0g3G9jovFIjY2NqDX65uSYKlUCr/f3/L5gUCgIymUy+Xo6+vjvHDh8/mYnp5GPp/HwcEBGIbB+Pg4knI+/uGX/hSZTBrTvAB+xXofst4gBAJB1823Wq0Wy8vLnAnt3t4eLs9cYq/18mCZdVI573VLURTbLAcAsVQS7q1nkE+lsf+Dn8J0/2Voxs3YSwTxakNzQtu4mL5HaO+hJYhtF0EzC6923pBCoRBWq7VpjF4nOJ1OjI6Otvy7Xq+vI7XtBsBisYj19XXYbLYzA97w8DDW1tbqqpNKpRILCwusoXwul8PIyEjLCeIiqlSNqLU+y2azCAQC+NRzP4I/5keFqSDq9mFw3IwdiwJ8QXONVy06kSmz2Yzl5WXW+LwdaAZ4xDiBhbEFMKMM29xA7Ga0Wm2dO4Jer+cc1sB1kEwmkzg4OIBIJMLc3FwdUbf1yXD/q55iB0qfz9d0O1MkEiGbzTa1gdnZ2ekYxdoNCPG7XZHInVAJxPCRq4/hGdcW+CoplkZseHJ4FpVSma0KjY2NdU3SSGPYRRFagnK5DKZUBlMpQ6CQgeqnwQMPQon4QiZSLhMewzDY39/H5cuXz/zt5OSk53AB4OKkB82+C7PZjI2NjQsjtFwjwRuxvb0NiqLqFoXtGssoioLNZsPOzk7HqmYjmgWotAJxAZicnGx5vXfaVclms5x2biYnJ7teuAiFQszNzSGdTuPHazfwlwcvoZDJo8qU4Tn24vc2tvGf3/qrGNIMcnq9WlAUBblczolkR6NR9PX11X1H5Lrd399vuTvRKoipExRSKRTaARQzWVgevgqqnw8eeG2dSBr7Qng83l1NZgHg7lX3/j0GwzCoVqtnyvmN1chO6SVqtRoqlQoOh4Pze5fLZU66VLVajYmJCayvryObzTZ9DCGzk5OTTckEMfAmaWG1EIvFmJ2dxfz8PFKpFG7cuAGv13vmhpFKpfAHImCY9v6pXEGqDeFwGG63Gx6PB4lEAoVyGcVsBoc/fhkn67sYGBsGwwPKDVtRzdDJ9qi2S7oTagdD0oy1v79f9xjijrCwsACGOSW9+/v7nLbe2w1I6XQaa2trcLvdmJmZwfT09JmqcyKRqDvXBoMBYrH4zDVISGYjyBbzRQZkKBQKJBKJC3u9buD1elEul/Ha+SW8a3ge//bBt+FNI5fQx6PYqtDExAQr5Wl1LzWDXC7vWo/aDvF4HBsbG7Db7XiteRZi7QCMl6cw9uAi5CY9JnJ87O/v/1wmre3t7boEtlpchGuFVqtFpVJpOvZwRTNyzufzW45p3cLn83VdjSuXy1hZWYFMJqsjPaQ6224XSKlUQiQScRqHauH3+znpmYlW9cqVKz2fv26aAWsbxLqFVCoFNTwIsUaFUiGPtc99E9l4ApJxI9L9vc81w8PDnGRyDoejqYOHVqtFLpdDOp1u+rxaa8hukM1kMZ3mQ6IdgHF+GmKZFMVoAo8bp1o+p7EvhNwPvRDqnxfu3iP7ew5CZsnFSbaMugWpGDR687WCy+XiHNlJjNw3NzcxNTWF7VwErnQUSr4I96mGsbd12kDWbgAym83Y2dlpuWLl8/mwWq2wWCys3YparYbZbEYgksOXf+hGNBKD3mDG4w+aMT3W2ay9NmAil8shl8uhWCwCOL0pSZKaSCSCWq2GUCiEiy5gJ36CiSceQimTQz6awLR5jFNTT6ts8lqQLulO1dRwOIyxsTH23xqNBl6vl/XcrQWRHtSGNQCnspFu9IMkShJAU7N/ArLAajx+i8WC7e3tOn9TuVyOUChUV52Px+PIZDIXYj9WC6VS2XYL83YhHA4jHA6zOyStJhuxWMxWhfb29kDTNKfIzouQ3BBLuGAwCLlcjvHxcYjF4lMC5PPhcEqPXCqNN8w/iEf04wgEAqzvcK9a0U5d48FgkG2yakQ0Gr2wSvtFSA+aBZGYzWZsbW2dW6N7fHzcMUWxFul0Gtvb2013w7xeL6fGMmLbRsa9Tshms6z/eCuQxlmFQsF5t5DY7TWOaYFAoCtrMC4NYq0g7OtHv0QEoUwC0/V5FDN5RA5cSA3HAEVvFXjSHNbu+ne73W2dCKampmC327G0dFYnyzBM3c4uF/j9fni9Xvyjx96CrXQImzEf+HobVCdpqOjW31kqlarbKbmb3Q0I7hHaOwxy0TdWaLPZLEQibgkgc3NzWF5ebhusAIANJWgXJdkIsViMy5cv4z98/W/gEJYgUchQyOXwxZPv4I/e/qGOq2nSGdts8KpFbZJWMBjEiy8t49sveCGSDqCQz6FcYfCdZ50YUIiglNFnCGttBDCfz2dT0QYHByEWi9sOyPv7+xirivHe17wBX37pR1CMGiEOZ/Brk6/i9B2lUikMDw+3fUwz78NmaCYzmZiYwM7OTlvNKfE5zOfzcLlccDgc0Ol0MJlMoCgKt6LH+MLWiwgcn+BRKoF3ji2iWirj4OAA5XIZ4+PjHc9lOBxuOYlPT09jY2MDQqEQWq0WUqkUR0dH7N/bbTGfF0SW8vNEOp3uaHnTCKlUioWFha4iOzuRw1aIx+Pwer3I5/MwGAxn9IBOpxOvm72Kt0qlCAQCsA2dLjKIxZfT6cTNmzcxMTHRdbWNyE2aPa9TKlw3TTWdcF7pQasJXCgUQiAQIJlM9lyJ9Pv9UKvVnM8rsY5q5oHdje0XRVFtCVMjOjWDEZLdTfMU8MoOTuOYk0gkul7wcm0Qa8TiwDD+8vtfg1yrgcpsRNx1jAevLEHG9OHGjRtQq9UwGo1dE2W9Xo/j4+Om13GxWEQgEGhr5ScUCjEwMHAmzQzorkJLxtxyuczaTS4Kh7GoOZ2r4prTfpZW8q97Gtp74IxKpdK0g5CgEwGsBUVRbCW1nZDd4/H0pE2LVfLwqPuQOvQhEYqAVyxBbTFhIx3EI7LOA/ro6CiOjo446ya1Wi1yZQFE6xlEAl7cePZruO+Rt6BaZfC9Z6KYn9KzhFWlUvU06ACnlVy73Q69Xg+bzYZLAMzxKi4tLCAViSLuC2DA2vkc1FqbtIPBYGibONRqESMWiyGTyTjZfwmFQjZykqRaRXklfCG2gyoDpEs5/NC1jd3tbbzNdInt+OWCxupxI+bm5rCysgI+nw+lUlm3QNvd3YXZfP60olbolfj1gmKxiO3tbVy6dIl9v2YJYa3QTWQnFy9mgnK5DJ/Ph0AgAKlUitHR0abXZT6fRywWg9VqRTKZbBqUYrVakc/nsbe3h76+PthsNs7nTiQSIZ/PN72u7HZ721Q4rvpJrjiv60GrydtisWBvb68nX1bgdCzmuhhyOp1IpVItx/Zubb+kUim7aGlnycYwTFu3Ca/XC7/fj8uXL3d9X0ul0jNuGN3cQ7XotkEMOP1sju0d/JvXvRM38iHEi1lQtAZPGeZh1J/KK2p3vUwmE2ctO0mWa0Zo9/f3ORWUSN9FYyWXa/Nrp8Y84HRni/hMN362Zu/zfwKhvftryH9PUetvCJxtCstkMpzjKIFT0kOy2lu9XzAY7GkbMRCPIROKoVQoYfUvv4x8Ng+mXEGqxM0uSSqVstG7XCHg06D7+QAYzCw+DIlMhWHLDK4sLmJ+fh42mw0mk4nz1lkjgsEgbt26hampqbobnuZRkPTzodfrEYvFLtQSiqIoGI3GlpqvdhVQq9UKj8fDeTChKIo19T+sppHyBuHb2MXR88uIurxw0UVMz891VWFq16RI3nNhYQH7+/uIJONYjx7ju+5NrB8doFKpXFgjTTO00uxeNBiGwfr6+hl9cbOIyE5Qq9VYWlqCQqHA6uoqnE7nmfNLvJjbIZlMwm63s4EiV69ebSsF2tvbY03r2zVxCYVCzM/PY2hoCOvr63C5XJyuP6FQ2NTpwO12Q6VStbzm2l3/58HU1BQcDkfXE3E74iAWnzbQtdI6tkMwGIRSqey4+CJhCQzDYH5+vunxMAyDk5OTri21RkZGEIvF2h5/q7QuhmGwubmJTCaDxcXFnhapzfThgUCg5wZIm83G+RwzDMOSvXGTGe8bX8I/nnkEH3roSfg8r/RxaDQaLCwsYGpqCrFYDDdu3IDT6ey4G0Saw+LxeN3vk8kkKpUKp2ucNPE1RtVy0bDG43Gsr69jYmKi43UxOTnZdNxp1hdyp91kuODuPbK/5+DxeKAoqqXkgGvVrxYajQYikagpYSIaK66Ix+PY3d3FjRs3kPdHIOALQPOA+//xByBVK5EOxZA9OF3dccHIyEhX4v1+Xh5UwY/BoVFMzl5HOhmGSi6Azdx94lgtGIbB9vY2QqEQrl69WvcdN26xkK2sdui2qmAwGBAOh5tqI6PRaMsBnaIoDA8Pd9UASCBVKjAwbkYfn0YhnYVIKYdQ1h354rpjQNM0Ridt+M0v/S98+2QHf7P2E/z+9z6LzEBn3+Hz4OfVGLaxsQGLxXLmu0in05wlQo3QarW4du0aBAIBlpeX4Xa72QnGV83hC/af4itHawjnXyEfDMPA6/Xi5s2b8Hg8GB0dxdLSEisxaYXG7mourgRqtRrXrl0Dj8fD8vJyx3te/LO0sFqQRsx2FcHzRKu2Q630oBt0+m7GxsbqZDVc4Xa7O4ZVFItFrKysQKvVtq3oncf2a2ZmBtvb2y0/o8/nO7Ojl81msby8jIGBgbaV9k5o9t1GIpGeF718Ph86nQ4ej6fjY+12O7Ra7ZndLtJk1vgaQqEQNpsNV69ehUQigd1ux8bGRtvGwGbNYbULSS4gOuna9+kkOXC73Tg8PMTly5c5FSta3RvxePxMX8j/CcEK9wjtHUK1Wq27OBubwnrdfrFarYjFYmdutkAg0Ha1Vi6X4ff7sbGxgZs3byIUCkGn0+HatWu478oi3qGbxoDJCPmQBpV8Hh96zVN460OvYVeunTpn1Wo1UqkUpyYXl8sFj8eDf/Frb8Hjr7Jh2qrBg0sTeOSyDPz+7gTxtchms1hZWYFKpcLs7OyZgaFxVVq7ldUKXBrCGjE8PNyU3JfL5bbVDr1ej1Qq1XXV+PrgKHKpNMRyKayP3IdyrgBdogJRG8uWRoRCIQwMdG7IA4AfhhzoM2iQDoQQ2nNCZtThs87lpg02F4WLdgRohu3t7TOZ7ASdqtdcQLSuALC8vIyvrj2PP9l5Fi8HnPieZxv/fuVbOAgeY3NzEysrKwCAxcVFzM7OclpsMAxzpruaoijO52VkZARXrlxBKBTC2tpaS8cGsViMQqFQ977b29uYmZlpe2y1CX0XjV5dD9pN4GTnqRvninA4DJlM1rbKlkwmsb6+jqmpqY4E7+TkpKN+vxWEQiGGh4fPuKgAp/NPYzNYMBjE5uYmZmdnz5VSSVDb9EjmwvNU/0ZGRhAKhdpWUO12O9RqdcudSpPJhGAw2PQ1iJ/54uIixsfHEQqFcOPGDbhcrjPzmlgsRj6fZ3/v9/uhUCi6ntMnJibqKs+tmsJINb9QKHRdNddqtSiVSnU7XKlU6gwhJrZdd3OF9p6G9g6i9gamKAqVSmeLKC4gWsa8Xg5PIYlCNIElpfHMhZjNZhEKhRCJRACcVnibJQS53W5MaQx44r5XIZxP40R9hHGZAXw+HzabDeVymc3Nrm1EaoTJZILH42lZnSA3pUQiYbVp1+aGfva3USwvL8MyOtLTDeXz+eDz+TAzM9OSeDTbZrHZbFhfX2+5TZRKpTgTPQK9Xs9mjJOJjSsxJg1i3Wj3xuWDeLx/CHvTg3DtHuB11x/GA/1a1meYy/cZi8U4N+tEChlUUUU2mYF/fQf6S1PIVUooMGUI+/o5H3c3uN2NYW63m5VxNEMvOyrNQJojjUYj/uTLf4pELIp0JA6+XIJiIoPPxUr45w+/uadmJI/HA51O17TRgytomsb09DTS6TR2dnYgk8lgtVrPhMTUTvD7+/sdde5c0qHOi25dD7g8ZnR0FE6nk3Os7NHRUdvmJTJOcdGlnqc6S6DX65tqjD0eTx3p29/fR6FQ6DpsoB1kMhkb2BAMBi9EbkLGx2bfsd1uh1Kp7LgNb7FY4HA42jYSisVitleBFIJIUpdSqUS1WsUhL4u//s6nIdWqMRjI4Z+88V1dfx4+n89ak1kslqYV2mw2i83NTZjN5p4r3FNTU1hfX2fPby6XOzOe3dPQ3kNLEPJKVlu1E8t5m1tomsaBqIw//u7f4icn+/jG+ov4VMiORDGHaDTKSgkODw8hEomwsLCAxcVFjIyMnJl0otEootEobDYbBH00jBIlpizjOD4+rns/i8XC3gzLy8twOBxnVq16vR7hcLjpDUG2sgwGQ9Mttm68XGtB9F6pVAqLi4ttq2jNVqV8Pp+NSGz1nF6IjNlshtPpZP8diUQ4EWOpVAqBQMBZ6gGceh6+ZnYRv3//2/BPZ1+ND9quY3zUwlqJdar4Nuq92yGbzaLsCiHlC8B8/TJm3/o6JN0n6ItlbhuZJbioZLlGBINBxOPxtlGsF165oHgQ6NUQymVwPb8K14vrqDAVFFBBPp/nTN5z5RJ8mTgS2TSCweAZy75etxGlUikWFxchk8mwvLxcd18yVQaRfBqBbBLhSASlUqmjdp+r1+l50Kv0oB2USiUKhQKn8xGNRiGRSFoS1f39fcRiMc4VtuPj456rs7WYmZk5M16TRkQifRAIBF3HoXeCRCJhq4LBYPBCqr5kVy0cCSNayCBXPj0vm5ubkMvlnLTGGo0GhUKBU+WdoigYDAYsLi5idHQUJycnuHHjBr5w8yf4bvwQLp8H+wcHuFmJ4rvH2z19JpPJhEgkgnw+f2acCYfDbNX8PD0KhDivbuzghv0EO84oMrnSmc96N5NZ4F6F9o6ArHKq1WpTyUEno/5OyJSK+HH8CGKNCu4X19EvFcOzf4i/iH4Vb55egk6n45STns/n4XA4znTjSqVS5HK5MzcXqWCZTCb4/X6sra1BJpPBbDazRFmn02HTeQChRgmtSAYFX8Ra0pA88lbg6uVKQCxluK5cW20bDw8Ps+/buNDodfFBSDLR7XZTAbXZbFhdXYVare74PSSTyTrv19rHazQaCIVC3Lp1q22yTzgc7lg9y2azODw8BMMw+MVXPYaKS4VbQS/6+vowPGXDO6RjWFlZwczMzIWGKtRCJpNxdgTgimQyCbfbfWExvVwRCYXRdxRGhSlh7u2PY3Bi9LQ5aMCKTCYDn8/HSlRI8p1UKq07vy8Hj/CpvRdRrjKIO7340P2vP/M+5yUojTZf+tFhfNK9gtXdVShzhxAHM/jEL3yo7WsQucF5JRtccF7Xg2YgVdpOY2orpxfi46pWqzlbVvUSytAKNE3DarXiay/+BCF1P+KRKKaEA4jH42xq1XmDLppBLpezDUmd5FbdQGbU4re/+knQltNkxpm8EG+1LXL2XweA8fHxrl0spFIppqenwTAMPv/dv0bM64V/z4U+pgrb4w/ih64tvGmkt4RE28QE/scPvgZXNQuJSIR38h+ELFFELpe7sKp5CTJ85ms/glKtRzIeRaqyife/aRoK2StpmfckB/fQFES31qwp7LyENvuzVSmvj4Ln5i1YHr4K5cgQ9OZx2Ma5DZgMw+DWrVuYnZ1tSti0Wi38fn/Lyoter4der0c0GsXW1hb4fD7GxsawwcTxF898FdrpcfTxeHht/xAmRGpONyWp0nq93o6DE7GUaebb2C1qE7tqt6HOW0m3WCzYevomLGI9ssdB8ObBac+ktnmhHQlmGAa7u7t13q98Pr9Ony2VSnH58mVsbGy0jCCORCItK0GEyJbL5bp4138+9xocJcNY79/A6689DDHNRzKZxK1btzA8PHwh1ZhGKBQKTil4XJHP59nvr9212avevRni8TgODg6gUCjwe2//JXzsa59GQX86FjygH8M7Jq6jj/fKsRSLRUSjUZycnLAaYplMhiKfwv9yvABK0I98KoNKtYqvBLYwbxqFXqxgn38RVZdam69/962/gSMdAY/uQ+jADfWIEV9138IHJ663fH44HO5atnMeXETgQi3UajV7D7QaD+LxOEQi0RnSRraLu/Vx7TUytxXcTAafO1qGMCxBJhLHslCAaCKGD776DbfNCk8sFiOXy13o+WeqVfzZ/k9RkgpQCERQKZXxIt2H+0QLGO3idchOWC8LH4qioNBpoOpnEHH7UUqlkI0lQEXTuHnzZt3jBAIB62ssFArZn8bv/FvBXfw05kExlYFUp8a//7tP4yPXHsfj8639bLvF0y+6MKgbhXN/DVrDKPLFMp5fO8YbHx5jj7dcLt/VVdp7hPYOoV1TWCaTOdf2m5IvRNkbRqlSxPUPvwdRhxs8fj8mukg/sdvtsFgsLasmer0edru941aiWq2GWq1GMpnEM6sv45M7L4CiaaRDEeRjKXxFHsJ/e/OHOE8spErbSqdbLpdZ03ouxuEEjQ4HjWiW2NVLQ1gt6NU4gt/dASM9QV+5jAizgYH3zYNHd/4uahNyWh230+mE0Wis+7tAIECxWKwjYHw+H4uLi7Db7chkMmc0zs30ofl8ng1lqCWyBBSPhzHFIKJiBZsXLpfLcfXqVezu7iIcDmNqaupCJ0ulUskpdpILyuUyu6DrVDk67wKUvMbBwQH6+/sxPz8PPp+PdDqNj8w+DNPkOPhUH+T8sy4KfD6fXTwSJJNJ/MhxC7FjP4rpLA6+/xyu/5MPgkEVR6loHaEF2jc+dQOhUIjCkBL8YAH2r3wPUuMQhuYmcJAMtX2e3+/vqvv7vDhv4EIzEBeXVo4Eh4eHZ5riotEoHA5Hx52pRlxkdZbg255NKIaH4H5+GclABKbFWRzIKreNzDLVKr7j2cTn7T9E3z4fT1y6DnPVDIrX/WdiGAbFYhH5fB7hdAJO1xHKxRK2/+5p6BfnYHlgAXuJIB7QtfbQbgar1dq2f6IdrimMWLl5E+OPLCIbTYLqo/C2a6/BkvlS3XHn83n2J5VKIRKJnJGwUH19+NrmTwCaB+fzNyEz6GGYs+Fm2I1Jtw7VapXd9W38afa3Vti2b6OKKva2XgIPPKgG9Eima46jiwbSO4V7hPYOgVwYzZrCztNgkkwmsbu7i392/5P4XHALsWIWYrUS91EDuKrhtuXidDohk8naVrr4fD5omuZcnZLL5RCP6qHM6hF2uPHcH38KVz7wVvDoPuyHfbhu4lY5bpe4RT57t9UOgBspaUzsasy67gblaA651ROY1UN4fn8Zr7JdRdmfRm47BPElbtZFZFus2TZmOp1GKpU6M8GSCu0ZAkpRmJ+fh8PhwObmJiamJnEz7IYvHkY5E8fVahU83v+/vT8Pb+Q6z7zhG4XCvoMgCIJ7c2ez2exdrV2yJVuLJcuOt4kT2c44sWNnPn/JZCaZzIydeWdizxKPM69jZzLxZHGcyIljeZEly5K1WKvdXJr7TpAgCIIgCGLfUfX+QZ0SAGIpgOymWjm/6+JFYiFQKFSdus9znud+JEIaSjqdLipkK8EwDPr7++H3+zE+Pl7Td1WKo8qhJT6VnZ2dooRGNV39CkmlUlhaWkI6nT7QrW11dRVdnV3QKqsbC/R6PbrbO6HamEQ2mYRteADR7R3I25qgkysqv0CNZDIZpLd2Edv1o/vddyCxF4QEgKGIECcQMXKt0lBKcdSpB1arFevr63mFnoRAICBE4AhOpxN+vx9nzpypWjRW2zK3EhzHwbe9A//mBiK+ALhMFjwA1+IKRqQjB57PsixkMpnggiCVSoXrAfldqV3uM5tz+P76JKISDsldH57fW4XaqcZDbW8WcxHBR8RqMplEIpFAOp3Oy/sn3SEVCgUkMhZSlgWrVqH9jvOQqTTYmV9FKKtDqr180KIQuVwuBDKq8flNJBIw7ybxa3c9iNcDLmT1Jli9Cdxjy5+0MQxTsbsnAKTSKah3riIRjoCXMGBVcsi0akDKQKlUCsXlYn7KMb+lxs5eDLFICOaGZkgkgM3y5jWR5tBSSiKRSADkpxzkWnPUMvt2OBwIBoNCheyp9i4EknEoGRazE5PIZivPuH0+H8LhsKg2gna7HZubm6Jb6RrlanDcG53N3n8vTK2NSMXiiGz5MOLZ9xDVaDQwGAzQ6/UlRX291YZvfOspyLR7UCpkuOm0HXKEsLu7W1PXGkCcOFWr1dBoNPB6vbBarQiHwzX5ZkYiEewsO+HcdiCRSuKF5StoNFqhU2vQ6jag+WS9qO+fRCQDgUBeb3eO4zA/P19U6JIIbSk6Ozvh2nTh97/zDQStKsT9QUikUoSm5LjMWJDJZNDe3n6gl3y1mM1m6PV6zM7OYmdnB93d3UeWD1gp2l6Jubk52Gw20UInHo9XLYoymYxwvnZ1dR3Yn7FYDBzH1TSx5TgO2U0fWqGCt/cEpMx+4ak9xaLfePSpHrmf5QODl/F33mmABwIcj3QoikeGS7c79nq9qK+vP/JtEsNRpx40NTUVdXFZW1tDX18fgDctzFiWranLmMfjgcViOZLIaSAQwObmJmKxGHo0dQi2ZWFstSG05UNdRzNus3XhfPfBVa5MJoNMJoNUKpX3Ox6PC7ez2WzR5Wnivf6DxVcQSMXgnpxHKhqH2mTE95xe2HfyI4JkIiCTyYTOkEqlsuz5/QHJbXjCOQV9gxVSKYu6BivubT6F6elpsCyL1tZW0eMX6dgltm6DpJAMDg5CrVbjQewHP0KhEBYXFqpuzwsAcpkcNzV346mXn8PZX34IQacbCp0G9w6cg7X+6JrV3H/7CTz25AxkcgWy6RQa67W4efjNFVgqaCllKVYUVouYTSQSmJ2dFTqbEKQSBnXK/RlWsRzQQmKxGBwOh+jcLIvFAofDIVrQtjFqmHYTYDrbEd3yAgyDB07fhHd0vZkHFIlEEAqFsLGxgWg0CmC/lWauyP3p6054gywyuxvQm+rwZ389gUfuGcStl2sv3IlEIqIurJ2dnfjFT16GXBqEb3EJ3fpmoLV0dCmRSCAQCCAYDAo5jhqNBro6DVrqm6Bm5NCrdNArNWAZKSKqDMbGxsAwDEwmE+rr68uKmp6eHkxOTualVzgcDthstqJRL6VSKdi0lcKn4LGjYxBaWkMsFIXOYsRTV17BpXs/jOEWcd+1GFiWxdDQkNCit1x3K7EYDAaEQqGa82gdDgeUSmVVHfWi0ajoJWOO47CxsQGv14u2traSRUCrq6tl2wyXgqxStLW14T8N/Cpe3l7Bq3s8Lp2/AO1WGLHo0bWWTaVSWF9fRzAYRGtrq/BZ2u3NGPM5kbX3QrMVRoeu9Hfh9Xqva7pBLkedemC32wU7PjKGh0IhsCwLpVKJVColtNqupWMjUF3L3GLEYjFsbm4iEAhAr9ejra1t37GC46BdGcHL2yvg0xlcqG/HB04UH09JBLaWqDopADMEF+BdW0M2m4WEYZBJpVDXeaKqNLFSPNg6iEa1HlfkC2BSGXzw7J0wKdRASwcikQg2NjawvLwMu90Om81W9nqb29CmUsEeEbPFUkj0ej1kMpkQDKmWM0k10qcvYZWPwNylwmmJAefqxRe5icFsUOLhO+w4fUKGWDSMd9zZC4aRCI/fCJ3CqKA9JgrFKzlYql2+9Hg82NjYqCgGyNJJLBYrevHNZDKYmZnBqVOnqjpg9Xq9qGU7r9cLl8uFL37gX2Lcv4lFvQMNCi3u7cwfwLRaLbRabd6AH4vFEAqFsLW1hVAojGeemwXLyjE7+Soamk6gs2cIoczhLtJijfGz7ghUr/oxl95GMhHG3renYXyoD8re/ehlrnjNZDJQKpXQ6/VobGw8EIVM/JIOgR/Mw6jWYS8axNAjt0B7eX+QymQy8Pv9grCXy+Uwm82CMwFBLpfDZNBh7rXvwWpgkcjIsJfQ4/zFy0W3n6QclCOQikOp0yBjMWPsmz/A+Y+9D3VdbeDV12a52m63w2w2Y3Z2FnV1daLdHophMBiwt7dXk6D1eDyIRqNFI9vlEDvIu91ubG5uorGxERculC7miMViyGQyVadzOBwO7O3t5a1S3NHYDU1zEOeb+5CwJDA1NXXoquhUKgWHw4FwOIz29vYDF/oWrQkt2n1XjCVuqeRFnETzrne6QS5HnXpQWLS6urqKnp4ewXGlu7u75tUNj8cDs9lcdXQ2lUpha2sLOzs7wmSt8DuTMgx+ufsiPtJ1HiOKUVzsO7pio1xIhLY7o8YKw2DwPXcjsOaGUq9FS0iCUCh0aEcFiUSC8/Vt6FPVYWNjY1/MvgFxIshkMtjc3MTo6CiMRiNaWlpKHoc2mw0ul6tsel05MUsg7jTV5j8vLS2h3lyH32x7c4IxOTl5JPuqkFAwgFP97VhcXMwTswCN0FJKkJtakDs4EUErpsAkk8lgfn4eMplM9AWqnBXJ9PQ0Ojs7q764NDU1YW1trezFwOVywefzYXh4GAzD4KaGDgxq6rGxsSGkXpSD5BnZbDZkshxemgUSiRiSqTiyqRQSseh1O9EirzjRaLTihdlfgAeHDf8W5r/lhPahHrAsC4PBAJPJVDSXrhBlpxnWT1+EyR/DxMq0IGaB/SiI1WoVhEAikYDP58Pi4iJSqRQ0Gg3q6upQZzZBGx7HyPQYND1NmFl2Y6C/D1z2PJgivq9KpRLpdPrA/bm0as1IhCKI7wZw5qMPQa5TY3fBAWXnrTXsMXEolUqcPXsW6+vrh7L30uv1JT2DyxEIBOB2u2taBq6E3+/H6uoqTCaTqHO12ugsWaGpq6sray+mVCrR0dGB6enpmpY+C4WsGOu/jo4OjI+PFxW0tUarjppyqQfVjivNzc344c9+iikEkYklUZ/hEIlE4HQ6D+24Uk10lhj+ezweMAwDm82Gs2fPVnaSkTBgpdJrFokjwv7BwYvo7OvBz7aW4doK4IM33YvL5lYsLCxAo9EcaNZRC0qlMq9jXS4kOt/W1gafz4f5+XmhqUmxCUdPTw+Wl5eLTnaJmK30/ZL3JFZoYnC73UilUgcmID09PZidnT1yO8FoNAq9Xl80Gkv+fiuLWipojwlSfVh4wESj0Yq5nMQfsKOjo6pIVK4pf+7/rayswGQy1RSh0Gq1Qou/YgLO4XAgFosdEAparVZIKagGVsqgt92EV36xgb6Bi7A1dyKZiCEbdsLnM9YUmasm55JPZLAXDWHJu4atiA91WiN627vQVuNSGaNkobDrwbjlZS8iSqVS8PgF3sjD3dnBytwIAsvjkEiAbz/5Ku68NAgZH0PSvwZV/cElssIuTsUwcywuwoSrXUqEt3eh0mrwmVsfAMJJXL169UDx0lHS1taGuro6TE1Noampqeql2VoKw2KxGJaWlnDmzJma0n1KXcRCoRCWl5ehUqkE5wIxr1dNdNbr9WJ9fV20V6jFYkEwGITT6RTty1mLkCWwLAuz2QyPx3PAqs3r9ZZth3u9OMrUg7HdDXzbOwt2bxHxQAgqmQK/LgFuPnv+UAKNdNISUwPh8XiQSCRgtVoxODhYdT65SqVCLHZ0qSmEQivFetTj9sZuXGUaMdjQKeQVkxSkw/rfih0LSDvrWCyG9fV1LC8vC2kh5Dsj21EYFRUrZgnE7lJMdDUQCMDj8RSdZCuVyrx6jqMglUoJx1exY+BG6BRGBe0xUxihrWTZtbKygnA4XHPxU3d3N77zwtOIt5gggQS9jA66JKpeZs2FnKSFlaCk+EFsW0ix3H7OBufqLPxKO0x6Bd55/zBONOuxtLQEl8uFnp6eqmxwxNpvpVIpLGe3kQj58KEL92Ez6IVRrcMytwOJ01nSSkwMJPdT7HIkSc2w6XnsYAkTCxsYnV7H6b4ONNYbwXHlo7ClID6ov/GuRxDOprDoWoMqI8GQfV8cx2IxLC4uQqVSobOzs+IFtpa8K61Wi3PnzmFpaQmTk5MYGBioapmVtMEVc36kUilhqbCWQpti7hjE0ozjOPT19VV1LK6srIiKzpLiIgBVpxB0dnZibGwMRqOx7EX1MEI2l7a2NoyPj+cJWlIwdFRm+oelVOpBNfuV53l8a/kKNA112BidQSYShbz3BBx6HrceMtrodDpLrh68mY61P36cOHHiUE0qNBrNkQpaYqWo0WiK5shqNBqhBS6wn4JksViE/zmKaK0Y1Gq10BjB5XJhdHRUyDNWKpU40dmJv3zuCaRazVBKZbjZ2ILUpq/qyHtPTw+mp6fL5gsnEomKk+zOzs6Sqx+14PP5hGOffCfFBC3NoaWUpPDgKBXxicVimJ2dhc1mE12EVYzxvU38MLACSUAChU6LHzo38R8febTm1wP2B6BnX38ZPiWPepUOjSq90De7XBSo2EkjBsfqCn75/Xdgb28PGo0GFsv+SVipx3wpotFoxTQPp9OJ7e1t9L73ElC/jeTiLhy7m2g71Y1T7+mF2+fB6OgoGhsbRVfE5mIymbC3t1d1fh0nM2B2dRtNDWb83m88jK1tPyYWNnG5R4dqnVGJmB0eHgbLsjCxLM60dGF+fl54jlqtxvDwMHw+H8bHx9HY2FjW0oZESaoVLgzDoLe3tyZ7L4PBgEAgUHGgJ/Zc3d3dVQuAvWQM31r+BaaXF2DW6PHrFj2aVQasrKwgGo2iq6ur6ugSsSSq9H+5hV+1XswGBwcxfvUqYjYdXtmYgdeqwl32HqhY2ZEJWQLLsrBYLHlRWo/H85ZIN8jlsK4HHM8jkoghurOHxaeeh7G1BfqmBszPzcGlahImoWInTvMBD1ZDu8iEIujU6vP+L5FIYGtrCz6fD2q1Gk1NTYf+nghqtVooYD0sYqwUdTrdgcm8XC4/kmhtLSKMpB60trbC7/cL4984t4efBZ2QO3yQKRR45pUX8V/e+/Gq00iUSmWezVshuR7Y5Y4VkpZWzWpLOfx+vzCZ1mq12Nvby3uc+NBSQUs5QLHQfamka7fbDbfbjYGBgUO3h/zh+hTU9Wasv3QFHC9F64UBPOmaxWlL7T3Bf7q1iL9Yeg2G+CoYuRwDERYfOXdnxW5QRHhUI2gDgQCkUin0ej0CgcCBJSXSY97j2ReYYpaty9lvhUIhLC4uoq6u7s1I2MNmcIkMzCMsTLcMQiKRoLW1Fc3NzdjY2BD9vrkYjUY4nc4Dlj/lIAWBN933a0hsvIxMIoSt3Shuu/9jWN3aRTCWKfp6RGTmDpaFYpZAop2FWCwWmM1mbGxs4MqVKyWLXaRv5OPVCrH3mp+f359Q9PZWHFANBgN2dnYqCqbZ2Vk0NzdXPYlIc1n8z6mfYicRgT8cQlLO4j8+9S38SuNpnOk/WbOwWFlZQXt7e9nnrK+vH8qejiCTyTDKBPDTZ54FeB6udTlecS3gA/puZBJJnDhx4sgEErDfPjo3Suvz+d4S6Qa5HCb1IJFIYH19HdjYRSIRwfmPfwASADzHYaizDwzDYGdnB2tra0JDHY1GA41GI7i35B7XP96YweNrE2Agwfb8Ck6fPo2OZAf8Oz54vV6wLAubzZbnqHBUaLVaeDyeQ7+O2GNVr9djdXW16GO50VqVSlW1vV+xRjLVQBoDReMxfOm7X0cyFMbaq6PQtTWh48wgXvdvoL9evEctobW1FSMjI2hoaDiwbZWaGuVSri17teS2n9ZqtQea1NCiMEpZCk/MZDKZFynM7XolJqG/kEwmg0gkglgshmg0ing8DsfULMKpBFzjc2DVMhjsFqx4wxjJ1AnbRIrViIF2KfNsuVwOTzKM765dhcZiQnBrB1wyjas2C96rrnxoGY1GOByOqkyrl5aWhFau5U6wwh7zPT09JWf4xaLimUxGMLwfHBw88DijZCHTKvO8fRmGQVtbG1paWgShJ1bY5naKqwRZbmYY5k2RbesEz2UQta6AU1gwPNwFp9OJkZGRA9tPBnmy3aXEbO62FcuRJp+3sbERS0tLcDqd6OnpyXsvMTm7lWBZFoODg8IkpVK0ptwFkrC0tASNRlNTC971sB/b8TC4TAbLz72OpvODMDZaITnRULNdGDGOLyWuieVTpcIvsWzHQ5iI+6DQaeAanYNUKYc3mYLrcgsePH/0Fe4sy0JnMuKx0RfB6ZRI+bw4LSvtT3tcVOt6EAqF4HQ6kclk0Nrait991wfxn5/6O6ha9tPGrBEOJxn9gTGA4/aLxSKRCLa2thCNRoVIIi9n8bdLL0GmVCCVSCCbzWJ6Zhp/7U/jPYMXMTQ0dM06eAH7EcRKTijlyGQymJ6ehsFgEHWsqtXqsu9HorXk/K/GKUKpVCIWix3aSUOuUEBlNiCVSCC0uQNIpPDpdVjaS2M6rYNOt/+j1WpFTzT7+vowPz+Ptv4eRDNJWJU6OJZXBDcbMZAx2OFwVLQVK0fhNbBYIIMKWkpJcjt3cDyPF9yLeGL+F2htbUVTohOSWBIrKysVl1rJwJgrWsngwLIsNBoNVCqV4Gf6DnkEP3zlBfTceytkCjkYmQzvuul2nO/M954Va5494XVix7GKTCqJib/7EW7/3U9AadTDHQuiQ1/+pCS9vMXidDphtVqFAaPSCZbbY35xcRFSqRTd3d0VBxxir1Sp6I4kzhfrukWE7fr6Oq5cuYKWlpaK4kmj0VQsFiBVwsWWmyUMi5aWFqyurgrpHmaz+UCBVYLPYN3vRY+yFdFIRMjVKnWRJEuCpY5DuVyOkydPIhQKYXp6GiaTCe2tLcAr34Xk+R8hqVdDffk+SC4/BEkNrS0JpNkBeY9S0exKx4XL5SpaOSyGRCIBt3MDO4sOZJMppMIxgOMhlctQ2a+jNA6Ho2TubLWFX2KIpPcvVpqGOrjHp6E0qKCrt2B5dRUjsf1PkjuRlcvlwuSWTGbJ32JIZTP4dmABE2Nj0FrMyPI82OUr+Gj3xSP5PEdJT08PJiYmoDfoEUolkOaykL3RnILg8/ngdDohl8vR3t4OrVYLjuOwMrqCr37g0/BzScgZFo3q/cnVwsJCXsSbYRjo9foD3yfHcZjzbIDnOMT8QUx958doONUDW/8JmDqaqpr8HwekYPkw9mSlIOc/Wa0RE61VKBSHEufA/lL82toarHFA2mpH//13QNNQh+iOHw/ddje6jHaEQiHs7e0JYwvDMFCpVILIJc4BuWg0Gjy/s4qxtVehrjOC80fwwaZB3NN7c1XbR9IOxHbtLEZu/mwpaFEYpSS5B8W3ln+Blz0rWN9xYcfAYuIH/xef6LiIy2fOCZG7WCwmiNZoNCqcpGTpinRRaWlpKSnYOI5Df1SG7Z6TGHEsQN9owYmUEhdkB0WbWPNsXdiOp8PriPn2MPhL9yLi9YNVqWGpol2nmBynTCaD7e3tvKYPpPVuJZRKJYaGhhAIBDAxMQGr1YqmBjsizzsQnNlEJLCFKGOHpM8o5N+KKbQhOcClRAbDMOjo6MgTtuXyHuvq6rC3t1fy9ZxOJ3y+8kUIJNpBIqq5BVZXJ65ihA3j+fmrkDAMrAYz7pHZ8I5Lt5QVJgaDAcFgsOKAp9frcf78eXg8Hox843+g2TMNNpMGF+fAv/5DgJVDcvH+sq9RCblcjrNnz5aMPhNIlKnwMb/fL1jIiSUUCmF7exvBYHC/OKSuAYNDQ5idnEbPu26FzmpB2h+CYiuETENxt49yJBIJxOPxAwKA4zgsLCyA47hDe8cW0qg2QCll4fft4OyvPoxMPAlLXwfuP3Uneoz76Tdk4kp+MpkMotGocDubzRaN4uSu7JDfV3xOrO14wKpV2JhZQtet5/CSZxnvbOqDTX20XpqHRS6Xgzdr8cl//FMEoxH8Q8aJD504h9tsnXC73dja2oLRaDzgILC0tISmpiboNVro8eb419nZCYfDgbm5uYqpDAzDoNNqR52tAUkugzO//B4AgEQqRWZzFyPhEdTX1xddqj5Kask9LexUWQ1i6ynkcjmGhoZER2vVavWBXFCxeL1eOJ1O6HQ6DAwM4D+eOom/XHgNL6xvoc5iwcPtQ2BdfrCW1jyLReBNC85QKHQg1USn00Gj0WA+votpNoKI1wdIgJhvD083bOFujoO0ynO9q6urpK2YGPx+v9DNjlBNce1bBSpojwGO48DzPCQSCUKpOF72rAAAgpvbyKTT0NWZMFm3Bc3kpDCoqFQqqNVq6HQ6NDY21jSYTU9Po6WxCf/WfgFX1CM4OTgItUKJsbEx6LW6qm27OI5DwrWDM2orZk9oEHRuwdDahNa9DKy8uJNAp9OVFYUEYlNWaHOWzWZFb6/RaMSFCxfgdDrx4le/B1tEBfCAIsVg4rEXgYv1GL7/ZtF5ylqtFjs7OxWfx7IsOjs7haUhp9OJ9vb2A9Ffo9EIt9t9oFAgt0pYzBKe3W6H2+0WCgVIgdV3p1/Hj155HnKtFtlUGms7frw8qMB9FQYsvV5/IJ+qHDabDXW8F45UGj+YcqDDpMXdfS1QT78GxSEFLYFEn0nnpcLIlV6vRygUyjtPIpEIVlZWKnp5chwHv9+P7e1todq7oaEhL6L7MXD45nYQPiRhUmrwybs/CE2Kx/j4eNX50w6H40Du7FEUfpVDI5PjNwfuwBfm/hKGrmZEt3y4W90siFngzUltNXn7pBNUrghOpVLwBncR9wcRdHux9vzPYbJbAY7Ha9nX0aItPe6wLCusZkkkkrzbDMNAKpUKfxc+Vup2JeKZNP7eO4NIPIZkJIZkMoWv/+wJ+KwDuNDVX3Ry4ff7kU6nS37vHR0dokWtkpXh1/tvxZ/NvQS5Tovozi4evnQH/kXXBfA8D6/XK/hR19XVoaGh4dC1FYVUY92Vmw5Tq48zWQUSW08hNlpbbfoEx3HCpMVsNh9Iw/rEiYu4ExZBOPr9fly9evXA8xiGEYoAC18/FAohEolgdGkOQbcLEa8fC0+/jMuf+jDC6ST8yRjqVdUVSpMajFqbLRQTrmSSkasL3srRWYAK2mOFYRjEs2/aK23PLqPVdAa6xnroLHUYPjV8ZFGZmZkZmM1mYcCV8IBasX+xHxoawvj4OJRKpeiBMZFIYHp6Gs3Nzfjtvl/C6MYSZuWrOD94Gt1aCyYmJoqKtkLIQFZpmT2ZTB54rVpzelqaW8BkVrEaceHJqRfQom/ALb0X0MbYq7owVJsywbIsuru7hSrytbU1nDhxQhgwZDIZXOFdyPe20KwxQS9X1rSEZ7PZMDY2dqDydUeaRn13O5ZfuQrv9Dwu/NoH4csmkMikoWQPNmEgyOXyqvNgGVYGjZyFWaXARiCGVV8Q4H3gR0YAvOmjqNFooNVqoVQqqz7WSQHgysoKJicn0dfXJwzKer0+rzAslUphbm4Op06dKhpBzWQy8Hq98Pl8SKVSQnOMYhdYjuOwu+nBH7z7w4IfMOmMZTQasbKyIro5RCqVQjwez7tokGKawxrxV8KQ4PGHd/4SjPYGaKRyzE5MVh2VK4RhGCEdIZdLSuCpxaswtzXhzEcehLWnA3KGxb0X74BGVroDHVniJDZfxW6TvxOJBHieP/DcbDabd7tYMW7u+7mie3AuLyIVT2Dm8WcgUypgaLRC2dVUtJo8k8mImih1dHRgfX1dsIkrx6DZji9dfBjuWAiOqTm8643UDIlEApvNBpvNBo7j4PP5sLq6ikQiAZPJhIaGhiOx2xIbMfX7/VhZWTl0Ooxer8fW1lZV/0OitV6vt2S0tlxzhVxyW1I3NDSUXBEpvFaZzWYwDIPx8XFRkWmGYWA0GmE0GtGf7ceqJgulyQCV1Qy/wwWdrR5aWW0R0VqbLRSzHgSKC1ryGd6qUEF7TJBB1aLUok6hwV4yhraLp9E8fBIRrx8nL9XuaVrI3NwctFptyfwr4hU7MzNTNpeS4PP54HA48trttiqNsLYNoNW0Xwxx9uxZXL16FZlMpmzuqJjCsMXFxQPLIWS7a5oxSoBAMox4KgGdUg+jWg8ZywJMdVmQpRwAxPxfb29vnrBtbWvF93YW8LRjFPrEOlRqDR5QtqBRqhb1neRC0lAKB1+dTAkpK0NDdys0DUYEHE7UtzVDLpWWebV9ShWGlWK1fgCxxWW8Z7AN7lAM8QyHgXvfD/0b3ouJRAKRSATRaBS7u7uIx+N5qxFE6FYqsmAYBt3d3UI6Ccl71msVWJ29AjRHwMn6MTk5jd7e3jyBmEgkBBEL7Ds3FBa1FWNjYwMNDQ1CSsfa2tqB7YlEIkLUqpxzRW50lkS6TCbTkXcAKgbpPEW+U7E966slEokg7tjCh87fgZ8G1uCLxSHNAp8avK2smAWQF129Xug9G+CXr0CmkKPzzktoGOiCBICaLX4czs7Ooru7W9Q2trW1wel0ihK1WpkSPQYlYlp30QgawzDCUjdZVVhfX0csFoPRaERDQ0PNIlOMdRexqKt2fCpGrY12gP0cUqPRiMXFRWxtbeU5oVQKeqRSKWxsbMDv96Opqaliak84HEZ9fX3efUajEb29vZiYmKgq3eIuew9e3V6FL7AGW2cbeFaK85wRS7PzeZNzsZAgQWHjpErs7u6irq7uwP1arRYbGxtVbcNxQwXtMSOVMPhXg3fha7MvYh6A3mLGB3ovgtvwIaKtP/Rse2lpCXK5vKjfXS5qtRqdnZ2YnJwsezElg1jhiR+Px6FSqYTbDMNgeHgY09PTSKVSJX3yKkU5vV4vdDpd0chpLRFaYnUlO6HFSfl+M4VTTT1Y3F4Dp7PCVNWrHY5cYfsPrz+HJ5dGIZXLEdnZw158C/9g3sX/fujXwUqrP01J3m7uRfNdzQMY2VmHNxRFU28n0uksLmb1cKw6DqRzFEIs1ioNlBzHYXZ2FuqhO3CqowPxq88D2wEM3fMIZjIa9L8R9VEqlVAqlQdej+SeRSKRvCILsr8KxS7ZZqPRiDNnzmBhYQE7W3PoVf9XcJ5FYEONySUT2s/9GfR6PSKRCLa3t7G3twe5XA6LxVJV1XgqlYLX68WFC/tOAKW6EWm1Wpw/fx5OpxNXrlwpGsFKpVIIh8Po7e29JoVf5fB6vTAajXmf22azwe12IxaLHdkStsfjgcvlwqlTp3BBqcR96bOYMM7hhK0Jjaa3lg9tbqHXO89cwkR0GxKJBAwkMCs1uMnafuB/XC4XVCpVVQVQra2tcDqdmJ6eFpXzaDKZ4Pf7ywYGGIYROl4B+5HTzc1NLCwsQK/Xo6GhoaptLGfdRVotk3PnKDhsBb1cLsfg4KAQrSXF1P5kFBO7LmS8dThlaoLmjehnIpGAw+FANBpFa2uraG/3aDRadIKq1+sFUSt2ZUUjU+APztyH/7uThP1EN3oMVpwyNwmT81o6JZJmC9UI2r29PTQ1NR24v9oVyLcCVNAeE7lLeza1Hr9/8p3oXAzio7d8EFIJg1QqhcnJSbS2ttacQ+dwOMBxnOiIi9lsRiwWw9zcHNq7u7AVC0Ijk8Oq1CGdTmN6errkIJZIJA7M8hiGwdDQEGZmZuBwOCpWpRcKKo7jsL6+nlcIVvh/YpfCiXOBxWLBmTNnID0nRfTnLkifdkPZZsRNv/QgfIpY2UKjYiiVykMnzsvlckjtdbCkm7H88ihWX3gdlz75IbBGLfzJWE1FM1qtNi/qCQB1Sg1+p+9OfDfEoLG5HQOmRgyYGuFyuTA2Noa+vr6SEyidTodwOFx2oDx4zJ6A5vSdSI+MQH3mPE4lEpiamsqL7BdSKveMvD4Ru1tbW4LjBgAhx7y+vh6x1f+K0YVlZDkOk3MxMJIkdha+BMfGb0Kr1aK+vr6igC/F0tJSVY1NyL5YXFyEQqFAXYsdf7X0OlbDu0i6ffjw4M2Ym5u7JoVf5XA6nUXP456eHiwuLtacC5nLwsICMplMnuWgVqZEZ30jUvHDVZ4fFRzHwePxYHNzM6/Qa4AfwM+2lvHCThJnWgbwzqY+qAoitLFYDB6Pp6ZoemtrK1wulyhRW1dXh42Njaos5oh/KrDvPLC9vY2lpSUhH7xSvUSp3NNiq3NHxVEUIVmtViG3dmRlHt9POOFxreJ1ZQRmpQaf6boZoa0dZDIZtLe3V+3EUG6VSq/Xo7+/H1NTU6JFbTaewL1dp9Hb8aYDhtFoxLlz5+BwOHD16lX09fWJvh6RZgsul0u0I0apz3Qj2HQVQgXtMZJ78YpGozDrDJC+YWtEqrmnp6dLzgrLQWw8ihUglOvc1NzcjJ+MvIr//sO/gMxiAACcVllwjjOit6en5AAQj8dLnnQnT57E0tLSAesaQim3AIfDgaamppIXedK5pBS5Cf4Wi+WAYJCfa4BVMwjzGxf2ZphhNBoxNTVV0bKLoFKpiuYZVYs0loJvZR22/k5o601g5TL4VzbgNCyCaW6FxWKpWuyQiFvuwJbwB/GRc7fnfbbm5mbBvLyUHZbRaCxbGEbsxMpFGJVKJU6fPo2JiYmaLogkN7PYMZjnAhJYRCKVwle/uQO1WoLf+6QNjUYX9KcP568aiUSQzWYPfNelHBVyHx8aGsLWtgf/9h//HFmzFlK1Cjvb2/h64An8m7veh5u6a289XS1+vx86na7oGKDVaqFQKKpetsyFpE5YrdaiF9W3wlJmbs6k1Wo9sGzOSBjcbuuCvj2Cs+0H/XLJSsTAwEDNkxCybyYnJ8tGOg+zHA9AyNkE3nTsWFlZgUqlEoqrCj9DPJPCYnAb8t1N9BiskDNSwZf7Wk28SD1FrccdgfhW/9Uzf4stxyqyWX5/1Su4gf+7FcK/fuf7axLjYvLLtVotTp48KXT6qrTSsbOzcyCFAXjTcpKkLlmtVtHdwEizBZvNVnHlKRAIlG37XizY9FYWuW/d7N5/BuQebH6//8BJRiKcwL5DgdgDyeVyIRQKlaymTSQSkMmKFwFluCx+nN5C0L+HRCCEyLYPz05cQdSmKzubrZRf2d3dDaVSienp6QOPkeXswm3c29sru+RSKoc2txd3NpvFuXPnikbkQqHQgZNZq9XizJkz8Hg8WFpaKvneBCLGayUSiWBsbAz9rBFDw/sFgTKZDNoGC/7V/R/E0MAgotEoRkdHMTMzc2A/lcNmsx1YNixlGK9UKnH27FlIpVKMjIwgFovlPV5qaR3Yj9rMz8/j1KlTFZfL5XI5Tp8+jbm5OYRCIdGfpRJqtRoWiwUtLS1Q6xqhlMvwB59uxL/6aANCEQaMvLqlu2IsLi6ip6fnwP2ijwGdCkxrPWLBEF7/879DZC+Ius42bMkO13iiWtbW1spOkLu7u4XVnWoJhUKYmJjAiRMnSkaIjnMpM5VKYWlpCaOjo5DJZDh37hza2tqKjl3looUOhwM2m+3QqRlkMjn5hqNNKcqdf9Wg1+vR3d2NCxcuoL29HcFgEGNjY5ienobX6wXHcfDGw/j86BP4p7UJ/L/Tz+M/vPo4nn/tFeh0OgwODl6zVQSyCnRUJNQy1HW3Y/m5V7H4459BY6uDvK32orlSxVOFqNVqnDp1CjMzMxXHhUrtzknqUjabLTouF4NhGLS0tMDhcFR8bqn8WQJxu7hRoBHaY4LjOEgkbxYhhcPhkmKgo6MDXq8XY2NjGBoaKrsk4/F44Pf7y874yw3UgVQc0UwS5hPNGP3m42i76QwaB7qxlTz8QNPW1gaXy4XJycm8gdFoNGJ5eTnvuaXEA2EjsofHlq9gfnoGF9ggPtJ1HjpWAZfLhe3t7bKVqoRoNFp0gCIzfLIUX+g3mUut0aZEIoHl5WVwHIe+vj6o1Wr0cX0Y3XFiNCTDfafvwok3GlN0dHSgo6MDoVAIW1tbWFpagtFoRGNjY9nBmfgIk2rlSCQClUpVdp+0trYK0drCqADLsgeOnfX1dQSDwbKd7AqXEomonZiYONKcUZJW0mj7LVyw/gGc7hDkLGA06DEbfC9MZdJeKuHxeKDT6YpGYTUaDaLRaMXIEiuRgnlDOBmaGqC3WuBfdcGV0cGjtMFisVzz4qdAIACFQlF2DGFZFo2NjdjY2KiYe5+Ly+WC1+utWBhzHEuZsVgMDocDyWQSra2totKwUqlU0Yl/IBBANBqtKvWkHGTSTtIPip1HJI/2KC3cclN7YrEYtre34XQ68dj6OHakGTByGUJuL3bDUUyc0eEdVeZzVoter4fb7T6y12tQaDG16MCpX3o3Yt5dRNw7YOXmmp08igVASqFUKnHq1KmyKVakW6OYbeno6EBDQwPm5+cFB5Zy/2ez2eByuSo2WwgGg2XHRLVaLdq+7a0AjdAeE4UnVTAYLDtTs1qtQgebUpEtn88Hj8dTMSer1EANAFpWAXA89tY20XHnJQBANsvBqFAVfX6xz1KO5uZm2Gw2wQEBOJivFQgEIJVKSwodfzKK/zH5DFbCu9iLRzG+48Tnf/IYXr/yCwDAuXPn0NraWnGbKtnSNDc3o6urCxMTE/D7/UWfU220ibTUJZZnQ0NDQpRHxkhxU0MHLjV0CGI2F1J4cOHCBdTV1WFtbQ0jIyNYX18v6bbQ2toqCO7t7W1ReXhqtVqICoyNjQl2SPrAJgI/+x74lavIZrOYmZlBKpXC0NBQ2X1drFsPEbULCwuHjtT6/X6MjIwgmUzi3LlzaO68G2j/J8D8G2DqfwvK3sdx9qZHSkafK0GWp0sJGDJZqIRZroJpJw6ZUoH+++6AXKVE00A3Hrl0O5LJJCYnJzE2NiakC10L1tbWRAmx5uZmeL1eUS4eHMdhZmYG0WgUZ8+eFZUDeb1EbSgUwuTkJJaXl9HU1ISzZ8+KXtIuNvEn528x15XDYLfbYbVaS0ZqTSYTdnd3j/Q9c1Gr1ejo6MD58+eRMmkQ9Oxg8h+exPQ/PQ1DWyP8SFd+kUNSq2tMMTiOw8W0DqZ6Cwz2BrBqFQZOncR7u89hdHS0ZMFbOcoFnYpBUqxKrUZ5vd6q0ivUajXOnj0LmUyG0dHRiuMmabZQCmJhV27sJpP1GwUaoT0GeJ4Hx3F50ZhYLFZxOUOv1+P06dOYnJyEvcmOicweJnZdUEpluKRuhGwvWjZSRigXoZUzUpxJqPGyUQ9dvRlR3x4k20HcdcvB3FdCIpGAQlHeficXq9UKlmVx9epVIeKcm6uztLSE06dL93m/6nMhmc0gnUxh8+oceJ6Dus4ES087Wk3iCyfi8XjFJUO9Xo8zZ85gdnYWe3t7B8RANRdml8uFra0ttLS0lI0QienSQ4o+OI6D1+vF7OwsOI6D1WrNy53SaLV4ZmUSL3I78C+s4TMPfkDUtgL7UYH6+npMTk6iYeFF6NavYi+WhsGowaSmFfb3/nrR6thCVCoVEonEgYvBYSO1kUgEy8vLUCgUB1cuZHbw+ofBaDTAG53wcqPP9fX1oqOPlXK5xUxqSMHcZy/fh18kvFgOerEXyOIzQ/egWWcCjBa0tbUhk8nA5/MJxvkGg+FQ9ku5hEIhUd3/CN3d3VhcXCw7Qc71o66maKlSl73DQhwLFAoFurq6akoNKDbxn5+fR0dHxzXpnkT2H8mpzT3e9Ho9FhcXj/w9CWQc8Xq9gGcPWosJw7/8EPxL69hb3kBDowSJU7W3VhVLLR3KCuE4DlevXsWZzj7cev4SlkM72DX1ol1XhxNt7eBa27CysgKXy4Wenh7Rx6CY60UhuWNcoU9use5cYiBpKvPz89BoNOjs7Cy6v0izhVKBm0AgAJOpvK9PMbcL6kNLOUDhSZtOp0UNFqRY7Ms//keMhNwwNDUgGY7ipc1X8f+87xOiDrZ0Ol3SMH5ychLvPX0ZdyklWAx6oT2hgN4XR8QfgLrEclcikaj6RDebzWBZFhMTEzjZOwAsh7DpnEBMkUV9X33RC0YikYDP58PK3Dx21lbBs1KkonGorXXQ1pkguUYnGsuyGBoagtPpLJqCUGkQJpXBVqtVVEEFaWQgNtJFjNYzmQzcbjeuXr0KuVyOhoYG/NPOPF6PeZCdcAGZLP5o/Mf4D2fvh7aC/ydBq9XiXIMWK9/7BTzxJGLJDPyxBLotaZh5cTN3pVJZUvDVImpJHmQ2m0VPT0/JY6/YRINEn9fX1zEyMoKBgYGyxy7J5T7M8nIsFsPMzIzw+Zqxv3S7bloHG00COauYLMsK3yeQb79EXBxqKRAE9qOzXV1dop9PCgFLNT4hpvq1FPhdC0FbyrGgVtLpdJ4VocfjgUwmO3TRUjlsNhsYhikqaqv1gq4Eaczg8XiQSqVQX1+Pnp4e/NvOVvyPyWfhdW/B0tsOJpLExy/fg/n5echkMnR2dl4zYXvY4yKTyeDq1at5TX1O1zUjY9hfFTzR1i54RScSCSwuLoJhGPT09FQ8VmoV2nK5HGfOnMHVq1fR0dGB1WwYzugedjZX0XdyoKbPqVQqMTw8DLfbXbYFcFdXF+bn54s6cezu7hYtSCt8n2u1WnQtoIL2GCAXWnJykM42ogdfCbCq5yAJS7D+yhhYjRL2wR68uuPAQF3lPKdiEVoyq21ubt6P8gHofaMNJmfjMDo6Cr1eX3Qgi8ViVUVoCXq9Hn1dPXjlf3wX+pQCbokX/kgQl1K3gG/nkUwm4fP5EAgEhFwgs9mM+y7cgil1EtFYFJI7LyKxE4DdYEG7rnRyu5h9UInW1lYYjUZMTEwIPodA6TaRoVAIy8vL0Gg0VZmPy2SymraPZVm0traitbUViUQCV1cW8cyrL0Iqk2FzYg7tt5zFtm8HP54dwa0NnchkMkIXpUwmIxyH2WxW+BsA+NVJ8PEk9qIJfOmZq/j7R98Bo1oBPrQLMa0olEpl2X7qYkVtJpPB+vo69vb20NXVJcpyp9QFqK2tDfX19UVzhXNZXl4um8tNIAWKhe9HOr0Vs/FpbGzE7Oxs2chmrv0S6UrmdDrBsiwsFgusVquo44SkRFQ78ezq6sLU1BQaB7qQyKTRpDFBxcqE76FWU32xbaPFUMmxoFZIhBzYn9hsbGyUtBA8SkieLGmpSo4pg8FwJHm0RMQSq8XCZiJNUOIPzz2I5xUjkMnl6DM1Iu4PYXh4GKFQ6JoKWzGdI0tBxGxu90UCy7KQy+V5OaXEfSQQCGBychJ1dXUlc1MPayfGsiyGh4fxRz/4FlZkcUhZKWJ7Ifgnn8Xvnr4HMqZyc5ti2O12IVq7tbV1oMGHWq0u2WwhGAxWPVF/q1t5UUF7TPA8D+kbHZpisRgYhhE9OPA8wPE8lHotYsEQtAoWwc1txAyNov4/nU7nnZzFZrW5MAyD/v5+TE9PF01pSCaTZSslyyHdTKBbYcdV3zzmtpZwsX0Yky+OQKnahdZugtFoRFdX14F989tD78Bfjj4HRhvHyRNdGIypwGeygFzcwCC2YrWQwhQETaMF39ucRnxrCqc7uvGe1lPg0hmh4EtM+9NCSPHVYVAqlWhoscPa34VdxwZ88w60nD+FFBdDKBJGpi4jtCklhQksy+b9Tb5nvrUeGedLGN/cxX9411k4/GHIWSnM9eJ8DtVqdcX2k0TUXr06jpR5Ch7+ZfB8Fu3623DW+nFsurawvb2NlpYW0YNwpYGXRGsdDofQqlahUMCxGYQ/mICUS4AFL+riSuzbcp/r9XrhdDpLCiy5XC5MJsQIMFLE09HRITR4mJ2dRSaTQV1dHerr8xuxBFNx/MPqKH4xOwLrxhT+5a33VXyPQli5DD/aXcbSj1+H1loHFSPDu5gG9FibDuVVW9hhrRZSqRTW19cRCAREdXmq5fXJODk7O4v+/v7rttxaTNTW1dVha2urJkHr9/uxtbWFWCwGs9mMEydOlJ3c6OVKnLG0Qi6Xw2azYS40J0wYhoeHEQgEromw1ev1NRXZplKposv6udjtdmxubh4YP4xGI86fPy9EO1taWg5MMqspCCvFTiqKjTopwsu7iIYjsPWcwHrEj19413CLrfYVoNwWwOPj4wcsJ4s1W8hkMkIXvkrkrgwwDINsNlvztl5rqKA9JiQSiXAwxWIxyGQy0YOllGHQrTDilbkVdL/zVrByFolQBHWBNCYnJ9He3l72Ipw7UJeb1eai1Wpht9uxtLR0wEu2nAdtJdKhOHZjAWSzHJ6b+Tkutp1Gu6UJjb2noGgzlvy/dl0dPtl1GUwPA7vdjkgkInQ5E7MfaxW0wJspCJNL8/j33/4zSPVaZDNpeCQJjM9M4eGG/rIDayVIhPawmKQKxFY2IVcrcer974KpbT/f9Y5T59CsL7/UlIvE2obl9pvRGH4OajmLRo0Kq22XwEtUELP4Klagy+VyKFo38PRLfwdbuw5avRyjq09gdnwNdw78Rk2CRWwFcX19PaamprC4mcF2UAaJBHCuzuLO2y5ikOfzHEmKIVUosOx1Y0CtgpKVwel0IhAIVDwerVYrPB6PaBN0glwuR3NzM5qbmw+0PdVqtTBZ6vC/Vl/FXiqO7ZAfe+k4vrbyKj5vfEB0ugkAPLs5D7cqi5hzD3K1Ajsb2/hxexzvvum2qra3kMPYUNXiWFALJA3M4XDAYrFc90pvq9UKhmEEUVttHm0gEMDW1hYikQiMRiPa2tpq/gy9vb15q3RGo/GaCNtaPHeJmK2UsmSxWOBwOEpOiElhnsPhgNvtRldXF8JSDn+79Assri6jyWTBp6xm2DUGUduVSCQEf+x4PI7ZbRd2F9eQSiYw/51noPqVhxBlWcykdWjLKIQJa62rC6SpxMLCAjweD/r6+oQgRWGzBb/fLzoIRdJAar2eXU+ooD0GOI4Dz/PCgVutIAyFQriYNUJz6VbMRnYgl7L48JlzuMvei0gkgrW1NaHdbGHENc1lEU0nwfM80ul9ASx2+dZut2N6evrA8kUqlapq+3Nzt+KhABQSKewGK/74Q78HX3QP3oQfrfWVxWYymRSS2rVaLdrb2zE9PS2qHaMYm6VKuBQZqG0WbC85ENjwoL67FXFbPVpP9sJYQ3cvwlFU+5IWv7937wfwLdcE5iemIGek+EjXBXRWIWaB/Ugj138zmt/5MLiZCaQsjTjXPSA4VVRTDFSJrcQVtA+YMP6CC8k4jxODJpg63FXZRxGqWRrTarVobOnF48//FMlEHHKFCmqtASuuCDY8YbQ2lv4+X9texf+Zew7RvSDqPU24S2rFoLlJ1HFos9kwOTlZtaDNpbDtaSgUwitL05ifnAaXyWLh2Vcw/IH7sbW1heemRzFc1ywUphb7IY8BwCsrI9j1byHo9mLx6Zcx+P57EZFkkMimD3TOutaEQiEhqltp0n4Y9pIxPOGcwvj8GM4yEfSmlbhw7vw1ea9KkO90bGwMw8PDCKbimNpxoVlvhklxMMJKrP3Isn1TU9OR7KfcVbrz59/cF7nCdnZ2FgqF4prm2BaSeKP7oNj8e61WWzalgWVZIb92fHoKf7bwMuQ2C4LhMBi9Bn88+Sz+8PyD0MoUyGQyeYI1FoshmUwK545SqYRKpYJKpUJ9fT1ubWzA07wHW3NLOPexR2BoagCrVuJ8535zjp2dHaytrQnRU5VKBZ1OV5XQZVkWJ0+ehN/vx/j4uBBtJs0W7HY7GIbB7u4uWlpaRO3jXEH7Vi4IA6igPRbIRYMcHNFoNK/4oByhUAgLCwu4dO48bivR6WdwcBCpVAoOh0Oo0LbZbPjJ5jy+vz6B7bkVPMlt4fasGbcMna1q5jUwMIDR0VFotVph0BIrHEKhEDY3NxGJRGCxWPZzt4aUiDVs4cW/egId9U1oqLdi97QSs6sLFbvwxOPxvCp7i8WCaDSKpaWlilGbWipWD7xGKolEOAoePFKRKCRSBqxCgQx/uBwjuVxes1VKJpPBwsICGIYRIpr/pbENr/BW3HzxEhhJdQNSLBYT2g9LGAa6/nPY29sDwzAYHh7G9PQ0MplMRUEmfvVBhkySg0Ith1LDI5vmIa1xmKq2iCMSS8PS0AKvx4lnn/gGbr77A4hFghgZiSLaZYVSqYRCoYBSqYRcLodSqYQ3GcFfL74OqVKOdCwOz5IDj+t3cPvwRVHvSZbxDpujl0qlEAqFEI1GEQ6HhQYcHHjEd4OIBUIwqJWAdD+1iewXsuxY6uekOgnflgrG1kYYW+yQq9VIbO9henwCKpUKZrMZFoulpm0nueeVzsOjcCwQSySdxBevPo1wKoGt4A7WXn8eF8+cwzmeq/rcOSpIEeBXf/wdvBbahHJ3BmqjAR/tvohbbJ1CK+hAILA/MWtsLNqR8bBotVpYrVasrKwUXbY/e/bskQhbpVIp6rhIiGilXUhTUxM2Nzcril+lUgm2tR7warG7uo6116+i++7L8Cc28XhEgX7TvpMMEaw6nQ4NDQ1551Yx7uLM+HFTI1LpNFLRGD40eDPONh+MGHMch1gshlAoVJPQNZv3u14uLS3B4/FgYGAALS0tmJyeh1pvw/KaF7294hwWtFottra2ANAcWkoRCv3fYrGYKEFLxGwl43JgXxT19vYik8lgc3MTf/fTJ/Hk3go09aZ9L8WZOaS6uvBuQ3Wz91Iz9VKkUilsbm7C5/NBq9UWjRjEWmQ48eu3wmJvh1SnQAPLwOPxVGwkUSwy3NbWhrm5Objd7rJdxg5zUpLcPXbTD0Ymhf10P5rPnEQmlgTjC8LvcKGuS1lzlKLWCC0pQCrMoZJIJFBKZVVfkIm/6MmTJ4VjVavVCubnpJPd9PQ0stls2ShqYUFGKezSO/D6yqvoO2uBXMkiEkiB2+iHW1/++yxFNYJWr2Hhdi5CKlPg1nd+GI3NXWBZFhcvdMOolSKRSCCRSCAYDCKRSCCZTGJ0ew1e5yoAYOxbP8DpDz8AJcNgyrWK2zsGKkZVOJ7DRNqPP3/qr2BpasRd9l7c2dhdMsWB4ziEQiFEIhGEw2Fh4iOXy6HT6aDRaNDQ0IDOvh6MaRJwLi7jwsffj2w8CblEitt7h2AsEtkrxf2tpzDh38ROMgmZjIWmzoiP33wfLlg7BNeR+fl5pFIpaDQa1NXVCQ4mlSD+vcWEy1E7FohldMeJvVgYXCaDzfFZdN5xEQs+N2Y9G0LRae5kQMzvo8AvzWBcEkJ0Zw9cJgNWKcefvvBDRJvOoMlsQWNj4zVJvSj8DK2trZicnCzZcfAohK1er0coFCoraIlziJj2soWvvbCwIGqyK5FIIFcpIGEYyDUqqM0GsEo5Bk+dxhmLuOhmLgsLC7jU0Y8H7XfD6fci6PbgYktxlwOGYfIaXxCqFbq9vb1C974U1Pjuk2Oos7XA73UjLlnA++7pASstvx9ybQkrpV4dN1TQHhMSiUQY9MnFoBxErIgRs7mwLIu2tja8ktoGE17Dwk9fw/pLV3Dh4x+AL7SHVc8m2uoaqnpNrVaLhoYG/P2rz8LBJuBb30SmtQ43Wfc7jpCLkcfjAcPs57iW62zidrvR09MDNmfQI20lJyYmSs7AS4nS/v5+jI2NCa4IhdRqfUNy9+LxONrb2/FwdzdafX14bGUE4XQSnbYmfOKOD4BNZDA9PQ2dTofOzs6q30sulyOdrs7IfGVlBeFwuOrjoxxzc3P7rWRzLhhEmOYyODiIubm5opEbAmmuUO7CFgqFEHMb8S/u/gLWYy+A4zO40HAbOnR3Y3V1VSjcEntxrGbS4vV6selcx4P3nMPYQhjbW+vIpBK482Ivmm37OXPFjkFmtx6/UMcQ2wui+77bIVPt56emQ1Eheg28ufyo0Wig1WqhVqvBMAy+vz6Jl2Nu7Hq9yJq1eGxlBDKGwc3WE8KFi0RdiXe1RqOBRqMRvptS59Vnem7FV9a3kbQpoYpxuNfWjcReCLBVIQDkSvz7M/fjlc1FrPJLePfw7YKwUyqVQh4v8KYLg8vlAsdxMBgMqKurK7pUmeGyuBJ0YX15GwM9vXiHvRdyKXvkjgUcxyGVSuX9pNPpvL9zc3mntx3wba4jvLOLsMcHLp1GzB+Ea3MTUk0s73WB/eLe3NuFv4ttD1C92P2Fdw1hzw7SyQRe/+Lf4+yvPIy6jmbU93XgZH1xh45rxcDAAMbHx6HX60t+N4XCVqVSoaOjQ9S5q9frsbOzUzKVKRKJYG5urqhziBjMZjN8Pl/F4roTKhOSax7orHWwn+6DUquBQaFCn7H6FCtyThA3lV5rE0acW1W/Tq1C11Jfj69/61VEI2GEFidhazqBze0Ixma3cfFU+WLy3Hx3GqGlHCA3QkuqnMuJECJmaxncSb7qzrIT8d0gjHYruIunoTLpwGWyiO4FsbgbzBMpcrkcKpUKCoUCarUaSqXywIVzWRrDPy1cgUylBJfl8JcLryHg30NzZl/w1NfXi4qqpFIpZDKZogNTbiOJ1tbWqqp7h4aGMD4+Lmx7LpFIpKqKVZK7x3Ec2tvb81I0zlhaDs7WlcD58+fh8/mE6tJKrQpzIT60YiDG9qT6+Khwu92Cx60Y+vv7sbS0hIWFhaLLnWR5uVR6S+GErbPu9rzHu7u7EYlEMD09jbq6OtEtbCvt80wmg/n5eUilUiFFY/hkErMLahh1Kgz0lh/sT5ob0WOw4tX5VXRcOA3fyjrOtnbjnrM3gcmJZpACkUgkgo2NDcTjcXAch3+a+imSUgm8K+tIRKJQG/V4bGMX6r5bhIhLfX19SfP0ckTcXvyn+34ZWq0WY2NjOHv2rOBRXK4AtBCNTI477T2whbiy1ni5LgwcxyEQCGB3dxerq6tgGAYmkwl1dXXQ6rT46syLmPY6EXJ7sSRPYMS9gl8y9iASCpd1LMhkMiUFKvmde8ElTh4ymUz4rVKpYDAYIJfLBZcPAjevwHNbi2g9P4SmoT4kQ1G0dHbgzuELULLFuyteD5hdK16KuJAMRnDL5x5FOhpFKh6He34Zkk2/kPpxLdMxCCTPdHp6uuKYU4uwLeeAQVYpaxWzwH7aweLiYtnrSSAQwMrSEv7zwx/DjzzzuBq+ipM6K/5F/01QVXkc+P1+eL3eol6wR0Uloev2+CBllchmM3jlue/gnQ//GswWG/zB6jxmSbrkWxUqaI8RhmGQSCTAMExJH9dAIIDl5eWqxWyh1+CHbr4ba9M81mfm0XbhNHiOx3tOX8Zw18EuQKlUCrFYDIlEAuFwGDs7O0gmk3mztL9ffg1ShRxrr45DYzEjFY3iyZ0w/ujeX66qknZzc7Ns/iVpJDE9PY1oNCoImWQ6BbZE+17gzeT4mZmZA/tOrMOB3+/H2toa5HI5Tpw4UXWFMCnUIXYwjY2Noot/xMyC3W433G53xeYA1RKJROB2u0sOwCQlonCy0t3dDYfDISwF5qJUKhEOh4u+nthjXKvV4vz583A6nbhy5UrFQpBK+9Dr9WJ9fT3PUxgAjDoFBrrsonxSpRIGv2I/DXN3CuoWK/TNp2AJZ/LELLD/+YutGNgy69gLBxHY3ELY64O5oxXN7SdwdvhwF79YLIZMJiPsHyIOh4aGcPXqVbAsW1WxULWRGYZh8jx0M5mM0CRi1rOBl9dGodBrsbPqRiqWgCuRQM85FW5q7UE0GsXc3NyB6Cmwf14rFIo8kapWq/PEaS1L/ZFIBPPz82ior8d/fORR/O3SLxBKJ6AMJfCp7puPVcxmMhnAtYturQWThjDq2lvBcWm0h6S47fR5KJVK+Hw+rK6uCrUBdXV1sFgsR9aEoRCj0QidTgen01nSw7nw+WKFbSkHjGpS7sqhVCqFQEqx/eNyueD1eoXx6NNmKxakDWhqaoJWUZ0zTiwWw8rKCs6cOXPgMVJsdS3dM4jQNehiyKRiMFub8NFP/2d43Q4kYhEYdeLSuEhAgmEYKmgp+WQyGcHlIBKJCFGEQsiFfnh4WNTAFAgEsLm5WdJr8OP1g3jtpBaMUQvpph8f6ixuEk4uDqXgOA7a8CKSoQAkUiAeCsN2qhumlqaqT06fz1exgp3kaq6srODK1XFcYYMY2VhG3B/CL+k5PNI+fEBAAPu5P93d3ZicnMwzKA+Hw2UrPD0eD1wuF3Q6XU0+soXY7XbYbDZsbGzgypUraGtrO5Q5eiaTES4KYm3KxMJxnLCcV+p1yeBW7Bjp6OiAy+XC5OQkBgcHhddQq9VFBaLf78fq6qroYxyAEK1fXFyETCY7YCaeS6koX2FUtpBqfFJdzg185Ka7heNkZWWlYg434VZbF55Kz8Da3QEwEsR2/ehtOyXqfcuxurqKEydOCLdNJhP8fj8sFguGhobKpvIU47BLjcQ6yGq1Il6vhYHzwLe0isWnnseZD98Pnb0BrEZZNnp6LeA4Dg6HA8FgEIODg1AqlWjDfncpjucQCobgcrmAuqNz8qgGsnLR2dmJf93ViR9ceQnmzjY0aQzo0VgwNTWF9vZ22O124XiLxWLw+XxCyku51I9yVBIunZ2dGBkZgdlsFn0cEWHr9/uFMayzs/PAWFLYFa3WlLtS2Gy2onZ5JL+2cDJPUq2qub5lMhlhcl/sOCZNJK6loPX5fFhbW4NOp8PHPnwPnnltAxwP2Fu7kQht4GTnBVGvo1arBUH7VnY6oIL2mCA+tMSDtlA0ib3QF9q0tLS0FI28cByHZDCCT15+135rxexkzZX+DMPg1tY+PDE/AvvwSZjamxDa3IZlJyGq8Cf3M1YzyHZ2duLxn30fry1MQ27Sg1Gw+IlrDjqZEvc29xf9H6PRuG8MPjcnRA2LfW6O4+ByubC9vQ2LxVKVwBIDwzBoa2tDU1MTHA4HnE5nRe/fYpB2o4VRxaNidna24pJgJV/C5ubmA+07i7W/JYNtLfuadPkhZuLFJgnFLsikDXGl/SfWJzUUCgmOB4SOjg6Mjo6Kqv5/qO0UZAyDp4NXIFfI8dDld8Oyl8bc3Bz6+4sf05UojM4C+4J2Z2dH2KZTp05hampK9NLtUebOWaVKhBwuqI0GXPzE+wEJoDYacLl3CFaRHp9HARFJTU1NRXO/GQkDo9EIp9N5zSNpxSBCm4i4hYUFvHvoUt5xe/bsWUxOTiKVSgmCVq1WCx0DSRHhzs6OkPpRV1e3n/pR5vPwPI9QKg6OLT82Dw4OYmpqqmqPaBK99/v9mJ6ezhO2qWwGE9FtjE340d/cjm7WgDWH48g6wAFAnbUe33rhKdRndtGiNeOUwYaZmRmYzeaiEWdSAyAW0ka+u7u75DXWaDRiY2OjpmLXSpCmLgaDIa+w2m41wL0TgUIuRYNpCPNzs6ImCRqNBtFolObQUg5CcmhZlhUOktwDqpKYrcWmxe12o6GhQRh0mpubsbGxUbO9y8NtQ1iemsVGqxoyuRwP3PxO3Glq22+TKXJp3eVyVdVbHgDWpQmo602Y/dELqDvRAlYhx5XN1ZKCFoDQeOGxnz+PGSYC1+wiHjZL8Z62U+Cz+0UoPp8PDQ0NR95tqBCSf5ZKpbCysgKn04murq4DF5fCbeA4DktLS0gmk0c6sOdCrJEq+fPm2riUwm63g2VZXL16FUNDQ2BZFtlsGvwbTQq8Xi9cLtehI8zETJzY0/T19e2fS/EJcHtPgIkMAPIHkOEYLCwsAMCR7r+1tbUDxzDpFT8/P1/Ri5aRMHig9RROwQClUrkvyhv3zw3i8lHtthZGZ4H9fPTl5WXhtlKpxMmTJzE1NXWkhYSVcDqd8Hq9+Nfv/gD+7/RL4AEY6y24KaOHWVp9++xa4DgOCwsLSKfToj57V1cXFhcXjzRHvRypVErIFSfvSYRp4XhN7PNmZmaQTCYP5JYzzL4oJ5NPkvqxvr6OeDwOuVwupEaR/RBJJ/C1mZ/h6uIcpEo5bgudwsd7Lxdtz6pUKgVnmcI0IzEUCluZQo7vRlaxsrsJLpnGi+5FtKcU+PcPffTIztk0l8WfzL6Akc05mKVBZLksToSl+PSd7yk5yZXL5SVTpoqxsLAAm81W1hKzliYSlSBpVMQfuHCfmQxKmAxvTmDJCmalcZi0qr5e/sK1QgXtMUFC98lkElKpVBhMSonZRCKBra0t+Hw+qFQq2O32qmxatra28vqQm81mrKysVO3VSQgGAnhP95kDUaRz587ltRItdQKQHCaxEeJIJILt7W34F9eQBAdTayP0zVakYwmENz0YGRkBAMEbkFSTE/sSr16K77zyOhQGLRKZJH64PA7nyipuNrSgubkZFy6IW3o5KuRyOfr7+xGLxbC8vAyGYYQWv1e8a3h87Spek+7h7taTaJFpMT8/D7vdfk38JYH9SKPP5xNVuJBr41IOq9UKlmXx89GXEbE8jxHnK3AYGmDj7oYmOowzZ84cyeSBZVn09/cjEAhgYmICjarX0Sz/BrCXAOOVw+/+O6zE/3/o6OyrqplGJZ/UWGy/6r3Y40ajEVtbW0K1vhhyIx/Nzc3QarUYHx+vKjWgWHQWeHO8yT3f1Wo1ent7MTExcc0mSYREIoHZ2VmYTCbB7s+SliItlaCzuRXJWBxTU1PXfDtIhL6atB+1Wg2ZTIZAIHDNuyWRFZjC/PBKx9HJkyexsrJSMbKfm/oBoKj12g93F7GSjQj/M+ZzwqLU4n0dw0Vf02q1Ynd3Fx6Pp+YmK0TYPj0/honJSUAqQcjrh7bOBFdXKzyJMJqkxqpft9j4cmVnHY7wLlR1RniW1yCVSICOZqSVpY87pVIpKqce2J+0sSx7TSKvpSCNdMxmc1XnkNFoRHt7u5CWVwoy5qtUKppDS8mH9ELOchwmdjYQSydh6GqBISXJW4JNpVLY2trCzs6O0FO7mmp5gtvtFsy5c7FYLPB6vTUNQqurq0WjTwzDoLOzU6hIr6+vL5oju7m5WfGE9/v92NnZETwJGxoa8Og734NvL46A5zhY2vfzYB8dvBv9pv3PQLq3EAshYl/y7cXXwQFYfuHnyCTSaAiGkG1qxL84fRsYhkEgEKhoMn8tUKvVGBoaQigUwuzsLKbDXryY8SIc24XHA7y6NIOHTN14+Ja7rtnsmDRjOH36tKjnV9O21Gw2Y1f7Y0yO7X9nO54AVnb/Hh+4s/3I96nRaMS54U6s/+xjGAmmkUhkMbfCQSKZwplLq2Att1b1euV8UoH9c6C9vb3k/5N2oWJ9WQsxGo04deoUpqenRbt8LC8vl1z1MBgMQh4tQa/Xo7OzE1evXj3yfGyC2+3G5ubmAWEej8bQ1dUFGSOFTKtFZ2fngXz3oyKVSmFxcRESiaQm0dzZ2Snae7tWlpaWEI/Hi26f2+2uGO3v7Owsmr9ejkLrtVAohNnpZxEKheCdXoTGZoVtoBNT8vWSghZ481g3GAxQ8mlAIoFEJd5JJpVKIRAIwO3zQsJIkQiFsfLMq+i8+xIY8BiRjmFXX3wyWu0S+KhnBbtba4hFYlh59lXc9OsfBKtUIpiKo6FEh0exVoo+nw+BQEBUl0BAfHORUpBzq1ohm4vFYkEikShazFsIWV1+q0IF7THAcRwgkeB/Tv0Ur65NQALg9Rd9uMjU4ZP3PAy32w2fzyfYJh32QrO5uVm0yrKpqQnT09NVC1qPxwOTyVR2qY5UpK+vr2NkZGQ/WssqEBt1IxtMYMOzgFt++d15/0MsxrxeLxKJBAwGw4F0inv4OsR3/JhhNLBYGnBHYzd6jQ3C46R6uzBC9YPQKjbmfVCZzZAppDC1NYGVyhCNRoWTNJPJHGj/mftTCPlOCh8rFMIkX7rwRyqV5t1ubm7G1158FVvrToR29qDW6mDuboGr/mCO9VEyPT1dtDDjKMhyKUTZFTR16vCD/zsHq12D7uE6vD7xY6Qb7Hk2MMW8PKv17eQSa4hsJbDpSeOfnt7D537ViFsv1IOBuOhKLhqNpuQyYyKRQCqVKusUwDAMOjo6sLCwUPFCUerzKZXKoi4fxYhE9qNqpaK5dXV1Qh5tLmazGZlMJi/n+ShIpVKYn5+HSqUqmspTmG9vNpuRSCRqXr4uBYleHSbvXKlUwmAwVBVxFwux3rPZbEVX3UgBphix0tzcDLlcLrTKrVbg6PV6NLa1QBoOIRVLQNfcgHQsgciGFyPSEcjlchgMBhgMBuj1+rwmEn0dbZj6k3+Lc/I3ltE7h8Hc/+uQyPJTSRKJBEKhEILBoOCvTF73VFMHXk17wbAsms8NIrYbQGJnDz1NbejvqN66rhjKvUZMXo0ju7SGm37zowhtuMBKWdjUpfO3xTS7iUQicDgceSuhlSCFYdUKWiJkLRbLkaxqNDc3I5lMlvUSZ1mWClrKQbLZLDZjAQR8W2BYKaK+PcRCYfzU4MOp8RGcaGqtKXeuGF6vt2SEiAyS1RRyEePzYgK5GG1tbaivr8fM1AyYl7fRxBuxFw+DCQcR/N48NA91Y2dnBz6fD5lMBvX19QfcGXKRSCRo4pR44LaHK+4f0iXN6/ViSF2Pzd4TaDjVIzx+X8vJig4LtVAohHN/iB9pPB5HPB4Xuk/F43HwPI/tVSey2Sziu3sAD5iyHKLxWOU3rZH19XUYDIaqL/QqlUrUcSORSCGBFJlsCu0nDegaMkKj0qBR14C2pv19nxsBz/1dzcUrkUhgc3MT/rQF9WYNhvt4/PJDZri3UxidDqP7QiOMVX3CfWHo8XiKPuZwOMpGZwkWiwUej6dkZyUxEJcPh8NRNvpWLHc2l8I82lysVqvgnjE4eNDKr1pILl93d3fRZfpSF0W73Y54PF72wiqWRCKB+fl5aDSaI8mN7+jowPj4+JEKWrKfyqWVrK+vi7b7A/a/S7lcjvHx8Zr8Wh9pH8Z//eHfoaGrHXKdGhJI8Kmhd6BTXy9EUkmRGcdxUKlUMJlM0L3+XTTEd7AUTKO73gCsTiD2079DePg+hMPhA+K1mL9yG4CAnMd3VsfAAzDVW/Brt74HuhiP0dHRQzvEAMCAqRFDCQ1GmmxQapXQ9Hbi9qwZMX8A+hpTJlKpVEV3mGKQ1CQxQSWO4+B2u7G1tQWLxXLk9R6dnZ2Ym5uDy+UqerypVCokk8m3dLcwKmiPiSSXgTqVRIbnsPTsqzjzq49Ab6tH20AfmnVHV73udDrLLn/Y7XZsbGyIzsd1uVxoaGioSmyr1WoMGtoxu+vERGQevvAemk0NuPLS6zDr99B4sgMDAwOiIoSJRKJitCISiQhFD3a7HefOncMFhoHNs4yfbi4gy3O4WN+O+1uPLgpEOhLlClTSHjV3eV4ul0OhUAhtQok/KfnsO911+Ll3De237c/yE4EQDLv7EZz29vYjrbQOBALY29urqdhFrVYjEolUvFgyEik61O/GTyb/Bmdvb4aMZSGBBGdaHoFaeTjv3EwmA7fbDa/XK6TkdHTcCib2/wJbvwvwKdgb5LC0PoTF0CC25ubKWnwVolQqi1Y2p1IpRKNR0QK1r68P4+PjFR09KkU+Ojo64PV6MTo6ekCoVIrOAsXzaHOx2+1Ip9Mlm2OIgaSvACh7wY3FYiW9oDs7OzEzMyPa+qwYpPisp6enKr/dcrAsC4vFUvKCXw2kyDOdTpfdTxzHlXUUKYXRaBSK/qrJwQaA5owcnzx9J/xGGRiJBLc0dKJFawKwP37l5uAC+8deIBDA2tWfI7AXwtNzGzBrlOi1GmHaTaN54B1VNQd5Z1MfLls7EEzFYVZqoJTuewDb7XbBIaarq6vmfGan04n7e4bx0eZGBFIxWJV6qKQspqenkUqlRPnq5kIcDXp7e6uePIgpDMsVslar9ZoWLvf392NyclL4nnPRaDQIhULX5H2PCipoj4FsNgsdq0IylgDLsjj9ofuRiUYhlzbAojw6weL3+6HT6coKRYvFAofDIer1OI7D9vZ2VUsqBD6RgUGlgzeyi5eWRnFX30U0GRvQZm2GtYqLQ7nZLKmcZ1kW7e3tBy5kt9q6cKutOlcF4M1uK0SsJpNJ4XfuknhuhzXS4UmpVFYl/j/SdR4ZLosx3wYkEgkeGLiAXzpxBpFwRIiIFHYrq4VUKiV0n6sFYuNSqciK4zgwnpN4z+V/hSDmIWNU6DU/CLOytugbx3Hwer3weDzgOE7okJa3j7V3AB0/ApJLgNQMuaIXgxKJ0LntsFGejY2Nqi56LMuipaUFS0tLhy7qs1qtUKvVmJqagqVFgYXE3yKUcmNnhcGDF36n4v8Xy6PNpa2tDUtLSzVFSElBU0dHR8XjIhQKle3WRy6spdpXlyIWi2F2dhZ1dXXXJN+1ra0No6OjsNvtNYsKso253rGl8Hg8aGhoKPucUqjVapw+fRoTExOi0y1SqRQ2Nzdx77mbqupsyHEc4hIZtAoZHj3fBa1cihSkCBtM8Hq98Hq9UCqV0Gg00Ol00Ov1Za9LGpkCmoJUBeIQk0gksLy8LAjbapbrC4tfTYo3/3doaKhsC+9Sk8HZ2Vk0NzfXNHEqZ4OVayV5PRx4CIODgxgbG4NcLs+7zhDxTVMOKHlwHIdmvQkGXQN+HliGzmqGlGVxc9oIlfTovpK1tTVRy4dms1lUbtj6+jqampqqPqlisRgWghvY23Oju74dX3j4s+A4DsF0DN5sCOtXrghFX2azuejrb0YD8MRC2HKt4v5b7hLuz00rMJvNotrt5pIbVSUilQhWAulOpFQqoVAoYDKZhMjqUQ8wSqkMn+y/FVmegwQSoWGEXq/H0NAQEokEHA4HlpeX0dzcXHNV8fT0NHp7e2tOayE2LmLeZ1/gHM5Fwu/3w+12C22VK0b02fr9nxwsFgvMZjMWFhbyLb7KUGjwznEc/H5/1WLPZrPB6/UKftGHQavVYuBUJ772449BbeKh1rGIpKL4xd4fo974FajZ0sKlVB5tLt3d3ZibmxPdBaoWS7lwOIzGxtJthRmGweDgIMbHxyGXyytGGHMbJBx157zC7WpsbMT6+rro9su5kHzekydPitpGt9t9KLswuVyOM2fOCF61lcaL2dlZ9Pb2imoZ7fF44PV6wTDMfuTwlz8DPPF1gJEAbxTCM+//DUha910XEokEIpEIwuEw3G43UqkUGIYRWjzr9XpotdqK761UKjE4OIhIJILFxUUoFApRNQBiil/7+/tLdjskebS5UViHwwGNRlPzOOwI+/Bd5ySezGzhtK0VD7QOgoHkWIQsgVjBFTqskCJZ6nJAyYN4cb67oRf9CjNa+3vQZrAgG47h6tWrR1LlGwgEhBaRlWhqasL8/HxZQZvJZODz+aqyt0okElhZWUE6nUbnmT7I6tsR/PESkOUhVcpw4oOXoOjYX8rKdSUgS3skF+ypjRl8b20CmUQCQfcOkk1m3Gfrxfr6OqLRqJBWUKzopFhUNTe5n6QAELGq1+uFVprHiVRSukiov78fmUwG6+vruHLlChoaGoRmBmJYWVmBxWI5lLBSq9VIJpMV30en01VllZVLbtMQYi9z2JQLhmHQ39+PUCi0b/FVwTO5sInExsYGmpqaanrvvr4+TExMFD1Wqz3f/eklNPcrsLkSxGtPOnDXBzuR4eLYjk6hw3BHyf8rl0ebS+7SY7mLNWlH2tLSUtVFPRqNVvwuWZYVIozlckHJNjQ2NoqynTsszc3NuHLlClpaWkRPCEkHPoZhRAsUktJz2FoKlmUxPDyM6elpJJPJknUDbrcbGo2m5LhQbHUkv9bDDv6D/wb8ws8BCQPJwM2Q2N4U/SQIkDsekNUvcq6TCCDLstDpdILQLfbda7VaDA8Pw+/3Y3JyEnV1dWVdgObn59HR0VFxbCfdDomHNnk9hUKRJ2g9Hg+i0WjNOeeu6B7++8SzCGTCkHqTcCWDmF9Zwt36NjQ2Nl53IZsLy7JC8xXi1UyKwqigpRQlnU7DrjFi2PpGFEShFvJxDlttvLa2hr6+PlHPJSdoKpUqebKTpUQxkKYB8XgcJ06ceHPZYkAPZY8FXCwFRiOHRPrm5yOesR0dHUilUvB6vZidnYU7vIdvuiegNOoR3wtCykrxzZ/+CPwJD8529EKn0yEej2Nubq5oCoBCoRB8aUnO6rVup3k9YFkWnZ2d6OjogNvtFuyhWlpayg7YPp8P0WhUtK1MOcotPXm9XsTj8aoH+1y/ZbVajaampmvivavX63Hu3Lk8F45iEbNcQUsu6LV6FsvlcjQ2NgqdygqpZimPkbBIRDOIRzNo6jbAvRqGrVUHprH8sV0pjzaXwcFBTE5OgmVZyPVaOKN7aImFBGujlZUVhMPhmhoziPW/Jn7NU1NTYFrrsRDegVIqwx2N3TDJVUJk+Ho2hwD2Uw8cDoeo2oNIJIK5ubmqU12qTW0pByksXFhYKJojTYoqi6WT+Xw+eDweYXWkr6+v5ORC0twDSXNP0cdKbRcZ+3NJpVJCNJe43gA4EM1lWVbwsCXjoDBJjb4M7H4D4KJwhU5DoXxE9OS6mFsEaX+r1+sRCoWExjC18opnBVkuiwzPwTMyDZXFiKDVgt+89UHoFMffwIAET3J9qhmGoYKWkg9ZwkylUgdOZFJtPD09XbPoiEQiYFm2qgR1UhxW7EKbSCQQDocrCotMJiMs+5Vq6yphGUj15bdLLpejubkZdrsdeyszSC3FsLuyjvknXkTjUC+UJj1meT0UsYwQWSX5WeSkYxgGLMsKFZmpVEpwGch9PNc2i9y+kSB2X83NzfB6vZicnIRGoxHa1+4lY/je2lWMLY5iUhFDZ5jBLRdvOrL3LiZMIpEInE6n6MG+WHFXLX7L1UJstRoaGjA/Pw+DwYCOjo68983tika67R2G5uZmjI2NHbqVamxbg6BLgbYeE2RKBtkMsLchwa5Dhsb+0hNToHIeLYGIoL9/7ik8l97CnnsbTzM7uNnYhoHEvjivxYmg3MS5GFqtFk5lBt964luo724HI2Hwk4VxvE9zAsO9/UduoyUGq9UKp9NZ0enD5XLB4/FU7TbAcRyi0eiRFbQRenv3V7amp6cRqlPhFe8qAKDel8Qj528Tjv1AIICtrS1EIhGYzeayzjPXArlcLgjVXEg0N9djnGVZITe3v78fOzs7uPLSX6JD9mVYzCwi0TQ8jqs4fzMHYED0NuS6RZhPtODx9asIJeMYbu2EPcDhrMjGMLne6LnuNovOGezubSLDc5AwEmjMRmTjCYyNjUAje/NYkcvlkMn2rRtlMhnkcrnQblsul1/TcVJb4A+tUMiRSYpvAXy9oYL2GEilUpBIJEgkEkWXL+32fX/O6enpmpYzKtn3FMNqtWJ9fb3oBWplZaVsi1qy/O33+9HW1lZVB7NcSLVsMBhEPB5/40RNQ202wthqR8dtb0bGPnjqbvQZbQf8Y8vdTiQS4Hn+wOPZbLai52whpfxkc0Uy8Z8tJZyL3T4MpPo4EAjsd/7hMvj7wCISMgm2wntwv/4Sevt6cDNzNLYrJHqZe9El9jWnT5+uWNFfsbjrOqFWq3H27Fm4XC6Mjo7mWU1ptVqhK1pht71a6evrw+zsbE1FS6SgyGq14jfu/zqu7nwLwaQTel0Thns+ikRYgomJCTQ1NZUsOBKTR0uIZ9N4md2Df9WNbCqDyLYP359fRc+7PlBzpX+lgrBCsjyH54LrUJuN2J5ZBKNUQiaVwnOx71jELKGrqwsrKytFPXMzmQzm5+ehUChq8hF3u90152VWoq2tDd+ffA1//eT3UXeiBfFAGOl4Ag3eZnR5NQgEAtDr9WhqajpyQV0rue3izWazsGIC7I85oVAIu7u7WFtbQzQaRdrzJBa3QkilUuB5BvffYUBk6x/BGv7/YGXiV+mMRiPMbU34/e9+AzKzHulkCtNry3jH2Uu4KWdSRiLKuZaMJLWNCG5ib9bU1ASlUgl1ZxNc088DABp6T4CBBO26Otx++pY8a6xUKiX8EAedYDCIVCqVtyoJ5K9M5gphIoJrWcUwm81IpVKY/Pb/hvr1pxCb30S2MQHmPb8JiaG2dLJrBRW0xwA5OdPpNAyG4mbOzc3NyGazFVsZFkLacdYS/TEajfD5fHkXukgkgnQ6XdJLcn19HT6fDy0tLVVFaxKJhCBeiXm9RqMRomS50YA9kxxPu+aE27fZOtFr2I+UkRP4elMogMuJavJ3rnAm9+U2cBDbfStXBBcTzcD+kvrrrkXMj15FJpWCb2UDfe++FbtIYynoxYCpdEGOWDQaDWKxmHDRy7WvKfWdVF3cdR1pbm6G1WrF/Pw8tra20HWiA9KRJ5H6yRPYfMkMc9/NYJjDt0hWq9Wor6/H+vq6kM9YrtqZQKyoctMjLjd+Nv+1zfvn8crKSsn202LzaAFgOx4GJ2WgrjPjyl/8A3oeuBMtw/3Y4cvnT5cjHA5XJWjT2SxS2Qy4dAae2WXomxuhMxsxPzWDkYgMLMsKkStyIc+NYF2rSZLRaMTa2hpWfFtISoFGtQEmhVrI6RXj9pBLMBXHP6yMwhndQ3xlE7/9wIeuyXZzHIeRqAcKvQ4Lz/0csW0fdDYL/srjx29dvA9GoxHJZBKrq6vC83Mn+mTMIo/l3i71dynEeJqSca7Y34W+1SzLwmAwgMmoYJTJ4NrOIhTKwrWdRjabRjY2ikxWIozFuZ+BbA95D5Iz+vzmIsKhIHbGZpHw76Hj1nN4duQ1dIWlUGD//VUqlZDaptFo0NjYKBx3hR7b5D37DA34eM9lPL52FbFMCr2GBjzac9OBfVKNECX2kUT8plIpBINBJBIJpNPpA80hiOgtde6QbW4Iu5GYfQFrwShSfBbY2QD3vT8B86t/CEmJeo/jgAraYyCTySCTySCbzZadAZM8raWlJdFRz0rtOMvR0tKCxcXFvEF4dXX1QHQ2106ksbGxYk4hMePO7QyjVCr3u9I0NqK7u7tsBON9HWcwZG7CViyEepUWvYaGYzd3PoqIKhGx5KfY7Ww2m/cYuR2Px4X7yIWD53mhrTLDMNjd24VULoNEwkCS5ZAKx7ETXMVUtg6KlljZggsxqNVq7O3tCbfn5uaK2tdci+Kua4VcLsfQ0NC+3+s3/hs6fIuQhCPYCHhxJr4Lvr0dku7DFx61tbVhZGQEDQ0NFfd/IpHA7OwsTCaTqKguwzDo7u4u2X5abB4tx3GI+vzwzi1DrtXglt/+BBL+ADyzS4Ch+gp/QjgcrqqwLuDbBdZ3INXIcPqDDwj339N5HuftPXke0OR3NBoVIli5E0UyAS5cws2NYomF53lMMRF8/4dPoa6rDYxEgvs0rWjmVVXn9Ka5LP548lnsxCNIRKKIJUP4H1M/xefPPQCDXFX0f8j5nxvBy2QygnBJp9PCWJILwzDYXnMhm02ClUohV6ugqTdDplRDIpEIAYbcVaTcboccx0EqlYr6XBKJ5EDnv1yRm9slMPexXJGZO/kn/5P7vNx9IQQOonZk/HHwWYAHg7G5ODhpL7I708hms+B5Pm/clEgkwraS+yUSCXiex6Lfhb3wDlLxOBLhEBhWCkYmhcFsEmy/cqPFiUQCe3t7ebmmhdtL/pYD+IC0BZACSAALk9Oi9uthyN3X8XhccPYhxw05dsgPz/Pg538O3u3EkmcXq/4owHPArhuIBoE3PIrfClBBewyQg0RM/ktHRweWlpbgcDgqFmUlEglkMpmal4mUSqUwQMrlcgQCASFpn+ByubC1tVXSTiSTyQhtDYPBIDKZDORyOXQ6Herq6kSbaxfSZbCiy3A8y4ulRGeuyMy9P/d2uQgFy7JCni/5m6QwkCIEEnUgj+X+XYnhRBSLoyzSXBYtl4bAQAIVK8O7hm8FF0/mFVwwDJPnESlGcGp2HHC+/iK44Cls6NvyKuKvV3HXUZH7fWUyGSgUCrTtLmPJu4dXHB6ctJnBgQM3/TNIj0DQAm+mHpBc42LHCjnfqjXHB95sP+10OjEyMpLXZMBgMCAQCBTNc0+lUtjY2IDf70dDQwM+ds/DeNI1AwYSyO1WDHb2oEtuxMjISMlc+XKIzaH1+/1YXV2FyWTCf37/J/Cncz/DdnxfbN3R2I07Gvcn+QzDCBX0lciNYBHxEQ6Hsbu7K4jf3O+hnPhdiOzg5aATYBjE9oKI7ezh29ptfO2R3yj6+QpXdXJ/pradWFlbRSaVwcbYDOramrAyMYO/3kqiT1svTGQLo55SqRQymQwSiUQYN6RSqZAGRcaQQiHVp7XgZc8KjE1WoGl/XB1uaINCoTiw3TzPH1gNIvu9XLQ09zb539z9QIR2bhoYebwwgkpuF74mgWwX2QcsewlMtAPS0GNgJXGwhpvBWD8HVq4/MJ5WGkvn9jz4yvRzb74XJLBrDLh4aliwVRRLse++cHWv8L7CVbxS94uh8DOTiUnu91Xs+4UV4CdSiLSZ4c1tNiM7eLwcJ1TQHgM8zyMWi4k2xye+kLlLlMUQ246zHOo6E/72ynMw2Bsgcfpw/6XbALzpn5jbqYTjOIRCIQQCAYRCISQSCcFuxWAwoKmp6botJxcKkmIRTzJwFot+lhKeuUtZ5CJBBsTci0Yp0XmcRWZmpQafO3U3/nrxdfgSUdhUeny89zKMKg2g0uQJEY7b70gUCoWwsbEhdK8hVcVGozHPI5L7+RNgX3kcKZcfO+tj8PEKDP3rrwjL4kdZ3FU4mJf6XRjNzr0QFhvwcy/0uZMJ8hvJNOxGDXqsBhiVUizuhJDEOpiRESEvTqPRQKvVQq1WV720rdVqYTAY9j05uSyS2bTwWCqVwuzsLHQ63aHte1pbW4VUCpVKBXt7G37oW8TE6DKaO9rw3vZhnKtvRSwWg8PhQDweR2trq5BC1IpW9BgbsBbZhVGuwoX6NrCMVHAzWVtby3czKUOlqDCwn+a0vLwMhUKBoaEhYQz5wrkHEEjGoZCyB0z3xVKN+AXy8xdjsRh2d3cRDocRiUTwwtosVl2LSMWScE/Moefdt4HnODz7ykto1ZqESBeJnJLJLvnJjX5uJSPY2/KAkUkhkUggUynByFmY6uvQ09KT585STDzm/l3qdi5n+LNoW5vAy54VAMAtDSfwSMdwnl1gubG0cMUo9/OVm8gXjqfkvFOr1TliNH8czb1dHZ0AfiPvnkLhGIvFKopMNc/jnYomPLk2iXg6hRa1Ee/UdmN2ZkZU4KLY5y+svcjdL7nR8ELhXa4W41rCGz8IzjsHpPUY4HkAPHD6LkgU169QUAwS/q3swXCdCIVCMBgMCAaD1yUJ/mtf+xqmpqbwB3/wB1UVVkxPT8NoNBb9n1QqhcnJyUN1x/ElIvh/Rp/ExswCDHYrYsEIPnr6VtjiDMxmM+rq6hCJRPKKtkjeq9FoFB0hOUzEsxSVRGcpwUn+phSHVBUHg0HBI1LGZaD5/pdhUMkw4fIhns7CpFYCQ3eg/vaHUFdXB4ZhyorL3AlG7oSiMM+M3FcoOIvdLhz8q4nCFCP7zF8DUy9BcIkHILn/18H0XUImk0EkEhEql6PRqHB8EscNlUoliN1S75/MpPGHj/8VHHwcDAOc7z2J95q64dvaRm9v75GPR9vb2/ijn/4j9jRSRLy7qO87gUQ4ike0J3DCWI/W1taqu9Dl+k13dXWVjSST9JNi0XryOtlstuoOUIdFTIOV3KVpiUSC6b0tfH99ArxEAnAcwO0fJ5/uvx11am1eTmKl4pxkNoMvjD6BQDIODjwYSCBjpPjC+QdgVhRvEZyL2NSlYrdLUbhiVOp2MeFZ6nivFJksdn+xQt7c8aRSQCL3vUsJx9ztLiYocycfuUL8egnKtwK83wN+5MfgE1FIWvogGb7ruuXPitVo9Ep+DJBZe7UXDuILyTDMgQrmo4jOPrUxgxSXhUyjxuLLV6BQqvBn65v47Jl7sLe3h42NDWg0GqjVahgMBiFfy+PxwOVy5c3OC+dJZMDJnZXmDgxk2T33MeIhWzhIFi6fFXuf3Nu5y4zF8prE3K7muaU+u9j3KfY5c+/LXY4jy05kv5O8L/I8kiuWe1/h+5H7yPMqkQz4EJvbQCKTxbfHVnC22QibwQBVchTS4P775y57ChFPvJnDSH5LJBLI5XLhf8jkojAdI1e45kZRcy+ihREP8n61/i257YOAVAYsjoBRKCE5fx+YvkvC9hmNxqLnMOmIFIvFsLGxIeQ7M8x+VyS1Wi1Edp/cmodHK0F4cRu6BgteG7mCcIMH//7dH6nqIllMGBQTCaFkHDuyLIION9xX5xDa3oXeasbOuQ68t0abQKVSiZMnTyIWiwnFZqUEaTGHg1y7v66urkO3dc6F47iSDVZIkxXiOkO+eyJcyRgE5Ofekt/vammGW53FUtQPqUwGCSPBAy2DuKe99H4k3wWJDOYKz4/U9eM7K6PYDAVgZBW4r3kAW8trcNUY9cy9TboaFoovskpRTmAWK2atxRkGQN4YX0o45t5Pxopykcl/LoLyuJGYbZDc+7Hj3oyyvG0E7de+9jX89//+37G1tYWTJ0/iK1/5Cm677bbj3qwDcDyHvVgY0VQSGk3lmXchuWbnlnoL/MkYGA6ifGKLQfzxotEo5qZnse3bxM7KGlyvjKPp7AB4nQ7RRBxKmRzZbBbpdBrhcDhPPMjlcmHgLGxdWDjQiH0MgCDOCkVYuf8t/C3mfSrdLhy0iw36hYUKuX+Tz0FuF/7OrbDNfazYIF1u8M/9KbacVc1POfh0Chy/BCTj+Nydp4T7Jfd9Ekx/eY/bSqKrWGSpWLSeTE7S6bRwH1nKLdyvAPIiUYWTj9xjpjAvj+cNkLS+cz8qtxmFxP10yX2bm09InpP7WhzHYXd3F5ubm4Kw+vuFn2MvFYdnegmpSATNF4Yw4tvDU7wxb2KQK+4Lo0zk9cV8/9lsBhKGgamtCZlUGlqbBXJWht0tL0ZGRoTtJf7OKpVq32JIra7Y6lmtVmNoaAihUAiLi4uQyWTo7OyEUqlEJJ3ES55lzM3M4qb+U7Bj35qQFJfWYvdXGFWNx+MIh8OIRqNCPmwmkxEiqmSsym24otfry0ZQy0U9E7E43lffj0lsIJCIoZ7VojXA5e3HQshxkHveCtsnkeBDTaeBpvyJVW40l2xHbv5krtCsROHxWkwgFub0VxKSVFBS3iq8LQTtt7/9bXzuc5/D1772Ndxyyy343//7f+O+++7D7OzskXVaOQqCqTj+ZOp5fH9pDJGAH1+Zeg6fPnk7lFKZ6NdgmH2z8xd+/hp+PPUsgnIguLmNm1q7cYbnirZM5ThOWB6NRqN5y6NkWVSn0+GmwSH4PQrU953AwAN3g4EEjWoDfunc/Ue2D8pRKcpU7qdYFCFXaFYbSQAOioRS4pH8yGSyqkTjjdjIAQAkMjmYh38L3Pf/F5Dc92jF8DsgeSN6WY630sWvmuOr0jGV+1i5vGwiFCWSfesge3QT6agfdo0SXDwJlUEPnUIpRDGJ4CbvmU6n87YdeFOIF1tCJWKNCBQFy+KksRGzgS1YezrASBkwUikePH0zTpiswv9x3H5+YSwWQzgcxs7OjhBpBvYjbQqFAmq1WvhNBKFer8fw8DACgQBmZ2fByRg8FlxEhM/C51rFgiaNlZ0t9PHaosWlJKpKJtuhUEgYv4j9EBF15LNJpVLI5XKo1WpotVro9XpIpVIh0koEPimcJRPz3GKr3O+VVLwXnvckeps7gbFKWNhkRkgZKdLpdEkHlsLzvtiko9REpJSYvFHHEArlWvC2yKG9dOkSzp49i69//evCff39/Xjve9+LL37xixX//3rl0P6v6ecxt+fBS1/9G0gkEtzymV/BnY3d+HBX9Xmv/2X0KYyNjUHdaEHEvQ1rfxfe03wSt5ra8oQrGZRzC1hIy8DCi3E6k8Ffzb+KsR0nOJ6HiVXiX/beDItCUzQaWS5SWUlAlhqExQjIaxl9pIiHT8WBvW1ApYVE/9Yy2L5RWAxs439OPwcuywEchwzH49HuizhvaRUlsMudi9lsFqlUSlhZIdHsZCaNl91LWA/tQilhcc7SDJtSf+A8JuSei0Q4syx7QLyTSSXxhVUq94X5i64FvLgyBaXZiODmDhRKGcBL8Nmz70Aiup+jnWuzRQqmSAV/7rI5WYImIjU3p5Xcl5uSUnhbJpPl/RQKxVKFOpXuo1Ao145/Njm0qVQKo6Oj+L3f+728+++99168+uqrRf+H5E8RQqHQNd1GwkrIBw484v4gWJUCO4sO/GxjF32Ryl9D7qCZ5TmMT14FL+Hxi//zD2BZKVwjM3Crn8NS20koFAqhHWxh5CP39QqXvRiGQYtEAlNahwwAs1KF9el5bBQRmSQKUSg6cy94Ygb7QsFbTQSV8lbBB2DtuDfihuU+rh4Tu5vIgseA0Qa1N4JZ7+yRvT4RdblFm++31At/FztHi0Wbc6OYRBxLpftRSRLVTKVSiMfjiMVi8Hg8iMfjmHAtwe/fRmB7DL65FXTcdh5yrRoL+iU0mOpgsVhw4sQJwROZYfJTA4iLSDmBSaFQKDe8oPX5fMhmswd6rDc0NMDj8RT9ny9+8Yv4wz/8w+uxeXnoZQoks2nc+m/+5f4SNStDj8mGocH9IgKxYo7neTQG5xBLp3H2E+9/Y8CX4SZbGz7ef+uht/OoLxD0gkOhlOeh496Aa8jrXgf+cuE14bYEEuhkCvzuxfdCSscGCoVyRLxtRpPCvCWS61SM3//93xeM/4PBIDY2Nq7HJuKDnecggQRqlQpKuQJylsX7TpzJizyI+ZHJZPhg9wWwchbGOhPUOg00ahXe03lG9GuU+znMcj5d4qdQKLlcqm/HO5reLFjVyuT4zMk7qJilUChHyg0fobVYLJBKpQeisV6v90DUlkCW5K83p8xN+LfD9+LqrguMRIJL9e1oUNeWs3tbYxfqlBpM+jehYFjcautEvUp8f3QKhUK5HkgkEnzwxDm8u3kAkXQK9SotZIy41qkUCoUilhte0Mrlcpw7dw7PPPMMHnnkEeH+Z555Bg8//PAxbllx2nV1aNfVHclrDZgaMWBqPJLXolAolGuJXq6CXq467s2gUChvU254QQsAv/3bv41f+ZVfwfnz53H58mX8+Z//OZxOJz71qU8d96ZRKBQKhUKhUK4xbwtB+6EPfQi7u7v4T//pP2FrawuDg4N48skn0dbWdtybRqFQKBQKhUK5xrwtfGgPy/XyoaVQKBQKhUKhiEesRqNlphQKhUKhUCiUGxoqaCkUCoVCoVAoNzRU0FIoFAqFQqFQbmiooKVQKBQKhUKh3NBQQUuhUCgUCoVCuaGhgpZCoVAoFAqFckNDBS2FQqFQKBQK5YaGCloKhUKhUCgUyg0NFbQUCoVCoVAolBsaKmgpFAqFQqFQKDc0VNBSKBQKhUKhUG5oqKClUCgUCoVCodzQUEFLoVAoFAqFQrmhoYKWQqFQKBQKhXJDQwUthUKhUCgUCuWGhgpaCoVCoVAoFMoNDRW0FAqFQqFQKJQbGipoKRQKhUKhUCg3NFTQUigUCoVCoVBuaKigpVAoFAqFQqHc0LDHvQFvBXieBwCEQqFj3hIKhUKhUCgUCoFoM6LVSkEFLYBwOAwAaGlpOeYtoVAoFAqFQqEUEg6HYTAYSj4u4StJ3n8GcBwHt9sNnU4HiURyzd4nFAqhpaUFGxsb0Ov11+x9KPnQ/X79ofv8eKD7/fpD9/nxQPf79ee49jnP8wiHw7Db7WCY0pmyNEILgGEYNDc3X7f30+v19AQ8Buh+v/7QfX480P1+/aH7/Hig+/36cxz7vFxklkCLwigUCoVCoVAoNzRU0FIoFAqFQqFQbmiooL2OKBQKfP7zn4dCoTjuTflnBd3v1x+6z48Hut+vP3SfHw90v19/3ur7nBaFUSgUCoVCoVBuaGiElkKhUCgUCoVyQ0MFLYVCoVAoFArlhoYKWgqFQqFQKBTKDQ0VtBQKhUKhUCiUGxoqaK8jX/va19DR0QGlUolz587hpZdeOu5NetvwhS98ARKJJO/HZrMJj/M8jy984Quw2+1QqVS48847MTMzc4xbfGPys5/9DO95z3tgt9shkUjwve99L+9xMfs5mUzit37rt2CxWKDRaPDQQw/B5XJdx09xY1Fpn3/sYx87cOzfdNNNec+h+7w6vvjFL+LChQvQ6XSwWq1473vfi4WFhbzn0GP9aBGzz+mxfvR8/etfx9DQkNAs4fLly3jqqaeEx2+k45wK2uvEt7/9bXzuc5/DH/zBH2B8fBy33XYb7rvvPjidzuPetLcNJ0+exNbWlvAzNTUlPPbf/tt/w5e//GV89atfxZUrV2Cz2XDPPfcgHA4f4xbfeESjUZw+fRpf/epXiz4uZj9/7nOfw+OPP47HHnsML7/8MiKRCB588EFks9nr9TFuKCrtcwB497vfnXfsP/nkk3mP031eHS+++CI+85nP4PXXX8czzzyDTCaDe++9F9FoVHgOPdaPFjH7HKDH+lHT3NyML33pSxgZGcHIyAjuvvtuPPzww4JovaGOc55yXbh48SL/qU99Ku++vr4+/vd+7/eOaYveXnz+85/nT58+XfQxjuN4m83Gf+lLXxLuSyQSvMFg4P/sz/7sOm3h2w8A/OOPPy7cFrOfA4EAL5PJ+Mcee0x4zubmJs8wDP/jH//4um37jUrhPud5nn/00Uf5hx9+uOT/0H1+eLxeLw+Af/HFF3mep8f69aBwn/M8PdavFyaTif+Lv/iLG+44pxHa60AqlcLo6CjuvffevPvvvfdevPrqq8e0VW8/lpaWYLfb0dHRgQ9/+MNYXV0FADgcDng8nrz9r1AocMcdd9D9f4SI2c+jo6NIp9N5z7Hb7RgcHKTfxSF44YUXYLVa0dPTg09+8pPwer3CY3SfH55gMAgAMJvNAOixfj0o3OcEeqxfO7LZLB577DFEo1Fcvnz5hjvOqaC9Dvh8PmSzWTQ0NOTd39DQAI/Hc0xb9fbi0qVL+Ju/+Rs8/fTT+D//5//A4/Hg5ptvxu7urrCP6f6/tojZzx6PB3K5HCaTqeRzKNVx33334Vvf+haee+45/PEf/zGuXLmCu+++G8lkEgDd54eF53n89m//Nm699VYMDg4CoMf6tabYPgfosX6tmJqaglarhUKhwKc+9Sk8/vjjGBgYuOGOc/a6vts/cyQSSd5tnucP3Eepjfvuu0/4+9SpU7h8+TI6Ozvx13/910LRAN3/14da9jP9LmrnQx/6kPD34OAgzp8/j7a2NvzoRz/C+973vpL/R/e5OD772c9icnISL7/88oHH6LF+bSi1z+mxfm3o7e3F1atXEQgE8E//9E949NFH8eKLLwqP3yjHOY3QXgcsFgukUumB2YrX6z0w86EcDRqNBqdOncLS0pLgdkD3/7VFzH622WxIpVLY29sr+RzK4WhsbERbWxuWlpYA0H1+GH7rt34LP/jBD/D888+jublZuJ8e69eOUvu8GPRYPxrkcjm6urpw/vx5fPGLX8Tp06fxJ3/yJzfccU4F7XVALpfj3LlzeOaZZ/Luf+aZZ3DzzTcf01a9vUkmk5ibm0NjYyM6Ojpgs9ny9n8qlcKLL75I9/8RImY/nzt3DjKZLO85W1tbmJ6ept/FEbG7u4uNjQ00NjYCoPu8Fniex2c/+1l897vfxXPPPYeOjo68x+mxfvRU2ufFoMf6tYHneSSTyRvvOL+uJWj/jHnsscd4mUzGf+Mb3+BnZ2f5z33uc7xGo+HX1taOe9PeFvzO7/wO/8ILL/Crq6v866+/zj/44IO8TqcT9u+XvvQl3mAw8N/97nf5qakp/iMf+Qjf2NjIh0KhY97yG4twOMyPj4/z4+PjPAD+y1/+Mj8+Ps6vr6/zPC9uP3/qU5/im5ub+WeffZYfGxvj7777bv706dN8JpM5ro/1lqbcPg+Hw/zv/M7v8K+++irvcDj4559/nr98+TLf1NRE9/kh+PSnP80bDAb+hRde4Le2toSfWCwmPIce60dLpX1Oj/Vrw+///u/zP/vZz3iHw8FPTk7y/+7f/TueYRj+Jz/5Cc/zN9ZxTgXtdeRP//RP+ba2Nl4ul/Nnz57NsyOhHI4PfehDfGNjIy+TyXi73c6/733v42dmZoTHOY7jP//5z/M2m41XKBT87bffzk9NTR3jFt+YPP/88zyAAz+PPvooz/Pi9nM8Huc/+9nP8mazmVepVPyDDz7IO53OY/g0Nwbl9nksFuPvvfdevr6+npfJZHxrayv/6KOPHtifdJ9XR7H9DYD/y7/8S+E59Fg/Wirtc3qsXxs+8YlPCLqkvr6ef8c73iGIWZ6/sY5zCc/z/PWLB1MoFAqFQqFQKEcLzaGlUCgUCoVCodzQUEFLoVAoFAqFQrmhoYKWQqFQKBQKhXJDQwUthUKhUCgUCuWGhgpaCoVCoVAoFMoNDRW0FAqFQqFQKJQbGipoKRQKhUKhUCg3NFTQUigUCoVCoVBuaKigpVAoFAqFQqHc0FBBS6FQKBQKhUK5oaGClkKhUCgUCoVyQ0MFLYVCobwN2NnZgc1mwx/90R8J9/385z+HXC7HT37yk2PcMgqFQrn2SHie5497IygUCoVyeJ588km8973vxauvvoq+vj6cOXMGDzzwAL7yla8c96ZRKBTKNYUKWgqFQnkb8ZnPfAbPPvssLly4gImJCVy5cgVKpfK4N4tCoVCuKVTQUigUytuIeDyOwcFBbGxsYGRkBENDQ8e9SRQKhXLNoTm0FAqF8jZidXUVbrcbHMdhfX39uDeHQqFQrgs0QkuhUChvE1KpFC5evIjh4WH09fXhy1/+MqamptDQ0HDcm0ahUCjXFCpoKRQK5W3C7/7u7+I73/kOJiYmoNVqcdddd0Gn0+GJJ5447k2jUCiUawpNOaBQKJS3AS+88AK+8pWv4Jvf/Cb0ej0YhsE3v/lNvPzyy/j6179+3JtHoVAo1xQaoaVQKBQKhUKh3NDQCC2FQqFQKBQK5YaGCloKhUKhUCgUyg0NFbQUCoVCoVAolBsaKmgpFAqFQqFQKDc0VNBSKBQKhUKhUG5oqKClUCgUCoVCodzQUEFLoVAoFAqFQrmhoYKWQqFQKBQKhXJDQwUthUKhUCgUCuWGhgpaCoVCoVAoFMoNDRW0FAqFQqFQKJQbmv8P2GxRuGYlIU8AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import torch\n", - "\n", - "\n", - "def plot_pyg_spatial(data, node_color=None, node_size=10, edge_alpha=0.15, edge_lw=0.5):\n", - " pos = data.pos.detach().cpu()\n", - " ei = data.edge_index.detach().cpu()\n", - "\n", - " x, y = pos[:, 0].numpy(), pos[:, 1].numpy()\n", - "\n", - " y = y.max() - y\n", - "\n", - " plt.figure(figsize=(8, 8))\n", - "\n", - " # edges\n", - " for s, t in ei.t().tolist():\n", - " plt.plot([x[s], x[t]], [y[s], y[t]], color=\"k\", alpha=edge_alpha, linewidth=edge_lw)\n", - "\n", - " # nodes\n", - " if node_color is None:\n", - " plt.scatter(x, y, s=node_size, c=\"tab:blue\")\n", - " else:\n", - " c = (\n", - " node_color.detach().cpu().numpy()\n", - " if isinstance(node_color, torch.Tensor)\n", - " else node_color\n", - " )\n", - " plt.scatter(x, y, s=node_size, c=c, cmap=\"Set2\")\n", - "\n", - " plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n", - " plt.xlabel(\"x\")\n", - " plt.ylabel(\"y\")\n", - " plt.title(f\"PyG graph: {data.num_nodes} nodes, {data.num_edges} edges\")\n", - " plt.show()\n", - "\n", - "\n", - "# example:\n", - "d = dataset[0]\n", - "plot_pyg_spatial(d, node_color=d.categorical_index)" - ] - }, - { - "cell_type": "markdown", - "id": "f20f5ca5", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7458cdf6", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "spatial", - "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.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/model_components_testing.ipynb b/notebooks/model_components_testing.ipynb deleted file mode 100644 index 56a5c97..0000000 --- a/notebooks/model_components_testing.ipynb +++ /dev/null @@ -1,685 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Model Components Testing\n", - "\n", - "Interactive checks for encoder, attention, SSL, heads, and losses.\n", - "\n", - "Config composition follows the same style as `data_loading_testing.ipynb`." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "flags:\n", - " use_attention: true\n", - " use_ssl: true\n", - "encoder:\n", - " _target_: src.models.components.backbones.EncoderConfig\n", - " input_dim: 64\n", - " hidden_dim: 128\n", - " out_dim: 128\n", - " num_layers: 3\n", - " dropout: 0.1\n", - " conv_type: gine\n", - " norm: batchnorm\n", - " jk: last\n", - " act: relu\n", - " pooling: mean\n", - " set2set_steps: 3\n", - " gat_heads: 4\n", - " use_edge_attr: true\n", - " edge_weight_index: 0\n", - " edge_attr_dim: 2\n", - "attention:\n", - " _target_: src.models.components.attention.AttnNetGatedProjected\n", - " input_dim: 128\n", - " projection_dim: 64\n", - " hidden_dim: 16\n", - " dropout: false\n", - " n_classes: 1\n", - "ssl:\n", - " method: bgrl\n", - " predictor:\n", - " _target_: src.models.components.ssl.MLPPredictor\n", - " input_size: 128\n", - " output_size: 128\n", - " hidden_size: 256\n", - "graph_head:\n", - " _target_: src.models.components.heads.GraphPredictionHead\n", - " input_dim: 128\n", - " output_dim: 1\n", - " hidden_dim: 128\n", - " num_layers: 2\n", - " dropout: 0.0\n", - "node_head:\n", - " _target_: src.models.components.heads.NodePredictionHead\n", - " input_dim: 128\n", - " output_dim: 1\n", - " hidden_dim: 128\n", - " num_layers: 2\n", - " dropout: 0.0\n", - "\n" - ] - } - ], - "source": [ - "import copy\n", - "import warnings\n", - "\n", - "import anndata as ad\n", - "import hydra\n", - "import rootutils\n", - "import torch\n", - "from omegaconf import OmegaConf\n", - "from torch_geometric.data import Data\n", - "\n", - "rootutils.setup_root(\"..\", indicator=\".project-root\", pythonpath=True)\n", - "\n", - "from src.data.spatial_omics_datamodule import SpatialOmicsDataModule\n", - "from src.models.components.factory import (\n", - " build_attention,\n", - " build_encoder,\n", - " build_graph_head,\n", - " build_loss,\n", - " build_node_head,\n", - " build_ssl,\n", - ")\n", - "\n", - "with hydra.initialize_config_dir(\n", - " config_dir=\"/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/configs\",\n", - " version_base=\"1.3\",\n", - "):\n", - " cfg = hydra.compose(\n", - " config_name=\"train\",\n", - " overrides=[\n", - " \"experiment=notebook_model_components\",\n", - " \"hydra/job_logging=stdout\",\n", - " \"hydra/hydra_logging=none\",\n", - " ],\n", - " )\n", - "\n", - "print(OmegaConf.to_yaml(cfg.model))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Notes\n", - "\n", - "- Keep experiment-specific settings in `configs/experiment/notebook_model_components.yaml`.\n", - "- Change behavior by editing that experiment file, then re-run this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data(\n", - " x=[762, 34],\n", - " edge_index=[2, 4536],\n", - " pos=[762, 2],\n", - " edge_attr=[4536, 2],\n", - " edge_attr_names=[2],\n", - " categorical_index=[762, 1],\n", - " categorical_labels=[1],\n", - " categorical_slices={ cell type=0 },\n", - " sample_id='s1',\n", - " region_id='r1',\n", - " patch_id='s1_r1_patch_0'\n", - ")\n", - "unit nodes=762, unit edges=4536\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/src/data/components/datasets.py:45: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " data = torch.load(entry.path)\n" - ] - } - ], - "source": [ - "dm: SpatialOmicsDataModule = hydra.utils.instantiate(cfg.data)\n", - "dm.prepare_data()\n", - "dm.setup()\n", - "\n", - "unit = dm.train_dataloader().dataset[0]\n", - "print(unit)\n", - "print(f\"unit nodes={unit.num_nodes}, unit edges={unit.num_edges}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "input_dim used=34\n", - "node_emb shape=(762, 128)\n", - "graph_emb shape=(1, 128)\n" - ] - } - ], - "source": [ - "encoder_cfg = hydra.utils.instantiate(cfg.model.encoder)\n", - "encoder_cfg.input_dim = int(unit.x.size(1))\n", - "\n", - "edge_attr = unit.edge_attr if hasattr(unit, \"edge_attr\") else None\n", - "if encoder_cfg.use_edge_attr and edge_attr is not None and encoder_cfg.conv_type == \"gine\":\n", - " encoder_cfg.edge_attr_dim = int(edge_attr.size(1))\n", - "\n", - "encoder = build_encoder(encoder_cfg)\n", - "batch = getattr(unit, \"batch\", None)\n", - "\n", - "node_emb, graph_emb = encoder(\n", - " unit.x,\n", - " unit.edge_index,\n", - " edge_attr=edge_attr,\n", - " batch=batch,\n", - " return_graph_embedding=True,\n", - ")\n", - "\n", - "print(f\"input_dim used={encoder_cfg.input_dim}\")\n", - "print(f\"node_emb shape={tuple(node_emb.shape)}\")\n", - "print(f\"graph_emb shape={tuple(graph_emb.shape)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "graph logits shape: (1, 1)\n", - "node logits shape: (762, 1)\n", - "attention logits shape: (762, 1)\n" - ] - } - ], - "source": [ - "graph_head_cfg = OmegaConf.to_container(cfg.model.graph_head, resolve=True)\n", - "graph_head_cfg.pop(\"_target_\", None)\n", - "node_head_cfg = OmegaConf.to_container(cfg.model.node_head, resolve=True)\n", - "node_head_cfg.pop(\"_target_\", None)\n", - "\n", - "graph_head = build_graph_head(graph_head_cfg)\n", - "node_head = build_node_head(node_head_cfg)\n", - "\n", - "print(\"graph logits shape:\", tuple(graph_head(graph_emb).shape))\n", - "print(\"node logits shape:\", tuple(node_head(node_emb).shape))\n", - "\n", - "attention_cfg = OmegaConf.to_container(cfg.model.attention, resolve=True)\n", - "attention_cfg.pop(\"_target_\", None)\n", - "attention = build_attention(\n", - " use_attention=cfg.model.flags.use_attention,\n", - " attention_type=\"gated_projected\",\n", - " **attention_cfg,\n", - ")\n", - "if attention is not None:\n", - " attn_logits, _ = attention(node_emb)\n", - " print(\"attention logits shape:\", tuple(attn_logits.shape))\n", - "else:\n", - " print(\"attention disabled\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "online_q shape: (762, 128)\n", - "target_y shape: (762, 128)\n" - ] - } - ], - "source": [ - "ssl_cfg = OmegaConf.to_container(cfg.model.ssl, resolve=True)\n", - "if \"predictor\" in ssl_cfg and isinstance(ssl_cfg[\"predictor\"], dict):\n", - " ssl_cfg[\"predictor\"].pop(\"_target_\", None)\n", - "\n", - "ssl_module = build_ssl(\n", - " use_ssl=cfg.model.flags.use_ssl,\n", - " encoder=encoder,\n", - " ssl_config=ssl_cfg,\n", - ")\n", - "\n", - "if ssl_module is None:\n", - " print(\"SSL disabled\")\n", - "else:\n", - " online_q, target_y = ssl_module(\n", - " (unit.x, unit.edge_index, edge_attr),\n", - " (unit.x, unit.edge_index, edge_attr),\n", - " )\n", - " print(\"online_q shape:\", tuple(online_q.shape))\n", - " print(\"target_y shape:\", tuple(target_y.shape))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "categorical_ce: 1.1970868110656738\n", - "regression_mse: 1.8591121435165405\n", - "regression_huber: 0.6854403018951416\n", - "survival_coxsgd: 2.9285335540771484\n" - ] - } - ], - "source": [ - "ce_loss = build_loss(\"categorical_ce\")\n", - "ce_logits = torch.randn(8, 3)\n", - "ce_target = torch.randint(0, 3, (8,))\n", - "print(\"categorical_ce:\", float(ce_loss(ce_logits, ce_target)))\n", - "\n", - "mse_loss = build_loss(\"regression_mse\")\n", - "y_pred = torch.randn(8, 1)\n", - "y_true = torch.randn(8, 1)\n", - "print(\"regression_mse:\", float(mse_loss(y_pred, y_true)))\n", - "\n", - "huber_loss = build_loss(\"regression_huber\", delta=1.0)\n", - "print(\"regression_huber:\", float(huber_loss(y_pred, y_true)))\n", - "\n", - "cox_loss = build_loss(\"survival_coxsgd\", top_n=2, regularizer_weight=0.05)\n", - "length = torch.tensor([5.0, 7.0, 2.0, 9.0, 6.0, 3.0, 8.0, 4.0])\n", - "event = torch.tensor([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0])\n", - "print(\"survival_coxsgd:\", float(cox_loss(torch.randn(8, 1), length, event)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "## Optional quick synthetic check\n", - "\n", - "# If you want to isolate from dataset-specific fields, you can run this in a code cell and then rerun cells 4-7:\n", - "\n", - "x = torch.randn(64, encoder_cfg.input_dim)\n", - "edge_index = torch.randint(0, 64, (2, 256))\n", - "edge_attr_syn = torch.randn(256, encoder_cfg.edge_attr_dim or 1)\n", - "unit = Data(x=x, edge_index=edge_index, edge_attr=edge_attr_syn)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load the same H5AD as data notebook\n", - "\n", - "This reads the exact file used in `data_loading_testing.ipynb` and confirms basic structure before graph modeling." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AnnData object with n_obs × n_vars = 4668 × 34\n", - " obs: 'cell type'\n", - " uns: 'cell type_colors'\n", - " obsm: 'spatial'\n", - "X shape: (4668, 34)\n", - "obs columns: ['cell type']\n", - "obsm['spatial'] shape: (4668, 2)\n" - ] - } - ], - "source": [ - "h5ad_path = \"/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/data/dummy/imc_data.h5ad\"\n", - "adata = ad.read_h5ad(h5ad_path)\n", - "print(adata)\n", - "print(f\"X shape: {adata.X.shape}\")\n", - "print(f\"obs columns: {list(adata.obs.columns)[:8]}\")\n", - "if \"spatial\" in adata.obsm:\n", - " print(f\"obsm['spatial'] shape: {adata.obsm['spatial'].shape}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exhaustive model application matrix\n", - "\n", - "Runs the model stack across:\n", - "- backbones: `gin`, `gcn`, `gat`, `graphsage`, `gine`\n", - "- edge-attribute flag variations (where meaningful)\n", - "- attention: none / gated / gated_projected\n", - "- SSL: off / on\n", - "\n", - "For each scenario it checks output shapes and finite values." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1] OK: {'conv_type': 'gin', 'use_edge_attr': False, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "[2] OK: {'conv_type': 'gin', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated', 'use_ssl': True}\n", - "[3] OK: {'conv_type': 'gcn', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "[4] OK: {'conv_type': 'gat', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated', 'use_ssl': False}\n", - "[5] OK: {'conv_type': 'gat', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "[6] OK: {'conv_type': 'graphsage', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "[7] OK: {'conv_type': 'graphsage', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "[8] OK: {'conv_type': 'gine', 'use_edge_attr': True, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "[9] OK: {'conv_type': 'gine', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': True}\n", - "Completed 9 scenarios.\n" - ] - } - ], - "source": [ - "def _to_plain_cfg(cfg_node):\n", - " plain = OmegaConf.to_container(cfg_node, resolve=True)\n", - " if isinstance(plain, dict):\n", - " plain.pop(\"_target_\", None)\n", - " return plain\n", - "\n", - "\n", - "def run_model_scenario(unit_graph, scenario):\n", - " cfg_local = copy.deepcopy(cfg)\n", - "\n", - " cfg_local.model.encoder.conv_type = scenario[\"conv_type\"]\n", - " cfg_local.model.encoder.use_edge_attr = scenario[\"use_edge_attr\"]\n", - " cfg_local.model.flags.use_attention = scenario[\"use_attention\"]\n", - " cfg_local.model.flags.use_ssl = scenario[\"use_ssl\"]\n", - "\n", - " encoder_cfg = hydra.utils.instantiate(cfg_local.model.encoder)\n", - " encoder_cfg.input_dim = int(unit_graph.x.size(1))\n", - "\n", - " edge_attr_local = unit_graph.edge_attr if hasattr(unit_graph, \"edge_attr\") else None\n", - " if encoder_cfg.conv_type == \"gine\":\n", - " if edge_attr_local is None:\n", - " raise ValueError(\"Scenario requested GINE but unit has no edge_attr\")\n", - " encoder_cfg.edge_attr_dim = int(edge_attr_local.size(1))\n", - "\n", - " with warnings.catch_warnings(record=True) as caught:\n", - " warnings.simplefilter(\"always\")\n", - " encoder_local = build_encoder(encoder_cfg)\n", - "\n", - " node_emb_local, graph_emb_local = encoder_local(\n", - " unit_graph.x,\n", - " unit_graph.edge_index,\n", - " edge_attr=edge_attr_local,\n", - " batch=getattr(unit_graph, \"batch\", None),\n", - " return_graph_embedding=True,\n", - " )\n", - "\n", - " assert torch.isfinite(node_emb_local).all()\n", - " assert torch.isfinite(graph_emb_local).all()\n", - "\n", - " graph_head_cfg_local = _to_plain_cfg(cfg_local.model.graph_head)\n", - " node_head_cfg_local = _to_plain_cfg(cfg_local.model.node_head)\n", - " graph_logits_local = build_graph_head(graph_head_cfg_local)(graph_emb_local)\n", - " node_logits_local = build_node_head(node_head_cfg_local)(node_emb_local)\n", - " assert torch.isfinite(graph_logits_local).all()\n", - " assert torch.isfinite(node_logits_local).all()\n", - "\n", - " attn_shape = None\n", - " if scenario[\"use_attention\"]:\n", - " attention_cfg_local = _to_plain_cfg(cfg_local.model.attention)\n", - " if scenario[\"attention_type\"] == \"gated\":\n", - " attention_cfg_local.pop(\"projection_dim\", None)\n", - " attn = build_attention(\n", - " use_attention=True,\n", - " attention_type=scenario[\"attention_type\"],\n", - " **attention_cfg_local,\n", - " )\n", - " attn_logits_local, _ = attn(node_emb_local)\n", - " attn_shape = tuple(attn_logits_local.shape)\n", - " assert torch.isfinite(attn_logits_local).all()\n", - "\n", - " ssl_shape = None\n", - " if scenario[\"use_ssl\"]:\n", - " ssl_cfg_local = _to_plain_cfg(cfg_local.model.ssl)\n", - " predictor_cfg_local = ssl_cfg_local.get(\"predictor\", {})\n", - " if isinstance(predictor_cfg_local, dict):\n", - " predictor_cfg_local.pop(\"_target_\", None)\n", - " ssl_model_local = build_ssl(\n", - " use_ssl=True,\n", - " encoder=encoder_local,\n", - " ssl_config=ssl_cfg_local,\n", - " )\n", - " q_local, y_local = ssl_model_local(\n", - " (unit_graph.x, unit_graph.edge_index, edge_attr_local),\n", - " (unit_graph.x, unit_graph.edge_index, edge_attr_local),\n", - " )\n", - " ssl_shape = (tuple(q_local.shape), tuple(y_local.shape))\n", - " assert torch.isfinite(q_local).all()\n", - " assert torch.isfinite(y_local).all()\n", - "\n", - " return {\n", - " \"scenario\": scenario,\n", - " \"node_emb\": tuple(node_emb_local.shape),\n", - " \"graph_emb\": tuple(graph_emb_local.shape),\n", - " \"graph_logits\": tuple(graph_logits_local.shape),\n", - " \"node_logits\": tuple(node_logits_local.shape),\n", - " \"attention_logits\": attn_shape,\n", - " \"ssl_shapes\": ssl_shape,\n", - " \"warnings\": [str(w.message) for w in caught],\n", - " }\n", - "\n", - "\n", - "scenarios = [\n", - " {\n", - " \"conv_type\": \"gin\",\n", - " \"use_edge_attr\": False,\n", - " \"use_attention\": False,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"gin\",\n", - " \"use_edge_attr\": False,\n", - " \"use_attention\": True,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": True,\n", - " },\n", - " {\n", - " \"conv_type\": \"gcn\",\n", - " \"use_edge_attr\": False,\n", - " \"use_attention\": True,\n", - " \"attention_type\": \"gated_projected\",\n", - " \"use_ssl\": False,\n", - " },\n", - " # {\n", - " # \"conv_type\": \"gcn\",\n", - " # \"use_edge_attr\": True,\n", - " # \"use_attention\": False,\n", - " # \"attention_type\": \"gated\",\n", - " # \"use_ssl\": False,\n", - " # },\n", - " {\n", - " \"conv_type\": \"gat\",\n", - " \"use_edge_attr\": False,\n", - " \"use_attention\": True,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"gat\",\n", - " \"use_edge_attr\": True,\n", - " \"use_attention\": False,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"graphsage\",\n", - " \"use_edge_attr\": False,\n", - " \"use_attention\": True,\n", - " \"attention_type\": \"gated_projected\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"graphsage\",\n", - " \"use_edge_attr\": True,\n", - " \"use_attention\": False,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"gine\",\n", - " \"use_edge_attr\": True,\n", - " \"use_attention\": True,\n", - " \"attention_type\": \"gated_projected\",\n", - " \"use_ssl\": False,\n", - " },\n", - " {\n", - " \"conv_type\": \"gine\",\n", - " \"use_edge_attr\": True,\n", - " \"use_attention\": False,\n", - " \"attention_type\": \"gated\",\n", - " \"use_ssl\": True,\n", - " },\n", - "]\n", - "\n", - "results = []\n", - "for idx, scenario in enumerate(scenarios, start=1):\n", - " try:\n", - " result = run_model_scenario(unit, scenario)\n", - " results.append(result)\n", - " print(f\"[{idx}] OK: {scenario}\")\n", - " except Exception as exc:\n", - " print(f\"[{idx}] FAILED: {scenario}\")\n", - " raise\n", - "\n", - "print(f\"Completed {len(results)} scenarios.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------------------------------------------------------------\n", - "Scenario 1: {'conv_type': 'gin', 'use_edge_attr': False, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=None, ssl_shapes=None\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 2: {'conv_type': 'gin', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated', 'use_ssl': True}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=(64, 1), ssl_shapes=((64, 128), (64, 128))\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 3: {'conv_type': 'gcn', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=(64, 1), ssl_shapes=None\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 4: {'conv_type': 'gat', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=(64, 1), ssl_shapes=None\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 5: {'conv_type': 'gat', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=None, ssl_shapes=None\n", - "warnings:\n", - " - use_edge_attr=True is ignored for conv_type='gat'. Choose 'gcn' (scalar edge_weight) or 'gine' (edge_attr) for edge-aware message passing.\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 6: {'conv_type': 'graphsage', 'use_edge_attr': False, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=(64, 1), ssl_shapes=None\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 7: {'conv_type': 'graphsage', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=None, ssl_shapes=None\n", - "warnings:\n", - " - use_edge_attr=True is ignored for conv_type='graphsage'. Choose 'gcn' (scalar edge_weight) or 'gine' (edge_attr) for edge-aware message passing.\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 8: {'conv_type': 'gine', 'use_edge_attr': True, 'use_attention': True, 'attention_type': 'gated_projected', 'use_ssl': False}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=(64, 1), ssl_shapes=None\n", - "----------------------------------------------------------------------------------------------------\n", - "Scenario 9: {'conv_type': 'gine', 'use_edge_attr': True, 'use_attention': False, 'attention_type': 'gated', 'use_ssl': True}\n", - "node_emb=(64, 128), graph_emb=(1, 128)\n", - "node_logits=(64, 1), graph_logits=(1, 1)\n", - "attention_logits=None, ssl_shapes=((64, 128), (64, 128))\n" - ] - } - ], - "source": [ - "for i, item in enumerate(results, start=1):\n", - " print(\"-\" * 100)\n", - " print(f\"Scenario {i}: {item['scenario']}\")\n", - " print(f\"node_emb={item['node_emb']}, graph_emb={item['graph_emb']}\")\n", - " print(f\"node_logits={item['node_logits']}, graph_logits={item['graph_logits']}\")\n", - " print(f\"attention_logits={item['attention_logits']}, ssl_shapes={item['ssl_shapes']}\")\n", - " if item[\"warnings\"]:\n", - " print(\"warnings:\")\n", - " for w in item[\"warnings\"]:\n", - " print(f\" - {w}\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "spatial", - "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.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/training_logic_testing.ipynb b/notebooks/training_logic_testing.ipynb deleted file mode 100644 index 620a2cb..0000000 --- a/notebooks/training_logic_testing.ipynb +++ /dev/null @@ -1,541 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "41a97e9b", - "metadata": {}, - "source": [ - "# Training Logic Testing\n", - "\n", - "Interactive smoke tests for all current training regimes on the same real dummy `adata` source used by the other notebooks.\n", - "\n", - "This notebook is for quick behavior checks (few batches), not benchmark training." - ] - }, - { - "cell_type": "markdown", - "id": "0fc92afa", - "metadata": {}, - "source": [ - "## Notes\n", - "\n", - "- Uses `experiment=notebook_training_logic` to pin `data/dummy/manifest.csv` and `data/dummy/processed`.\n", - "- Runs each regime as a smoke test on CPU with small batch limits.\n", - "- You can increase training depth by overriding trainer limits in the scenario calls." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "36cdfa6f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Project root: /Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil\n", - "Config dir: /Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/configs\n" - ] - } - ], - "source": [ - "from __future__ import annotations\n", - "\n", - "from pathlib import Path\n", - "from typing import Any\n", - "\n", - "import hydra\n", - "import pandas as pd\n", - "import rootutils\n", - "import torch\n", - "from hydra.core.global_hydra import GlobalHydra\n", - "from hydra.core.hydra_config import HydraConfig\n", - "from omegaconf import DictConfig, OmegaConf, open_dict\n", - "\n", - "rootutils.setup_root(\"..\", indicator=\".project-root\", pythonpath=True)\n", - "\n", - "from src.train import train\n", - "\n", - "ROOT = Path(rootutils.find_root(indicator=\".project-root\"))\n", - "CONFIG_DIR = ROOT / \"configs\"\n", - "print(f\"Project root: {ROOT}\")\n", - "print(f\"Config dir: {CONFIG_DIR}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2a1678df", - "metadata": {}, - "outputs": [], - "source": [ - "def _to_float(value: Any) -> float | None:\n", - " \"\"\"Convert metric values (tensor/scalar) to Python floats when possible.\"\"\"\n", - " if value is None:\n", - " return None\n", - " if isinstance(value, torch.Tensor):\n", - " if value.numel() == 0:\n", - " return None\n", - " return float(value.detach().cpu().flatten()[0].item())\n", - " try:\n", - " return float(value)\n", - " except (TypeError, ValueError):\n", - " return None\n", - "\n", - "\n", - "def run_training_scenario(\n", - " name: str,\n", - " task: str,\n", - " model: str,\n", - " extra_overrides: list[str] | None = None,\n", - " print_cfg: bool = False,\n", - ") -> dict[str, Any]:\n", - " \"\"\"Compose Hydra config and run a short train+test cycle.\"\"\"\n", - " base_overrides = [\n", - " \"experiment=notebook_training_logic\",\n", - " \"hydra/job_logging=stdout\",\n", - " \"hydra/hydra_logging=none\",\n", - " \"callbacks=none\",\n", - " \"logger=null\",\n", - " f\"model={model}\",\n", - " \"trainer.accelerator=cpu\",\n", - " \"trainer.devices=1\",\n", - " \"trainer.max_epochs=1\",\n", - " \"trainer.limit_train_batches=2\",\n", - " \"trainer.limit_val_batches=1\",\n", - " \"trainer.limit_test_batches=1\",\n", - " \"trainer.log_every_n_steps=1\",\n", - " ]\n", - "\n", - " # BGRL task config includes a defaults-based scheduler override; some notebook\n", - " # compose flows can fail resolving that override. In that case, inject task and\n", - " # scheduler nodes explicitly after compose.\n", - " if task != \"pretrain_bgrl\":\n", - " base_overrides.append(f\"task={task}\")\n", - "\n", - " if extra_overrides:\n", - " base_overrides.extend(extra_overrides)\n", - "\n", - " GlobalHydra.instance().clear()\n", - " with hydra.initialize_config_dir(config_dir=str(CONFIG_DIR), version_base=\"1.3\"):\n", - " cfg: DictConfig = hydra.compose(\n", - " config_name=\"train\",\n", - " overrides=base_overrides,\n", - " return_hydra_config=True,\n", - " )\n", - "\n", - " if task == \"pretrain_bgrl\":\n", - " pretrain_task_cfg = OmegaConf.load(CONFIG_DIR / \"task\" / \"pretrain_bgrl.yaml\")\n", - " step_sched_cfg = OmegaConf.load(CONFIG_DIR / \"scheduler\" / \"cosine_step.yaml\")\n", - " with open_dict(cfg):\n", - " cfg.task = pretrain_task_cfg.task\n", - " cfg.scheduler = step_sched_cfg\n", - "\n", - " if print_cfg:\n", - " print(OmegaConf.to_yaml(cfg))\n", - "\n", - " with open_dict(cfg):\n", - " cfg.paths.root_dir = str(ROOT)\n", - " cfg.extras.print_config = False\n", - " # Keep optimizer/scheduler/task as config nodes for LightningModule init.\n", - " cfg.model._recursive_ = False\n", - "\n", - " HydraConfig().set_config(cfg)\n", - " metric_dict, _ = train(cfg)\n", - "\n", - " summary = {\n", - " \"scenario\": name,\n", - " \"task\": task,\n", - " \"model\": model,\n", - " \"train/loss\": _to_float(metric_dict.get(\"train/loss\")),\n", - " \"val/loss\": _to_float(metric_dict.get(\"val/loss\")),\n", - " \"test/loss\": _to_float(metric_dict.get(\"test/loss\")),\n", - " \"train/acc\": _to_float(metric_dict.get(\"train/acc\")),\n", - " \"val/acc\": _to_float(metric_dict.get(\"val/acc\")),\n", - " \"test/acc\": _to_float(metric_dict.get(\"test/acc\")),\n", - " }\n", - " print(\n", - " f\"[{name}] train/loss={summary['train/loss']} val/loss={summary['val/loss']} test/loss={summary['test/loss']}\"\n", - " )\n", - " return summary" - ] - }, - { - "cell_type": "markdown", - "id": "ce22b139", - "metadata": {}, - "source": [ - "## Data And Config Sanity Check\n", - "\n", - "This confirms the notebook uses the same dummy manifest/adata pipeline as the other notebooks." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "22a27876", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Manifest: /Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/data//dummy/manifest.csv\n", - "Processed: /Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/data//dummy/processed\n", - "Adata expected via manifest: /Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/data/dummy/imc_data.h5ad\n", - "name: finetune_mean\n", - "aggregation: mean\n", - "bag_key: region_id\n", - "bag_fallback_key: sample_id\n", - "max_instances_per_bag: 0\n", - "instance_sampling: all\n", - "target_type: binary\n", - "target_columns: null\n", - "loss: categorical_bce\n", - "\n" - ] - } - ], - "source": [ - "GlobalHydra.instance().clear()\n", - "with hydra.initialize_config_dir(config_dir=str(CONFIG_DIR), version_base=\"1.3\"):\n", - " cfg_preview = hydra.compose(\n", - " config_name=\"train\",\n", - " overrides=[\n", - " \"experiment=notebook_training_logic\",\n", - " \"task=finetune_mean\",\n", - " \"model=supervised_module\",\n", - " \"hydra/job_logging=stdout\",\n", - " \"hydra/hydra_logging=none\",\n", - " ],\n", - " return_hydra_config=True,\n", - " )\n", - "\n", - "print(\"Manifest:\", cfg_preview.data.raw_manifest_path)\n", - "print(\"Processed:\", cfg_preview.data.processed_dir)\n", - "print(\"Adata expected via manifest:\", ROOT / \"data\" / \"dummy\" / \"imc_data.h5ad\")\n", - "print(OmegaConf.to_yaml(cfg_preview.task))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "657e38cc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train dataset size: 9\n", - "Example x shape: (762, 34)\n", - "Example edge_index shape: (2, 4536)\n", - "Example region_id: r1\n", - "Example sample_id: s1\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/lovrorabuzin/Projects/grass-mil_unification/grass-mil/src/data/components/datasets.py:45: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " data = torch.load(entry.path)\n" - ] - } - ], - "source": [ - "dm = hydra.utils.instantiate(cfg_preview.data)\n", - "dm.prepare_data()\n", - "dm.setup()\n", - "train_ds = dm.train_dataloader().dataset\n", - "example = train_ds[0]\n", - "\n", - "print(\"Train dataset size:\", len(train_ds))\n", - "print(\"Example x shape:\", tuple(example.x.shape))\n", - "print(\"Example edge_index shape:\", tuple(example.edge_index.shape))\n", - "if hasattr(example, \"region_id\"):\n", - " print(\"Example region_id:\", example.region_id)\n", - "if hasattr(example, \"sample_id\"):\n", - " print(\"Example sample_id:\", example.sample_id)" - ] - }, - { - "cell_type": "markdown", - "id": "bc4c7e9a", - "metadata": {}, - "source": [ - "## Run Training Regimes (Smoke)\n", - "\n", - "Each cell runs one scenario and appends to `RESULTS`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ddad2bc5", - "metadata": {}, - "outputs": [], - "source": [ - "RESULTS: list[dict[str, Any]] = []" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "581b92dc", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Config group override must be a string or a list. Got NoneType", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# 1) BGRL pretraining\u001b[39;00m\n\u001b[1;32m 2\u001b[0m RESULTS\u001b[38;5;241m.\u001b[39mappend(\n\u001b[0;32m----> 3\u001b[0m \u001b[43mrun_training_scenario\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mbgrl_pretrain\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mtask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpretrain_bgrl\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mbgrl_module\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 8\u001b[0m )\n", - "Cell \u001b[0;32mIn[2], line 50\u001b[0m, in \u001b[0;36mrun_training_scenario\u001b[0;34m(name, task, model, extra_overrides, print_cfg)\u001b[0m\n\u001b[1;32m 48\u001b[0m GlobalHydra\u001b[38;5;241m.\u001b[39minstance()\u001b[38;5;241m.\u001b[39mclear()\n\u001b[1;32m 49\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m hydra\u001b[38;5;241m.\u001b[39minitialize_config_dir(config_dir\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mstr\u001b[39m(CONFIG_DIR), version_base\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1.3\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m---> 50\u001b[0m cfg: DictConfig \u001b[38;5;241m=\u001b[39m \u001b[43mhydra\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompose\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 51\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtrain\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 52\u001b[0m \u001b[43m \u001b[49m\u001b[43moverrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbase_overrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 53\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_hydra_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m task \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpretrain_bgrl\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 57\u001b[0m pretrain_task_cfg \u001b[38;5;241m=\u001b[39m OmegaConf\u001b[38;5;241m.\u001b[39mload(CONFIG_DIR \u001b[38;5;241m/\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtask\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m/\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpretrain_bgrl.yaml\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/compose.py:38\u001b[0m, in \u001b[0;36mcompose\u001b[0;34m(config_name, overrides, return_hydra_config, strict)\u001b[0m\n\u001b[1;32m 36\u001b[0m gh \u001b[38;5;241m=\u001b[39m GlobalHydra\u001b[38;5;241m.\u001b[39minstance()\n\u001b[1;32m 37\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m gh\u001b[38;5;241m.\u001b[39mhydra \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m---> 38\u001b[0m cfg \u001b[38;5;241m=\u001b[39m \u001b[43mgh\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhydra\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompose_config\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 39\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 40\u001b[0m \u001b[43m \u001b[49m\u001b[43moverrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 41\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mRunMode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mRUN\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 42\u001b[0m \u001b[43m \u001b[49m\u001b[43mfrom_shell\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 43\u001b[0m \u001b[43m \u001b[49m\u001b[43mwith_log_configuration\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(cfg, DictConfig)\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_hydra_config:\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/_internal/hydra.py:594\u001b[0m, in \u001b[0;36mHydra.compose_config\u001b[0;34m(self, config_name, overrides, run_mode, with_log_configuration, from_shell, validate_sweep_overrides)\u001b[0m\n\u001b[1;32m 576\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompose_config\u001b[39m(\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 578\u001b[0m config_name: Optional[\u001b[38;5;28mstr\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 583\u001b[0m validate_sweep_overrides: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 584\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m DictConfig:\n\u001b[1;32m 585\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 586\u001b[0m \u001b[38;5;124;03m :param config_name:\u001b[39;00m\n\u001b[1;32m 587\u001b[0m \u001b[38;5;124;03m :param overrides:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 591\u001b[0m \u001b[38;5;124;03m :return:\u001b[39;00m\n\u001b[1;32m 592\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 594\u001b[0m cfg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconfig_loader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_configuration\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 595\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 596\u001b[0m \u001b[43m \u001b[49m\u001b[43moverrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 597\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_mode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 598\u001b[0m \u001b[43m \u001b[49m\u001b[43mfrom_shell\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfrom_shell\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 599\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidate_sweep_overrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_sweep_overrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 600\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m with_log_configuration:\n\u001b[1;32m 602\u001b[0m configure_log(cfg\u001b[38;5;241m.\u001b[39mhydra\u001b[38;5;241m.\u001b[39mhydra_logging, cfg\u001b[38;5;241m.\u001b[39mhydra\u001b[38;5;241m.\u001b[39mverbose)\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/_internal/config_loader_impl.py:142\u001b[0m, in \u001b[0;36mConfigLoaderImpl.load_configuration\u001b[0;34m(self, config_name, overrides, run_mode, from_shell, validate_sweep_overrides)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mload_configuration\u001b[39m(\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 135\u001b[0m config_name: Optional[\u001b[38;5;28mstr\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 139\u001b[0m validate_sweep_overrides: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 140\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m DictConfig:\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 142\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_load_configuration_impl\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 143\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 144\u001b[0m \u001b[43m \u001b[49m\u001b[43moverrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 145\u001b[0m \u001b[43m \u001b[49m\u001b[43mrun_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_mode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 146\u001b[0m \u001b[43m \u001b[49m\u001b[43mfrom_shell\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfrom_shell\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidate_sweep_overrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_sweep_overrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 148\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m OmegaConfBaseException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 150\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ConfigCompositionException()\u001b[38;5;241m.\u001b[39mwith_traceback(sys\u001b[38;5;241m.\u001b[39mexc_info()[\u001b[38;5;241m2\u001b[39m]) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/_internal/config_loader_impl.py:253\u001b[0m, in \u001b[0;36mConfigLoaderImpl._load_configuration_impl\u001b[0;34m(self, config_name, overrides, run_mode, from_shell, validate_sweep_overrides)\u001b[0m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m validate_sweep_overrides:\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvalidate_sweep_overrides_legal(\n\u001b[1;32m 250\u001b[0m overrides\u001b[38;5;241m=\u001b[39mparsed_overrides, run_mode\u001b[38;5;241m=\u001b[39mrun_mode, from_shell\u001b[38;5;241m=\u001b[39mfrom_shell\n\u001b[1;32m 251\u001b[0m )\n\u001b[0;32m--> 253\u001b[0m defaults_list \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_defaults_list\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[43mrepo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcaching_repo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[43m \u001b[49m\u001b[43moverrides_list\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparsed_overrides\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[43m \u001b[49m\u001b[43mprepend_hydra\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 258\u001b[0m \u001b[43m \u001b[49m\u001b[43mskip_missing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_mode\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mRunMode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mMULTIRUN\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 259\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 261\u001b[0m config_overrides \u001b[38;5;241m=\u001b[39m defaults_list\u001b[38;5;241m.\u001b[39mconfig_overrides\n\u001b[1;32m 263\u001b[0m cfg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compose_config_from_defaults_list(\n\u001b[1;32m 264\u001b[0m defaults\u001b[38;5;241m=\u001b[39mdefaults_list\u001b[38;5;241m.\u001b[39mdefaults, repo\u001b[38;5;241m=\u001b[39mcaching_repo\n\u001b[1;32m 265\u001b[0m )\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/_internal/defaults_list.py:744\u001b[0m, in \u001b[0;36mcreate_defaults_list\u001b[0;34m(repo, config_name, overrides_list, prepend_hydra, skip_missing)\u001b[0m\n\u001b[1;32m 729\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_defaults_list\u001b[39m(\n\u001b[1;32m 730\u001b[0m repo: IConfigRepository,\n\u001b[1;32m 731\u001b[0m config_name: Optional[\u001b[38;5;28mstr\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 734\u001b[0m skip_missing: \u001b[38;5;28mbool\u001b[39m,\n\u001b[1;32m 735\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m DefaultsList:\n\u001b[1;32m 736\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 737\u001b[0m \u001b[38;5;124;03m :param repo:\u001b[39;00m\n\u001b[1;32m 738\u001b[0m \u001b[38;5;124;03m :param config_name:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 742\u001b[0m \u001b[38;5;124;03m :return:\u001b[39;00m\n\u001b[1;32m 743\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 744\u001b[0m overrides \u001b[38;5;241m=\u001b[39m \u001b[43mOverrides\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrepo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moverrides_list\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverrides_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 745\u001b[0m defaults, tree \u001b[38;5;241m=\u001b[39m _create_defaults_list(\n\u001b[1;32m 746\u001b[0m repo,\n\u001b[1;32m 747\u001b[0m config_name,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 750\u001b[0m skip_missing\u001b[38;5;241m=\u001b[39mskip_missing,\n\u001b[1;32m 751\u001b[0m )\n\u001b[1;32m 752\u001b[0m overrides\u001b[38;5;241m.\u001b[39mensure_overrides_used()\n", - "File \u001b[0;32m/opt/anaconda3/envs/spatial/lib/python3.12/site-packages/hydra/_internal/defaults_list.py:95\u001b[0m, in \u001b[0;36mOverrides.__init__\u001b[0;34m(self, repo, overrides_list)\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdeletions[key] \u001b[38;5;241m=\u001b[39m Deletion(name\u001b[38;5;241m=\u001b[39mvalue)\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, (\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mlist\u001b[39m)):\n\u001b[0;32m---> 95\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 96\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConfig group override must be a string or a list. Got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(value)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 97\u001b[0m )\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m override\u001b[38;5;241m.\u001b[39mis_add():\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mappend_group_defaults\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m 100\u001b[0m GroupDefault(\n\u001b[1;32m 101\u001b[0m group\u001b[38;5;241m=\u001b[39moverride\u001b[38;5;241m.\u001b[39mkey_or_group,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 105\u001b[0m )\n\u001b[1;32m 106\u001b[0m )\n", - "\u001b[0;31mValueError\u001b[0m: Config group override must be a string or a list. Got NoneType" - ] - } - ], - "source": [ - "# 1) BGRL pretraining\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"bgrl_pretrain\",\n", - " task=\"pretrain_bgrl\",\n", - " model=\"bgrl_module\",\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b340a149", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'RESULTS' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# 2) Supervised mean\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mRESULTS\u001b[49m\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m 3\u001b[0m run_training_scenario(\n\u001b[1;32m 4\u001b[0m name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msupervised_mean_default\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 5\u001b[0m task\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfinetune_mean\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 6\u001b[0m model\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msupervised_mean_module\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m )\n", - "\u001b[0;31mNameError\u001b[0m: name 'RESULTS' is not defined" - ] - } - ], - "source": [ - "# 2) Supervised mean\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mean_default\",\n", - " task=\"finetune_mean\",\n", - " model=\"supervised_module\",\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "302aafca", - "metadata": {}, - "outputs": [], - "source": [ - "# 3) Supervised MIL default\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mil_default\",\n", - " task=\"finetune_mil\",\n", - " model=\"supervised_module\",\n", - " )\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "da9336e4", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "00f012d7", - "metadata": {}, - "outputs": [], - "source": [ - "# 4) MIL with region accumulation (hyperbatch threshold)\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mil_region_accum\",\n", - " task=\"finetune_mil\",\n", - " model=\"supervised_module\",\n", - " extra_overrides=[\n", - " \"task.region_accumulation.enabled=true\",\n", - " \"task.region_accumulation.hyperbatch_size=2\",\n", - " \"task.region_accumulation.flush_on_epoch_end=true\",\n", - " ],\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3d3db263", - "metadata": {}, - "outputs": [], - "source": [ - "# 5) MIL with node auxiliary loss (graph_label targets)\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mil_node_aux_graph_label\",\n", - " task=\"finetune_mil\",\n", - " model=\"supervised_module\",\n", - " extra_overrides=[\n", - " \"task.node_aux.enabled=true\",\n", - " \"task.node_aux.target_mode=graph_label\",\n", - " \"task.node_aux.loss_mode=bce\",\n", - " \"task.node_aux.weight=0.2\",\n", - " ],\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50146d48", - "metadata": {}, - "outputs": [], - "source": [ - "# 6) MIL with node auxiliary loss (attention_shaped_ti targets)\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mil_node_aux_attention_shaped_ti\",\n", - " task=\"finetune_mil\",\n", - " model=\"supervised_module\",\n", - " extra_overrides=[\n", - " \"task.node_aux.enabled=true\",\n", - " \"task.node_aux.target_mode=attention_shaped_ti\",\n", - " \"task.node_aux.loss_mode=bce\",\n", - " \"task.node_aux.weight=0.2\",\n", - " ],\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8c3f8b46", - "metadata": {}, - "outputs": [], - "source": [ - "# 7) MIL with entropy regularization\n", - "RESULTS.append(\n", - " run_training_scenario(\n", - " name=\"supervised_mil_entropy_reg\",\n", - " task=\"finetune_mil\",\n", - " model=\"supervised_module\",\n", - " extra_overrides=[\n", - " \"task.entropy_reg.enabled=true\",\n", - " \"task.entropy_reg.mode=attention\",\n", - " \"task.entropy_reg.weight=0.01\",\n", - " ],\n", - " )\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "5d1b19bb", - "metadata": {}, - "source": [ - "## Summary And Validation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "90bb0d90", - "metadata": {}, - "outputs": [], - "source": [ - "summary_df = pd.DataFrame(RESULTS)\n", - "summary_df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fe9ad807", - "metadata": {}, - "outputs": [], - "source": [ - "loss_keys = [\"train/loss\", \"val/loss\", \"test/loss\"]\n", - "\n", - "for row in RESULTS:\n", - " scenario = row[\"scenario\"]\n", - " train_loss = row.get(\"train/loss\")\n", - " if train_loss is None:\n", - " raise AssertionError(f\"{scenario}: missing train/loss\")\n", - " if not torch.isfinite(torch.tensor(train_loss)):\n", - " raise AssertionError(f\"{scenario}: non-finite train/loss={train_loss}\")\n", - "\n", - " for key in loss_keys[1:]:\n", - " value = row.get(key)\n", - " if value is None:\n", - " continue\n", - " if not torch.isfinite(torch.tensor(value)):\n", - " raise AssertionError(f\"{scenario}: non-finite {key}={value}\")\n", - "\n", - "print(\"All available losses are finite (train/loss required).\")" - ] - }, - { - "cell_type": "markdown", - "id": "dbd79336", - "metadata": {}, - "source": [ - "## Optional: Extend Scenarios\n", - "\n", - "- Increase depth by passing extra overrides like `trainer.max_epochs=3` or larger `trainer.limit_train_batches`.\n", - "- Toggle MIL options in combinations by reusing `run_training_scenario(..., extra_overrides=[...])`.\n", - "- Set `print_cfg=True` in `run_training_scenario` to inspect the fully composed config for a scenario." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "spatial", - "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.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/grass_mil/configs/experiment/notebook_data_shadow_custom.yaml b/src/grass_mil/configs/experiment/notebook_data_shadow_custom.yaml deleted file mode 100644 index 9f0ccac..0000000 --- a/src/grass_mil/configs/experiment/notebook_data_shadow_custom.yaml +++ /dev/null @@ -1,35 +0,0 @@ -# @package _global_ - -defaults: - - override /data: spatial_omics - - override /model: null - - override /trainer: default - -data: - raw_manifest_path: ${paths.data_dir}/dummy/manifest.csv - processed_dir: ${paths.data_dir}/dummy/processed - coord_scale_um: 1.0 - sample_unit: tile - use_molecular_features: true - tiling: - tile_size_um: 300.0 - stride_um: 300.0 - categorical_features: - include_labels: ["cell type"] - h5ad: - coord_source: obsm - coord_key: spatial - categorical_label_columns: ["cell type"] - split: - train_val_test_split: [1.0, 0.0, 0.0] - split_by: sample - sampler: - name: shadow_custom - kwargs: {} - runtime: - enabled: true - depth: 2 - num_neighbors: 8 - subgraph_batch_size: 8 - replace: false - shuffle_subgraphs: true diff --git a/src/grass_mil/configs/experiment/notebook_model_components.yaml b/src/grass_mil/configs/experiment/notebook_model_components.yaml deleted file mode 100644 index f99a40f..0000000 --- a/src/grass_mil/configs/experiment/notebook_model_components.yaml +++ /dev/null @@ -1,37 +0,0 @@ -# @package _global_ - -defaults: - - override /data: spatial_omics - - override /model: components - - override /trainer: default - -data: - raw_manifest_path: ${paths.data_dir}/dummy/manifest.csv - processed_dir: ${paths.data_dir}/dummy/processed - coord_scale_um: 1.0 - sample_unit: tile - use_molecular_features: true - tiling: - tile_size_um: 300.0 - stride_um: 300.0 - categorical_features: - include_labels: ["cell type"] - h5ad: - coord_source: obsm - coord_key: spatial - categorical_label_columns: ["cell type"] - split: - train_val_test_split: [1.0, 0.0, 0.0] - split_by: sample - -model: - flags: - use_attention: true - use_ssl: true - encoder: - conv_type: gine - use_edge_attr: true - edge_attr_dim: 2 - ssl: - predictor: - hidden_size: 256 diff --git a/src/grass_mil/configs/experiment/notebook_training_logic.yaml b/src/grass_mil/configs/experiment/notebook_training_logic.yaml deleted file mode 100644 index 8f1cd96..0000000 --- a/src/grass_mil/configs/experiment/notebook_training_logic.yaml +++ /dev/null @@ -1,44 +0,0 @@ -# @package _global_ - -defaults: - - override /data: spatial_omics - - override /model: null - - override /trainer: default - -data: - raw_manifest_path: ${paths.data_dir}/dummy/manifest.csv - processed_dir: ${paths.data_dir}/dummy/processed - coord_scale_um: 1.0 - sample_unit: tile - use_molecular_features: true - tiling: - tile_size_um: 300.0 - stride_um: 300.0 - categorical_features: - include_labels: ["cell type"] - h5ad: - coord_source: obsm - coord_key: spatial - categorical_label_columns: ["cell type"] - split: - train_val_test_split: [1.0, 0.0, 0.0] - split_by: sample - sampler: - name: shadow_custom - kwargs: {} - runtime: - enabled: true - depth: 2 - num_neighbors: 8 - subgraph_batch_size: 8 - replace: false - shuffle_subgraphs: true - -trainer: - accelerator: cpu - devices: 1 - max_epochs: 1 - limit_train_batches: 2 - limit_val_batches: 1 - limit_test_batches: 1 - log_every_n_steps: 1 diff --git a/src/grass_mil/data/spatial_omics_datamodule.py b/src/grass_mil/data/spatial_omics_datamodule.py index ad21cdf..d1551c0 100644 --- a/src/grass_mil/data/spatial_omics_datamodule.py +++ b/src/grass_mil/data/spatial_omics_datamodule.py @@ -228,6 +228,17 @@ def test_dataloader(self) -> Any: shuffle=False, ) + def predict_dataloader(self) -> Any: + """Inference loader, over the test split. + + Required by `grass-mil-predict`: `Trainer.predict` raises + `MisconfigurationException` without it. Predicting on the held-out split + mirrors `test_dataloader` so exported tables line up with test metrics. + To score a different set of graphs, point `data.processed_dir` at a + precompute whose entries carry the split you want. + """ + return self.test_dataloader() + def _subset_dataset_from_entries( dataset: SpatialOmicsGraphDataset, diff --git a/vignettes/01_anndata_to_spatial_graphs.ipynb b/vignettes/01_anndata_to_spatial_graphs.ipynb new file mode 100644 index 0000000..693098d --- /dev/null +++ b/vignettes/01_anndata_to_spatial_graphs.ipynb @@ -0,0 +1,337 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fb27b941602401d91542211134fc71a", + "metadata": {}, + "source": [ + "# 1 - From AnnData to spatial graphs\n", + "\n", + "This vignette takes a public spatial-proteomics dataset from `squidpy`,\n", + "converts it into the inputs `grass-mil` expects, and builds the cellular\n", + "graphs the models train on.\n", + "\n", + "**Dataset.** `squidpy.datasets.mibitof()` -- MIBI-TOF imaging of colorectal\n", + "carcinoma: 3 images, ~3,300 cells, 36 protein markers, 8 annotated cell types\n", + "(Hartmann et al.). It is a good fit because `grass-mil` is built for\n", + "cell-resolved spatial proteomics: every cell has coordinates, a type, and a\n", + "marker profile.\n", + "\n", + "**What you need to supply.** `grass-mil` reads a *manifest* -- one row per\n", + "image -- pointing at per-sample files. Everything else is config.\n" + ] + }, + { + "cell_type": "markdown", + "id": "acae54e37e7d407bbb7b55eff062a284", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "The vignettes need the `io` and `interpretability` extras, plus `squidpy` to\n", + "fetch the data. `squidpy` is only used here to download a public dataset; it\n", + "is not a runtime dependency of `grass-mil`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a63283cbaf04dbcab1f6479b197f3a8", + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install 'grass-mil[interpretability,io]' squidpy\n", + "\n", + "import pathlib\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import squidpy as sq\n", + "\n", + "WORK = pathlib.Path(\"vignette_work\").resolve()\n", + "RAW = WORK / \"data\" / \"raw\"\n", + "PROCESSED = WORK / \"data\" / \"processed\"\n", + "RAW.mkdir(parents=True, exist_ok=True)\n", + "print(\"working directory:\", WORK)" + ] + }, + { + "cell_type": "markdown", + "id": "8dd0d8092fe74a7c96281538738b07e2", + "metadata": {}, + "source": [ + "## Load the public dataset\n", + "\n", + "`squidpy` caches the download, so re-running is cheap.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72eea5119410473aa328ad9291626812", + "metadata": {}, + "outputs": [], + "source": [ + "adata = sq.datasets.mibitof()\n", + "print(adata)\n", + "print()\n", + "print(\"images :\", sorted(adata.obs[\"library_id\"].unique()))\n", + "print(\"donors :\", sorted(adata.obs[\"donor\"].unique()))\n", + "print(\"types :\", sorted(adata.obs[\"Cluster\"].unique()))" + ] + }, + { + "cell_type": "markdown", + "id": "8edb47106e1a46a883d545849b8ab81b", + "metadata": {}, + "source": [ + "## Reshape into the grass-mil input contract\n", + "\n", + "Two conventions matter:\n", + "\n", + "1. **One file per sample.** The manifest maps `sample_id` to a file, so we\n", + " split the combined AnnData by `library_id`.\n", + "2. **Name the cell-type column `cell_type`.** Several defaults key off this\n", + " name -- the sampler's `property_name`, the composition transform, and the\n", + " interpretability `cell_type_column`. You can override all of them, but\n", + " renaming once here is simpler.\n", + "\n", + "We also densify `X`: the h5ad loader reads the matrix directly.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10185d26023b46108eb7d9f57d49d2b3", + "metadata": {}, + "outputs": [], + "source": [ + "rows = []\n", + "for lib in sorted(adata.obs[\"library_id\"].unique()):\n", + " sub = adata[adata.obs[\"library_id\"] == lib].copy()\n", + " sub.X = np.asarray(sub.X.todense(), dtype=np.float32)\n", + " sub.obs[\"cell_type\"] = sub.obs[\"Cluster\"].astype(str)\n", + " sub.obs = sub.obs[[\"cell_type\", \"cell_size\", \"donor\"]]\n", + " path = RAW / f\"{lib}.h5ad\"\n", + " sub.write_h5ad(path)\n", + " rows.append(\n", + " {\n", + " \"sample_id\": lib,\n", + " \"input_path\": path.name, # resolved relative to the manifest\n", + " \"input_type\": \"h5ad\",\n", + " \"region_id\": lib,\n", + " \"donor\": str(sub.obs[\"donor\"].iloc[0]),\n", + " }\n", + " )\n", + "\n", + "manifest = pd.DataFrame(rows)\n", + "manifest[[\"sample_id\", \"input_path\", \"input_type\", \"region_id\"]].to_csv(\n", + " RAW / \"manifest.csv\", index=False\n", + ")\n", + "\n", + "# A bag-level label. See the caveat in vignette 2 before reading anything\n", + "# into supervised numbers on a three-image dataset.\n", + "manifest[\"donor_label\"] = (manifest[\"donor\"] == \"21d7\").astype(int)\n", + "manifest[[\"region_id\", \"donor_label\"]].to_csv(RAW / \"labels.csv\", index=False)\n", + "\n", + "manifest" + ] + }, + { + "cell_type": "markdown", + "id": "8763a12b2bbd4a93a75aff182afb95dc", + "metadata": {}, + "source": [ + "## Build the graphs\n", + "\n", + "`prepare_data()` runs once and writes `.pt` graph files plus an index. The\n", + "settings worth understanding:\n", + "\n", + "- **`coord_scale_um`** converts stored coordinates to micrometres. MIBI-TOF\n", + " FOVs here are ~400 um across ~1024 px, so ~0.39 um/px. Getting this wrong\n", + " silently rescales every distance downstream -- graph edges, ego-graph radii,\n", + " and the filtration thresholds in the interpretability report.\n", + "- **`sample_unit=tile`** cuts each image into square patches. A patch is one\n", + " graph unit, and later one MIL bag.\n", + "- **`tiling.tile_size_um=100`** gives ~16 patches per image at this scale.\n", + "- **`min_cells`** drops patches too sparse to form a useful graph.\n", + "\n", + "Run it through the CLI so the exact command is reusable outside a notebook.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7623eae2785240b9bd12b16a66d81610", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess\n", + "import os\n", + "import sys\n", + "\n", + "cmd = [\n", + " sys.executable,\n", + " \"-m\",\n", + " \"grass_mil.train\",\n", + " \"task=finetune_mean\",\n", + " \"model=supervised_module\",\n", + " \"data=spatial_omics\",\n", + " \"trainer=cpu\",\n", + " f\"data.raw_manifest_path={RAW}/manifest.csv\",\n", + " f\"data.processed_dir={PROCESSED}\",\n", + " \"data.h5ad.coord_source=obsm\",\n", + " \"data.h5ad.coord_key=spatial\",\n", + " \"data.h5ad.categorical_label_columns=[cell_type]\",\n", + " \"data.coord_scale_um=0.39\",\n", + " \"data.sample_unit=tile\",\n", + " \"data.tiling.tile_size_um=100\",\n", + " \"data.tiling.stride_um=100\",\n", + " \"data.min_cells=20\",\n", + " \"data.tiling.min_cells=20\",\n", + " f\"data.graph_labels.label_file={RAW}/labels.csv\",\n", + " \"data.graph_labels.id_column=region_id\",\n", + " \"data.graph_labels.tasks=[donor_label]\",\n", + " \"data.graph_labels.scope=region\",\n", + " \"data.split.train_val_test_split=[0.34,0.33,0.33]\",\n", + " \"data.split.split_by=sample\",\n", + " \"data.force_precompute=true\",\n", + " f\"paths.log_dir={WORK}/logs\",\n", + " \"+trainer.fast_dev_run=true\", # precompute only; no real training here\n", + "]\n", + "env = dict(os.environ, PROJECT_ROOT=str(WORK))\n", + "out = subprocess.run(cmd, capture_output=True, text=True, env=env)\n", + "print(\"exit code:\", out.returncode)\n", + "if out.returncode:\n", + " print(out.stdout[-3000:], out.stderr[-3000:])" + ] + }, + { + "cell_type": "markdown", + "id": "7cdc8c89c7104fffa095e18ddfef8986", + "metadata": {}, + "source": [ + "## Inspect what was built\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b118ea5561624da68c537baed56e602f", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import collections\n", + "\n", + "index = json.loads((PROCESSED / \"processed_index.json\").read_text())\n", + "entries = index[\"entries\"] if \"entries\" in index else index\n", + "meta = json.loads((PROCESSED / \"metadata.json\").read_text())\n", + "\n", + "print(\"graph units (patches):\", len(entries))\n", + "print(\"per sample :\", dict(collections.Counter(e[\"sample_id\"] for e in entries)))\n", + "print(\"per split :\", dict(collections.Counter(e[\"split\"] for e in entries)))\n", + "print()\n", + "print(\"cell types :\", meta[\"label_maps\"][\"cell_type\"])\n", + "print(\n", + " \"markers :\",\n", + " len(meta[\"molecular_feature_names\"]),\n", + " meta[\"molecular_feature_names\"][:6],\n", + " \"...\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "938c804e27f84196a10c8828c723f798", + "metadata": {}, + "source": [ + "Note the split: whole images go to train/val/test. Splitting by `sample`\n", + "rather than by `patch` is deliberate -- patches from one image share a donor\n", + "and a batch, so a patch-level split would leak that identity across folds.\n" + ] + }, + { + "cell_type": "markdown", + "id": "504fb2a444614c0babb325280ed9130a", + "metadata": {}, + "source": [ + "## Look at one graph unit\n", + "\n", + "Each unit is a `torch_geometric.data.Data`: node features `x` (markers),\n", + "`edge_index` (Delaunay adjacency), `pos` (micrometre coordinates), and\n", + "`categorical_codes` (the cell-type index the encoder embeds).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59bbdb311c014d738909a11f9e486628", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "sample_entry = entries[0]\n", + "g = torch.load(sample_entry[\"path\"], weights_only=False)\n", + "print(g)\n", + "print()\n", + "print(\"nodes:\", g.num_nodes, \"| edges:\", g.edge_index.shape[1])\n", + "print(\"x :\", tuple(g.x.shape))\n", + "print(\"pos : extent\", g.pos.min(0).values.tolist(), \"to\", g.pos.max(0).values.tolist(), \"um\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b43b363d81ae4b689946ece5c682cd59", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "inv = {v: k for k, v in meta[\"label_maps\"][\"cell_type\"].items()}\n", + "codes = g.categorical_codes[:, 0].numpy()\n", + "pos = g.pos.numpy()\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "src, dst = g.edge_index.numpy()\n", + "for s, d in zip(src[::3], dst[::3]): # subsample edges for clarity\n", + " ax.plot(pos[[s, d], 0], pos[[s, d], 1], lw=0.3, color=\"0.8\", zorder=1)\n", + "for c in np.unique(codes):\n", + " m = codes == c\n", + " ax.scatter(pos[m, 0], pos[m, 1], s=18, label=inv[int(c)], zorder=2)\n", + "ax.set_xlabel(\"x (um)\")\n", + "ax.set_ylabel(\"y (um)\")\n", + "ax.set_title(f\"patch {sample_entry['patch_id']} - cellular graph\")\n", + "ax.legend(fontsize=7, markerscale=0.8, loc=\"upper right\")\n", + "ax.set_aspect(\"equal\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "8a65eabff63a45729fe45fb5ade58bdc", + "metadata": {}, + "source": [ + "## Next\n", + "\n", + "Vignette 2 pretrains an encoder on these graphs without labels, then uses the\n", + "learned embeddings to discover spatial niches.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/vignettes/02_pretraining_and_niches.ipynb b/vignettes/02_pretraining_and_niches.ipynb new file mode 100644 index 0000000..4cdbe51 --- /dev/null +++ b/vignettes/02_pretraining_and_niches.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fb27b941602401d91542211134fc71a", + "metadata": {}, + "source": [ + "# 2 - Self-supervised pretraining and niche discovery\n", + "\n", + "Vignette 1 turned three MIBI-TOF images into 44 patch graphs. Here we:\n", + "\n", + "1. pretrain a graph encoder with **BGRL**, which needs no labels,\n", + "2. attach a supervised head and export per-instance embeddings,\n", + "3. run the interpretability report to discover **spatial niches**.\n", + "\n", + "---\n", + "\n", + "### Read this before interpreting any number below\n", + "\n", + "This dataset has **three images from two donors**. That is enough to\n", + "demonstrate the mechanics and enough for unsupervised niche discovery, but it\n", + "is *not* enough for supervised evaluation:\n", + "\n", + "- Splitting by sample (the correct choice) puts one image in each of\n", + " train/val/test.\n", + "- The only genuine bag-level variable is donor identity, and after that split\n", + " the training image carries a single class.\n", + "\n", + "So the supervised step here is **plumbing, not a result**. It exists because\n", + "`grass-mil-predict` needs a supervised checkpoint to export instance tables.\n", + "Treat the classifier as a feature extractor. The niche analysis at the end is\n", + "the part that stands on its own, because it is unsupervised.\n" + ] + }, + { + "cell_type": "markdown", + "id": "acae54e37e7d407bbb7b55eff062a284", + "metadata": {}, + "source": [ + "## Setup\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a63283cbaf04dbcab1f6479b197f3a8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pathlib\n", + "import subprocess\n", + "import sys\n", + "import glob\n", + "\n", + "import pandas as pd\n", + "\n", + "WORK = pathlib.Path(\"vignette_work\").resolve()\n", + "RAW, PROCESSED = WORK / \"data\" / \"raw\", WORK / \"data\" / \"processed\"\n", + "assert PROCESSED.exists(), \"Run vignette 1 first.\"\n", + "env = dict(os.environ, PROJECT_ROOT=str(WORK))\n", + "\n", + "DATA_ARGS = [\n", + " \"data=spatial_omics\",\n", + " f\"data.raw_manifest_path={RAW}/manifest.csv\",\n", + " f\"data.processed_dir={PROCESSED}\",\n", + " \"data.h5ad.coord_source=obsm\",\n", + " \"data.h5ad.coord_key=spatial\",\n", + " \"data.h5ad.categorical_label_columns=[cell_type]\",\n", + " \"data.coord_scale_um=0.39\",\n", + " \"data.sample_unit=tile\",\n", + " \"data.tiling.tile_size_um=100\",\n", + " \"data.tiling.stride_um=100\",\n", + " \"data.min_cells=20\",\n", + " \"data.tiling.min_cells=20\",\n", + " \"data.split.train_val_test_split=[0.34,0.33,0.33]\",\n", + " \"data.split.split_by=sample\",\n", + "]\n", + "\n", + "\n", + "def run(args, tag):\n", + " out = subprocess.run([sys.executable, \"-m\"] + args, capture_output=True, text=True, env=env)\n", + " print(f\"{tag}: exit {out.returncode}\")\n", + " if out.returncode:\n", + " print(out.stdout[-2500:], out.stderr[-2500:])\n", + " raise RuntimeError(f\"{tag} failed - see output above\")\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "id": "8dd0d8092fe74a7c96281538738b07e2", + "metadata": {}, + "source": [ + "## 1. BGRL pretraining (no labels)\n", + "\n", + "BGRL learns node representations by matching two augmented views of the same\n", + "graph. Nothing here uses `donor_label`.\n", + "\n", + "The augmentation preset matters. `bgrl_paper` adds Gaussian noise to a named\n", + "continuous feature (cell size) and requires the reserved 'unassigned'\n", + "cell-type slot. This cohort keeps `cell_size` in `obs`, not in the marker\n", + "matrix, so we use `uniform`, which drops edges and features independently of\n", + "structure and has no feature-name dependency.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72eea5119410473aa328ad9291626812", + "metadata": {}, + "outputs": [], + "source": [ + "run(\n", + " [\n", + " \"grass_mil.train\",\n", + " \"task=pretrain_bgrl\",\n", + " \"model=bgrl_module\",\n", + " \"trainer=cpu\",\n", + " \"+augmentation@task.augmentation=uniform\",\n", + " *DATA_ARGS,\n", + " f\"paths.log_dir={WORK}/logs\",\n", + " \"trainer.max_epochs=10\",\n", + " ],\n", + " \"BGRL pretraining\",\n", + ")\n", + "\n", + "bgrl_ckpt = sorted(\n", + " glob.glob(f\"{WORK}/logs/train/runs/*/checkpoints/*.ckpt\"), key=os.path.getmtime\n", + ")[-1]\n", + "print(\"pretrained encoder:\", bgrl_ckpt)" + ] + }, + { + "cell_type": "markdown", + "id": "8edb47106e1a46a883d545849b8ab81b", + "metadata": {}, + "source": [ + "## 2. Attach a supervised head\n", + "\n", + "`model.init_from_ckpt` loads the pretrained encoder weights into a supervised\n", + "module; `encoder_init_map=auto_bgrl_or_identity` handles the BGRL key names.\n", + "\n", + "As flagged above, this run is not a result -- it exists to produce a\n", + "checkpoint `grass-mil-predict` can consume.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10185d26023b46108eb7d9f57d49d2b3", + "metadata": {}, + "outputs": [], + "source": [ + "run(\n", + " [\n", + " \"grass_mil.train\",\n", + " \"task=finetune_mean\",\n", + " \"model=supervised_module\",\n", + " \"trainer=cpu\",\n", + " f\"model.init_from_ckpt={bgrl_ckpt}\",\n", + " \"model.encoder_init_map=auto_bgrl_or_identity\",\n", + " *DATA_ARGS,\n", + " f\"data.graph_labels.label_file={RAW}/labels.csv\",\n", + " \"data.graph_labels.id_column=region_id\",\n", + " \"data.graph_labels.tasks=[donor_label]\",\n", + " \"data.graph_labels.scope=region\",\n", + " f\"paths.log_dir={WORK}/logs\",\n", + " \"trainer.max_epochs=1\",\n", + " ],\n", + " \"supervised head\",\n", + ")\n", + "\n", + "ft_ckpt = sorted(glob.glob(f\"{WORK}/logs/train/runs/*/checkpoints/*.ckpt\"), key=os.path.getmtime)[\n", + " -1\n", + "]\n", + "print(\"checkpoint:\", ft_ckpt)" + ] + }, + { + "cell_type": "markdown", + "id": "8763a12b2bbd4a93a75aff182afb95dc", + "metadata": {}, + "source": [ + "## 3. Export per-instance embeddings\n", + "\n", + "`grass-mil-predict` runs inference on the held-out split and writes the tables\n", + "the interpretability suite consumes. Enabling the ShaDow sampler means each\n", + "*instance* is an ego-graph around one cell, so the exported table describes\n", + "local neighbourhoods rather than whole patches.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7623eae2785240b9bd12b16a66d81610", + "metadata": {}, + "outputs": [], + "source": [ + "run(\n", + " [\n", + " \"grass_mil.inference.predict\",\n", + " f\"ckpt_path={ft_ckpt}\",\n", + " \"task=finetune_mean\",\n", + " \"model=supervised_module\",\n", + " \"trainer=cpu\",\n", + " *DATA_ARGS,\n", + " \"data.sampler.name=shadow_custom\",\n", + " \"data.sampler.runtime.enabled=true\",\n", + " \"data.sampler.runtime.depth=2\",\n", + " \"data.sampler.runtime.num_neighbors=8\",\n", + " f\"data.graph_labels.label_file={RAW}/labels.csv\",\n", + " \"data.graph_labels.id_column=region_id\",\n", + " \"data.graph_labels.tasks=[donor_label]\",\n", + " \"data.graph_labels.scope=region\",\n", + " \"interpretability.enabled=true\",\n", + " \"embeddings.enabled=true\",\n", + " f\"paths.log_dir={WORK}/logs\",\n", + " ],\n", + " \"predict\",\n", + ")\n", + "\n", + "instance_table = sorted(\n", + " glob.glob(f\"{WORK}/logs/predict/runs/*/predictions/instance_table.csv\"), key=os.path.getmtime\n", + ")[-1]\n", + "inst = pd.read_csv(instance_table)\n", + "print(instance_table)\n", + "print(\"instances:\", len(inst))\n", + "print(\"embedding dims:\", sum(c.startswith(\"inst_emb_\") for c in inst.columns))\n", + "print(\"composition :\", [c for c in inst.columns if c.startswith(\"comp_\")])" + ] + }, + { + "cell_type": "markdown", + "id": "7cdc8c89c7104fffa095e18ddfef8986", + "metadata": {}, + "source": [ + "> **Known limitation.** `interpretability.spatial.enabled=true` would also\n", + "> export a `spatial_table` of edges, which the Moran's I and Ripley plugins\n", + "> need. It currently fails when the ShaDow sampler is active: the sampler\n", + "> builds batches without `Batch.from_data_list()`, so `to_data_list()` raises\n", + "> and the per-instance subgraphs are never collected. The niche analysis below\n", + "> does not depend on it.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b118ea5561624da68c537baed56e602f", + "metadata": {}, + "source": [ + "## 4. Discover niches\n", + "\n", + "The report reduces the embedding space, clusters it into niches, orders them\n", + "by composition, and renders an HTML document. Niches are named in dendrogram\n", + "order; unassigned instances are labelled `Background`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "938c804e27f84196a10c8828c723f798", + "metadata": {}, + "outputs": [], + "source": [ + "run(\n", + " [\n", + " \"grass_mil.interpretability.report_cli\",\n", + " f\"data.instance_table={instance_table}\",\n", + " f\"paths.log_dir={WORK}/logs\",\n", + " # report.yaml gets its own hydra run dir; pin it so outputs land\n", + " # in the work directory instead of ./outputs//